跳到正文

OpenAI Decisions API 怎么用:已公测,只收输入费 $0.10/百万 token

predicate、choice、score 三种问题分别返回概率、选项和分数。按每次 400 输入 token 估算,每百万次判断约 $40;返回的概率要按自己的标注数据定阈值。

•••31 分钟阅读•API 指南
OpenAI Decisions API 已公测:POST /v1/decisions 返回 predicate、choice、score 三类结果,价格标签为每百万输入 token $0.10

截至 2026 年 10 月 10 日,OpenAI Decisions API 已经可以直接调用。OpenAI 在 2026 年 10 月 6 日(美国时间,北京时间 10 月 7 日凌晨)把它从限量预览改为公测(public beta),官方指南写的是预计"未来几周"正式发布(GA),没有给日期。它目前只支持 GPT-6 Luna(gpt-6-luna),走单独的 POST /v1/decisions 端点,SDK 方法是 client.decisions.create。

计费只看输入:每百万输入 token $0.10,输出、缓存读取和缓存写入都不收费。按每次 400 输入 token 估算,每百万次判断约 $40,比同样的任务走 Luna Responses 接口加严格枚举(约 $47.50)便宜约 16%。反过来,如果你的提示词有 1,024 token 以上的固定说明,并且 Responses 能稳定命中提示词缓存,Luna Responses 会便宜得多,下文有公式可以代入自己的数。官方 API 的支持地区不含中国大陆,国内接入路线见"国内开发者怎么跑起来"一节。

OpenAI Decisions API 是什么:在你给定的答案里选一个

Decisions API 是 OpenAI 专门做"判定类调用"的接口:你传入文本或图片,再给出几个问题和允许的答案,它不生成文字,只返回结构固定的结果。按官方指南,问题有三种:

问题类型适合做什么主要返回
predicate判断一个条件是否成立,比如商品照片有没有明显破损probability:条件成立的概率,0 到 1
choice从一组固定选项里选一个,比如工单分到哪个部门choice:你提供的某个值,另附每个选项的概率和 confidence
score按有序等级打分,比如问题严重程度score:按概率加权的等级序号,另附每个等级的概率和 confidence

典型用途是分类、请求路由和排优先级,也可以让 Agent 从几个预设动作里选下一步。OpenAI 另有一份语音控制指南,演示把它和 Live API 配合,从语音请求里选出"后退、刷新、不操作"这类浏览器动作。

它和 GPT-6 Luna 的关系:Decisions API 目前唯一可用的模型就是 gpt-6-luna。同一个模型走 /v1/responses 时按 Luna 的普通价格计费、输出文字;走 /v1/decisions 时按 Decisions 的价格计费、只返回判定结果。需要自定义 JSON 对象、提取字段或一段解释文字时,官方建议继续用 Responses API 的结构化输出(Structured Outputs);需要模型发起工具调用时用 function calling。

两个同名对象别混:Decisions 也是一个与 OpenAI 无关的低代码平台(decisions.com),它文档里的 OpenAI Module 是该平台自己的集成模块;decisionapi.net 是第三方网站,不是 OpenAI 文档。

Decisions API 现在能用吗:10 月 6 日起公测,GA 预计未来几周

能用。OpenAI API 更新日志在 2026 年 10 月 6 日记了一条:"Released the Decisions API in beta with gpt-6-luna";同一天开发者社区的公测公告说面向所有开发者开放。9 月 29 日 DevDay 发布后到 10 月 6 日之间,它只对 OpenAI 选定的客户开放,当时没有公开文档和价格;这个限量预览阶段已经结束。

"公测"对你意味着三件事:

  • 不用申请:有 OpenAI API 账号就能调用,也可以先在 Playground 里试问题和输入。官方没有公布 Decisions 专属的账号层级门槛;Free 层能不能调用,文档没有写。
  • 接口还可能变:字段名、SDK 方法、限制在 GA 前都可能调整,生产代码最好把调用封装在一个函数里(做法见下文"第四步")。
  • 价格是公测价:GA 之后的价格、会不会加缓存折扣,都没有公布。

目前已公布和仍未知的内容:

项目现状
状态公测,2026 年 10 月 6 日(美国时间)起
正式发布(GA)"未来几周",无具体日期
模型只有 gpt-6-luna
端点与 SDKPOST /v1/decisions;client.decisions.create(Go 为 client.Decisions.New)
价格每百万输入 token $0.10,输出与缓存不收费
数据控制符合条件的客户可用零数据保留(ZDR)和 HIPAA;数据驻留支持美国和欧洲(EEA 加瑞士)
Decisions 专属速率限额未公布
每次请求最多几个问题、score 最多几个等级未公布

