本页面上的部分或全部信息可能不适用于 Cloud de Confiance by S3NS。如需了解详情，请参阅与 Google Cloud 的区别。

Google 会使用 AI 技术将内容翻译成您偏好的语言。AI 翻译可能包含错误。

Gemini 4 Argon 开发者指南

Gemini 4 Argon 是 Google 的前沿模型，擅长处理复杂、真实的跨领域任务，包括编码、金融、法律、网络安全和科学。它是 Gemini 4 系列中的首个模型。

本文档介绍了 4 Argon 的新功能、它强制执行的 API 惯例、如何迁移到该模型以及快速入门。如需大致了解 Gemini 4 系列，请参阅 Gemini 4 使用入门。

Gemini 4 Argon 的新功能

统一的输入和输出 token 限制：4 Argon 的统一 token 限制为 1,048,576 个，包括输入和输出 token（其中输出包括思考、函数调用和最终回答）。
长解码最多 1,048,576 个 token：将生成扩展到超出单次请求的输出限制（65,536 个 token，或非流式传输直接 HTTP 请求的 32,768 个 token），在 GenerateContent 上最多可生成 1,048,576 个 token（减去输入 token）。Google Gen AI SDK 会自动跨请求处理 continuation_token，您也可以在自己的续传循环中管理 continuation_token。
思考等级：LOW、MEDIUM（上的默认值gemini-4-argon）和 HIGH（上的默认值gemini-4-argon-cyber-permissive）。
具有持久缓存的隐式缓存：隐式缓存会自动应用于 6,144 个或更多 token 的共享提示前缀，并且默认启用持久缓存。不支持显式上下文缓存。
智能体视频理解：正式版，默认处于关闭状态。

快速入门

在开始之前，您必须使用应用默认凭据 (ADC) 或 API 密钥向 Agent Platform 进行身份验证。如需了解详情，请参阅 Gemini Enterprise Agent Platform 使用入门。

在以下代码块中，将 PROJECT_ID 替换为您的项目 ID。

在 Agent Studio 中试用

如需在 Agent Studio 界面中测试提示并配置 gemini-4-argon，请执行以下操作：

在您的 Cloud de Confiance by S3NS 项目中打开 Agent Studio ，然后在 Gemini 组下选择 gemini-4-argon 。
在模型设置中，配置以下内容：
- 思考等级：选择 Low、Medium（默认）或 High。
- 区域：选择 Global、us 或 eu。
- 输出 token 限制：设置为介于 32,768 和 1,048,576 之间（1,048,576 默认）。对于超出单次请求限制的回答，Agent Studio 会自动处理续传 token。

安装

升级到最新的 Google Gen AI SDK（google-genai >= 2.30.1 对于 Python， @google/genai >= 2.29.1 对于 JavaScript，>= 1.74.0 对于 Go，>= 1.77.0 对于 Java，>= 1.26.0 对于 .NET，或 >= 1.6.0 对于 Kotlin）：

pip install --upgrade "google-genai>=2.30.1"

基本请求

Python (GenerateContent)

from google import genai
from google.genai import types

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Design a lock-free ring buffer in Rust for multi-producer, single-consumer telemetry ingestion.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level="MEDIUM",  # Default: "MEDIUM" (Valid: "LOW", "MEDIUM", "HIGH")
        ),
    ),
)
print(response.text)

Python (Interactions API)

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

# Turn 1: Initial request (stored server-side by default)
turn1 = client.interactions.create(
    model="gemini-4-argon",
    input="Design a lock-free ring buffer in Rust for multi-producer, single-consumer telemetry ingestion.",
    store=True,
)
print(turn1.output_text)

# Turn 2: Continue the conversation using previous_interaction_id
turn2 = client.interactions.create(
    model="gemini-4-argon",
    input="Add a bounded backpressure policy and unit tests for concurrent writers.",
    previous_interaction_id=turn1.id,
)
print(turn2.output_text)

REST

curl -X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
"https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
-d '{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Provide an architectural review of this Go interface."
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
      "thinkingLevel": "MEDIUM"
    }
  }
}'

结构化输出

from pydantic import BaseModel, Field
from google import genai
from google.genai import types

