Gemini 4 Neon API 怎么调用?模型 ID、思考等级和首次请求核验

在 Gemini API 付费项目中调用 gemini-4-neon:选择 high 或 xhigh 思考等级,读取思考 token 和缓存 token 用量,并排查与 Carbon 不同的报错。

木质底座上的四挡旋钮开关,第四挡用橙色标出,导线连着一支尚未点亮的玻璃管灯。

调用 Gemini 4 Neon,需要在付费层级的 Gemini API 项目中发送 model: "gemini-4-neon"。Neon 没有免费层级。它默认的思考等级是 high,也接受 low、medium 和 xhigh;输入、思考和输出共用一个 1,048,576 token 的上下文窗口。Google 的 Neon 指南建议新代码从 Interactions API 起步,generateContent 同样可用。 一次请求要满足三个条件才算成功:interaction 的状态是 completed(或 candidate 以 STOP 结束),有可见文本,并且用量记录显示了你将被计费的内容(包括思考 token)。

Google 于 2026 年 11 月 18 日将 gemini-4-neon 作为正式版(GA)发布。本文内容于 2026 年 11 月 19 日对照 Google 文档核验,重点放在 Neon 特有的部分。项目设置、API 密钥和计费方式与另一款付费的 Gemini 4 模型相同,已在 Gemini 4 Carbon API 接入教程中完整介绍,这里只做概括。