一个文档细节:截至 2026 年 10 月 10 日,GPT-6 Luna 模型页的端点表里还没有列出 v1/decisions,以 Decisions 指南和 API 参考为准。

第一条请求怎么写:POST /v1/decisions 的三种问题

请求只有三个字段:model(固定写 gpt-6-luna)、input(文本字符串,或包含文字和图片的 user 消息)、questions(问题数组)。用 SDK 时,官方给出的最低版本是 Python 3.26.0、JavaScript 7.30.0、Go 3.73.0、Ruby 0.101.0、Java 4.78.0,版本更低的 SDK 里没有 decisions 这个方法。

下面的示例按官方指南和 API 参考里的请求结构改写成中文场景,需要环境变量 OPENAI_API_KEY。示例没有经过实际调用,返回值以你自己的结果为准。

choice:从固定选项里选一个

工单分流是最直接的用法。每个选项有 value,description 可选,但写清每个选项什么时候适用,结果会更稳定。官方也建议留一个 other 这样的兜底选项:

python
from openai import OpenAI  # 需要 openai>=3.26.0

client = OpenAI()  # 读取环境变量 OPENAI_API_KEY

decision = client.decisions.create(
    model="gpt-6-luna",
    input="我的订单 #4471 被扣了两次钱",
    questions=[
        {
            "type": "choice",
            "name": "department",
            "instructions": "这张工单应该分到哪个部门?",
            "choices": [
                {"value": "billing", "description": "付款、发票和退款"},
                {"value": "technical", "description": "产品使用中的问题"},
                {"value": "shipping", "description": "配送和物流跟踪"},
                {"value": "other", "description": "不属于以上类别,交给人工"},
            ],
        }
    ],
)

answer = decision.answers[0]
if answer.type == "refusal":
    print(f"拒答:{answer.name}")
elif answer.type == "choice":
    print(answer.choice, answer.confidence, answer.probabilities)
print(decision.usage.input_tokens)  # 计费只看这个数

不用 SDK 时,直接发 HTTP 请求:

bash
curl https://api.openai.com/v1/decisions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": "我的订单 #4471 被扣了两次钱",
    "questions": [{
      "type": "choice",
      "name": "department",
      "instructions": "这张工单应该分到哪个部门?",
      "choices": [
        {"value": "billing", "description": "付款、发票和退款"},
        {"value": "technical", "description": "产品使用中的问题"},
        {"value": "shipping", "description": "配送和物流跟踪"},
        {"value": "other", "description": "不属于以上类别,交给人工"}
      ]
    }]
  }'

官方文档给的示意返回(标注为 illustrative,不是实测值)大致是这样:

json
{
  "answers": [
    {
      "type": "choice",
      "name": "department",
      "choice": "billing",
      "probabilities": [
        { "value": "billing", "probability": 0.95 },
        { "value": "technical", "probability": 0.02 },
        { "value": "shipping", "probability": 0.01 },
        { "value": "other", "probability": 0.02 }
      ],
      "confidence": 0.93
    }
  ]
}

predicate 和 score:判断条件、按等级打分,一次请求问多个问题

互不依赖的问题可以放进同一个 questions 数组,共用一份输入,每个问题的类型可以不同。下面这个请求带一张截图,同时问"有没有报错弹窗"(predicate)和"问题有多严重"(score)。图片按官方指南的写法转成 base64 data URL:

python
import base64
from pathlib import Path

from openai import OpenAI

client = OpenAI()
image_base64 = base64.b64encode(Path("screenshot.png").read_bytes()).decode("ascii")

decision = client.decisions.create(
    model="gpt-6-luna",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "用户反馈:在 Safari 里点导出没反应,Chrome 正常。"},
                {"type": "input_image", "image_url": f"data:image/png;base64,{image_base64}"},
            ],
        }
    ],
    questions=[
        {
            "type": "predicate",
            "name": "error_dialog",
            "instructions": "截图里是否出现了错误提示弹窗?只看弹窗,不看页面上的普通文字。",
        },
        {
            "type": "score",
            "name": "severity",
            "instructions": "这个问题有多严重?",
            "levels": [
                {"label": "仅外观", "description": "只影响显示,功能没有损失"},
                {"label": "有替代办法", "description": "某个操作失败,但换一种方式可以完成"},
                {"label": "完全受阻", "description": "操作失败,且没有替代办法"},
            ],
        },
    ],
)