class ArchitectureReview(BaseModel):
    component: str = Field(description="Service or module name")
    bottlenecks: list[str] = Field(description="Throughput or latency bottlenecks")
    recommended_changes: list[str] = Field(description="Concrete refactoring steps")

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Review a synchronous order-processing pipeline backed by a single primary database at 15,000 writes/sec.",
    config=types.GenerateContentConfig(
        response_mime_type="application/json",
        response_schema=ArchitectureReview,
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
    ),
)
print(response.text)

长解码

默认情况下，单个 API 请求最多生成 65,536 个输出 token（或非流式传输直接 HTTP 请求的 32,768 个 token），其中输出包括思考、函数调用和最终回答。如需在 GenerateContent (v1beta1) 上生成最多 1,048,576 个 token 的补全，请将 max_output_tokens 设置为大于 65,536（对于流式传输请求）或大于 32,768（对于非流式传输请求）（最多 1,048,576）。当 finish_reason 为 CONTINUATION 时，Google Gen AI SDK 会自动跨请求跟踪 continuation_token（在 GenerateContentConfig 中设置 automatic_continuation=False 以停用自动续传），您也可以在自定义循环中传递 continuation_token。

Python（SDK - 推荐）

from google import genai
from google.genai import types

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

# Automatic continuation is enabled by default in google-genai >= 2.30.1.
# Chunks across all continuation requests are yielded as a single stream.
for chunk in client.models.generate_content_stream(
    model="gemini-4-argon",
    contents="Write a complete formal proof of the prime number theorem.",
    config=types.GenerateContentConfig(
        max_output_tokens=256000,
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
    ),
):
    print(chunk.text, end="")

# Set automatic_continuation=False to disable automatic continuation.
for chunk in client.models.generate_content_stream(
    model="gemini-4-argon",
    contents="Write a complete formal proof of the prime number theorem.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
        automatic_continuation=False,
    ),
):
    print(chunk.text, end="")

REST（自定义续传循环）

# Request 1: Initial request with maxOutputTokens > 32,768
curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Write a complete formal proof of the prime number theorem."}]
    }],
    "generationConfig": {
      "maxOutputTokens": 131072,
      "thinkingConfig": {"thinkingLevel": "HIGH"}
    }
  }'

# Request 2: Resend the original request with top-level continuationToken
# from Request 1 (candidates[0].continuationToken)
curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Write a complete formal proof of the prime number theorem."}]
    }],
    "continuationToken": "CONTINUATION_TOKEN_FROM_REQUEST_1",
    "generationConfig": {
      "maxOutputTokens": 131072,
      "thinkingConfig": {"thinkingLevel": "HIGH"}
    }
  }'

强制性 API 规则和行为惯例

Gemini 4 Argon 强制执行以下惯例：

思考等级：4 Argon 支持三个 thinking_level 值（thinking_budget 和 MINIMAL 会返回 HTTP 400 验证错误）：

思考等级	推荐的工作负载
`HIGH`（`gemini-4-argon-cyber-permissive` 上的默认值）	多文件软件工程、形式证明、架构设计和漏洞发现。
`MEDIUM`（`gemini-4-argon` 上的默认值）	一般编码、工具使用、文档问答和视频理解。
`LOW`	分类、摘要和元数据提取。

统一的输入和输出 token 限制以及单次请求的输出限制：
- 1,048,576 是模型的总体 token 限制，包括输入和输出 token（其中输出包括思考、函数调用和最终回答）。max_output_tokens 控制生成的输出 token 上限（最多为 1,048,576 减去输入 token）；将 max_output_tokens 设置为大于 1,048,576 会返回 HTTP 400 错误。
- 为避免意外的长补全，默认的单次请求输出限制（思考 + 模型回答）为 65,536 个 token（或非流式传输直接 HTTP 请求的 32,768 个 token）。

长解码：