本文有两点限制:

  • Ofox 上没有 Neon。 我们在 2026 年 11 月 19 日检查了 Ofox 模型列表(GET https://api.ofox.ai/v1/models):列表里有 google/gemini-4-hydrogen 和 google/gemini-4-argon,没有 Neon;https://ofox.ai/models/google/gemini-4-neon 返回 404。下文所有示例都使用 Google 原生端点和 Google API 密钥。本博客由 Ofox 发布。
  • 我们没有实际调用 Neon。 撰写本文时没有可用的 Google 密钥。请求体对照了 Google 公开的接口规范(Neon 指南、Interactions 与 generateContent 参考文档,以及思考、缓存和长输出相关文档)。响应检查脚本在离线环境中用 15 份人工构造的响应做了测试。这能证明解析逻辑正确,但不能证明鉴权、延迟或回答质量。

Gemini 4 Neon API 关键参数一览

下表数值均来自 Google 的 What’s new in Gemini 4 Neon 指南、价格页和 Neon 模型卡(均为英文),核验日期 2026 年 11 月 19 日。

项目Neon 的值
模型 IDgemini-4-neon(没有 -preview 后缀)
访问方式仅限 Gemini API 付费层级;Google AI Pro 和 Ultra 套餐用户也可在 Google AI Studio 中使用
APIInteractions API(Google 快速入门所用)和 generateContent
思考等级low、medium、high(默认)、xhigh;minimal 会被拒绝
上下文1,048,576 token,输入、思考和输出共用
同步输出每个 hop(单段生成)默认值和上限均为 65,536 token,流式与非流式相同
更长的输出后台执行或客户端续写,上限为 1M 减去输入量
标准价格(美元/百万 token)输入 $3.00,缓存输入 $0.15,输出(含思考)$15.00
缓存只有隐式缓存,提示达到 4,096 token 起生效;不支持显式 cachedContents
采样参数temperature、top_p、top_k 在合法范围内会被忽略;超出范围返回 400
知识截止2026 年 3 月(模型卡)

Neon 没有首发优惠价,这一点与 Carbon 不同(Carbon 的优惠价 11 月 30 日结束)。按思考等级计算的单任务成本,见 Gemini 4 Neon 价格拆解。

与 Carbon、Hydrogen 请求相比有哪些变化

Google 表示,从其他 Gemini 4 模型切换到 Neon “无需修改请求结构”。字段不变,变的是字段的取值和相关限制。如果你已经按我们的 Carbon 或 Hydrogen 接入教程写好了可运行的代码,需要留意下面这些差异。

方面CarbonHydrogenNeon
模型 IDgemini-4-carbongemini-4-hydrogengemini-4-neon
免费层级无有无
默认思考等级mediumhighhigh
xhigh不支持支持支持
非流式单个 hop原始 REST 每个 hop 32,768 token65,53665,536
采样参数忽略范围内忽略,超出范围返回 400范围内忽略,超出范围返回 400
标准价格(输入/输出)11 月 30 日前 $2 / $10,之后 $4 / $20$1.50 / $7.50$3 / $15,固定

来源:Carbon、Hydrogen 和 Neon 各自的 “What’s new” 指南,以及 Choosing a model 页面(英文)。32,768 与 65,536 的 hop 对比出自 Google 的 Hydrogen 指南。

由此带来三个实际影响:

  1. 从 Carbon 迁移过来,每次调用的默认花费会上升。 Carbon 默认 medium,Neon 默认 high。从未设置 thinking_level 的代码,换到 Neon 后会在你什么都没改的情况下思考得更多。请显式设置思考等级,让这一行为在代码评审时一目了然。
  2. 从 Hydrogen 迁移过来,出问题的可能是密钥而不是请求。 Hydrogen 的集成可能跑在免费层级项目上,同一个密钥调不到 Neon。在排查请求体之前,先确认密钥属于哪个项目。
  3. 为 Neon 写的代码放到 Carbon 上可能出错。 xhigh 对 Neon 和 Hydrogen 有效,对 Carbon 和 Argon 无效。如果你在不同模型之间分配任务步骤,应把思考等级作为路由的一部分,而不是写成全局常量。Neon 与 Carbon 对比讲了两款模型各自在什么情况下值这个价。

第 1 步:确认密钥属于付费项目

调用 Neon 需要四个条件同时满足:Google 账号有权使用 Gemini API;Google AI Studio 中有对应项目;API 密钥属于这个项目;同一项目已开通付费层级计费。Google 的计费指南把从免费层级升到付费层级描述为给项目关联一个结算账号,Projects 页面会显示每个项目的计费层级。Google AI Pro 或 Ultra 套餐能让你在 AI Studio 里使用 Neon,但不要把它当作 API 密钥所属项目已在付费层级的证明。请在 Projects 页面核对项目的层级。

分步说明(导入 Cloud 项目、密钥类型与限制、预付与后付)见 Carbon 接入教程的第一节,同样适用于 Neon。Google 的原始资料是 API 密钥指南和计费指南(均为英文)。

把密钥放在环境变量里,检查是否已加载,但不要把它打印出来:

export GEMINI_API_KEY="..."   # 在 shell 或密钥管理器中设置,切勿提交到代码库
python3 -c 'import os; print("Key configured:", bool(os.environ.get("GEMINI_API_KEY")))'

输出 True 只说明变量有值。项目能否调到 Neon,要靠第一次请求来证明。

第 2 步:用 Interactions API 发送第一个请求

Google 的 Neon 快速入门使用 Interactions API,新代码从这里开始即可。安装当前的 SDK(包名 google-genai,导入方式为 from google import genai;不是旧的 google-generativeai 包):

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade google-genai

保存为 neon_first_call.py:

import json
import os
from pathlib import Path
from google import genai

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

interaction = client.interactions.create(
    model="gemini-4-neon",
    input="List exactly three checks for confirming a new API integration works.",
    store=False,
    generation_config={
        "thinking_level": "low",
        "max_output_tokens": 65536,
    },
)

Path("neon-response.json").write_text(
    json.dumps(interaction.model_dump(mode="json"), indent=2), encoding="utf-8"
)
print("Status:", interaction.status)
print("Usage:", interaction.usage)
print(interaction.output_text)

这个请求里有三处是特意这样设置的:

  • thinking_level: "low" 让访问检查保持低成本。不设置的话,Neon 会按 high 思考。先用 low 验证调用链路,再按实际工作负载设置所需等级(第 5 步)。
  • max_output_tokens: 65536 是 Neon 文档中的默认值,也是每个 hop 的上限。它是思考加可见输出的总上限,不代表最终账单。Google 建议不要沿用旧应用里 8,192 这类较低的上限;想少花钱,应该降低思考等级。
  • store=False 让这次一次性调用不被存储。如果要用 background=True 或 previous_interaction_id,请保留存储(默认开启),这两项都依赖已存储的 interaction。付费层级下,Google 会把已存储的 interaction 保留 55 天。

同一请求的 REST 写法如下,便于看清实际发送的内容:

curl --silent --show-error --max-time 900 \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-4-neon",
    "input": "List exactly three checks for confirming a new API integration works.",
    "store": false,
    "generation_config": {
      "thinking_level": "low",
      "max_output_tokens": 65536
    }
  }' \
  --output neon-response.json