for answer in decision.answers:  # 按提问顺序返回
    if answer.type == "refusal":
        print(f"拒答:{answer.name}")
    elif answer.type == "predicate":
        print(answer.name, answer.probability)
    elif answer.type == "score":
        print(answer.name, answer.score, answer.confidence)

score 的等级要从低到高排列。如果后一个问题要看前一个问题的答案(例如先判断有没有破损,有破损再选维修类别),官方要求拆成两次请求。

返回字段:probability、choice、probabilities、confidence、score

字段出现在含义
probabilitypredicate条件成立的概率估计,0 到 1;predicate 没有单独的 confidence
choicechoice你提供的某个选项值(值区分类型,字符串 "true" 和布尔值 true 是两个选项)
probabilitieschoice、score每个选项或等级的概率;score 里每项带 value(从 0 开始的序号)和 label
confidencechoice、score单独给出的置信度,和概率分布一起返回
scorescore各等级序号按概率加权的平均值,可以落在两个等级之间
type: "refusal"任何问题这个问题被拒答,只带问题的 name(没起名时为 null)
usage整个响应input_tokens、cached_tokens、cache_write_tokens、output_tokens、reasoning_tokens 等用量字段

score 的算法举例:三个等级的概率是 0.1、0.7、0.2,score = 0 × 0.1 + 1 × 0.7 + 2 × 0.2 = 1.1,意思是"大致在'有替代办法'这一级,略偏严重"。想要一个确定的类别,就用 choice,不要拿 score 四舍五入。

Decisions API 有哪些限制:2–255 个选项、每次最多 128 张图

下面这些限制来自 API 参考和官方指南,写代码前先对一遍:

限制内容
模型只有 gpt-6-luna
choice 选项数2 到 255 个,值不能重复
图片数量每次请求所有消息加起来最多 128 张
图片格式用 base64 data URL;不接受 file ID(见下方说明)
图片清晰度detail 可选 low、high、auto、original,默认 auto
消息角色只接受 user 消息,没有 system 或 developer 消息
不支持的输入文件、音频、工具与函数调用、item 引用
safety_identifier可选,最长 128 个字符,用来标识你的终端用户
速率限额没有公布 Decisions 专属限额,在控制台 Settings > Organization > Limits 查看

图片地址的说法有冲突:指南写的是图片必须是内嵌的 base64 data URL,不支持 HTTP(S) 图片链接;API 参考却写 base64 和可公开访问的 HTTP(S) 链接都可以。两边都说不接受 file ID。稳妥的做法是统一传 base64,两份文档都认可。

速率限额也要注意口径。OpenAI 在 10 月 6 日同时调整了账号层级,现在是 Free、Build、Launch、Grow(详见 OpenAI API 账号分层(Tier):Free、Build、Launch、Grow 额度与升级条件),以前常见的"Tier 1 每分钟 500 次"已经作废。Luna 在 Responses 等端点上的标准限额是 Build 每分钟 5,000 次请求、200 万 token,Launch 10,000 次、1,000 万 token,Grow 30,000 次、1.8 亿 token,但文档没有说这些数字适用于 /v1/decisions。按峰值规划容量时,以控制台显示的数字为准。

另外两点:Decisions API 支持零数据保留和 HIPAA,但只对符合条件、签了相应协议的客户开放;使用区域处理(regional processing)会加收溢价。

每千次、每百万次判断要花多少钱:用自己的 token 数复算

Decisions API 的价格写在官方指南的"Pricing and availability"一节,定价总页里没有单独一行:使用 gpt-6-luna 时,每百万输入 token $0.10,输出、缓存读取、缓存写入都不收费。所以:

单次成本 = 输入 token × $0.10 ÷ 1,000,000

输入 token 包括你的说明、选项描述、待判断的文本和图片折算的 token,以响应里的 usage.input_tokens 为准。区域处理溢价和长上下文倍率照样适用(Luna 模型页写的是区域处理加收 10%,单次输入超过 272K token 时输入按 2 倍计价),判断类请求一般碰不到后者。这个价格只适用于 /v1/decisions,同一个模型走其他端点仍按 Luna 的普通价格。

拿来比较的是同一个模型走 Responses API 加严格枚举的做法。按 Luna 模型页的 Standard 价格(每百万 token:输入 $0.10、缓存输入 $0.01、缓存写入 $0.125、输出 $0.50),reasoning.effort 设为 none 时:

Luna Responses 单次成本 = (未缓存输入 × $0.10 + 缓存输入 × $0.01 + 输出 × $0.50) ÷ 1,000,000