长解码的工作原理：长解码会将最多 1,048,576 个 token 的生成拆分为多个 GenerateContent 推断。例如，如果某项任务需要 256,000 个输出 token（包括思考、函数调用和最终回答），则第一个流式传输请求最多生成 65,536 个输出 token，并发出 finish_reason=CONTINUATION 以及包含原始提示的哈希和生成状态（截至该点）的加密 continuation_token。在后续请求中包含 continuation_token 和原始提示，会从中断处继续生成，直到不再发出 continuation_token 且 finish_reason=STOP。（在 Agent Studio 中，将输出 token 限制设置为大于 65,536 且最多为 1,048,576 会自动处理续传 token。）
何时使用长解码：大多数请求都在每个请求的限制范围内完成（65,536 个 token，或非流式传输 REST 调用的 32,768 个 token）。仅当一个回答需要更多输出时，才使用长解码。长解码为模型提供了更多推理空间；它不会使回答更长（使用 thinking_level 控制推理深度）。

工作负载	使用长解码？	原因
硬数学、科学、研究和形式证明	是	模型可以花费超过 65,536 个 token 来探索和检查其推理。
最难的编码和智能体任务	是	某些任务在一个回答中需要超过 65,536 个 token 的思考和代码。大多数编码和智能体任务都在 65,536 个 token 内完成。
在输出限制处停止的评估工具	是	当模型花费整个 65,536 个或 32,768 个 token 的请求进行思考时，长解码可防止回答被截断。
Chat、问答、摘要、分类和提取	否	这些任务在 32,768 个 token 内完成。
请求固定长度，例如“写一本 70 万字的书”	否	模型不遵循长度目标。
以许多短轮次调用工具的智能体	否	每个轮次都很短。每个轮次的大量输出会快速填满统一的 1,048,576 个 token 输入和输出限制。
提示接近 1,048,576 个 token 的输入限制	否	输出只能使用 1,048,576 个 token 减去输入。
对延迟时间敏感的请求	否	长解码可以运行几分钟。

选择续传选项：选择以下两个选项之一。大多数开发者使用选项 1。所有选项在 gemini-4-argon 和 gemini-4-argon-cyber-permissive 上都达到相同的 1,048,576 个 token 限制。

维度	选项 1：Google Gen AI SDK（推荐）	选项 2：您自己的流式传输循环 (`streamGenerateContent`)	选项 2：您自己的非流式传输循环 (`generateContent`)
谁开始每个片段	Google Gen AI SDK：Python (`google-genai`) 2.30.1、JavaScript (`@google/genai`) 2.29.1、Go 1.74.0、Java 1.77.0、.NET 1.26.0 和 Kotlin 1.6.0。您设置 `max_output_tokens`。	您的代码，在每个检查点或流式传输中断后	您的代码，每 32,768 个 token
每个请求的 token 数	每个片段最多 65,536 个	每个流 65,536 个，在 32,768 个之后每 5,000 个 token 设一个检查点	每个请求 32,768 个
每个请求的时限	20 分钟	20 分钟	20 分钟
存储	无服务器存储空间（符合 ZDR）	无服务器存储空间（符合 ZDR）	无服务器存储空间（符合 ZDR）
适用场景	大多数应用	流式传输的 REST 调用方和自定义工具	简单评估工具