在 Interactions API 中,generation_config 内的字段名在 Python、JavaScript 和 REST 里都是 snake_case。output_text 是 SDK 提供的便捷属性;原始 REST 响应中,文本位于类型为 model_output 的 steps 条目里,具体在类型为 text 的 content 条目中。

--max-time 设为 900 秒,是依照 Google 的迁移建议:难度高的提示至少预留 15 分钟。简单提示配合 low,返回会快得多。如果客户端超时,服务器可能仍然处理了这个请求(并已计费),所以在确认之前不要自动重试。

第 3 步:客户端已在用 generateContent 也可以

generateContent 仍然支持 Neon。如果你的应用已经在解析 candidates,可能只需要改模型名和思考配置。注意大小写不同:generateContent 的 REST 使用 camelCase。

curl --silent --show-error --max-time 900 \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-neon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "List exactly three checks for confirming a new API integration works."}]}],
    "generationConfig": {
      "thinkingConfig": {"thinkingLevel": "low"},
      "maxOutputTokens": 65536
    }
  }' \
  --output neon-response.json

Python SDK 写法:

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-4-neon",
    contents="List exactly three checks for confirming a new API integration works.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="low"),
        max_output_tokens=65536,
    ),
)
print(response.text)
print("Thinking tokens:", response.usage_metadata.thoughts_token_count)

两种写法中,等级的取值都是小写字符串("low"、"xhigh"),与 Google 的思考指南(英文)一致。不要混用两套 API:generation_config.thinking_level 属于 Interactions 请求体,generationConfig.thinkingConfig.thinkingLevel 属于 generateContent 请求体。在两套 API 之间复制代码后出现 400,先检查字段结构。另外,旧的 thinkingBudget(thinking_budget)要删掉:它在 Gemini 4 上已被弃用,与思考等级同时发送会返回 400。

每条代码路径只选一套 API。Interactions API 提供服务端状态(previous_interaction_id)和后台执行。用 generateContent 时,历史记录要自己管理,并且必须把之前的模型回合(包括其中的思考签名)原样发回。

第 4 步:先检查状态、文本和用量,再信任这次调用

HTTP 200 并不够。interaction 返回的状态可能不是 completed;generateContent 的 candidate 也可能把全部额度花在思考上,然后以 MAX_TOKENS 结束。这两种情况都可能完全没有可见文本。Google 的长输出指南(英文)给出了 Interactions 各状态的处理方式:

状态含义处理方式
queued、in_progress仍在运行(后台调用)用同一个 id 轮询 interactions.get
completed已完成拼接 model_output 文本,读取 usage
requires_action模型请求调用工具运行工具,并用这个 id 发送结果
requires_continuation前台 hop 达到 65,536 上限,但预算还有剩余SDK 默认会自动续写;用 REST 时,带上 previous_interaction_id 和 continuation_token 发送下一个 hop
incompletemax_output_tokens 已全部用完;文本可能为空续写,或调高 max_output_tokens 后重新发送
failed服务器未能完成重试一次;再失败就保留 id 以便联系支持
cancelled你取消了它读取 usage 查看已计费的部分

在 generateContent 上,对应的是 finishReason 的取值:STOP 表示成功,MAX_TOKENS 表示达到上限,CONTINUATION 表示还需要下一个 hop(最新的 SDK 会自动续写)。

下面的检查脚本可以读取两种 API 保存下来的响应。它不发起任何网络请求,也从不重试:

import json
import sys
from pathlib import Path

PENDING = {"queued", "in_progress"}


def check_interaction(p):
    status = p.get("status")
    if status in PENDING:
        raise ValueError(f"Still {status}: poll interactions.get with this id later")
    if status != "completed":
        raise ValueError(f"Interaction status is {status}, not completed (see the status table)")
    text = "".join(
        c.get("text", "")
        for s in p.get("steps", [])
        if s.get("type") == "model_output"
        for c in s.get("content", [])
        if c.get("type") == "text"
    )
    u = p.get("usage") or {}
    usage = {
        "input": u.get("total_input_tokens"),
        "cached_input": u.get("total_cached_tokens"),
        "output": u.get("total_output_tokens"),
        "thinking": u.get("total_thought_tokens"),
        "tool_use": u.get("total_tool_use_tokens"),
        "total": u.get("total_tokens"),
    }
    return text, usage