下表的 token 数都是假设值,用来看方向:

情形Decisions API 每百万次Luna Responses 每百万次哪个便宜
A:短提示词,400 输入 token,Responses 输出约 15 token$40$47.50Decisions 便宜约 16%
A':输入翻倍到 800 token,输出不变$80$87.50Decisions 仍便宜 $7.50
B:1,500 token 固定说明 + 100 token 变动内容,Responses 输出约 10 token,命中缓存$160$30Responses 便宜约 5.3 倍
A 走 Luna Batch(半价,异步)—$23.75离线任务用 Batch 更便宜

情形 A 的算法:Decisions 是 400 × $0.10 ÷ 1,000,000 = $0.00004 一次,每千次 $0.04,每百万次 $40;Luna Responses 是 400 × $0.10 ÷ 1,000,000 + 15 × $0.50 ÷ 1,000,000 = $0.0000475 一次,每百万次 $47.50。差价全部来自输出 token,Decisions 不收这部分。

情形 B 的算法:Decisions 没有缓存折扣,1,600 个输入 token 全价计费,1,600 × $0.10 ÷ 1,000,000 = $0.00016 一次,每百万次 $160;Luna Responses 命中缓存时是 (1,500 × $0.01 + 100 × $0.10 + 10 × $0.50) ÷ 1,000,000 = $0.000015 + $0.00001 + $0.000005 = $0.00003 一次,每百万次 $30(缓存未命中的那几次还要按 $0.125 付缓存写入费)。社区里已经有开发者指出,这个端点没有缓存输入折扣,长提示词的分类任务从 Luna Responses 迁过来并不划算。

临界点可以直接算出来。设固定前缀为 P、变动输入为 V、Responses 输出为 O(都按 token 计),两者的差只剩前缀和输出:Decisions 多付 0.09 × P,Responses 多付 0.50 × O。只有 P < 5.6 × O 时 Decisions 更便宜,输出 15 token 时约是 83 token 的前缀。而 OpenAI 的提示词缓存只在前缀达到 1,024 token 时才生效,缓存在最后一次写入或复用后至少保留 30 分钟。换成可以直接执行的规则:

  • 提示词短、没有可缓存的长前缀,或者请求稀疏、缓存经常过期:Decisions 更便宜。
  • 有 1,024 token 以上固定说明、流量足够让缓存一直热着:命中缓存时 Luna Responses 更便宜,差距可以到几倍。
  • 不急着要结果的离线打标:Luna Batch 半价,按情形 A 的假设比 Decisions 还便宜。官方指南没有提到 Decisions 能否走 Batch。
两组示例 token 数下 Decisions API 与 Luna Responses 每百万次判断费用的条形对比:短提示词 $40 对 $47.50,命中缓存的长前缀 $160 对 $30

这里只比较了 token 价格。Decisions 的真正优势在速度和直接给出概率,下文分开讲;如果你在意的是延迟,每百万次判断几美元到一百多美元的差价可能不是决定因素。

换成你自己的数:拿 20 条真实样本分别走两种接口,取 usage 里的输入、缓存和输出 token 平均值代入上面两个公式。带截图的判断,图片会折算成输入 token,要单独统计。想对比 Luna 和 Sol 在相同 token 用量下的花费,可以看 GPT-6 Luna 与 Sol 价格对比:API 和 Codex 分别怎么算。

调用 v1/decisions 返回 403 是什么意思

在 10 月 6 日公测之前,这个 403 的意思是账号不在预览名单里,跟请求怎么写无关。第三方 eesel 在 2026 年 10 月 1 日和 2 日的测试里,用普通 API Key 请求 POST https://api.openai.com/v1/decisions,两天都拿 到 HTTP 403:

json
{
  "error": {
    "message": "Decision API is not enabled for this user.",
    "type": "invalid_request_error",
    "param": null,
    "code": null
  }
}

当时连空请求体也直接返回这个错误,说明它是按账号开放的功能开关。公测开始后,第三方测试者(例如日本 classmethod 在 10 月 7 日的测试)和社区回帖都没有再报告这个错误。