实现规则和限制：
- v1beta1 API 要求（已知问题）：上的长解码 (continuation_token) 仅在 v1beta1 API（而非 v1）中受支持。Google Gen AI SDK 默认使用 v1beta1，除非在 http_options 中指定 api_version='v1'；对于直接 REST 调用，请使用 v1beta1 端点路径。GenerateContentgenerateContentstreamGenerateContentInteractions API 不支持长解码。
- SDK 版本和 OpenAI 兼容性：升级到最新的 Google Gen AI SDK（对于 Python，为google-genai >= 2.30.1；对于 JavaScript，为@google/genai >= 2.29.1；对于 Go，为>= 1.74.0；对于 Java，为>= 1.77.0；对于 .NET，为>= 1.26.0；对于 Kotlin，为>= 1.6.0）。旧版 SDK 和 OpenAI 兼容性层无法使用续传 token 检索长补全。对于自定义客户端实现，请参阅 Python 和 JavaScript/TypeScript 中的 Google Gen AI SDK 参考实现。
- 使用 continuation_token 重新发送原始请求：在自定义循环中，将 max_output_tokens 设置为大于 65,536（流式传输）或 32,768（一元）且最多为 1,048,576，并在每个续传请求中重新发送原始 contents、system_instruction 和 tools 以及最新的 continuation_token（REST 中 GenerateContentRequest 上的顶级字段，或 Google Gen AI SDK 中 GenerateContentConfig 中的顶级字段）。请勿将部分模型输出附加到 contents 中，也不要发送后续提示要求模型继续。
- 通过仅思考请求继续：当 finish_reason为CONTINUATION且存在continuation_token时，即使请求花费了所有 32,768 个或 65,536 个 token 进行思考 (parts: [{"text": ""}])，也要循环。如果存在continuation_token时finish_reason为MAX_TOKENS，则生成已达到请求的max_output_tokens上限，请在请求中提高max_output_tokens。仅在 STOP 之后，才将累积的部分合并为单个 model 轮次，以用于多轮对话记录。
- token 计数、压缩和 95% 的隐式缓存折扣:
  - 在 Python Google Gen AI SDK (generate_content 和 generate_content_stream) 中，最终回答或块的 usage_metadata 会累积跨续传请求的总计费 token。由于每个续传请求都会将之前的部分补全重新填充为输入 token，因此 prompt_token_count 会在续传请求中累积增加，请勿使用 prompt_token_count 在智能体 Harness 中触发上下文压缩。请改为读取 initial_prompt_token_count（在GenerateContentResponse或 usage_metadata上），并等待GenerateContent完成（不存在continuation_token）后再进行压缩。
  - 在自定义 REST 循环中，usage_metadata 在每个请求中是累积的；对跨请求的最终 prompt_token_count、cached_content_token_count、candidates_token_count 和 thoughts_token_count 求和。
  - 每个续传请求都会重新填充提示以及之前解码的 token，并且当请求在 15-20 分钟的缓存 TTL 内连续运行时，会自动获得 95% 的隐式上下文缓存折扣（最低 6,144 个 token）。
  - streamGenerateContent 和 generateContent 会在每个请求结束时（65,536 个流式传输/32,768 个一元）返回 usage_metadata，并且会在请求结束时进行结算。

被忽略的抽样参数（temperature、top_k、top_p） ：后端会忽略自定义值。使用 thinking_level 控制推理深度，使用 response_schema 控制输出格式。
不受支持的参数（frequency_penalty、presence_penalty、candidate_count） ：这些参数会返回 HTTP 400 错误。请从您的请求中移除这些参数。
上下文缓存：不支持显式上下文缓存。隐式缓存（默认启用持久缓存）会自动应用于 6,144 个或更多 token 的共享提示前缀，因此请将静态内容放在提示的开头。
智能体视频：上传的视频默认设置为media_processing="static" 设置 media_processing="agentic" 以启用智能体视频处理。
token 计数和结算：模型处理的每个 token 都会被计数和结算，包括思考 token 以及使用接地时的内部工具系统说明和函数声明。依托 Google 搜索进行接地仍按查询收费。

函数调用：

轮次对称性：每个 FunctionResponse 都必须与前面的 FunctionCall 的 id、name、和顺序匹配。
顺序执行：在多步工具循环中，首选顺序工具执行轮次。

工具前格式设置：使用 \n\n 分隔内嵌说明，并避免在工具调用之前使用非结构化文本。如需在工具调用之前记录中间状态，请使用专用函数声明：

{
  "name": "update",
  "description": "Update working notes before tool execution",
  "parameters": {
    "type": "OBJECT",
    "properties": {
      "previous_step": {"type": "STRING"},
      "plan": {"type": "STRING"},
      "next_step": {"type": "STRING"}
    },
    "required": ["previous_step", "plan", "next_step"]
  }
}

聊天序列验证：
- 历史记录载荷不能以 model 角色轮次结束。
- 不支持预填模型轮次。

从 3.1 Pro 迁移到 4 Argon

以下行为与 gemini-3.1-pro-preview 不同：

4 Argon 在输入和输出方面具有统一的 1,048,576 个 token 限制（其中输出包括思考、函数调用和最终回答），而不是单独的输入和输出限制。单次请求的输出上限为 65,536 个 token（或非流式传输直接 HTTP 请求的 32,768 个 token），并且可以使用长解码在 GenerateContent 上扩展到最多 1,048,576 个 token（在 Google Gen AI SDK 中自动处理，或在自定义循环中使用 continuation_token）。
thinking_budget 会返回 HTTP 400 错误，而不是映射到思考等级。MINIMAL 也会返回错误。
不支持显式上下文缓存。
模型处理的每个 token 都会被结算，包括使用接地时的内部工具系统说明和函数声明。