def check_generate_content(p):
    cands = p.get("candidates") or []
    if not cands:
        reason = (p.get("promptFeedback") or {}).get("blockReason")
        raise ValueError(f"No candidates (prompt block reason: {reason})")
    c = cands[0]
    reason = c.get("finishReason")
    if reason != "STOP":
        raise ValueError(f"finishReason is {reason}, not STOP")
    text = "".join(
        part.get("text", "")
        for part in (c.get("content") or {}).get("parts", [])
        if not part.get("thought")
    )
    u = p.get("usageMetadata") or {}
    usage = {
        "input": u.get("promptTokenCount"),
        "cached_input": u.get("cachedContentTokenCount", 0),
        "output": u.get("candidatesTokenCount"),
        "thinking": u.get("thoughtsTokenCount"),
        "tool_use": u.get("toolUsePromptTokenCount", 0),
        "total": u.get("totalTokenCount"),
    }
    return text, usage


def check(payload):
    if "error" in payload:
        raise ValueError("API error: " + json.dumps(payload["error"]))
    if "candidates" in payload or "promptFeedback" in payload:
        text, usage = check_generate_content(payload)
    elif "status" in payload or "steps" in payload:
        text, usage = check_interaction(payload)
    else:
        raise ValueError("Unrecognised response shape")
    if not text.strip():
        raise ValueError("Completed, but no visible text")
    return text, usage


if __name__ == "__main__":
    path = sys.argv[1] if len(sys.argv) > 1 else "neon-response.json"
    payload = json.loads(Path(path).read_text(encoding="utf-8"))
    try:
        text, usage = check(payload)
    except ValueError as exc:
        raise SystemExit(str(exc))
    print("Usage:", json.dumps(usage))
    print(text)

运行 python3 check_neon.py neon-response.json。通过时会打印一行统一格式的用量和可见回答。接着读一下回答本身:应该是三条相关的检查项,而不是拒答或说到一半被截断的句子。

我们测试了什么。 我们用与上方完全相同的检查脚本,跑了 15 份手写的测试样例:一个已完成的 interaction,文本分布在两个 model_output 步骤中,另有一个思考步骤;同一个 interaction 经过 google-genai SDK 的 Interaction 模型和 model_dump(mode="json") 往返处理后的版本(即第 2 步保存的形式);in_progress、incomplete、requires_action、requires_continuation、failed,以及已完成但文本为空的 interaction;一个 API 错误响应体;以 STOP 结束(含一个应被排除的思考部分)、MAX_TOKENS、CONTINUATION、MALFORMED_FUNCTION_CALL 结束的 generateContent 响应,以及一个被拦截的提示和一个只有思考内容的回答。三个格式正确的成功样例全部通过,其余十二个都以预期的消息退出。这些样例按文档中的字段名编写,不是真实采集的 Neon 输出。

Neon 需要关注哪些用量字段

Neon 的两个成本杠杆(思考和缓存命中)都体现在用量记录里。

含义Interactions usagegenerateContent usageMetadata
输入 tokentotal_input_tokenspromptTokenCount
缓存命中的输入total_cached_tokenscachedContentTokenCount
可见输出total_output_tokenscandidatesTokenCount
思考total_thought_tokensthoughtsTokenCount
工具调用提示 tokentotal_tool_use_tokenstoolUsePromptTokenCount
合计total_tokenstotalTokenCount

字段名出自 Google 的 Interactions 和 generateContent API 参考文档(均为英文)。Google 参考文档里的示例(来自更早的模型,不是 Neon)显示,思考与可见输出是分开报告的:一句话的回复,可见输出 23 个 token,思考 49 个 token。在 Neon 上,思考按 $15.00 的输出单价计费。Google 会计入模型处理的每一个 token,包括思考;使用 grounding 时,还包括内部系统指令和函数声明。所以在 high 或 xhigh 下,即使可见回答很短,输出费用也可能很高。每次调用都把 thinking 和 output 记在一起;账单看起来不对时,首先看的就是这两个数。

第 5 步:按任务选择思考等级

Google 指南对四个等级的描述大致如下(转述):

等级Google 的描述典型用途
lowtoken 最少,延迟最低快速对话、高吞吐处理、低成本的访问检查
mediumtoken 用量较低,响应较快交互式编程、UI 原型、对延迟敏感的工具调用
high(默认)智能与速度之间的平衡大多数复杂编程、Agent 执行、多模态知识工作
xhightoken 最多,推理最深困难的多步骤工程问题,以及 high 不够用的分析和科学问题

Google 推荐的做法是:把 max_output_tokens 设得足够高,避免回答被上限截断,然后用四个等级分别评估你的任务,最后选满足质量要求的最低等级。请求 xhigh 的写法:

interaction = client.interactions.create(
    model="gemini-4-neon",
    input="Audit this retry queue for race conditions and rewrite the lock logic.",
    generation_config={"thinking_level": "xhigh"},
)

Neon 特有的两点注意事项:

  • xhigh 与 65,536 上限会相互影响。 这个上限覆盖思考加输出。Google 的思考指南提醒,在文本或 JSON 提取这类简单提示上,xhigh 可能想得过多,把 max_output_tokens 用光。如果看到 MAX_TOKENS,或者 interaction 处于 incomplete 且可见文本很少,先看任务本身。任务简单就降低等级;任务确实困难,就保持等级,改用后台执行并设置更大的 max_output_tokens 给它更多空间(见下文后台执行一节)。不要为了省钱调小 max_output_tokens:Google 指出这样会截断回答,而已经完成的思考照样计费。
  • Google 的成本说法是在特定等级下测出来的。 Google 的 Neon 发布公告称,在默认的 high 等级下,Neon 取得了较高的 Artificial Analysis Intelligence Index 分数,同时单任务成本比 Carbon 低 32%;Neon 的最高智能分数出现在 xhigh。Google 把这个 32% 和 AA Intelligence Index 挂钩,但没有说明对比的是 Carbon 的哪个思考等级、哪个价格期间,也没有说明用的是哪个 AA 数据快照;用我们 2026 年 11 月 19 日读到的 AA 数据复算不出 32%,对比过程见 Neon 价格拆解。这些是 Google 公布的基准测试结果,不是对你的工作负载的预测。请用上面的用量字段测量你自己的任务。

previous_interaction_id 只携带对话历史,不携带 generation_config、tools 或 system_instruction。因此后续回合如果没有带 thinking_level,会回到 Neon 的默认值 high。每个回合都要重新发送等级。

用隐式缓存,不用 cachedContents

Neon 只支持隐式缓存。如果迁移的代码用 caches.create 创建缓存,或者发送 cached_content,请删掉这些字段。Google 的缓存指南说明,Interactions API 和 Gemini 4 模型都不支持显式缓存。

提示达到 4,096 token 后,隐式缓存会自动生效。命中部分按每百万输入 token $0.15 计费,而不是 $3.00,比标准输入价便宜 95%。命中无法强制,但 Google 的缓存指南(英文)给出了两种提高命中率的方法:

  • 把体量大、可复用的内容(系统指令、代码库结构图、参考文档)放在提示的开头,把每次请求不同的问题放在末尾。
  • 前缀相同的请求,尽量在相近的时间内发送。

对于多轮对话和 Agent 循环,Google 补充了一条 Gemini 4 规则:新请求至少要新增 2,050 个 token(模型输出、思考和函数结果都算在内),上一个请求才会被完整缓存。新增内容不足时,上一个请求的最后 2,050 个 token 会按标准输入价重新处理。Google 表示,大多数 Agent 回合都会超过这个门槛。

然后用数据验证,而不是凭假设:对于共享长前缀的第二个及之后的请求,total_cached_tokens(Interactions)或 cachedContentTokenCount(generateContent)应该大于 0。如果一直是 0,检查前缀是否逐字节一致,包括你可能在开头插入的时间戳或请求 ID。

超过 64K 的输出:后台执行

一次同步的 Neon 响应,思考加输出最多 65,536 token。对于长篇规格说明、大型重构计划或完整测试套件,Google 建议使用后台执行:

import time
from google import genai

client = genai.Client()
interaction = client.interactions.create(
    model="gemini-4-neon",
    input="Write a complete migration specification and test plan for this service.",
    background=True,
    generation_config={"max_output_tokens": 262144, "thinking_level": "high"},
)