如果你现在仍然遇到它,OpenAI 没有文档说明原因,可以按下面的顺序排查(这是推断,不是官方说法):

  1. 路径和模型:确认是 POST https://api.openai.com/v1/decisions,model 写的是 gpt-6-luna。/v1/decisions/create、/v1/beta/decisions 这类路径不存在。
  2. SDK 版本:Python 低于 3.26.0、JavaScript 低于 7.30.0 时 SDK 里没有 decisions 方法,通常会先在本地报错;自己拼 URL 时要确认没有用错端点。
  3. 项目和组织权限:在控制台检查这个 API Key 所属的项目是否限制了可用端点或模型,换一个组织管理员创建的 Key 对比。
  4. 账号地区:OpenAI 的支持国家和地区列表以外的访问可能导致账号受限。

逐项排除后仍是 403,就带上请求 ID 联系 OpenAI 支持,别靠反复改请求体试。

要不要把 GPT-6 Luna 严格枚举分类器迁到 /v1/decisions

不一定。已经用 Luna 加严格枚举 schema 跑得好好的分类器,要按延迟、成本结构和输入类型来判断:

你的情况建议理由
实时聊天里的路由、Agent 一个任务里要做很多次小判断优先测试迁移延迟逐次累加,Decisions 主打速度
需要一个概率来设阈值(自动通过、转人工、拦截三档)测试迁移,优先用 predicateLuna 严格枚举只给答案,不给概率
提示词短、没有长的固定说明可以迁不收输出费,按情形 A 的假设便宜约 16%
有 1,024 token 以上固定说明,流量稳定先留在 Luna Responses命中缓存时 Responses 便宜几倍
离线重新打标、历史数据回填用 Luna Batch半价,不需要实时返回
要输出自定义 JSON、提取字段或附带理由留在 Responses 结构化输出Decisions 只返回概率、选项和分数
只能经第三方网关调用先确认网关是否提供 Decisions很多 OpenAI 兼容网关只提供普通 Luna

决定迁移时,按这个顺序做,风险最小:

  1. 准备标注集:从线上取几百条已经有人工结论的样本,覆盖常见和难判断的输入。
  2. 影子运行:线上继续用 Luna 方案,同时把同样的输入发给 /v1/decisions,只记录不执行。
  3. 对比四个数:准确率(尤其是"该不该执行动作"这类难判断)、延迟中位数和长尾、每千次判断的实际费用、高峰期有没有触发限额。
  4. 用标注集定阈值:根据误判的代价决定 probability 或 confidence 到多少才自动执行(下文"概率不能直接当阈值"一节)。
  5. 分批切换:先切可撤销的动作(打标签、分队列),保留 Luna 方案作为回退。

用 GPT-6 Luna 和严格枚举 schema 实现有限选项判断

这是 Decisions API 公测之前的做法,现在仍然有用:提示词有长前缀、需要走 Batch,或者你只能经过只提供普通 Luna 的网关时,它更合适。GPT-6 Luna 支持文本和图片输入,也支持结构化输出,reasoning.effort 可以设为 none,Responses、Chat Completions 和 Batch 三个端点都能调用。按 OpenAI 的结构化输出指南,把输出约束成一个只有 enum 字段的 JSON Schema,并打开 strict,模型返回的答案就只能是你列出的选项之一。

第一步:选项里留一个"交给人工"

结构化输出指南明确说了两件事:模型会尽量遵守 schema,当输入和问题完全无关时,这种"必须选一个"的约束可能导致胡乱作答;结构化输出仍然可能出错。所以候选答案里要有一个出口,例如 needs_human(信息不足、无法判断或与问题无关),提示词里写清什么情况选它。Decisions API 的 choice 问题同样适用这条,官方也建议留 other。

第二步:用 Responses API 调用(官方直连)

下面的 Python 示例需要 openai SDK 和环境变量 OPENAI_API_KEY。decide() 接收上下文文本、可选的图片地址、问题和选项列表,返回一个保证在列表内的答案:

python
import json
import time
from openai import OpenAI

client = OpenAI()  # 读取环境变量 OPENAI_API_KEY

def decide(context: str, question: str, options: list[str],
           fallback: str = "needs_human", image_url: str | None = None) -> dict:
    """在 options 中选一个答案;任何异常情况都返回 fallback。"""
    if fallback not in options:
        options = options + [fallback]

    content = [{"type": "input_text", "text": context}]
    if image_url:  # 公网 URL 或 data:image/png;base64,... 均可
        content.append({"type": "input_image", "image_url": image_url})

    start = time.perf_counter()
    resp = client.responses.create(
        model="gpt-6-luna",
        reasoning={"effort": "none"},
        input=[
            {"role": "developer",
             "content": f"{question}\n只能从给定选项中选一个。"
                        f"信息不足、无法判断或输入与问题无关时,选 {fallback}。"},
            {"role": "user", "content": content},
        ],
        text={"format": {
            "type": "json_schema",
            "name": "decision",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"answer": {"type": "string", "enum": options}},
                "required": ["answer"],
                "additionalProperties": False,
            },
        }},
    )
    latency_ms = round((time.perf_counter() - start) * 1000)

    answer = fallback
    if resp.status == "completed" and resp.output_text:  # 拒答或输出被截断时 output_text 为空
        try:
            parsed = json.loads(resp.output_text).get("answer")
        except json.JSONDecodeError:
            parsed = None
        if parsed in options:
            answer = parsed

    return {
        "answer": answer,
        "model": resp.model,
        "latency_ms": latency_ms,
        "input_tokens": resp.usage.input_tokens,
        "output_tokens": resp.usage.output_tokens,
    }