如需进行对照比较，请参阅从 Gemini 3.1 Pro 迁移。

 client = genai.Client(
     enterprise=True,
     project="PROJECT_ID",
     location="global", # Supports "global", "us", and "eu"
 )

 response = client.models.generate_content(
-    model="gemini-3.1-pro-preview",
+    model="gemini-4-argon",
     contents=prompt,
     config=types.GenerateContentConfig(
-        temperature=0.0,
-        cached_content="projects/.../cachedContents/...", # Explicit caching unsupported
         thinking_config=types.ThinkingConfig(
-            thinking_budget=16384, # Returns HTTP 400 instead of mapping silently
-            thinking_level="MINIMAL", # MINIMAL unsupported on Gemini 4 Argon
+            thinking_level="MEDIUM", # Valid: "LOW", "MEDIUM" (default), "HIGH"
         ),
     ),
 )

如需从 gemini-3.1-pro-preview 迁移，请执行以下操作：

将模型 ID 更新为 gemini-4-argon（或 gemini-4-argon-cyber-permissive，适用于 Fairwind 批准的网络安全工作负载）。
升级到最新的 Google Gen AI SDK 并考虑统一的输入和输出 token 限制：升级到 google-genai >= 2.30.1 (Python)、 @google/genai >= 2.29.1 (JavaScript) 或等效的最新 Google Gen AI SDK。输入和输出 token（包括思考和函数调用）共享统一的 1,048,576 个 token 限制。对于 GenerateContent 上超过 65,536 个 token（最多 1,048,576 个 token）的输出，请将 max_output_tokens 设置为大于 65,536，以便 Google Gen AI SDK 自动跨请求继续（或在您自己的 REST 循环中处理 continuation_token）。
替换推理预算参数：将 thinking_budget 和 MINIMAL 替换为 thinking_level，并将其设置为 LOW、MEDIUM（ gemini-4-argon 上的默认值）或 HIGH（ gemini-4-argon-cyber-permissive 上的默认值）。
移除显式缓存 ，并预先加载静态提示内容（6,144 个或更多 token），以实现自动隐式缓存。
移除无效或不受支持的参数：
- 移除 temperature、top_p 和 top_k，这些参数会被忽略。
- 移除 candidate_count、frequency_penalty 和 presence_penalty。
- 从对话记录中移除所有预填模型轮次。

开发者摘要核对清单

目标模型 ID：gemini-4-argon（或 gemini-4-argon-cyber-permissive，适用于 Fairwind 批准的项目），并升级到最新的 Google Gen AI SDK （Python google-genai >= 2.30.1、JS @google/genai >= 2.29.1、Go >= 1.74.0、Java >= 1.77.0、.NET >= 1.26.0、Kotlin >= 1.6.0）

位置：global、us 或 eu

预算：统一的 1,048,576 个 token 输入和输出限制，以及 65,536 个 token 的单次请求输出上限（非流式传输直接 HTTP 调用的 32,768 个 token），或在 GenerateContent 上将 max_output_tokens 设置为最多 1,048,576，以进行长解码。

使用 thinking_level（MEDIUM 在 gemini-4-argon 上是默认值，HIGH 在 gemini-4-argon-cyber-permissive 上是默认值；有效值：LOW、MEDIUM、HIGH）。移除 thinking_budget 和 MINIMAL。

移除以下参数：frequency_penalty、presence_penalty、candidate_count、temperature、top_p 和 top_k。

从多轮对话请求记录中移除所有预填模型轮次。

移除显式缓存调用，并将静态提示内容（6,144 个或更多 token）放在最前面，以实现隐式缓存。

已知问题

GenerateContent 上的**长解码需要 v1beta1** ：GenerateContent API（generateContent 和 streamGenerateContent）上的长解码（continuation_token）仅在 v1beta1 API（而非 v1）中受支持。 Google Gen AI SDK 默认使用 v1beta1，除非在 http_options 中设置 api_version='v1' ；对于直接 REST 调用，请使用 v1beta1 端点路径。