while interaction.status in ("queued", "in_progress"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# 拼接所有 64K 续写 hop 中的文本。
text = "".join(
    content.text
    for step in interaction.steps
    if step.type == "model_output"
    for content in step.content
    if content.type == "text"
)
print("Status:", interaction.status)
print("Usage:", interaction.usage)
print(text)

服务器按 64K 一个 hop 续写,所以文本会分布在多个 model_output 步骤中,要全部拼接起来(上面的检查脚本也是这么做的)。一个后台 interaction 最长可运行 24 小时;如果以 failed 结束,按状态表的做法重试一次。还有两个容易忽略的细节。设置了 background 却没有设置 max_output_tokens,服务器仍会在 65,536 token 后停止。后台执行依赖存储,所以不要和 store=False 一起用。上限是 1,048,576 减去输入 token 数。如果无法存储 interaction,Google 的长输出指南(英文)介绍了客户端续写的做法。

Gemini 4 Neon API 常见报错与解决方法

在改动任何东西之前,先记录端点、准确的模型 ID、项目、SDK 版本,以及完整的错误响应体(去掉密钥)。从最先出错的那一层开始修。

症状Neon 上的可能原因解决方法
同一密钥调 Hydrogen 正常,调 Neon 报访问或配额错误密钥属于免费层级项目;Neon 仅限付费层级换用已开通付费计费的项目下的密钥(第 1 步)
找不到模型拼写错误、自己加了 -preview 之类的后缀,或者所用网关不路由 Neon对 generativelanguage.googleapis.com 使用 gemini-4-neon
thinking_level 报 400发送了 minimal(Gemini 4 会拒绝);混用了 Interactions 和 generateContent 的字段结构;或者旧的 thinkingBudget 与等级一起发送使用 low/medium/high/xhigh;字段名与端点对应;删除 thinkingBudget
带采样参数时报 400 校验错误temperature、top_p 或 top_k 超出范围删除采样参数;范围内的值反正也会被忽略
迁移缓存代码后请求失败残留旧的 cached_content/cachedContents 引用(不支持显式缓存)删除,依靠隐式缓存
MAX_TOKENS、incomplete 或文本为空max_output_tokens 设得太低,被思考用光恢复为 65,536;长任务用后台执行;或者有意识地降低思考等级
MALFORMED_FUNCTION_CALL让模型以纯文本 JSON 输出工具调用,却没有声明工具用 function calling 声明工具,或改用结构化输出
多轮工具调用中出现签名错误思考签名被丢弃,或在并行调用之间被复制使用 previous_interaction_id,或把之前的回合原样发回;见思考签名缺失的修复方法
复杂提示下客户端超时high/xhigh 推理需要数分钟把 HTTP 超时调到至少 15 分钟,或使用后台执行
429付费层级同样有速率限制降低并发并退避;见 429 重试指南

表中大部分内容直接来自 Google 的 Neon 迁移检查清单。在同系列模型上排查路由、配额和响应问题的完整示例,见 Gemini 4 Argon API 报错排查;其中 Argon 特有的取值(默认思考等级、可选等级)不适用于 Neon。Carbon、Neon 和 Hydrogen 的报错(包括回答为空或被截断)集中整理在 Gemini 4 Carbon、Neon、Hydrogen 报错排查。

能通过 Ofox 调用 Gemini 4 Neon 吗?

截至 2026 年 11 月 19 日还不能。Ofox 模型列表返回了 Gemini 4 Hydrogen 和 Argon,没有 Neon;Neon 的模型页路径返回 404。不要把上面的代码指向 Ofox 的 base URL:Interactions 端点和 Ofox 密钥属于不同的系统,而且没有可以到达 Neon 的路由。

之后想再确认,可以在 Ofox 模型列表(用 Ofox 密钥请求 GET https://api.ofox.ai/v1/models)或 ofox.ai/models 中查找 google/gemini-4-neon。如果出现了,它的模型页会列出支持的协议和当前价格。Ofox 上 Gemini 模型的请求格式见 Ofox Gemini API 文档。端点和鉴权以该文档为准,不要假设本文的 Google 原生代码能原样沿用。

如果现在就需要通过 Ofox 使用 Gemini 4 模型,Gemini 4 Hydrogen 已经上架,其接入教程包含 Ofox 路由。Google 拿 Neon 与哪些竞品旗舰做了基准对比、结果如何,见 Gemini 4 Neon、Claude Opus 5.5 与 GPT-6.2 Sol 对比。

首次调用验收清单

在宣布 Neon 集成完成之前,保存这份不含密钥的记录:

  • 模型 ID gemini-4-neon、端点、SDK 版本和项目标识。
  • 一份能通过检查脚本的已保存响应:completed 或 STOP,文本非空。
  • 用量记录,思考 token 和缓存输入 token 分开记录。
  • 你发送的 thinking_level 和 max_output_tokens,在代码中显式写出,而不是沿用默认值。
  • 遇到过的错误,以及修复它的改动。

有了这个基线,再逐项加入工具、长文档或后台任务。出问题时,你就知道是新加的部分导致的。

相关文档