ROUTES = ["billing", "shipping", "technical", "other", "needs_human"]
print(decide("我的订单 #4471 被扣了两次钱", "这张工单应该分到哪个队列?", ROUTES))

成功的判断标准:返回的 answer 是 ROUTES 里的一个值;input_tokens、output_tokens 有数,代入上文的成本公式。

一次要回答好几个问题(比如"分到哪个队列"和"能不能自动回复")时,在 schema 里放多个枚举字段即可,每个字段都要列进 required。结构化输出指南规定,一个 schema 里所有枚举值加起来不超过 1,000 个。

第三步:经 OpenAI 兼容网关时改用 Chat Completions

如果你通过 OpenAI 兼容网关调用(下文讲国内路线),一般走 Chat Completions 接口(/v1/chat/completions)。结构化输出在 Chat Completions 里写在 response_format 中,其余逻辑不变:

python
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.laozhang.ai/v1",
                api_key=os.environ["LAOZHANG_API_KEY"])

options = ["billing", "shipping", "technical", "other", "needs_human"]
resp = client.chat.completions.create(
    model="gpt-6-luna",
    reasoning_effort="none",
    messages=[
        {"role": "developer",
         "content": "这张工单应该分到哪个队列?只能从给定选项中选一个;无法判断时选 needs_human。"},
        {"role": "user", "content": [
            {"type": "text", "text": "快递显示已签收,但我没收到"},
            # 有截图时追加:{"type": "image_url", "image_url": {"url": "https://..."}}
        ]},
    ],
    response_format={"type": "json_schema", "json_schema": {
        "name": "decision",
        "strict": True,
        "schema": {
            "type": "object",
            "properties": {"answer": {"type": "string", "enum": options}},
            "required": ["answer"],
            "additionalProperties": False,
        },
    }},
)

choice = resp.choices[0]
answer = "needs_human"
if choice.finish_reason == "stop" and not choice.message.refusal:
    try:
        parsed = json.loads(choice.message.content).get("answer")
        answer = parsed if parsed in options else "needs_human"
    except (TypeError, json.JSONDecodeError):
        pass  # 返回的不是合法 JSON,说明 json_schema 可能没有生效
print(answer, resp.usage)

两段代码都在本地再校验一次答案是否在列表里。原因很简单:官方直连时,严格 schema 已经保证这一点;经第三方网关时,这一层校验能兜住 response_format 没被透传的情况。

第四步:把 decide() 换成 Decisions API 实现

让业务代码只依赖 decide(context, question, options) 和它返回的 answer,不直接接触 gpt-6-luna、text.format 这些实现细节。问题文本和选项列表放在配置里集中管理,每次调用把输入版本、答案、模型、延迟和 token 数写进日志。

这样一来,迁移到 Decisions API 只需要另写一个返回同样结构的实现,再加一个 confidence 字段。下面这个版本按官方请求结构写成,图片按指南要求传 base64:

python
import time
from openai import OpenAI  # 需要 openai>=3.26.0

client = OpenAI()

def decide_with_decisions(context: str, question: str, options: list[str],
                          fallback: str = "needs_human",
                          image_base64: str | None = None) -> dict:
    """与 decide() 返回结构相同,多一个 confidence。"""
    if fallback not in options:
        options = options + [fallback]

    if image_base64:
        input_ = [{"role": "user", "content": [
            {"type": "input_text", "text": context},
            {"type": "input_image", "image_url": f"data:image/png;base64,{image_base64}"},
        ]}]
    else:
        input_ = context

    start = time.perf_counter()
    decision = client.decisions.create(
        model="gpt-6-luna",
        input=input_,
        questions=[{
            "type": "choice",
            "name": "answer",
            "instructions": f"{question}\n信息不足、无法判断或输入与问题无关时,选 {fallback}。",
            "choices": [{"value": o} for o in options],
        }],
    )
    latency_ms = round((time.perf_counter() - start) * 1000)

    result = decision.answers[0]
    answer, confidence = fallback, None
    if result.type == "choice" and result.choice in options:  # 拒答时 type 为 refusal
        answer, confidence = result.choice, result.confidence

    return {
        "answer": answer,
        "confidence": confidence,
        "model": decision.model,
        "latency_ms": latency_ms,
        "input_tokens": decision.usage.input_tokens,
        "output_tokens": decision.usage.output_tokens,
    }

用同一批标注样本分别跑 decide() 和 decide_with_decisions(),比较答案、延迟和 token 数,再决定切不切。选项超过 255 个时 Decisions 放不下,要先拆成两级问题。

速度差距:OpenAI 称快约 10 倍,第三方测得中位约 260 毫秒

OpenAI 在更新日志和指南里都说 Decisions API 比 Responses API 快约 10 倍,但没有公布测试方法。流传很广的"约 150 毫秒返回"出自媒体报道和发布会,OpenAI 文档里没有这个数。

能参考的是几份第三方数据,测试地点和网络都不同,只能看数量级:

测试设置中位耗时
classmethod,Decisions API(10 月 7 日)curl 调官方 choice 示例,145 输入 token,跑 5 次273 毫秒
classmethod,Decisions API官方 score 示例,跑 5 次256 毫秒
社区开发者,Decisions API带图片输入,约 3 Mbps 网络约 0.8 秒
eesel,GPT-6 Luna 严格枚举(10 月初)20 张工单各跑两遍,推理 none,笔记本端到端1.46 秒

数据来源:classmethod 的测试、OpenAI 社区公告帖的回帖、eesel 的测试。eesel 的 Luna 测试里,推理强度调到 low、medium 时中位耗时分别是 1.62 秒和 2.33 秒。

差距在哪里有影响:工单、邮件分流基本没有影响;实时聊天里,每轮在回复前多等 1 秒以上,用户能感觉到;Agent 一个任务里做 20 次小判断,按 1.46 秒算光等待就要约 29 秒,按 0.26 秒算约 5 秒。从国内经网关调用还会多出一段网络延迟,要在你自己的网络环境里测。

概率不能直接当阈值:会发消息、扣钱的动作要加兜底

Decisions API 返回的 probability 和 confidence 是模型自己的估计,不保证判断正确,也不一定和真实比例对得上。两份公开报告值得先看:

  • classmethod 用官方 choice 示例跑 5 次,每次都是 billing 概率 1.0、confidence 1.0,而文档的示意值是 0.95 和 0.93;score 示例 5 次都是 0.97、confidence 0.96,示意值是 1.1 和 0.55。数值只有两位小数,多次调用完全相同。
  • 社区开发者 platypus 用"70% 正面的硬币"测试:predicate 给出的概率接近 70%,和真实比例一致;同样的问题写成 choice,给出约 98%,而且选项顺序一换,概率也跟着变。
左侧为 70% 正面硬币测试中真实比例、predicate 与 choice 的概率条,右侧为按动作后果分级的三档处理方式

这只是小样本的个人测试,不代表所有任务,但足以说明:不要把 0.9 直接当"九成把握"。OpenAI 自己的建议也是用你应用里的标注样本来定阈值,按误判的代价取舍。实际操作上(以下是做法建议,不是官方规定):

  1. 需要可信概率时优先用 predicate:把"是不是退款请求"这类二元判断写成 predicate,比塞进 choice 更容易校准。
  2. 留出口:每个 choice 问题都有 other 或 needs_human 这类选项,选中就转人工或走默认流程。
  3. 用标注集画阈值:把几百条样本的概率和人工结论放在一起,看阈值设在多少时误判可以接受,不同问题分别设。
  4. 按后果分级:可撤销的动作(打标签、分队列)可以直接执行;发消息、退款、封号、改数据这类动作,需要人工复核或第二道规则校验。
  5. 留日志:记录输入版本、问题与选项版本、答案、概率和最终结果,换模型、换接口或 GA 后接口变化时用来对比。

严格枚举的 Luna 方案也有同样的问题,只是它连概率都不给。eesel 的测试里,"分到哪个队列"所有设置都是 40 次全对;但"这张工单能不能自动回复",Luna 不推理时 40 次里对了 33 次。分队列错了,损失的是几分钟;自动回复错了,错误回复会直接发到客户那里。

国内开发者怎么跑起来:直连限制与 OpenAI 兼容网关

OpenAI 的 API 支持国家和地区列表里没有中国大陆,页面还写明在列表以外访问可能导致账号被封禁或暂停。按你的条件,有三条路:

路线能用 Decisions API 吗适合谁要注意什么
OpenAI 官方直连能,就是上文的写法有合规海外主体和 OpenAI 账号的团队唯一能用到 ZDR、HIPAA、数据驻留这些数据控制的路线
已上架 Decisions 的第三方网关能,但请求格式是网关自己的已经在用这些网关的团队Vercel AI Gateway 用 AI SDK 的写法,和 /v1/decisions 原生格式不同
只提供普通 Luna 的 OpenAI 兼容网关不能只需要有限选项判断、能接受 Luna 方案的团队用上文第三步的 Chat Completions 写法

已上架 Decisions 的网关:Vercel AI Gateway 列出模型 openai/gpt-6-luna-decisions,输入同样是每百万 token $0.10,页面示例用的是 AI SDK 的 experimental_decide 函数,问题的写法(例如 type: 'boolean')和 OpenAI 原生请求不一样;OpenRouter 也上架了名为 GPT-6 Luna Decisions 的模型。上文的 Python 示例不能原样套用到这两家,请求格式以它们各自的文档为准;能不能从国内访问和付款,也要先在小额度下确认。

只需要 Luna 方案时,以 laozhang.ai 为例:截至 2026 年 10 月 10 日,它的模型目录列出 gpt-6-luna,走 OpenAI 兼容接口(/v1/chat/completions),标价输入 $0.1、输出 $0.5(每百万 token),与 OpenAI 官方 Standard 价格相同,实际扣费以控制台和调用日志为准。目录里没有 Decisions 模型,所以它只能跑上文的严格枚举方案。接入时用第三步的写法,把 base_url 换成 https://api.laozhang.ai/v1。

它是否完整透传 response_format 的严格 json_schema 和 reasoning_effort,公开文档里没有写明。上线前先做一次确认:

  1. 发一条正常工单,看返回的 message.content 是否是 {"answer": "..."} 这样的纯 JSON,且值在列表里。
  2. 再发一条和问题完全无关的输入(比如一句闲聊),看返回是否仍是合法 JSON、仍是列表里的值(理想情况是 needs_human)。
  3. 如果返回了自由文本、被 Markdown 代码块包裹的 JSON 或列表外的值,说明约束没有生效。这时本地校验会把它们兜成 needs_human,但兜底比例会变高,需要评估是否改走官方直连。

Decisions API 价格、开放时间与 Jev 的常见问题

OpenAI Decisions API 的价格是多少?

使用 gpt-6-luna 时,每百万输入 token $0.10,输出、缓存读取和缓存写入都不收费;区域处理溢价和长上下文倍率仍然适用。按每次 400 输入 token 估算,每千次判断 $0.04,每百万次 $40。注意这个端点没有缓存折扣,提示词里固定说明很长时,命中缓存的 Luna Responses 可能更便宜。这是公测期价格,GA 后的价格没有公布。

OpenAI Decisions API 什么时候全面开放?

它从 2026 年 10 月 6 日(美国时间)起已经公测,开发者不用申请就能调用。正式发布(GA)官方只说"未来几周",没有给日期。GA 前接口和价格都可能调整,以 Decisions 指南和更新日志为准。

GPT-6 Luna 和 Decisions API 是什么关系?

Decisions API 目前只支持 gpt-6-luna 一个模型。同一个 Luna 走 /v1/responses 时生成文字、按 Luna 的输入加输出价格计费;走 /v1/decisions 时只返回概率、选项或分数,只收输入费。OpenAI 称后者快约 10 倍。

OpenAI Decisions API 和 Jev 有什么不同?

Jev 是 TypeSafe AI 的专用判断模型,只接受文本;Decisions API 能处理图片,而且在 OpenAI 平台内,可以用零数据保留、HIPAA 和美欧数据驻留。两者的效果对比目前只有第三方报告,结论不一:classmethod 测得延迟相近(255 毫秒对 238 毫秒),按每次请求计,Decisions 约 $0.0000406、Jev 约 $0.0000169;社区里有开发者认为 Jev 在需要判断的任务上更准,也有人在文档分类和成文规则路由上测得各模型差不多。用你自己的标注样本对比再选。

发现内容有误,或遇到文中没覆盖的问题?请把文章地址和你看到的情况发到 hi@laozhang.ai,核实后我们会更新正文。