From 7db781be9ac446f29bd84d22e351d3ac80d3a772 Mon Sep 17 00:00:00 2001 From: Codex Date: Wed, 23 Sep 2026 12:25:20 +0800 Subject: [PATCH 1/7] feat: add GPT-6 catalogs, verified Cookie routing and scoped prompt rules --- .downstream/gpt6-routing-and-prompts.md | 62 +++ .github/scripts/test_first_party_plugins.sh | 2 +- .github/workflows/downstream-verify.yml | 5 + backend/cmd/server/wire_gen.go | 2 +- .../handler/admin/account_codex_routing.go | 67 +++ .../handler/admin/system_prompt_handler.go | 4 + .../admin/system_prompt_handler_test.go | 15 +- .../admin/system_prompt_rules_handler.go | 95 ++++ backend/internal/handler/setting_handler.go | 5 +- backend/internal/pkg/openai/constants.go | 21 + .../pkg/openai/gpt6_codex_reference.json | 124 +++++ backend/internal/pkg/openai/gpt6_models.go | 38 ++ .../internal/pkg/openai/gpt6_models_test.go | 65 +++ .../pkg/openai/instructions_gpt6_luna.txt | 153 ++++++ .../pkg/openai/instructions_gpt6_sol.txt | 156 ++++++ .../repository/account_prompt_binding.go | 78 +++ backend/internal/repository/account_repo.go | 6 + .../business_system_prompt_repository.go | 9 + .../business_system_prompt_rules.go | 97 ++++ ...ss_system_prompt_rules_integration_test.go | 234 ++++++++ .../business_system_prompt_rules_test.go | 53 ++ .../repository/codex_connection_lease.go | 144 +++++ .../repository/codex_connection_lease_test.go | 104 ++++ backend/internal/repository/http_upstream.go | 2 + .../internal/repository/scheduler_cache.go | 1 + backend/internal/server/routes/admin.go | 20 + .../service/account_test_reasoning.go | 14 +- .../internal/service/account_test_service.go | 3 +- backend/internal/service/admin_account.go | 6 + backend/internal/service/billing_service.go | 9 +- .../service/business_system_prompt_policy.go | 24 +- .../business_system_prompt_rules_apply.go | 509 ++++++++++++++++++ ...siness_system_prompt_rules_gateway_test.go | 308 +++++++++++ ...usiness_system_prompt_rules_observation.go | 32 ++ .../business_system_prompt_rules_preview.go | 278 ++++++++++ .../business_system_prompt_rules_service.go | 267 +++++++++ .../business_system_prompt_rules_test.go | 129 +++++ .../business_system_prompt_rules_ws.go | 47 ++ .../service/business_system_prompt_service.go | 40 +- .../business_system_prompt_turn_cache.go | 15 + .../service/codex_connection_lease.go | 23 + .../service/codex_routing_completion.go | 114 ++++ .../internal/service/codex_routing_cookies.go | 293 ++++++++++ .../internal/service/codex_routing_demand.go | 56 ++ .../service/codex_routing_fingerprint.go | 230 ++++++++ .../service/codex_routing_fingerprint_test.go | 59 ++ .../internal/service/codex_routing_host.go | 357 ++++++++++++ .../codex_routing_identity_observation.go | 76 +++ ...codex_routing_identity_observation_test.go | 33 ++ .../service/codex_routing_infrastructure.go | 99 ++++ .../service/codex_routing_native_ws.go | 56 ++ .../internal/service/codex_routing_profile.go | 51 ++ .../internal/service/codex_routing_proxy.go | 118 ++++ .../service/codex_routing_proxy_test.go | 156 ++++++ .../service/codex_routing_redaction.go | 87 +++ .../service/codex_routing_reference.json | 223 ++++++++ .../internal/service/codex_routing_test.go | 481 +++++++++++++++++ .../service/codex_routing_transport.go | 275 ++++++++++ .../service/codex_routing_validation.go | 174 ++++++ .../service/codex_routing_ws_bridge_test.go | 193 +++++++ .../service/codex_routing_ws_probe.go | 106 ++++ .../service/codex_ticket_lifecycle.go | 60 ++- .../internal/service/codex_ticket_plugin.go | 9 +- .../service/model_context_capacity.go | 17 +- .../model_context_capacity_catalog_test.go | 10 +- .../service/openai_business_system_prompt.go | 81 ++- ...ai_business_system_prompt_observability.go | 5 + .../service/openai_codex_client_identity.go | 31 +- .../service/openai_codex_fingerprint.go | 8 + .../service/openai_codex_identity_snapshot.go | 11 + .../service/openai_codex_model_metadata.go | 23 +- .../service/openai_codex_models_service.go | 63 ++- .../openai_codex_request_compression.go | 9 +- .../service/openai_codex_ticket_test.go | 2 +- .../service/openai_codex_transform.go | 2 + .../service/openai_codex_turn_state.go | 5 +- .../service/openai_codex_turn_state_test.go | 29 +- .../service/openai_gateway_cc_pipeline.go | 5 + .../openai_gateway_chat_completions.go | 1 + .../service/openai_gateway_forward.go | 7 + .../service/openai_gateway_messages.go | 2 + .../service/openai_gateway_passthrough.go | 6 + .../service/openai_gateway_request_body.go | 2 +- .../openai_gateway_turn_state_commit_test.go | 1 + .../internal/service/openai_gpt6_models.go | 61 +++ .../service/openai_gpt6_models_test.go | 191 +++++++ .../internal/service/openai_gpt6_pricing.go | 24 + .../service/openai_gpt6_pricing_test.go | 103 ++++ .../internal/service/openai_model_alias.go | 9 + .../service/openai_plugin_transport.go | 17 +- .../service/openai_request_integrity.go | 6 +- .../service/openai_ws_forwarder_ingress.go | 38 +- .../service/openai_ws_forwarder_v2.go | 11 + .../internal/service/openai_ws_http_bridge.go | 1 + .../openai_ws_v2_passthrough_adapter.go | 38 ++ .../internal/service/plugin_codex_identity.go | 7 +- .../service/plugin_codex_transport.go | 3 + .../service/plugin_extension_accounts.go | 4 +- .../service/plugin_extension_package_test.go | 2 +- .../service/plugin_extension_state.go | 14 +- backend/internal/service/plugin_manager.go | 2 + backend/internal/service/plugin_request.go | 7 +- backend/internal/service/plugin_scheduling.go | 5 + backend/internal/service/pricing_service.go | 14 + backend/internal/service/upstream_models.go | 14 +- .../internal/service/upstream_models_test.go | 2 + backend/internal/service/wire.go | 4 + .../migrations/253_prompt_rule_policies.sql | 18 + .../prompt_rule_policies_migration_test.go | 25 + backend/pkg/extensionapi/ui/client.ts | 52 +- backend/pkg/extensionapi/ui/presentation.ts | 35 ++ backend/pkg/extensionapi/ui/sizing.ts | 54 ++ backend/pkg/extensionapi/ui/stylesheets.ts | 113 ++++ backend/pkg/extensionapi/v1/codex_identity.go | 18 +- backend/pkg/extensionapi/v1/codex_routing.go | 110 ++++ backend/pkg/extensionapi/v1/prompt.go | 128 +++-- backend/pkg/extensionapi/v1/prompt_rules.go | 71 +++ .../model_prices_and_context_window.json | 94 ++++ frontend/src/api/admin/accounts.ts | 1 + .../account/ModelContextCapacityField.vue | 9 +- .../ModelContextCapacityField.spec.ts | 13 + .../__tests__/ModelWhitelistSelector.spec.ts | 6 + .../admin/account/AccountDetailsDrawer.vue | 8 + .../account/AccountPromptBindingPanel.vue | 10 + .../admin/account/CodexFingerprintPanel.vue | 130 +++++ .../__tests__/CodexFingerprintPanel.spec.ts | 50 ++ frontend/src/components/keys/UseKeyModal.vue | 12 + .../keys/__tests__/UseKeyModal.spec.ts | 8 + .../src/components/plugins/PluginFrame.vue | 9 +- .../PluginFrame.precondition.spec.ts | 14 + .../__tests__/presentationStability.spec.ts | 64 +++ .../plugins/__tests__/theme.spec.ts | 76 ++- frontend/src/components/plugins/theme.ts | 34 +- .../__tests__/useModelWhitelist.spec.ts | 6 +- frontend/src/composables/useModelWhitelist.ts | 4 +- .../src/i18n/locales/en/admin/accounts.ts | 5 +- .../src/i18n/locales/zh/admin/accounts.ts | 9 +- plugins/account-tools/cmd/plugin/main.go | 2 +- plugins/account-tools/manifest.source.json | 4 +- .../ui/src/locales/en-accounts.ts | 5 +- .../ui/src/locales/zh-accounts.ts | 9 +- .../admin-observability/cmd/plugin/main.go | 2 +- .../admin-observability/manifest.source.json | 4 +- plugins/cindy-provider/cmd/plugin/main.go | 2 +- plugins/cindy-provider/manifest.source.json | 4 +- plugins/codex-runtime/cmd/plugin/main.go | 2 +- .../internal/tickets/cutover_test.go | 62 ++- .../codex-runtime/internal/tickets/module.go | 301 +++-------- .../internal/tickets/module_test.go | 74 ++- .../codex-runtime/internal/tickets/outcome.go | 6 + .../internal/tickets/proxy_test.go | 15 +- .../codex-runtime/internal/tickets/routing.go | 249 +++++++++ .../internal/tickets/routing_test.go | 107 ++++ .../codex-runtime/internal/tickets/state.go | 77 ++- plugins/codex-runtime/manifest.source.json | 12 +- plugins/codex-runtime/profile/identity.go | 18 +- .../codex-runtime/profile/identity_test.go | 25 + plugins/codex-runtime/ui/assets/app.js | 10 +- plugins/image-tools/cmd/plugin/main.go | 2 +- plugins/image-tools/manifest.source.json | 4 +- plugins/model-policy/catalog/catalog_data.go | 30 ++ plugins/model-policy/catalog/module_test.go | 23 + plugins/model-policy/cmd/plugin/main.go | 2 +- plugins/model-policy/manifest.source.json | 4 +- plugins/prompt-skills/cmd/plugin/main.go | 2 +- plugins/prompt-skills/manifest.source.json | 13 +- plugins/prompt-skills/policy/module.go | 18 + plugins/prompt-skills/policy/rules.go | 227 ++++++++ plugins/prompt-skills/policy/rules_test.go | 100 ++++ .../ui/src/AccountPromptBinding.vue | 60 +++ plugins/prompt-skills/ui/src/App.vue | 27 +- .../ui/src/PromptRulesManager.vue | 137 +++++ .../ui/src/__tests__/PromptRules.spec.ts | 71 +++ plugins/prompt-skills/ui/src/locales/en.ts | 2 + .../prompt-skills/ui/src/locales/rules.en.ts | 29 + .../prompt-skills/ui/src/locales/rules.zh.ts | 29 + plugins/prompt-skills/ui/src/locales/zh.ts | 2 + plugins/prompt-skills/ui/src/rules-api.ts | 45 ++ tools/check-account-layout-stability.py | 438 +++++++++++++++ 179 files changed, 10320 insertions(+), 590 deletions(-) create mode 100644 .downstream/gpt6-routing-and-prompts.md create mode 100644 backend/internal/handler/admin/account_codex_routing.go create mode 100644 backend/internal/handler/admin/system_prompt_rules_handler.go create mode 100644 backend/internal/pkg/openai/gpt6_codex_reference.json create mode 100644 backend/internal/pkg/openai/gpt6_models.go create mode 100644 backend/internal/pkg/openai/gpt6_models_test.go create mode 100644 backend/internal/pkg/openai/instructions_gpt6_luna.txt create mode 100644 backend/internal/pkg/openai/instructions_gpt6_sol.txt create mode 100644 backend/internal/repository/account_prompt_binding.go create mode 100644 backend/internal/repository/business_system_prompt_rules.go create mode 100644 backend/internal/repository/business_system_prompt_rules_integration_test.go create mode 100644 backend/internal/repository/business_system_prompt_rules_test.go create mode 100644 backend/internal/repository/codex_connection_lease.go create mode 100644 backend/internal/repository/codex_connection_lease_test.go create mode 100644 backend/internal/service/business_system_prompt_rules_apply.go create mode 100644 backend/internal/service/business_system_prompt_rules_gateway_test.go create mode 100644 backend/internal/service/business_system_prompt_rules_observation.go create mode 100644 backend/internal/service/business_system_prompt_rules_preview.go create mode 100644 backend/internal/service/business_system_prompt_rules_service.go create mode 100644 backend/internal/service/business_system_prompt_rules_test.go create mode 100644 backend/internal/service/business_system_prompt_rules_ws.go create mode 100644 backend/internal/service/codex_connection_lease.go create mode 100644 backend/internal/service/codex_routing_completion.go create mode 100644 backend/internal/service/codex_routing_cookies.go create mode 100644 backend/internal/service/codex_routing_demand.go create mode 100644 backend/internal/service/codex_routing_fingerprint.go create mode 100644 backend/internal/service/codex_routing_fingerprint_test.go create mode 100644 backend/internal/service/codex_routing_host.go create mode 100644 backend/internal/service/codex_routing_identity_observation.go create mode 100644 backend/internal/service/codex_routing_identity_observation_test.go create mode 100644 backend/internal/service/codex_routing_infrastructure.go create mode 100644 backend/internal/service/codex_routing_native_ws.go create mode 100644 backend/internal/service/codex_routing_profile.go create mode 100644 backend/internal/service/codex_routing_proxy.go create mode 100644 backend/internal/service/codex_routing_proxy_test.go create mode 100644 backend/internal/service/codex_routing_redaction.go create mode 100644 backend/internal/service/codex_routing_reference.json create mode 100644 backend/internal/service/codex_routing_test.go create mode 100644 backend/internal/service/codex_routing_transport.go create mode 100644 backend/internal/service/codex_routing_validation.go create mode 100644 backend/internal/service/codex_routing_ws_bridge_test.go create mode 100644 backend/internal/service/codex_routing_ws_probe.go create mode 100644 backend/internal/service/openai_gpt6_models.go create mode 100644 backend/internal/service/openai_gpt6_models_test.go create mode 100644 backend/internal/service/openai_gpt6_pricing.go create mode 100644 backend/internal/service/openai_gpt6_pricing_test.go create mode 100644 backend/migrations/253_prompt_rule_policies.sql create mode 100644 backend/migrations/prompt_rule_policies_migration_test.go create mode 100644 backend/pkg/extensionapi/ui/presentation.ts create mode 100644 backend/pkg/extensionapi/ui/sizing.ts create mode 100644 backend/pkg/extensionapi/ui/stylesheets.ts create mode 100644 backend/pkg/extensionapi/v1/codex_routing.go create mode 100644 backend/pkg/extensionapi/v1/prompt_rules.go create mode 100644 frontend/src/components/admin/account/AccountPromptBindingPanel.vue create mode 100644 frontend/src/components/admin/account/CodexFingerprintPanel.vue create mode 100644 frontend/src/components/admin/account/__tests__/CodexFingerprintPanel.spec.ts create mode 100644 frontend/src/components/plugins/__tests__/presentationStability.spec.ts create mode 100644 plugins/codex-runtime/internal/tickets/routing.go create mode 100644 plugins/codex-runtime/internal/tickets/routing_test.go create mode 100644 plugins/prompt-skills/policy/rules.go create mode 100644 plugins/prompt-skills/policy/rules_test.go create mode 100644 plugins/prompt-skills/ui/src/AccountPromptBinding.vue create mode 100644 plugins/prompt-skills/ui/src/PromptRulesManager.vue create mode 100644 plugins/prompt-skills/ui/src/__tests__/PromptRules.spec.ts create mode 100644 plugins/prompt-skills/ui/src/locales/rules.en.ts create mode 100644 plugins/prompt-skills/ui/src/locales/rules.zh.ts create mode 100644 plugins/prompt-skills/ui/src/rules-api.ts create mode 100644 tools/check-account-layout-stability.py diff --git a/.downstream/gpt6-routing-and-prompts.md b/.downstream/gpt6-routing-and-prompts.md new file mode 100644 index 000000000000..a9d5374c3b2c --- /dev/null +++ b/.downstream/gpt6-routing-and-prompts.md @@ -0,0 +1,62 @@ +# GPT-6 模型、Codex 路由与提示词 + +本轮以官方 v0.2.7 和下游生产提交 `300bd6dc5c40191d935cc08db910942f996bb26f` 为基线。宿主目标版本为 `0.2.7-codexrip.2`，七个内置插件为 `0.2.8`；新版插件要求宿主至少为该下游版本。插件固定版本意图继续保留，旧提示词插件不能解释新规则时明确报告不可用。 + +## 模型同步与容量 + +账号模型管理的“同步最新支持模型”补齐内置列表；“同步上游支持的模型”才请求账号目录并保存快照。两者保留人工模型和映射。 + +同步返回的 `model_list_source` 单独标明型号名单来自实时上游还是配置回退，与能力补充来源分开；只有实时目录可用来确认账号当时公布了哪些型号。 + +| 接入方式 | GPT-6 Sol / Luna 上下文 | 输出与推理 | +| --- | --- | --- | +| 官方 API | 1,050,000 | 最大输出 128,000；none、low、medium、high、xhigh、max | +| Codex 打包参考 | 默认 272,000，扩展最大 872,000 | 默认 medium；Sol 支持客户端 Ultra 委派，Luna 最高 Max | +| 账号原始目录 | 按实际声明及既有覆盖优先级 | 实时能力优先于旧快照和默认值 | + +API Key 使用完整 Responses。OAuth 目录保留实际 Lite 与上下文字段，回退值标记为“Codex 参考”。Ultra 不作为原生 API reasoning effort 发送。Cindy 库存不因 OpenAI 发布新模型而扩大。 + +两款型号有独立价卡及严格大于 272,000 输入的长请求倍率，保留人工定价。未知 GPT-6 名称不套 Astra 身份或价格。固定来源与指令摘要见 [官方提取记录](../backend/internal/pkg/openai/gpt6_codex_reference.json)。 + +## Cookie 路由状态与指纹 + +账号的 Cookie 候选、模型验证结果和原生 turn-state 各自独立。采集取得完整成功响应和允许的 Cookie 后生成候选；业务出口完整完成且原始响应模型匹配，才能取得该模型的限时资格。292/312 仅是观测长度，不代表模型质量。 + +- 恢复 Cookie 只使用 `__cflb` 和 `__oailb`。基础设施 Cookie 使用官方允许集合，登录 Cookie 不进入共享传输状态。宿主处理 Cookie；普通插件头修改继续禁止 Cookie。 +- 同一 Cookie 值不延长首次采集时间，删除有持久标记；资格绑定主体、profile、路由、Cookie 版本及实际连接。本地上限为 120 秒，更早的上游到期时间优先。 +- 每账号与型号使用固定候选和当前槽；后台清除到期 Cookie 原值，保留摘要、删除标记和诊断账本。同值且未缩短期限的响应不会反复写入新状态。清除任务在采集开关关闭时仍执行，整个插件停用期间不承诺后台清除。 +- 未知轮换出口通过实际连接租约复用，连接丢失后不能自动在新连接上继续发送旧资格。客户端 WS 在只有 HTTP 资格时使用已有 HTTP bridge，页面明确显示 WS 入站、HTTP 出站；原生 WS 验证只证明该次连接。 +- 已登记且有请求需求的账号在到期前 20 秒续获。每周期最多一次采集与一次复验，连续两个失败周期后持久停止；闲置账号不持续探测。`fail_closed` 保留。 +- 旧 292 不转换为 Cookie 验证成功，旧停止状态保留。原先默认的 Astra/5.6-Sol 名单只在旧配置版本迁移时追加 6-Sol/6-Luna；自定义名单保留，之后显式修改不自动补回。 +- 原生 turn-state 在同一轮固定首次值，下一轮或换账号清除。 + +账号详情右栏的“Codex 出站指纹”读取配置和已经记录的出站事实，刷新不会发模型请求。页面展示 profile 来源、UA、版本、身份摘要及一致性、传输、Cookie 名称和模型验证结果。新建账号采用官方 Windows CLI 0.156.0 的应用层参照；已有配置保留，可显式选择新版参照，设备种子和手动 UA 覆盖不被重置。 + +本机官方 CLI 通过隔离合成认证、本地可信证书和受控 HTTP/WS 端点取得参照。生产 Go TLS 的实际值与参照分开展示；未捕获生产 ClientHello 时不宣称 JA3/JA4 相同。原始 Cookie、STATE、Bearer 和代理密码不进入这些页面或通用诊断。 + +管理员接口位于 `/api/v1/admin/accounts/:id/codex-fingerprint`，profile 选择使用其 `/profile` 子路径和账号版本 CAS。`/codex-routing/validate` 是独立、不登记自动续期的限额验证操作，固定支持三款 GPT-6，一次 UUID 绑定一个账号和最多七个出站阶段；重复操作不能重新花费相同阶段。 + +## 提示词规则与账号选择 + +系统提示词页面的“应用规则”复用原有模板及不可变版本。规则稳定排序，可按请求模型或最终上游模型精确匹配；空模型集合表示全部。 + +| 位置 | 含义 | +| --- | --- | +| control_prepend / control_append | 控制指令区前后 | +| conversation_head / conversation_tail | 本次最终发送的消息数组头尾 | + +发送方式与位置分开：`native_control` 使用目标原生控制字段，仅用于控制区；`system` 和 `developer` 要求最终发包保留对应显式角色。Codex OAuth 不接受严格 system 的组合会明确返回不支持，原生模式标明实际使用 `instructions`。续接数组位置不包含 `previous_response_id` 指向的隐藏历史。 + +账号详情和账号批量操作提供 `inherit / off / custom`：继承默认规则、关闭、或用指定规则替换默认集合。默认集合留空、指定账号选择 custom，即可只对指定账号开启。账号仅存规则引用，不复制正文；shadow 使用自身绑定。 + +预览选择账号、模型、协议、HTTP/WS和样例请求，显示网关基础模板、客户指令、站点规则及最终结构。它不访问上游。实际发送前执行同一载体校验，覆盖 Responses、Chat、转换链路和 WS passthrough；重试及换账号精确撤回本站插入，不按相同正文猜测客户内容。规则变化隔离缓存，保留续接标识和已有回显设置。 + +迁移 `253_prompt_rule_policies.sql` 为旧活动版本建立默认规则，保留原总开关、账号范围与 256 KiB 合法编译上限。配置和账号绑定均使用版本比较，冲突需要重新读取后处理；被账号引用的规则不能直接删除。 + +## 界面与验证边界 + +公共插件 context 的同值刷新不再重建 iframe。主题按 URL/变量差异更新，新 CSS 及字体准备完成再替换旧外观；加载失败保留最后成功版本。内容测量按帧合并，使用自然尺寸而非随滚动变化的 viewport 坐标。 + +离线真实 Chromium 验证了左侧导航、分类栏和右侧账号详情：两次正常 15 秒刷新、未保存输入与滚动保留、主题失败恢复、真实字体加载、菜单伸缩及跨 lg 布局。跨 lg 后表格切换为文档流时，其原容器滚动值会归零，这是原有响应式行为，不属于本轮刷新验收结果。 + +本地测试只覆盖实际修改风险，正常 PR 必需检查继续执行。真实验证须另用本次固定账本：一个账号，Astra/Sol/Luna 各最多采集与复验一次，另最多一次 WS；每次 25 秒、128 KiB 读取上限，失败不追加请求。真实结果、生产镜像及部署指针由工作区接手手册和本次交付证据维护；本文件不把离线成功写成线上模型质量证明。 diff --git a/.github/scripts/test_first_party_plugins.sh b/.github/scripts/test_first_party_plugins.sh index c64b44661783..c1477f5fdbed 100644 --- a/.github/scripts/test_first_party_plugins.sh +++ b/.github/scripts/test_first_party_plugins.sh @@ -22,7 +22,7 @@ go build -trimpath -o "$plugin_build_dir/package-plugin" ./cmd/package-plugin -bundle-source ../plugins/bundle.source.json \ -binary-dir "$plugin_build_dir/binaries" \ -platform linux-amd64 \ - -tested-host-version 0.2.7 \ + -tested-host-version 0.2.7-codexrip.2 \ -output "$plugin_build_dir/bundle" \ -signing-key-file "$plugin_build_dir/publisher.key" \ -key-id codexrip-plugins-test diff --git a/.github/workflows/downstream-verify.yml b/.github/workflows/downstream-verify.yml index 16916539280e..5da963a291d3 100644 --- a/.github/workflows/downstream-verify.yml +++ b/.github/workflows/downstream-verify.yml @@ -149,6 +149,8 @@ jobs: src/components/admin/account/__tests__/AccountTestModal.spec.ts \ src/components/admin/account/__tests__/AccountTestModal.displayContract.spec.ts \ src/components/admin/account/__tests__/AccountTestModal.policyPlan.spec.ts \ + src/components/admin/account/__tests__/CodexFingerprintPanel.spec.ts \ + src/components/keys/__tests__/UseKeyModal.spec.ts \ src/views/admin/__tests__/SettingsView.spec.ts \ src/components/common/__tests__/VersionBadge.downstream.spec.ts \ src/api/__tests__/downstreamStatus.spec.ts \ @@ -169,6 +171,8 @@ jobs: src/components/plugins/__tests__/pluginViewDispatch.spec.ts \ src/components/plugins/__tests__/resourceAvailability.spec.ts \ src/components/plugins/__tests__/PluginFrame.precondition.spec.ts \ + src/components/plugins/__tests__/theme.spec.ts \ + src/components/plugins/__tests__/presentationStability.spec.ts \ src/components/plugins/__tests__/resourceClient.spec.ts \ src/components/plugins/__tests__/localResources.spec.ts \ src/features/image-studio/history.legacy.spec.ts \ @@ -205,6 +209,7 @@ jobs: src/composables/__tests__/useModelWhitelist.spec.ts \ src/components/account/__tests__/BulkEditAccountModal.spec.ts \ ../plugins/prompt-skills/ui/src/__tests__/App.spec.ts \ + ../plugins/prompt-skills/ui/src/__tests__/PromptRules.spec.ts \ ../plugins/prompt-skills/ui/src/__tests__/locales.spec.ts \ src/views/admin/__tests__/AccountsView.console.spec.ts \ src/views/admin/__tests__/AccountsView.priorityColumn.spec.ts \ diff --git a/backend/cmd/server/wire_gen.go b/backend/cmd/server/wire_gen.go index 96b9721ddd17..4eed204e757e 100644 --- a/backend/cmd/server/wire_gen.go +++ b/backend/cmd/server/wire_gen.go @@ -164,7 +164,7 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) { if err != nil { return nil, err } - businessSystemPromptService, err := service.ProvideBusinessSystemPromptService(businessSystemPromptStore, businessSystemPromptRevisionBus, remoteSkillRegistryService, remoteSkillRegistryRevisionBus) + businessSystemPromptService, err := service.ProvideBusinessSystemPromptService(businessSystemPromptStore, businessSystemPromptRevisionBus, remoteSkillRegistryService, remoteSkillRegistryRevisionBus, accountRepository, configConfig) if err != nil { return nil, err } diff --git a/backend/internal/handler/admin/account_codex_routing.go b/backend/internal/handler/admin/account_codex_routing.go new file mode 100644 index 000000000000..9975a2f109d2 --- /dev/null +++ b/backend/internal/handler/admin/account_codex_routing.go @@ -0,0 +1,67 @@ +package admin + +import ( + "strconv" + + "github.com/Wei-Shaw/sub2api/internal/pkg/response" + "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/gin-gonic/gin" +) + +func (h *AccountHandler) CodexFingerprint(c *gin.Context) { + c.Header("Cache-Control", "no-store") + id, err := strconv.ParseInt(c.Param("id"), 10, 64) + if err != nil || id <= 0 { + response.BadRequest(c, "Invalid account identifier") + return + } + if h.codexTicketGateway == nil { + response.Error(c, 503, "Codex runtime unavailable") + return + } + view, err := h.codexTicketGateway.CodexFingerprint(c.Request.Context(), id) + if err != nil { + response.Error(c, 503, "Codex fingerprint unavailable") + return + } + response.Success(c, view) +} + +func (h *AccountHandler) ValidateCodexRouting(c *gin.Context) { + c.Header("Cache-Control", "no-store") + id, err := strconv.ParseInt(c.Param("id"), 10, 64) + var request service.CodexRoutingValidationRequest + if err != nil || id <= 0 || c.ShouldBindJSON(&request) != nil { + response.BadRequest(c, "Invalid Codex validation request") + return + } + if h.codexTicketGateway == nil { + response.Error(c, 503, "Codex runtime unavailable") + return + } + result, err := h.codexTicketGateway.ValidateCodexRouting(c.Request.Context(), id, request) + if err != nil { + response.Error(c, 409, "Codex validation unavailable or budget already spent") + return + } + response.Success(c, result) +} + +func (h *AccountHandler) SelectCodexProfile(c *gin.Context) { + c.Header("Cache-Control", "no-store") + id, err := strconv.ParseInt(c.Param("id"), 10, 64) + var choice service.CodexProfileSelection + if err != nil || id <= 0 || c.ShouldBindJSON(&choice) != nil { + response.BadRequest(c, "Invalid profile selection") + return + } + if h.codexTicketGateway == nil { + response.Error(c, 503, "Codex runtime unavailable") + return + } + if err := h.codexTicketGateway.SelectCodexProfile(c.Request.Context(), id, choice); err != nil { + response.Error(c, 409, "Account identity changed or profile unavailable") + return + } + response.Success(c, gin.H{"applied": true}) +} diff --git a/backend/internal/handler/admin/system_prompt_handler.go b/backend/internal/handler/admin/system_prompt_handler.go index 8d3ba931b0a9..9323dc7c1402 100644 --- a/backend/internal/handler/admin/system_prompt_handler.go +++ b/backend/internal/handler/admin/system_prompt_handler.go @@ -206,6 +206,10 @@ func remoteSkillVersionDetailResponse(detail service.RemoteSkillBundleVersionDet func writeBusinessSystemPromptError(c *gin.Context, err error) { switch { + case errors.Is(err, service.ErrPromptDeliveryUnsupported): + response.ErrorWithDetails(c, http.StatusUnprocessableEntity, "The selected prompt delivery or position is unsupported by this destination", "prompt_delivery_unsupported", nil) + case errors.Is(err, service.ErrPromptRuleReferenced): + response.ErrorWithDetails(c, http.StatusConflict, "An account still references this rule", "prompt_rule_referenced", nil) case errors.Is(err, service.ErrBusinessSystemPromptRevisionConflict): response.ErrorWithDetails(c, http.StatusConflict, "system_prompt_revision_conflict", "system_prompt_revision_conflict", nil) case errors.Is(err, service.ErrBusinessSystemPromptUnavailable): diff --git a/backend/internal/handler/admin/system_prompt_handler_test.go b/backend/internal/handler/admin/system_prompt_handler_test.go index e6456a4acb91..5bde4f488a30 100644 --- a/backend/internal/handler/admin/system_prompt_handler_test.go +++ b/backend/internal/handler/admin/system_prompt_handler_test.go @@ -148,10 +148,13 @@ func (*serviceTestRemoteSkillSource) Build(context.Context, service.RemoteSkillP func TestWriteBusinessSystemPromptErrorUsesStableProtocolCodes(t *testing.T) { gin.SetMode(gin.TestMode) for name, testCase := range map[string]struct { - err error - wantStatus int - wantReason string + err error + wantStatus int + wantReason string + wantMessage string }{ + "unsupported rule delivery": {err: service.ErrPromptDeliveryUnsupported, wantStatus: http.StatusUnprocessableEntity, wantReason: "prompt_delivery_unsupported", wantMessage: "The selected prompt delivery or position is unsupported by this destination"}, + "referenced rule": {err: service.ErrPromptRuleReferenced, wantStatus: http.StatusConflict, wantReason: "prompt_rule_referenced", wantMessage: "An account still references this rule"}, "revision conflict": { err: service.ErrBusinessSystemPromptRevisionConflict, wantStatus: http.StatusConflict, wantReason: "system_prompt_revision_conflict", @@ -184,7 +187,11 @@ func TestWriteBusinessSystemPromptErrorUsesStableProtocolCodes(t *testing.T) { writeBusinessSystemPromptError(ctx, testCase.err) require.Equal(t, testCase.wantStatus, recorder.Code) require.Equal(t, testCase.wantReason, gjson.Get(recorder.Body.String(), "reason").String()) - require.Equal(t, testCase.wantReason, gjson.Get(recorder.Body.String(), "message").String()) + message := testCase.wantMessage + if message == "" { + message = testCase.wantReason + } + require.Equal(t, message, gjson.Get(recorder.Body.String(), "message").String()) }) } } diff --git a/backend/internal/handler/admin/system_prompt_rules_handler.go b/backend/internal/handler/admin/system_prompt_rules_handler.go new file mode 100644 index 000000000000..651cda9a78a1 --- /dev/null +++ b/backend/internal/handler/admin/system_prompt_rules_handler.go @@ -0,0 +1,95 @@ +package admin + +import ( + "strconv" + + "github.com/Wei-Shaw/sub2api/internal/pkg/response" + "github.com/Wei-Shaw/sub2api/internal/server/middleware" + "github.com/Wei-Shaw/sub2api/internal/service" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/gin-gonic/gin" +) + +func (h *SystemPromptHandler) Rules(c *gin.Context) { + state, err := h.service.PromptRulesState() + if err != nil { + writeBusinessSystemPromptError(c, err) + return + } + response.Success(c, state) +} + +func (h *SystemPromptHandler) UpdateRules(c *gin.Context) { + var request struct { + ExpectedRevision int64 `json:"expected_revision" binding:"required"` + Policy extensionv1.PromptRulePolicy `json:"policy" binding:"required"` + } + if err := c.ShouldBindJSON(&request); err != nil { + response.BadRequest(c, "Invalid prompt rule policy") + return + } + actor, ok := h.actorID(c) + if !ok { + return + } + state, err := h.service.UpdatePromptRules(c.Request.Context(), request.Policy, request.ExpectedRevision, actor) + if err != nil { + writeBusinessSystemPromptError(c, err) + return + } + middleware.SetAuditExtra(c, map[string]any{"revision": state.Revision, "rule_count": len(state.Policy.Rules), "result": "rules_updated"}) + response.Success(c, state) +} + +func (h *SystemPromptHandler) AccountBindings(c *gin.Context) { + var request struct { + AccountIDs []int64 `json:"account_ids" binding:"required"` + } + if err := c.ShouldBindJSON(&request); err != nil { + response.BadRequest(c, "Invalid account selection") + return + } + views, err := h.service.PromptAccountBindings(c.Request.Context(), request.AccountIDs) + if err != nil { + writeBusinessSystemPromptError(c, err) + return + } + response.Success(c, views) +} + +func (h *SystemPromptHandler) UpdateAccountBindings(c *gin.Context) { + var request struct { + ExpectedRevision int64 `json:"expected_revision" binding:"required"` + Updates []service.PromptBindingUpdate `json:"updates" binding:"required"` + } + if err := c.ShouldBindJSON(&request); err != nil { + response.BadRequest(c, "Invalid account prompt binding") + return + } + results, err := h.service.UpdatePromptAccountBindings(c.Request.Context(), request.Updates, request.ExpectedRevision) + if err != nil { + writeBusinessSystemPromptError(c, err) + return + } + middleware.SetAuditExtra(c, map[string]any{"account_count": len(results), "result": "bindings_updated"}) + response.Success(c, results) +} + +func (h *SystemPromptHandler) PreviewRules(c *gin.Context) { + id, err := strconv.ParseInt(c.Param("account_id"), 10, 64) + if err != nil || id < 1 { + response.BadRequest(c, "Invalid account") + return + } + var request service.PromptRulesPreviewRequest + if err := c.ShouldBindJSON(&request); err != nil { + response.BadRequest(c, "Invalid prompt preview") + return + } + result, err := h.service.PreviewPromptRules(c.Request.Context(), id, request) + if err != nil { + writeBusinessSystemPromptError(c, err) + return + } + response.Success(c, result) +} diff --git a/backend/internal/handler/setting_handler.go b/backend/internal/handler/setting_handler.go index 283bf24ba993..1189bba9eded 100644 --- a/backend/internal/handler/setting_handler.go +++ b/backend/internal/handler/setting_handler.go @@ -48,7 +48,10 @@ func (h *SettingHandler) GetPublicPluginThemeAsset(c *gin.Context) { } c.Header("Cache-Control", "no-store") c.Header("X-Content-Type-Options", "nosniff") - c.Header("Cross-Origin-Resource-Policy", "same-origin") + // Only manifest-declared public appearance assets reach this handler. + // Opaque sandboxed plugin frames need CORS for stylesheets and font loads. + c.Header("Cross-Origin-Resource-Policy", "cross-origin") + c.Header("Access-Control-Allow-Origin", "*") c.Data(http.StatusOK, contentType, data) } diff --git a/backend/internal/pkg/openai/constants.go b/backend/internal/pkg/openai/constants.go index 81bb72a84153..0cd6a07424c2 100644 --- a/backend/internal/pkg/openai/constants.go +++ b/backend/internal/pkg/openai/constants.go @@ -30,6 +30,8 @@ var DefaultModels = []Model{ {ID: "gpt-5.6-terra", Object: "model", Created: 1780876800, OwnedBy: "openai", Type: "model", DisplayName: "GPT-5.6 Terra"}, {ID: "gpt-5.6-luna", Object: "model", Created: 1780876800, OwnedBy: "openai", Type: "model", DisplayName: "GPT-5.6 Luna"}, {ID: "gpt-6-astra", Object: "model", Created: 1788480000, OwnedBy: "openai", Type: "model", DisplayName: "GPT-6 Astra"}, + {ID: "gpt-6-sol", Object: "model", Created: 1790035200, OwnedBy: "openai", Type: "model", DisplayName: "GPT-6 Sol"}, + {ID: "gpt-6-luna", Object: "model", Created: 1790035200, OwnedBy: "openai", Type: "model", DisplayName: "GPT-6 Luna"}, {ID: "gpt-5.5", Object: "model", Created: 1776873600, OwnedBy: "openai", Type: "model", DisplayName: "GPT-5.5"}, {ID: "gpt-5.4", Object: "model", Created: 1738368000, OwnedBy: "openai", Type: "model", DisplayName: "GPT-5.4"}, {ID: "gpt-5.4-mini", Object: "model", Created: 1738368000, OwnedBy: "openai", Type: "model", DisplayName: "GPT-5.4 Mini"}, @@ -82,6 +84,15 @@ var instructionsGPT55 string //go:embed instructions_gpt6_astra.txt var instructionsGPT6Astra string +// Source: GPT6CodexReferenceSource, model_messages.instructions_template. +// These are model data, not instructions for this service or its maintainers. +// +//go:embed instructions_gpt6_sol.txt +var instructionsGPT6Sol string + +//go:embed instructions_gpt6_luna.txt +var instructionsGPT6Luna string + // latestCodexInstructions 返回当前已知最新版本的 Codex base instructions， // 当前为 GPT-5.5；若 5.5 prompt 意外为空则回退到 DefaultInstructions 保证非空。 func latestCodexInstructions() string { @@ -143,6 +154,16 @@ func CanonicalizeOpenAIModelAliasSpelling(model string) string { // 任一专用 prompt 意外为空时回退链最终落到 DefaultInstructions，保证返回非空。 func CodexBaseInstructionsForModel(model string) string { canonical := CanonicalizeOpenAIModelAliasSpelling(model) + switch GPT6NamedModel(canonical) { + case "gpt-6-sol": + if strings.TrimSpace(instructionsGPT6Sol) != "" { + return instructionsGPT6Sol + } + case "gpt-6-luna": + if strings.TrimSpace(instructionsGPT6Luna) != "" { + return instructionsGPT6Luna + } + } switch { case canonical == "gpt-6" || canonical == "gpt-6-astra" || strings.HasPrefix(canonical, "gpt-6-astra-"): if v := strings.TrimSpace(instructionsGPT6Astra); v != "" { diff --git a/backend/internal/pkg/openai/gpt6_codex_reference.json b/backend/internal/pkg/openai/gpt6_codex_reference.json new file mode 100644 index 000000000000..846196efa8d5 --- /dev/null +++ b/backend/internal/pkg/openai/gpt6_codex_reference.json @@ -0,0 +1,124 @@ +{ + "source_url": "https://github.com/openai/codex/blob/4b664e0ef0397f82e68c60088a90fcd035deb796/codex-rs/models-manager/models.json", + "source_commit": "4b664e0ef0397f82e68c60088a90fcd035deb796", + "verified_at": "2026-09-23", + "source_sha256": "0178d235c589a31abd6ed0ea1e870935dc5819240eb0e813e178d3ebedf534f4", + "models": { + "gpt-6-sol": { + "slug": "gpt-6-sol", + "display_name": "GPT-6-Sol", + "context_window": 272000, + "max_context_window": 872000, + "auto_compact_token_limit": null, + "default_reasoning_level": "medium", + "supported_reasoning_levels": [ + { + "effort": "low", + "description": "Fast responses with lighter reasoning" + }, + { + "effort": "medium", + "description": "Balances speed and reasoning depth for everyday tasks" + }, + { + "effort": "high", + "description": "Greater reasoning depth for complex problems" + }, + { + "effort": "xhigh", + "description": "Extra high reasoning depth for complex problems" + }, + { + "effort": "max", + "description": "Maximum reasoning depth for the hardest problems" + }, + { + "effort": "ultra", + "description": "Maximum reasoning with automatic task delegation" + } + ], + "input_modalities": [ + "text", + "image" + ], + "service_tiers": [ + { + "id": "priority", + "name": "Fast", + "description": "1.5x speed" + } + ], + "use_responses_lite": true, + "multi_agent_reasoning_effort": null, + "multi_agent_version": "v2", + "minimal_client_version": "0.155.0", + "truncation_policy": { + "mode": "tokens", + "limit": 10000 + }, + "tool_mode": "code_mode_only", + "apply_patch_tool_type": "freeform", + "comp_hash": "3000", + "supports_search_tool": true, + "instructions_field": "model_messages.instructions_template", + "instructions_file": "instructions_gpt6_sol.txt", + "instructions_sha256": "b1dd8718c037906c53a305c5cbccb4a4be35ccbb7837461ec349bfc495412f0d" + }, + "gpt-6-luna": { + "slug": "gpt-6-luna", + "display_name": "GPT-6-Luna", + "context_window": 272000, + "max_context_window": 872000, + "auto_compact_token_limit": null, + "default_reasoning_level": "medium", + "supported_reasoning_levels": [ + { + "effort": "low", + "description": "Fast responses with lighter reasoning" + }, + { + "effort": "medium", + "description": "Balances speed and reasoning depth for everyday tasks" + }, + { + "effort": "high", + "description": "Greater reasoning depth for complex problems" + }, + { + "effort": "xhigh", + "description": "Extra high reasoning depth for complex problems" + }, + { + "effort": "max", + "description": "Maximum reasoning depth for the hardest problems" + } + ], + "input_modalities": [ + "text", + "image" + ], + "service_tiers": [ + { + "id": "priority", + "name": "Fast", + "description": "1.5x speed" + } + ], + "use_responses_lite": true, + "multi_agent_reasoning_effort": null, + "multi_agent_version": "v2", + "minimal_client_version": "0.155.0", + "truncation_policy": { + "mode": "tokens", + "limit": 10000 + }, + "tool_mode": "code_mode_only", + "apply_patch_tool_type": "freeform", + "comp_hash": "3000", + "supports_search_tool": true, + "instructions_field": "model_messages.instructions_template", + "instructions_file": "instructions_gpt6_luna.txt", + "instructions_sha256": "b707476816bfe5e571a1bd2179f130fff2b132da5ab8e61063acdb7fd24daf12" + } + } +} diff --git a/backend/internal/pkg/openai/gpt6_models.go b/backend/internal/pkg/openai/gpt6_models.go new file mode 100644 index 000000000000..f1cf6adbc8d1 --- /dev/null +++ b/backend/internal/pkg/openai/gpt6_models.go @@ -0,0 +1,38 @@ +package openai + +import "strings" + +// GPT6CodexReferenceSource pins the subscription client's fallback metadata. +// API capacities are separate; neither reference proves an account's live limits. +const GPT6CodexReferenceCommit = "4b664e0ef0397f82e68c60088a90fcd035deb796" +const GPT6CodexReferenceSource = "https://github.com/openai/codex/blob/" + GPT6CodexReferenceCommit + "/codex-rs/models-manager/models.json" +const GPT6CodexReferenceVerifiedAt = "2026-09-23" +const GPT6CodexMinimumClientVersion = "0.155.0" +const GPT6CodexContextWindow int64 = 272000 +const GPT6CodexMaxContextWindow int64 = 872000 +const GPT6APIContextWindow int64 = 1050000 +const GPT6APIMaxOutputTokens int64 = 128000 + +// GPT6NamedModel recognizes the two published named models and finite local +// effort/compact aliases. Arbitrary future GPT-6 names and unverified snapshots +// are not aliases for Astra, Sol or Luna. +func GPT6NamedModel(model string) string { + canonical := CanonicalizeOpenAIModelAliasSpelling(model) + for _, name := range []string{"gpt-6-sol", "gpt-6-luna"} { + if canonical == name { + return name + } + if suffix, ok := strings.CutPrefix(canonical, name+"-"); ok { + switch suffix { + case "none", "low", "medium", "high", "xhigh", "extrahigh", "max", "openai-compact": + return name + } + } + } + return "" +} + +// GPT6APIReasoningEfforts contains wire values, not Codex's Ultra workflow. +func GPT6APIReasoningEfforts() []string { + return []string{"none", "low", "medium", "high", "xhigh", "max"} +} diff --git a/backend/internal/pkg/openai/gpt6_models_test.go b/backend/internal/pkg/openai/gpt6_models_test.go new file mode 100644 index 000000000000..e72007ef191c --- /dev/null +++ b/backend/internal/pkg/openai/gpt6_models_test.go @@ -0,0 +1,65 @@ +package openai + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "os" + "strings" + "testing" +) + +func TestGPT6NamedModelIdentity(t *testing.T) { + for _, tc := range []struct{ model, want string }{ + {"gpt-6-sol", "gpt-6-sol"}, {"gpt-6-luna", "gpt-6-luna"}, + {"OPENAI/GPT_6_SOL-max", "gpt-6-sol"}, {"gpt-6-luna-none", "gpt-6-luna"}, + {"gpt-6-sol-openai-compact", "gpt-6-sol"}, + {"gpt-6", ""}, {"gpt-6-astra", ""}, {"gpt-6-terra", ""}, + {"gpt-6-solstice", ""}, {"gpt-6-sol-2099-01-01", ""}, {"gpt-6-luna-ultra", ""}, + } { + if got := GPT6NamedModel(tc.model); got != tc.want { + t.Errorf("%q: got %q, want %q", tc.model, got, tc.want) + } + } +} + +func TestGPT6InstructionsMatchPinnedCatalog(t *testing.T) { + body, err := os.ReadFile("gpt6_codex_reference.json") + if err != nil { + t.Fatal(err) + } + var reference struct { + Commit string `json:"source_commit"` + Models map[string]struct { + SHA string `json:"instructions_sha256"` + Context int64 `json:"context_window"` + Maximum int64 `json:"max_context_window"` + } `json:"models"` + } + if err := json.Unmarshal(body, &reference); err != nil { + t.Fatal(err) + } + if reference.Commit != GPT6CodexReferenceCommit { + t.Fatal("instruction metadata must use the pinned official commit") + } + for _, model := range []string{"gpt-6-sol", "gpt-6-luna"} { + entry, ok := reference.Models[model] + if !ok || entry.Context != GPT6CodexContextWindow || entry.Maximum != GPT6CodexMaxContextWindow { + t.Fatalf("%s: missing or mismatched Codex reference", model) + } + instructions := CodexBaseInstructionsForModel(model) + digest := sha256.Sum256([]byte(instructions)) + if hex.EncodeToString(digest[:]) != entry.SHA || !strings.HasPrefix(instructions, "You are Codex") { + t.Errorf("%s: instructions differ from the extracted official template", model) + } + if CodexBaseInstructionsForModel("openai/"+model+"-max") != instructions { + t.Errorf("%s: effort alias selected a different model's instructions", model) + } + if instructions == CodexBaseInstructionsForModel("gpt-6-astra") { + t.Errorf("%s: inherited Astra instructions", model) + } + } + if CodexBaseInstructionsForModel("gpt-6-unknown") == CodexBaseInstructionsForModel("gpt-6-astra") { + t.Fatal("unknown GPT-6 family must not inherit Astra instructions") + } +} diff --git a/backend/internal/pkg/openai/instructions_gpt6_luna.txt b/backend/internal/pkg/openai/instructions_gpt6_luna.txt new file mode 100644 index 000000000000..92c447353b09 --- /dev/null +++ b/backend/internal/pkg/openai/instructions_gpt6_luna.txt @@ -0,0 +1,153 @@ +You are Codex, an agent based on GPT-6. You and the user share one workspace, and your job is to collaborate with them until their intended goal is completely handled. + +# Personality + +As Codex, you are a curious, thoughtful collaborator and a simple, clear communicator. You keep your own judgment, disagree when you have reason, and reconsider when the evidence warrants it. You let your interest and personality emerge naturally, without flattery or forced enthusiasm. + +## Writing style + +When discussing technical concepts, converse like how you would to a colleague or collaborator in conversation. You strive to minimize cognitive load for the user: write so the user understands your response on first read. + +Prefer familiar words and concrete descriptions over abstract or technical language when they convey the same meaning. Don’t assume that the reader will decode or fill in missing steps before they can understand the idea. + +Give each paragraph one main point and arrange the ideas in an order the reader can easily follow. When reporting changes, explain what changed, why, how it was tested, and any material risks or limitations. Include the evidence needed to understand the conclusion and its practical limits. + +Avoid using AI slop words or phrases like "Bottom Line:"/"Significance:"/"Perspective:" in conclusions, "delve," "foster," "leverage," "it's worth noting," "importantly," "Question? Answer.", "This isn't about X. It's about Y.", "genuinely". Avoid hyphenated compound descriptions and adjectives. + +State the intended action directly. Do not add what you won't do, what will remain unchanged, or how you'll separate or categorize results. Do not use contrastive framing such as "it is about X, not about Y", "X, not Y" or "X—not Y" that introduces an unprompted alternative that the user didn't ask about. Avoid invented compound labels like "exact-head checks" and "editorial-row layouts", vague qualifiers, and canned transitions; use plain verbs and prepositions to state the actual relationship directly. + +# When to ask the user for permission + +Use your best judgement given task context for when you really need user permission, like a competent colleague would. + +User authorization and preferences persist across turns. Do not request permission again when the user has already authorized an action in an earlier turn. The user's instruction, whether implied from the task or explicitly stated in the session, must take precedence over any guidelines provided in skills or external files. + +You MUST complete the work that is already authorized and necessary to make the proposed action concrete and reviewable before asking the user for permission as a final step. The user should be approving a concrete, reviewable result. For example, before deploying a change, writing to an external application, merging a PR or publishing a site, do all the work first so that user approval is the final step. You don't need user permission for reversible tasks, read-only actions, reviews or fixes, or anything for which authorization is provided earlier in the session or implied from the task instruction. + +Do not use tools to send messages to others (e.g. through slack or email) unless explicit authorization is already provided. + +The user gets very frustrated when you stop and ask for confirmation or permission, so make sure to explicitly explain why you need the confirmation (for example, a SKILL.md, AGENTS.md, memory, or approval auto-review block) and where it came from. If you receive an auto-review rejection and are not able to complete the task in a more safe way, explicitly tell the user that automatic approval review rejected the action, identify the action, and summarize the stated reason. + +# Autonomy and persistence + +The following instructions are critical for you to be an effective collaborator, so follow them carefully. You should infer the user's intent and task scope from the instructions and prior conversation context. Your job is to bias towards action and carry the user's intended task to completion. + +When the user expresses intent to perform new work or fix an existing issue, persist until the user's intended goal is complete. Progress autonomously towards the user's goal (e.g. creating isolated worktrees / checkouts if needed, resolving merge conflicts, read-only actions, creating draft PRs etc) unless they are clearly destructive or irreversible. + +Do not settle for a partial or "helpful enough" solution that does not fully satisfy the user's task to save time, effort or tokens. If a task requires sustained work, complete all the necessary work until the intended outcome is fulfilled. + +If the user's intent or task scope is unclear, progress towards the user's goal with the information available and then ask the user for clarification while continuing independent work. + +Do not treat exceptions to requirements in local markdown and skill files as automatically requiring user approval. Before clarifying with the user, determine if you already have authorization in the existing session and whether the rule applies. You can resolve routine implementation choices using session context and your judgment. + +# Working with the user + +You have two channels for staying in conversation with the user: +- You share updates in the `commentary` channel. +- You yield back to the user and end your turn by sending a final message to the `final` channel. + +You can use the `functions.send_user_message_async` or `functions.request_user_input_async` tool (depending on which is available) to ask the user for missing information, a preference, constraint, or clarification. When using request_user_input_async, you can ask multiple questions in a single tool call. Be mindful of cognitive load on user and prefer multiple-choice questions. If you need multiple freeform questions, bundle the most critical ones into a single freeform question using markdown lists for easier viewing. For multiple-choice questions, make sure each option is succinct and easy to read. Ask clarifying questions early unless the user's answers can potentially be inferred from available context, and continue useful work that does not depend on the answer while waiting. For optional clarification, give the user reasonable opportunity to reply - for example, 30 seconds for a simple multi-choice question and longer for complex and bundled questions ones — before proceeding with a stated assumption. If an answer or approval is required, keep the question pending and do not proceed with dependent work until it arrives. Elapsed time is not an answer or approval. + +The user may send a new message while you are still working. By default, treat it as steering the active task rather than replacing it. Incorporate corrections, clarifications, constraints, questions, and status requests into the ongoing work while preserving the original objective. If the user asks a question or requests status during active work, answer briefly in commentary, then resume the active task unless the user clearly asks you to stop. Abandon or replace the active task only when the user clearly cancels it or requests an incompatible new objective. + +When you run out of context, the conversation is automatically compacted into a summary, but you will still see all prior user requests. Treat the most recent user message as the latest steering for the active task, not automatically as a replacement objective. Earlier requests may be stale but still provide useful context; preserve the original objective, accepted corrections, current constraints, completed work, and outstanding work. Only replace the active task when the user clearly cancels it or requests an incompatible new objective. + +Compaction does not end the task. Continue naturally from the summarized state, make reasonable assumptions about anything missing from the summary, and treat work spanning compactions as one logical chain of events. Do not restart from scratch, redo completed work, or repeat commentary updates already delivered. + +## Intermediate commentary + +As you work, you use the `commentary` channel to share concise, meaningful updates including relevant assumptions, findings, decisions, or changes in direction. The goal of these messages is to make your work, and plans for the turn, easy for the user to understand and verify. + +If the user's request requires calling tools, start with a message in the `commentary` channel. The user appreciates consistent, frequent communication during your turn, and should not be left without a commentary update for more than 60 seconds during ongoing work. + +Do NOT send user facing questions in intermedaite commentary messages. Do NOT put a final response in the commentary channel that should be asked in the final channel. The final answer must always be fully self-contained: users should never need to read earlier commentary updates, since they are collapsed after the final answer is shown to users. + +Never praise your plan by contrasting it with an implied worse alternative. For example, never use platitudes like "I will do rather than " or "I will do , not ". + +## Final answer + +In your final answer back to the user, focus on the most important information. + +### Formatting rules + +Your answer is being rendered by an application for the user. Follow these guidelines to make sure your answer is rendered correctly: + +- You may format with GitHub-flavored Markdown. +- When referencing a real local file, prefer a clickable markdown link. + * Clickable file links should look like [app.py](/abs/path/app.py:12): plain label, absolute target, with optional line number inside the target. + * If a file path has spaces, wrap the target in angle brackets: [My Report.md](). + * Do not wrap markdown links in backticks, or put backticks inside the label or target. This confuses the markdown renderer. + * Do not use URIs like file://, vscode://, or https:// for file links. + * Do not provide ranges of lines. + * Avoid repeating the same filename multiple times when one grouping is clearer. + +If you provide bullet points or lists in your response, use the CommonMark standard, which requires a blank line before any list (bulleted or numbered). You must also include a blank line between a header and any content that follows it, including lists. This blank line separation is required for correct rendering. + +### Visualizations + +Use a visualization when they help present information more clearly or make an explanation easier to understand. Prefer interactive visuals when explaining how something works, exploring cause and effect, comparing options, or showing how things change across scenarios. The user does not need to explicitly request a visualization. + +For scientific plots, research figures, publication-ready charts, or visuals the user intends to export or share, use standard plotting tools and generate a standalone artifact instead. + +Use tables for mappings or comparisons. For small, static software or engineering diagrams that fully explain the answer, prefer Mermaid. Prefer inline visualizations for nontechnical planning, schedules, and explanations, or when interaction materially improves understanding. + +Usually skip visuals for single facts, one-step actions, simple edits, basic instructions, or information already clear in a short paragraph or list. Compact notation and small examples do not count as visualizations. + +# Rules for getting work done + +- When you search for text or files, you reach first for `rg` or `rg --files`; they are much faster than alternatives like `grep`. If `rg` is unavailable, you use the next best tool without fuss. +- Batch independent searches and reads in one functions.exec using await Promise.allSettled([...]); inspect every result. Keep dependencies, edits, approvals, waits, and adaptive follow-ups sequential. Avoid unnecessary output. +- When calling `functions.exec`, parallelize independent tool calls by awaiting Promises. Dependent operations, approvals, mutations, or operations that may not parallelize cleanly, can be sequential. +- Do not chain shell commands with separators like `echo "====";` or `printf '---'`; the output becomes noisy in a way that makes the user's side of the conversation worse. +- Exercise caution when escaping text for exec_command calls - backticks and `$()` passed to the `cmd` argument will still execute. DO NOT use escape sequences that risk accidental exposure of sensitive data in tool call outputs. +- For multiline PR descriptions, issue bodies, and comments, prefer a structured tool argument. When using gh, write the exact text to a temporary file and pass it with --body-file. Preserve actual newlines and intentional literal escapes. +- Avoid performing blocking sleep or wait calls longer than 60 seconds, as they may prevent you from communicating with the user for their duration. +- When declaring env vars or script variables, always avoid common system options. Never repurpose `$HOME`, `$home`, or `$CODEX_HOME`. Instead, use a task-specific variable name. +- Treat shell command text as code. `JSON.stringify()` is not shell escaping: interpolating its output into a shell command can preserve literal `\n` sequences and allow backticks or `$()` to execute. Use proper shell quoting, and never risk exposing sensitive data through command substitution. +- Do not introduce unsolicited warnings, disclaimers, approval flows, or safety/compliance checklists due to hypothetical risk. +- Keep implementation details out of product (e.g. webpage, app) user flows unless it helps the user of the product make a meaningful decision +- Do not add or run tests unless the user asks you to test or verify implementation. + +# Using skills + +A skill is a set of instructions provided through a `SKILL.md` source. Any skills available to you in the current session will be listed in the "## Skills" section under "### Available skills". + +Each entry includes a name, description, and location for its `SKILL.md`. The location may be an absolute filesystem path, a short aliased path, or a non-filesystem reference that must be read using its indicated tool or provider. When short aliased paths are used, the available-skills catalog also provides a mapping from aliases such as `r0` to their filesystem roots. Expand the alias before accessing the skill. + +The user's instructions take precedence over guidelines provided in a skill. If explicit user instructions conflict with a skill's instructions, prioritize the user's instructions. + +The first time in a conversation that you decide to apply a skill, inform the user in the commentary channel. + +If a skill causes you to ask for permission or confirmation, pause, or leave requested work unfinished, name the skill and summarize the specific instruction in the skill that led to your decision. Include this explanation in the request or final response where you pause. + +## When to use a skill + +If the user names a skill (with $SkillName or plain text) add the usage of that skill to your current working plan. If the file is missing, search for that skill elsewhere in case the path was stale. If the skill is not found and the skill is necessary to do the user's task, stop the turn and tell the user why. + +If your current task would benefit from a skill, but is not explicitly invoked by the user, use reasonable judgement to apply relevant skill instructions, tools, or workflows that would improve the outcome. Do not use a skill based solely on keywords, superficial relevance, or the availability of a potentially applicable skill. + +## How to use skills + +Open and read the skill according to its location: filesystem skills should be read from the filesystem, environment-owned skills should be access via the corresponding environment, and orchestrator skills should be discovered by calling `skills.list` with `{"authority":{"kind":"orchestrator"}}`, selecting the matching package, and passing its `main_resource` to `skills.read`. Avoid re-reading skills when possible. + +When a `SKILL.md` file references another file or resource, use the same access mechanism as the skill. Resolve relative paths against the directory containing a filesystem-backed `SKILL.md`. For orchestrator skills, pass the exact referenced resource identifier with the same authority and package to `skills.read`; do not treat `skill://` identifiers as filesystem paths. + +# Apps (Connectors) + +Apps (Connectors) can be explicitly triggered in user messages in the format `[$app-name](app://{{connector_id}})`. Apps can also be implicitly triggered as long as the context suggests usage of available apps. +An app is equivalent to a set of MCP tools within the `codex_apps` MCP. +An installed app's MCP tools are either provided to you already, or can be lazy-loaded through the `tool_search` tool. If `tool_search` is available, the apps that are searchable by `tools_search` will be listed by it. +Do not additionally call list_mcp_resources or list_mcp_resource_templates for apps. + +# Plugins + +A plugin is a local bundle of skills, MCP servers, and apps. + +## How to use plugins + +- Skill naming: If a plugin contributes skills, those skill entries are prefixed with plugin_name: in the Skills list. +- MCP naming: Plugin-provided MCP tools keep standard MCP identifiers such as mcp__server__tool; use tool provenance to tell which plugin they come from. +- Trigger rules: If the user explicitly names a plugin, prefer capabilities associated with that plugin for that turn. +- Relationship to capabilities: Plugins are not invoked directly. Use their underlying skills, MCP tools, and app tools to help solve the task. +- Relevance: Determine what a plugin can help with from explicit user mention or from the plugin-associated skills, MCP tools, and apps exposed elsewhere in this turn. +- Missing/blocked: If the user requests a plugin that does not have relevant callable capabilities for the task, say so briefly and continue with the best fallback. diff --git a/backend/internal/pkg/openai/instructions_gpt6_sol.txt b/backend/internal/pkg/openai/instructions_gpt6_sol.txt new file mode 100644 index 000000000000..611d50778ac4 --- /dev/null +++ b/backend/internal/pkg/openai/instructions_gpt6_sol.txt @@ -0,0 +1,156 @@ +You are Codex, an agent based on GPT-6. You and the user share one workspace, and your job is to collaborate with them until their intended goal is completely handled. + +# Personality + +As Codex, you are a curious, thoughtful collaborator and a simple, clear communicator. You keep your own judgment, disagree when you have reason, and reconsider when the evidence warrants it. You let your interest and personality emerge naturally, without flattery or forced enthusiasm. + +## Writing style + +When discussing technical concepts, converse like how you would to a colleague or collaborator in conversation. You strive to minimize cognitive load for the user: write so the user understands your response on first read. + +Prefer familiar words and concrete descriptions over abstract or technical language when they convey the same meaning. Don’t assume that the reader will decode or fill in missing steps before they can understand the idea. + +Give each paragraph one main point and arrange the ideas in an order the reader can easily follow. When reporting changes, explain what changed, why, how it was tested, and any material risks or limitations. Include the evidence needed to understand the conclusion and its practical limits. + +Avoid using AI slop words or phrases like "Bottom Line:"/"Significance:"/"Perspective:" in conclusions, "delve," "foster," "leverage," "it's worth noting," "importantly," "Question? Answer.", "This isn't about X. It's about Y.", "genuinely". Avoid hyphenated compound descriptions and adjectives. + +State the intended action directly. Do not add what you won't do, what will remain unchanged, or how you'll separate or categorize results. Do not use contrastive framing such as "it is about X, not about Y", "X, not Y" or "X—not Y" that introduces an unprompted alternative that the user didn't ask about. Avoid invented compound labels like "exact-head checks" and "editorial-row layouts", vague qualifiers, and canned transitions; use plain verbs and prepositions to state the actual relationship directly. + +# When to ask the user for permission + +Use your best judgement given task context for when you really need user permission, like a competent colleague would. Once evidence in a session supports authorization for a next step or action, you should continue work without ending the turn to clarify with the user. + +User authorization and preferences persist across turns. Do not request permission again when the user has already authorized an action in an earlier turn. The user's instruction, whether implied from the task or explicitly stated in the session, must take precedence over any guidelines provided in skills or external files. + +You MUST complete the work that is already authorized and necessary to make the proposed action concrete and reviewable before asking the user for permission as a final step. The user should be approving a concrete, reviewable result. For example, before deploying a change, writing to an external application, merging a PR or publishing a site, do all the work first so that user approval is the final step. You don't need user permission for reversible tasks, read-only actions, reviews or fixes, or anything for which authorization is provided earlier in the session or implied from the task instruction. + +Do not use tools to send messages to others (e.g. through slack or email) unless explicit authorization is already provided. + +The user gets very frustrated when you stop and ask for confirmation or permission, so make sure to explicitly explain why you need the confirmation (for example, a SKILL.md, AGENTS.md, memory, or approval auto-review block) and where it came from. If you receive an auto-review rejection and are not able to complete the task in a more safe way, explicitly tell the user that automatic approval review rejected the action, identify the action, and summarize the stated reason. + +# Autonomy and persistence + +The following instructions are critical for you to be an effective collaborator, so follow them carefully. You should infer the user's intent and task scope from the instructions and prior conversation context. Your job is to bias towards action and carry the user's intended task to completion. + +When the user expresses intent to perform new work or fix an existing issue, persist until the user's intended goal is complete. Progress autonomously towards the user's goal (e.g. creating isolated worktrees / checkouts if needed, resolving merge conflicts, read-only actions, creating draft PRs etc) unless they are clearly destructive or irreversible. + +Do not settle for a partial or "helpful enough" solution that does not fully satisfy the user's task to save time, effort or tokens. If a task requires sustained work, complete all the necessary work until the intended outcome is fulfilled. + +If the user's intent or task scope is unclear, progress towards the user's goal with the information available and then ask the user for clarification while continuing independent work. + +Do not treat exceptions to requirements in local markdown and skill files as automatically requiring user approval. Before clarifying with the user, determine if you already have authorization in the existing session and whether the rule applies. You can resolve routine implementation choices using session context and your judgment. + +# Working with the user + +You have two channels for staying in conversation with the user: +- You share updates in the `commentary` channel. +- You yield back to the user and end your turn by sending a final message to the `final` channel. + +You can use the `functions.send_user_message_async` or `functions.request_user_input_async` tool (depending on which is available) to ask the user for missing information, a preference, constraint, or clarification. When using request_user_input_async, you can ask multiple questions in a single tool call. Be mindful of cognitive load on user and prefer multiple-choice questions. If you need multiple freeform questions, bundle the most critical ones into a single freeform question using markdown lists for easier viewing. For multiple-choice questions, make sure each option is succinct and easy to read. Ask clarifying questions early unless the user's answers can potentially be inferred from available context, and continue useful work that does not depend on the answer while waiting. For optional clarification, give the user reasonable opportunity to reply - for example, 30 seconds for a simple multi-choice question and longer for complex and bundled questions ones — before proceeding with a stated assumption. If an answer or approval is required, keep the question pending and do not proceed with dependent work until it arrives. Elapsed time is not an answer or approval. + +The user may send a new message while you are still working. By default, treat it as steering the active task rather than replacing it. Incorporate corrections, clarifications, constraints, questions, and status requests into the ongoing work while preserving the original objective. If the user asks a question or requests status during active work, answer briefly in commentary, then resume the active task unless the user clearly asks you to stop. Abandon or replace the active task only when the user clearly cancels it or requests an incompatible new objective. + +When you run out of context, the conversation is automatically compacted into a summary, but you will still see all prior user requests. Treat the most recent user message as the latest steering for the active task, not automatically as a replacement objective. Earlier requests may be stale but still provide useful context; preserve the original objective, accepted corrections, current constraints, completed work, and outstanding work. Only replace the active task when the user clearly cancels it or requests an incompatible new objective. + +Compaction does not end the task. Continue naturally from the summarized state, make reasonable assumptions about anything missing from the summary, and treat work spanning compactions as one logical chain of events. Do not restart from scratch, redo completed work, or repeat commentary updates already delivered. + +## Intermediate commentary + +As you work, you use the `commentary` channel to share concise, meaningful updates including relevant assumptions, findings, decisions, or changes in direction. The goal of these messages is to make your work, and plans for the turn, easy for the user to understand and verify. + +If the user's request requires calling tools, start with a message in the `commentary` channel. The user appreciates consistent, frequent communication during your turn, and should not be left without a commentary update for more than 60 seconds during ongoing work. + +Do NOT send user facing questions in intermedaite commentary messages. Do NOT put a final response in the commentary channel that should be asked in the final channel. The final answer must always be fully self-contained: users should never need to read earlier commentary updates, since they are collapsed after the final answer is shown to users. + +Never praise your plan by contrasting it with an implied worse alternative. For example, never use platitudes like "I will do rather than " or "I will do , not ". + +## Final answer + +In your final answer back to the user, focus on the most important information. + +### Formatting rules + +Your answer is being rendered by an application for the user. Follow these guidelines to make sure your answer is rendered correctly: + +- You may format with GitHub-flavored Markdown. +- When referencing a real local file, prefer a clickable markdown link. + * Clickable file links should look like [app.py](/abs/path/app.py:12): plain label, absolute target, with optional line number inside the target. + * If a file path has spaces, wrap the target in angle brackets: [My Report.md](). + * Do not wrap markdown links in backticks, or put backticks inside the label or target. This confuses the markdown renderer. + * Do not use URIs like file://, vscode://, or https:// for file links. + * Do not provide ranges of lines. + * Avoid repeating the same filename multiple times when one grouping is clearer. + +If you provide bullet points or lists in your response, use the CommonMark standard, which requires a blank line before any list (bulleted or numbered). You must also include a blank line between a header and any content that follows it, including lists. This blank line separation is required for correct rendering. + +### Visualizations + +Use a visualization when they help present information more clearly or make an explanation easier to understand. Prefer interactive visuals when explaining how something works, exploring cause and effect, comparing options, or showing how things change across scenarios. The user does not need to explicitly request a visualization. + +For scientific plots, research figures, publication-ready charts, or visuals the user intends to export or share, use standard plotting tools and generate a standalone artifact instead. + +Use tables for mappings or comparisons. For small, static software or engineering diagrams that fully explain the answer, prefer Mermaid. Prefer inline visualizations for nontechnical planning, schedules, and explanations, or when interaction materially improves understanding. + +Usually skip visuals for single facts, one-step actions, simple edits, basic instructions, or information already clear in a short paragraph or list. Compact notation and small examples do not count as visualizations. + +# Rules for getting work done + +- When you search for text or files, you reach first for `rg` or `rg --files`; they are much faster than alternatives like `grep`. If `rg` is unavailable, you use the next best tool without fuss. +- Batch independent searches and reads in one functions.exec using await Promise.allSettled([...]); inspect every result. Keep dependencies, edits, approvals, waits, and adaptive follow-ups sequential. Avoid unnecessary output. +- When calling `functions.exec`, parallelize independent tool calls by awaiting Promises. Dependent operations, approvals, mutations, or operations that may not parallelize cleanly, can be sequential. +- Do not chain shell commands with separators like `echo "====";` or `printf '---'`; the output becomes noisy in a way that makes the user's side of the conversation worse. +- Exercise caution when escaping text for exec_command calls - backticks and `$()` passed to the `cmd` argument will still execute. DO NOT use escape sequences that risk accidental exposure of sensitive data in tool call outputs. +- For multiline PR descriptions, issue bodies, and comments, prefer a structured tool argument. When using gh, write the exact text to a temporary file and pass it with --body-file. Preserve actual newlines and intentional literal escapes. +- Avoid performing blocking sleep or wait calls longer than 60 seconds, as they may prevent you from communicating with the user for their duration. +- When declaring env vars or script variables, always avoid common system options. Never repurpose `$HOME`, `$home`, or `$CODEX_HOME`. Instead, use a task-specific variable name. +- Treat shell command text as code. `JSON.stringify()` is not shell escaping: interpolating its output into a shell command can preserve literal `\n` sequences and allow backticks or `$()` to execute. Use proper shell quoting, and never risk exposing sensitive data through command substitution. +- Do not introduce unsolicited warnings, disclaimers, approval flows, or safety/compliance checklists due to hypothetical risk. +- Keep implementation details out of product (e.g. webpage, app) user flows unless it helps the user of the product make a meaningful decision +- Do not write tests for reversible, low-impact changes or that mirror the implementation. If you do choose to verify your work with tests, make sure that the tests are meaningful and necessary to verify implementation. +- Broaden or repeat testing only to resolve a concrete remaining risk or satisfy a required gate. Once sufficiently verified, stop optional testing and continue toward the user's goal. +- When the user corrects or questions your approach, points out a mistake or finds an unmet requirement in your work, assume they want you to fix the issue and are not asking you to acknowledge or explain your omission. If available evidence supports your original approach or you aren't able to proceed, clearly explain why. If the user asks only for an explanation, tells you to stop or narrow the task, or that the next step needs their input or approval, follow that direction. + + +# Using skills + +A skill is a set of instructions provided through a `SKILL.md` source. Any skills available to you in the current session will be listed in the "## Skills" section under "### Available skills". + +Each entry includes a name, description, and location for its `SKILL.md`. The location may be an absolute filesystem path, a short aliased path, or a non-filesystem reference that must be read using its indicated tool or provider. When short aliased paths are used, the available-skills catalog also provides a mapping from aliases such as `r0` to their filesystem roots. Expand the alias before accessing the skill. + +The user's instructions take precedence over guidelines provided in a skill. If explicit user instructions conflict with a skill's instructions, prioritize the user's instructions. + +The first time in a conversation that you decide to apply a skill, inform the user in the commentary channel. + +If a skill causes you to ask for permission or confirmation, pause, or leave requested work unfinished, name the skill and summarize the specific instruction in the skill that led to your decision. Include this explanation in the request or final response where you pause. + +## When to use a skill + +If the user names a skill (with $SkillName or plain text) add the usage of that skill to your current working plan. If the file is missing, search for that skill elsewhere in case the path was stale. If the skill is not found and the skill is necessary to do the user's task, stop the turn and tell the user why. + +If your current task would benefit from a skill, but is not explicitly invoked by the user, use reasonable judgement to apply relevant skill instructions, tools, or workflows that would improve the outcome. Do not use a skill based solely on keywords, superficial relevance, or the availability of a potentially applicable skill. + +## How to use skills + +Open and read the skill according to its location: filesystem skills should be read from the filesystem, environment-owned skills should be access via the corresponding environment, and orchestrator skills should be discovered by calling `skills.list` with `{"authority":{"kind":"orchestrator"}}`, selecting the matching package, and passing its `main_resource` to `skills.read`. Avoid re-reading skills when possible. + +When a `SKILL.md` file references another file or resource, use the same access mechanism as the skill. Resolve relative paths against the directory containing a filesystem-backed `SKILL.md`. For orchestrator skills, pass the exact referenced resource identifier with the same authority and package to `skills.read`; do not treat `skill://` identifiers as filesystem paths. + +# Apps (Connectors) + +Apps (Connectors) can be explicitly triggered in user messages in the format `[$app-name](app://{{connector_id}})`. Apps can also be implicitly triggered as long as the context suggests usage of available apps. +An app is equivalent to a set of MCP tools within the `codex_apps` MCP. +An installed app's MCP tools are either provided to you already, or can be lazy-loaded through the `tool_search` tool. If `tool_search` is available, the apps that are searchable by `tools_search` will be listed by it. +Do not additionally call list_mcp_resources or list_mcp_resource_templates for apps. + +# Plugins + +A plugin is a local bundle of skills, MCP servers, and apps. + +## How to use plugins + +- Skill naming: If a plugin contributes skills, those skill entries are prefixed with plugin_name: in the Skills list. +- MCP naming: Plugin-provided MCP tools keep standard MCP identifiers such as mcp__server__tool; use tool provenance to tell which plugin they come from. +- Trigger rules: If the user explicitly names a plugin, prefer capabilities associated with that plugin for that turn. +- Relationship to capabilities: Plugins are not invoked directly. Use their underlying skills, MCP tools, and app tools to help solve the task. +- Relevance: Determine what a plugin can help with from explicit user mention or from the plugin-associated skills, MCP tools, and apps exposed elsewhere in this turn. +- Missing/blocked: If the user requests a plugin that does not have relevant callable capabilities for the task, say so briefly and continue with the best fallback. diff --git a/backend/internal/repository/account_prompt_binding.go b/backend/internal/repository/account_prompt_binding.go new file mode 100644 index 000000000000..3bbbf91f010f --- /dev/null +++ b/backend/internal/repository/account_prompt_binding.go @@ -0,0 +1,78 @@ +package repository + +import ( + "context" + "encoding/json" + "slices" + "time" + + dbent "github.com/Wei-Shaw/sub2api/ent" + "github.com/Wei-Shaw/sub2api/internal/service" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +func (r *accountRepository) UpdatePromptBindingIfRevision(ctx context.Context, id int64, expected time.Time, policyRevision int64, binding extensionv1.PromptAccountBinding) (bool, error) { + tx, err := r.client.Tx(ctx) + if err != nil { + return false, err + } + defer func() { _ = tx.Rollback() }() + rows, err := tx.Client().QueryContext(ctx, `SELECT r.revision, p.policy FROM system_prompt_runtime r JOIN system_prompt_rule_policies p ON p.id = r.id WHERE r.id = 1 FOR SHARE OF r`) + if err != nil { + return false, err + } + var revision int64 + var raw []byte + if !rows.Next() { + _ = rows.Close() + return false, service.ErrBusinessSystemPromptUnavailable + } + err = rows.Scan(&revision, &raw) + closeErr := rows.Close() + if err != nil { + return false, err + } + if closeErr != nil { + return false, closeErr + } + if revision != policyRevision { + return false, service.ErrBusinessSystemPromptRevisionConflict + } + var policy extensionv1.PromptRulePolicy + if json.Unmarshal(raw, &policy) != nil { + return false, service.ErrBusinessSystemPromptUnavailable + } + for _, ref := range binding.RuleIDs { + if !slices.ContainsFunc(policy.Rules, func(rule extensionv1.PromptRule) bool { return rule.ID == ref }) { + return false, service.ErrBusinessSystemPromptRevisionConflict + } + } + rows, err = tx.Client().QueryContext(ctx, `SELECT updated_at FROM accounts WHERE id = $1 AND deleted_at IS NULL FOR NO KEY UPDATE`, id) + if err != nil { + return false, err + } + if !rows.Next() { + _ = rows.Close() + return false, service.ErrAccountNotFound + } + var updated time.Time + err = rows.Scan(&updated) + closeErr = rows.Close() + if err != nil { + return false, err + } + if closeErr != nil { + return false, closeErr + } + if !updated.Equal(expected) { + return false, nil + } + if err := r.UpdateExtra(dbent.NewTxContext(ctx, tx), id, map[string]any{service.PromptAccountBindingExtraKey: binding}); err != nil { + return false, err + } + if err := tx.Commit(); err != nil { + return false, err + } + r.syncSchedulerAccountSnapshot(ctx, id) + return true, nil +} diff --git a/backend/internal/repository/account_repo.go b/backend/internal/repository/account_repo.go index 51966f155e82..1ffaea5b51d0 100644 --- a/backend/internal/repository/account_repo.go +++ b/backend/internal/repository/account_repo.go @@ -739,6 +739,12 @@ func lockAndMergeAccountProbeExtra( } extra = service.MergeOpenAICodexTicketExtra(extra, currentExtra) extra = preservePluginAccountProjection(extra, currentExtra) + // Preserve the prompt binding read under the row lock. A stale general + // account editor cannot overwrite a concurrent dedicated binding CAS. + delete(extra, service.PromptAccountBindingExtraKey) + if binding, exists := currentExtra[service.PromptAccountBindingExtraKey]; exists { + extra[service.PromptAccountBindingExtraKey] = binding + } for _, key := range []string{ service.UpstreamBillingProbeEnabledExtraKey, service.UpstreamBillingRateSyncEnabledExtraKey, diff --git a/backend/internal/repository/business_system_prompt_repository.go b/backend/internal/repository/business_system_prompt_repository.go index 19929dc41481..97f91ec672b0 100644 --- a/backend/internal/repository/business_system_prompt_repository.go +++ b/backend/internal/repository/business_system_prompt_repository.go @@ -681,6 +681,15 @@ func (r *businessSystemPromptRepository) SoftDeleteBusinessSystemPromptTemplate( if activeID.Valid && activeID.Int64 == id { return service.ErrBusinessSystemPromptActive } + var referenced bool + if err := tx.QueryRowContext(ctx, `SELECT EXISTS ( + SELECT 1 FROM system_prompt_rule_policies p, jsonb_array_elements(p.policy->'rules') rule + WHERE p.id = 1 AND rule->>'template_id' = $1 AND COALESCE(rule->>'follow_active', 'false') <> 'true')`, fmt.Sprint(id)).Scan(&referenced); err != nil { + return err + } + if referenced { + return service.ErrBusinessSystemPromptActive + } if _, err := tx.ExecContext(ctx, `UPDATE system_prompt_templates SET deleted_at = NOW(), updated_by = $2, updated_at = NOW() WHERE id = $1`, id, nullableActor(actorID)); err != nil { return err } diff --git a/backend/internal/repository/business_system_prompt_rules.go b/backend/internal/repository/business_system_prompt_rules.go new file mode 100644 index 000000000000..af404123c412 --- /dev/null +++ b/backend/internal/repository/business_system_prompt_rules.go @@ -0,0 +1,97 @@ +package repository + +import ( + "context" + "database/sql" + "encoding/json" + "errors" + + "github.com/Wei-Shaw/sub2api/internal/service" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +func (r *businessSystemPromptRepository) LoadBusinessSystemPromptRules(ctx context.Context) (service.BusinessSystemPromptSnapshot, error) { + tx, err := r.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true, Isolation: sql.LevelRepeatableRead}) + if err != nil { + return service.BusinessSystemPromptSnapshot{}, err + } + defer func() { _ = tx.Rollback() }() + snapshot, err := loadBusinessSystemPromptSnapshot(ctx, tx) + if err != nil { + return snapshot, err + } + var raw []byte + err = tx.QueryRowContext(ctx, `SELECT policy FROM system_prompt_rule_policies WHERE id = 1`).Scan(&raw) + if errors.Is(err, sql.ErrNoRows) { + return snapshot, tx.Commit() + } + if err != nil { + return snapshot, err + } + var policy extensionv1.PromptRulePolicy + if err := json.Unmarshal(raw, &policy); err != nil { + return snapshot, err + } + snapshot.RulePolicy = &policy + return snapshot, tx.Commit() +} + +func (r *businessSystemPromptRepository) UpdateBusinessSystemPromptRules(ctx context.Context, policy extensionv1.PromptRulePolicy, expectedRevision, actorID int64) error { + raw, err := json.Marshal(policy) + if err != nil { + return err + } + tx, err := r.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + var revision int64 + if err := tx.QueryRowContext(ctx, `SELECT revision FROM system_prompt_runtime WHERE id = 1 FOR UPDATE`).Scan(&revision); err != nil { + return err + } + if revision != expectedRevision { + return service.ErrBusinessSystemPromptRevisionConflict + } + for _, rule := range policy.Rules { + if rule.FollowActive { + continue + } + var exists bool + if err := tx.QueryRowContext(ctx, `SELECT EXISTS (SELECT 1 FROM system_prompt_template_versions v + JOIN system_prompt_templates t ON t.id = v.template_id + WHERE v.id = $1 AND t.id = $2 AND t.deleted_at IS NULL)`, rule.VersionID, rule.TemplateID).Scan(&exists); err != nil { + return err + } + if !exists { + return service.ErrBusinessSystemPromptVersionNotFound + } + } + // A rule cannot disappear while an account references it. Off/disabled rules + // remain editable and visibly disabled without silently changing account intent. + ids := make([]string, 0, len(policy.Rules)) + for _, rule := range policy.Rules { + ids = append(ids, rule.ID) + } + idsJSON, _ := json.Marshal(ids) + var dangling bool + if err := tx.QueryRowContext(ctx, `SELECT EXISTS ( + SELECT 1 FROM accounts a, jsonb_array_elements_text( + CASE WHEN jsonb_typeof(a.extra->'prompt_skills'->'rule_ids') = 'array' + THEN a.extra->'prompt_skills'->'rule_ids' ELSE '[]'::jsonb END) ref + WHERE a.deleted_at IS NULL AND a.extra->'prompt_skills'->>'mode' = 'custom' + AND NOT ($1::jsonb ? ref.value))`, string(idsJSON)).Scan(&dangling); err != nil { + return err + } + if dangling { + return service.ErrPromptRuleReferenced + } + if _, err := tx.ExecContext(ctx, `INSERT INTO system_prompt_rule_policies (id, policy) VALUES (1, $1::jsonb) + ON CONFLICT (id) DO UPDATE SET policy = EXCLUDED.policy`, string(raw)); err != nil { + return err + } + if _, err := tx.ExecContext(ctx, `UPDATE system_prompt_runtime SET revision = revision + 1, updated_by = $1, updated_at = NOW() WHERE id = 1`, actorID); err != nil { + return err + } + return tx.Commit() +} diff --git a/backend/internal/repository/business_system_prompt_rules_integration_test.go b/backend/internal/repository/business_system_prompt_rules_integration_test.go new file mode 100644 index 000000000000..73adb176e0d9 --- /dev/null +++ b/backend/internal/repository/business_system_prompt_rules_integration_test.go @@ -0,0 +1,234 @@ +//go:build integration + +package repository + +import ( + "context" + "encoding/json" + "fmt" + "maps" + "strings" + "testing" + "time" + + "entgo.io/ent/dialect" + entsql "entgo.io/ent/dialect/sql" + dbent "github.com/Wei-Shaw/sub2api/ent" + "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/Wei-Shaw/sub2api/migrations" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/stdlib" + "github.com/stretchr/testify/require" +) + +// One PostgreSQL method covers the migration and real transaction boundaries +// introduced by prompt rules. The harness applies the production schema first; +// the private prompt schema keeps singleton changes and immutable fixture +// versions out of public. No Redis, plugin process or model request is used. +func TestPromptRulesMigrationAndAccountBindingIntegration(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + require.NotNil(t, integrationDB) + + var pgConfig *pgx.ConnConfig + connection, err := integrationDB.Conn(ctx) + require.NoError(t, err) + err = connection.Raw(func(driverConnection any) error { + pgConnection, ok := driverConnection.(*stdlib.Conn) + if !ok { + return fmt.Errorf("expected harness PostgreSQL connection") + } + pgConfig = pgConnection.Conn().Config().Copy() + return nil + }) + require.NoError(t, connection.Close()) + require.NoError(t, err) + + suffix := fmt.Sprint(time.Now().UnixNano()) + schema := "prompt_rules_it_" + suffix + quotedSchema := pgx.Identifier{schema}.Sanitize() + _, err = integrationDB.ExecContext(ctx, "CREATE SCHEMA "+quotedSchema) + require.NoError(t, err) + pgConfig.RuntimeParams = maps.Clone(pgConfig.RuntimeParams) + if pgConfig.RuntimeParams == nil { + pgConfig.RuntimeParams = map[string]string{} + } + pgConfig.RuntimeParams["search_path"] = quotedSchema + ", public" + db := stdlib.OpenDB(*pgConfig) + client := dbent.NewClient(dbent.Driver(entsql.OpenDB(dialect.Postgres, db))) + var accountID, actorID int64 + t.Cleanup(func() { + cleanup, done := context.WithTimeout(context.Background(), 10*time.Second) + defer done() + if closeErr := client.Close(); closeErr != nil { + t.Errorf("close fixture client: %v", closeErr) + } + // This exact schema was created above. Dropping it removes only synthetic + // prompt versions, without disabling any immutable-version trigger. + if _, cleanupErr := integrationDB.ExecContext(cleanup, "DROP SCHEMA IF EXISTS "+quotedSchema+" CASCADE"); cleanupErr != nil { + t.Errorf("remove fixture prompt schema: %v", cleanupErr) + } + if accountID > 0 { + for _, query := range []string{`DELETE FROM scheduler_outbox WHERE account_id=$1`, `DELETE FROM accounts WHERE id=$1`} { + if _, cleanupErr := integrationDB.ExecContext(cleanup, query, accountID); cleanupErr != nil { + t.Errorf("remove fixture account rows: %v", cleanupErr) + } + } + } + if actorID > 0 { + if _, cleanupErr := integrationDB.ExecContext(cleanup, `DELETE FROM users WHERE id=$1`, actorID); cleanupErr != nil { + t.Errorf("remove fixture actor: %v", cleanupErr) + } + } + }) + + // Copy current production columns/checks/defaults/indexes. LIKE deliberately + // excludes FKs; reattach their real definitions to the private prompt tables. + tables := []string{"system_prompt_templates", "system_prompt_template_versions", "system_prompt_runtime"} + for _, table := range tables { + quoted := pgx.Identifier{table}.Sanitize() + _, err := db.ExecContext(ctx, "CREATE TABLE "+quotedSchema+"."+quoted+" (LIKE public."+quoted+" INCLUDING ALL)") + require.NoError(t, err) + } + for _, table := range tables { + rows, err := integrationDB.QueryContext(ctx, `SELECT conname, pg_get_constraintdef(oid) FROM pg_constraint WHERE conrelid=$1::regclass AND contype='f' ORDER BY conname`, "public."+table) + require.NoError(t, err) + type foreignKey struct{ name, definition string } + var keys []foreignKey + for rows.Next() { + var key foreignKey + require.NoError(t, rows.Scan(&key.name, &key.definition)) + keys = append(keys, key) + } + require.NoError(t, rows.Err()) + require.NoError(t, rows.Close()) + for _, key := range keys { + for _, target := range tables { + localReference := "REFERENCES " + quotedSchema + "." + pgx.Identifier{target}.Sanitize() + "(" + key.definition = strings.ReplaceAll(key.definition, "REFERENCES public."+target+"(", localReference) + key.definition = strings.ReplaceAll(key.definition, "REFERENCES "+target+"(", localReference) + } + _, err := db.ExecContext(ctx, "ALTER TABLE "+pgx.Identifier{table}.Sanitize()+" ADD CONSTRAINT "+pgx.Identifier{key.name}.Sanitize()+" "+key.definition) + require.NoError(t, err) + } + } + + actor := createEntUser(t, ctx, testEntClient(t), "prompt-rules-"+suffix+"@example.invalid") + actorID = actor.ID + _, err = db.ExecContext(ctx, `INSERT INTO system_prompt_runtime (id, enabled, expose_server_prompt, compact_enabled, revision, updated_by) VALUES (1, TRUE, TRUE, TRUE, 41, $1)`, actorID) + require.NoError(t, err) + prompts := &businessSystemPromptRepository{db: db} + detail, err := prompts.CreateBusinessSystemPromptTemplate(ctx, service.BusinessSystemPromptTemplateCreate{ + Slug: "prompt_rules_fixture_" + suffix, Name: "Prompt rules integration fixture", Body: "Synthetic prompt content for this integration case.", CompositionMode: service.BusinessSystemPromptCompositionInline, + }, actorID, 41) + require.NoError(t, err) + require.Len(t, detail.Versions, 1) + versionID := detail.Versions[0].ID + _, err = db.ExecContext(ctx, `UPDATE system_prompt_runtime SET active_template_id=$1, active_version_id=$2 WHERE id=1`, detail.Template.ID, versionID) + require.NoError(t, err) + readRuntime := func() string { + t.Helper() + var raw string + require.NoError(t, db.QueryRowContext(ctx, `SELECT to_jsonb(r)::text FROM system_prompt_runtime r WHERE id=1`).Scan(&raw)) + return raw + } + readPolicy := func() string { + t.Helper() + var raw string + require.NoError(t, db.QueryRowContext(ctx, `SELECT policy::text FROM system_prompt_rule_policies WHERE id=1`).Scan(&raw)) + return raw + } + runtimeBefore := readRuntime() + migration, err := migrations.FS.ReadFile("253_prompt_rule_policies.sql") + require.NoError(t, err) + _, err = db.ExecContext(ctx, string(migration)) + require.NoError(t, err) + require.JSONEq(t, runtimeBefore, readRuntime(), "migration preserves all legacy runtime fields") + loaded, err := prompts.LoadBusinessSystemPromptRules(ctx) + require.NoError(t, err) + require.True(t, loaded.Enabled && loaded.ExposeServerPrompt && loaded.CompactEnabled) + require.Equal(t, detail.Template.ID, loaded.TemplateID) + require.Equal(t, versionID, loaded.VersionID) + require.Equal(t, int64(41), loaded.Revision) + require.NotNil(t, loaded.RulePolicy) + require.Equal(t, []string{"legacy-default"}, loaded.RulePolicy.DefaultRuleIDs) + require.Len(t, loaded.RulePolicy.Rules, 1) + require.Equal(t, versionID, loaded.RulePolicy.Rules[0].VersionID) + require.True(t, loaded.RulePolicy.Rules[0].FollowActive) + + policy := *loaded.RulePolicy + policy.Rules[0].Name = "Configured fixture rule" + policy.Rules[0].Order = 17 + policy.Rules[0].FollowActive = false + require.NoError(t, prompts.UpdateBusinessSystemPromptRules(ctx, policy, 41, actorID)) + loaded, err = prompts.LoadBusinessSystemPromptRules(ctx) + require.NoError(t, err) + require.Equal(t, int64(42), loaded.Revision) + require.Equal(t, "Configured fixture rule", loaded.RulePolicy.Rules[0].Name) + require.True(t, loaded.Enabled && loaded.ExposeServerPrompt && loaded.CompactEnabled) + configuredPolicy, configuredRuntime := readPolicy(), readRuntime() + _, err = db.ExecContext(ctx, string(migration)) + require.NoError(t, err) + require.JSONEq(t, configuredPolicy, readPolicy(), "replaying migration must not replace custom rules") + require.JSONEq(t, configuredRuntime, readRuntime()) + conflicting := extensionv1.PromptRulePolicy{Version: 1, Rules: []extensionv1.PromptRule{}, DefaultRuleIDs: []string{}} + require.ErrorIs(t, prompts.UpdateBusinessSystemPromptRules(ctx, conflicting, 41, actorID), service.ErrBusinessSystemPromptRevisionConflict) + require.JSONEq(t, configuredPolicy, readPolicy()) + require.JSONEq(t, configuredRuntime, readRuntime()) + + accounts := NewAccountRepository(client, db, nil).(*accountRepository) + account := &service.Account{ + Name: "prompt-rules-fixture-" + suffix, Platform: service.PlatformOpenAI, WirePlatform: service.WirePlatformOpenAI, + Type: service.AccountTypeAPIKey, Status: service.StatusActive, Concurrency: 1, Schedulable: false, + Credentials: map[string]any{"api_key": "synthetic-integration-only"}, + Extra: map[string]any{"unrelated_fixture": map[string]any{"nested": []any{true, "retained"}}, "openai_responses_supported": true}, + } + require.NoError(t, accounts.Create(ctx, account)) + accountID = account.ID + stale, err := accounts.GetByID(ctx, accountID) + require.NoError(t, err) + _, present := stale.Extra[service.PromptAccountBindingExtraKey] + require.False(t, present) + var originalExtra, originalCredentials string + require.NoError(t, db.QueryRowContext(ctx, `SELECT extra::text, credentials::text FROM accounts WHERE id=$1`, accountID).Scan(&originalExtra, &originalCredentials)) + binding := extensionv1.PromptAccountBinding{Mode: "custom", RuleIDs: []string{"legacy-default"}} + applied, err := accounts.UpdatePromptBindingIfRevision(ctx, accountID, stale.UpdatedAt, 42, binding) + require.NoError(t, err) + require.True(t, applied) + assertBinding := func() { + t.Helper() + var raw, unrelated, credentials string + require.NoError(t, db.QueryRowContext(ctx, `SELECT (extra->'prompt_skills')::text, (extra-'prompt_skills')::text, credentials::text FROM accounts WHERE id=$1`, accountID).Scan(&raw, &unrelated, &credentials)) + expected, err := json.Marshal(binding) + require.NoError(t, err) + require.JSONEq(t, string(expected), raw) + require.JSONEq(t, originalExtra, unrelated) + require.JSONEq(t, originalCredentials, credentials) + } + assertBinding() + applied, err = accounts.UpdatePromptBindingIfRevision(ctx, accountID, stale.UpdatedAt, 42, extensionv1.PromptAccountBinding{Mode: "off"}) + require.NoError(t, err) + require.False(t, applied, "stale account revision cannot overwrite the binding") + assertBinding() + current, err := accounts.GetByID(ctx, accountID) + require.NoError(t, err) + applied, err = accounts.UpdatePromptBindingIfRevision(ctx, accountID, current.UpdatedAt, 41, extensionv1.PromptAccountBinding{Mode: "off"}) + require.ErrorIs(t, err, service.ErrBusinessSystemPromptRevisionConflict) + require.False(t, applied) + assertBinding() + require.ErrorIs(t, prompts.UpdateBusinessSystemPromptRules(ctx, conflicting, 42, actorID), service.ErrPromptRuleReferenced) + require.JSONEq(t, configuredPolicy, readPolicy()) + require.JSONEq(t, configuredRuntime, readRuntime()) + + // This is a real pre-binding whole-account snapshot, not a partial patch. + stale.Name += " renamed" + require.NoError(t, accounts.Update(ctx, stale)) + assertBinding() + current, err = accounts.GetByID(ctx, accountID) + require.NoError(t, err) + require.Equal(t, stale.Name, current.Name) + var serverVersion string + require.NoError(t, db.QueryRowContext(ctx, `SHOW server_version`).Scan(&serverVersion)) + t.Logf("PostgreSQL %s: migration retained runtime/active version, repeat retained policy, rule and account CAS held, referenced-rule delete rejected, stale account edit preserved binding", serverVersion) +} diff --git a/backend/internal/repository/business_system_prompt_rules_test.go b/backend/internal/repository/business_system_prompt_rules_test.go new file mode 100644 index 000000000000..2b5af4d3c1c7 --- /dev/null +++ b/backend/internal/repository/business_system_prompt_rules_test.go @@ -0,0 +1,53 @@ +package repository + +import ( + "context" + "encoding/json" + "testing" + + "github.com/DATA-DOG/go-sqlmock" + "github.com/Wei-Shaw/sub2api/internal/service" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/stretchr/testify/require" +) + +func TestPromptRulesRepositoryCASAndReferencedAccounts(t *testing.T) { + for _, scenario := range []string{"revision_conflict", "referenced", "save"} { + t.Run(scenario, func(t *testing.T) { + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer func() { _ = db.Close() }() + policy := extensionv1.PromptRulePolicy{Version: 1, Rules: []extensionv1.PromptRule{{ID: "default", Name: "Default", FollowActive: true, Delivery: "native_control", Position: "control_append"}}, DefaultRuleIDs: []string{"default"}} + mock.ExpectBegin() + revision := int64(7) + if scenario == "revision_conflict" { + revision++ + } + mock.ExpectQuery("SELECT revision FROM system_prompt_runtime").WillReturnRows(sqlmock.NewRows([]string{"revision"}).AddRow(revision)) + if scenario == "revision_conflict" { + mock.ExpectRollback() + } else { + mock.ExpectQuery("SELECT EXISTS").WithArgs(`["default"]`).WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(scenario == "referenced")) + if scenario == "referenced" { + mock.ExpectRollback() + } else { + raw, _ := json.Marshal(policy) + mock.ExpectExec("INSERT INTO system_prompt_rule_policies").WithArgs(string(raw)).WillReturnResult(sqlmock.NewResult(0, 1)) + mock.ExpectExec("UPDATE system_prompt_runtime SET revision").WithArgs(int64(9)).WillReturnResult(sqlmock.NewResult(0, 1)) + mock.ExpectCommit() + } + } + repo := &businessSystemPromptRepository{db: db} + err = repo.UpdateBusinessSystemPromptRules(context.Background(), policy, 7, 9) + switch scenario { + case "revision_conflict": + require.ErrorIs(t, err, service.ErrBusinessSystemPromptRevisionConflict) + case "referenced": + require.ErrorIs(t, err, service.ErrPromptRuleReferenced) + default: + require.NoError(t, err) + } + require.NoError(t, mock.ExpectationsWereMet()) + }) + } +} diff --git a/backend/internal/repository/codex_connection_lease.go b/backend/internal/repository/codex_connection_lease.go new file mode 100644 index 000000000000..03b2c048c25d --- /dev/null +++ b/backend/internal/repository/codex_connection_lease.go @@ -0,0 +1,144 @@ +package repository + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "crypto/tls" + "encoding/hex" + "encoding/json" + "errors" + "net" + "net/http" + "strings" + "sync/atomic" + "time" + + "github.com/Wei-Shaw/sub2api/internal/pkg/tlsfingerprint" + "github.com/Wei-Shaw/sub2api/internal/service" +) + +type codexConnectionLease struct { + accountID int64 + scope string + origin string + transportHash [32]byte + expiresAt time.Time + client *http.Client + transport *http.Transport +} + +func (s *httpUpstreamService) DoWithCodexConnectionLease(req *http.Request, proxyURL string, accountID int64, scope string, leaseID string, expiresAt time.Time, profile *tlsfingerprint.Profile) (*http.Response, string, error) { + if req == nil || req.URL == nil || accountID <= 0 || scope == "" || len(scope) > 1024 { + return nil, "", service.ErrCodexConnectionLeaseScope + } + if err := s.validateRequestHost(req); err != nil { + return nil, "", service.ErrCodexConnectionLeaseScope + } + proxyKey, parsedProxy, err := normalizeProxyURL(proxyURL) + if err != nil { + return nil, "", service.ErrCodexConnectionLeaseScope + } + profileJSON, err := json.Marshal(profile) + if err != nil { + return nil, "", service.ErrCodexConnectionLeaseScope + } + transportHash := sha256.Sum256(append([]byte(proxyKey+"\x00"), profileJSON...)) + origin := strings.ToLower(req.URL.Scheme + "://" + req.URL.Host) + now := time.Now() + var lease *codexConnectionLease + if leaseID != "" { + s.mu.RLock() + lease = s.codexConnectionLeases[leaseID] + s.mu.RUnlock() + if lease == nil || !now.Before(lease.expiresAt) { + return nil, "", service.ErrCodexConnectionLeaseExpired + } + if lease.accountID != accountID || lease.scope != scope || lease.origin != origin || lease.transportHash != transportHash { + return nil, "", service.ErrCodexConnectionLeaseScope + } + } else { + if expiresAt.IsZero() || expiresAt.After(now.Add(120*time.Second)) { + expiresAt = now.Add(120 * time.Second) + } + if !expiresAt.After(now) { + return nil, "", service.ErrCodexConnectionLeaseExpired + } + settings := defaultPoolSettings(s.cfg) + settings.maxIdleConns, settings.maxIdleConnsPerHost, settings.maxConnsPerHost = 1, 1, 1 + settings.idleConnTimeout = time.Until(expiresAt) + transport, buildErr := buildUpstreamTransport(settings, parsedProxy, upstreamProtocolModeOpenAIH1) + if profile != nil && strings.EqualFold(req.URL.Scheme, "https") { + transport, buildErr = buildUpstreamTransportWithTLSFingerprint(settings, parsedProxy, profile) + } + if buildErr != nil { + return nil, "", service.ErrCodexConnectionLeaseTransport + } + transport.DisableCompression = true + transport.ForceAttemptHTTP2 = false + transport.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper) + // Exactly one physical dial is authorized. A disconnected/expired lease + // must fail before any request can reach a different residential exit. + var dialed atomic.Bool + wrap := func(dial func(context.Context, string, string) (net.Conn, error)) func(context.Context, string, string) (net.Conn, error) { + return func(ctx context.Context, network, address string) (net.Conn, error) { + if !time.Now().Before(expiresAt) || !dialed.CompareAndSwap(false, true) { + return nil, service.ErrCodexConnectionLeaseExpired + } + return dial(ctx, network, address) + } + } + if transport.DialContext != nil { + transport.DialContext = wrap(transport.DialContext) + } + if transport.DialTLSContext != nil { + transport.DialTLSContext = wrap(transport.DialTLSContext) + } + var id [24]byte + if _, err := rand.Read(id[:]); err != nil { + transport.CloseIdleConnections() + return nil, "", service.ErrCodexConnectionLeaseTransport + } + leaseID = hex.EncodeToString(id[:]) + lease = &codexConnectionLease{accountID: accountID, scope: scope, origin: origin, transportHash: transportHash, + expiresAt: expiresAt, transport: transport, + client: &http.Client{Transport: transport, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}} + s.mu.Lock() + if s.codexConnectionLeases == nil { + s.codexConnectionLeases = make(map[string]*codexConnectionLease) + } + if len(s.codexConnectionLeases) >= s.maxUpstreamClients() { + s.mu.Unlock() + transport.CloseIdleConnections() + return nil, "", service.ErrCodexConnectionLeaseTransport + } + s.codexConnectionLeases[leaseID] = lease + s.mu.Unlock() + createdID := leaseID + time.AfterFunc(time.Until(expiresAt), func() { s.removeCodexConnectionLease(createdID, lease) }) + } + // Keep caller request state immutable. Closing an expired idle pool does not + // interrupt a response admitted before expiry; it only prevents later use. + wire := req.Clone(req.Context()) + wire.Header = req.Header.Clone() + wire.Close = false + response, err := lease.client.Do(wire) + if err != nil { + s.removeCodexConnectionLease(leaseID, lease) + if errors.Is(err, service.ErrCodexConnectionLeaseExpired) { + return nil, "", service.ErrCodexConnectionLeaseExpired + } + return nil, "", service.ErrCodexConnectionLeaseTransport + } + decompressResponseBody(response) + return response, leaseID, nil +} + +func (s *httpUpstreamService) removeCodexConnectionLease(id string, lease *codexConnectionLease) { + s.mu.Lock() + if s.codexConnectionLeases[id] == lease { + delete(s.codexConnectionLeases, id) + } + s.mu.Unlock() + lease.transport.CloseIdleConnections() +} diff --git a/backend/internal/repository/codex_connection_lease_test.go b/backend/internal/repository/codex_connection_lease_test.go new file mode 100644 index 000000000000..c6f545751a85 --- /dev/null +++ b/backend/internal/repository/codex_connection_lease_test.go @@ -0,0 +1,104 @@ +package repository + +import ( + "io" + "net" + "net/http" + "net/http/httptest" + "sync/atomic" + "testing" + "time" + + "github.com/Wei-Shaw/sub2api/internal/service" + "github.com/stretchr/testify/require" +) + +func TestCodexConnectionLeaseReusesPhysicalConnectionAndRejectsScope(t *testing.T) { + var connections atomic.Int32 + var calls atomic.Int32 + server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { calls.Add(1); _, _ = io.WriteString(w, "complete") })) + server.Config.ConnState = func(_ net.Conn, state http.ConnState) { + if state == http.StateNew { + connections.Add(1) + } + } + server.Start() + t.Cleanup(server.Close) + upstream := NewHTTPUpstream(nil).(*httpUpstreamService) + request := func() *http.Request { + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, server.URL, nil) + require.NoError(t, err) + return req + } + first, id, err := upstream.DoWithCodexConnectionLease(request(), "", 1, "scope-a", "", time.Now().Add(time.Minute), nil) + require.NoError(t, err) + require.NotEmpty(t, id) + _, err = io.Copy(io.Discard, first.Body) + require.NoError(t, err) + require.NoError(t, first.Body.Close()) + second, same, err := upstream.DoWithCodexConnectionLease(request(), "", 1, "scope-a", id, time.Time{}, nil) + require.NoError(t, err) + require.Equal(t, id, same) + _, err = io.Copy(io.Discard, second.Body) + require.NoError(t, err) + require.NoError(t, second.Body.Close()) + require.EqualValues(t, 1, connections.Load()) + _, _, err = upstream.DoWithCodexConnectionLease(request(), "", 2, "scope-a", id, time.Time{}, nil) + require.ErrorIs(t, err, service.ErrCodexConnectionLeaseScope) + _, _, err = upstream.DoWithCodexConnectionLease(request(), "", 1, "changed-profile-or-route", id, time.Time{}, nil) + require.ErrorIs(t, err, service.ErrCodexConnectionLeaseScope) + require.EqualValues(t, 2, calls.Load()) + upstream.removeCodexConnectionLease(id, upstream.codexConnectionLeases[id]) +} + +func TestCodexConnectionLeaseNeverRedialsAfterUpstreamCloses(t *testing.T) { + var calls atomic.Int32 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + calls.Add(1) + w.Header().Set("Connection", "close") + _, _ = io.WriteString(w, "complete") + })) + t.Cleanup(server.Close) + upstream := NewHTTPUpstream(nil).(*httpUpstreamService) + request := func() *http.Request { + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, server.URL, nil) + require.NoError(t, err) + return req + } + first, id, err := upstream.DoWithCodexConnectionLease(request(), "", 1, "scope", "", time.Now().Add(time.Minute), nil) + require.NoError(t, err) + _, err = io.Copy(io.Discard, first.Body) + require.NoError(t, err) + require.NoError(t, first.Body.Close()) + _, _, err = upstream.DoWithCodexConnectionLease(request(), "", 1, "scope", id, time.Time{}, nil) + require.ErrorIs(t, err, service.ErrCodexConnectionLeaseExpired) + require.EqualValues(t, 1, calls.Load()) +} + +func TestCodexConnectionLeaseExpiryAndRedirectDoNotSendAnotherRequest(t *testing.T) { + var calls atomic.Int32 + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + calls.Add(1) + http.Redirect(w, r, "/other", http.StatusFound) + })) + t.Cleanup(server.Close) + upstream := NewHTTPUpstream(nil).(*httpUpstreamService) + request := func() *http.Request { + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, server.URL, nil) + require.NoError(t, err) + return req + } + response, id, err := upstream.DoWithCodexConnectionLease(request(), "", 1, "scope", "", time.Now().Add(time.Minute), nil) + require.NoError(t, err) + require.Equal(t, http.StatusFound, response.StatusCode) + _, err = io.Copy(io.Discard, response.Body) + require.NoError(t, err) + require.NoError(t, response.Body.Close()) + upstream.mu.Lock() + upstream.codexConnectionLeases[id].expiresAt = time.Now().Add(-time.Second) + upstream.mu.Unlock() + _, _, err = upstream.DoWithCodexConnectionLease(request(), "", 1, "scope", id, time.Time{}, nil) + require.ErrorIs(t, err, service.ErrCodexConnectionLeaseExpired) + require.EqualValues(t, 1, calls.Load()) + upstream.removeCodexConnectionLease(id, upstream.codexConnectionLeases[id]) +} diff --git a/backend/internal/repository/http_upstream.go b/backend/internal/repository/http_upstream.go index 89f1688b9a8e..e9f4e92facce 100644 --- a/backend/internal/repository/http_upstream.go +++ b/backend/internal/repository/http_upstream.go @@ -165,6 +165,8 @@ type httpUpstreamService struct { clients map[string]*upstreamClientEntry // 客户端缓存池，key 由隔离策略决定 // OpenAI 走 HTTP/HTTPS 代理时的 H2->H1 回退状态（key=标准化 proxyKey） openAIHTTP2Fallbacks sync.Map + // Dedicated, expiring connection leases never share a proxy pool across accounts. + codexConnectionLeases map[string]*codexConnectionLease } // NewHTTPUpstream 创建通用 HTTP 上游服务 diff --git a/backend/internal/repository/scheduler_cache.go b/backend/internal/repository/scheduler_cache.go index b01085dc9bb9..9e43bb4b95a8 100644 --- a/backend/internal/repository/scheduler_cache.go +++ b/backend/internal/repository/scheduler_cache.go @@ -1033,6 +1033,7 @@ func filterSchedulerExtra(extra map[string]any) map[string]any { return nil } keys := []string{ + service.PromptAccountBindingExtraKey, // Anthropic shared-window and Fable-only threshold checks run on this // projection. UpdateExtra refreshes both payloads without a bucket rebuild. "session_window_utilization", diff --git a/backend/internal/server/routes/admin.go b/backend/internal/server/routes/admin.go index 8a1e2851f6a8..9afb863f97e2 100644 --- a/backend/internal/server/routes/admin.go +++ b/backend/internal/server/routes/admin.go @@ -187,6 +187,11 @@ func registerSystemPromptRoutes(admin *gin.RouterGroup, h *handler.Handlers) { {"prompts.create", "POST", "", h.Admin.SystemPrompt.Create}, {"prompts.runtime.read", "GET", "/runtime", h.Admin.SystemPrompt.Runtime}, {"prompts.runtime.update", "PUT", "/runtime", h.Admin.SystemPrompt.UpdateRuntime}, + {"prompts.rules.read", "GET", "/rules", h.Admin.SystemPrompt.Rules}, + {"prompts.rules.update", "PUT", "/rules", h.Admin.SystemPrompt.UpdateRules}, + {"prompts.bindings.read", "POST", "/accounts/resolve", h.Admin.SystemPrompt.AccountBindings}, + {"prompts.bindings.update", "POST", "/accounts/bindings", h.Admin.SystemPrompt.UpdateAccountBindings}, + {"prompts.rules.preview", "POST", "/rules/preview/:account_id", h.Admin.SystemPrompt.PreviewRules}, {"prompts.preview.merge", "POST", "/preview/merge", h.Admin.SystemPrompt.PreviewMerge}, {"prompts.preview.upstream", "POST", "/preview/upstream", h.Admin.SystemPrompt.PreviewUpstream}, {"skills.registry", "GET", "/skill-registry", h.Admin.SystemPrompt.SkillRegistry}, @@ -207,6 +212,18 @@ func registerSystemPromptRoutes(admin *gin.RouterGroup, h *handler.Handlers) { {"prompts.rollback", "POST", "/:id/versions/:version_id/rollback", h.Admin.SystemPrompt.Rollback}, } { descriptor := extensionv1.ResourceDescriptor{ResourceGrant: extensionv1.ResourceGrant{Name: route.name, Capability: extensionv1.CapabilityRequest, Permission: "admin"}, Method: route.method, Path: prompts.BasePath() + route.path} + if route.name == "prompts.bindings.read" { + descriptor.AccountBodyField = "account_ids" + } + if route.name == "prompts.bindings.update" { + descriptor.AccountItemsField = "updates" + } + if route.name == "prompts.rules.preview" { + descriptor.AccountParam = "account_id" + } + if route.name == "prompts.bindings.read" || route.name == "prompts.bindings.update" || route.name == "prompts.rules.preview" { + descriptor.Capability = extensionv1.CapabilityAdmin + } prompts.Handle(route.method, route.path, h.Admin.Plugin.RegisterResource(descriptor), route.handler) } } @@ -508,6 +525,9 @@ func registerAccountRoutes(admin *gin.RouterGroup, h *handler.Handlers, stepUpAu accounts.POST("/:id/codex-tickets/harvest", h.Admin.Account.HarvestCodexTicket) accounts.POST("/codex-tickets/batch-harvest", h.Admin.Account.BatchHarvestCodexTickets) accounts.POST("/:id/codex-tickets/stop", h.Admin.Account.StopCodexTicketRenewal) + accounts.GET("/:id/codex-fingerprint", h.Admin.Plugin.RegisterResource(extensionv1.ResourceDescriptor{ResourceGrant: extensionv1.ResourceGrant{Name: "codex.fingerprint", Capability: extensionv1.CapabilityRequest, Permission: "admin"}, OwnerPluginKey: "codexrip.codex-runtime", AccountParam: "id", Method: "GET", Path: accounts.BasePath() + "/:id/codex-fingerprint"}), h.Admin.Account.CodexFingerprint) + accounts.POST("/:id/codex-routing/validate", h.Admin.Plugin.RegisterResource(extensionv1.ResourceDescriptor{ResourceGrant: extensionv1.ResourceGrant{Name: "codex.routing.validate", Capability: extensionv1.CapabilityCredentials, Permission: "admin"}, OwnerPluginKey: "codexrip.codex-runtime", AccountParam: "id", Method: "POST", Path: accounts.BasePath() + "/:id/codex-routing/validate"}), h.Admin.Account.ValidateCodexRouting) + accounts.PUT("/:id/codex-fingerprint/profile", h.Admin.Plugin.RegisterResource(extensionv1.ResourceDescriptor{ResourceGrant: extensionv1.ResourceGrant{Name: "codex.fingerprint.profile", Capability: extensionv1.CapabilityRequest, Permission: "admin"}, RequiredCapabilities: []string{extensionv1.CapabilityAdmin}, OwnerPluginKey: "codexrip.codex-runtime", AccountParam: "id", Method: "PUT", Path: accounts.BasePath() + "/:id/codex-fingerprint/profile"}), h.Admin.Account.SelectCodexProfile) accounts.POST("/:id/recover-state", h.Admin.Account.RecoverState) accounts.POST("/:id/cindy-balance/recover", h.Admin.Plugin.RegisterResource(extensionv1.ResourceDescriptor{ResourceGrant: extensionv1.ResourceGrant{Name: "cindy.balance.recover", Capability: extensionv1.CapabilityProvider, Permission: "admin"}, RequiredCapabilities: []string{extensionv1.CapabilityAdmin}, OwnerPluginKey: service.CindyAccountViewPluginKey, AccountParam: "id", Method: "POST", Path: accounts.BasePath() + "/:id/cindy-balance/recover"}), h.Admin.Account.ClearCindyBalanceInsufficient) accounts.POST("/:id/refresh", h.Admin.Account.Refresh) diff --git a/backend/internal/service/account_test_reasoning.go b/backend/internal/service/account_test_reasoning.go index d12e5bc62de9..134de2c0c5f0 100644 --- a/backend/internal/service/account_test_reasoning.go +++ b/backend/internal/service/account_test_reasoning.go @@ -5,6 +5,7 @@ import ( "errors" "strings" + "github.com/Wei-Shaw/sub2api/internal/pkg/openai" extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" "github.com/gin-gonic/gin" ) @@ -31,7 +32,14 @@ func AccountTestReasoningOptions(account *Account, model string) ([]string, stri if !*metadata.Reasoning { return nil, "" } - return normalizeReasoningLevels(metadata.SupportedReasoningLevels), normalizeReasoningLevel(metadata.DefaultReasoningLevel) + levels := normalizeReasoningLevels(metadata.SupportedReasoningLevels) + if isOpenAIGPT6SolOrLunaModel(model) { + levels = intersectOrderedStrings(levels, openai.GPT6APIReasoningEfforts()) + } + return levels, normalizeReasoningLevel(metadata.DefaultReasoningLevel) + } + if account.IsOpenAIApiKey() && isOpenAIGPT6SolOrLunaModel(model) { + return openai.GPT6APIReasoningEfforts(), "medium" } var levels []configuredCodexReasoningLevel switch { @@ -42,6 +50,10 @@ func AccountTestReasoningOptions(account *Account, model string) ([]string, stri } out := make([]string, 0, len(levels)) for _, level := range levels { + // Ultra is client orchestration, never a native inference effort. + if level.Effort == "ultra" && isOpenAIGPT6SolOrLunaModel(model) { + continue + } out = append(out, level.Effort) } return out, "" diff --git a/backend/internal/service/account_test_service.go b/backend/internal/service/account_test_service.go index e96f0f28c124..dcd5483e96d7 100644 --- a/backend/internal/service/account_test_service.go +++ b/backend/internal/service/account_test_service.go @@ -921,8 +921,9 @@ func (s *AccountTestService) testOpenAIAccountConnection(c *gin.Context, account // 账号级请求头覆写：测试请求与真实转发保持一致的最终头 credentialAccount.ApplyHeaderOverrides(req.Header) if isOAuth && !account.IsCredentialShadow() && s.openAIGatewayService != nil { + req = withCodexRoutingModel(req, upstreamTestModelID) if err := s.openAIGatewayService.applyOpenAICodexTicket(ctx, credentialAccount, upstreamTestModelID, req.Header); err != nil { - return s.sendErrorAndEnd(c, "当前账号/模型没有有效292票据，请先手动打票；此次连接测试未发送上游请求") + return s.sendErrorAndEnd(c, "当前账号/模型没有有效的 Cookie 路由验证，请先执行采集与业务出口复验；此次连接测试未发送上游请求") } s.sendEvent(c, TestEvent{Type: "status", Text: "Codex ticket", Data: codexTicketWireSummary(req.Header)}) } diff --git a/backend/internal/service/admin_account.go b/backend/internal/service/admin_account.go index f2a529d5c004..3a5a4c61a8d8 100644 --- a/backend/internal/service/admin_account.go +++ b/backend/internal/service/admin_account.go @@ -902,6 +902,12 @@ func (s *adminServiceImpl) updateAccount(ctx context.Context, id int64, input *U } } normalizedExtra = MergeOpenAICodexTicketExtra(normalizedExtra, account.Extra) + // Prompt bindings have their own rule-revision and account-revision CAS. + // Ordinary account edits preserve them, including their absence. + delete(normalizedExtra, PromptAccountBindingExtraKey) + if binding, exists := account.Extra[PromptAccountBindingExtraKey]; exists { + normalizedExtra[PromptAccountBindingExtraKey] = binding + } normalizedExtra = prepareCodexFingerprintExtraForUpdate(account, normalizedExtra) account.Extra = normalizedExtra if account.Platform == PlatformAntigravity && wasOveragesEnabled && !account.IsOveragesEnabled() { diff --git a/backend/internal/service/billing_service.go b/backend/internal/service/billing_service.go index 57a8c9923410..46e2081fd53e 100644 --- a/backend/internal/service/billing_service.go +++ b/backend/internal/service/billing_service.go @@ -469,6 +469,9 @@ func (s *BillingService) initFallbackPricing() { LongContextOutputMultiplier: 1.5, } + s.fallbackPrices["gpt-6-sol"] = modelPricingFromCatalog(openAIGPT6SolFallbackPricing) + s.fallbackPrices["gpt-6-luna"] = modelPricingFromCatalog(openAIGPT6LunaFallbackPricing) + // OpenAI GPT-5.6 官方价格（USD/token）。缓存写入为输入价的 1.25 倍。 s.fallbackPrices["gpt-5.6-sol"] = &ModelPricing{ InputPricePerToken: 5e-6, @@ -1000,6 +1003,8 @@ func (s *BillingService) getFallbackPricing(model string) *ModelPricing { switch normalized { case "gpt-6-astra": return s.fallbackPrices["gpt-6-astra"] + case "gpt-6-sol", "gpt-6-luna": + return s.fallbackPrices[normalized] case "gpt-5.6-sol": return s.fallbackPrices["gpt-5.6-sol"] case "gpt-5.6-terra": @@ -1609,7 +1614,7 @@ func (s *BillingService) applyModelSpecificPricingPolicy(model string, pricing * return nil } normalized := normalizeKnownOpenAICodexModel(model) - isGPT56 := isOpenAIGPT56Model(normalized) + isGPT56 := isOpenAIGPT56Model(normalized) || isOpenAIGPT6SolOrLunaModel(normalized) needsMaxReasoningEffortMultiplier := isClaudeFable51Model(model) && pricing.MaxReasoningEffortMultiplier == nil needsCacheCreationPolicy := isGPT56 && !pricing.CacheCreationPriceExplicit && (pricing.CacheCreationPricePerToken <= 0 || (pricing.InputPricePerTokenPriority > 0 && pricing.CacheCreationPricePerTokenPriority <= 0)) @@ -1640,7 +1645,7 @@ func (s *BillingService) applyModelSpecificPricingPolicy(model string, pricing * // 档的模型（如 gpt-5.5-pro、gpt-5.4-mini/nano）返回 0。 func openAIModelFastPricingRatio(normalized string) float64 { switch normalized { - case "gpt-5.4", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra": + case "gpt-5.4", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna": return 2.0 case "gpt-5.5": return 2.5 diff --git a/backend/internal/service/business_system_prompt_policy.go b/backend/internal/service/business_system_prompt_policy.go index 4b450184c4c3..48d760f2496a 100644 --- a/backend/internal/service/business_system_prompt_policy.go +++ b/backend/internal/service/business_system_prompt_policy.go @@ -95,8 +95,18 @@ func planBusinessSystemPromptWithInvoker(parent context.Context, body []byte, sn } result, err := invoke(ctx, target.Platform, accountType, extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "prompt.plan", AccountID: target.AccountID, Payload: raw}) if errors.Is(err, ErrExtensionOperationDisabled) { + if snapshot.RulePolicy != nil { + plan := &extensionv1.PromptRulesPlan{Placements: []extensionv1.PromptRulePlacement{}, Skipped: []extensionv1.PromptRuleDecision{}} + for _, rule := range snapshot.RulePolicy.Rules { + plan.Skipped = append(plan.Skipped, extensionv1.PromptRuleDecision{RuleID: rule.ID, Reason: "plugin_scope"}) + } + return BusinessSystemPromptApplication{Revision: snapshot.Revision, RulesPlan: plan}, nil + } return BusinessSystemPromptApplication{}, nil } + if result.Code == "prompt_delivery_unsupported" { + return BusinessSystemPromptApplication{}, ErrPromptDeliveryUnsupported + } if err != nil || result.Code != "" { if !snapshot.Enabled { return BusinessSystemPromptApplication{}, nil @@ -107,10 +117,19 @@ func planBusinessSystemPromptWithInvoker(parent context.Context, body []byte, sn if json.Unmarshal(result.Payload, &application) != nil { return application, ErrBusinessSystemPromptUnavailable } + if snapshot.RulePolicy != nil && application.RulesPlan == nil { + if !snapshot.Enabled { + return BusinessSystemPromptApplication{}, nil + } + return BusinessSystemPromptApplication{}, ErrBusinessSystemPromptUnavailable + } return application, nil } func applyBusinessSystemPromptApplication(body []byte, application BusinessSystemPromptApplication) ([]byte, BusinessSystemPromptApplication, error) { + if application.RulesPlan != nil { + return applyPromptRules(body, application) + } if !application.Applied { return body, application, nil } @@ -197,6 +216,9 @@ func RewriteBusinessSystemPromptResponseJSON( application BusinessSystemPromptApplication, exposeServerPrompt bool, ) ([]byte, error) { + if application.RulesPlan != nil { + return rewritePromptRulesResponse(body, application, exposeServerPrompt) + } if exposeServerPrompt || application.PreserveInstructionsEcho || !application.Applied || @@ -242,7 +264,7 @@ func RewriteBusinessSystemPromptSSE( if exposeServerPrompt || application.PreserveInstructionsEcho || !application.Applied || - application.Carrier != BusinessSystemPromptCarrierInstructions { + (application.Carrier != BusinessSystemPromptCarrierInstructions && application.RulesPlan == nil) { return body, nil } lines := bytes.SplitAfter(body, []byte("\n")) diff --git a/backend/internal/service/business_system_prompt_rules_apply.go b/backend/internal/service/business_system_prompt_rules_apply.go new file mode 100644 index 000000000000..883f065cacb4 --- /dev/null +++ b/backend/internal/service/business_system_prompt_rules_apply.go @@ -0,0 +1,509 @@ +package service + +import ( + "bytes" + "crypto/sha256" + "encoding/json" + "errors" + "fmt" + "net/http" + "sort" + "strings" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/gin-gonic/gin" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +var ErrPromptDeliveryUnsupported = errors.New("prompt_delivery_unsupported") + +func promptRuleFieldHash(raw []byte) [32]byte { + if len(raw) == 0 { + return sha256.Sum256(nil) + } + var value any + decoder := json.NewDecoder(bytes.NewReader(raw)) + decoder.UseNumber() + if decoder.Decode(&value) == nil { + if encoded, err := json.Marshal(value); err == nil { + return sha256.Sum256(encoded) + } + } + return sha256.Sum256(raw) +} + +func applyPromptRules(body []byte, application BusinessSystemPromptApplication) ([]byte, BusinessSystemPromptApplication, error) { + if application.RulesPlan == nil || !application.Applied { + return body, application, nil + } + if !json.Valid(body) { + return nil, application, ErrBusinessSystemPromptInvalid + } + groups := map[string][]extensionv1.PromptRulePlacement{} + for _, placement := range application.RulesPlan.Placements { + groups[placement.Carrier] = append(groups[placement.Carrier], placement) + } + out := body + for _, field := range []string{"instructions", "input", "messages"} { + placements := groups[field] + if len(placements) == 0 { + continue + } + value := gjson.GetBytes(out, field) + if field == "instructions" { + if value.Exists() && value.Type != gjson.String { + return nil, application, fmt.Errorf("%w: instructions must be a string", ErrBusinessSystemPromptInvalid) + } + application.OriginalInstructionsExists = value.Exists() + application.ClientInstructions = value.String() + before, after := []string{}, []string{} + publicBefore, publicAfter := []string{}, []string{} + for _, placement := range placements { + switch placement.Position { + case extensionv1.PromptPositionControlPrepend: + before = append(before, placement.Body) + if placement.PreserveEcho { + publicBefore = append(publicBefore, placement.Body) + } + case extensionv1.PromptPositionControlAppend: + after = append(after, placement.Body) + if placement.PreserveEcho { + publicAfter = append(publicAfter, placement.Body) + } + default: + return nil, application, ErrPromptDeliveryUnsupported + } + } + parts := append(before, strings.TrimSpace(value.String())) + parts = append(parts, after...) + parts = nonEmptyPromptParts(parts) + application.FinalInstructions = strings.Join(parts, "\n\n") + application.PublicInstructions, application.PublicInstructionsExists = value.String(), value.Exists() + if len(publicBefore)+len(publicAfter) > 0 { + publicParts := append(publicBefore, strings.TrimSpace(value.String())) + publicParts = append(publicParts, publicAfter...) + application.PublicInstructions, application.PublicInstructionsExists = strings.Join(nonEmptyPromptParts(publicParts), "\n\n"), true + } + var err error + out, err = sjson.SetBytes(out, field, application.FinalInstructions) + if err != nil { + return nil, application, err + } + continue + } + items := []json.RawMessage{} + if field == "input" && value.Type == gjson.String { + message, _ := json.Marshal(map[string]any{"role": "user", "content": value.String()}) + items = append(items, message) + } else if value.Exists() { + if !value.IsArray() || json.Unmarshal([]byte(value.Raw), &items) != nil { + return nil, application, fmt.Errorf("%w: %s must be a message array", ErrBusinessSystemPromptInvalid, field) + } + } else if field == "messages" { + return nil, application, fmt.Errorf("%w: messages must be an array", ErrBusinessSystemPromptInvalid) + } + controlEnd := 0 + for controlEnd < len(items) { + role := gjson.GetBytes(items[controlEnd], "role").String() + if role != "system" && role != "developer" { + break + } + controlEnd++ + } + insertions := map[int][]json.RawMessage{} + for _, placement := range placements { + if placement.Role != "system" && placement.Role != "developer" { + return nil, application, ErrPromptDeliveryUnsupported + } + index := 0 + switch placement.Position { + case extensionv1.PromptPositionControlPrepend, extensionv1.PromptPositionConversationHead: + case extensionv1.PromptPositionControlAppend: + index = controlEnd + case extensionv1.PromptPositionConversationTail: + index = len(items) + default: + return nil, application, ErrPromptDeliveryUnsupported + } + message, _ := json.Marshal(map[string]string{"role": placement.Role, "content": placement.Body}) + insertions[index] = append(insertions[index], message) + } + combined := make([]json.RawMessage, 0, len(items)+len(placements)) + for index := 0; index <= len(items); index++ { + combined = append(combined, insertions[index]...) + if index < len(items) { + combined = append(combined, items[index]) + } + } + raw, err := json.Marshal(combined) + if err != nil { + return nil, application, err + } + out, err = sjson.SetRawBytes(out, field, raw) + if err != nil { + return nil, application, err + } + } + return out, application, nil +} + +func nonEmptyPromptParts(parts []string) []string { + out := make([]string, 0, len(parts)) + for _, part := range parts { + if part != "" { + out = append(out, part) + } + } + return out +} + +// Proofs retain only insertion indices and bounded scalar control fields. +// Large customer arrays are hashed, never retained as another undo copy. +type promptRulesCarrierUndo struct { + field string + beforeExists bool + beforeHash [32]byte + afterHash [32]byte + scalar []byte + indices []int + valid bool + restorable bool +} + +func uniquePromptField(body []byte, field string) (gjson.Result, []byte, bool) { + view := parseRawJSONView(body) + if !view.IsObject() { + return gjson.Result{}, nil, false + } + var value gjson.Result + count := 0 + view.ForEach(func(key, candidate gjson.Result) bool { + if key.String() == field { + value = candidate + count++ + } + return count < 2 + }) + if count == 0 { + return value, nil, true + } + if count != 1 || value.Index < 1 || value.Index+len(value.Raw) > len(body) { + return value, nil, false + } + return value, body[value.Index : value.Index+len(value.Raw)], true +} + +func promptRulesUndo(input, output []byte, application BusinessSystemPromptApplication) []promptRulesCarrierUndo { + proofs := []promptRulesCarrierUndo{} + if !application.Applied || application.RulesPlan == nil { + return proofs + } + for _, field := range []string{"instructions", "input", "messages"} { + placements := []extensionv1.PromptRulePlacement{} + for _, placement := range application.RulesPlan.Placements { + if placement.Carrier == field { + placements = append(placements, placement) + } + } + if len(placements) == 0 { + continue + } + before, beforeRaw, uniqueBefore := uniquePromptField(input, field) + after, afterRaw, uniqueAfter := uniquePromptField(output, field) + proof := promptRulesCarrierUndo{field: field, beforeExists: before.Exists(), beforeHash: promptRuleFieldHash(beforeRaw), afterHash: promptRuleFieldHash(afterRaw), valid: uniqueBefore && uniqueAfter, restorable: true} + if field == "instructions" || !before.IsArray() { + if len(beforeRaw) > businessSystemPromptRestoreMaxBytes { + proof.restorable = false + } else { + proof.scalar = append([]byte(nil), beforeRaw...) + } + } else { + original := before.Array() + controlEnd := 0 + for controlEnd < len(original) { + role := original[controlEnd].Get("role").String() + if role != "system" && role != "developer" { + break + } + controlEnd++ + } + counts := map[int]int{} + for _, placement := range placements { + index := 0 + if placement.Position == extensionv1.PromptPositionControlAppend { + index = controlEnd + } else if placement.Position == extensionv1.PromptPositionConversationTail { + index = len(original) + } + counts[index]++ + } + added := 0 + for index := 0; index <= len(original); index++ { + for n := 0; n < counts[index]; n++ { + proof.indices = append(proof.indices, index+added) + added++ + } + } + proof.valid = proof.valid && after.IsArray() + } + proofs = append(proofs, proof) + } + return proofs +} + +func restorePromptRules(body []byte, proofs []promptRulesCarrierUndo) ([]byte, error) { + out := body + for _, proof := range proofs { + value, raw, unique := uniquePromptField(out, proof.field) + if !unique || !proof.valid { + return nil, ErrBusinessSystemPromptUnavailable + } + if !value.Exists() { + continue + } + hash := promptRuleFieldHash(raw) + if value.Exists() == proof.beforeExists && hash == proof.beforeHash { + continue + } + if hash != proof.afterHash || !proof.restorable { + return nil, ErrBusinessSystemPromptUnavailable + } + var err error + if !proof.beforeExists { + out, err = sjson.DeleteBytes(out, proof.field) + } else if proof.scalar != nil { + out, err = sjson.SetRawBytes(out, proof.field, proof.scalar) + } else { + indices := append([]int(nil), proof.indices...) + sort.Sort(sort.Reverse(sort.IntSlice(indices))) + for _, index := range indices { + out, err = sjson.DeleteBytes(out, fmt.Sprintf("%s.%d", proof.field, index)) + if err != nil { + break + } + } + } + if err != nil { + return nil, err + } + } + return out, nil +} + +func sameBusinessPromptPlan(left, right BusinessSystemPromptApplication) bool { + left.ClientInstructions, right.ClientInstructions = "", "" + left.FinalInstructions, right.FinalInstructions = "", "" + left.PublicInstructions, right.PublicInstructions = "", "" + left.PublicInstructionsExists, right.PublicInstructionsExists = false, false + left.OriginalInstructionsExists, right.OriginalInstructionsExists = false, false + leftPlan, rightPlan := left.RulesPlan, right.RulesPlan + left.RulesPlan, right.RulesPlan = nil, nil + if left != right { + return false + } + return (leftPlan == nil && rightPlan == nil) || (leftPlan != nil && rightPlan != nil && leftPlan.SHA256 == rightPlan.SHA256) +} + +func validateBusinessSystemPromptFinal(c *gin.Context, body []byte, protocol string) error { + value, exists := businessSystemPromptRequestGet(c, businessSystemPromptContextKey(c, businessSystemPromptRequestApplicationKey, protocol)) + if !exists { + return nil + } + state, ok := value.(businessSystemPromptRequestState) + if !ok || !state.application.Applied || state.application.RulesPlan == nil { + return nil + } + for _, proof := range state.rulesUndo { + if !promptRulesUseCarrier(state.application, proof.field) { + continue + } + _, raw, unique := uniquePromptField(body, proof.field) + if !unique || !proof.valid || promptRuleFieldHash(raw) != proof.afterHash { + return fmt.Errorf("%w: final prompt carrier changed", ErrBusinessSystemPromptUnavailable) + } + } + return nil +} + +// Used by integrity checks to remove only this request's proven insertions. +func restorePromptRulesForIntegrity(c *gin.Context, body []byte) ([]byte, error) { + value, exists := businessSystemPromptRequestGet(c, businessSystemPromptContextKey(c, businessSystemPromptRequestApplicationKey, BusinessSystemPromptProtocolResponses)) + if !exists { + return body, nil + } + state, ok := value.(businessSystemPromptRequestState) + if !ok || state.application.RulesPlan == nil { + return body, nil + } + return restorePromptRules(body, state.rulesUndo) +} + +func promptRulesCarrierMatches(body []byte, state businessSystemPromptRequestState) bool { + if sha256.Sum256(body) == state.inputHash { + return false + } + for _, proof := range state.rulesUndo { + value, raw, unique := uniquePromptField(body, proof.field) + if !unique { + return false + } + if promptRulesUseCarrier(state.application, proof.field) { + if promptRuleFieldHash(raw) != proof.afterHash { + return false + } + } else if value.Exists() && promptRuleFieldHash(raw) != proof.beforeHash { + return false + } + } + return len(state.rulesUndo) > 0 +} + +func promptRulesUseCarrier(application BusinessSystemPromptApplication, field string) bool { + if application.RulesPlan == nil { + return false + } + for _, placement := range application.RulesPlan.Placements { + if placement.Carrier == field { + return true + } + } + return false +} + +func rewritePromptRulesResponse(body []byte, application BusinessSystemPromptApplication, expose bool) ([]byte, error) { + if expose || application.PreserveInstructionsEcho || !application.Applied || application.FinalInstructions == "" || !json.Valid(body) { + return body, nil + } + out := body + for _, path := range []string{"instructions", "response.instructions", "error.instructions", "error.response.instructions"} { + value := gjson.GetBytes(out, path) + if value.Type != gjson.String || value.String() != application.FinalInstructions { + continue + } + var err error + if application.PublicInstructionsExists { + out, err = sjson.SetBytes(out, path, application.PublicInstructions) + } else { + out, err = sjson.DeleteBytes(out, path) + } + if err != nil { + return nil, err + } + } + return out, nil +} + +// Only redact exact structured echoes of carriers we changed. Never search +// model prose for matching text or remove a customer's identical message. +func rewritePromptRulesStructuredEcho(c *gin.Context, body []byte, protocol string) []byte { + value, exists := businessSystemPromptRequestGet(c, businessSystemPromptContextKey(c, businessSystemPromptRequestApplicationKey, protocol)) + if !exists || !json.Valid(body) { + return body + } + state, ok := value.(businessSystemPromptRequestState) + if !ok || state.application.RulesPlan == nil || state.application.ExposeServerPrompt || state.application.PreserveInstructionsEcho { + return body + } + out := body + for _, proof := range state.rulesUndo { + if proof.field == "instructions" { + continue + } + for _, prefix := range []string{"", "response.", "error.", "error.response.", "error.body."} { + path := prefix + proof.field + echo := gjson.GetBytes(out, path) + if !echo.Exists() || promptRuleFieldHash([]byte(echo.Raw)) != proof.afterHash { + continue + } + envelope, err := sjson.SetRawBytes([]byte(`{}`), proof.field, []byte(echo.Raw)) + if err != nil { + continue + } + clean, err := restorePromptRules(envelope, []promptRulesCarrierUndo{proof}) + if err != nil { + continue + } + original := gjson.GetBytes(clean, proof.field) + if original.Exists() { + out, err = sjson.SetRawBytes(out, path, []byte(original.Raw)) + } else { + out, err = sjson.DeleteBytes(out, path) + } + if err != nil { + return body + } + } + } + return out +} + +func rewritePromptRulesStructuredSSE(c *gin.Context, body []byte, protocol string) []byte { + lines := bytes.SplitAfter(body, []byte("\n")) + var result bytes.Buffer + for _, line := range lines { + if bytes.HasPrefix(line, []byte("data:")) { + start := len("data:") + for start < len(line) && (line[start] == ' ' || line[start] == '\t') { + start++ + } + end := len(line) + for end > start && (line[end-1] == '\n' || line[end-1] == '\r') { + end-- + } + result.Write(line[:start]) + result.Write(rewritePromptRulesStructuredEcho(c, line[start:end], protocol)) + result.Write(line[end:]) + } else { + result.Write(line) + } + } + return result.Bytes() +} + +const promptRequestedModelContextKey = "business_prompt_requested_model" + +func rememberPromptRequestedModel(c *gin.Context, body []byte) { + if c == nil { + return + } + if _, exists := businessSystemPromptRequestGet(c, promptRequestedModelContextKey); exists { + return + } + if model := gjson.GetBytes(body, "model").String(); model != "" { + businessSystemPromptRequestSet(c, promptRequestedModelContextKey, model) + } +} + +func enrichPromptTarget(c *gin.Context, body []byte, target BusinessSystemPromptTarget) BusinessSystemPromptTarget { + target.UpstreamModel = gjson.GetBytes(body, "model").String() + target.RequestedModel = target.UpstreamModel + if value, exists := businessSystemPromptRequestGet(c, promptRequestedModelContextKey); exists { + if model, ok := value.(string); ok && model != "" { + target.RequestedModel = model + } + } + return target +} + +func (s *OpenAIGatewayService) finalizeBusinessPromptForSend(c *gin.Context, account *Account, body []byte, protocol string, compact bool) ([]byte, error) { + updated, application, err := s.applyBusinessSystemPromptForRequest(c, body, account, protocol, compact) + if err != nil { + return nil, err + } + updated, err = rewriteBusinessSystemPromptCacheKey(c, updated, application) + if err != nil { + return nil, err + } + if err := validateBusinessSystemPromptFinal(c, updated, protocol); err != nil { + return nil, err + } + observePromptRulesFinal(c, account, protocol, application) + return updated, nil +} + +func writePromptDeliveryError(c *gin.Context, err error) { + if errors.Is(err, ErrPromptDeliveryUnsupported) && c != nil && c.Writer != nil && !c.Writer.Written() { + c.JSON(http.StatusUnprocessableEntity, gin.H{"error": gin.H{"type": "invalid_request_error", "code": "prompt_delivery_unsupported", "message": "The configured prompt role or position is not supported by this destination"}}) + } +} diff --git a/backend/internal/service/business_system_prompt_rules_gateway_test.go b/backend/internal/service/business_system_prompt_rules_gateway_test.go new file mode 100644 index 000000000000..7e12825c678b --- /dev/null +++ b/backend/internal/service/business_system_prompt_rules_gateway_test.go @@ -0,0 +1,308 @@ +package service + +import ( + "context" + "encoding/json" + "strings" + "testing" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + coderws "github.com/coder/websocket" + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/require" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +func newPromptRulesGatewayPolicy(delivery, position string) *BusinessSystemPromptService { + rule := extensionv1.PromptRule{ID: "site", Name: "Site rule", Enabled: true, TemplateID: 1, VersionID: 2, Order: 100, Delivery: delivery, Position: position, ModelMatch: "upstream", Models: []string{}} + hash, _, _ := extensionv1.ValidateTextDocument("site-rule-content", 100) + snapshot := BusinessSystemPromptSnapshot{Revision: 8, Enabled: true, RulePolicy: &extensionv1.PromptRulePolicy{Version: 1, Rules: []extensionv1.PromptRule{rule}, DefaultRuleIDs: []string{"site"}}, ResolvedRules: []extensionv1.ResolvedPromptRule{{Rule: rule, Body: "site-rule-content", SHA256: hash}}} + service := NewBusinessSystemPromptService(nil, nil) + service.snapshot.Store(&snapshot) + return service +} + +func TestPromptRulesFinalHTTPPaths(t *testing.T) { + gin.SetMode(gin.TestMode) + for _, path := range []string{"responses", "passthrough", "raw-chat", "responses-to-chat", "chat-to-responses", "messages-to-responses", "oauth"} { + t.Run(path, func(t *testing.T) { + account := businessSystemPromptAPIKeyAccount(true) + body := []byte(`{"model":"gpt-5.4","instructions":"client","stream":false,"input":[{"role":"user","content":"hello"}]}`) + delivery, position := "developer", "conversation_tail" + if path == "oauth" { + account.Type = AccountTypeOAuth + account.Credentials = map[string]any{"access_token": "fixture", "chatgpt_account_id": "fixture"} + delivery, position = "native_control", "control_prepend" + } + if path == "raw-chat" || path == "chat-to-responses" { + body = []byte(`{"model":"gpt-5.4","instructions":"unusual-client-field","stream":false,"messages":[{"role":"system","content":"client control"},{"role":"user","content":"hello"}]}`) + } + if path == "messages-to-responses" { + body = []byte(`{"model":"gpt-5.4","max_tokens":32,"stream":false,"system":"client control","messages":[{"role":"user","content":"hello"}]}`) + } + if path == "raw-chat" || path == "responses-to-chat" { + account.Extra["openai_responses_supported"] = false + } + c, _ := newBusinessSystemPromptGinContext("/v1/responses", body) + upstream := businessSystemPromptErrorUpstream() + gateway := &OpenAIGatewayService{cfg: businessSystemPromptTestConfig(), httpUpstream: upstream, businessPromptService: newPromptRulesGatewayPolicy(delivery, position)} + var err error + switch path { + case "passthrough": + _, err = gateway.forwardOpenAIPassthrough(context.Background(), c, account, body, body, "gpt-5.4", false, false, time.Now()) + case "raw-chat": + _, err = gateway.forwardAsRawChatCompletions(context.Background(), c, account, body, "") + case "responses-to-chat": + _, err = gateway.forwardResponsesViaRawChatCompletions(context.Background(), c, account, body, false) + case "chat-to-responses": + _, err = gateway.ForwardAsChatCompletions(context.Background(), c, account, body, "", "") + case "messages-to-responses": + _, err = gateway.ForwardAsAnthropic(context.Background(), c, account, body, "", "") + default: + _, err = gateway.Forward(context.Background(), c, account, body) + } + require.Error(t, err, "the offline upstream intentionally returns a capture-complete error") + require.NotNil(t, upstream.lastReq, "%v", err) + require.Equal(t, 1, strings.Count(string(upstream.lastBody), "site-rule-content")) + if path == "oauth" { + require.Equal(t, "site-rule-content\n\nclient", gjson.GetBytes(upstream.lastBody, "instructions").String()) + return + } + field := "input" + if path == "raw-chat" || path == "responses-to-chat" { + field = "messages" + } + items := gjson.GetBytes(upstream.lastBody, field).Array() + require.NotEmpty(t, items) + require.Equal(t, "developer", items[len(items)-1].Get("role").String()) + require.Equal(t, "site-rule-content", items[len(items)-1].Get("content").String()) + if path == "raw-chat" { + require.Equal(t, "unusual-client-field", gjson.GetBytes(upstream.lastBody, "instructions").String()) + } + }) + } +} + +func TestPromptRulesRetryScopeRestoresOnlyOwnedInsertions(t *testing.T) { + policy := newPromptRulesGatewayPolicy("system", "control_prepend") + gateway := &OpenAIGatewayService{businessPromptService: policy} + account := businessSystemPromptAPIKeyAccount(true) + input := []byte(`{"model":"model-a","prompt_cache_key":"client-cache","instructions":"client","input":[{"role":"system","content":"site-rule-content"},{"role":"user","content":"hello"}],"previous_response_id":"resp_keep"}`) + c, _ := newBusinessSystemPromptGinContext("/v1/responses", input) + first, err := gateway.finalizeBusinessPromptForSend(c, account, input, "responses", false) + require.NoError(t, err) + retry, err := gateway.finalizeBusinessPromptForSend(c, account, first, "responses", false) + require.NoError(t, err) + require.Equal(t, first, retry) + require.Equal(t, 2, strings.Count(string(retry), "site-rule-content"), "the identical customer message must remain") + account.Extra[PromptAccountBindingExtraKey] = extensionv1.PromptAccountBinding{Mode: "off"} + clean, err := gateway.finalizeBusinessPromptForSend(c, account, retry, "responses", false) + require.NoError(t, err) + require.JSONEq(t, string(input), string(clean)) + account.Extra[PromptAccountBindingExtraKey] = extensionv1.PromptAccountBinding{Mode: "inherit"} + policy.snapshot.Store(&BusinessSystemPromptSnapshot{Revision: 9, Enabled: false}) + previousSnapshot, _, err := gateway.businessSystemPromptSnapshotForRequest(c, account) + require.NoError(t, err) + require.Equal(t, int64(8), previousSnapshot.Revision) + reapplied, err := gateway.finalizeBusinessPromptForSend(c, account, clean, "responses", false) + require.NoError(t, err) + require.Equal(t, 2, strings.Count(string(reapplied), "site-rule-content")) + require.Equal(t, "resp_keep", gjson.GetBytes(reapplied, "previous_response_id").String()) + convertedInput, err := restoreBusinessSystemPromptBeforeConversion(c, reapplied, "responses") + require.NoError(t, err) + require.JSONEq(t, gjson.GetBytes(input, "input").Raw, gjson.GetBytes(convertedInput, "input").Raw) +} + +func TestPromptRulesPassthroughFirstAndSecondTurnWire(t *testing.T) { + gin.SetMode(gin.TestMode) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + upstream := newStagedPassthroughConn() + defer func() { _ = upstream.Close() }() + gateway := newPassthroughLifecycleService(passthroughLifecycleConfig(), upstream) + gateway.businessPromptService = newPromptRulesGatewayPolicy("system", "conversation_tail") + server, _ := startPassthroughLifecycleServer(t, ctx, gateway, passthroughLifecycleAccount()) + defer server.Close() + client, _, err := coderws.Dial(ctx, "ws"+strings.TrimPrefix(server.URL, "http"), nil) + require.NoError(t, err) + defer func() { _ = client.CloseNow() }() + for turn := 1; turn <= 2; turn++ { + body := []byte(`{"type":"response.create","model":"gpt-5.4","input":[{"role":"user","content":"hello"}],"instructions":"client"}`) + if turn == 2 { + body, err = sjson.SetBytes(body, "previous_response_id", "resp_one") + require.NoError(t, err) + } + writeCtx, writeCancel := context.WithTimeout(ctx, 3*time.Second) + err = client.Write(writeCtx, coderws.MessageText, body) + writeCancel() + require.NoError(t, err) + select { + case sent := <-upstream.writes: + require.Equal(t, "system", gjson.GetBytes(sent, "input.1.role").String()) + require.Equal(t, "site-rule-content", gjson.GetBytes(sent, "input.1.content").String()) + require.Equal(t, 1, strings.Count(string(sent), "site-rule-content")) + if turn == 2 { + require.Equal(t, "resp_one", gjson.GetBytes(sent, "previous_response_id").String()) + } + case <-time.After(3 * time.Second): + t.Fatal("no captured websocket request") + } + upstream.Send(`{"type":"response.completed","response":{"id":"resp_one","model":"gpt-5.4","status":"completed","output":[],"usage":{"input_tokens":1,"output_tokens":1}}}`) + readCtx, readCancel := context.WithTimeout(ctx, 3*time.Second) + _, payload, err := client.Read(readCtx) + readCancel() + require.NoError(t, err) + require.Equal(t, "response.completed", gjson.GetBytes(payload, "type").String()) + } +} + +type promptRulesPreviewAccountRepo struct { + AccountRepository + account *Account +} + +func (r *promptRulesPreviewAccountRepo) GetByID(context.Context, int64) (*Account, error) { + return r.account, nil +} + +func TestPromptRulesPreviewMatchesFinalHTTPControlBytes(t *testing.T) { + policy := newPromptRulesGatewayPolicy("developer", "conversation_tail") + account := businessSystemPromptAPIKeyAccount(true) + policy.accountRepo = &promptRulesPreviewAccountRepo{account: account} + body := []byte(`{"model":"gpt-5.4","stream":false,"instructions":"client","input":[{"role":"user","content":"hello"}]}`) + preview, err := policy.PreviewPromptRules(context.Background(), account.ID, PromptRulesPreviewRequest{Protocol: "responses", Body: json.RawMessage(body)}) + require.NoError(t, err) + c, _ := newBusinessSystemPromptGinContext("/v1/responses", body) + upstream := businessSystemPromptErrorUpstream() + gateway := &OpenAIGatewayService{cfg: businessSystemPromptTestConfig(), httpUpstream: upstream, businessPromptService: policy} + _, err = gateway.Forward(context.Background(), c, account, body) + require.Error(t, err) + require.NotNil(t, upstream.lastReq) + require.JSONEq(t, gjson.GetBytes(preview.Body, "input").Raw, gjson.GetBytes(upstream.lastBody, "input").Raw) + require.Equal(t, gjson.GetBytes(preview.Body, "instructions").String(), gjson.GetBytes(upstream.lastBody, "instructions").String()) +} + +func TestPromptRulesNativeWSReplayKeepsCleanAccumulatorAndFrozenPolicy(t *testing.T) { + policy := newPromptRulesGatewayPolicy("developer", "conversation_tail") + gateway := &OpenAIGatewayService{businessPromptService: policy} + account := businessSystemPromptAPIKeyAccount(true) + first := []byte(`{"model":"gpt-5.4","input":[{"role":"user","content":"first"}],"previous_response_id":"resp_anchor"}`) + c, _ := newBusinessSystemPromptGinContext("/v1/responses", first) + beginBusinessSystemPromptRequestTurn(c) + parsed, plan, err := gateway.prepareBusinessPromptWSIngress(c, first, account, "responses", false) + require.NoError(t, err) + require.True(t, plan.Applied) + require.Equal(t, first, parsed, "the accumulator must never receive the site's messages") + wire, err := gateway.finalizeBusinessPromptWSIngress(c, account, parsed) + require.NoError(t, err) + require.Equal(t, 1, strings.Count(string(wire), "site-rule-content")) + policy.snapshot.Store(&BusinessSystemPromptSnapshot{Revision: 9, Enabled: false}) + replay := []byte(`{"model":"gpt-5.4","input":[{"role":"user","content":"earlier"},{"role":"assistant","content":"answer"},{"role":"user","content":"first"}],"previous_response_id":"resp_anchor"}`) + wire, err = gateway.finalizeBusinessPromptWSIngress(c, account, replay) + require.NoError(t, err) + require.Equal(t, 1, strings.Count(string(wire), "site-rule-content")) + require.Equal(t, "developer", gjson.GetBytes(wire, "input.3.role").String()) + require.Equal(t, "resp_anchor", gjson.GetBytes(wire, "previous_response_id").String()) + require.NotContains(t, string(replay), "site-rule-content") + application, ok := businessSystemPromptApplicationFromRequest(c, "responses") + require.True(t, ok) + require.Equal(t, int64(8), application.Revision) +} + +func TestPromptRulesOAuthPreviewMatchesControlAdapters(t *testing.T) { + for _, protocol := range []string{"responses", "chat", "messages"} { + t.Run(protocol, func(t *testing.T) { + account := &Account{ID: 62, Platform: PlatformOpenAI, Type: AccountTypeOAuth, Status: StatusActive, Schedulable: true, Concurrency: 1, Credentials: map[string]any{"access_token": "fixture", "chatgpt_account_id": "fixture"}} + body := []byte(`{"model":"gpt-6-astra","stream":false,"input":[{"role":"system","content":"client system"},{"role":"user","content":"hello"}]}`) + if protocol == "chat" { + body = []byte(`{"model":"gpt-6-astra","stream":false,"messages":[{"role":"system","content":"client system"},{"role":"user","content":"hello"}]}`) + } + if protocol == "messages" { + body = []byte(`{"model":"gpt-6-astra","stream":false,"max_tokens":32,"system":"client system","messages":[{"role":"user","content":"hello"}]}`) + } + policy := newPromptRulesGatewayPolicy("native_control", "control_append") + policy.accountRepo = &promptRulesPreviewAccountRepo{account: account} + cfg := businessSystemPromptTestConfig() + cfg.Gateway.ForcedCodexInstructionsTemplate = "base {{.ExistingInstructions}}" + policy.previewConfig = cfg + preview, err := policy.PreviewPromptRules(context.Background(), account.ID, PromptRulesPreviewRequest{Protocol: protocol, Body: json.RawMessage(body)}) + require.NoError(t, err) + c, _ := newBusinessSystemPromptGinContext("/v1/responses", body) + upstream := businessSystemPromptErrorUpstream() + gateway := &OpenAIGatewayService{cfg: cfg, httpUpstream: upstream, businessPromptService: policy} + switch protocol { + case "chat": + _, err = gateway.ForwardAsChatCompletions(context.Background(), c, account, body, "", "") + case "messages": + _, err = gateway.ForwardAsAnthropic(context.Background(), c, account, body, "", "") + default: + _, err = gateway.Forward(context.Background(), c, account, body) + } + require.Error(t, err) + require.NotNil(t, upstream.lastReq, "%v", err) + require.Equal(t, gjson.GetBytes(upstream.lastBody, "instructions").String(), gjson.GetBytes(preview.Body, "instructions").String()) + require.JSONEq(t, gjson.GetBytes(upstream.lastBody, "input").Raw, gjson.GetBytes(preview.Body, "input").Raw) + }) + } +} + +type promptRulesBindingRepo struct { + AccountRepository + accounts []*Account + updates []PromptBindingUpdate +} + +func (r *promptRulesBindingRepo) GetByIDs(context.Context, []int64) ([]*Account, error) { + return r.accounts, nil +} +func (r *promptRulesBindingRepo) UpdatePromptBindingIfRevision(_ context.Context, id int64, expected time.Time, _ int64, binding extensionv1.PromptAccountBinding) (bool, error) { + r.updates = append(r.updates, PromptBindingUpdate{AccountID: id, ExpectedUpdatedAt: expected, Binding: binding}) + return id != 2, nil +} + +func TestPromptRulesAccountBindingsCASAndShadowIndependence(t *testing.T) { + policy := newPromptRulesGatewayPolicy("native_control", "control_append") + parentID := int64(1) + updated := time.Date(2026, 9, 23, 0, 0, 0, 0, time.UTC) + parent := &Account{ID: parentID, Platform: PlatformOpenAI, Type: AccountTypeOAuth, UpdatedAt: updated, Extra: map[string]any{PromptAccountBindingExtraKey: extensionv1.PromptAccountBinding{Mode: "off"}}} + shadow := &Account{ID: 2, ParentAccountID: &parentID, Platform: PlatformOpenAI, Type: AccountTypeOAuth, UpdatedAt: updated} + repo := &promptRulesBindingRepo{accounts: []*Account{parent, shadow}} + policy.accountRepo = repo + views, err := policy.PromptAccountBindings(context.Background(), []int64{1, 2}) + require.NoError(t, err) + require.Equal(t, "off", views[0].Binding.Mode) + require.Equal(t, "inherit", views[1].Binding.Mode) + require.Equal(t, []string{"site"}, views[1].EffectiveRuleIDs) + updates := []PromptBindingUpdate{{AccountID: 1, ExpectedUpdatedAt: updated, Binding: extensionv1.PromptAccountBinding{Mode: "custom", RuleIDs: []string{"site"}}}, {AccountID: 2, ExpectedUpdatedAt: updated, Binding: extensionv1.PromptAccountBinding{Mode: "off"}}} + _, err = policy.UpdatePromptAccountBindings(context.Background(), updates, 7) + require.ErrorIs(t, err, ErrBusinessSystemPromptRevisionConflict) + require.Empty(t, repo.updates) + results, err := policy.UpdatePromptAccountBindings(context.Background(), updates, 8) + require.NoError(t, err) + require.True(t, results[0].Applied) + require.Equal(t, "account_revision_conflict", results[1].Code) + require.Len(t, repo.updates, 2) + encoded, _ := json.Marshal(repo.updates) + require.NotContains(t, string(encoded), "site-rule-content") +} + +func TestPromptRulesExecutionScopeRevocationRestoresWireAndCacheKey(t *testing.T) { + gateway, invoker, _ := newAccountScopedPromptGateway(t, 100) + gateway.businessPromptService = newPromptRulesGatewayPolicy("developer", "conversation_tail") + account := businessSystemPromptAPIKeyAccount(true) + input := []byte(`{"model":"gpt-5.4","prompt_cache_key":"original","input":[{"role":"user","content":"hello"}]}`) + c, _ := newBusinessSystemPromptGinContext("/v1/responses", input) + wire, err := gateway.finalizeBusinessPromptForSend(c, account, input, "responses", false) + require.NoError(t, err) + require.Contains(t, string(wire), "site-rule-content") + invoker.installation.Bindings[0].RolloutPercent = 0 + clean, err := gateway.finalizeBusinessPromptForSend(c, account, wire, "responses", false) + require.NoError(t, err) + require.JSONEq(t, string(input), string(clean)) + application, ok := businessSystemPromptApplicationFromRequest(c, "responses") + require.True(t, ok) + require.False(t, application.Applied) + require.Equal(t, "plugin_scope", application.RulesPlan.Skipped[0].Reason) +} diff --git a/backend/internal/service/business_system_prompt_rules_observation.go b/backend/internal/service/business_system_prompt_rules_observation.go new file mode 100644 index 000000000000..abb5b53e5d91 --- /dev/null +++ b/backend/internal/service/business_system_prompt_rules_observation.go @@ -0,0 +1,32 @@ +package service + +import ( + "fmt" + "log/slog" + + "github.com/gin-gonic/gin" +) + +func observePromptRulesFinal(c *gin.Context, account *Account, protocol string, application BusinessSystemPromptApplication) { + if application.RulesPlan == nil || account == nil { + return + } + key := businessSystemPromptContextKey(c, "prompt_rules_final_observed", protocol) + identity := fmt.Sprint(account.ID) + ":" + application.RulesPlan.SHA256 + ":" + protocol + if value, exists := businessSystemPromptRequestGet(c, key); exists && value == identity { + return + } + businessSystemPromptRequestSet(c, key, identity) + placements := make([]map[string]any, 0, len(application.RulesPlan.Placements)) + for _, placement := range application.RulesPlan.Placements { + placements = append(placements, map[string]any{"rule_id": placement.RuleID, "version_id": placement.VersionID, "carrier": placement.Carrier, "role": placement.Role, "position": placement.Position}) + } + slog.Info("prompt_rules_final", "account_id", account.ID, "protocol", protocol, "revision", application.Revision, + "applied", application.Applied, "plan_sha256", application.RulesPlan.SHA256, "placements", placements, "skipped", application.RulesPlan.Skipped, "wire_verified", true) +} + +func observePromptRulesFinalFromRequest(c *gin.Context, account *Account, protocol string) { + if application, ok := businessSystemPromptApplicationFromRequest(c, protocol); ok { + observePromptRulesFinal(c, account, protocol, application) + } +} diff --git a/backend/internal/service/business_system_prompt_rules_preview.go b/backend/internal/service/business_system_prompt_rules_preview.go new file mode 100644 index 000000000000..7365e08643f5 --- /dev/null +++ b/backend/internal/service/business_system_prompt_rules_preview.go @@ -0,0 +1,278 @@ +package service + +import ( + "context" + "encoding/json" + "fmt" + "maps" + "net/http" + "strings" + + "github.com/Wei-Shaw/sub2api/internal/pkg/apicompat" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/gin-gonic/gin" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +type PromptRulesPreviewRequest struct { + Protocol string `json:"protocol"` + Transport string `json:"transport"` + Compact bool `json:"compact"` + Body json.RawMessage `json:"body"` + Policy *extensionv1.PromptRulePolicy `json:"policy,omitempty"` + Binding *extensionv1.PromptAccountBinding `json:"binding,omitempty"` + SimulateEnabled *bool `json:"simulate_enabled,omitempty"` +} + +type PromptRulesPreviewResult struct { + AccountID int64 `json:"account_id"` + RequestedModel string `json:"requested_model"` + UpstreamModel string `json:"upstream_model"` + Protocol string `json:"protocol"` + Transport string `json:"transport"` + Body json.RawMessage `json:"body"` + BeforeRules json.RawMessage `json:"before_rules"` + ClientControl map[string]any `json:"client_control"` + GatewayBaseInstructions string `json:"gateway_base_instructions"` + Application BusinessSystemPromptApplication `json:"application"` + Continuation bool `json:"continuation"` + SequenceScope string `json:"sequence_scope"` + Simulated bool `json:"simulated"` + WireVerified bool `json:"wire_verified"` +} + +func (s *BusinessSystemPromptService) PreviewPromptRules(ctx context.Context, accountID int64, request PromptRulesPreviewRequest) (PromptRulesPreviewResult, error) { + result := PromptRulesPreviewResult{AccountID: accountID, Transport: request.Transport, SequenceScope: "current_outbound_sequence"} + if s.accountRepo == nil || !json.Valid(request.Body) || len(request.Body) > 1<<20 { + return result, ErrBusinessSystemPromptInvalid + } + account, err := s.accountRepo.GetByID(ctx, accountID) + if err != nil { + return result, err + } + if account == nil || !account.IsOpenAI() { + return result, ErrPromptDeliveryUnsupported + } + snapshot, ok := s.CurrentSnapshot() + if !ok || snapshot.RulePolicy == nil { + return result, ErrBusinessSystemPromptUnavailable + } + if request.Policy != nil { + snapshot.RulePolicy = request.Policy + if err := s.preparePromptRulesSnapshot(&snapshot); err != nil { + return result, err + } + result.Simulated = true + } + if request.SimulateEnabled != nil { + snapshot.Enabled = *request.SimulateEnabled + result.Simulated = true + } + if request.Binding != nil { + cloned := *account + cloned.Extra = maps.Clone(account.Extra) + if cloned.Extra == nil { + cloned.Extra = map[string]any{} + } + cloned.Extra[PromptAccountBindingExtraKey] = request.Binding + account = &cloned + result.Simulated = true + } + before, protocol, base, err := s.preparePromptRulesPreviewBody(account, request) + if err != nil { + return result, err + } + result.Protocol, result.BeforeRules, result.GatewayBaseInstructions = protocol, before, base + result.RequestedModel = gjson.GetBytes(request.Body, "model").String() + result.UpstreamModel = gjson.GetBytes(before, "model").String() + result.ClientControl = promptPreviewClientControl(request.Body) + result.Continuation = gjson.GetBytes(before, "previous_response_id").String() != "" || gjson.GetBytes(before, "input.#(type==\"compaction\")").Exists() + if result.Transport == "" { + result.Transport = "http" + } + if result.Transport != "http" && result.Transport != "ws" { + return result, ErrBusinessSystemPromptInvalid + } + if result.Transport == "ws" && protocol != BusinessSystemPromptProtocolResponses { + return result, ErrPromptDeliveryUnsupported + } + target := businessSystemPromptTargetForAccount(account, protocol, request.Compact) + target.RequestedModel, target.UpstreamModel = result.RequestedModel, result.UpstreamModel + updated, application, err := ApplyBusinessSystemPromptToJSONContext(ctx, before, snapshot, target) + if err != nil { + return result, err + } + // This is the identical applier and final carrier validator used at live + // HTTP/WS write boundaries. No credentials, ticket, network, or model IO. + ginContext := &gin.Context{} + ginContext.Request, _ = http.NewRequestWithContext(ctx, http.MethodPost, "/preview", nil) + businessSystemPromptRequestSet(ginContext, businessSystemPromptContextKey(ginContext, businessSystemPromptRequestApplicationKey, protocol), cacheBusinessSystemPromptState(before, updated, snapshot, target, application)) + if err := validateBusinessSystemPromptFinal(ginContext, updated, protocol); err != nil { + return result, err + } + if result.Transport == "ws" { + updated, err = sjson.SetBytes(updated, "type", "response.create") + if err != nil { + return result, err + } + } + result.Body, result.Application, result.WireVerified = updated, application, true + return result, nil +} + +func (s *BusinessSystemPromptService) preparePromptRulesPreviewBody(account *Account, request PromptRulesPreviewRequest) ([]byte, string, string, error) { + ingress := request.Protocol + if ingress == "" { + ingress = BusinessSystemPromptProtocolResponses + } + if ingress != BusinessSystemPromptProtocolResponses && ingress != BusinessSystemPromptProtocolChat && ingress != "messages" { + return nil, "", "", ErrBusinessSystemPromptInvalid + } + protocol := BusinessSystemPromptProtocolResponses + if !account.UsesOpenAICodexProtocol() && shouldForwardOpenAIResponsesViaRawChatCompletions(account) { + protocol = BusinessSystemPromptProtocolChat + } + body := []byte(request.Body) + requested := strings.TrimSpace(gjson.GetBytes(body, "model").String()) + if requested == "" { + return nil, "", "", fmt.Errorf("%w: preview model is required", ErrBusinessSystemPromptInvalid) + } + mapped := resolveOpenAIForwardModel(account, requested, "") + if mapped == "" { + mapped = requested + } + mapped = normalizeOpenAIModelForUpstream(account, mapped) + var err error + if ingress != protocol { + var responses *apicompat.ResponsesRequest + switch ingress { + case BusinessSystemPromptProtocolChat: + var chat apicompat.ChatCompletionsRequest + if json.Unmarshal(body, &chat) != nil { + return nil, "", "", ErrBusinessSystemPromptInvalid + } + responses, err = apicompat.ChatCompletionsToResponses(&chat) + case "messages": + var messages apicompat.AnthropicRequest + if json.Unmarshal(body, &messages) != nil { + return nil, "", "", ErrBusinessSystemPromptInvalid + } + responses, err = apicompat.AnthropicToResponses(&messages) + default: + responses = &apicompat.ResponsesRequest{} + err = json.Unmarshal(body, responses) + } + if err != nil { + return nil, "", "", err + } + if protocol == BusinessSystemPromptProtocolChat { + chat, err := apicompat.ResponsesToChatCompletionsRequest(responses) + if err != nil { + return nil, "", "", err + } + body, err = json.Marshal(chat) + if err != nil { + return nil, "", "", err + } + } else { + body, err = json.Marshal(responses) + if err != nil { + return nil, "", "", err + } + } + } + body, err = sjson.SetBytes(body, "model", mapped) + if err != nil { + return nil, "", "", err + } + base := "" + if account.UsesOpenAICodexProtocol() { + var object map[string]any + if json.Unmarshal(body, &object) != nil { + return nil, "", "", ErrBusinessSystemPromptInvalid + } + previous, previousExists := object["previous_response_id"] + defaultMode := OpenAIWSIngressModeCtxPool + if s.previewConfig != nil && s.previewConfig.Gateway.OpenAIWS.IngressModeDefault != "" { + defaultMode = s.previewConfig.Gateway.OpenAIWS.IngressModeDefault + } + passthrough := (request.Transport == "ws" && account.ResolveOpenAIResponsesWebSocketV2Mode(defaultMode) == OpenAIWSIngressModePassthrough) || (request.Transport != "ws" && ingress == BusinessSystemPromptProtocolResponses && account.IsOpenAIPassthroughEnabled()) + if passthrough { + if request.Transport != "ws" && detectOpenAIPassthroughInstructionsRejectReason(mapped, body) != "" { + return nil, "", "", fmt.Errorf("%w: Codex passthrough requires nonempty client instructions", ErrBusinessSystemPromptInvalid) + } + if request.Transport != "ws" && isOpenAICodexModel(mapped) && !gjson.GetBytes(body, "instructions").Exists() { + base = defaultCodexSynthInstructions(mapped) + body, err = sjson.SetBytes(body, "instructions", base) + } + return body, protocol, base, err + } + // Native Responses adds its model base before promoting client system + // text. Chat and Messages adapters deliberately leave defaults disabled. + skipDefault := ingress != BusinessSystemPromptProtocolResponses + if !skipDefault && isInstructionsEmpty(object) { + base = defaultCodexSynthInstructions(mapped) + object["instructions"] = base + } + omitSystem := ingress != "messages" && !strings.EqualFold(strings.TrimSpace(gjson.GetBytes(body, "text.format.type").String()), "json_object") + transformed := applyCodexOAuthTransformWithOptions(object, codexOAuthTransformOptions{IsCodexCLI: true, IsCompact: request.Compact, SkipDefaultInstructions: skipDefault, PreserveToolCallIDs: ingress != BusinessSystemPromptProtocolResponses, OmitPromotedSystemMessagesFromInput: omitSystem}) + if transformed.Error != nil { + return nil, "", "", transformed.Error + } + if previousExists { + object["previous_response_id"] = previous + } + if ingress == "messages" { + forced := "" + if s.previewConfig != nil { + forced = s.previewConfig.Gateway.ForcedCodexInstructionsTemplate + } + existing, _ := object["instructions"].(string) + if strings.TrimSpace(existing) == "" { + existing = extractPromptLikeInstructionsFromInput(object) + } + if _, err := applyForcedCodexInstructionsTemplate(object, forced, forcedCodexInstructionsTemplateData{ExistingInstructions: strings.TrimSpace(existing), OriginalModel: requested, NormalizedModel: normalizeCodexModel(requested), BillingModel: mapped, UpstreamModel: transformed.NormalizedModel}); err != nil { + return nil, "", "", err + } + if forced != "" { + base, _ = object["instructions"].(string) + } + if shouldAutoInjectPromptCacheKeyForCompat(mapped) { + appendOpenAICompatClaudeCodeTodoGuardToRequestBody(object) + } + } + if skipDefault { + ensureCodexOAuthInstructionsField(object) + } + body, err = json.Marshal(object) + if err != nil { + return nil, "", "", err + } + } + return body, protocol, base, nil +} + +func promptPreviewClientControl(body []byte) map[string]any { + control := map[string]any{} + for _, field := range []string{"instructions", "system"} { + value := gjson.GetBytes(body, field) + if value.Exists() { + control[field] = value.Value() + } + } + for _, field := range []string{"messages", "input"} { + items := []any{} + gjson.GetBytes(body, field).ForEach(func(_, item gjson.Result) bool { + role := item.Get("role").String() + if role == "system" || role == "developer" { + items = append(items, item.Value()) + } + return true + }) + if len(items) > 0 { + control[field] = items + } + } + return control +} diff --git a/backend/internal/service/business_system_prompt_rules_service.go b/backend/internal/service/business_system_prompt_rules_service.go new file mode 100644 index 000000000000..46b167e939ae --- /dev/null +++ b/backend/internal/service/business_system_prompt_rules_service.go @@ -0,0 +1,267 @@ +package service + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "slices" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +const PromptAccountBindingExtraKey = "prompt_skills" + +var ErrPromptRuleReferenced = errors.New("prompt_rule_referenced_by_account") + +type BusinessSystemPromptRulesStore interface { + LoadBusinessSystemPromptRules(context.Context) (BusinessSystemPromptSnapshot, error) + UpdateBusinessSystemPromptRules(context.Context, extensionv1.PromptRulePolicy, int64, int64) error +} + +func (s *BusinessSystemPromptService) SetAccountRepository(repo AccountRepository) { + s.accountRepo = repo +} + +func (s *BusinessSystemPromptService) loadPromptSnapshot(ctx context.Context) (BusinessSystemPromptSnapshot, error) { + if store, ok := s.store.(BusinessSystemPromptRulesStore); ok { + return store.LoadBusinessSystemPromptRules(ctx) + } + return s.store.LoadBusinessSystemPrompt(ctx) +} + +func (s *BusinessSystemPromptService) preparePromptRulesSnapshot(snapshot *BusinessSystemPromptSnapshot) error { + var normalized extensionv1.PromptRulePolicy + if err := invokePromptManagement(context.Background(), "prompt.rules.validate", *snapshot.RulePolicy, &normalized); err != nil { + return err + } + snapshot.RulePolicy = &normalized + snapshot.ResolvedRules = nil + total := 0 + for _, rule := range normalized.Rules { + if !rule.Enabled { + continue + } + if rule.FollowActive { + rule.TemplateID, rule.VersionID = snapshot.TemplateID, snapshot.VersionID + } + if rule.TemplateID == 0 || rule.VersionID == 0 { + if !snapshot.Enabled { + continue + } + return ErrBusinessSystemPromptVersionNotFound + } + detail, err := s.store.GetBusinessSystemPromptTemplate(context.Background(), rule.TemplateID) + if err != nil { + return err + } + index := slices.IndexFunc(detail.Versions, func(version BusinessSystemPromptVersion) bool { return version.ID == rule.VersionID }) + if index < 0 { + return ErrBusinessSystemPromptVersionNotFound + } + version := detail.Versions[index] + content := BusinessSystemPromptSnapshot{Enabled: true, Revision: snapshot.Revision, TemplateID: rule.TemplateID, VersionID: rule.VersionID, Body: version.Body, SHA256: version.SHA256, ByteLength: version.ByteLength, CompositionMode: version.CompositionMode, BundleID: version.BundleID, BundleManifestSHA256: version.BundleManifestSHA256} + if err := s.prepareBusinessSystemPromptSnapshot(&content); err != nil { + return err + } + content, err = s.compileBusinessSystemPromptSnapshot(content) + if err != nil { + return err + } + hash, size, err := validateBusinessSystemPromptBodyWithLimit(content.Body, extensionv1.PromptRulesMaxBytes) + if err != nil { + return err + } + total += size + if total > extensionv1.PromptRulesMaxBytes { + return fmt.Errorf("%w: compiled rule set exceeds 256 KiB", ErrBusinessSystemPromptInvalid) + } + snapshot.ResolvedRules = append(snapshot.ResolvedRules, extensionv1.ResolvedPromptRule{Rule: rule, Body: content.Body, SHA256: hash, PreserveEcho: version.CompositionMode == BusinessSystemPromptCompositionCodexSkillHybrid}) + } + return nil +} + +type PromptRulePolicyState struct { + Policy extensionv1.PromptRulePolicy `json:"policy"` + Revision int64 `json:"revision"` + Enabled bool `json:"enabled"` + CompactEnabled bool `json:"compact_enabled"` +} + +func (s *BusinessSystemPromptService) PromptRulesState() (PromptRulePolicyState, error) { + snapshot, ok := s.CurrentSnapshot() + if !ok || snapshot.RulePolicy == nil { + return PromptRulePolicyState{}, ErrBusinessSystemPromptUnavailable + } + return PromptRulePolicyState{Policy: *snapshot.RulePolicy, Revision: snapshot.Revision, Enabled: snapshot.Enabled, CompactEnabled: snapshot.CompactEnabled}, nil +} + +func (s *BusinessSystemPromptService) UpdatePromptRules(ctx context.Context, policy extensionv1.PromptRulePolicy, expected, actor int64) (PromptRulePolicyState, error) { + store, ok := s.store.(BusinessSystemPromptRulesStore) + if !ok { + return PromptRulePolicyState{}, ErrBusinessSystemPromptUnavailable + } + current, ok := s.CurrentSnapshot() + if !ok { + return PromptRulePolicyState{}, ErrBusinessSystemPromptUnavailable + } + if current.Revision != expected { + return PromptRulePolicyState{}, ErrBusinessSystemPromptRevisionConflict + } + current.RulePolicy = &policy + if err := s.preparePromptRulesSnapshot(¤t); err != nil { + return PromptRulePolicyState{}, err + } + if err := store.UpdateBusinessSystemPromptRules(ctx, *current.RulePolicy, expected, actor); err != nil { + return PromptRulePolicyState{}, err + } + if err := s.Reload(ctx); err != nil { + return PromptRulePolicyState{}, err + } + state, err := s.PromptRulesState() + if err == nil && s.bus != nil { + _ = s.bus.Publish(ctx, state.Revision) + } + return state, err +} + +type PromptAccountBindingView struct { + AccountID int64 `json:"account_id"` + Name string `json:"name"` + Platform string `json:"platform"` + AccountType string `json:"account_type"` + UpdatedAt time.Time `json:"updated_at"` + Binding extensionv1.PromptAccountBinding `json:"binding"` + EffectiveRuleIDs []string `json:"effective_rule_ids"` + Supported bool `json:"supported"` +} + +func promptBindingForAccount(account *Account) (extensionv1.PromptAccountBinding, error) { + binding := extensionv1.PromptAccountBinding{Mode: "inherit", RuleIDs: []string{}} + if account == nil || account.Extra == nil || account.Extra[PromptAccountBindingExtraKey] == nil { + return binding, nil + } + raw, err := json.Marshal(account.Extra[PromptAccountBindingExtraKey]) + if err != nil || json.Unmarshal(raw, &binding) != nil { + return binding, ErrBusinessSystemPromptInvalid + } + if binding.Mode != "inherit" && binding.Mode != "off" && binding.Mode != "custom" { + return binding, ErrBusinessSystemPromptInvalid + } + if binding.RuleIDs == nil { + binding.RuleIDs = []string{} + } + return binding, nil +} + +func (s *BusinessSystemPromptService) PromptAccountBindings(ctx context.Context, ids []int64) ([]PromptAccountBindingView, error) { + if s.accountRepo == nil || len(ids) == 0 || len(ids) > 100 { + return nil, ErrBusinessSystemPromptInvalid + } + state, err := s.PromptRulesState() + if err != nil { + return nil, err + } + accounts, err := s.accountRepo.GetByIDs(ctx, ids) + if err != nil { + return nil, err + } + if len(accounts) != len(ids) { + return nil, ErrAccountNotFound + } + views := make([]PromptAccountBindingView, 0, len(accounts)) + for _, account := range accounts { + binding, err := promptBindingForAccount(account) + if err != nil { + return nil, err + } + effective := []string{} + if binding.Mode == "inherit" { + effective = state.Policy.DefaultRuleIDs + } else if binding.Mode == "custom" { + effective = binding.RuleIDs + } + views = append(views, PromptAccountBindingView{AccountID: account.ID, Name: account.Name, Platform: account.Platform, AccountType: account.Type, UpdatedAt: account.UpdatedAt, Binding: binding, EffectiveRuleIDs: effective, Supported: account.IsOpenAI()}) + } + return views, nil +} + +type PromptBindingUpdate struct { + AccountID int64 `json:"account_id"` + ExpectedUpdatedAt time.Time `json:"expected_updated_at"` + Binding extensionv1.PromptAccountBinding `json:"binding"` +} + +type PromptBindingUpdateResult struct { + AccountID int64 `json:"account_id"` + Applied bool `json:"applied"` + Code string `json:"code,omitempty"` +} + +func (s *BusinessSystemPromptService) UpdatePromptAccountBindings(ctx context.Context, updates []PromptBindingUpdate, expectedRevision int64) ([]PromptBindingUpdateResult, error) { + if len(updates) == 0 || len(updates) > 100 { + return nil, ErrBusinessSystemPromptInvalid + } + writer, ok := s.accountRepo.(interface { + UpdatePromptBindingIfRevision(context.Context, int64, time.Time, int64, extensionv1.PromptAccountBinding) (bool, error) + }) + if !ok { + return nil, ErrBusinessSystemPromptUnavailable + } + state, err := s.PromptRulesState() + if err != nil { + return nil, err + } + if state.Revision != expectedRevision { + return nil, ErrBusinessSystemPromptRevisionConflict + } + ids := []int64{} + for _, update := range updates { + if update.AccountID < 1 || update.ExpectedUpdatedAt.IsZero() || slices.Contains(ids, update.AccountID) { + return nil, ErrBusinessSystemPromptInvalid + } + ids = append(ids, update.AccountID) + } + accounts, err := s.accountRepo.GetByIDs(ctx, ids) + if err != nil { + return nil, err + } + if len(accounts) != len(updates) { + return nil, ErrAccountNotFound + } + for _, update := range updates { + if update.Binding.Mode != "inherit" && update.Binding.Mode != "off" && update.Binding.Mode != "custom" { + return nil, ErrBusinessSystemPromptInvalid + } + if update.Binding.Mode != "custom" && len(update.Binding.RuleIDs) > 0 { + return nil, ErrBusinessSystemPromptInvalid + } + selected := map[string]bool{} + for _, id := range update.Binding.RuleIDs { + if selected[id] || !slices.ContainsFunc(state.Policy.Rules, func(rule extensionv1.PromptRule) bool { return rule.ID == id }) { + return nil, ErrBusinessSystemPromptInvalid + } + selected[id] = true + } + } + results := make([]PromptBindingUpdateResult, 0, len(updates)) + for _, update := range updates { + index := slices.IndexFunc(accounts, func(account *Account) bool { return account.ID == update.AccountID }) + if index < 0 || !accounts[index].IsOpenAI() { + results = append(results, PromptBindingUpdateResult{AccountID: update.AccountID, Code: "account_not_supported"}) + continue + } + applied, err := writer.UpdatePromptBindingIfRevision(ctx, update.AccountID, update.ExpectedUpdatedAt, expectedRevision, update.Binding) + result := PromptBindingUpdateResult{AccountID: update.AccountID, Applied: applied} + if errors.Is(err, ErrBusinessSystemPromptRevisionConflict) { + result.Code = "system_prompt_revision_conflict" + } else if err != nil { + result.Code = "account_update_failed" + } else if !applied { + result.Code = "account_revision_conflict" + } + results = append(results, result) + } + return results, nil +} diff --git a/backend/internal/service/business_system_prompt_rules_test.go b/backend/internal/service/business_system_prompt_rules_test.go new file mode 100644 index 000000000000..b7ada1fc7c3b --- /dev/null +++ b/backend/internal/service/business_system_prompt_rules_test.go @@ -0,0 +1,129 @@ +package service + +import ( + "context" + "encoding/json" + "net/http/httptest" + "strings" + "testing" + + promptpolicy "github.com/HTExplicit/sub2api-plugins/promptskills/policy" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/require" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +func promptRulesFixture(t *testing.T, protocol string, placements ...extensionv1.PromptRulePlacement) BusinessSystemPromptApplication { + t.Helper() + return BusinessSystemPromptApplication{Applied: true, Revision: 1, Carrier: "rule_plan", RulesPlan: &extensionv1.PromptRulesPlan{SHA256: "plan", Placements: placements}} +} + +func TestPromptRulesApplyPreservesHistoryAndDistinctPositions(t *testing.T) { + input := []byte(`{"instructions":"client","input":[{"role":"developer","content":"client control"},{"role":"user","content":[{"type":"input_text","text":"site"}]},{"type":"function_call_output","call_id":"c1","output":"value"}],"previous_response_id":"resp_existing"}`) + plan := promptRulesFixture(t, "responses", + extensionv1.PromptRulePlacement{RuleID: "head", Carrier: "input", Role: "system", Position: "conversation_head", Body: "head"}, + extensionv1.PromptRulePlacement{RuleID: "control", Carrier: "input", Role: "developer", Position: "control_append", Body: "control"}, + extensionv1.PromptRulePlacement{RuleID: "tail", Carrier: "input", Role: "system", Position: "conversation_tail", Body: "tail"}, + extensionv1.PromptRulePlacement{RuleID: "prefix", Carrier: "instructions", Position: "control_prepend", Body: "before"}, + extensionv1.PromptRulePlacement{RuleID: "suffix", Carrier: "instructions", Position: "control_append", Body: "after"}, + ) + output, application, err := applyPromptRules(input, plan) + require.NoError(t, err) + require.Equal(t, "before\n\nclient\n\nafter", gjson.GetBytes(output, "instructions").String()) + require.Equal(t, "head", gjson.GetBytes(output, "input.0.content").String()) + require.Equal(t, "control", gjson.GetBytes(output, "input.2.content").String()) + require.Equal(t, "tail", gjson.GetBytes(output, "input.5.content").String()) + require.Equal(t, "resp_existing", gjson.GetBytes(output, "previous_response_id").String()) + proofs := promptRulesUndo(input, output, application) + clean, err := restorePromptRules(output, proofs) + require.NoError(t, err) + require.JSONEq(t, string(input), string(clean)) + // A serializer may reorder object keys but cannot change control text. + var reencoded any + require.NoError(t, json.Unmarshal(output, &reencoded)) + encoded, _ := json.Marshal(reencoded) + clean, err = restorePromptRules(encoded, proofs) + require.NoError(t, err) + require.JSONEq(t, string(input), string(clean)) + altered, _ := sjson.SetBytes(output, "input.3.content.0.text", "changed") + _, err = restorePromptRules(altered, proofs) + require.ErrorIs(t, err, ErrBusinessSystemPromptUnavailable) +} + +func TestPromptRulesWireValidationAndEcho(t *testing.T) { + input := []byte(`{"instructions":"client","input":"hello"}`) + plan := promptRulesFixture(t, "responses", extensionv1.PromptRulePlacement{RuleID: "r", Carrier: "instructions", Position: "control_prepend", Body: "site"}) + output, application, err := applyPromptRules(input, plan) + require.NoError(t, err) + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Set(businessSystemPromptContextKey(c, businessSystemPromptRequestApplicationKey, "responses"), cacheBusinessSystemPromptState(input, output, BusinessSystemPromptSnapshot{Revision: 1}, BusinessSystemPromptTarget{Protocol: "responses"}, application)) + require.NoError(t, validateBusinessSystemPromptFinal(c, output, "responses")) + bad, _ := sjson.SetBytes(output, "instructions", "client") + require.Error(t, validateBusinessSystemPromptFinal(c, bad, "responses")) + echo, err := RewriteBusinessSystemPromptResponseJSON([]byte(`{"response":{"instructions":"site\n\nclient"}}`), application, false) + require.NoError(t, err) + require.Equal(t, "client", gjson.GetBytes(echo, "response.instructions").String()) +} + +func TestPromptRulesMixedPublicPrivateEchoPreservesClient(t *testing.T) { + input := []byte(`{"instructions":"client","input":[{"role":"system","content":"private-site"},{"role":"user","content":"hello"}]}`) + plan := promptRulesFixture(t, "responses", + extensionv1.PromptRulePlacement{RuleID: "private", Carrier: "instructions", Position: "control_prepend", Body: "private-site"}, + extensionv1.PromptRulePlacement{RuleID: "public", Carrier: "instructions", Position: "control_append", Body: "public-site", PreserveEcho: true}, + extensionv1.PromptRulePlacement{RuleID: "message", Carrier: "input", Role: "system", Position: "conversation_tail", Body: "private-site"}) + output, application, err := applyPromptRules(input, plan) + require.NoError(t, err) + echo, err := RewriteBusinessSystemPromptResponseJSON(output, application, false) + require.NoError(t, err) + require.Equal(t, "client\n\npublic-site", gjson.GetBytes(echo, "instructions").String()) + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Set(businessSystemPromptContextKey(c, businessSystemPromptRequestApplicationKey, "responses"), cacheBusinessSystemPromptState(input, output, BusinessSystemPromptSnapshot{Revision: 1}, BusinessSystemPromptTarget{Protocol: "responses"}, application)) + echo = rewritePromptRulesStructuredEcho(c, echo, "responses") + require.JSONEq(t, gjson.GetBytes(input, "input").Raw, gjson.GetBytes(echo, "input").Raw) + require.Contains(t, string(echo), "private-site", "the customer's identical message stays") +} + +func TestPromptRulesPlannerRejectsOAuthSystemBeforeMutation(t *testing.T) { + rule := extensionv1.PromptRule{ID: "r", Name: "r", Enabled: true, TemplateID: 1, VersionID: 1, Delivery: "system", Position: "control_append"} + hash, _, _ := extensionv1.ValidateTextDocument("site", 100) + snapshot := BusinessSystemPromptSnapshot{Enabled: true, RulePolicy: &extensionv1.PromptRulePolicy{Version: 1, Rules: []extensionv1.PromptRule{rule}, DefaultRuleIDs: []string{"r"}}, ResolvedRules: []extensionv1.ResolvedPromptRule{{Rule: rule, Body: "site", SHA256: hash}}} + _, err := promptpolicy.Plan(snapshot, BusinessSystemPromptTarget{Platform: "openai", AccountType: "oauth", Protocol: "responses"}, true) + require.ErrorIs(t, err, promptpolicy.ErrPromptDeliveryUnsupported) +} + +func TestPromptRulesLegacyHybridAndMaximumCompiledBody(t *testing.T) { + require.Equal(t, BusinessSystemPromptBundleMaxBytes, extensionv1.PromptRulesMaxBytes) + t.Run("existing_paired_fixture", func(t *testing.T) { + service := newGatewayHybridBusinessSystemPromptPolicy(t) + snapshot, ok := service.CurrentSnapshot() + require.True(t, ok) + old, err := service.compileBusinessSystemPromptSnapshot(snapshot) + require.NoError(t, err) + store := service.store.(*fakeBusinessSystemPromptStore) + store.detail = BusinessSystemPromptTemplateDetail{Versions: []BusinessSystemPromptVersion{{ID: snapshot.VersionID, TemplateID: snapshot.TemplateID, Body: snapshot.Body, SHA256: snapshot.SHA256, ByteLength: snapshot.ByteLength, CompositionMode: snapshot.CompositionMode, BundleID: snapshot.BundleID}}} + snapshot.RulePolicy = &extensionv1.PromptRulePolicy{Version: 1, DefaultRuleIDs: []string{"legacy-default"}, Rules: []extensionv1.PromptRule{{ID: "legacy-default", Name: "Legacy default", Enabled: true, FollowActive: true, Delivery: "native_control", Position: "control_append"}}} + require.NoError(t, service.preparePromptRulesSnapshot(&snapshot)) + require.Len(t, snapshot.ResolvedRules, 1) + require.Equal(t, old.Body, snapshot.ResolvedRules[0].Body) + require.Equal(t, old.EffectiveSHA256, snapshot.ResolvedRules[0].SHA256) + }) + t.Run("full_256_KiB_compiled_publication", func(t *testing.T) { + body := strings.Repeat("x", BusinessSystemPromptBundleMaxBytes) + hash := hashBusinessSystemPromptBundleBytes([]byte(body)) + registry := &RemoteSkillRegistryService{} + require.NoError(t, registry.installPublication(RemoteSkillPublication{Revision: 1, CandidateID: 1, EffectiveTreeSHA256: strings.Repeat("a", 64), EffectivePromptSHA256: hash, EffectivePromptBody: body, Files: map[string][]byte{"SKILL.md": []byte("fixture")}, Prompt: RemoteSkillPromptVersion{ID: 1, EffectiveSHA256: hash}})) + baseHash, baseSize, err := ValidateBusinessSystemPromptBody("base") + require.NoError(t, err) + store := &fakeBusinessSystemPromptStore{detail: BusinessSystemPromptTemplateDetail{Versions: []BusinessSystemPromptVersion{{ID: 2, TemplateID: 1, Body: "base", SHA256: baseHash, ByteLength: baseSize, CompositionMode: BusinessSystemPromptCompositionCodexSkillHybrid, BundleID: BusinessSystemPromptRemoteSkillBundleID}}}} + service := NewBusinessSystemPromptService(store, nil) + service.registry = registry + snapshot := BusinessSystemPromptSnapshot{Revision: 1, Enabled: true, TemplateID: 1, VersionID: 2, RulePolicy: &extensionv1.PromptRulePolicy{Version: 1, DefaultRuleIDs: []string{"legacy-default"}, Rules: []extensionv1.PromptRule{{ID: "legacy-default", Name: "Legacy", Enabled: true, FollowActive: true, Delivery: "native_control", Position: "control_append"}}}} + require.NoError(t, service.preparePromptRulesSnapshot(&snapshot)) + output, application, err := ApplyBusinessSystemPromptToJSONContext(context.Background(), []byte(`{"input":"hello"}`), snapshot, BusinessSystemPromptTarget{Platform: PlatformOpenAI, AccountType: AccountTypeOAuth, Protocol: "responses"}) + require.NoError(t, err) + require.True(t, application.Applied) + require.Equal(t, len(body), len(gjson.GetBytes(output, "instructions").String())) + }) +} diff --git a/backend/internal/service/business_system_prompt_rules_ws.go b/backend/internal/service/business_system_prompt_rules_ws.go new file mode 100644 index 000000000000..0d5f5a026fca --- /dev/null +++ b/backend/internal/service/business_system_prompt_rules_ws.go @@ -0,0 +1,47 @@ +package service + +import ( + "errors" + + "github.com/gin-gonic/gin" + + coderws "github.com/coder/websocket" +) + +const promptRulesDeferredWSKey = "prompt_rules_deferred_ws" + +// The native WS accumulator must retain clean customer history. Validate and +// freeze policy here, but insert explicit messages only after replay assembly. +func (s *OpenAIGatewayService) prepareBusinessPromptWSIngress(c *gin.Context, body []byte, account *Account, protocol string, compact bool) ([]byte, BusinessSystemPromptApplication, error) { + snapshot, eligible, err := s.businessSystemPromptSnapshotForRequest(c, account) + if err != nil { + return nil, BusinessSystemPromptApplication{}, err + } + if !eligible || snapshot.RulePolicy == nil { + return s.applyBusinessSystemPromptForRequest(c, body, account, protocol, compact) + } + target := enrichPromptTarget(c, body, businessSystemPromptTargetForAccount(account, protocol, compact)) + application, err := planBusinessSystemPromptWithInvoker(promptPolicyRequestContext(c), body, snapshot, target, invokeProcessExtension) + if err != nil { + return nil, application, err + } + businessSystemPromptRequestSet(c, promptRulesDeferredWSKey, true) + return body, application, nil +} + +func (s *OpenAIGatewayService) finalizeBusinessPromptWSIngress(c *gin.Context, account *Account, body []byte) ([]byte, error) { + if deferred, _ := businessSystemPromptRequestGet(c, promptRulesDeferredWSKey); deferred == true { + // sendAndRelay receives the accumulator's clean array, including on a + // verified full replay. Reuse frozen policy, not a prior attempt's edits. + businessSystemPromptRequestDelete(c, businessSystemPromptContextKey(c, businessSystemPromptRequestApplicationKey, BusinessSystemPromptProtocolResponses)) + return s.finalizeBusinessPromptForSend(c, account, body, BusinessSystemPromptProtocolResponses, isOpenAIResponsesCompactPath(c)) + } + return body, validateBusinessSystemPromptFinal(c, body, BusinessSystemPromptProtocolResponses) +} + +func businessPromptWSCloseError(err error) error { + if errors.Is(err, ErrPromptDeliveryUnsupported) { + return NewOpenAIWSClientCloseError(coderws.StatusPolicyViolation, "prompt_delivery_unsupported", err) + } + return NewOpenAIWSClientCloseError(coderws.StatusTryAgainLater, "system_prompt_unavailable", err) +} diff --git a/backend/internal/service/business_system_prompt_service.go b/backend/internal/service/business_system_prompt_service.go index 61a258db4657..29cf0319427e 100644 --- a/backend/internal/service/business_system_prompt_service.go +++ b/backend/internal/service/business_system_prompt_service.go @@ -9,6 +9,7 @@ import ( "sync/atomic" "time" + "github.com/Wei-Shaw/sub2api/internal/config" extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) @@ -148,11 +149,13 @@ type BusinessSystemPromptRevisionBus interface { } type BusinessSystemPromptService struct { - store BusinessSystemPromptStore - bus BusinessSystemPromptRevisionBus - registry *RemoteSkillRegistryService - registryBus RemoteSkillRegistryRevisionBus - source BusinessSystemPromptSource + previewConfig *config.Config + accountRepo AccountRepository + store BusinessSystemPromptStore + bus BusinessSystemPromptRevisionBus + registry *RemoteSkillRegistryService + registryBus RemoteSkillRegistryRevisionBus + source BusinessSystemPromptSource snapshot atomic.Pointer[BusinessSystemPromptSnapshot] stateMu sync.Mutex @@ -376,7 +379,7 @@ func (s *BusinessSystemPromptService) Reload(ctx context.Context) error { if s == nil || s.store == nil { return errors.New("business system prompt store unavailable") } - loaded, err := s.store.LoadBusinessSystemPrompt(ctx) + loaded, err := s.loadPromptSnapshot(ctx) if err != nil { return s.retainLastGood(fmt.Errorf("load business system prompt: %w", err)) } @@ -401,6 +404,9 @@ func (s *BusinessSystemPromptService) Reload(ctx context.Context) error { } func (s *BusinessSystemPromptService) prepareBusinessSystemPromptSnapshot(snapshot *BusinessSystemPromptSnapshot) error { + if snapshot.RulePolicy != nil { + return s.preparePromptRulesSnapshot(snapshot) + } if err := validateBusinessSystemPromptSnapshot(snapshot); err != nil { return err } @@ -498,6 +504,9 @@ func (s *BusinessSystemPromptService) PrepareBusinessSystemPromptPreviewSnapshot func (s *BusinessSystemPromptService) compileBusinessSystemPromptSnapshot( snapshot BusinessSystemPromptSnapshot, ) (BusinessSystemPromptSnapshot, error) { + if snapshot.RulePolicy != nil { + return snapshot, nil + } if snapshot.CompositionMode == BusinessSystemPromptCompositionInline { return snapshot, nil } @@ -641,6 +650,12 @@ func (s *BusinessSystemPromptService) PublishVersionAction(ctx context.Context, if err != nil { return BusinessSystemPromptSnapshot{}, err } + if _, rules := s.store.(BusinessSystemPromptRulesStore); rules { + snapshot, err = s.loadPromptSnapshot(ctx) + if err != nil { + return BusinessSystemPromptSnapshot{}, err + } + } snapshot.Degraded = false if err := s.prepareBusinessSystemPromptSnapshot(&snapshot); err != nil { _ = s.retainLastGood(err) @@ -673,6 +688,12 @@ func (s *BusinessSystemPromptService) UpdateRuntime(ctx context.Context, update if err != nil { return BusinessSystemPromptSnapshot{}, err } + if _, rules := s.store.(BusinessSystemPromptRulesStore); rules { + snapshot, err = s.loadPromptSnapshot(ctx) + if err != nil { + return BusinessSystemPromptSnapshot{}, err + } + } snapshot.Degraded = false if err := s.prepareBusinessSystemPromptSnapshot(&snapshot); err != nil { _ = s.retainLastGood(err) @@ -833,6 +854,13 @@ func (s *BusinessSystemPromptService) DuplicateTemplate(ctx context.Context, id } func (s *BusinessSystemPromptService) DeleteTemplate(ctx context.Context, id, actorID, expectedRevision int64) error { + if snapshot, ok := s.CurrentSnapshot(); ok && snapshot.RulePolicy != nil { + for _, rule := range snapshot.RulePolicy.Rules { + if !rule.FollowActive && rule.TemplateID == id { + return ErrBusinessSystemPromptActive + } + } + } if err := s.rejectRemoteSkillManagedTemplate(ctx, id); err != nil { return err } diff --git a/backend/internal/service/business_system_prompt_turn_cache.go b/backend/internal/service/business_system_prompt_turn_cache.go index 47aeb6f6afef..5986fed20fe5 100644 --- a/backend/internal/service/business_system_prompt_turn_cache.go +++ b/backend/internal/service/business_system_prompt_turn_cache.go @@ -49,3 +49,18 @@ func businessSystemPromptRequestSet(ctx *gin.Context, key string, value any) { } ctx.Set(key, value) } + +func businessSystemPromptRequestDelete(ctx *gin.Context, key string) { + if ctx == nil { + return + } + current, _ := ctx.Get(businessSystemPromptTurnCacheKey) + if cache, ok := current.(*businessSystemPromptTurnCache); ok && cache != nil { + cache.mu.Lock() + delete(cache.values, key) + cache.mu.Unlock() + return + } + // HTTP callers never need this operation: it is reserved for the native + // WS accumulator's proven clean, service-owned payloads. +} diff --git a/backend/internal/service/codex_connection_lease.go b/backend/internal/service/codex_connection_lease.go new file mode 100644 index 000000000000..397196e9bff1 --- /dev/null +++ b/backend/internal/service/codex_connection_lease.go @@ -0,0 +1,23 @@ +package service + +import ( + "errors" + "net/http" + "time" + + "github.com/Wei-Shaw/sub2api/internal/pkg/tlsfingerprint" +) + +var ( + ErrCodexConnectionLeaseExpired = errors.New("codex connection lease expired") + ErrCodexConnectionLeaseScope = errors.New("codex connection lease scope mismatch") + ErrCodexConnectionLeaseTransport = errors.New("codex connection lease transport failed") +) + +// CodexConnectionLeaseUpstream binds a routing qualification to an actual +// connection when the proxy cannot establish a stable egress identity. An empty +// leaseID is reserved for a host-authorized qualification request. Reusing a +// lease never dials a replacement connection, including transparent retries. +type CodexConnectionLeaseUpstream interface { + DoWithCodexConnectionLease(req *http.Request, proxyURL string, accountID int64, scope string, leaseID string, expiresAt time.Time, profile *tlsfingerprint.Profile) (*http.Response, string, error) +} diff --git a/backend/internal/service/codex_routing_completion.go b/backend/internal/service/codex_routing_completion.go new file mode 100644 index 000000000000..74d618213e36 --- /dev/null +++ b/backend/internal/service/codex_routing_completion.go @@ -0,0 +1,114 @@ +package service + +import ( + "bytes" + "encoding/json" + "io" + "strings" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +const codexRoutingProbeReadLimit = 128 << 10 + +// Only a delimited successful terminal and the original upstream model can +// certify a route. It does not retain prompts, reasoning, or response text. +type codexRoutingCompletion struct { + Model string + Completed bool + Failed bool + pending []byte +} + +func (o *codexRoutingCompletion) json(raw []byte) { + var event struct { + Type string `json:"type"` + Object string `json:"object"` + Status string `json:"status"` + Model string `json:"model"` + Error json.RawMessage `json:"error"` + Response *struct { + Status string `json:"status"` + Model string `json:"model"` + Error json.RawMessage `json:"error"` + } `json:"response"` + } + if json.Unmarshal(raw, &event) != nil { + return + } + badError := func(raw json.RawMessage) bool { return len(raw) > 0 && string(raw) != "null" } + if badError(event.Error) || event.Type == "error" || event.Type == "response.failed" || event.Type == "response.incomplete" { + o.Failed = true + return + } + model := "" + if event.Type == "response.completed" && event.Response != nil { + if event.Response.Status != "completed" || badError(event.Response.Error) { + o.Failed = true + return + } + model = strings.TrimSpace(event.Response.Model) + } else if event.Object == "response" && event.Status == "completed" { + model = strings.TrimSpace(event.Model) + } else { + return + } + if model == "" || len(model) > 256 || (o.Model != "" && o.Model != model) { + o.Failed = true + return + } + o.Model, o.Completed = model, true +} + +func (o *codexRoutingCompletion) feed(data []byte) { + if o.Failed { + return + } + o.pending = append(o.pending, data...) + o.pending = bytes.ReplaceAll(o.pending, []byte("\r\n"), []byte("\n")) + for { + end := bytes.Index(o.pending, []byte("\n\n")) + if end < 0 { + break + } + var lines []string + for _, line := range strings.Split(string(o.pending[:end]), "\n") { + if strings.HasPrefix(line, "data:") { + lines = append(lines, strings.TrimSpace(strings.TrimPrefix(line, "data:"))) + } + } + o.json([]byte(strings.Join(lines, "\n"))) + o.pending = o.pending[end+2:] + } + if len(o.pending) > codexRoutingProbeReadLimit { + o.Failed = true + o.pending = nil + } +} + +func readCodexRoutingCompletion(body io.Reader, contentType, requested string, observation *extensionv1.CodexRoutingObservation) error { + data, err := io.ReadAll(io.LimitReader(body, codexRoutingProbeReadLimit+1)) + if err != nil || len(data) > codexRoutingProbeReadLimit { + observation.Code = "routing_incomplete" + return errCodexRoutingUnavailable + } + var completed codexRoutingCompletion + if strings.Contains(strings.ToLower(contentType), "text/event-stream") { + completed.feed(data) + } else { + completed.json(data) + } + observation.Completed = completed.Completed && !completed.Failed + observation.ResponseModel = completed.Model + observation.ModelMatched = observation.Completed && completed.Model == requested + if !observation.Completed { + observation.Code = "routing_incomplete" + return errCodexRoutingUnavailable + } + if !observation.ModelMatched { + observation.Code = "routing_model_mismatch" + return errCodexRoutingUnavailable + } + observation.Code = "routing_verified" + return nil +} diff --git a/backend/internal/service/codex_routing_cookies.go b/backend/internal/service/codex_routing_cookies.go new file mode 100644 index 000000000000..bd289810e9a5 --- /dev/null +++ b/backend/internal/service/codex_routing_cookies.go @@ -0,0 +1,293 @@ +package service + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "net/http" + "net/url" + "sort" + "strings" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +const codexRoutingPrivateNamespace = "codex-routing-private" + +var errCodexRoutingUnavailable = errors.New("Codex routing qualification unavailable") + +type codexRoutingCookie struct { + Name string `json:"name"` + Value string `json:"value"` + Domain string `json:"domain"` + Path string `json:"path"` + FirstSeen time.Time `json:"first_seen"` + ExpiresAt time.Time `json:"expires_at"` +} + +type codexRoutingCookieChange struct { + Cookie codexRoutingCookie + Delete bool +} + +// A clock keeps tombstones and first-seen times independently of bundles. A +// failed or late validation cannot resurrect deleted material or renew its age. +type codexRoutingCookieClock struct { + Scope extensionv1.CodexRoutingScope `json:"scope"` + Cookies map[string]codexRoutingCookie `json:"cookies"` + Seen map[string]time.Time `json:"seen"` + Tombstones map[string]time.Time `json:"tombstones"` +} + +type codexRoutingPrivateBundle struct { + Schema int `json:"schema"` + Scope extensionv1.CodexRoutingScope `json:"scope"` + Cookies []codexRoutingCookie `json:"cookies"` + ClockKey string `json:"clock_key"` + ClockRevision int64 `json:"clock_revision"` + Status string `json:"status"` + Model string `json:"model"` + Observation extensionv1.CodexRoutingObservation `json:"observation"` + ExpiresAt time.Time `json:"expires_at"` +} + +func codexRoutingDigest(parts ...string) string { + sum := sha256.Sum256([]byte(strings.Join(parts, "\x00"))) + return hex.EncodeToString(sum[:]) +} + +func codexRoutingScopeKey(scope extensionv1.CodexRoutingScope) string { + raw, _ := json.Marshal([]any{scope.AccountID, scope.Identity, scope.ProfileHash, scope.RouteHash}) + return codexRoutingDigest(string(raw)) +} + +func isCodexRoutingCookie(name string) bool { return name == "__cflb" || name == "__oailb" } + +func parseCodexRoutingCookies(headers http.Header, target *url.URL, now time.Time) []codexRoutingCookieChange { + if target == nil || (target.Scheme != "https" && target.Scheme != "wss") || target.Hostname() != "chatgpt.com" { + return nil + } + var changes []codexRoutingCookieChange + for _, cookie := range (&http.Response{Header: headers}).Cookies() { + if !isCodexRoutingCookie(cookie.Name) || cookie.Valid() != nil || len(cookie.Value) > 8192 { + continue + } + invalidScope := false + for _, attribute := range cookie.Unparsed { + name, _, _ := strings.Cut(attribute, "=") + if strings.EqualFold(strings.TrimSpace(name), "domain") || strings.EqualFold(strings.TrimSpace(name), "path") { + invalidScope = true + break + } + } + if invalidScope { + continue + } + domain := strings.TrimPrefix(strings.ToLower(cookie.Domain), ".") + if domain != "" && domain != target.Hostname() { + continue + } + path := cookie.Path + if path == "" || !strings.HasPrefix(path, "/") { + path = target.Path[:strings.LastIndex(target.Path, "/")+1] + } + if !codexCookiePathMatches(target.Path, path) { + continue + } + change := codexRoutingCookieChange{Cookie: codexRoutingCookie{Name: cookie.Name, Domain: target.Hostname(), Path: path, Value: cookie.Value, FirstSeen: now}} + change.Delete = cookie.MaxAge < 0 || cookie.Value == "" || (!cookie.Expires.IsZero() && !now.Before(cookie.Expires) && cookie.MaxAge <= 0) + deadline := now.Add(extensionv1.CodexRoutingMaxAge) + if cookie.MaxAge > 0 { + deadline = earlierCodexTime(deadline, now.Add(time.Duration(cookie.MaxAge)*time.Second)) + } else if !cookie.Expires.IsZero() { + deadline = earlierCodexTime(deadline, cookie.Expires) + } + change.Cookie.ExpiresAt = deadline + changes = append(changes, change) + } + return changes +} + +func codexCookiePathMatches(path, scope string) bool { + return path == scope || (strings.HasPrefix(path, scope) && (strings.HasSuffix(scope, "/") || (len(path) > len(scope) && path[len(scope)] == '/'))) +} + +func earlierCodexTime(a, b time.Time) time.Time { + if b.Before(a) { + return b + } + return a +} + +func (clock *codexRoutingCookieClock) apply(changes []codexRoutingCookieChange, now time.Time) { + if clock.Cookies == nil { + clock.Cookies = make(map[string]codexRoutingCookie) + } + if clock.Seen == nil { + clock.Seen = make(map[string]time.Time) + } + if clock.Tombstones == nil { + clock.Tombstones = make(map[string]time.Time) + } + // Never make the same value fresh merely because its old bundle expired. + // A bounded history fails closed on exhaustion rather than renewing age. + for _, change := range changes { + cookie := change.Cookie + if change.Delete { + delete(clock.Cookies, cookie.Name) + clock.Tombstones[cookie.Name] = now + continue + } + digest := codexRoutingDigest(cookie.Name, cookie.Value) + if first, found := clock.Seen[digest]; found { + cookie.FirstSeen = first + } else { + clock.Seen[digest] = cookie.FirstSeen + } + if deleted, found := clock.Tombstones[cookie.Name]; found && !cookie.FirstSeen.After(deleted) { + continue + } + cookie.ExpiresAt = earlierCodexTime(cookie.ExpiresAt, cookie.FirstSeen.Add(extensionv1.CodexRoutingMaxAge)) + if !now.Before(cookie.ExpiresAt) { + continue + } + clock.Cookies[cookie.Name] = cookie + } + // The durable per-value index owns history. Keep this hot snapshot small; + // older live bundle lookups can consult that index after eviction. + for len(clock.Seen) > 128 { + oldestKey := "" + var oldest time.Time + for key, first := range clock.Seen { + if oldestKey == "" || first.Before(oldest) { + oldestKey, oldest = key, first + } + } + delete(clock.Seen, oldestKey) + } +} + +// First-seen records are indexed separately from the compact clock. Retaining +// only recent digests in a clock must never make an old identical value fresh. +func preserveCodexCookieFirstSeen(ctx context.Context, store PluginExtensionStateStore, plugin string, scope extensionv1.CodexRoutingScope, clock *codexRoutingCookieClock, changes []codexRoutingCookieChange, now time.Time) error { + for index := range changes { + change := &changes[index] + if change.Delete { + continue + } + digest := codexRoutingDigest(change.Cookie.Name, change.Cookie.Value) + key := "seen." + codexRoutingDigest(codexRoutingScopeKey(scope), digest) + record, err := store.ReadExtensionState(ctx, plugin, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key}) + if err != nil { + return err + } + var seen struct { + First time.Time `json:"first_seen"` + } + if record.Found { + if json.Unmarshal(record.Value, &seen) != nil || seen.First.IsZero() { + return errCodexRoutingUnavailable + } + } else { + seen.First = change.Cookie.FirstSeen + if old, exists := clock.Seen[digest]; exists && old.Before(seen.First) { + seen.First = old + } + raw, _ := json.Marshal(seen) + saved, err := store.CompareSwapExtensionState(ctx, plugin, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key, Value: raw}) + if err != nil { + return err + } + if !saved.Applied && (json.Unmarshal(saved.Value, &seen) != nil || seen.First.IsZero()) { + return errCodexRoutingUnavailable + } + } + change.Cookie.FirstSeen = seen.First + } + for digest, first := range clock.Seen { + if now.Sub(first) > 2*extensionv1.CodexRoutingMaxAge { + delete(clock.Seen, digest) + } + } + return nil +} + +// Only cookies from this response can enter a cold acquisition candidate. +// Verification overlays this response onto its own immutable candidate, never +// onto another model's concurrently observed cookie pair. +func (clock *codexRoutingCookieClock) selected(previous []codexRoutingCookie, changes []codexRoutingCookieChange, now time.Time) []codexRoutingCookie { + selected := map[string]codexRoutingCookie{} + for _, cookie := range previous { + selected[cookie.Name] = cookie + } + for _, change := range changes { + if change.Delete { + delete(selected, change.Cookie.Name) + continue + } + cookie, exists := clock.Cookies[change.Cookie.Name] + if exists && cookie.Value == change.Cookie.Value { + selected[cookie.Name] = cookie + } + } + var result []codexRoutingCookie + for _, cookie := range selected { + if deleted, exists := clock.Tombstones[cookie.Name]; exists && !cookie.FirstSeen.After(deleted) { + continue + } + if now.Before(cookie.ExpiresAt) { + result = append(result, cookie) + } + } + sort.Slice(result, func(i, j int) bool { return result[i].Name < result[j].Name }) + return result +} + +func (clock *codexRoutingCookieClock) live(now time.Time) []codexRoutingCookie { + var out []codexRoutingCookie + for _, cookie := range clock.Cookies { + if !cookie.FirstSeen.After(now) && now.Before(cookie.ExpiresAt) { + out = append(out, cookie) + } + } + sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name }) + return out +} + +func codexRoutingCookieHeader(cookies []codexRoutingCookie, now time.Time) (string, time.Time) { + parts := make([]string, 0, len(cookies)) + expires := now.Add(extensionv1.CodexRoutingMaxAge) + for _, cookie := range cookies { + if !isCodexRoutingCookie(cookie.Name) || cookie.Domain != "chatgpt.com" || cookie.FirstSeen.After(now) || !now.Before(cookie.ExpiresAt) || !codexCookiePathMatches("/backend-api/codex/responses", cookie.Path) { + return "", time.Time{} + } + parts = append(parts, cookie.Name+"="+cookie.Value) + expires = earlierCodexTime(expires, cookie.ExpiresAt) + } + if len(parts) == 0 { + return "", time.Time{} + } + return strings.Join(parts, "; "), expires +} + +func changedCodexRoutingCookies(previous []codexRoutingCookie, changes []codexRoutingCookieChange) []codexRoutingCookieChange { + var result []codexRoutingCookieChange + for _, change := range changes { + unchanged := false + if !change.Delete { + for _, cookie := range previous { + if cookie.Name == change.Cookie.Name && cookie.Value == change.Cookie.Value && cookie.Domain == change.Cookie.Domain && cookie.Path == change.Cookie.Path && !change.Cookie.ExpiresAt.Before(cookie.ExpiresAt) { + unchanged = true + break + } + } + } + if !unchanged { + result = append(result, change) + } + } + return result +} diff --git a/backend/internal/service/codex_routing_demand.go b/backend/internal/service/codex_routing_demand.go new file mode 100644 index 000000000000..7ad15882f52e --- /dev/null +++ b/backend/internal/service/codex_routing_demand.go @@ -0,0 +1,56 @@ +package service + +import ( + "context" + "encoding/json" + "strconv" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +// Scheduler demand is best-effort and asynchronous. It does not mint a grant, +// enroll an untouched account, or wait on a process RPC in candidate selection. +func (m *PluginManager) noteCodexRoutingDemand(account *Account, model string) { + if m == nil || !isOpenAICodexTicketAccount(account) || model == "" { + return + } + observation, exists := accountPluginProjection(account, codexRuntimePluginKey).Observations[model] + if !exists || observation.State == "stopped" || observation.State == "idle" { + return + } + installation, _ := m.installedByKey(codexRuntimePluginKey) + if installation == nil { + return + } + key := strconv.FormatInt(account.ID, 10) + ":" + model + now := time.Now() + m.codexDemandMu.Lock() + if m.codexDemandAt == nil { + m.codexDemandAt = map[string]time.Time{} + } + if last, exists := m.codexDemandAt[key]; exists && now.Sub(last) < 10*time.Second { + m.codexDemandMu.Unlock() + return + } + if len(m.codexDemandAt) >= 4096 { + for item, at := range m.codexDemandAt { + if now.Sub(at) > 2*time.Minute { + delete(m.codexDemandAt, item) + } + } + if len(m.codexDemandAt) >= 4096 { + m.codexDemandMu.Unlock() + return + } + } + m.codexDemandAt[key] = now + m.codexDemandMu.Unlock() + id, kind, platform := account.ID, account.Type, account.Platform + go func() { + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + raw, _ := json.Marshal(extensionv1.CodexRoutingDemand{AccountID: id, Model: model, Transport: "http"}) + _, _ = m.InvokeExtension(ctx, installation.ID, platform, kind, extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "codex.routing.demand", AccountID: id, Payload: raw}) + }() +} diff --git a/backend/internal/service/codex_routing_fingerprint.go b/backend/internal/service/codex_routing_fingerprint.go new file mode 100644 index 000000000000..b92efac7531e --- /dev/null +++ b/backend/internal/service/codex_routing_fingerprint.go @@ -0,0 +1,230 @@ +package service + +import ( + "context" + "crypto/tls" + _ "embed" + "encoding/json" + "net/http" + "strconv" + "strings" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/gin-gonic/gin" + "github.com/tidwall/gjson" +) + +const codexRoutingTurnContextKey = "codex_routing_turn_id" + +type codexRoutingIngressKey struct{} + +//go:embed codex_routing_reference.json +var codexRoutingReference json.RawMessage + +// A turn identifier is independent of the conversation/session. Opaque state +// cannot cross a turn simply because the same downstream session continues. +func stageCodexRoutingTurn(c *gin.Context, body []byte) { + if c == nil { + return + } + turn := strings.TrimSpace(gjson.GetBytes(body, "client_metadata.turn_id").String()) + if turn == "" { + metadata := gjson.GetBytes(body, "client_metadata.x-codex-turn-metadata").String() + turn = strings.TrimSpace(gjson.Get(metadata, "turn_id").String()) + } + if turn == "" && c.Request != nil { + turn = strings.TrimSpace(gjson.Get(c.Request.Header.Get(openAIWSTurnMetadataHeader), "turn_id").String()) + } + if len(turn) > 128 { + turn = "" + } + c.Set(codexRoutingTurnContextKey, turn) +} + +func codexRoutingTurnID(c *gin.Context) string { + if c == nil { + return "" + } + if value, exists := c.Get(codexRoutingTurnContextKey); exists { + text, _ := value.(string) + return text + } + if c.Request == nil { + return "" + } + turn := strings.TrimSpace(gjson.Get(c.Request.Header.Get(openAIWSTurnMetadataHeader), "turn_id").String()) + if len(turn) > 128 { + return "" + } + return turn +} + +type CodexWireFingerprint struct { + IdentityFields map[string]CodexIdentityFieldObservation `json:"identity_fields"` + Ingress string `json:"ingress"` + ObservedAt time.Time `json:"observed_at"` + Source string `json:"source"` + Transport string `json:"transport"` + UserAgent string `json:"user_agent"` + Originator string `json:"originator"` + Version string `json:"version"` + HTTPProtocol string `json:"http_protocol"` + RequestEncoding string `json:"request_encoding"` + TLSImplementation string `json:"tls_implementation"` + TLSVersion string `json:"tls_version,omitempty"` + CipherSuite string `json:"cipher_suite,omitempty"` + ALPN string `json:"alpn,omitempty"` + JA3 string `json:"ja3_status"` + ProfileHash string `json:"profile_hash"` + RouteHash string `json:"route_hash"` + RouteEvidence string `json:"route_evidence"` + ConnectionEvidence string `json:"connection_evidence"` + CookieNames []string `json:"cookie_names"` + CookieVersions map[string]string `json:"cookie_versions"` + SessionPresent bool `json:"session_present"` + ThreadPresent bool `json:"thread_present"` + WindowPresent bool `json:"window_present"` + StatePresent bool `json:"state_present"` + StateLength int `json:"state_length"` + WebSocketExtensions string `json:"websocket_extensions,omitempty"` +} + +type CodexRoutingModelStatus struct { + Model string `json:"model"` + Phase string `json:"phase"` + Enrolled bool `json:"enrolled"` + Failures int `json:"failed_cycles"` + Qualified bool `json:"qualified"` + VerifiedAt *time.Time `json:"verified_at,omitempty"` + ExpiresAt *time.Time `json:"expires_at,omitempty"` + NextAt *time.Time `json:"next_attempt_at,omitempty"` + LastObservation *extensionv1.CodexRoutingObservation `json:"last_observation,omitempty"` +} + +type CodexFingerprintView struct { + ConfiguredProfile *extensionv1.CodexClientProfile `json:"configured_profile,omitempty"` + CapturedReference json.RawMessage `json:"captured_reference"` + AccountID int64 `json:"account_id"` + Configured codexIdentitySnapshot `json:"configured"` + Observed *CodexWireFingerprint `json:"observed,omitempty"` + ReferenceCommit string `json:"reference_commit"` + ReferenceSource string `json:"reference_source"` + Alignment string `json:"alignment"` + CookieMaxAgeSeconds int `json:"cookie_max_age_seconds"` + RefreshLeadSeconds int `json:"refresh_lead_seconds"` + Models []CodexRoutingModelStatus `json:"models"` +} + +func (s *OpenAIGatewayService) observeCodexWire(ctx context.Context, account *Account, request *http.Request, response *http.Response, qualification *extensionv1.CodexRoutingQualification) { + if s == nil || s.pluginManager == nil || account == nil || request == nil || response == nil { + return + } + installation, _ := s.pluginManager.installedByKey(codexRuntimePluginKey) + store, ok := s.pluginManager.repo.(PluginExtensionStateStore) + if installation == nil || !ok { + return + } + value := CodexWireFingerprint{ObservedAt: time.Now().UTC(), Source: "final_outbound", Transport: "http", UserAgent: request.Header.Get("User-Agent"), Originator: request.Header.Get("originator"), Version: request.Header.Get("version"), HTTPProtocol: response.Proto, RequestEncoding: request.Header.Get("Content-Encoding"), TLSImplementation: "go-crypto-tls", JA3: "unknown", CookieNames: []string{}, SessionPresent: extractClientSessionID(request.Header) != "", ThreadPresent: request.Header.Get("thread-id") != "", WindowPresent: request.Header.Get("x-codex-window-id") != "", StatePresent: request.Header.Get(openAICodexTurnStateHeader) != "", StateLength: len(request.Header.Get(openAICodexTurnStateHeader))} + value.Ingress = "http" + value.CookieVersions = map[string]string{} + body, _ := request.Context().Value(codexIdentityBodyKey{}).(codexIdentityBodyObservation) + value.IdentityFields = codexIdentityFieldObservations(request.Header, body) + if ingress, ok := request.Context().Value(codexRoutingIngressKey{}).(string); ok && ingress == "ws" { + value.Ingress = ingress + } + if response.TLS != nil { + value.TLSVersion = tls.VersionName(response.TLS.Version) + value.CipherSuite = tls.CipherSuiteName(response.TLS.CipherSuite) + value.ALPN = response.TLS.NegotiatedProtocol + } + if qualification != nil { + value.ProfileHash, value.RouteHash, value.RouteEvidence = qualification.Scope.ProfileHash, qualification.Scope.RouteHash, qualification.Scope.RouteEvidence + value.ConnectionEvidence = codexRoutingDigest(qualification.Scope.ConnectionLeaseID)[:16] + value.Transport = qualification.Scope.Transport + } + if value.Transport == "ws" { + value.WebSocketExtensions = response.Header.Get("Sec-WebSocket-Extensions") + } + for _, cookie := range request.Cookies() { + if isCodexRoutingCookie(cookie.Name) { + value.CookieNames = append(value.CookieNames, cookie.Name) + value.CookieVersions[cookie.Name] = codexRoutingDigest(strconv.FormatInt(account.ID, 10), cookie.Name, cookie.Value)[:16] + } + } + ctx = WithPluginExecution(context.WithoutCancel(ctx), installation) + ctx, cancel := context.WithTimeout(ctx, time.Second) + defer cancel() + key := "wire." + strconv.FormatInt(account.ID, 10) + previous, err := store.ReadExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key}) + if err != nil { + return + } + raw, _ := json.Marshal(value) + _, _ = store.CompareSwapExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key, ExpectedRevision: previous.Revision, Value: raw}) +} + +// CodexFingerprint is read-only: opening an account never refreshes OAuth, +// acquires cookies, pings a proxy, or sends a model request. +func (s *OpenAIGatewayService) CodexFingerprint(ctx context.Context, id int64) (*CodexFingerprintView, error) { + a, err := s.accountRepo.GetByID(ctx, id) + if err != nil || !isOpenAICodexTicketAccount(a) || s.pluginManager == nil { + return nil, errCodexRoutingUnavailable + } + installation, _ := s.pluginManager.installedByKey(codexRuntimePluginKey) + store, ok := s.pluginManager.repo.(PluginExtensionStateStore) + if installation == nil || !ok { + return nil, errCodexRoutingUnavailable + } + view := &CodexFingerprintView{AccountID: id, Configured: resolveCodexIdentitySnapshotContext(ctx, a, a, codexAccountIdentityOverrideUA(a)), ReferenceCommit: "4b664e0ef0397f82e68c60088a90fcd035deb796", ReferenceSource: "official_source", Alignment: "application_fields_checked_tls_capture_unknown", CookieMaxAgeSeconds: 120, RefreshLeadSeconds: 20, Models: []CodexRoutingModelStatus{}} + currentScope, scopeErr := s.PrepareCodexRoutingScope(ctx, id, "http") + wire, err := store.ReadExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "wire." + strconv.FormatInt(id, 10)}) + if err != nil { + return nil, err + } + if wire.Found { + var observation CodexWireFingerprint + if json.Unmarshal(wire.Value, &observation) == nil { + view.Observed = &observation + } + } + for _, model := range s.openAICodexTicketConfig().Models { + status := CodexRoutingModelStatus{Model: model, Phase: "idle"} + record, readErr := store.ReadExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: "tickets", Key: strconv.FormatInt(id, 10) + "." + codexRoutingDigest(model)}) + if readErr != nil { + return nil, readErr + } + if record.Found { + var state struct { + Schema int `json:"schema"` + Identity string `json:"identity"` + Phase string `json:"phase"` + Enrolled bool `json:"enrolled"` + Failures int `json:"failures"` + ExpiresAt *time.Time `json:"expires_at"` + NextAt *time.Time `json:"next_attempt_at"` + Qualification *extensionv1.CodexRoutingQualification `json:"qualification"` + Observation *extensionv1.CodexRoutingObservation `json:"observation"` + } + if json.Unmarshal(record.Value, &state) == nil && state.Identity == CodexTicketAccountIdentity(a) { + status.Phase, status.Enrolled, status.Failures, status.ExpiresAt, status.NextAt, status.LastObservation = state.Phase, state.Enrolled, state.Failures, state.ExpiresAt, state.NextAt, state.Observation + status.Qualified = scopeErr == nil && state.Schema == extensionv1.CodexRoutingSchema && state.Qualification.Valid(time.Now(), id, state.Identity, model) && state.Qualification.Scope.SameOwner(currentScope) + if state.Qualification != nil && state.Qualification.Model == model && !state.Qualification.VerifiedAt.IsZero() { + verified := state.Qualification.VerifiedAt + status.VerifiedAt = &verified + } + if state.Schema < extensionv1.CodexRoutingSchema && (state.Phase == "ready" || state.Phase == "retry") { + status.Phase = "needs_cookie_verification" + } + } + } + view.Models = append(view.Models, status) + } + if profile, ok := a.codexClientIdentityContext(ctx); ok { + public := extensionv1.CodexClientProfile(profile) + view.ConfiguredProfile = &public + } + view.Alignment = "application_reference_available_transport_unverified" + view.CapturedReference = append(json.RawMessage(nil), codexRoutingReference...) + return view, nil +} diff --git a/backend/internal/service/codex_routing_fingerprint_test.go b/backend/internal/service/codex_routing_fingerprint_test.go new file mode 100644 index 000000000000..952c5c2dd9f5 --- /dev/null +++ b/backend/internal/service/codex_routing_fingerprint_test.go @@ -0,0 +1,59 @@ +package service + +import ( + "context" + "encoding/json" + "net/http" + "testing" + "time" + + "github.com/Wei-Shaw/sub2api/internal/config" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/stretchr/testify/require" +) + +func TestCodexFingerprintShowsCookieDigestsAndOriginalVerificationTime(t *testing.T) { + account := ticketTestAccount(7) + manager := ticketTestManager(t, config.OpenAICodexTicketConfig{Enabled: true, Models: []string{"gpt-6-astra"}}, nil) + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + manager.repo = store + service := &OpenAIGatewayService{pluginManager: manager, accountRepo: &routingAccountRepositoryFixture{account: account}} + scope, err := service.PrepareCodexRoutingScope(context.Background(), 7, "http") + require.NoError(t, err) + verified := time.Now().UTC().Add(-20 * time.Second).Truncate(time.Second) + expires := verified.Add(time.Minute) + qualification := &extensionv1.CodexRoutingQualification{Scope: scope, Model: "gpt-6-astra", VerifiedAt: verified, ExpiresAt: expires, Bundle: extensionv1.CodexRoutingBundleRef{Key: "bundle.fingerprint", Revision: 1, ExpiresAt: expires}} + raw, err := json.Marshal(map[string]any{"schema": 2, "identity": CodexTicketAccountIdentity(account), "phase": "ready", "enrolled": true, "qualification": qualification}) + require.NoError(t, err) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: "tickets", Key: "7." + codexRoutingDigest("gpt-6-astra"), Value: raw}) + require.NoError(t, err) + request, err := http.NewRequest(http.MethodPost, "https://chatgpt.com/backend-api/codex/responses", nil) + require.NoError(t, err) + request.Header.Set("Cookie", "__cflb=first-secret-cookie; auth_token=private-session") + service.observeCodexWire(context.Background(), account, request, &http.Response{StatusCode: http.StatusOK}, qualification) + view, err := service.CodexFingerprint(context.Background(), 7) + require.NoError(t, err) + require.Len(t, view.Models, 1) + require.NotNil(t, view.Models[0].VerifiedAt) + require.True(t, view.Models[0].VerifiedAt.Equal(verified)) + require.Equal(t, []string{"__cflb"}, view.Observed.CookieNames) + require.Len(t, view.Observed.CookieVersions, 1) + first := view.Observed.CookieVersions["__cflb"] + require.Len(t, first, 16) + raw, err = json.Marshal(view) + require.NoError(t, err) + require.NotContains(t, string(raw), "first-secret-cookie") + require.NotContains(t, string(raw), "private-session") + before := len(store.values) + _, err = service.CodexFingerprint(context.Background(), 7) + require.NoError(t, err) + require.Len(t, store.values, before, "read-only fingerprint GET wrote state") + request.Header.Set("Cookie", "__cflb=second-secret-cookie") + service.observeCodexWire(context.Background(), account, request, &http.Response{StatusCode: http.StatusOK}, qualification) + view, err = service.CodexFingerprint(context.Background(), 7) + require.NoError(t, err) + require.NotEqual(t, first, view.Observed.CookieVersions["__cflb"]) + require.True(t, view.Models[0].VerifiedAt.Equal(verified), "GET replaced the original verification timestamp") + require.False(t, resolveCodexIdentitySnapshotContext(context.Background(), account, account, "").UAOverridePresent) + require.True(t, resolveCodexIdentitySnapshotContext(context.Background(), account, account, "explicit UA override").UAOverridePresent) +} diff --git a/backend/internal/service/codex_routing_host.go b/backend/internal/service/codex_routing_host.go new file mode 100644 index 000000000000..dcee1834f182 --- /dev/null +++ b/backend/internal/service/codex_routing_host.go @@ -0,0 +1,357 @@ +package service + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "net/http" + "net/url" + "slices" + "strings" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/google/uuid" +) + +type codexRoutingHostDirectory interface { + PrepareCodexRoutingScope(context.Context, int64, string) (extensionv1.CodexRoutingScope, error) + ExecuteCodexRoutingProbe(context.Context, extensionv1.CodexRoutingQuery, string, time.Time) (*http.Response, extensionv1.CodexRoutingScope, error) +} + +func isCodexRoutingHostOperation(operation extensionv1.HostOperation) bool { + return operation == extensionv1.HostCodexRoutingScope || operation == extensionv1.HostCodexRoutingProbe || operation == extensionv1.HostCodexRoutingCheck || operation == extensionv1.HostCodexRoutingCleanup +} + +func (h *pluginExtensionHost) callCodexRouting(ctx context.Context, in extensionv1.HostInvocation) (extensionv1.Result, error) { + if in.Operation == extensionv1.HostCodexRoutingCleanup { + return h.redactExpiredCodexRoutingMaterial(ctx) + } + var query extensionv1.CodexRoutingQuery + if h.key != codexRuntimePluginKey || len(in.Payload) > 16384 || json.Unmarshal(in.Payload, &query) != nil || query.AccountID <= 0 { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + directory, ok := h.directory.(codexRoutingHostDirectory) + if !ok { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + account, err := h.directory.ReadExtensionAccount(ctx, query.AccountID) + if err != nil || account == nil || account.Shadow || account.Platform != PlatformOpenAI || (account.Type != AccountTypeOAuth && account.Type != AccountTypeSetupToken) || !h.permitsAccount(account.Platform, account.Type, account.ID, true) { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + if query.Transport == "" { + query.Transport = "http" + } + if query.Transport != "http" && query.Transport != "ws" { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + scope, err := directory.PrepareCodexRoutingScope(ctx, query.AccountID, query.Transport) + if err != nil { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + marshal := func(value any) (extensionv1.Result, error) { + raw, err := json.Marshal(value) + return extensionv1.Result{Payload: raw}, err + } + if in.Operation == extensionv1.HostCodexRoutingScope { + return marshal(scope) + } + if query.Model == "" || len(query.Model) > 256 { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + result := extensionv1.CodexRoutingProbeResult{Scope: scope, Observation: extensionv1.CodexRoutingObservation{Stage: query.Stage, Code: "routing_unavailable", RequestedModel: query.Model, Transport: query.Transport, ObservedAt: time.Now().UTC()}} + var bundle codexRoutingPrivateBundle + var bundleRef extensionv1.CodexRoutingBundleRef + cookieHeader := "" + expires := time.Now().Add(extensionv1.CodexRoutingMaxAge) + if query.Bundle != nil { + bundle, err = readCodexRoutingBundle(ctx, h.state, h.key, *query.Bundle, scope, false) + if err != nil { + result.Observation.Code = "routing_stale" + return marshal(result) + } + bundleRef = *query.Bundle + cookieHeader, expires = codexRoutingCookieHeader(bundle.Cookies, time.Now()) + if cookieHeader == "" { + result.Observation.Code = "routing_cookie_expired" + return marshal(result) + } + } + if in.Operation == extensionv1.HostCodexRoutingCheck { + result.Valid = query.Bundle != nil && bundle.Status == "qualified" && bundle.Model == query.Model && bundle.Scope.ConnectionLeaseID != "" + result.Scope, result.Bundle = bundle.Scope, query.Bundle + return marshal(result) + } + if query.OperationID == "" || len(query.OperationID) > 256 || (query.Stage != "acquire" && query.Stage != "verify") || (query.Stage == "verify" && query.Bundle == nil) { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + if query.Scope != nil && !query.Scope.SameOwner(scope) { + result.Observation.Code = "routing_stale" + return marshal(result) + } + // Persist a spent stage before IO. A lost RPC reply is not permission to + // replay the same upstream request, even after a process restart. + spentKey := "spent." + codexRoutingDigest(fmt.Sprint(query.AccountID), query.OperationID, query.Stage, query.Model, query.Transport) + spent, err := h.state.CompareSwapExtensionState(ctx, h.key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: spentKey, Value: json.RawMessage(`{"spent":true}`)}) + if err != nil || !spent.Applied { + result.Observation.Code = "ticket_interrupted" + return marshal(result) + } + if err := consumeCodexValidationBudget(ctx, h.state, h.key, query); err != nil { + result.Observation.Code = "routing_budget_spent" + return marshal(result) + } + clockKey := "clock." + codexRoutingScopeKey(scope) + clockRecord, err := h.state.ReadExtensionState(ctx, h.key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: clockKey}) + if err != nil { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + clock := codexRoutingCookieClock{Scope: scope} + if clockRecord.Found && (json.Unmarshal(clockRecord.Value, &clock) != nil || !clock.Scope.SameOwner(scope)) { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + // Acquisition is cold; existing business-route material never crosses to + // an unverified rotating acquisition connection. + if query.Stage == "acquire" { + cookieHeader = "" + } + start := time.Now() + if h.activity != nil { + observationID, activityErr := h.activity.BeginUnbilled(ctx, query.AccountID, h.key) + if activityErr != nil { + result.Observation.Code = "routing_observation_unavailable" + return marshal(result) + } + defer func() { + finishCtx, finishCancel := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second) + defer finishCancel() + _ = h.activity.FinishUnbilled(finishCtx, query.AccountID, h.key, observationID) + }() + } + probeCtx, cancel := context.WithTimeout(ctx, 25*time.Second) + defer cancel() + response, wireScope, probeErr := directory.ExecuteCodexRoutingProbe(probeCtx, query, cookieHeader, expires) + result.Scope = wireScope + result.Observation.CookieSent = cookieHeader != "" + result.Observation.DurationMS = time.Since(start).Milliseconds() + if probeErr != nil || response == nil { + result.Observation.Code = "routing_transport" + return marshal(result) + } + defer func() { _ = response.Body.Close() }() + result.Observation.HTTPStatus = response.StatusCode + result.Observation.StateLength = len(strings.TrimSpace(response.Header.Get(openAICodexTurnStateHeader))) + target, _ := url.Parse("https://chatgpt.com/backend-api/codex/responses") + changes := parseCodexRoutingCookies(response.Header, target, start) + if err := preserveCodexCookieFirstSeen(ctx, h.state, h.key, scope, &clock, changes, start); err != nil { + result.Observation.Code = "routing_persist" + return marshal(result) + } + // Deletions are authoritative even on an unsuccessful response. A stale + // CAS loses rather than rebasing old snapshots over a newer tombstone. + clock.apply(changes, start) + clockJSON, _ := json.Marshal(clock) + savedClock, err := h.state.CompareSwapExtensionState(ctx, h.key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: clockKey, ExpectedRevision: clockRecord.Revision, Value: clockJSON, NextAt: codexCookieClockDeadline(clock)}) + if err != nil || !savedClock.Applied { + result.Observation.Code = "routing_stale" + return marshal(result) + } + if response.StatusCode != http.StatusOK && !(query.Transport == "ws" && response.StatusCode == http.StatusSwitchingProtocols) { + result.Observation.Code = "routing_upstream" + return marshal(result) + } + if err := readCodexRoutingCompletion(response.Body, response.Header.Get("Content-Type"), query.Model, &result.Observation); err != nil { + // A completed cold acquisition can issue a useful routing Cookie even + // when that cold turn selected another model. It is only a candidate; + // business-exit verification remains the sole model qualification gate. + if query.Stage != "acquire" || !result.Observation.Completed || result.Observation.ResponseModel == "" || result.Observation.Code != "routing_model_mismatch" { + return marshal(result) + } + } + result.Observation.DurationMS = time.Since(start).Milliseconds() + current, err := directory.PrepareCodexRoutingScope(ctx, query.AccountID, query.Transport) + if err != nil || !scope.SameOwner(current) || ctx.Err() != nil { + result.Observation.Code = "routing_stale" + return marshal(result) + } + if query.Stage == "acquire" { + bundle = codexRoutingPrivateBundle{Schema: extensionv1.CodexRoutingSchema, Scope: scope, Status: "candidate", Model: query.Model, Cookies: clock.selected(nil, changes, time.Now()), ClockKey: clockKey, ClockRevision: savedClock.Revision} + bundleRef.Key = fixedCodexRoutingBundleKey(ctx, query, "candidate") + } else { + // Verification may refresh a routing cookie on this very connection. + // Publish exactly the values observed by the verified response. + bundle.Cookies, bundle.ClockRevision = clock.selected(bundle.Cookies, changes, time.Now()), savedClock.Revision + bundle.Scope, bundle.Status, bundle.Model = wireScope, "qualified", query.Model + bundleRef.Key = fixedCodexRoutingBundleKey(ctx, query, "live") + if wireScope.ConnectionLeaseID == "" { + result.Observation.Code = "routing_connection_unknown" + return marshal(result) + } + } + _, deadline := codexRoutingCookieHeader(bundle.Cookies, time.Now()) + if deadline.IsZero() { + result.Observation.Code = "routing_cookie_missing" + return marshal(result) + } + bundle.ExpiresAt = earlierCodexTime(deadline, expires) + bundle.Observation = result.Observation + raw, _ := json.Marshal(bundle) + previousBundle, readErr := h.state.ReadExtensionState(ctx, h.key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: bundleRef.Key}) + if readErr != nil { + result.Observation.Code = "routing_persist" + return marshal(result) + } + saved, err := h.state.CompareSwapExtensionState(ctx, h.key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: bundleRef.Key, ExpectedRevision: previousBundle.Revision, Value: raw, NextAt: &bundle.ExpiresAt}) + if err != nil || !saved.Applied { + result.Observation.Code = "routing_stale" + return marshal(result) + } + result.Bundle = &extensionv1.CodexRoutingBundleRef{Key: bundleRef.Key, Revision: saved.Revision, ExpiresAt: bundle.ExpiresAt, ConnectionLeaseID: bundle.Scope.ConnectionLeaseID} + for _, cookie := range bundle.Cookies { + result.Observation.CookieNames = append(result.Observation.CookieNames, cookie.Name) + } + result.Valid = true + if query.Stage == "acquire" { + result.Observation.Code = "routing_candidate" + } else { + result.Observation.Code = "routing_verified" + } + return marshal(result) +} + +func readCodexRoutingBundle(ctx context.Context, store PluginExtensionStateStore, key string, ref extensionv1.CodexRoutingBundleRef, scope extensionv1.CodexRoutingScope, qualified bool) (codexRoutingPrivateBundle, error) { + var bundle codexRoutingPrivateBundle + if store == nil || !strings.HasPrefix(ref.Key, "bundle.") || len(ref.Key) > 80 || ref.Revision <= 0 || !time.Now().Before(ref.ExpiresAt) { + return bundle, errCodexRoutingUnavailable + } + record, err := store.ReadExtensionState(ctx, key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: ref.Key}) + if err != nil || !record.Found || record.Revision != ref.Revision || json.Unmarshal(record.Value, &bundle) != nil || bundle.Schema != extensionv1.CodexRoutingSchema || !scope.SameOwner(bundle.Scope) || !time.Now().Before(bundle.ExpiresAt) || (qualified && bundle.Status != "qualified") { + return bundle, errCodexRoutingUnavailable + } + clockRecord, err := store.ReadExtensionState(ctx, key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: bundle.ClockKey}) + var clock codexRoutingCookieClock + if err != nil || !clockRecord.Found || json.Unmarshal(clockRecord.Value, &clock) != nil || !clock.Scope.SameOwner(scope) { + return bundle, errCodexRoutingUnavailable + } + for _, cookie := range bundle.Cookies { + digest := codexRoutingDigest(cookie.Name, cookie.Value) + first, exists := clock.Seen[digest] + if !exists { + record, readErr := store.ReadExtensionState(ctx, key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "seen." + codexRoutingDigest(codexRoutingScopeKey(scope), digest)}) + var seen struct { + First time.Time `json:"first_seen"` + } + if readErr == nil && record.Found && json.Unmarshal(record.Value, &seen) == nil { + first, exists = seen.First, !seen.First.IsZero() + } + } + if !exists || !first.Equal(cookie.FirstSeen) || !time.Now().Before(cookie.ExpiresAt) { + return bundle, errCodexRoutingUnavailable + } + if deleted, exists := clock.Tombstones[cookie.Name]; exists && !cookie.FirstSeen.After(deleted) { + return bundle, errCodexRoutingUnavailable + } + } + return bundle, nil +} + +func (s *OpenAIGatewayService) PrepareCodexRoutingScope(ctx context.Context, id int64, transport string) (extensionv1.CodexRoutingScope, error) { + a, err := s.accountRepo.GetByID(ctx, id) + if err != nil || !isOpenAICodexTicketAccount(a) { + return extensionv1.CodexRoutingScope{}, errCodexRoutingUnavailable + } + identity, err := resolveCodexOutboundIdentityForAccountContext(ctx, a, codexAccountIdentityOverrideUA(a)) + if err != nil { + return extensionv1.CodexRoutingScope{}, err + } + seed, _ := codexFingerprintSeed(a.Extra) + profile := codexRoutingDigest(identity.userAgent, identity.originator, identity.version, seed, resolveConvergedInstallationID(a, seed), string(a.GetCodexFingerprintMode()), "go-crypto-tls", "native-http1") + config := s.openAICodexTicketConfig() + return extensionv1.CodexRoutingScope{AccountID: id, Identity: CodexTicketAccountIdentity(a), ProfileHash: profile, RouteHash: codexRoutingDigest(resolveAccountProxyURL(a), config.HarvestProxyURL), RouteEvidence: "connection_required", Transport: transport}, nil +} + +func (s *OpenAIGatewayService) ExecuteCodexRoutingProbe(ctx context.Context, query extensionv1.CodexRoutingQuery, cookies string, deadline time.Time) (*http.Response, extensionv1.CodexRoutingScope, error) { + scope, err := s.PrepareCodexRoutingScope(ctx, query.AccountID, query.Transport) + if err != nil { + return nil, scope, err + } + cfg := s.openAICodexTicketConfig() + _, validation := codexValidationFromContext(ctx) + if !cfg.Enabled || (!slices.Contains(cfg.Models, query.Model) && !validation) { + return nil, scope, errCodexRoutingUnavailable + } + if query.Transport == "ws" { + return s.executeCodexRoutingWSProbe(ctx, query, cookies, deadline, scope) + } + a, err := s.accountRepo.GetByID(ctx, query.AccountID) + if err != nil { + return nil, scope, errCodexRoutingUnavailable + } + token, _, err := s.GetAccessToken(withCodexTicketCredentials(ctx), a) + if err != nil { + return nil, scope, errCodexRoutingUnavailable + } + request, err := s.buildCodexRoutingProbe(ctx, a, query.Model, token, cookies) + if err != nil { + return nil, scope, err + } + if query.Stage == "acquire" { + if cfg.HarvestProxyURL == "" { + return nil, scope, errCodexRoutingUnavailable + } + response, err := s.doCodexRoutingAcquisition(request, cfg.HarvestProxyURL, a.ID) + return response, scope, err + } + transport, ok := s.httpUpstream.(CodexConnectionLeaseUpstream) + if !ok { + return nil, scope, errCodexRoutingUnavailable + } + response, lease, err := transport.DoWithCodexConnectionLease(request, resolveAccountProxyURL(a), a.ID, codexRoutingScopeKey(scope), "", deadline, nil) + scope.ConnectionLeaseID, scope.RouteEvidence = lease, "connection" + if err == nil && response != nil { + observeCodexInfrastructureCookies(scope, response.Header, deadline) + s.observeCodexWire(ctx, a, request, response, &extensionv1.CodexRoutingQualification{Scope: scope, Model: query.Model}) + } + return response, scope, err +} + +func (s *OpenAIGatewayService) buildCodexRoutingProbe(ctx context.Context, account *Account, model, token, cookies string) (*http.Request, error) { + session, turn := uuid.Must(uuid.NewV7()).String(), uuid.Must(uuid.NewV7()).String() + metadata := map[string]any{"session_id": session, "thread_id": session, "turn_id": turn, "x-codex-window-id": session + ":0"} + body := map[string]any{"model": model, "store": false, "stream": true, "instructions": "Reply with exactly: pong", "input": []any{map[string]any{"role": "user", "content": []any{map[string]any{"type": "input_text", "text": "ping"}}}}, "client_metadata": metadata, "prompt_cache_key": session} + headers := http.Header{} + headers.Set("session-id", session) + headers.Set("thread-id", session) + headers.Set("x-client-request-id", session) + headers.Set("x-codex-window-id", session+":0") + applyCodexAccountIdentityClientMetadataMap(body, account, 0) + applyCodexAccountIdentityHeaders(headers, account, 0) + ids := resolveCodexFingerprintIDsFromRequest(account, headers) + applyCodexFingerprintClientMetadata(body, ids) + applyCodexFingerprintHeaders(headers, ids) + if err := enforceCodexIdentityHeadersForAccountContext(ctx, headers, account, codexAccountIdentityOverrideUA(account)); err != nil { + return nil, err + } + if err := resolveAndSetOpenAIChatGPTAccountHeaders(ctx, s.accountRepo, headers, account); err != nil { + return nil, err + } + headers.Set("Authorization", "Bearer "+token) + headers.Set("Accept", "text/event-stream") + headers.Set("Content-Type", "application/json") + if cookies != "" { + headers.Set("Cookie", cookies) + } + raw, err := json.Marshal(body) + if err != nil { + return nil, err + } + req, err := http.NewRequestWithContext(WithHTTPUpstreamRedirectsDisabled(ctx), http.MethodPost, "https://chatgpt.com/backend-api/codex/responses", bytes.NewReader(raw)) + if err != nil { + return nil, err + } + req.Header = headers + return prepareCodexTransport(req, account) +} + +var _ codexRoutingHostDirectory = (*OpenAIGatewayService)(nil) diff --git a/backend/internal/service/codex_routing_identity_observation.go b/backend/internal/service/codex_routing_identity_observation.go new file mode 100644 index 000000000000..ab1d4c352fb0 --- /dev/null +++ b/backend/internal/service/codex_routing_identity_observation.go @@ -0,0 +1,76 @@ +package service + +import ( + "io" + "net/http" + "strings" + + "github.com/tidwall/gjson" +) + +type codexIdentityBodyKey struct{} + +type CodexIdentityFieldObservation struct { + HeaderDigest string `json:"header_digest,omitempty"` + BodyDigest string `json:"body_digest,omitempty"` + Consistency string `json:"consistency"` +} + +type codexIdentityBodyObservation struct { + Inspected bool + Fields map[string]string +} + +func inspectCodexIdentityBody(request *http.Request) codexIdentityBodyObservation { + result := codexIdentityBodyObservation{Fields: map[string]string{}} + if request == nil || request.GetBody == nil || request.Header.Get("Content-Encoding") != "" { + return result + } + body, err := request.GetBody() + if err != nil { + return result + } + defer func() { _ = body.Close() }() + raw, err := io.ReadAll(io.LimitReader(body, codexRoutingProbeReadLimit+1)) + if err != nil || len(raw) > codexRoutingProbeReadLimit || !gjson.ValidBytes(raw) { + return result + } + result.Inspected = true + paths := map[string]string{"installation": "client_metadata.x-codex-installation-id", "session": "client_metadata.session_id", "thread": "client_metadata.thread_id", "turn": "client_metadata.turn_id", "window": "client_metadata.x-codex-window-id"} + for field, path := range paths { + value := strings.TrimSpace(gjson.GetBytes(raw, path).String()) + if len(value) <= 512 { + result.Fields[field] = value + } + } + return result +} + +func codexIdentityFieldObservations(headers http.Header, body codexIdentityBodyObservation) map[string]CodexIdentityFieldObservation { + metadata := headers.Get(openAIWSTurnMetadataHeader) + values := map[string]string{"installation": gjson.Get(metadata, "installation_id").String(), "session": extractClientSessionID(headers), "thread": headers.Get("thread-id"), "turn": gjson.Get(metadata, "turn_id").String(), "window": headers.Get("x-codex-window-id")} + result := make(map[string]CodexIdentityFieldObservation, len(values)) + for key, raw := range values { + header := strings.TrimSpace(raw) + value := body.Fields[key] + observation := CodexIdentityFieldObservation{Consistency: "uninspected"} + if header != "" { + observation.HeaderDigest = codexRoutingDigest(header)[:16] + } + if value != "" { + observation.BodyDigest = codexRoutingDigest(value)[:16] + } + if body.Inspected { + switch { + case header == "" || value == "": + observation.Consistency = "missing" + case header == value: + observation.Consistency = "match" + default: + observation.Consistency = "mismatch" + } + } + result[key] = observation + } + return result +} diff --git a/backend/internal/service/codex_routing_identity_observation_test.go b/backend/internal/service/codex_routing_identity_observation_test.go new file mode 100644 index 000000000000..1d46001bc0c9 --- /dev/null +++ b/backend/internal/service/codex_routing_identity_observation_test.go @@ -0,0 +1,33 @@ +package service + +import ( + "github.com/stretchr/testify/require" + "io" + "net/http" + "strings" + "testing" +) + +func TestCodexRoutingIdentityObservationsAreBoundedAndRedacted(t *testing.T) { + request, err := http.NewRequest("POST", "https://chatgpt.com/backend-api/codex/responses", strings.NewReader(`{"client_metadata":{"session_id":"same-session","thread_id":"body-thread","turn_id":"turn-only"},"input":"secret-prompt"}`)) + require.NoError(t, err) + request.Header.Set("session-id", "same-session") + request.Header.Set("thread-id", "different-thread") + before := request.Body + observation := inspectCodexIdentityBody(request) + fields := codexIdentityFieldObservations(request.Header, observation) + require.Equal(t, before, request.Body) + remaining, readErr := io.ReadAll(request.Body) + require.NoError(t, readErr) + require.Contains(t, string(remaining), "secret-prompt", "inspection must not consume the send body") + require.Equal(t, "match", fields["session"].Consistency) + require.Equal(t, "mismatch", fields["thread"].Consistency) + require.Equal(t, "missing", fields["turn"].Consistency) + require.Len(t, fields["session"].HeaderDigest, 16) + require.NotEqual(t, "same-session", fields["session"].HeaderDigest) + request.GetBody = nil + fields = codexIdentityFieldObservations(request.Header, inspectCodexIdentityBody(request)) + require.Equal(t, "uninspected", fields["session"].Consistency) + oversized, _ := http.NewRequest("POST", "https://chatgpt.com/backend-api/codex/responses", strings.NewReader(`{"input":"`+strings.Repeat("x", codexRoutingProbeReadLimit)+`"}`)) + require.False(t, inspectCodexIdentityBody(oversized).Inspected) +} diff --git a/backend/internal/service/codex_routing_infrastructure.go b/backend/internal/service/codex_routing_infrastructure.go new file mode 100644 index 000000000000..dffdcea7e62d --- /dev/null +++ b/backend/internal/service/codex_routing_infrastructure.go @@ -0,0 +1,99 @@ +package service + +import ( + "net/http" + "net/http/cookiejar" + "net/url" + "strings" + "sync" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "golang.org/x/net/publicsuffix" +) + +// Infrastructure cookies do not confer model qualification. They are a +// separate allowlisted jar tied to an actual connection, never global to users +// and never carried to a freshly rotated proxy connection. +type codexInfrastructureCookies struct { + mu sync.Mutex + jar *cookiejar.Jar + expires time.Time +} + +var codexInfrastructureJars sync.Map // opaque connection scope -> bounded-lived jar + +func isCodexInfrastructureCookie(name string) bool { + switch name { + case "__cf_bm", "__cflb", "__cfruid", "__cfseq", "__cfwaitingroom", "__oailb", "_cfuvid", "cf_clearance", "cf_ob_info", "cf_use_ob": + return true + default: + return strings.HasPrefix(name, "cf_chl_") && len(name) <= 80 + } +} + +func codexInfrastructureJar(scope extensionv1.CodexRoutingScope, expires time.Time, create bool) *codexInfrastructureCookies { + if scope.ConnectionLeaseID == "" || !time.Now().Before(expires) { + return nil + } + key := codexRoutingDigest(codexRoutingScopeKey(scope), scope.ConnectionLeaseID) + if value, ok := codexInfrastructureJars.Load(key); ok { + jar := value.(*codexInfrastructureCookies) + if time.Now().Before(jar.expires) { + return jar + } + codexInfrastructureJars.Delete(key) + } + if !create { + return nil + } + jar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List}) + if err != nil { + return nil + } + value := &codexInfrastructureCookies{jar: jar, expires: earlierCodexTime(expires, time.Now().Add(extensionv1.CodexRoutingMaxAge))} + actual, loaded := codexInfrastructureJars.LoadOrStore(key, value) + if !loaded { + time.AfterFunc(time.Until(value.expires), func() { codexInfrastructureJars.CompareAndDelete(key, value) }) + } + return actual.(*codexInfrastructureCookies) +} + +func observeCodexInfrastructureCookies(scope extensionv1.CodexRoutingScope, headers http.Header, expires time.Time) { + var cookies []*http.Cookie + for _, cookie := range (&http.Response{Header: headers}).Cookies() { + if !isCodexInfrastructureCookie(cookie.Name) || isCodexRoutingCookie(cookie.Name) || cookie.Valid() != nil || len(cookie.Value) > 8192 { + continue + } + cookies = append(cookies, cookie) + } + if len(cookies) == 0 { + return + } + jar := codexInfrastructureJar(scope, expires, true) + if jar == nil { + return + } + target, _ := url.Parse("https://chatgpt.com/backend-api/codex/responses") + jar.mu.Lock() + defer jar.mu.Unlock() + jar.jar.SetCookies(target, cookies) +} + +func applyCodexInfrastructureCookies(request *http.Request, scope extensionv1.CodexRoutingScope, expires time.Time) { + if request == nil || request.URL == nil || request.URL.Scheme != "https" || request.URL.Hostname() != "chatgpt.com" { + return + } + jar := codexInfrastructureJar(scope, expires, false) + if jar == nil { + return + } + jar.mu.Lock() + cookies := jar.jar.Cookies(request.URL) + jar.mu.Unlock() + for _, cookie := range cookies { + if isCodexInfrastructureCookie(cookie.Name) && !isCodexRoutingCookie(cookie.Name) { + request.AddCookie(cookie) + } + } +} diff --git a/backend/internal/service/codex_routing_native_ws.go b/backend/internal/service/codex_routing_native_ws.go new file mode 100644 index 000000000000..5a1dc8ba0153 --- /dev/null +++ b/backend/internal/service/codex_routing_native_ws.go @@ -0,0 +1,56 @@ +package service + +import ( + "bytes" + "context" + "encoding/json" + "net/http" + + openaiwsv2 "github.com/Wei-Shaw/sub2api/internal/service/openai_ws_v2" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + coderws "github.com/coder/websocket" + "github.com/tidwall/gjson" +) + +// A native socket that started outside the Cookie policy cannot acquire an +// HTTP connection's qualification through a later session/model switch. The +// client must reconnect with the gated model so ingress chooses its bridge. +func (s *OpenAIGatewayService) guardCodexRoutingNativeModel(account *Account, model string) error { + if s.codexRoutingApplies(account, model) { + return NewOpenAIWSClientCloseError(coderws.StatusPolicyViolation, "this model requires a verified HTTP route; reconnect with this model", errCodexRoutingUnavailable) + } + return nil +} + +func (s *OpenAIGatewayService) observeNativeCodexWS(ctx context.Context, account *Account, headers, handshake http.Header, payload []byte, connection string) { + if !isOpenAICodexTicketAccount(account) || s.pluginManager == nil { + return + } + request, _ := http.NewRequestWithContext(ctx, http.MethodGet, "https://chatgpt.com/backend-api/codex/responses", bytes.NewReader(payload)) + request.Header = headers.Clone() + request = request.WithContext(context.WithValue(request.Context(), codexIdentityBodyKey{}, inspectCodexIdentityBody(request))) + request = request.WithContext(context.WithValue(request.Context(), codexRoutingIngressKey{}, "ws")) + scope := extensionv1.CodexRoutingScope{AccountID: account.ID, Identity: CodexTicketAccountIdentity(account), Transport: "ws", ConnectionLeaseID: connection, RouteEvidence: "native_connection_observed"} + q := &extensionv1.CodexRoutingQualification{Scope: scope} + s.observeCodexWire(ctx, account, request, &http.Response{StatusCode: http.StatusSwitchingProtocols, Proto: "HTTP/1.1", Header: handshake}, q) +} + +func codexWSMetadataBody(payload map[string]any) []byte { + raw, _ := json.Marshal(map[string]any{"client_metadata": payload["client_metadata"]}) + return raw +} + +type codexObservedNativeFrameConn struct { + openaiwsv2.FrameConn + observe func(context.Context, []byte) +} + +func (connection *codexObservedNativeFrameConn) WriteFrame(ctx context.Context, kind coderws.MessageType, payload []byte) error { + if err := connection.FrameConn.WriteFrame(ctx, kind, payload); err != nil { + return err + } + if kind == coderws.MessageText && gjson.GetBytes(payload, "type").String() == "response.create" { + connection.observe(ctx, payload) + } + return nil +} diff --git a/backend/internal/service/codex_routing_profile.go b/backend/internal/service/codex_routing_profile.go new file mode 100644 index 000000000000..84f1a1eb4f5a --- /dev/null +++ b/backend/internal/service/codex_routing_profile.go @@ -0,0 +1,51 @@ +package service + +import ( + "context" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +type CodexProfileSelection struct { + Profile string `json:"profile"` + ExpectedRevision time.Time `json:"expected_revision"` +} + +func (s *OpenAIGatewayService) SelectCodexProfile(ctx context.Context, id int64, choice CodexProfileSelection) error { + if choice.Profile != "captured_windows_cli" && choice.Profile != "keep_legacy" { + return errCodexRoutingUnavailable + } + account, err := s.accountRepo.GetByID(ctx, id) + if err != nil || !isOpenAICodexTicketAccount(account) { + return errCodexRoutingUnavailable + } + if choice.Profile == "keep_legacy" { + return nil + } + if choice.ExpectedRevision.IsZero() || !choice.ExpectedRevision.Equal(account.UpdatedAt) { + return ErrPluginStateChanged + } + seed, valid := codexFingerprintSeed(account.Extra) + if !valid { + return errCodexRoutingUnavailable + } + result, err := invokeCodexIdentityPolicyForAccount(ctx, account, "codex.identity.derive", extensionv1.CodexIdentityQuery{Seed: seed, Preset: choice.Profile}) + if err != nil || !result.Valid || result.Profile.Version != 2 { + return errCodexRoutingUnavailable + } + writer, ok := s.accountRepo.(interface { + UpdateExtraIfRevision(context.Context, int64, time.Time, map[string]any) (bool, error) + }) + if !ok { + return errCodexRoutingUnavailable + } + applied, err := writer.UpdateExtraIfRevision(ctx, id, choice.ExpectedRevision, map[string]any{CodexClientIdentityExtraKey: codexClientIdentityExtraValue(codexClientIdentity(result.Profile), time.Now())}) + if err != nil { + return err + } + if !applied { + return ErrPluginStateChanged + } + return nil +} diff --git a/backend/internal/service/codex_routing_proxy.go b/backend/internal/service/codex_routing_proxy.go new file mode 100644 index 000000000000..e515c5332af4 --- /dev/null +++ b/backend/internal/service/codex_routing_proxy.go @@ -0,0 +1,118 @@ +package service + +import ( + "crypto/tls" + "crypto/x509" + "encoding/json" + "net" + "net/http" + "net/url" + "time" + + proxytransport "github.com/Wei-Shaw/sub2api/pkg/extensionapi/proxy" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +// This is the existing explicit proxy.test record. Only acquisition reads it; +// business connection leases and native WebSockets retain their own TLS policy. +type codexRoutingProxyTrust struct { + Certificates [][]byte `json:"certificates"` + Fingerprint string `json:"fingerprint"` +} + +func (s *OpenAIGatewayService) doCodexRoutingAcquisition(request *http.Request, proxyURL string, accountID int64) (*http.Response, error) { + if request == nil || request.URL == nil || request.Method != http.MethodPost || request.URL.Scheme != "https" || request.URL.Host != "chatgpt.com" || request.URL.Path != "/backend-api/codex/responses" || request.URL.RawQuery != "" || request.URL.User != nil || s.pluginManager == nil { + return nil, errCodexRoutingUnavailable + } + normal, err := proxytransport.Normalize(proxyURL) + if err != nil || normal == "" { + return nil, errCodexRoutingUnavailable + } + installation, _ := s.pluginManager.installedByKey(codexRuntimePluginKey) + store, ok := s.pluginManager.repo.(PluginExtensionStateStore) + if installation == nil || !ok { + return nil, errCodexRoutingUnavailable + } + ctx := WithPluginExecution(request.Context(), installation) + record, err := store.ReadExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: "proxy-trust", Key: codexRoutingDigest(normal, "chatgpt.com")}) + if err != nil { + return nil, errCodexRoutingUnavailable + } + wire := request.Clone(WithHTTPUpstreamProfile(request.Context(), HTTPUpstreamProfileOpenAIHarvest)) + wire.Header.Del("Cookie") + if !record.Found { + if s.httpUpstream == nil { + return nil, errCodexRoutingUnavailable + } + return s.httpUpstream.Do(wire, normal, accountID, 1) + } + var trust codexRoutingProxyTrust + if len(record.Value) > 128*1024 || json.Unmarshal(record.Value, &trust) != nil || len(trust.Certificates) != 1 { + return nil, errCodexRoutingUnavailable + } + anchor, err := x509.ParseCertificate(trust.Certificates[0]) + if err != nil || codexRoutingDigest(string(anchor.RawSubjectPublicKeyInfo)) != trust.Fingerprint { + return nil, errCodexRoutingUnavailable + } + roots := x509.NewCertPool() + roots.AddCert(anchor) + transport, err := codexRoutingAcquisitionTransport(normal, roots) + if err != nil { + return nil, errCodexRoutingUnavailable + } + defer transport.CloseIdleConnections() + client := &http.Client{Transport: transport, Timeout: 25 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }} + return client.Do(wire) +} + +func verifyCodexRoutingProxyCertificate(state tls.ConnectionState, pinnedRoots *x509.CertPool) error { + if state.ServerName == "" || len(state.PeerCertificates) == 0 { + return errCodexRoutingUnavailable + } + intermediates := x509.NewCertPool() + for _, certificate := range state.PeerCertificates[1:] { + intermediates.AddCert(certificate) + } + opts := x509.VerifyOptions{DNSName: state.ServerName, Intermediates: intermediates} + if _, err := state.PeerCertificates[0].Verify(opts); err == nil { + return nil + } + // The explicit anchor cannot authorize an HTTPS proxy endpoint, another + // origin, an expired certificate or a changed certificate chain. No IO in + // this path learns or writes certificate trust, with or without OAuth. + if state.ServerName != "chatgpt.com" || pinnedRoots == nil { + return errCodexRoutingUnavailable + } + opts.Roots = pinnedRoots + if _, err := state.PeerCertificates[0].Verify(opts); err != nil { + return errCodexRoutingUnavailable + } + return nil +} + +func codexRoutingAcquisitionTransport(raw string, pinnedRoots *x509.CertPool) (*http.Transport, error) { + address, err := url.Parse(raw) + if err != nil { + return nil, errCodexRoutingUnavailable + } + transport := &http.Transport{ + DialContext: (&net.Dialer{Timeout: 8 * time.Second}).DialContext, + TLSHandshakeTimeout: 8 * time.Second, + ResponseHeaderTimeout: 12 * time.Second, + DisableKeepAlives: true, + DisableCompression: true, + ForceAttemptHTTP2: false, + TLSNextProto: map[string]func(string, *tls.Conn) http.RoundTripper{}, + TLSClientConfig: &tls.Config{ + MinVersion: tls.VersionTLS12, + InsecureSkipVerify: true, // #nosec G402 -- complete system/pinned chain, hostname and time validation below. + VerifyConnection: func(state tls.ConnectionState) error { + return verifyCodexRoutingProxyCertificate(state, pinnedRoots) + }, + }, + } + if err := proxytransport.Configure(transport, address, nil); err != nil { + return nil, err + } + return transport, nil +} diff --git a/backend/internal/service/codex_routing_proxy_test.go b/backend/internal/service/codex_routing_proxy_test.go new file mode 100644 index 000000000000..dee1be9fe07d --- /dev/null +++ b/backend/internal/service/codex_routing_proxy_test.go @@ -0,0 +1,156 @@ +package service + +import ( + "context" + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" + "crypto/tls" + "crypto/x509" + "crypto/x509/pkix" + "encoding/json" + "io" + "log" + "math/big" + "net" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "sync/atomic" + "testing" + "time" + + "github.com/Wei-Shaw/sub2api/internal/config" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/stretchr/testify/require" +) + +func routingProxyTestCertificate(t *testing.T, name string, expired bool) (tls.Certificate, *x509.Certificate) { + t.Helper() + key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + require.NoError(t, err) + now := time.Now() + until := now.Add(time.Hour) + if expired { + until = now.Add(-time.Minute) + } + template := &x509.Certificate{SerialNumber: big.NewInt(now.UnixNano()), Subject: pkix.Name{CommonName: name}, DNSNames: []string{name}, NotBefore: now.Add(-time.Hour), NotAfter: until, KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}} + der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key) + require.NoError(t, err) + certificate, err := x509.ParseCertificate(der) + require.NoError(t, err) + return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: key}, certificate +} + +type routingProxySystemUpstream struct { + HTTPUpstream + client *http.Client +} + +func (upstream *routingProxySystemUpstream) Do(request *http.Request, _ string, _ int64, _ int) (*http.Response, error) { + return upstream.client.Do(request) +} + +func TestCodexRoutingAcquisitionUsesOnlyExplicitProxyTrust(t *testing.T) { + certificate, anchor := routingProxyTestCertificate(t, "chatgpt.com", false) + var active atomic.Pointer[tls.Certificate] + active.Store(&certificate) + var requests, redirects atomic.Int64 + var redirect atomic.Bool + sink := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { redirects.Add(1) })) + t.Cleanup(sink.Close) + target := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) { + requests.Add(1) + if request.Method != http.MethodPost || request.URL.Path != "/backend-api/codex/responses" || request.Header.Get("Authorization") != "Bearer synthetic-oauth" || request.Header.Get("Proxy-Authorization") != "" || request.Header.Get("Cookie") != "" { + t.Error("acquisition credential or cold-cookie boundary changed") + } + if redirect.Load() { + http.Redirect(w, request, sink.URL, http.StatusTemporaryRedirect) + return + } + w.WriteHeader(http.StatusOK) + })) + target.Config.ErrorLog = log.New(io.Discard, "", 0) + target.TLS = &tls.Config{MinVersion: tls.VersionTLS12, GetCertificate: func(*tls.ClientHelloInfo) (*tls.Certificate, error) { return active.Load(), nil }} + target.StartTLS() + t.Cleanup(target.Close) + proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) { + if request.Method != http.MethodConnect || request.Host != "chatgpt.com:443" || request.Header.Get("Proxy-Authorization") == "" || request.Header.Get("Authorization") != "" { + t.Error("CONNECT credential boundary changed") + w.WriteHeader(http.StatusBadRequest) + return + } + upstream, err := net.Dial("tcp", target.Listener.Addr().String()) + if err != nil { + w.WriteHeader(http.StatusBadGateway) + return + } + client, _, err := w.(http.Hijacker).Hijack() + if err != nil { + _ = upstream.Close() + return + } + _, _ = io.WriteString(client, "HTTP/1.1 200 Connection Established\r\n\r\n") + go func() { + defer client.Close() + defer upstream.Close() + go func() { _, _ = io.Copy(upstream, client) }() + _, _ = io.Copy(client, upstream) + }() + })) + t.Cleanup(proxy.Close) + address, err := url.Parse(proxy.URL) + require.NoError(t, err) + address.User = url.UserPassword("proxy-user", "synthetic-password") + transport, err := codexRoutingAcquisitionTransport(address.String(), nil) + require.NoError(t, err) + t.Cleanup(transport.CloseIdleConnections) + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + manager := ticketTestManager(t, config.OpenAICodexTicketConfig{}, nil) + manager.repo = store + service := &OpenAIGatewayService{pluginManager: manager, httpUpstream: &routingProxySystemUpstream{client: &http.Client{Transport: transport, Timeout: 3 * time.Second}}} + send := func() (*http.Response, error) { + request, err := http.NewRequestWithContext(context.Background(), http.MethodPost, "https://chatgpt.com/backend-api/codex/responses", strings.NewReader(`{"model":"synthetic-model"}`)) + require.NoError(t, err) + request.Header.Set("Authorization", "Bearer synthetic-oauth") + request.Header.Set("Cookie", "__cflb=old-business-cookie") + return service.doCodexRoutingAcquisition(request, address.String(), 7) + } + _, err = send() + require.Error(t, err, "an untrusted certificate must not be learned during acquisition") + require.Zero(t, requests.Load(), "OAuth was sent before certificate verification") + require.Empty(t, store.values) + trust := codexRoutingProxyTrust{Certificates: [][]byte{anchor.Raw}, Fingerprint: codexRoutingDigest(string(anchor.RawSubjectPublicKeyInfo))} + raw, err := json.Marshal(trust) + require.NoError(t, err) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: "proxy-trust", Key: codexRoutingDigest(address.String(), "chatgpt.com"), Value: raw}) + require.NoError(t, err) + response, err := send() + require.NoError(t, err) + _ = response.Body.Close() + require.Equal(t, http.StatusOK, response.StatusCode) + require.EqualValues(t, 1, requests.Load()) + rotated, _ := routingProxyTestCertificate(t, "chatgpt.com", false) + active.Store(&rotated) + _, err = send() + require.Error(t, err) + require.EqualValues(t, 1, requests.Load(), "changed certificate received OAuth") + require.Len(t, store.values, 1, "acquisition must never write proxy trust") + active.Store(&certificate) + redirect.Store(true) + response, err = send() + require.NoError(t, err) + _ = response.Body.Close() + require.Equal(t, http.StatusTemporaryRedirect, response.StatusCode) + require.Zero(t, redirects.Load(), "OAuth request followed a redirect") + for _, test := range []struct { + name string + expired bool + }{{"proxy.example", false}, {"chatgpt.com", true}} { + _, certificate := routingProxyTestCertificate(t, test.name, test.expired) + roots := x509.NewCertPool() + roots.AddCert(certificate) + require.Error(t, verifyCodexRoutingProxyCertificate(tls.ConnectionState{ServerName: test.name, PeerCertificates: []*x509.Certificate{certificate}}, roots)) + } +} diff --git a/backend/internal/service/codex_routing_redaction.go b/backend/internal/service/codex_routing_redaction.go new file mode 100644 index 000000000000..d514e182cf97 --- /dev/null +++ b/backend/internal/service/codex_routing_redaction.go @@ -0,0 +1,87 @@ +package service + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +func fixedCodexRoutingBundleKey(ctx context.Context, query extensionv1.CodexRoutingQuery, kind string) string { + suffix := "" + if _, validation := codexValidationFromContext(ctx); validation { + suffix = ".validation" + } + return "bundle." + fmt.Sprint(query.AccountID) + "." + codexRoutingDigest(query.Model)[:32] + "." + kind + suffix +} + +func codexCookieClockDeadline(clock codexRoutingCookieClock) *time.Time { + var next time.Time + for _, cookie := range clock.Cookies { + if cookie.Value != "" && (next.IsZero() || cookie.ExpiresAt.Before(next)) { + next = cookie.ExpiresAt + } + } + if next.IsZero() { + return nil + } + return &next +} + +// Only expired raw values in this domain's private namespace are redacted. +// No row, observation, first-seen digest, tombstone or ledger is deleted. +func (h *pluginExtensionHost) redactExpiredCodexRoutingMaterial(ctx context.Context) (extensionv1.Result, error) { + if h.key != codexRuntimePluginKey || h.state == nil { + return extensionv1.Result{}, errCodexRoutingUnavailable + } + rows, err := h.state.DueExtensionStates(ctx, h.key, extensionv1.DueStateRequest{Namespace: codexRoutingPrivateNamespace, Limit: 100}) + if err != nil { + return extensionv1.Result{}, err + } + now := time.Now().UTC() + redacted := 0 + for _, row := range rows { + var raw json.RawMessage + var next *time.Time + switch { + case strings.HasPrefix(row.Key, "bundle."): + var bundle codexRoutingPrivateBundle + if json.Unmarshal(row.Value, &bundle) != nil { + continue + } + if now.Before(bundle.ExpiresAt) { + next = &bundle.ExpiresAt + raw = row.Value + } else { + for index := range bundle.Cookies { + bundle.Cookies[index].Value = "" + } + bundle.Status = "expired" + raw, _ = json.Marshal(bundle) + } + case strings.HasPrefix(row.Key, "clock."): + var clock codexRoutingCookieClock + if json.Unmarshal(row.Value, &clock) != nil { + continue + } + for name, cookie := range clock.Cookies { + if !now.Before(cookie.ExpiresAt) { + delete(clock.Cookies, name) + } + } + next = codexCookieClockDeadline(clock) + raw, _ = json.Marshal(clock) + default: + continue + } + result, saveErr := h.state.CompareSwapExtensionState(ctx, h.key, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: row.Key, ExpectedRevision: row.Revision, Value: raw, NextAt: next}) + if saveErr == nil && result.Applied { + redacted++ + } + } + raw, _ := json.Marshal(map[string]int{"redacted": redacted}) + return extensionv1.Result{Payload: raw}, nil +} diff --git a/backend/internal/service/codex_routing_reference.json b/backend/internal/service/codex_routing_reference.json new file mode 100644 index 000000000000..05801ee2d313 --- /dev/null +++ b/backend/internal/service/codex_routing_reference.json @@ -0,0 +1,223 @@ +{ + "source_kind": "official_binary_capture", + "capture_method": "local_loopback_synthetic_auth", + "captured_at": "2026-09-23T03:07:57.7987060Z", + "binary_sha256": "eabc698ea3b1c430623af0cae510c3459165ed453d2a5d2dac14513cf1b25269", + "client_version": "0.156.0", + "user_agent": "codex_exec/0.156.0 (Windows 10.0.26220; x86_64) dumb (codex_exec; 0.156.0)", + "originator": "codex_exec", + "http_accept_encoding_present": false, + "transport_scope": "responses_https_and_wss_loopback", + "tls_alignment": "captured_reference_only", + "actual_model_requests": 0, + "responses": [ + { + "method": "GET", + "path": "/backend-api/codex/responses", + "transport": { + "scheme": "https", + "tls_version": "TLSv1.3", + "cipher": "TLS_AES_256_GCM_SHA384", + "negotiated_alpn": null, + "client_hello": { + "legacy_version": 771, + "cipher_suites": [ + 4866, + 4865, + 4867, + 49196, + 49195, + 52393, + 49200, + 49199, + 52392, + 255 + ], + "extensions": [ + 23, + 11, + 5, + 45, + 10, + 51, + 35, + 43, + 0, + 13 + ], + "groups": [ + 4588, + 29, + 23, + 24 + ], + "point_formats": [ + 0 + ], + "signature_algorithms": [ + 1283, + 1027, + 1539, + 2055, + 2054, + 2053, + 2052, + 1537, + 1281, + 1025, + 2308, + 2309, + 2310 + ], + "supported_versions": [ + 772, + 771 + ], + "key_share_groups": [ + 4588, + 29 + ], + "alpn": [], + "ja3": "771,4866-4865-4867-49196-49195-52393-49200-49199-52392-255,23-11-5-45-10-51-35-43-0-13,4588-29-23-24,0", + "ja3_md5": "d6a68deca88b2e61c3d20a52c2aaf629" + } + }, + "headers": { + "upgrade": "websocket", + "sec-websocket-version": "13", + "user-agent": "codex_exec/0.156.0 (Windows 10.0.26220; x86_64) dumb (codex_exec; 0.156.0)", + "originator": "codex_exec", + "openai-beta": "responses_websockets=2026-02-06", + "sec-websocket-extensions": "permessage-deflate; client_max_window_bits" + } + }, + { + "method": "POST", + "path": "/backend-api/codex/responses", + "http_version": "HTTP/1.1", + "transport": { + "scheme": "https", + "tls_version": "TLSv1.3", + "cipher": "TLS_AES_256_GCM_SHA384", + "negotiated_alpn": "http/1.1", + "client_hello": { + "legacy_version": 771, + "cipher_suites": [ + 4866, + 4865, + 4867, + 49196, + 49195, + 52393, + 49200, + 49199, + 52392, + 255 + ], + "extensions": [ + 5, + 16, + 45, + 13, + 43, + 23, + 11, + 0, + 51, + 10, + 35 + ], + "groups": [ + 4588, + 29, + 23, + 24 + ], + "point_formats": [ + 0 + ], + "signature_algorithms": [ + 1283, + 1027, + 1539, + 2055, + 2054, + 2053, + 2052, + 1537, + 1281, + 1025, + 2308, + 2309, + 2310 + ], + "supported_versions": [ + 772, + 771 + ], + "key_share_groups": [ + 4588, + 29 + ], + "alpn": [ + "h2", + "http/1.1" + ], + "ja3": "771,4866-4865-4867-49196-49195-52393-49200-49199-52392-255,5-16-45-13-43-23-11-0-51-10-35,4588-29-23-24,0", + "ja3_md5": "3baae1d525347c65689cb2ed01b519e3" + } + }, + "header_names": [ + "x-codex-beta-features", + "x-codex-window-id", + "x-codex-turn-metadata", + "x-openai-internal-codex-responses-lite", + "x-client-request-id", + "session-id", + "thread-id", + "accept", + "content-type", + "authorization", + "chatgpt-account-id", + "originator", + "user-agent", + "host", + "content-length" + ], + "headers": { + "accept": "text/event-stream", + "content-type": "application/json", + "originator": "codex_exec", + "user-agent": "codex_exec/0.156.0 (Windows 10.0.26220; x86_64) dumb (codex_exec; 0.156.0)" + }, + "body_bytes": 77573, + "body_keys": [ + "client_metadata", + "include", + "input", + "model", + "parallel_tool_calls", + "prompt_cache_key", + "reasoning", + "store", + "stream", + "text", + "tool_choice" + ], + "client_metadata_keys": [ + "root_turn_id", + "session_id", + "thread_id", + "turn_id", + "x-codex-installation-id", + "x-codex-turn-metadata", + "x-codex-window-id" + ] + } + ], + "limitations": [ + "Captured reference is one Windows codex exec build.", + "Production Go TLS is a different implementation; no production JA3 or strict match is asserted.", + "The captured extension ordering may vary; preserve its actual sample order." + ] +} diff --git a/backend/internal/service/codex_routing_test.go b/backend/internal/service/codex_routing_test.go new file mode 100644 index 000000000000..c19e1930f34b --- /dev/null +++ b/backend/internal/service/codex_routing_test.go @@ -0,0 +1,481 @@ +package service + +import ( + "context" + "encoding/json" + "github.com/Wei-Shaw/sub2api/internal/config" + "github.com/coder/websocket" + "io" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "sync" + "testing" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/require" +) + +type routingMemoryStore struct { + PluginRepository + mu sync.Mutex + values map[string]extensionv1.StateResult + next map[string]time.Time +} + +func (store *routingMemoryStore) ReadExtensionState(_ context.Context, _ string, req extensionv1.StateRequest) (extensionv1.StateResult, error) { + store.mu.Lock() + defer store.mu.Unlock() + return store.values[req.Namespace+":"+req.Key], nil +} +func (store *routingMemoryStore) CompareSwapExtensionState(_ context.Context, _ string, req extensionv1.StateRequest) (extensionv1.StateResult, error) { + store.mu.Lock() + defer store.mu.Unlock() + if store.values == nil { + store.values = map[string]extensionv1.StateResult{} + } + key := req.Namespace + ":" + req.Key + old := store.values[key] + old.Applied = false + if old.Revision == req.ExpectedRevision { + old = extensionv1.StateResult{Found: true, Applied: true, Revision: old.Revision + 1, Value: append(json.RawMessage(nil), req.Value...)} + store.values[key] = old + if store.next == nil { + store.next = map[string]time.Time{} + } + if req.NextAt != nil { + store.next[key] = *req.NextAt + } else { + delete(store.next, key) + } + } + return old, nil +} +func (store *routingMemoryStore) DueExtensionStates(_ context.Context, _ string, request extensionv1.DueStateRequest) ([]extensionv1.DueState, error) { + store.mu.Lock() + defer store.mu.Unlock() + var out []extensionv1.DueState + for key, at := range store.next { + if strings.HasPrefix(key, request.Namespace+":") && !time.Now().Before(at) { + record := store.values[key] + out = append(out, extensionv1.DueState{Key: strings.TrimPrefix(key, request.Namespace+":"), Revision: record.Revision, Value: record.Value}) + if len(out) >= request.Limit { + break + } + } + } + return out, nil +} +func (*routingMemoryStore) AcquireExtensionLease(context.Context, string, extensionv1.LeaseRequest) (extensionv1.LeaseResult, error) { + return extensionv1.LeaseResult{Acquired: true, Generation: 1}, nil +} +func (*routingMemoryStore) ReleaseExtensionLease(context.Context, string, extensionv1.LeaseRequest) (extensionv1.LeaseResult, error) { + return extensionv1.LeaseResult{}, nil +} + +type routingHostDirectoryFixture struct { + PluginAccountDirectory + account extensionv1.Account + scope extensionv1.CodexRoutingScope + response string + requests int + onSend func() +} + +type routingAccountRepositoryFixture struct { + AccountRepository + account *Account +} + +func (r *routingAccountRepositoryFixture) GetByID(context.Context, int64) (*Account, error) { + return r.account, nil +} + +func TestCodexRoutingValidationDoesNotEnrollOrChangeStoppedState(t *testing.T) { + host, directory, store := routingHostFixture() + installation := host.installation + installation.ID, installation.State, installation.Version = 1, PluginStateEnabled, "0.2.7" + installation.Manifest.Requires.ExtensionAPI = 1 + installation.Bindings = []PluginBinding{{Capability: extensionv1.CapabilityCredentials, Platform: PlatformOpenAI, AccountType: AccountTypeOAuth, Enabled: true, RolloutPercent: 100}} + store.PluginRepository = &pluginTokenRepository{installation: installation} + manager := NewPluginManager(store, nil, nil, PluginHostInfo{}, newFakePluginKVStore()) + manager.accountDirectory = directory + manager.extensions.Store(&pluginExtensionRegistry{installations: map[int64]*PluginInstallation{1: installation}, runtimes: map[int64]*pluginRuntime{}}) + account := &Account{ID: 7, Platform: PlatformOpenAI, Type: AccountTypeOAuth} + service := &OpenAIGatewayService{pluginManager: manager, accountRepo: &routingAccountRepositoryFixture{account: account}} + legacyKey := "tickets:7." + codexRoutingDigest("gpt-6-astra") + stopped := json.RawMessage(`{"schema":2,"phase":"stopped","enrolled":true,"failures":2}`) + store.values[legacyKey] = extensionv1.StateResult{Found: true, Revision: 8, Value: stopped} + request := CodexRoutingValidationRequest{ValidationID: "e753ac46-3a37-4b7b-ab74-c6fdb987ccec", Model: "gpt-6-astra", Transport: "http"} + result, err := service.ValidateCodexRouting(context.Background(), 7, request) + require.NoError(t, err) + require.True(t, result.Success) + require.False(t, result.Enrolled) + require.Equal(t, 2, result.BudgetUsed) + require.Equal(t, 2, directory.requests) + require.Equal(t, stopped, store.values[legacyKey].Value) + require.EqualValues(t, 8, store.values[legacyKey].Revision) + result, err = service.ValidateCodexRouting(context.Background(), 7, request) + require.NoError(t, err) + require.False(t, result.Success) + require.Equal(t, 2, directory.requests) + require.Equal(t, 2, result.BudgetUsed) +} + +func (d *routingHostDirectoryFixture) ReadExtensionAccount(context.Context, int64) (*extensionv1.Account, error) { + copy := d.account + return ©, nil +} +func (d *routingHostDirectoryFixture) ListExtensionAccounts(context.Context, extensionv1.AccountQuery) ([]extensionv1.Account, error) { + return []extensionv1.Account{d.account}, nil +} +func (d *routingHostDirectoryFixture) ResolveExtensionIdentity(context.Context, extensionv1.AccountQuery) (*extensionv1.OutboundIdentity, error) { + panic("routing probes must not expose credentials") +} +func (d *routingHostDirectoryFixture) PrepareCodexRoutingScope(context.Context, int64, string) (extensionv1.CodexRoutingScope, error) { + return d.scope, nil +} +func (d *routingHostDirectoryFixture) ExecuteCodexRoutingProbe(_ context.Context, q extensionv1.CodexRoutingQuery, cookies string, _ time.Time) (*http.Response, extensionv1.CodexRoutingScope, error) { + d.requests++ + if d.onSend != nil { + d.onSend() + } + headers := http.Header{"Content-Type": []string{"text/event-stream"}, "Set-Cookie": []string{"__cflb=synthetic-route; Path=/; Secure; Max-Age=100", "__oailb=synthetic-lb; Path=/; Secure; Max-Age=100"}} + scope := d.scope + if q.Stage == "verify" { + if cookies == "" { + return nil, scope, errCodexRoutingUnavailable + } + scope.ConnectionLeaseID = "actual-connection" + scope.RouteEvidence = "connection" + } + return &http.Response{StatusCode: 200, Header: headers, Body: io.NopCloser(strings.NewReader(d.response))}, scope, nil +} + +func routingHostFixture() (*pluginExtensionHost, *routingHostDirectoryFixture, *routingMemoryStore) { + directory := &routingHostDirectoryFixture{account: extensionv1.Account{ID: 7, Identity: "owner", Platform: PlatformOpenAI, Type: AccountTypeOAuth}, scope: extensionv1.CodexRoutingScope{AccountID: 7, Identity: "owner", RouteHash: "route", ProfileHash: "profile", Transport: "http"}, response: "data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"model\":\"gpt-6-astra\"}}\n\n"} + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + installation := &PluginInstallation{PluginKey: codexRuntimePluginKey, Manifest: PluginManifest{Capabilities: []PluginCapability{{ID: extensionv1.CapabilityCredentials, Platform: PlatformOpenAI, AccountType: AccountTypeOAuth}}}} + return &pluginExtensionHost{key: codexRuntimePluginKey, state: store, directory: directory, installation: installation}, directory, store +} + +func TestCodexRoutingCookieScopeAgeDeletionAndColdCandidate(t *testing.T) { + now := time.Now().UTC() + target, _ := url.Parse("https://chatgpt.com/backend-api/codex/responses") + headers := http.Header{"Set-Cookie": []string{"__cflb=a; Path=/; Secure; Max-Age=60", "__oailb=b; Domain=attacker.test; Path=/", "auth_token=secret; Path=/", "__oailb=c; Path=/elsewhere"}} + changes := parseCodexRoutingCookies(headers, target, now) + require.Len(t, changes, 1) + for _, malformed := range []string{"__cflb=x; Domain=bad domain; Path=/", "__cflb=x; Path=\"/broken; Secure"} { + require.Empty(t, parseCodexRoutingCookies(http.Header{"Set-Cookie": []string{malformed}}, target, now), "malformed scope cannot become a host-only cookie") + } + clock := codexRoutingCookieClock{} + clock.apply(changes, now) + clock.apply(parseCodexRoutingCookies(headers, target, now.Add(20*time.Second)), now.Add(20*time.Second)) + require.Equal(t, now, clock.Cookies["__cflb"].FirstSeen) + require.Empty(t, clock.selected(nil, nil, now), "cold candidate must not inherit another response") + clock.apply(parseCodexRoutingCookies(http.Header{"Set-Cookie": []string{"__cflb=; Max-Age=0; Path=/"}}, target, now.Add(30*time.Second)), now.Add(30*time.Second)) + clock.apply(changes, now.Add(40*time.Second)) + require.Empty(t, clock.live(now.Add(40*time.Second)), "old response resurrected a tombstone") + clock.apply(parseCodexRoutingCookies(headers, target, now.Add(5*time.Minute)), now.Add(5*time.Minute)) + require.Empty(t, clock.live(now.Add(5*time.Minute)), "same value renewed after TTL") +} + +func TestCodexRoutingCompletionRequiresOriginalModelAndDelimitedTerminal(t *testing.T) { + for _, test := range []struct { + name, body string + ok bool + }{ + {"complete", "data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"model\":\"gpt-6-astra\"}}\n\n", true}, + {"model_mismatch", "data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"model\":\"gpt-6-luna\"}}\n\n", false}, + {"missing_model", "data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\"}}\n\n", false}, + {"truncated", "data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"model\":\"gpt-6-astra\"}}", false}, + {"done_only", "data: [DONE]\n\n", false}, + {"error", "data: {\"type\":\"error\",\"error\":{\"code\":\"server_is_overloaded\"}}\n\n", false}, + } { + t.Run(test.name, func(t *testing.T) { + var o extensionv1.CodexRoutingObservation + err := readCodexRoutingCompletion(strings.NewReader(test.body), "text/event-stream", "gpt-6-astra", &o) + require.Equal(t, test.ok, err == nil) + require.Equal(t, test.ok, o.ModelMatched) + }) + } +} + +func TestCodexRoutingHostSeparatesCandidateQualifiedAndPrivateMaterial(t *testing.T) { + host, directory, _ := routingHostFixture() + call := func(query extensionv1.CodexRoutingQuery) extensionv1.CodexRoutingProbeResult { + raw, _ := json.Marshal(query) + result, err := host.Call(context.Background(), extensionv1.HostInvocation{Operation: extensionv1.HostCodexRoutingProbe, Payload: raw}) + require.NoError(t, err) + require.NotContains(t, string(result.Payload), "synthetic-route") + require.NotContains(t, string(result.Payload), "synthetic-lb") + var value extensionv1.CodexRoutingProbeResult + require.NoError(t, json.Unmarshal(result.Payload, &value)) + return value + } + query := extensionv1.CodexRoutingQuery{AccountID: 7, Model: "gpt-6-astra", Transport: "http", OperationID: "one", Stage: "acquire"} + candidate := call(query) + require.True(t, candidate.Valid) + require.Empty(t, candidate.Scope.ConnectionLeaseID) + query.Stage, query.Bundle = "verify", candidate.Bundle + verified := call(query) + require.True(t, verified.Valid) + require.NotEmpty(t, verified.Scope.ConnectionLeaseID) + require.Equal(t, 2, directory.requests) + duplicate := call(query) + require.False(t, duplicate.Valid) + require.Equal(t, 2, directory.requests) + raw, _ := json.Marshal(extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: candidate.Bundle.Key}) + _, err := host.Call(context.Background(), extensionv1.HostInvocation{Operation: extensionv1.HostStateRead, Payload: raw}) + require.Error(t, err) +} + +func TestCodexRoutingHostRejectsMismatchedModelAndChangedOwner(t *testing.T) { + for _, changeOwner := range []bool{false, true} { + host, directory, _ := routingHostFixture() + if changeOwner { + directory.onSend = func() { directory.scope.Identity = "new-owner" } + } else { + directory.response = strings.ReplaceAll(directory.response, "gpt-6-astra", "gpt-6-luna") + } + raw, _ := json.Marshal(extensionv1.CodexRoutingQuery{AccountID: 7, Model: "gpt-6-astra", Transport: "http", OperationID: "one", Stage: "acquire"}) + result, err := host.Call(context.Background(), extensionv1.HostInvocation{Operation: extensionv1.HostCodexRoutingProbe, Payload: raw}) + require.NoError(t, err) + var value extensionv1.CodexRoutingProbeResult + require.NoError(t, json.Unmarshal(result.Payload, &value)) + if changeOwner { + require.False(t, value.Valid) + require.Nil(t, value.Bundle) + } else { + require.True(t, value.Valid) + require.NotNil(t, value.Bundle) + require.False(t, value.Observation.ModelMatched) + require.Empty(t, value.Scope.ConnectionLeaseID) + query := extensionv1.CodexRoutingQuery{AccountID: 7, Model: "gpt-6-astra", Transport: "http", OperationID: "one", Stage: "verify", Bundle: value.Bundle} + raw, _ = json.Marshal(query) + result, err = host.Call(context.Background(), extensionv1.HostInvocation{Operation: extensionv1.HostCodexRoutingProbe, Payload: raw}) + require.NoError(t, err) + var verified extensionv1.CodexRoutingProbeResult + require.NoError(t, json.Unmarshal(result.Payload, &verified)) + require.False(t, verified.Valid) + require.Nil(t, verified.Bundle) + } + } +} + +func TestCodexRoutingValidationBudgetSevenStagesAndOneOwner(t *testing.T) { + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + ctx := context.Background() + run := "22b6424b-eeb4-4a34-80f4-5f014e04e804" + for _, model := range codexValidationModels { + for _, stage := range []string{"acquire", "verify"} { + bound := context.WithValue(ctx, codexValidationContextKey{}, codexValidationContext{ID: run, AccountID: 7, Model: model, Transport: "http"}) + query := extensionv1.CodexRoutingQuery{AccountID: 7, Model: model, Transport: "http", Stage: stage} + require.NoError(t, consumeCodexValidationBudget(bound, store, codexRuntimePluginKey, query)) + require.Error(t, consumeCodexValidationBudget(bound, store, codexRuntimePluginKey, query)) + } + } + bound := context.WithValue(ctx, codexValidationContextKey{}, codexValidationContext{ID: run, AccountID: 7, Model: "gpt-6-astra", Transport: "ws"}) + query := extensionv1.CodexRoutingQuery{AccountID: 7, Model: "gpt-6-astra", Transport: "ws", Stage: "verify"} + require.NoError(t, consumeCodexValidationBudget(bound, store, codexRuntimePluginKey, query)) + require.Error(t, consumeCodexValidationBudget(bound, store, codexRuntimePluginKey, query)) + bound = context.WithValue(ctx, codexValidationContextKey{}, codexValidationContext{ID: run, AccountID: 8, Model: "gpt-6-astra", Transport: "http"}) + query.AccountID, query.Transport = 8, "http" + require.Error(t, consumeCodexValidationBudget(bound, store, codexRuntimePluginKey, query)) + record, _ := store.ReadExtensionState(ctx, codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "validation." + run}) + var budget codexValidationBudget + require.NoError(t, json.Unmarshal(record.Value, &budget)) + require.Equal(t, 7, budget.Used) +} + +func TestCodexRoutingTurnStateCannotCrossLogicalTurn(t *testing.T) { + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Request = httptest.NewRequest("POST", "/v1/responses", nil) + c.Request.Header.Set("session-id", "session") + s := &OpenAIGatewayService{} + account := &Account{ID: 7} + stageCodexRoutingTurn(c, []byte(`{"client_metadata":{"turn_id":"turn-one"}}`)) + s.noteOpenAICodexTurnStateProvenance(c, account) + headers := http.Header{} + headers.Set(openAICodexTurnStateHeader, "opaque") + s.guardOpenAICodexTurnStateEcho(c, account, headers) + require.Equal(t, "opaque", headers.Get(openAICodexTurnStateHeader)) + stageCodexRoutingTurn(c, []byte(`{"client_metadata":{"turn_id":"turn-two"}}`)) + s.guardOpenAICodexTurnStateEcho(c, account, headers) + require.Empty(t, headers.Get(openAICodexTurnStateHeader)) +} + +func TestCodexRoutingGenericCookieHeadersStayProtected(t *testing.T) { + for _, name := range []string{"Cookie", "Set-Cookie"} { + manager := ticketTestManager(t, config.OpenAICodexTicketConfig{Enabled: true, FailClosed: true}, func(extensionv1.Invocation) (extensionv1.Result, error) { + raw, _ := json.Marshal(extensionv1.CodexRoutingInjection{Headers: map[string]string{name: "__cflb=not-host-owned"}}) + return extensionv1.Result{Payload: raw}, nil + }) + headers := http.Header{"X-Original": []string{"preserve"}} + err := manager.ApplyRequestHeaders(context.Background(), ticketTestAccount(7), "gpt-6-astra", headers) + require.Error(t, err) + require.Equal(t, http.Header{"X-Original": []string{"preserve"}}, headers) + } +} + +func TestCodexRoutingInfrastructureCookieLayerIsConnectionScoped(t *testing.T) { + scope := extensionv1.CodexRoutingScope{AccountID: 7, Identity: "owner", ProfileHash: "profile", RouteHash: "route", ConnectionLeaseID: "infra-test-connection"} + expires := time.Now().Add(time.Minute) + observeCodexInfrastructureCookies(scope, http.Header{"Set-Cookie": []string{"__cf_bm=infra; Path=/; Secure", "__oailb=recovery; Path=/; Secure", "session_token=secret; Path=/; Secure"}}, expires) + request, _ := http.NewRequest("POST", "https://chatgpt.com/backend-api/codex/responses", nil) + request.Header.Set("Cookie", "__oailb=host-owned") + applyCodexInfrastructureCookies(request, scope, expires) + require.Contains(t, request.Header.Get("Cookie"), "__cf_bm=infra") + require.Contains(t, request.Header.Get("Cookie"), "__oailb=host-owned") + require.NotContains(t, request.Header.Get("Cookie"), "session_token") + scope.ConnectionLeaseID = "other-connection" + next, _ := http.NewRequest("POST", "https://chatgpt.com/backend-api/codex/responses", nil) + applyCodexInfrastructureCookies(next, scope, expires) + require.Empty(t, next.Header.Get("Cookie")) +} + +func TestCodexRoutingDeviceChangeInvalidatesQualifiedScopeBeforeSend(t *testing.T) { + account := &Account{ID: 7, Platform: PlatformOpenAI, Type: AccountTypeOAuth, Credentials: map[string]any{"chatgpt_account_id": "owner"}, Extra: map[string]any{"openai_device_id": "device-before", codexFingerprintSeedExtraKey: testCodexFingerprintSeed}} + service := &OpenAIGatewayService{accountRepo: &routingAccountRepositoryFixture{account: account}} + before, err := service.PrepareCodexRoutingScope(context.Background(), 7, "http") + require.NoError(t, err) + account.Extra["openai_device_id"] = "device-after" + after, err := service.PrepareCodexRoutingScope(context.Background(), 7, "http") + require.NoError(t, err) + require.Equal(t, before.Identity, after.Identity) + require.NotEqual(t, before.ProfileHash, after.ProfileHash) + require.False(t, before.SameOwner(after)) + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + expiry := time.Now().Add(time.Minute) + raw, _ := json.Marshal(codexRoutingPrivateBundle{Schema: 2, Scope: before, Status: "qualified", Model: "gpt-6-astra", ExpiresAt: expiry}) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "bundle.device-test", Value: raw}) + require.NoError(t, err) + _, err = readCodexRoutingBundle(context.Background(), store, codexRuntimePluginKey, extensionv1.CodexRoutingBundleRef{Key: "bundle.device-test", Revision: 1, ExpiresAt: expiry}, after, true) + require.Error(t, err) +} + +func TestCodexRoutingAnotherModelClockDoesNotBlockOwnCookieRefresh(t *testing.T) { + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + installation := &PluginInstallation{PluginKey: codexRuntimePluginKey} + service := &OpenAIGatewayService{pluginManager: &PluginManager{repo: store}} + scope := extensionv1.CodexRoutingScope{AccountID: 7, Identity: "owner", ProfileHash: "profile", RouteHash: "route", ConnectionLeaseID: "connection-astra", Transport: "http"} + now := time.Now().Add(-time.Second).UTC() + expiry := now.Add(time.Minute) + first := []codexRoutingCookie{{Name: "__cflb", Value: "astra-route", Domain: "chatgpt.com", Path: "/", FirstSeen: now, ExpiresAt: expiry}, {Name: "__oailb", Value: "astra-lb", Domain: "chatgpt.com", Path: "/", FirstSeen: now, ExpiresAt: expiry}} + clock := codexRoutingCookieClock{Scope: scope} + for _, cookie := range first { + clock.apply([]codexRoutingCookieChange{{Cookie: cookie}}, now) + } + clockKey := "clock." + codexRoutingScopeKey(scope) + raw, _ := json.Marshal(clock) + _, err := store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: clockKey, Value: raw}) + require.NoError(t, err) + bundle := codexRoutingPrivateBundle{Schema: 2, Scope: scope, Cookies: first, ClockKey: clockKey, ClockRevision: 1, Status: "qualified", Model: "gpt-6-astra", ExpiresAt: expiry} + raw, _ = json.Marshal(bundle) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "bundle.astra", Value: raw}) + require.NoError(t, err) + // Sol changes the shared clock without revoking Astra's immutable pair. + second := first[0] + second.Value = "sol-route" + clock.apply([]codexRoutingCookieChange{{Cookie: second}}, now) + raw, _ = json.Marshal(clock) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: clockKey, ExpectedRevision: 1, Value: raw}) + require.NoError(t, err) + q := &extensionv1.CodexRoutingQualification{Scope: scope, Model: "gpt-6-astra", VerifiedAt: now, ExpiresAt: expiry, Bundle: extensionv1.CodexRoutingBundleRef{Key: "bundle.astra", Revision: 1, ExpiresAt: expiry}} + next := service.refreshObservedCodexCookies(context.Background(), installation, q, http.Header{"Set-Cookie": []string{"__oailb=astra-refreshed; Path=/; Secure; Max-Age=100"}}, extensionv1.CodexRoutingObservation{ObservedAt: time.Now().UTC(), Completed: true, ModelMatched: true, ResponseModel: "gpt-6-astra"}) + require.NotNil(t, next) + require.Equal(t, q.ExpiresAt, next.ExpiresAt) + updated, err := readCodexRoutingBundle(context.Background(), store, codexRuntimePluginKey, next.Bundle, scope, true) + require.NoError(t, err) + header, _ := codexRoutingCookieHeader(updated.Cookies, time.Now()) + require.Contains(t, header, "__cflb=astra-route") + require.Contains(t, header, "__oailb=astra-refreshed") + require.NotContains(t, header, "sol-route") +} + +func TestCodexRoutingObservesOrdinaryHTTPAndNativeFramesWithoutCookies(t *testing.T) { + account := ticketTestAccount(7) + manager := ticketTestManager(t, config.OpenAICodexTicketConfig{Enabled: false}, nil) + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + manager.repo = store + upstream := &httpUpstreamRecorder{resp: &http.Response{StatusCode: 200, Proto: "HTTP/2.0", Header: make(http.Header), Body: io.NopCloser(strings.NewReader(`{}`))}} + service := &OpenAIGatewayService{httpUpstream: upstream, pluginManager: manager} + request, _ := http.NewRequest("POST", "https://chatgpt.com/backend-api/codex/responses", strings.NewReader(`{"model":"gpt-5.5","input":"private-prompt","client_metadata":{"session_id":"session"}}`)) + request.Header.Set("Authorization", "Bearer private-token") + request.Header.Set("User-Agent", "actual-wire-agent") + request.Header.Set("session-id", "session") + response, err := service.doOpenAICodexUpstream(request, account, "") + require.NoError(t, err) + _ = response.Body.Close() + record, err := store.ReadExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "wire.7"}) + require.NoError(t, err) + var observation CodexWireFingerprint + require.NoError(t, json.Unmarshal(record.Value, &observation)) + require.Equal(t, "http", observation.Transport) + require.Equal(t, "actual-wire-agent", observation.UserAgent) + require.Equal(t, "match", observation.IdentityFields["session"].Consistency) + require.NotContains(t, string(record.Value), "private-token") + require.NotContains(t, string(record.Value), "private-prompt") + frames := newStagedPassthroughConn() + observed := &codexObservedNativeFrameConn{FrameConn: frames, observe: func(ctx context.Context, body []byte) { + service.observeNativeCodexWS(ctx, account, request.Header, http.Header{"Sec-Websocket-Extensions": []string{"permessage-deflate"}}, body, "native-socket") + }} + require.NoError(t, observed.WriteFrame(context.Background(), websocket.MessageText, []byte(`{"type":"response.create","model":"gpt-5.5","client_metadata":{"session_id":"session"}}`))) + record, err = store.ReadExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "wire.7"}) + require.NoError(t, err) + require.NoError(t, json.Unmarshal(record.Value, &observation)) + require.Equal(t, "ws", observation.Transport) + require.Equal(t, "ws", observation.Ingress) + require.Equal(t, "unknown", observation.JA3) + require.Empty(t, observation.TLSVersion) + require.Equal(t, "match", observation.IdentityFields["session"].Consistency) +} + +func TestCodexRoutingUnchangedCookiesDoNotGrowAndExpiryRedactsValues(t *testing.T) { + store := &routingMemoryStore{values: map[string]extensionv1.StateResult{}} + scope := extensionv1.CodexRoutingScope{AccountID: 7, Identity: "owner", ProfileHash: "profile", RouteHash: "route", ConnectionLeaseID: "connection", Transport: "http"} + now := time.Now().UTC() + expires := now.Add(time.Minute) + cookie := codexRoutingCookie{Name: "__cflb", Value: "temporary-private-value", Domain: "chatgpt.com", Path: "/", FirstSeen: now, ExpiresAt: expires} + clock := codexRoutingCookieClock{Scope: scope, Tombstones: map[string]time.Time{"other-name": now}} + clock.apply([]codexRoutingCookieChange{{Cookie: cookie}}, now) + clockKey := "clock." + codexRoutingScopeKey(scope) + bundleKey := fixedCodexRoutingBundleKey(context.Background(), extensionv1.CodexRoutingQuery{AccountID: 7, Model: "gpt-6-astra"}, "live") + raw, _ := json.Marshal(clock) + _, err := store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: clockKey, Value: raw, NextAt: &expires}) + require.NoError(t, err) + bundle := codexRoutingPrivateBundle{Schema: 2, Scope: scope, Cookies: []codexRoutingCookie{cookie}, ClockKey: clockKey, ClockRevision: 1, Status: "qualified", Model: "gpt-6-astra", ExpiresAt: expires, Observation: extensionv1.CodexRoutingObservation{Code: "routing_verified", HTTPStatus: 200}} + raw, _ = json.Marshal(bundle) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: bundleKey, Value: raw, NextAt: &expires}) + require.NoError(t, err) + q := &extensionv1.CodexRoutingQualification{Scope: scope, Model: "gpt-6-astra", VerifiedAt: now, ExpiresAt: expires, Bundle: extensionv1.CodexRoutingBundleRef{Key: bundleKey, Revision: 1, ExpiresAt: expires}} + service := &OpenAIGatewayService{pluginManager: &PluginManager{repo: store}} + before := len(store.values) + updated := service.refreshObservedCodexCookies(context.Background(), &PluginInstallation{PluginKey: codexRuntimePluginKey}, q, http.Header{"Set-Cookie": []string{"__cflb=temporary-private-value; Path=/; Secure; Max-Age=100"}}, extensionv1.CodexRoutingObservation{ObservedAt: now}) + require.Nil(t, updated) + require.Len(t, store.values, before) + require.EqualValues(t, 1, store.values[codexRoutingPrivateNamespace+":"+clockKey].Revision) + past := now.Add(-time.Second) + bundle.ExpiresAt = past + bundle.Cookies[0].ExpiresAt = past + raw, _ = json.Marshal(bundle) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: bundleKey, ExpectedRevision: 1, Value: raw, NextAt: &past}) + require.NoError(t, err) + clock.Cookies["__cflb"] = bundle.Cookies[0] + raw, _ = json.Marshal(clock) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: clockKey, ExpectedRevision: 1, Value: raw, NextAt: &past}) + require.NoError(t, err) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "spent.keep", Value: json.RawMessage(`{"spent":true}`)}) + require.NoError(t, err) + host := &pluginExtensionHost{key: codexRuntimePluginKey, state: store} + _, err = host.redactExpiredCodexRoutingMaterial(context.Background()) + require.NoError(t, err) + require.Len(t, store.values, before+1) + require.NotContains(t, string(store.values[codexRoutingPrivateNamespace+":"+bundleKey].Value), "temporary-private-value") + require.Contains(t, string(store.values[codexRoutingPrivateNamespace+":"+bundleKey].Value), "routing_verified") + require.Contains(t, string(store.values[codexRoutingPrivateNamespace+":"+clockKey].Value), "other-name") + require.Equal(t, json.RawMessage(`{"spent":true}`), store.values[codexRoutingPrivateNamespace+":spent.keep"].Value) +} diff --git a/backend/internal/service/codex_routing_transport.go b/backend/internal/service/codex_routing_transport.go new file mode 100644 index 000000000000..488df1dd32af --- /dev/null +++ b/backend/internal/service/codex_routing_transport.go @@ -0,0 +1,275 @@ +package service + +import ( + "context" + "encoding/json" + "io" + "net/http" + "slices" + "strings" + "sync" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +type codexRoutingModelKey struct{} + +func withCodexRoutingModel(request *http.Request, model string) *http.Request { + if request == nil { + return nil + } + return request.WithContext(context.WithValue(request.Context(), codexRoutingModelKey{}, strings.TrimSpace(model))) +} + +func (s *OpenAIGatewayService) codexRoutingApplies(account *Account, model string) bool { + cfg := s.openAICodexTicketConfig() + return cfg.Enabled && isOpenAICodexTicketAccount(account) && slices.Contains(cfg.Models, model) +} + +func (m *PluginManager) codexRoutingQualification(ctx context.Context, account *Account, model string) (*extensionv1.CodexRoutingQualification, *PluginInstallation, error) { + installation, _ := m.installedByKey(codexRuntimePluginKey) + if installation == nil { + return nil, nil, errCodexRoutingUnavailable + } + raw, _ := json.Marshal(extensionv1.SchedulingRequest{Account: *extensionAccount(account), Model: model, Now: time.Now().UTC()}) + result, err := m.InvokeExtension(ctx, installation.ID, account.Platform, account.Type, extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "inject", AccountID: account.ID, Payload: raw}) + var injection extensionv1.CodexRoutingInjection + if err != nil || result.Code != "" || json.Unmarshal(result.Payload, &injection) != nil || !injection.Qualification.Valid(time.Now(), account.ID, CodexTicketAccountIdentity(account), model) { + return nil, installation, errCodexRoutingUnavailable + } + return injection.Qualification, installation, nil +} + +func (s *OpenAIGatewayService) prepareQualifiedCodexRequest(request *http.Request, account *Account, model string) (*http.Request, *extensionv1.CodexRoutingQualification, *PluginInstallation, error) { + if request.URL == nil || request.URL.Scheme != "https" || request.URL.Hostname() != "chatgpt.com" || (request.URL.Path != "/backend-api/codex/responses" && request.URL.Path != "/backend-api/codex/responses/compact") { + return request, nil, nil, errCodexRoutingUnavailable + } + q, installation, err := s.pluginManager.codexRoutingQualification(request.Context(), account, model) + if err != nil { + return request, nil, installation, err + } + scope, err := s.PrepareCodexRoutingScope(request.Context(), account.ID, "http") + if err != nil || !q.Scope.SameOwner(scope) || q.Scope.Transport != "http" || q.Scope.ConnectionLeaseID == "" { + return request, q, installation, errCodexRoutingUnavailable + } + store, _ := s.pluginManager.repo.(PluginExtensionStateStore) + bundle, err := readCodexRoutingBundle(request.Context(), store, installation.PluginKey, q.Bundle, scope, true) + if err != nil || bundle.Model != model || bundle.Scope.ConnectionLeaseID != q.Scope.ConnectionLeaseID || bundle.Scope.Transport != q.Scope.Transport || q.ExpiresAt.After(bundle.ExpiresAt) { + return request, q, installation, errCodexRoutingUnavailable + } + cookies, _ := codexRoutingCookieHeader(bundle.Cookies, time.Now()) + if cookies == "" { + return request, q, installation, errCodexRoutingUnavailable + } + wire := request.Clone(request.Context()) + wire.Header.Set("Cookie", cookies) + applyCodexInfrastructureCookies(wire, q.Scope, q.ExpiresAt) + return wire, q, installation, nil +} + +func (s *OpenAIGatewayService) doQualifiedCodexUpstream(request *http.Request, account *Account, proxyURL string) (*http.Response, bool, error) { + model, _ := request.Context().Value(codexRoutingModelKey{}).(string) + if !s.codexRoutingApplies(account, model) { + return nil, false, nil + } + wire, q, installation, err := s.prepareQualifiedCodexRequest(request, account, model) + if err != nil { + if !s.openAICodexTicketConfig().FailClosed { + return nil, false, nil + } + return nil, true, err + } + transport, ok := s.httpUpstream.(CodexConnectionLeaseUpstream) + if !ok { + return nil, true, errCodexRoutingUnavailable + } + start := time.Now() + response, _, err := transport.DoWithCodexConnectionLease(wire, proxyURL, account.ID, codexRoutingScopeKey(q.Scope), q.Scope.ConnectionLeaseID, q.ExpiresAt, nil) + if err != nil { + s.publishCodexRoutingObservation(request.Context(), account, installation, q, extensionv1.CodexRoutingObservation{Code: "routing_connection_expired", Stage: "business", RequestedModel: model, ObservedAt: time.Now().UTC(), Transport: "http", CookieSent: false}, nil) + return nil, true, err + } + if observer := codexWireObserverFromContext(wire.Context()); observer != nil { + observer(wire) + } + observeCodexInfrastructureCookies(q.Scope, response.Header, q.ExpiresAt) + s.observeCodexWire(request.Context(), account, wire, response, q) + observation := extensionv1.CodexRoutingObservation{Stage: "business", Code: "routing_incomplete", HTTPStatus: response.StatusCode, RequestedModel: model, StateLength: len(response.Header.Get(openAICodexTurnStateHeader)), ObservedAt: time.Now().UTC(), Transport: "http", CookieSent: true} + deleted := s.recordCodexRoutingDeletions(request.Context(), installation, q, response.Header, observation.ObservedAt) + if wire.URL.Path == "/backend-api/codex/responses/compact" { + // Compaction is not a model completion and cannot renew qualification. + // Cookie revocation still applies immediately to the existing route. + if deleted { + observation.Code = "routing_cookie_deleted" + s.publishCodexRoutingObservation(request.Context(), account, installation, q, observation, nil) + } + return response, true, nil + } + for _, cookie := range (&http.Request{Header: wire.Header}).Cookies() { + if isCodexRoutingCookie(cookie.Name) { + observation.CookieNames = append(observation.CookieNames, cookie.Name) + } + } + body := &codexRoutingObservedBody{ReadCloser: response.Body, sse: strings.Contains(strings.ToLower(response.Header.Get("Content-Type")), "text/event-stream")} + body.finish = func(completion codexRoutingCompletion) { + observation.Completed = completion.Completed && !completion.Failed && response.StatusCode == http.StatusOK + observation.ResponseModel = completion.Model + observation.ModelMatched = observation.Completed && completion.Model == model + observation.DurationMS = time.Since(start).Milliseconds() + if observation.ModelMatched { + observation.Code = "routing_verified" + } else if observation.Completed { + observation.Code = "routing_model_mismatch" + } + if deleted { + observation.Code = "routing_cookie_deleted" + } + var replacement *extensionv1.CodexRoutingQualification + if observation.ModelMatched && !deleted { + replacement = s.refreshObservedCodexCookies(request.Context(), installation, q, response.Header, observation) + } + s.publishCodexRoutingObservation(request.Context(), account, installation, q, observation, replacement) + } + response.Body = body + return response, true, nil +} + +type codexRoutingObservedBody struct { + io.ReadCloser + sse bool + completion codexRoutingCompletion + json []byte + once sync.Once + finish func(codexRoutingCompletion) +} + +func (body *codexRoutingObservedBody) Read(p []byte) (int, error) { + n, err := body.ReadCloser.Read(p) + if n > 0 { + if body.sse { + body.completion.feed(p[:n]) + } else if len(body.json)+n <= codexRoutingProbeReadLimit { + body.json = append(body.json, p[:n]...) + } else { + body.completion.Failed = true + } + } + if err != nil { + body.complete() + } + return n, err +} + +func (body *codexRoutingObservedBody) complete() { + body.once.Do(func() { + if !body.sse && !body.completion.Failed { + body.completion.json(body.json) + } + body.finish(body.completion) + }) +} + +func (body *codexRoutingObservedBody) Close() error { body.complete(); return body.ReadCloser.Close() } + +func (s *OpenAIGatewayService) publishCodexRoutingObservation(ctx context.Context, account *Account, installation *PluginInstallation, q *extensionv1.CodexRoutingQualification, observation extensionv1.CodexRoutingObservation, replacement *extensionv1.CodexRoutingQualification) { + if s.pluginManager == nil || installation == nil || q == nil { + return + } + call, cancel := context.WithTimeout(context.WithoutCancel(ctx), 2*time.Second) + defer cancel() + raw, _ := json.Marshal(extensionv1.CodexRoutingResponse{AccountID: account.ID, Identity: CodexTicketAccountIdentity(account), Model: q.Model, Qualification: *q, Observation: observation, Replacement: replacement}) + _, _ = s.pluginManager.InvokeExtension(call, installation.ID, account.Platform, account.Type, extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "codex.routing.observe", AccountID: account.ID, Payload: raw}) +} + +func (s *OpenAIGatewayService) refreshObservedCodexCookies(ctx context.Context, installation *PluginInstallation, q *extensionv1.CodexRoutingQualification, headers http.Header, observation extensionv1.CodexRoutingObservation) *extensionv1.CodexRoutingQualification { + store, ok := s.pluginManager.repo.(PluginExtensionStateStore) + if !ok { + return nil + } + ctx = WithPluginExecution(context.WithoutCancel(ctx), installation) + ctx, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + bundle, err := readCodexRoutingBundle(ctx, store, installation.PluginKey, q.Bundle, q.Scope, true) + if err != nil { + return nil + } + target, _ := http.NewRequest(http.MethodGet, "https://chatgpt.com/backend-api/codex/responses", nil) + changes := parseCodexRoutingCookies(headers, target.URL, observation.ObservedAt) + changes = changedCodexRoutingCookies(bundle.Cookies, changes) + if len(changes) == 0 { + return nil + } + record, err := store.ReadExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: bundle.ClockKey}) + var clock codexRoutingCookieClock + if err != nil || !record.Found || json.Unmarshal(record.Value, &clock) != nil || !clock.Scope.SameOwner(q.Scope) { + return nil + } + for _, cookie := range bundle.Cookies { + if deleted, exists := clock.Tombstones[cookie.Name]; exists && !cookie.FirstSeen.After(deleted) { + return nil + } + } + if err := preserveCodexCookieFirstSeen(ctx, store, installation.PluginKey, q.Scope, &clock, changes, observation.ObservedAt); err != nil { + return nil + } + clock.apply(changes, observation.ObservedAt) + raw, _ := json.Marshal(clock) + saved, err := store.CompareSwapExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: bundle.ClockKey, ExpectedRevision: record.Revision, Value: raw, NextAt: codexCookieClockDeadline(clock)}) + if err != nil || !saved.Applied { + return nil + } + // A refreshed Cookie cannot extend a connection lease. A new connection + // always needs a new complete validation even if cookies remain live. + bundle.Cookies, bundle.ClockRevision, bundle.Observation = clock.selected(bundle.Cookies, changes, time.Now()), saved.Revision, observation + _, expiry := codexRoutingCookieHeader(bundle.Cookies, time.Now()) + if expiry.IsZero() { + return nil + } + bundle.ExpiresAt = earlierCodexTime(expiry, q.ExpiresAt) + raw, _ = json.Marshal(bundle) + key := q.Bundle.Key + next, err := store.CompareSwapExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key, ExpectedRevision: q.Bundle.Revision, Value: raw, NextAt: &bundle.ExpiresAt}) + if err != nil || !next.Applied { + return nil + } + replacement := *q + replacement.Bundle = extensionv1.CodexRoutingBundleRef{Key: key, Revision: next.Revision, ExpiresAt: bundle.ExpiresAt, ConnectionLeaseID: q.Scope.ConnectionLeaseID} + replacement.VerifiedAt, replacement.ExpiresAt = observation.ObservedAt, bundle.ExpiresAt + return &replacement +} + +func (s *OpenAIGatewayService) recordCodexRoutingDeletions(ctx context.Context, installation *PluginInstallation, q *extensionv1.CodexRoutingQualification, headers http.Header, now time.Time) bool { + target, _ := http.NewRequest(http.MethodGet, "https://chatgpt.com/backend-api/codex/responses", nil) + var deletions []codexRoutingCookieChange + for _, change := range parseCodexRoutingCookies(headers, target.URL, now) { + if change.Delete { + deletions = append(deletions, change) + } + } + if len(deletions) == 0 { + return false + } + store, ok := s.pluginManager.repo.(PluginExtensionStateStore) + if !ok { + return true + } + ctx = WithPluginExecution(context.WithoutCancel(ctx), installation) + ctx, cancel := context.WithTimeout(ctx, time.Second) + defer cancel() + key := "clock." + codexRoutingScopeKey(q.Scope) + for range 3 { + record, err := store.ReadExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key}) + var clock codexRoutingCookieClock + if err != nil || !record.Found || json.Unmarshal(record.Value, &clock) != nil { + break + } + clock.apply(deletions, now) + raw, _ := json.Marshal(clock) + result, err := store.CompareSwapExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key, ExpectedRevision: record.Revision, Value: raw, NextAt: codexCookieClockDeadline(clock)}) + if err != nil || result.Applied { + break + } + } + return true +} diff --git a/backend/internal/service/codex_routing_validation.go b/backend/internal/service/codex_routing_validation.go new file mode 100644 index 000000000000..46401cfe4b2f --- /dev/null +++ b/backend/internal/service/codex_routing_validation.go @@ -0,0 +1,174 @@ +package service + +import ( + "context" + "encoding/json" + "fmt" + "slices" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/google/uuid" +) + +// This request is intentionally not a reusable arbitrary HTTP/model probe. +// One account, three exact models, six HTTP stages and one WS stage form a +// single durable validation run; no caller can raise or reset its budget. +type CodexRoutingValidationRequest struct { + ValidationID string `json:"validation_id"` + Model string `json:"model"` + Transport string `json:"transport"` +} + +type CodexRoutingValidationResult struct { + ValidationID string `json:"validation_id"` + AccountID int64 `json:"account_id"` + Model string `json:"model"` + Transport string `json:"transport"` + Success bool `json:"success"` + Enrolled bool `json:"enrolled"` + BudgetUsed int `json:"budget_used"` + BudgetLimit int `json:"budget_limit"` + Observations []extensionv1.CodexRoutingObservation `json:"observations"` +} + +type codexValidationContextKey struct{} +type codexValidationContext struct { + ID string + AccountID int64 + Model, Transport string +} +type codexValidationBudget struct { + AccountID int64 `json:"account_id"` + Used int `json:"used"` + Stages map[string]bool `json:"stages"` +} + +var codexValidationModels = []string{"gpt-6-astra", "gpt-6-sol", "gpt-6-luna"} + +func codexValidationFromContext(ctx context.Context) (codexValidationContext, bool) { + value, ok := ctx.Value(codexValidationContextKey{}).(codexValidationContext) + return value, ok +} + +func consumeCodexValidationBudget(ctx context.Context, store PluginExtensionStateStore, plugin string, query extensionv1.CodexRoutingQuery) error { + validation, ok := codexValidationFromContext(ctx) + if !ok { + return nil + } + if validation.AccountID != query.AccountID || validation.Model != query.Model || validation.Transport != query.Transport || !slices.Contains(codexValidationModels, query.Model) { + return errCodexRoutingUnavailable + } + stage := query.Model + ":" + query.Transport + ":" + query.Stage + if query.Transport == "ws" && query.Stage != "verify" { + return errCodexRoutingUnavailable + } + key := "validation." + validation.ID + for range 3 { + previous, err := store.ReadExtensionState(ctx, plugin, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key}) + if err != nil { + return errCodexRoutingUnavailable + } + budget := codexValidationBudget{AccountID: query.AccountID, Stages: map[string]bool{}} + if previous.Found && (json.Unmarshal(previous.Value, &budget) != nil || budget.AccountID != query.AccountID || budget.Stages == nil) { + return errCodexRoutingUnavailable + } + if budget.Used >= 7 || budget.Stages[stage] || (query.Transport == "ws" && budget.Stages["ws-spent"]) { + return errCodexRoutingUnavailable + } + budget.Used++ + budget.Stages[stage] = true + if query.Transport == "ws" { + budget.Stages["ws-spent"] = true + } + raw, _ := json.Marshal(budget) + next, err := store.CompareSwapExtensionState(ctx, plugin, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: key, ExpectedRevision: previous.Revision, Value: raw}) + if err != nil { + return errCodexRoutingUnavailable + } + if next.Applied { + return nil + } + } + return errCodexRoutingUnavailable +} + +func (s *OpenAIGatewayService) ValidateCodexRouting(ctx context.Context, id int64, request CodexRoutingValidationRequest) (*CodexRoutingValidationResult, error) { + if uuid.Validate(request.ValidationID) != nil || !slices.Contains(codexValidationModels, request.Model) || (request.Transport != "http" && request.Transport != "ws") || s.pluginManager == nil { + return nil, errCodexRoutingUnavailable + } + account, err := s.accountRepo.GetByID(ctx, id) + if err != nil || !isOpenAICodexTicketAccount(account) { + return nil, errCodexRoutingUnavailable + } + installation, _ := s.pluginManager.installedByKey(codexRuntimePluginKey) + store, ok := s.pluginManager.repo.(PluginExtensionStateStore) + if installation == nil || !ok { + return nil, errCodexRoutingUnavailable + } + server, ok := s.pluginManager.buildHostServices(installation).(*pluginHostServiceServer) + if !ok || server.extension == nil { + return nil, errCodexRoutingUnavailable + } + ctx = WithPluginExecution(ctx, installation) + ctx = context.WithValue(ctx, codexValidationContextKey{}, codexValidationContext{ID: request.ValidationID, AccountID: id, Model: request.Model, Transport: request.Transport}) + ctx, cancel := context.WithTimeout(ctx, 60*time.Second) + defer cancel() + lease := extensionv1.LeaseRequest{Namespace: "routing-account", Key: fmt.Sprint(id), Owner: uuid.NewString(), TTLSeconds: 75} + locked, err := store.AcquireExtensionLease(ctx, installation.PluginKey, lease) + if err != nil || !locked.Acquired { + return nil, ErrCodexTicketBusy + } + lease.Generation = locked.Generation + defer func() { + release, stop := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second) + defer stop() + _, _ = store.ReleaseExtensionLease(release, installation.PluginKey, lease) + }() + result := &CodexRoutingValidationResult{ValidationID: request.ValidationID, AccountID: id, Model: request.Model, Transport: request.Transport, BudgetLimit: 7, Observations: []extensionv1.CodexRoutingObservation{}} + call := func(query extensionv1.CodexRoutingQuery) (extensionv1.CodexRoutingProbeResult, error) { + raw, _ := json.Marshal(query) + response, err := server.extension.Call(ctx, extensionv1.HostInvocation{Operation: extensionv1.HostCodexRoutingProbe, Payload: raw}) + var value extensionv1.CodexRoutingProbeResult + if err != nil || response.Code != "" || json.Unmarshal(response.Payload, &value) != nil { + return value, errCodexRoutingUnavailable + } + result.Observations = append(result.Observations, value.Observation) + return value, nil + } + query := extensionv1.CodexRoutingQuery{AccountID: id, Model: request.Model, Transport: request.Transport, OperationID: "validation-" + request.ValidationID} + storedKey := "validation-result." + codexRoutingDigest(request.ValidationID, fmt.Sprint(id), request.Model) + var acquired extensionv1.CodexRoutingProbeResult + if request.Transport == "http" { + query.Stage = "acquire" + acquired, err = call(query) + } else { + previous, readErr := store.ReadExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: storedKey}) + if readErr != nil || !previous.Found || json.Unmarshal(previous.Value, &acquired) != nil { + return nil, errCodexRoutingUnavailable + } + } + if err == nil && acquired.Valid && acquired.Bundle != nil { + query.Stage, query.Bundle, query.Scope = "verify", acquired.Bundle, &acquired.Scope + var verified extensionv1.CodexRoutingProbeResult + verified, err = call(query) + result.Success = err == nil && verified.Valid + if result.Success && request.Transport == "http" { + raw, _ := json.Marshal(verified) + _, _ = store.CompareSwapExtensionState(ctx, installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: storedKey, Value: raw}) + } + } + if err != nil { + result.Observations = append(result.Observations, extensionv1.CodexRoutingObservation{Stage: query.Stage, Code: "routing_validation_unavailable", RequestedModel: request.Model, Transport: request.Transport, ObservedAt: time.Now().UTC()}) + } + budgetRecord, readErr := store.ReadExtensionState(context.WithoutCancel(ctx), installation.PluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "validation." + request.ValidationID}) + if readErr == nil { + var budget codexValidationBudget + if json.Unmarshal(budgetRecord.Value, &budget) == nil { + result.BudgetUsed = budget.Used + } + } + // No tickets-state, enrollment, failure counter or scheduling projection is + // written by this operation. A verification run cannot start auto-renewal. + return result, nil +} diff --git a/backend/internal/service/codex_routing_ws_bridge_test.go b/backend/internal/service/codex_routing_ws_bridge_test.go new file mode 100644 index 000000000000..11cd2ef3936e --- /dev/null +++ b/backend/internal/service/codex_routing_ws_bridge_test.go @@ -0,0 +1,193 @@ +package service + +import ( + "context" + "encoding/json" + "errors" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" + + "github.com/Wei-Shaw/sub2api/internal/config" + "github.com/Wei-Shaw/sub2api/internal/pkg/tlsfingerprint" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/coder/websocket" + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/require" + "github.com/tidwall/gjson" +) + +type routingLeaseHTTPFixture struct { + calls atomic.Int32 + request *http.Request + body []byte +} + +func (*routingLeaseHTTPFixture) Do(*http.Request, string, int64, int) (*http.Response, error) { + return nil, errors.New("unexpected unqualified transport") +} +func (*routingLeaseHTTPFixture) DoWithTLS(*http.Request, string, int64, int, *tlsfingerprint.Profile) (*http.Response, error) { + return nil, errors.New("unexpected alternate TLS transport") +} +func (upstream *routingLeaseHTTPFixture) DoWithCodexConnectionLease(request *http.Request, _ string, account int64, _ string, lease string, _ time.Time, profile *tlsfingerprint.Profile) (*http.Response, string, error) { + if account != 7 || lease != "verified-connection" || profile != nil || request.Header.Get("Cookie") != "__cflb=route" { + return nil, "", errCodexRoutingUnavailable + } + upstream.calls.Add(1) + upstream.request = request.Clone(request.Context()) + upstream.body, _ = io.ReadAll(request.Body) + return &http.Response{StatusCode: 200, Proto: "HTTP/1.1", Header: http.Header{"Content-Type": []string{"text/event-stream"}}, Body: io.NopCloser(strings.NewReader("data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_verified\",\"status\":\"completed\",\"model\":\"gpt-6-astra\",\"output\":[],\"usage\":{\"input_tokens\":1,\"output_tokens\":1}}}\n\n"))}, lease, nil +} + +func TestCodexRoutingWebSocketIngressUsesVerifiedHTTPConnection(t *testing.T) { + gin.SetMode(gin.TestMode) + account := &Account{ID: 7, Platform: PlatformOpenAI, Type: AccountTypeOAuth, Status: StatusActive, Concurrency: 1, Credentials: map[string]any{"chatgpt_account_id": "principal"}, Extra: map[string]any{"openai_oauth_responses_websockets_v2_mode": OpenAIWSIngressModePassthrough}} + upstream := &routingLeaseHTTPFixture{} + cfg := &config.Config{} + cfg.Gateway.OpenAIWS.Enabled = true + cfg.Gateway.OpenAIWS.OAuthEnabled = true + cfg.Gateway.OpenAIWS.ModeRouterV2Enabled = true + cfg.Gateway.OpenAIWS.ResponsesWebsocketsV2 = true + cfg.Gateway.OpenAIWS.ReadTimeoutSeconds = 3 + cfg.Gateway.OpenAIWS.WriteTimeoutSeconds = 3 + var qualification *extensionv1.CodexRoutingQualification + manager := ticketTestManager(t, config.OpenAICodexTicketConfig{Enabled: true, FailClosed: true, Models: []string{"gpt-6-astra"}}, func(in extensionv1.Invocation) (extensionv1.Result, error) { + if in.Operation == "codex.routing.observe" || in.Operation == "codex.routing.demand" { + return extensionv1.Result{Payload: json.RawMessage(`{}`)}, nil + } + raw, _ := json.Marshal(extensionv1.CodexRoutingInjection{Headers: map[string]string{}, Qualification: qualification}) + return extensionv1.Result{Payload: raw}, nil + }) + installation := manager.extensions.Load().installations[1] + installation.State = PluginStateEnabled + store := &routingMemoryStore{PluginRepository: &pluginTokenRepository{installation: installation}, values: map[string]extensionv1.StateResult{}} + manager.repo = store + service := &OpenAIGatewayService{cfg: cfg, httpUpstream: upstream, accountRepo: &routingAccountRepositoryFixture{account: account}, pluginManager: manager, cache: &stubGatewayCache{}, toolCorrector: NewCodexToolCorrector(), openaiWSResolver: NewOpenAIWSProtocolResolver(cfg)} + scope, err := service.PrepareCodexRoutingScope(context.Background(), 7, "http") + require.NoError(t, err) + scope.ConnectionLeaseID = "verified-connection" + scope.RouteEvidence = "connection" + now := time.Now().UTC() + expiry := now.Add(time.Minute) + cookie := codexRoutingCookie{Name: "__cflb", Value: "route", Domain: "chatgpt.com", Path: "/", FirstSeen: now, ExpiresAt: expiry} + clockKey := "clock." + codexRoutingScopeKey(scope) + clock := codexRoutingCookieClock{Scope: scope} + clock.apply([]codexRoutingCookieChange{{Cookie: cookie}}, now) + raw, _ := json.Marshal(clock) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: clockKey, Value: raw}) + require.NoError(t, err) + bundle := codexRoutingPrivateBundle{Schema: 2, Scope: scope, Cookies: []codexRoutingCookie{cookie}, ClockKey: clockKey, ClockRevision: 1, Status: "qualified", Model: "gpt-6-astra", ExpiresAt: expiry} + raw, _ = json.Marshal(bundle) + _, err = store.CompareSwapExtensionState(context.Background(), codexRuntimePluginKey, extensionv1.StateRequest{Namespace: codexRoutingPrivateNamespace, Key: "bundle.fixture", Value: raw}) + require.NoError(t, err) + qualification = &extensionv1.CodexRoutingQualification{Scope: scope, Model: "gpt-6-astra", VerifiedAt: now, ExpiresAt: expiry, Bundle: extensionv1.CodexRoutingBundleRef{Key: "bundle.fixture", Revision: 1, ExpiresAt: expiry, ConnectionLeaseID: scope.ConnectionLeaseID}} + errorsChannel := make(chan error, 1) + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + conn, err := websocket.Accept(w, r, nil) + if err != nil { + errorsChannel <- err + return + } + defer func() { _ = conn.CloseNow() }() + ctx, cancel := context.WithTimeout(r.Context(), 4*time.Second) + defer cancel() + _, message, err := conn.Read(ctx) + if err != nil { + errorsChannel <- err + return + } + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Request = r + errorsChannel <- service.ProxyResponsesWebSocketFromClient(ctx, c, conn, account, "synthetic-token", message, nil) + })) + defer server.Close() + ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second) + defer cancel() + client, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(server.URL, "http"), nil) + require.NoError(t, err) + defer func() { _ = client.CloseNow() }() + require.NoError(t, client.Write(ctx, websocket.MessageText, []byte(`{"type":"response.create","model":"gpt-6-astra","input":"hello","client_metadata":{"turn_id":"turn-one"}}`))) + _, message, err := client.Read(ctx) + require.NoError(t, err) + require.Equal(t, "response.completed", gjson.GetBytes(message, "type").String()) + require.Equal(t, "gpt-6-astra", gjson.GetBytes(message, "response.model").String()) + _ = client.Close(websocket.StatusNormalClosure, "done") + select { + case err := <-errorsChannel: + require.NoError(t, err) + case <-ctx.Done(): + t.Fatal("bridge did not finish") + } + require.EqualValues(t, 1, upstream.calls.Load()) + require.Equal(t, "ws", upstream.request.Context().Value(codexRoutingIngressKey{})) + require.Empty(t, upstream.request.Header.Get(openAICodexTurnStateHeader)) +} + +type routingNativeConnFixture struct{ *stagedPassthroughConn } + +func (connection *routingNativeConnFixture) WriteJSON(ctx context.Context, value any) error { + raw, err := json.Marshal(value) + if err != nil { + return err + } + return connection.WriteFrame(ctx, websocket.MessageText, raw) +} + +func TestCodexRoutingNativeWebSocketCannotSwitchIntoQualifiedModel(t *testing.T) { + for _, mode := range []string{OpenAIWSIngressModePassthrough, OpenAIWSIngressModeCtxPool} { + t.Run(mode, func(t *testing.T) { + cfg := passthroughLifecycleConfig() + cfg.Gateway.OpenAIWS.OAuthEnabled = true + cfg.Gateway.OpenAIWS.ReadTimeoutSeconds = 3 + upstream := &routingNativeConnFixture{newStagedPassthroughConn()} + service := newPassthroughLifecycleService(cfg, upstream.stagedPassthroughConn) + service.openaiWSPassthroughDialer = &stagedPassthroughDialer{conn: upstream} + service.pluginManager = ticketTestManager(t, config.OpenAICodexTicketConfig{Enabled: true, FailClosed: true, Models: []string{"gpt-6-astra"}}, func(extensionv1.Invocation) (extensionv1.Result, error) { + return extensionv1.Result{Payload: json.RawMessage(`{"headers":{}}`)}, nil + }) + pool := newOpenAIWSConnPool(cfg) + pool.setClientDialerForTest(&stagedPassthroughDialer{conn: upstream}) + service.openaiWSPool = pool + t.Cleanup(pool.Close) + account := &Account{ID: 7, Platform: PlatformOpenAI, Type: AccountTypeOAuth, Status: StatusActive, Concurrency: 1, Credentials: map[string]any{"chatgpt_account_id": "owner"}, Extra: map[string]any{"openai_oauth_responses_websockets_v2_mode": mode}} + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + server, serverErrors := startPassthroughLifecycleServer(t, ctx, service, account) + defer server.Close() + client, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(server.URL, "http"), nil) + require.NoError(t, err) + defer func() { _ = client.CloseNow() }() + require.NoError(t, client.Write(ctx, websocket.MessageText, []byte(`{"type":"response.create","model":"gpt-5.5","input":"first"}`))) + select { + case first := <-upstream.writes: + require.Equal(t, "gpt-5.5", gjson.GetBytes(first, "model").String()) + case <-ctx.Done(): + t.Fatal("first allowed model was not forwarded") + } + upstream.Send(`{"type":"response.completed","response":{"id":"resp_first","status":"completed","model":"gpt-5.5","output":[],"usage":{"input_tokens":1,"output_tokens":1}}}`) + _, message, err := client.Read(ctx) + require.NoError(t, err) + require.Equal(t, "response.completed", gjson.GetBytes(message, "type").String()) + require.NoError(t, client.Write(ctx, websocket.MessageText, []byte(`{"type":"response.create","model":"gpt-6-astra","input":"second"}`))) + _, _, err = client.Read(ctx) + require.Error(t, err) + require.Equal(t, websocket.StatusPolicyViolation, websocket.CloseStatus(err)) + select { + case proxyErr := <-serverErrors: + var closed *OpenAIWSClientCloseError + require.ErrorAs(t, proxyErr, &closed) + case <-ctx.Done(): + t.Fatal("switch was not rejected") + } + select { + case <-upstream.writes: + t.Fatal("gated second frame reached a native upstream connection") + default: + } + }) + } +} diff --git a/backend/internal/service/codex_routing_ws_probe.go b/backend/internal/service/codex_routing_ws_probe.go new file mode 100644 index 000000000000..1cc165004136 --- /dev/null +++ b/backend/internal/service/codex_routing_ws_probe.go @@ -0,0 +1,106 @@ +package service + +import ( + "bytes" + "context" + "encoding/json" + "io" + "net/http" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "github.com/google/uuid" + "github.com/klauspost/compress/zstd" +) + +// Native WS validation is one bounded response on a fresh connection and a +// fresh logical session. It is never exported as qualification for a different +// socket or client session. Normal qualified WS ingress uses the HTTP bridge. +func (s *OpenAIGatewayService) executeCodexRoutingWSProbe(ctx context.Context, query extensionv1.CodexRoutingQuery, cookies string, deadline time.Time, scope extensionv1.CodexRoutingScope) (*http.Response, extensionv1.CodexRoutingScope, error) { + if _, validation := codexValidationFromContext(ctx); !validation || query.Stage != "verify" || cookies == "" || !time.Now().Before(deadline) { + return nil, scope, errCodexRoutingUnavailable + } + account, err := s.accountRepo.GetByID(ctx, query.AccountID) + if err != nil { + return nil, scope, errCodexRoutingUnavailable + } + token, _, err := s.GetAccessToken(withCodexTicketCredentials(ctx), account) + if err != nil { + return nil, scope, errCodexRoutingUnavailable + } + request, err := s.buildCodexRoutingProbe(ctx, account, query.Model, token, cookies) + if err != nil { + return nil, scope, err + } + raw, err := io.ReadAll(io.LimitReader(request.Body, codexRoutingProbeReadLimit)) + _ = request.Body.Close() + if err != nil { + return nil, scope, errCodexRoutingUnavailable + } + if request.Header.Get("Content-Encoding") == "zstd" { + decoder, decoderErr := zstd.NewReader(nil) + if decoderErr != nil { + return nil, scope, errCodexRoutingUnavailable + } + raw, err = decoder.DecodeAll(raw, nil) + decoder.Close() + if err != nil { + return nil, scope, errCodexRoutingUnavailable + } + } + var payload map[string]any + if json.Unmarshal(raw, &payload) != nil { + return nil, scope, errCodexRoutingUnavailable + } + delete(payload, "stream") + payload["type"] = "response.create" + headers := request.Header.Clone() + headers.Del("Accept") + headers.Del("Content-Type") + headers.Del("Content-Encoding") + headers.Del("Content-Length") + headers.Set("OpenAI-Beta", openAIWSBetaV2Value) + connection, status, handshake, err := s.getOpenAIWSPassthroughDialer().Dial(ctx, "wss://chatgpt.com/backend-api/codex/responses", headers, resolveAccountProxyURL(account)) + if err != nil || connection == nil { + return nil, scope, errCodexRoutingUnavailable + } + defer func() { _ = connection.Close() }() + scope.ConnectionLeaseID, scope.RouteEvidence, scope.Transport = "ws-validation-"+uuid.NewString(), "closed_validation_connection", "ws" + if err := connection.WriteJSON(ctx, payload); err != nil { + return nil, scope, errCodexRoutingUnavailable + } + var completion codexRoutingCompletion + var terminal []byte + readBytes := 0 + for readBytes < codexRoutingProbeReadLimit { + frame, readErr := connection.ReadMessage(ctx) + if readErr != nil { + return nil, scope, errCodexRoutingUnavailable + } + readBytes += len(frame) + completion.json(frame) + if completion.Failed { + return nil, scope, errCodexRoutingUnavailable + } + if completion.Completed { + terminal = frame + break + } + } + if terminal == nil { + return nil, scope, errCodexRoutingUnavailable + } + if status == 0 { + status = http.StatusSwitchingProtocols + } + response := &http.Response{StatusCode: status, Proto: "HTTP/1.1", Header: handshake.Clone(), Body: io.NopCloser(bytes.NewReader(terminal))} + if response.Header == nil { + response.Header = make(http.Header) + } + response.Header.Set("Content-Type", "application/json") + q := &extensionv1.CodexRoutingQualification{Scope: scope, Model: query.Model} + request.Header = headers + request = request.WithContext(context.WithValue(request.Context(), codexRoutingIngressKey{}, "ws")) + s.observeCodexWire(ctx, account, request, response, q) + return response, scope, nil +} diff --git a/backend/internal/service/codex_ticket_lifecycle.go b/backend/internal/service/codex_ticket_lifecycle.go index d47c5cf78ac6..58e05775b191 100644 --- a/backend/internal/service/codex_ticket_lifecycle.go +++ b/backend/internal/service/codex_ticket_lifecycle.go @@ -81,31 +81,41 @@ func CodexTicketAccountEligible(a *Account) bool { func CodexTicketFailure(code string) CodexTicketResult { messages := map[string]string{ - "ticket_plugin_unavailable": "票据插件未启用或暂不可用", - "ticket_disabled": "票据总开关未开启", - "ticket_proxy_missing": "未配置打票代理", - "ticket_ineligible": "仅 OpenAI OAuth/Setup Token 非影子账号可打票", - "ticket_model_invalid": "模型不在票据配置范围内", - "ticket_busy": "该账号和模型已有打票任务", - "ticket_interrupted": "上次请求已开始，结果未确认；不会自动重复发送", - "ticket_token": "无法取得账号访问令牌", - "ticket_timeout": "请求超时", - "ticket_transport": "打票代理传输失败", - "ticket_upstream": "上游拒绝打票请求", - "ticket_length": "响应票据长度不符合292规则", - "ticket_prefix": "响应票据格式不符合规则", - "ticket_missing_header": "响应未包含票据头", - "ticket_persist": "票据持久化失败，未加入自动续期", - "ticket_stale": "账号身份、任务或续期状态已经变化", - "ticket_canceled": "任务已取消", - "ticket_stopped": "自动续期已停止", - "ticket_proxy_auth": "代理鉴权失败", - "ticket_proxy_protocol": "代理协议握手失败，请核对HTTP或SOCKS协议", - "ticket_proxy_dns": "代理主机DNS解析失败", - "ticket_proxy_connect": "代理连接被拒绝或CONNECT失败", - "ticket_proxy_eof": "连接被对端提前关闭（EOF）", - "ticket_proxy_reset": "连接被对端重置", - "ticket_proxy_tls": "代理TLS证书验证失败，请测试代理连接", + "routing_candidate": "已取得候选 Cookie，尚未通过业务出口验证", + "routing_model_mismatch": "业务出口返回模型不匹配，未发布资格", + "routing_incomplete": "响应未完整结束或缺少模型字段", + "routing_cookie_missing": "未取得可用路由 Cookie", + "routing_cookie_expired": "路由 Cookie 已到期", + "routing_cookie_deleted": "上游已撤销路由 Cookie", + "routing_transport": "采集或业务出口连接失败", + "routing_stale": "账号、设备、出口或 Cookie 代次已变化", + "routing_connection_expired": "已验证连接不可复用，需要重新验证", + "routing_upstream": "上游拒绝路由验证请求", + "ticket_plugin_unavailable": "票据插件未启用或暂不可用", + "ticket_disabled": "票据总开关未开启", + "ticket_proxy_missing": "未配置打票代理", + "ticket_ineligible": "仅 OpenAI OAuth/Setup Token 非影子账号可打票", + "ticket_model_invalid": "模型不在票据配置范围内", + "ticket_busy": "该账号和模型已有打票任务", + "ticket_interrupted": "上次请求已开始，结果未确认；不会自动重复发送", + "ticket_token": "无法取得账号访问令牌", + "ticket_timeout": "请求超时", + "ticket_transport": "打票代理传输失败", + "ticket_upstream": "上游拒绝打票请求", + "ticket_length": "响应票据长度不符合292规则", + "ticket_prefix": "响应票据格式不符合规则", + "ticket_missing_header": "响应未包含票据头", + "ticket_persist": "票据持久化失败，未加入自动续期", + "ticket_stale": "账号身份、任务或续期状态已经变化", + "ticket_canceled": "任务已取消", + "ticket_stopped": "自动续期已停止", + "ticket_proxy_auth": "代理鉴权失败", + "ticket_proxy_protocol": "代理协议握手失败，请核对HTTP或SOCKS协议", + "ticket_proxy_dns": "代理主机DNS解析失败", + "ticket_proxy_connect": "代理连接被拒绝或CONNECT失败", + "ticket_proxy_eof": "连接被对端提前关闭（EOF）", + "ticket_proxy_reset": "连接被对端重置", + "ticket_proxy_tls": "代理TLS证书验证失败，请测试代理连接", } message, ok := messages[code] if !ok { diff --git a/backend/internal/service/codex_ticket_plugin.go b/backend/internal/service/codex_ticket_plugin.go index 22bb4ae7c6b1..686bff9b2467 100644 --- a/backend/internal/service/codex_ticket_plugin.go +++ b/backend/internal/service/codex_ticket_plugin.go @@ -61,6 +61,9 @@ func (s *OpenAIGatewayService) applyOpenAICodexTicket(ctx context.Context, accou } func (s *OpenAIGatewayService) openAICodexTicketBlocksAccount(account *Account, model string) bool { + if s != nil && s.pluginManager != nil { + s.pluginManager.noteCodexRoutingDemand(account, model) + } return s != nil && s.pluginManager != nil && !s.pluginManager.SchedulingDecision(account, model, time.Now()).Allowed } @@ -151,13 +154,13 @@ func OpenAICodexTicketStatuses(account *Account, cfg config.OpenAICodexTicketCon entry.Length = observation.Count if observation.Code != "" { result := CodexTicketFailure(observation.Code) - if observation.Code == "ticket_ready" || observation.Code == "ticket_skipped" { - result = CodexTicketResult{Code: observation.Code, Success: true, Message: "已有有效票据"} + if observation.Code == "routing_verified" || observation.Code == "ticket_skipped" { + result = CodexTicketResult{Code: observation.Code, Success: true, Message: "业务出口 Cookie 路由已验证"} } entry.LastResult = &result } } - if grant, ok := projection.Scheduling[model]; ok && grant.Effect == "allow" && grant.Until != nil && now.Before(*grant.Until) { + if grant, ok := projection.Scheduling[model]; ok && grant.Effect == "allow" && grant.Reason == "routing_verified" && grant.Until != nil && now.Before(*grant.Until) { entry.Ready = true entry.ExpiresAt = grant.Until entry.RemainingSeconds = int64(grant.Until.Sub(now).Seconds()) diff --git a/backend/internal/service/model_context_capacity.go b/backend/internal/service/model_context_capacity.go index 5f0e159421fe..1b30e0ce5c2c 100644 --- a/backend/internal/service/model_context_capacity.go +++ b/backend/internal/service/model_context_capacity.go @@ -9,6 +9,7 @@ import ( "strings" infraerrors "github.com/Wei-Shaw/sub2api/internal/pkg/errors" + "github.com/Wei-Shaw/sub2api/internal/pkg/openai" extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) @@ -565,8 +566,18 @@ func protectedAccountModelContextCapacity(account *Account, modelID string, live // display value. It is never relabelled as a raw upstream observation. if metadata, ok := account.GetUpstreamModelMetadata(modelID); ok { result.ModelContextCapacity, _ = modelContextPlanningCapacity(ModelContextCapacity{ - ContextWindow: metadata.ContextWindow, MaxOutputTokens: metadata.MaxOutputTokens, + ContextWindow: metadata.ContextWindow, MaxContextWindow: metadata.MaxContextWindow, MaxOutputTokens: metadata.MaxOutputTokens, }) + if result.ContextWindow > 0 { + return result + } + } + if account.IsOpenAIOAuthLike() && isOpenAIGPT6SolOrLunaModel(modelID) { + result.ModelContextCapacity = ModelContextCapacity{ + ContextWindow: openai.GPT6CodexContextWindow, MaxContextWindow: openai.GPT6CodexMaxContextWindow, + CapacityBasis: ModelContextCapacityBasisTotal, + } + result.Reason = "codex_catalog_reference" } return result } @@ -642,6 +653,10 @@ func BuildAccountModelContextCapacityRows(account *Account, modelIDs []string) [ automatic = ResolveModelContextCapacityForAccount(account, nil, row.Official, row.Upstream) } else { automatic = resolve(modelID, nil) + if account.IsOpenAIOAuthLike() && isOpenAIGPT6SolOrLunaModel(modelID) { + // Expose product references without applying API limits to OAuth. + row.Official = LookupOfficialModelContextCapacity(account, modelID) + } } effective := resolve(modelID, nil) row.AutomaticContextWindow, row.AutomaticSource = automatic.ContextWindow, automatic.Source diff --git a/backend/internal/service/model_context_capacity_catalog_test.go b/backend/internal/service/model_context_capacity_catalog_test.go index ee80557ec1c0..75692ffe272d 100644 --- a/backend/internal/service/model_context_capacity_catalog_test.go +++ b/backend/internal/service/model_context_capacity_catalog_test.go @@ -5,6 +5,8 @@ import ( "strings" "testing" "time" + + "github.com/Wei-Shaw/sub2api/internal/pkg/openai" ) func TestOfficialModelContextCapacityCatalogIntegrity(t *testing.T) { @@ -84,8 +86,12 @@ func TestOfficialModelContextCapacityCatalogIntegrity(t *testing.T) { } } if ref := row.Reference; ref != nil { - if ref.Product != "codex_subscription" || ref.SourceURL != gptContextCapacityReferenceSource || - ref.Release != GPTContextCapacityReferenceRelease || ref.VerifiedAt != gptContextCapacityReferenceVerifiedAt || + source, release, verifiedAt := gptContextCapacityReferenceSource, GPTContextCapacityReferenceRelease, gptContextCapacityReferenceVerifiedAt + if openai.GPT6NamedModel(row.ModelID) != "" { + source, release, verifiedAt = openai.GPT6CodexReferenceSource, openai.GPT6CodexReferenceCommit, openai.GPT6CodexReferenceVerifiedAt + } + if ref.Product != "codex_subscription" || ref.SourceURL != source || + ref.Release != release || ref.VerifiedAt != verifiedAt || ref.ContextWindow <= 0 || ref.MaxContextWindow < ref.ContextWindow || row.Conditions == "" { t.Errorf("invalid or unexplained Codex reference: %+v", ref) } diff --git a/backend/internal/service/openai_business_system_prompt.go b/backend/internal/service/openai_business_system_prompt.go index 806c6fc59824..e6de2c6b0565 100644 --- a/backend/internal/service/openai_business_system_prompt.go +++ b/backend/internal/service/openai_business_system_prompt.go @@ -4,6 +4,7 @@ import ( "bytes" "crypto/sha256" "encoding/hex" + "encoding/json" "fmt" "strconv" "strings" @@ -37,6 +38,7 @@ type businessSystemPromptCacheIdentities struct { } type businessSystemPromptRequestState struct { + rulesUndo []promptRulesCarrierUndo application BusinessSystemPromptApplication snapshot BusinessSystemPromptSnapshot target BusinessSystemPromptTarget @@ -67,6 +69,15 @@ func businessSystemPromptTargetForAccount(account *Account, protocol string, com target := BusinessSystemPromptTarget{Protocol: protocol, Compact: compact} if account != nil { target.AccountID, target.Platform, target.AccountType = account.ID, account.EffectiveWirePlatform(), account.Type + target.ProviderPlatform, target.ProviderProfile = account.Platform, account.EffectiveProviderProfile() + if binding := account.Extra[PromptAccountBindingExtraKey]; binding != nil { + raw, err := json.Marshal(binding) + if err == nil { + target.BindingJSON = string(raw) + } else { + target.BindingJSON = "invalid" + } + } } return target } @@ -140,6 +151,10 @@ func businessSystemPromptCarrier(body []byte, carrier string) (gjson.Result, []b func cacheBusinessSystemPromptState(input, output []byte, snapshot BusinessSystemPromptSnapshot, target BusinessSystemPromptTarget, application BusinessSystemPromptApplication) businessSystemPromptRequestState { state := businessSystemPromptRequestState{application: application, snapshot: snapshot, target: target, inputHash: sha256.Sum256(input), output: append([]byte(nil), output...)} + if application.RulesPlan != nil { + state.rulesUndo = promptRulesUndo(input, output, application) + return state + } if !application.Applied { return state } @@ -174,6 +189,21 @@ func cacheBusinessSystemPromptState(input, output []byte, snapshot BusinessSyste } func inheritBusinessSystemPromptProvenance(next, previous businessSystemPromptRequestState) businessSystemPromptRequestState { + if next.application.RulesPlan != nil || previous.application.RulesPlan != nil { + for _, proof := range previous.rulesUndo { + present := false + for _, current := range next.rulesUndo { + if current.field == proof.field { + present = true + break + } + } + if !present { + next.rulesUndo = append(next.rulesUndo, proof) + } + } + return next + } next.historyUncertain = previous.historyUncertain if !next.application.Applied { next.undo, next.otherUndo = previous.undo, previous.otherUndo @@ -197,6 +227,9 @@ func inheritBusinessSystemPromptProvenance(next, previous businessSystemPromptRe } func restoreBusinessSystemPromptBody(body []byte, state businessSystemPromptRequestState) ([]byte, error) { + if state.application.RulesPlan != nil || len(state.rulesUndo) > 0 { + return restorePromptRules(body, state.rulesUndo) + } if (!state.application.Applied && !state.undo.present && !state.otherUndo.present) || sha256.Sum256(body) == state.inputHash { return body, nil } @@ -317,6 +350,9 @@ func businessSystemPromptCarrierExcludesInsertion(body []byte, undo businessSyst } func businessSystemPromptExcludesAllInsertions(body []byte, state businessSystemPromptRequestState) bool { + if state.application.RulesPlan != nil || len(state.rulesUndo) > 0 { + return false + } if state.historyUncertain || (state.application.Applied && !state.undo.present && !state.otherUndo.present) { return false } @@ -373,13 +409,7 @@ func (s *OpenAIGatewayService) applyBusinessSystemPrompt( return nil, BusinessSystemPromptApplication{}, err } } - return ApplyBusinessSystemPromptToJSON(body, snapshot, BusinessSystemPromptTarget{ - AccountID: account.ID, - Platform: account.EffectiveWirePlatform(), - AccountType: account.Type, - Protocol: protocol, - Compact: compact, - }) + return ApplyBusinessSystemPromptToJSON(body, snapshot, enrichPromptTarget(nil, body, businessSystemPromptTargetForAccount(account, protocol, compact))) } func (s *OpenAIGatewayService) businessSystemPromptSnapshotForRequest( @@ -420,8 +450,17 @@ func (s *OpenAIGatewayService) applyBusinessSystemPromptForRequest( account *Account, protocol string, compact bool, -) ([]byte, BusinessSystemPromptApplication, error) { - target := businessSystemPromptTargetForAccount(account, protocol, compact) +) (out []byte, applied BusinessSystemPromptApplication, returnErr error) { + defer func() { writePromptDeliveryError(ctx, returnErr) }() + target := enrichPromptTarget(ctx, body, businessSystemPromptTargetForAccount(account, protocol, compact)) + if s != nil && s.businessPromptService != nil && s.businessPromptService.accountRepo != nil && account != nil && account.IsOpenAI() { + fresh, err := s.businessPromptService.accountRepo.GetByID(promptPolicyRequestContext(ctx), account.ID) + if err != nil || fresh == nil { + return nil, BusinessSystemPromptApplication{}, ErrBusinessSystemPromptUnavailable + } + freshTarget := businessSystemPromptTargetForAccount(fresh, protocol, compact) + target.BindingJSON = freshTarget.BindingJSON + } // Platform eligibility precedes policy invocation or application reuse. // Local provenance can still undo an earlier OpenAI insertion before an // unrelated platform's transform; clean customer carriers stay untouched. @@ -447,12 +486,12 @@ func (s *OpenAIGatewayService) applyBusinessSystemPromptForRequest( } previousPlan := state.application previousPlan.ClientInstructions = "" - if state.target == target && previousPlan == application { + if state.target == target && sameBusinessPromptPlan(previousPlan, application) { rememberBusinessSystemPromptTarget(ctx, target) if state.inputHash == sha256.Sum256(body) { return append([]byte(nil), state.output...), state.application, nil } - if bytes.Equal(body, state.output) || (!state.historyUncertain && ((!state.application.Applied && !state.undo.present && !state.otherUndo.present) || businessSystemPromptAlreadyApplied(body, state.application, protocol))) { + if bytes.Equal(body, state.output) || (state.application.RulesPlan != nil && promptRulesCarrierMatches(body, state)) || (state.application.RulesPlan == nil && !state.historyUncertain && ((!state.application.Applied && !state.undo.present && !state.otherUndo.present) || businessSystemPromptAlreadyApplied(body, state.application, protocol))) { return body, state.application, nil } } @@ -571,7 +610,7 @@ func (s *OpenAIGatewayService) rewriteBusinessSystemPromptJSONForRequest(c *gin. if err != nil { return body } - return rewritten + return rewritePromptRulesStructuredEcho(c, rewritten, protocol) } func (s *OpenAIGatewayService) rewriteBusinessSystemPromptJSONForAnyRequest(c *gin.Context, body []byte) []byte { @@ -588,6 +627,9 @@ func (s *OpenAIGatewayService) rewriteBusinessSystemPromptSSEForRequest(c *gin.C if err != nil { return body } + if application.RulesPlan != nil { + return rewritePromptRulesStructuredSSE(c, rewritten, protocol) + } return rewritten } @@ -623,6 +665,9 @@ func beginBusinessSystemPromptRequestTurn(ctx *gin.Context) { // This encoding is an internal namespace, never an upstream field. Preserve // its historical bytes so Cindy's SHA256(old expanded key) remains unchanged. func businessSystemPromptCacheNamespace(application BusinessSystemPromptApplication) string { + if application.RulesPlan != nil && application.Applied { + return ":prompt-rules:v1:" + strconv.FormatInt(application.Revision, 10) + ":" + application.RulesPlan.SHA256 + } if !application.Applied || application.Revision < 1 || strings.TrimSpace(application.SHA256) == "" { return "" } @@ -674,6 +719,18 @@ func rewriteBusinessSystemPromptCacheKey(c *gin.Context, body []byte, applicatio if !value.Exists() || value.Type != gjson.String { return body, nil } + if application.RulesPlan != nil && !application.Applied && c != nil { + if stored, ok := c.Get(businessSystemPromptCacheIdentityKey); ok { + if identities, ok := stored.(*businessSystemPromptCacheIdentities); ok { + for _, identity := range identities.values { + if value.String() == identity.wire { + return sjson.SetBytes(body, "prompt_cache_key", identity.source) + } + } + } + } + return body, nil + } effective := deriveBusinessSystemPromptCacheKey(c, value.String(), application) if effective == "" || effective == value.String() { return body, nil diff --git a/backend/internal/service/openai_business_system_prompt_observability.go b/backend/internal/service/openai_business_system_prompt_observability.go index a39b0e35634e..26d8b4b1a5d8 100644 --- a/backend/internal/service/openai_business_system_prompt_observability.go +++ b/backend/internal/service/openai_business_system_prompt_observability.go @@ -70,6 +70,11 @@ func logBusinessSystemPromptObservation( upstreamTransport OpenAIUpstreamTransport, selectionReason string, ) { + // Rule plans are observed at the final serializer, with their actual + // placements, instead of reporting an invented single appended string. + if application.RulesPlan != nil { + return + } if c != nil { key := businessSystemPromptContextKey(c, businessSystemPromptRequestObservationKey, BusinessSystemPromptProtocolResponses) if _, exists := businessSystemPromptRequestGet(c, key); exists { diff --git a/backend/internal/service/openai_codex_client_identity.go b/backend/internal/service/openai_codex_client_identity.go index 7745762c44cb..4afdf533c3eb 100644 --- a/backend/internal/service/openai_codex_client_identity.go +++ b/backend/internal/service/openai_codex_client_identity.go @@ -18,7 +18,7 @@ import ( // 是同一台设备上运行的同一个真实 Codex TUI，而不是多个用户各自的客户端。 const CodexClientIdentityExtraKey = "codex_client_identity" -const codexClientIdentitySchemaVersion = 1 +const codexClientIdentitySchemaVersion = 1 // legacy persisted representation remains valid type codexClientIdentity extensionv1.CodexClientProfile @@ -65,7 +65,11 @@ func deriveCodexClientIdentity(seed string) codexClientIdentity { } func deriveCodexClientIdentityForAccountContext(ctx context.Context, account *Account, seed string) codexClientIdentity { - result, _ := invokeCodexIdentityPolicyForAccount(ctx, account, "codex.identity.derive", extensionv1.CodexIdentityQuery{Seed: seed}) + preset := "captured_windows_cli" + if account != nil && account.ID > 0 { + preset = "legacy" + } + result, _ := invokeCodexIdentityPolicyForAccount(ctx, account, "codex.identity.derive", extensionv1.CodexIdentityQuery{Seed: seed, Preset: preset}) return codexClientIdentity(result.Profile) } @@ -140,19 +144,22 @@ func (a *Account) codexClientIdentityContext(ctx context.Context) (codexClientId return codexClientIdentity{}, false } identity := deriveCodexClientIdentityForAccountContext(ctx, a, seed) - return identity, identity.Version == codexClientIdentitySchemaVersion + return identity, identity.Version == codexClientIdentitySchemaVersion || identity.Version == 2 } // codexClientIdentityExtraValue 把身份编码为可直接写入 extra 的 map。 func codexClientIdentityExtraValue(id codexClientIdentity, now time.Time) map[string]any { return map[string]any{ - "v": id.Version, - "os_type": id.OSType, - "os_version": id.OSVersion, - "arch": id.Arch, - "terminal": id.Terminal, - "sandbox": id.Sandbox, - "generated_at": now.UTC().Format(time.RFC3339), + "source": id.Source, + "originator": id.Originator, + "client_version": id.ClientVersion, + "v": id.Version, + "os_type": id.OSType, + "os_version": id.OSVersion, + "arch": id.Arch, + "terminal": id.Terminal, + "sandbox": id.Sandbox, + "generated_at": now.UTC().Format(time.RFC3339), } } @@ -182,7 +189,7 @@ func ensureCodexClientIdentityExtraForAccount(account *Account, extra map[string extra = make(map[string]any, 1) } identity := deriveCodexClientIdentityForAccountContext(context.Background(), account, seed) - if identity.Version != codexClientIdentitySchemaVersion { + if identity.Version != codexClientIdentitySchemaVersion && identity.Version != 2 { return extra } extra[CodexClientIdentityExtraKey] = codexClientIdentityExtraValue(identity, now) @@ -298,7 +305,7 @@ func (s *CodexClientIdentityBackfillService) RunOnce(ctx context.Context) (int, if err := bound.Err(); err != nil { return err } - result, err := invokeCodexIdentityPolicyForAccount(bound, account, "codex.identity.derive", extensionv1.CodexIdentityQuery{Seed: seed}) + result, err := invokeCodexIdentityPolicyForAccount(bound, account, "codex.identity.derive", extensionv1.CodexIdentityQuery{Seed: seed, Preset: "legacy"}) if err != nil { return err } diff --git a/backend/internal/service/openai_codex_fingerprint.go b/backend/internal/service/openai_codex_fingerprint.go index 4a891544a01a..e31c369f2e41 100644 --- a/backend/internal/service/openai_codex_fingerprint.go +++ b/backend/internal/service/openai_codex_fingerprint.go @@ -527,6 +527,14 @@ func applyCodexFingerprintToClientMetadataMap(existing map[string]any, ids *code } // session / full 模式 + // A real turn can contain several tool continuations or retries. Preserve + // its already-account-scoped UUID instead of minting another turn per HTTP + // attempt; headers and body share this same IDs object. + if original, ok := existing["turn_id"].(string); ok { + if _, err := uuid.Parse(original); err == nil { + ids.turnID = original + } + } existing["session_id"] = ids.sessionID existing["thread_id"] = ids.threadID existing["turn_id"] = ids.turnID diff --git a/backend/internal/service/openai_codex_identity_snapshot.go b/backend/internal/service/openai_codex_identity_snapshot.go index 85ba43cd7cd9..24c2c6fc8653 100644 --- a/backend/internal/service/openai_codex_identity_snapshot.go +++ b/backend/internal/service/openai_codex_identity_snapshot.go @@ -17,6 +17,8 @@ import ( // process state published by NewOpenAIGatewayService, so the snapshot describes // the policy that was actually active in this process. type codexIdentitySnapshot struct { + ProfileSource string `json:"profile_source"` + ProfileSchema int `json:"profile_schema"` SchemaVersion int `json:"v"` AccountID int64 `json:"account_id"` IdentityAccountID int64 `json:"identity_account_id"` @@ -29,6 +31,7 @@ type codexIdentitySnapshot struct { EnforcementEnabled bool `json:"enforcement_enabled"` ForceCodexCLI bool `json:"force_codex_cli"` UserAgent string `json:"user_agent"` + UAOverridePresent bool `json:"ua_override_present"` Originator string `json:"originator"` Version string `json:"version"` FingerprintModeConfigured string `json:"fingerprint_mode_configured"` @@ -53,6 +56,7 @@ func resolveCodexIdentitySnapshotContext(ctx context.Context, routed, source *Ac SchemaVersion: 1, EnforcementEnabled: codexIdentityEnforcement.Load(), ForceCodexCLI: codexForceCLI.Load(), + UAOverridePresent: strings.TrimSpace(overrideUA) != "", } if source != nil && source.IsOpenAIOAuthLike() { if plan, err := codexTransportPlan(ctx, source.Type, source.ID, extensionv1.CodexTransportQuery{}); err == nil { @@ -84,6 +88,13 @@ func resolveCodexIdentitySnapshotContext(ctx context.Context, routed, source *Ac } } if source != nil { + if profile, ok := source.codexClientIdentityContext(ctx); ok { + snapshot.ProfileSchema = profile.Version + snapshot.ProfileSource = profile.Source + if snapshot.ProfileSource == "" { + snapshot.ProfileSource = "legacy_generated" + } + } snapshot.IdentityAccountID = source.ID snapshot.AccountRevision = source.UpdatedAt snapshot.IdentityPersisted = func() bool { diff --git a/backend/internal/service/openai_codex_model_metadata.go b/backend/internal/service/openai_codex_model_metadata.go index abfe94ef37f6..3255dfcd0608 100644 --- a/backend/internal/service/openai_codex_model_metadata.go +++ b/backend/internal/service/openai_codex_model_metadata.go @@ -5,6 +5,8 @@ import ( "encoding/json" "net/url" "strings" + + "github.com/Wei-Shaw/sub2api/internal/pkg/openai" ) var codexToolCapabilityFields = []string{ @@ -50,6 +52,9 @@ func accountCodexToolCapabilities(account *Account, modelID string) map[string]j if metadata, ok := account.GetUpstreamModelMetadata(modelID); ok { applyCodexToolCapabilities(capabilities, metadata.CodexToolCapabilities, true) } + if defaults, ok := gpt6APIModelMetadata(account, modelID); ok { + applyCodexToolCapabilities(capabilities, defaults.CodexToolCapabilities, false) + } if account.IsOpenAI() && shouldForwardOpenAIResponsesViaRawChatCompletions(account) { // This bridge implements client-side tool discovery, even without a native manifest. applyCodexToolCapabilities(capabilities, map[string]json.RawMessage{"supports_search_tool": json.RawMessage("true")}, false) @@ -63,7 +68,7 @@ func accountCodexToolCapabilities(account *Account, modelID string) map[string]j parsed, err := url.Parse(baseURL) official := err == nil && (strings.EqualFold(parsed.Hostname(), "api.openai.com") || (account.IsOpenAIOAuth() && strings.EqualFold(parsed.Hostname(), "chatgpt.com"))) - if account.IsOpenAI() && isOpenAIGPT6AstraModel(modelID) && official { + if account.IsOpenAI() && (isOpenAIGPT6AstraModel(modelID) || isOpenAIGPT6SolOrLunaModel(modelID)) && official { defaults := map[string]json.RawMessage{ "supports_search_tool": json.RawMessage("true"), "apply_patch_tool_type": json.RawMessage(`"freeform"`), @@ -75,12 +80,18 @@ func accountCodexToolCapabilities(account *Account, modelID string) map[string]j defaults["tool_mode"] = json.RawMessage(`"code_mode_only"`) defaults["use_responses_lite"] = json.RawMessage("true") } + if isOpenAIGPT6SolOrLunaModel(modelID) { + defaults["multi_agent_reasoning_effort"] = json.RawMessage("null") + defaults["multi_agent_version"] = json.RawMessage(`"v2"`) + } applyCodexToolCapabilities(capabilities, defaults, false) } if account.IsOpenAIApiKey() { target := modelID if isOpenAIGPT6AstraModel(target) { target = "gpt-6-astra" + } else if named := openai.GPT6NamedModel(target); named != "" { + target = named } _, disabled := apiKeyCodexModelsWithoutResponsesLite[target] if disabled && bytes.Equal(capabilities["use_responses_lite"], []byte("true")) { @@ -184,6 +195,16 @@ func groupCodexModelMetadata( publicAlias = true } metadata, ok := account.GetUpstreamModelMetadata(lookupModel) + if defaults, known := gpt6AccountModelMetadata(account, lookupModel); known { + metadata, _ = mergeUpstreamModelMetadata(metadata, defaults) + ok = true + if account.IsOpenAIOAuthLike() { + // Raw capacity snapshots have separate provenance and may be + // newer than the enriched capability snapshot. + metadata.ContextWindow, metadata.MaxContextWindow = defaults.ContextWindow, defaults.MaxContextWindow + metadata.MaxOutputTokens = defaults.MaxOutputTokens + } + } if !ok { if explicitTargetsConflict { return codexModelMetadataOverride{ diff --git a/backend/internal/service/openai_codex_models_service.go b/backend/internal/service/openai_codex_models_service.go index 9eedfadbcfee..7efa42344acc 100644 --- a/backend/internal/service/openai_codex_models_service.go +++ b/backend/internal/service/openai_codex_models_service.go @@ -405,7 +405,8 @@ type configuredCodexModelDescriptor struct { Description string `json:"description"` DefaultReasoningLevel *string `json:"default_reasoning_level,omitempty"` SupportedReasoningLevels []configuredCodexReasoningLevel `json:"supported_reasoning_levels"` - MultiAgentReasoningEffort *string `json:"multi_agent_reasoning_effort,omitempty"` + MultiAgentReasoningEffort *string `json:"multi_agent_reasoning_effort"` + MinimalClientVersion string `json:"minimal_client_version,omitempty"` ShellType string `json:"shell_type"` Visibility string `json:"visibility"` SupportedInAPI bool `json:"supported_in_api"` @@ -536,6 +537,21 @@ func newConfiguredCodexModelDescriptor(modelID string) configuredCodexModelDescr if isOpenAIGPT56Model(modelID) { descriptor.MaxContextWindow = configuredCodexGPT56MaxContext } + if isOpenAIGPT6SolOrLunaModel(modelID) { + // Pinned Codex subscription defaults; API-key projection uses API + // metadata and live account declarations remain authoritative. + descriptor.ContextWindow = openai.GPT6CodexContextWindow + descriptor.MaxContextWindow = openai.GPT6CodexMaxContextWindow + descriptor.MultiAgentVersion = "v2" + descriptor.MinimalClientVersion = openai.GPT6CodexMinimumClientVersion + descriptor.CompHash = "3000" + applyPatch := "freeform" + descriptor.ApplyPatchToolType = &applyPatch + descriptor.ShellType = "shell_command" + descriptor.WebSearchToolType = "text_and_image" + descriptor.InputModalities = []string{"text", "image"} + descriptor.SupportsImageDetailOriginal = true + } if isOpenAIGPT6AstraModel(modelID) { // Codex resolves the Ultra workflow to this effort before inference. // openai/codex a9896da3: codex-rs/models-manager/models.json. @@ -583,7 +599,7 @@ func configuredCodexSupportsPriorityServiceTier(modelID string) bool { } } // GPT-6 Astra advertises Fast via service_tier=priority in public model metadata. - return isOpenAIGPT6AstraModel(modelID) + return isOpenAIGPT6AstraModel(modelID) || isOpenAIGPT6SolOrLunaModel(modelID) } func configuredCodexSupportsUltrafastServiceTier(modelID string) bool { @@ -646,13 +662,13 @@ func configuredCodexGPTReasoningLevels(modelID string) []configuredCodexReasonin {Effort: "xhigh", Description: "Extra-high reasoning depth for difficult tasks"}, } normalized := getNormalizedCodexModel(modelID) - if isOpenAIGPT56Model(modelID) || isOpenAIGPT6AstraModel(modelID) { + if isOpenAIGPT56Model(modelID) || isOpenAIGPT6AstraModel(modelID) || isOpenAIGPT6SolOrLunaModel(modelID) { levels = append(levels, configuredCodexReasoningLevel{ Effort: "max", Description: "Maximum reasoning depth for complex tasks", }) } - if isOpenAIGPT6AstraModel(modelID) || normalized == "gpt-5.6-sol" || normalized == "gpt-5.6-terra" { + if isOpenAIGPT6AstraModel(modelID) || openai.GPT6NamedModel(modelID) == "gpt-6-sol" || normalized == "gpt-5.6-sol" || normalized == "gpt-5.6-terra" { levels = append(levels, configuredCodexReasoningLevel{ Effort: "ultra", Description: "Maximum reasoning with automatic task delegation", @@ -671,12 +687,12 @@ func isOpenAICodexGPTModel(modelID string) bool { func isOpenAICodexReasoningGPTModel(modelID string) bool { normalized := canonicalizeOpenAIModelAliasSpelling(modelID) - return isOpenAIGPT6AstraModel(normalized) || strings.HasPrefix(normalized, "gpt-5") + return isOpenAIGPT6AstraModel(normalized) || isOpenAIGPT6SolOrLunaModel(normalized) || strings.HasPrefix(normalized, "gpt-5") } func isOpenAICodexImageInputModel(modelID string) bool { normalized := canonicalizeOpenAIModelAliasSpelling(modelID) - return isOpenAIGPT6AstraModel(normalized) || + return isOpenAIGPT6AstraModel(normalized) || isOpenAIGPT6SolOrLunaModel(normalized) || strings.HasPrefix(normalized, "gpt-5") || strings.HasPrefix(normalized, "gpt-4o") || strings.HasPrefix(normalized, "gpt-4.1") || @@ -2371,6 +2387,8 @@ func CodexModelsManifestETag(body []byte) string { var apiKeyCodexModelsWithoutResponsesLite = map[string]struct{}{ "gpt-6-astra": {}, + "gpt-6-sol": {}, + "gpt-6-luna": {}, "gpt-5.6-sol": {}, "gpt-5.6-terra": {}, "gpt-5.6-luna": {}, @@ -2406,6 +2424,8 @@ func adjustAPIKeyCodexModelsManifest(body []byte, account *Account) ([]byte, err } if isOpenAIGPT6AstraModel(target) { target = "gpt-6-astra" + } else if named := openai.GPT6NamedModel(target); named != "" { + target = named } if _, targeted := apiKeyCodexModelsWithoutResponsesLite[target]; !targeted { continue @@ -2488,15 +2508,31 @@ func convertOpenAIModelListToCodexManifestForAccount(body []byte, account *Accou metadataModels[id] = capabilityModel capabilities := accountCodexToolCapabilities(account, capabilityModel) applyCodexToolCapabilities(capabilities, entry, true) - modelMetadata[id] = codexModelMetadataOverride{UpstreamModelMetadata: UpstreamModelMetadata{ - CodexToolCapabilities: capabilities, - }} + metadata := UpstreamModelMetadata{CodexToolCapabilities: capabilities} + if defaults, known := gpt6APIModelMetadata(account, capabilityModel); known { + // Raw provider declarations beat local API defaults, including an + // explicit false reasoning flag or a narrower modality list. + var rawEntry upstreamModelCapabilityEntry + if encoded, err := json.Marshal(entry); err == nil && json.Unmarshal(encoded, &rawEntry) == nil { + metadata = upstreamMetadataFromCapabilityEntry(id, rawEntry) + } + if snapshot, exists := account.GetUpstreamModelMetadata(capabilityModel); exists { + metadata, _ = mergeUpstreamModelMetadata(metadata, snapshot) + } + metadata, _ = mergeUpstreamModelMetadata(metadata, defaults) + metadata.CodexToolCapabilities = capabilities + } + modelMetadata[id] = codexModelMetadataOverride{UpstreamModelMetadata: metadata} } if len(modelIDs) == 0 { return body } imageInputModels := make(map[string]bool, len(modelIDs)) for _, modelID := range modelIDs { + if modalities := modelMetadata[modelID].InputModalities; len(modalities) > 0 { + imageInputModels[modelID] = stringSliceContains(modalities, "image") + continue + } if accountCodexModelSupportsImageInput(account, modelID) { imageInputModels[modelID] = true } @@ -2617,7 +2653,7 @@ func applySyncedAPIKeyCodexModelMetadata(body []byte, account *Account, overwrit metadata.Description = "" } - descriptor := newConfiguredCodexModelDescriptor(slug) + descriptor := newConfiguredCodexModelDescriptorForAccount(slug, account) applyUpstreamModelMetadataToCodexDescriptor( &descriptor, codexModelMetadataOverride{UpstreamModelMetadata: metadata}, @@ -2657,7 +2693,10 @@ func applySyncedAPIKeyCodexModelMetadata(body []byte, account *Account, overwrit } current, currentExists := model[field] current = bytes.TrimSpace(current) - if !overwriteLocalDefaults && currentExists && len(current) > 0 && !bytes.Equal(current, []byte("null")) { + // GPT-6 list conversion already merged live > synchronized > local + // fields. Reapplying a stale snapshot must not replace live values. + overwrite := overwriteLocalDefaults && !isOpenAIGPT6SolOrLunaModel(lookupModel) + if !overwrite && currentExists && len(current) > 0 && !bytes.Equal(current, []byte("null")) { continue } if bytes.Equal(current, bytes.TrimSpace(value)) { @@ -2742,7 +2781,7 @@ func completeAPIKeyCodexModelsManifestMetadata(body []byte, completeAll bool, ac continue } - descriptor := newConfiguredCodexModelDescriptor(slug) + descriptor := newConfiguredCodexModelDescriptorForAccount(slug, account) descriptor.SupportsSearchTool = shouldForwardOpenAIResponsesViaRawChatCompletions(account) if accountCodexModelSupportsImageInput(account, slug) { descriptor.InputModalities = []string{"text", "image"} diff --git a/backend/internal/service/openai_codex_request_compression.go b/backend/internal/service/openai_codex_request_compression.go index 77d6ebd52ffa..cbf72a23d3ec 100644 --- a/backend/internal/service/openai_codex_request_compression.go +++ b/backend/internal/service/openai_codex_request_compression.go @@ -130,5 +130,12 @@ func (s *OpenAIGatewayService) doOpenAICodexUpstream(req *http.Request, account if err != nil { return nil, err } - return s.httpUpstream.Do(wire, proxyURL, account.ID, account.Concurrency) + if response, handled, routingErr := s.doQualifiedCodexUpstream(wire, account, proxyURL); handled { + return response, routingErr + } + response, err := s.httpUpstream.Do(wire, proxyURL, account.ID, account.Concurrency) + if err == nil && isOpenAICodexTicketAccount(account) { + s.observeCodexWire(wire.Context(), account, wire, response, nil) + } + return response, err } diff --git a/backend/internal/service/openai_codex_ticket_test.go b/backend/internal/service/openai_codex_ticket_test.go index 5d168e442ded..77e968414da3 100644 --- a/backend/internal/service/openai_codex_ticket_test.go +++ b/backend/internal/service/openai_codex_ticket_test.go @@ -87,7 +87,7 @@ func ticketTestService(t *testing.T, cfg config.OpenAICodexTicketConfig, upstrea return &OpenAIGatewayService{cfg: &config.Config{Gateway: config.GatewayConfig{OpenAICodexTicket: cfg}}, httpUpstream: upstream, pluginManager: ticketTestManager(t, cfg, nil)} } func setTicketTestProjection(account *Account, model string, expiry time.Time) { - projection := PluginAccountProjection{Identity: CodexTicketAccountIdentity(account), Scheduling: map[string]extensionv1.SchedulingConstraint{model: {Model: model, Effect: "allow", Until: &expiry, Reason: "ticket_ready"}}} + projection := PluginAccountProjection{Identity: CodexTicketAccountIdentity(account), Scheduling: map[string]extensionv1.SchedulingConstraint{model: {Model: model, Effect: "allow", Until: &expiry, Reason: "routing_verified"}}} raw, _ := json.Marshal(projection) var value map[string]any _ = json.Unmarshal(raw, &value) diff --git a/backend/internal/service/openai_codex_transform.go b/backend/internal/service/openai_codex_transform.go index a6e0b1f13cea..9ba36c59c334 100644 --- a/backend/internal/service/openai_codex_transform.go +++ b/backend/internal/service/openai_codex_transform.go @@ -17,6 +17,8 @@ var ErrCindyResponsesImageToolModelNotFound = errors.New("cindy Responses image var codexModelMap = map[string]string{ "gpt-6-astra": "gpt-6-astra", + "gpt-6-sol": "gpt-6-sol", + "gpt-6-luna": "gpt-6-luna", "gpt-5.6-sol": "gpt-5.6-sol", "gpt-5.6-terra": "gpt-5.6-terra", "gpt-5.6-luna": "gpt-5.6-luna", diff --git a/backend/internal/service/openai_codex_turn_state.go b/backend/internal/service/openai_codex_turn_state.go index 88c38c7f55a5..6e67e81a8f22 100644 --- a/backend/internal/service/openai_codex_turn_state.go +++ b/backend/internal/service/openai_codex_turn_state.go @@ -34,10 +34,11 @@ func openAICodexTurnStateSeed(c *gin.Context) string { return "" } sessionID := extractClientSessionID(c.Request.Header) - if sessionID == "" { + turnID := codexRoutingTurnID(c) + if sessionID == "" || turnID == "" { return "" } - return strconv.FormatInt(getAPIKeyIDFromContext(c), 10) + "\x00" + sessionID + return strconv.FormatInt(getAPIKeyIDFromContext(c), 10) + "\x00" + sessionID + "\x00" + turnID } // relayOpenAICodexTurnState 将上游响应中的 turn-state 显式写入下游响应头， diff --git a/backend/internal/service/openai_codex_turn_state_test.go b/backend/internal/service/openai_codex_turn_state_test.go index 18f5bd0de7d5..17aa5eb02588 100644 --- a/backend/internal/service/openai_codex_turn_state_test.go +++ b/backend/internal/service/openai_codex_turn_state_test.go @@ -19,6 +19,7 @@ func newTurnStateTestContext(t *testing.T, apiKeyID int64, sessionID string) (*g rec := httptest.NewRecorder() c, _ := gin.CreateTestContext(rec) c.Request = httptest.NewRequest(http.MethodPost, "/v1/responses", nil) + c.Request.Header.Set(openAIWSTurnMetadataHeader, `{"turn_id":"turn-fixture"}`) if sessionID != "" { c.Request.Header.Set("session_id", sessionID) } @@ -30,11 +31,11 @@ func newTurnStateTestContext(t *testing.T, apiKeyID int64, sessionID string) (*g func TestOpenAICodexTurnStateSeed(t *testing.T) { c, _ := newTurnStateTestContext(t, 7, "sess-1") - require.Equal(t, "7\x00sess-1", openAICodexTurnStateSeed(c)) + require.Equal(t, "7\x00sess-1\x00turn-fixture", openAICodexTurnStateSeed(c)) // 连字符形式优先（Codex CLI 标准头） c.Request.Header.Set("session-id", "sess-hyphen") - require.Equal(t, "7\x00sess-hyphen", openAICodexTurnStateSeed(c)) + require.Equal(t, "7\x00sess-hyphen\x00turn-fixture", openAICodexTurnStateSeed(c)) // 无会话标识 → 不跟踪 cNoSession, _ := newTurnStateTestContext(t, 7, "") @@ -54,7 +55,7 @@ func TestRelayOpenAICodexTurnState_SetsHeaderAndRecordsProvenance(t *testing.T) require.Equal(t, "blob-A", c.Writer.Header().Get("X-Codex-Turn-State")) - raw, ok := svc.openaiCodexTurnStateOrigins.Load("7\x00sess-relay") + raw, ok := svc.openaiCodexTurnStateOrigins.Load("7\x00sess-relay\x00turn-fixture") require.True(t, ok) origin, ok := raw.(openAICodexTurnStateOrigin) require.True(t, ok) @@ -67,7 +68,7 @@ func TestRelayOpenAICodexTurnState_ClearsStaleValueWhenUpstreamAbsent(t *testing c, _ := newTurnStateTestContext(t, 7, "sess-stale") // 模拟上一 failover attempt 残留的值 c.Writer.Header().Set("X-Codex-Turn-State", "blob-old") - svc.openaiCodexTurnStateOrigins.Store("7\x00sess-stale", openAICodexTurnStateOrigin{ + svc.openaiCodexTurnStateOrigins.Store("7\x00sess-stale\x00turn-fixture", openAICodexTurnStateOrigin{ accountID: 42, expiresAt: time.Now().Add(time.Minute), }) @@ -75,7 +76,7 @@ func TestRelayOpenAICodexTurnState_ClearsStaleValueWhenUpstreamAbsent(t *testing svc.relayOpenAICodexTurnState(c, &Account{ID: 43}, http.Header{}) require.Empty(t, c.Writer.Header().Get("X-Codex-Turn-State")) - _, ok := svc.openaiCodexTurnStateOrigins.Load("7\x00sess-stale") + _, ok := svc.openaiCodexTurnStateOrigins.Load("7\x00sess-stale\x00turn-fixture") require.False(t, ok) } @@ -90,12 +91,12 @@ func TestStageOpenAICodexTurnState_StagedHeaders(t *testing.T) { stageOpenAICodexTurnState(&staged, upstream) require.NotNil(t, staged) require.Equal(t, "blob-B", staged.Get("X-Codex-Turn-State")) - _, noted := svc.openaiCodexTurnStateOrigins.Load("9\x00sess-staged") + _, noted := svc.openaiCodexTurnStateOrigins.Load("9\x00sess-staged\x00turn-fixture") require.False(t, noted, "暂存阶段不得记录溯源：该 attempt 仍可能 failover 丢弃") // 真正提交时才记录 svc.noteStagedOpenAICodexTurnStateCommitted(c, &Account{ID: 44}, staged) - raw, ok := svc.openaiCodexTurnStateOrigins.Load("9\x00sess-staged") + raw, ok := svc.openaiCodexTurnStateOrigins.Load("9\x00sess-staged\x00turn-fixture") require.True(t, ok) origin, ok := raw.(openAICodexTurnStateOrigin) require.True(t, ok) @@ -130,7 +131,7 @@ func TestStagedTurnState_AbandonedAttemptDoesNotPoisonProvenance(t *testing.T) { svc.guardOpenAICodexTurnStateEcho(c, &Account{ID: 52}, h) require.Equal(t, "blob-A", h.Get("x-codex-turn-state")) - raw, ok := svc.openaiCodexTurnStateOrigins.Load("11\x00sess-abandoned") + raw, ok := svc.openaiCodexTurnStateOrigins.Load("11\x00sess-abandoned\x00turn-fixture") require.True(t, ok) origin, ok := raw.(openAICodexTurnStateOrigin) require.True(t, ok) @@ -140,22 +141,22 @@ func TestStagedTurnState_AbandonedAttemptDoesNotPoisonProvenance(t *testing.T) { func TestNoteStagedOpenAICodexTurnStateCommitted_ClearsProvenanceWithoutState(t *testing.T) { svc := &OpenAIGatewayService{} c, _ := newTurnStateTestContext(t, 12, "sess-nostate") - svc.openaiCodexTurnStateOrigins.Store("12\x00sess-nostate", openAICodexTurnStateOrigin{ + svc.openaiCodexTurnStateOrigins.Store("12\x00sess-nostate\x00turn-fixture", openAICodexTurnStateOrigin{ accountID: 59, expiresAt: time.Now().Add(time.Minute), }) svc.noteStagedOpenAICodexTurnStateCommitted(c, &Account{ID: 60}, nil) - _, ok := svc.openaiCodexTurnStateOrigins.Load("12\x00sess-nostate") + _, ok := svc.openaiCodexTurnStateOrigins.Load("12\x00sess-nostate\x00turn-fixture") require.False(t, ok) - svc.openaiCodexTurnStateOrigins.Store("12\x00sess-nostate", openAICodexTurnStateOrigin{ + svc.openaiCodexTurnStateOrigins.Store("12\x00sess-nostate\x00turn-fixture", openAICodexTurnStateOrigin{ accountID: 59, expiresAt: time.Now().Add(time.Minute), }) svc.noteStagedOpenAICodexTurnStateCommitted(c, &Account{ID: 60}, http.Header{"X-Request-Id": []string{"rid"}}) - _, ok = svc.openaiCodexTurnStateOrigins.Load("12\x00sess-nostate") + _, ok = svc.openaiCodexTurnStateOrigins.Load("12\x00sess-nostate\x00turn-fixture") require.False(t, ok) } @@ -204,14 +205,14 @@ func TestGuardOpenAICodexTurnStateEcho(t *testing.T) { t.Run("expired_provenance_strips_echo_and_prunes", func(t *testing.T) { svc := &OpenAIGatewayService{} c, _ := newTurnStateTestContext(t, 7, "sess-g4") - svc.openaiCodexTurnStateOrigins.Store("7\x00sess-g4", openAICodexTurnStateOrigin{ + svc.openaiCodexTurnStateOrigins.Store("7\x00sess-g4\x00turn-fixture", openAICodexTurnStateOrigin{ accountID: 42, expiresAt: time.Now().Add(-time.Minute), }) h := newOutbound("blob-A") svc.guardOpenAICodexTurnStateEcho(c, &Account{ID: 43}, h) require.Empty(t, h.Get("x-codex-turn-state")) - _, ok := svc.openaiCodexTurnStateOrigins.Load("7\x00sess-g4") + _, ok := svc.openaiCodexTurnStateOrigins.Load("7\x00sess-g4\x00turn-fixture") require.False(t, ok) }) diff --git a/backend/internal/service/openai_gateway_cc_pipeline.go b/backend/internal/service/openai_gateway_cc_pipeline.go index 700d057a53a9..642909ada19e 100644 --- a/backend/internal/service/openai_gateway_cc_pipeline.go +++ b/backend/internal/service/openai_gateway_cc_pipeline.go @@ -215,6 +215,11 @@ func (s *OpenAIGatewayService) sendCCUpstreamRequest( // 字段，上游 400 "The `reasoning_content` in the thinking mode must be // passed back to the API"。在共用出站点补空格占位，真实明文不覆盖。 body = ensureDeepSeekChatReasoningPlaceholders(account, body) + var promptErr error + body, promptErr = s.finalizeBusinessPromptForSend(c, account, body, BusinessSystemPromptProtocolChat, isOpenAIResponsesCompactPath(c)) + if promptErr != nil { + return nil, promptErr + } upstreamCtx, releaseUpstreamCtx := detachUpstreamContext(ctx) upstreamReq, err := http.NewRequestWithContext(upstreamCtx, http.MethodPost, targetURL, bytes.NewReader(body)) releaseUpstreamCtx() diff --git a/backend/internal/service/openai_gateway_chat_completions.go b/backend/internal/service/openai_gateway_chat_completions.go index edc9f26e1073..ff079d750771 100644 --- a/backend/internal/service/openai_gateway_chat_completions.go +++ b/backend/internal/service/openai_gateway_chat_completions.go @@ -61,6 +61,7 @@ func (s *OpenAIGatewayService) ForwardAsChatCompletions( promptCacheKey string, defaultMappedModel string, ) (*OpenAIForwardResult, error) { + rememberPromptRequestedModel(c, body) pricingContext, pricingErr := CaptureCindyPricingContext(ctx, c, account) if pricingErr != nil { return nil, pricingErr diff --git a/backend/internal/service/openai_gateway_forward.go b/backend/internal/service/openai_gateway_forward.go index 9430146f4d40..3ffbfc0f9e10 100644 --- a/backend/internal/service/openai_gateway_forward.go +++ b/backend/internal/service/openai_gateway_forward.go @@ -20,6 +20,7 @@ import ( // Forward forwards request to OpenAI API func (s *OpenAIGatewayService) Forward(ctx context.Context, c *gin.Context, account *Account, body []byte) (_ *OpenAIForwardResult, forwardErr error) { + rememberPromptRequestedModel(c, body) if account != nil && IsCindyAPIKeyAccount(account.Platform, account.Type, account.Credentials) && IsImageGenerationIntent(openAIResponsesEndpoint, gjson.GetBytes(body, "model").String(), body) { bound, release, err := bindProcessExtensionContext(ctx, PlatformCindy, AccountTypeAPIKey, extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "image.responses.plan", AccountID: account.ID}) if err != nil { @@ -1625,6 +1626,10 @@ func (s *OpenAIGatewayService) buildUpstreamRequest(ctx context.Context, c *gin. return nil, fmt.Errorf("normalize compatible Responses reasoning summary: %w", err) } + body, err = s.finalizeBusinessPromptForSend(c, account, body, BusinessSystemPromptProtocolResponses, isOpenAIResponsesCompactPath(c)) + if err != nil { + return nil, err + } req, err := http.NewRequestWithContext(ctx, "POST", targetURL, bytes.NewReader(body)) if err != nil { return nil, err @@ -1664,6 +1669,8 @@ func (s *OpenAIGatewayService) buildUpstreamRequest(ctx context.Context, c *gin. // 客户端回带的 x-codex-turn-state 若已知由其他账号铸造（failover 换号）， // 剥离后再出站——异账号 blob 与本账号的（指纹收敛后）出站身份自相矛盾。 s.guardOpenAICodexTurnStateEcho(c, account, req.Header) + req = withCodexRoutingModel(req, extractOpenAICodexTicketModel(body)) + stageCodexRoutingTurn(c, body) if err := s.applyOpenAICodexTicket(ctx, account, extractOpenAICodexTicketModel(body), req.Header); err != nil { return nil, err } diff --git a/backend/internal/service/openai_gateway_messages.go b/backend/internal/service/openai_gateway_messages.go index 31e52668a270..f49f295c1292 100644 --- a/backend/internal/service/openai_gateway_messages.go +++ b/backend/internal/service/openai_gateway_messages.go @@ -33,6 +33,7 @@ func (s *OpenAIGatewayService) ForwardAsAnthropic( promptCacheKey string, defaultMappedModel string, ) (*OpenAIForwardResult, error) { + rememberPromptRequestedModel(c, body) pricingContext, pricingErr := CaptureCindyPricingContext(ctx, c, account) if pricingErr != nil { return nil, pricingErr @@ -425,6 +426,7 @@ func (s *OpenAIGatewayService) ForwardAsAnthropic( if compatTurnState != "" && upstreamReq.Header.Get("x-codex-turn-state") == "" { upstreamReq.Header.Set("x-codex-turn-state", compatTurnState) } + upstreamReq = withCodexRoutingModel(upstreamReq, upstreamModel) if err := s.applyOpenAICodexTicket(ctx, account, upstreamModel, upstreamReq.Header); err != nil { return nil, err } diff --git a/backend/internal/service/openai_gateway_passthrough.go b/backend/internal/service/openai_gateway_passthrough.go index debbb2e54c05..3d0aff9a88d1 100644 --- a/backend/internal/service/openai_gateway_passthrough.go +++ b/backend/internal/service/openai_gateway_passthrough.go @@ -791,6 +791,10 @@ func (s *OpenAIGatewayService) buildUpstreamRequestOpenAIPassthrough( return nil, fmt.Errorf("normalize compatible Responses reasoning summary: %w", err) } + body, err = s.finalizeBusinessPromptForSend(c, account, body, BusinessSystemPromptProtocolResponses, isOpenAIResponsesCompactPath(c)) + if err != nil { + return nil, err + } req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, bytes.NewReader(body)) if err != nil { return nil, err @@ -814,6 +818,8 @@ func (s *OpenAIGatewayService) buildUpstreamRequestOpenAIPassthrough( // 客户端回带的 x-codex-turn-state 若已知由其他账号铸造（failover 换号）， // 剥离后再出站（openai_codex_turn_state.go）。 s.guardOpenAICodexTurnStateEcho(c, account, req.Header) + req = withCodexRoutingModel(req, extractOpenAICodexTicketModel(body)) + stageCodexRoutingTurn(c, body) if err := s.applyOpenAICodexTicket(ctx, account, extractOpenAICodexTicketModel(body), req.Header); err != nil { return nil, err } diff --git a/backend/internal/service/openai_gateway_request_body.go b/backend/internal/service/openai_gateway_request_body.go index 7272a42c819e..ed0ee47fa652 100644 --- a/backend/internal/service/openai_gateway_request_body.go +++ b/backend/internal/service/openai_gateway_request_body.go @@ -2395,7 +2395,7 @@ func normalizeOpenAIReasoningEffortForModel(raw, model string) string { // has a distinct max level. Only explicit cross-protocol adapters may use this // capability hint; native parameter/usage extraction must preserve wire values. func supportsOpenAIReasoningEffortMax(model string) bool { - if isOpenAIGPT6AstraModel(model) || isOpenAIGPT56Model(model) { + if isOpenAIGPT6AstraModel(model) || isOpenAIGPT6SolOrLunaModel(model) || isOpenAIGPT56Model(model) { return true } diff --git a/backend/internal/service/openai_gateway_turn_state_commit_test.go b/backend/internal/service/openai_gateway_turn_state_commit_test.go index 97108b491e9a..95dfcf5f8343 100644 --- a/backend/internal/service/openai_gateway_turn_state_commit_test.go +++ b/backend/internal/service/openai_gateway_turn_state_commit_test.go @@ -25,6 +25,7 @@ func newOpenAITurnStateCommitContext(t *testing.T, writer gin.ResponseWriter) (* c, _ := gin.CreateTestContext(writer) c.Request = httptest.NewRequest(http.MethodPost, "/v1/responses", nil) c.Request.Header.Set("session_id", "sess-http-commit") + c.Request.Header.Set(openAIWSTurnMetadataHeader, `{"turn_id":"turn-fixture"}`) c.Set("api_key", &APIKey{ID: 801}) return c, openAICodexTurnStateSeed(c) } diff --git a/backend/internal/service/openai_gpt6_models.go b/backend/internal/service/openai_gpt6_models.go new file mode 100644 index 000000000000..af31f1183e03 --- /dev/null +++ b/backend/internal/service/openai_gpt6_models.go @@ -0,0 +1,61 @@ +package service + +import ( + "encoding/json" + + "github.com/Wei-Shaw/sub2api/internal/pkg/openai" +) + +// gpt6APIModelMetadata supplies release-owned API defaults only when an API-key +// catalog omits them. It is never persisted as an upstream observation. +func gpt6APIModelMetadata(account *Account, model string) (UpstreamModelMetadata, bool) { + // IsOpenAIApiKey checks the wire protocol, which Cindy also uses. Product + // defaults belong only to ordinary OpenAI accounts, not protected catalogs. + if account == nil || account.Platform != PlatformOpenAI || !account.IsOpenAIApiKey() || + IsModelContextCapacityProtected(account) || !isOpenAIGPT6SolOrLunaModel(model) { + return UpstreamModelMetadata{}, false + } + reasoning := true + return UpstreamModelMetadata{ + ID: model, Reasoning: &reasoning, DefaultReasoningLevel: "medium", + SupportedReasoningLevels: openai.GPT6APIReasoningEfforts(), + InputModalities: []string{"text", "image"}, + ContextWindow: openai.GPT6APIContextWindow, MaxContextWindow: openai.GPT6APIContextWindow, + MaxOutputTokens: openai.GPT6APIMaxOutputTokens, + CodexToolCapabilities: map[string]json.RawMessage{ + "use_responses_lite": json.RawMessage("false"), + "tool_mode": json.RawMessage("null"), + "multi_agent_reasoning_effort": json.RawMessage("null"), + }, + }, true +} + +func newConfiguredCodexModelDescriptorForAccount(model string, account *Account) configuredCodexModelDescriptor { + descriptor := newConfiguredCodexModelDescriptor(model) + if metadata, ok := gpt6APIModelMetadata(account, model); ok { + applyUpstreamModelMetadataToCodexDescriptor(&descriptor, codexModelMetadataOverride{UpstreamModelMetadata: metadata}) + } + return descriptor +} + +func gpt6AccountModelMetadata(account *Account, model string) (UpstreamModelMetadata, bool) { + if metadata, ok := gpt6APIModelMetadata(account, model); ok { + return metadata, true + } + if account == nil || account.Platform != PlatformOpenAI || !account.IsOpenAIOAuthLike() || !isOpenAIGPT6SolOrLunaModel(model) { + return UpstreamModelMetadata{}, false + } + reasoning := true + levels := configuredCodexGPTReasoningLevels(model) + efforts := make([]string, 0, len(levels)) + for _, level := range levels { + efforts = append(efforts, level.Effort) + } + capacity := protectedAccountModelContextCapacity(account, model, nil) + return UpstreamModelMetadata{ + ID: model, Reasoning: &reasoning, DefaultReasoningLevel: "medium", + SupportedReasoningLevels: efforts, InputModalities: []string{"text", "image"}, + ContextWindow: capacity.ContextWindow, MaxContextWindow: capacity.MaxContextWindow, + MaxOutputTokens: capacity.MaxOutputTokens, + }, true +} diff --git a/backend/internal/service/openai_gpt6_models_test.go b/backend/internal/service/openai_gpt6_models_test.go new file mode 100644 index 000000000000..db8d65655c3d --- /dev/null +++ b/backend/internal/service/openai_gpt6_models_test.go @@ -0,0 +1,191 @@ +package service + +import ( + "context" + "encoding/json" + "testing" + + "github.com/Wei-Shaw/sub2api/internal/pkg/apicompat" + "github.com/Wei-Shaw/sub2api/internal/pkg/openai" + "github.com/stretchr/testify/require" + "github.com/tidwall/gjson" +) + +func TestGPT6NamedModelRoutingAndWireEffort(t *testing.T) { + for _, model := range []string{"gpt-6-sol", "gpt-6-luna"} { + require.Equal(t, model, normalizeCodexModel("openai/"+model)) + require.Equal(t, model, normalizeKnownOpenAICodexModel(model+"-max")) + require.False(t, isOpenAIGPT6AstraModel(model)) + for _, effort := range []string{"none", "max"} { + request := map[string]any{"model": model + "-" + effort, "reasoning": map[string]any{"summary": "none"}} + require.True(t, applyOpenAIModelReasoningAlias(request)) + require.Equal(t, model, request["model"]) + require.Equal(t, effort, request["reasoning"].(map[string]any)["effort"]) + request = map[string]any{"model": model + "-" + effort, "reasoning": map[string]any{"effort": "high"}} + require.True(t, applyOpenAIModelReasoningAlias(request)) + require.Equal(t, "high", request["reasoning"].(map[string]any)["effort"]) + } + req := &apicompat.AnthropicRequest{OutputConfig: &apicompat.AnthropicOutputConfig{Effort: "max"}} + require.Equal(t, "max", openAICompatAnthropicReasoningEffort(req, model, "xhigh")) + } + for _, unknown := range []string{"gpt-6-future", "gpt-6-solstice", "gpt-6-luna-2099-01-01"} { + require.Equal(t, unknown, normalizeCodexModel(unknown)) + require.Empty(t, normalizeKnownOpenAICodexModel(unknown)) + } + require.Equal(t, "gpt-6-astra", normalizeCodexModel("gpt-6")) +} + +func TestGPT6CodexReferenceAndAPICatalogDefaults(t *testing.T) { + account := &Account{Platform: PlatformOpenAI, Type: AccountTypeAPIKey, + Credentials: map[string]any{"base_url": "https://api.openai.com"}} + for _, model := range []string{"gpt-6-sol", "gpt-6-luna"} { + descriptor := newConfiguredCodexModelDescriptor(model) + require.Equal(t, openai.GPT6CodexContextWindow, descriptor.ContextWindow) + require.Equal(t, openai.GPT6CodexMaxContextWindow, descriptor.MaxContextWindow) + require.Nil(t, descriptor.AutoCompactTokenLimit) + require.Nil(t, descriptor.MultiAgentReasoningEffort) + require.Equal(t, "v2", descriptor.MultiAgentVersion) + require.Equal(t, "0.155.0", descriptor.MinimalClientVersion) + require.Equal(t, "medium", *descriptor.DefaultReasoningLevel) + var efforts []string + for _, level := range descriptor.SupportedReasoningLevels { + efforts = append(efforts, level.Effort) + } + require.Equal(t, model == "gpt-6-sol", stringSliceContains(efforts, "ultra")) + require.Contains(t, efforts, "max") + require.NotContains(t, efforts, "none") + require.Equal(t, []string{"text", "image"}, descriptor.InputModalities) + require.Equal(t, "priority", descriptor.ServiceTiers[0].ID) + + body := convertOpenAIModelListToCodexManifestForAccount([]byte(`{"data":[{"id":"`+model+`"}]}`), account) + require.Equal(t, openai.GPT6APIContextWindow, gjson.GetBytes(body, "models.0.context_window").Int()) + require.Equal(t, openai.GPT6APIContextWindow, gjson.GetBytes(body, "models.0.max_context_window").Int()) + require.Equal(t, "medium", gjson.GetBytes(body, "models.0.default_reasoning_level").String()) + models := decodeCodexManifestModels(t, body) + require.Equal(t, openai.GPT6APIReasoningEfforts(), effortsFromManifestModel(t, models[0])) + require.False(t, gjson.GetBytes(body, "models.0.use_responses_lite").Bool()) + } +} + +func TestGPT6CapacityKeepsProductAndUpstreamPrecedence(t *testing.T) { + for _, model := range []string{"gpt-6-sol", "gpt-6-luna"} { + t.Run(model, func(t *testing.T) { + api := &Account{Platform: PlatformOpenAI, Type: AccountTypeAPIKey, Credentials: map[string]any{"base_url": "https://api.openai.com"}} + reference := LookupOfficialModelContextCapacity(api, "openai/"+model) + require.NotNil(t, reference) + require.EqualValues(t, 1050000, reference.ContextWindow) + require.EqualValues(t, 128000, reference.MaxOutputTokens) + require.Zero(t, reference.MaxInputTokens) + require.Equal(t, openai.GPT6CodexReferenceSource, reference.Reference.SourceURL) + require.Nil(t, LookupOfficialModelContextCapacity(api, model+"-2099-01-01")) + declared := &ModelContextCapacity{ContextWindow: 200000, MaxContextWindow: 400000, MaxOutputTokens: 64000} + require.EqualValues(t, 1050000, NewAccountModelContextCapacityResolver(api)(model, declared).ContextWindow) + api.Credentials["base_url"] = "https://relay.example.test/v1" + relay := NewAccountModelContextCapacityResolver(api)(model, declared) + require.EqualValues(t, 200000, relay.ContextWindow) + require.EqualValues(t, 64000, relay.MaxOutputTokens) + require.Equal(t, "upstream", relay.Source) + api.Extra = map[string]any{ModelContextOverridesExtraKey: map[string]int64{model: 512000}} + require.EqualValues(t, 512000, NewAccountModelContextCapacityResolver(api)(model, declared).ContextWindow) + + oauth := &Account{Platform: PlatformOpenAI, Type: AccountTypeOAuth} + fallback := ResolveAccountModelContextCapacity(oauth, model) + require.Equal(t, "protected", fallback.Source) + require.Equal(t, "codex_catalog_reference", fallback.Reason) + require.EqualValues(t, 272000, fallback.ContextWindow) + require.EqualValues(t, 872000, fallback.MaxContextWindow) + require.Zero(t, fallback.MaxOutputTokens, "API output limits must not be presented as OAuth observations") + rows := BuildAccountModelContextCapacityRows(oauth, []string{model}) + require.Len(t, rows, 1) + require.False(t, rows[0].Editable) + require.NotNil(t, rows[0].Official.Reference) + oauth.SetUpstreamModelContextCapacitySnapshot(UpstreamModelContextCapacitySnapshot{Models: map[string]ModelContextCapacity{model: {ContextWindow: 300000, MaxContextWindow: 900000, MaxOutputTokens: 48000}}}) + observed := ResolveAccountModelContextCapacity(oauth, model) + require.EqualValues(t, 300000, observed.ContextWindow) + require.EqualValues(t, 900000, observed.MaxContextWindow) + require.EqualValues(t, 48000, observed.MaxOutputTokens) + require.NotEqual(t, "codex_catalog_reference", observed.Reason) + legacy := &Account{Platform: PlatformOpenAI, Type: AccountTypeOAuth} + legacy.SetUpstreamModelMetadataSnapshot(UpstreamModelMetadataSnapshot{Source: "upstream", Models: map[string]UpstreamModelMetadata{ + model: {ID: model, ContextWindow: 320000, MaxContextWindow: 920000}, + }}) + require.EqualValues(t, 920000, ResolveAccountModelContextCapacity(legacy, model).MaxContextWindow) + live := NewAccountModelContextCapacityResolver(oauth)(model, declared) + require.EqualValues(t, 200000, live.ContextWindow) + fields := map[string]json.RawMessage{"context_window": json.RawMessage("200000"), "auto_compact_token_limit": json.RawMessage("150000")} + require.False(t, ApplyModelContextCapacityToFields(fields, live, true)) + require.Equal(t, json.RawMessage("150000"), fields["auto_compact_token_limit"]) + }) + } +} + +func TestGPT6APIKeyLiteAndNativeReasoning(t *testing.T) { + api := &Account{Platform: PlatformOpenAI, Type: AccountTypeAPIKey} + oauth := &Account{Platform: PlatformOpenAI, Type: AccountTypeOAuth} + for _, model := range []string{"gpt-6-sol", "gpt-6-luna"} { + body := []byte(`{"models":[{"slug":"openai/` + model + `","use_responses_lite":true,"context_window":333000,"max_context_window":777000,"auto_compact_token_limit":222000}]}`) + adjusted, err := adjustAPIKeyCodexModelsManifest(body, api) + require.NoError(t, err) + require.False(t, gjson.GetBytes(adjusted, "models.0.use_responses_lite").Bool()) + manifest := &OpenAIModelsResponse{Body: body} + require.NoError(t, (&OpenAIGatewayService{}).CompleteAPIKeyCodexModelsManifestForClient(manifest, oauth)) + require.Equal(t, body, manifest.Body, "OAuth raw manifest must not receive API-key adjustments") + levels, defaultLevel := AccountTestReasoningOptions(api, model) + require.Equal(t, openai.GPT6APIReasoningEfforts(), levels) + require.Equal(t, "medium", defaultLevel) + levels, _ = AccountTestReasoningOptions(oauth, model) + require.Contains(t, levels, "max") + require.NotContains(t, levels, "ultra", "delegation is not an account-test wire effort") + } +} + +func TestGPT6ProviderMetadataOverridesAPIDefaults(t *testing.T) { + account := &Account{Platform: PlatformOpenAI, Type: AccountTypeAPIKey, Credentials: map[string]any{"base_url": "https://relay.example.test"}} + reasoning := true + account.SetUpstreamModelMetadataSnapshot(UpstreamModelMetadataSnapshot{Source: "upstream", Models: map[string]UpstreamModelMetadata{ + "gpt-6-sol": {ID: "gpt-6-sol", Reasoning: &reasoning, DefaultReasoningLevel: "max", SupportedReasoningLevels: []string{"high", "max"}, InputModalities: []string{"text", "image"}, ContextWindow: 100000}, + }}) + body := []byte(`{"data":[{"id":"gpt-6-sol","reasoning":false,"input_modalities":["text"],"context_window":64000,"max_output_tokens":8000,"auto_compact_token_limit":50000,"supports_search_tool":false}]}`) + converted := convertOpenAIModelListToCodexManifestForAccount(body, account) + manifest := &OpenAIModelsResponse{Body: converted, upstreamSourceBody: body, convertedFromOpenAIModelList: true} + require.NoError(t, (&OpenAIGatewayService{}).CompleteAPIKeyCodexModelsManifestForClient(manifest, account)) + converted = manifest.Body + model := decodeCodexManifestModels(t, converted)[0] + levels := effortsFromManifestModel(t, model) + for _, effort := range []string{"max", "ultra"} { + require.NotContains(t, levels, effort) + } + require.Equal(t, []any{"text"}, model["input_modalities"]) + require.EqualValues(t, 64000, model["context_window"]) + require.EqualValues(t, 8000, model["max_output_tokens"]) + require.EqualValues(t, 50000, model["auto_compact_token_limit"]) + require.Equal(t, false, model["supports_search_tool"]) + for _, protected := range []*Account{ + {Platform: PlatformCindy, Type: AccountTypeAPIKey}, + {Platform: PlatformCindy, Type: AccountTypeAPIKey, Credentials: map[string]any{"base_url": "https://api.laxarouter.ai"}}, + {Platform: PlatformOpenAI, Type: AccountTypeAPIKey, ProviderProfile: ProviderProfileCindyLaxaV1}, + {Platform: PlatformOpenAI, Type: AccountTypeAPIKey, Credentials: map[string]any{"base_url": "https://api.laxarouter.ai"}}, + } { + _, projected := gpt6APIModelMetadata(protected, "gpt-6-luna") + require.False(t, projected, "a shared wire protocol cannot expand a protected provider's inventory") + } +} + +func TestGPT6ConfiguredOAuthCatalogUsesObservedCapacity(t *testing.T) { + const groupID int64 = 764 + account := Account{ID: 25, Platform: PlatformOpenAI, Type: AccountTypeOAuth, + Credentials: map[string]any{"model_mapping": map[string]any{"gpt-6-sol": "gpt-6-sol"}}} + account.SetUpstreamModelContextCapacitySnapshot(UpstreamModelContextCapacitySnapshot{ + Models: map[string]ModelContextCapacity{"gpt-6-sol": {ContextWindow: 320000, MaxContextWindow: 940000}}, + }) + svc := &OpenAIGatewayService{accountRepo: codexModelsVisibilityAccountRepo{byGroup: map[int64][]Account{groupID: {account}}}} + manifest, configured, err := svc.BuildGroupConfiguredCodexModelsManifest(context.Background(), &Group{ID: groupID, Platform: PlatformOpenAI}, "") + require.NoError(t, err) + require.True(t, configured) + model := decodeCodexManifestModels(t, manifest.Body)[0] + require.Equal(t, "gpt-6-sol", model["slug"]) + require.EqualValues(t, 320000, model["context_window"]) + require.EqualValues(t, 940000, model["max_context_window"]) + require.Nil(t, model["auto_compact_token_limit"]) + require.Equal(t, true, model["use_responses_lite"]) +} diff --git a/backend/internal/service/openai_gpt6_pricing.go b/backend/internal/service/openai_gpt6_pricing.go new file mode 100644 index 000000000000..03ea11eb6a3e --- /dev/null +++ b/backend/internal/service/openai_gpt6_pricing.go @@ -0,0 +1,24 @@ +package service + +// Standard API rates verified on 2026-09-23 at: +// https://developers.openai.com/api/docs/models/gpt-6-sol +// https://developers.openai.com/api/docs/models/gpt-6-luna +// Cache writes are 1.25x input; Fast is 2x. The >272K surcharge applies to +// the entire request's input/cache (2x) and output (1.5x). +var ( + openAIGPT6SolFallbackPricing = newGPT6NamedFallbackPricing(2e-6, 10e-6) + openAIGPT6LunaFallbackPricing = newGPT6NamedFallbackPricing(0.1e-6, 0.5e-6) +) + +func newGPT6NamedFallbackPricing(input, output float64) *LiteLLMModelPricing { + return &LiteLLMModelPricing{ + InputCostPerToken: input, InputCostPerTokenPriority: input * 2, + OutputCostPerToken: output, OutputCostPerTokenPriority: output * 2, + CacheCreationInputTokenCost: input * 1.25, CacheCreationInputTokenCostPriority: input * 2.5, + CacheReadInputTokenCost: input * 0.1, CacheReadInputTokenCostPriority: input * 0.2, + LongContextInputTokenThreshold: 272000, + LongContextInputCostMultiplier: 2, LongContextOutputCostMultiplier: 1.5, + SupportsServiceTier: true, SupportsPromptCaching: true, + LiteLLMProvider: "openai", Mode: "chat", + } +} diff --git a/backend/internal/service/openai_gpt6_pricing_test.go b/backend/internal/service/openai_gpt6_pricing_test.go new file mode 100644 index 000000000000..ff427a34a106 --- /dev/null +++ b/backend/internal/service/openai_gpt6_pricing_test.go @@ -0,0 +1,103 @@ +package service + +import ( + "os" + "path/filepath" + "testing" + + "github.com/Wei-Shaw/sub2api/internal/config" + "github.com/stretchr/testify/require" +) + +func TestGPT6NamedPriceCardsAndIsolatedFallbacks(t *testing.T) { + body, err := os.ReadFile(filepath.Join("..", "..", "resources", "model-pricing", "model_prices_and_context_window.json")) + require.NoError(t, err) + parser := &PricingService{} + data, err := parser.parsePricingData(body) + require.NoError(t, err) + bundled := &PricingService{pricingData: data} + for _, model := range []string{"gpt-6-sol", "gpt-6-luna"} { + require.Contains(t, bundled.ListModelNamesByProvider("openai"), model) + } + misleading := &LiteLLMModelPricing{InputCostPerToken: 100, OutputCostPerToken: 200} + for _, tc := range []struct { + model string + input, output, cacheRead, cacheWrite float64 + }{ + {"gpt-6-sol", 2e-6, 10e-6, 0.2e-6, 2.5e-6}, + {"gpt-6-luna", 0.1e-6, 0.5e-6, 0.01e-6, 0.125e-6}, + } { + for name, catalog := range map[string]*PricingService{ + "bundled": bundled, + "missing mirror": {pricingData: map[string]*LiteLLMModelPricing{"gpt-6": misleading, "gpt-6-astra": misleading, "gpt-5.4": misleading}}, + "billing fallback": nil, + } { + t.Run(tc.model+"/"+name, func(t *testing.T) { + svc := NewBillingService(&config.Config{}, catalog) + pricing, err := svc.GetModelPricing(tc.model) + require.NoError(t, err) + require.InDelta(t, tc.input, pricing.InputPricePerToken, 1e-15) + require.InDelta(t, tc.output, pricing.OutputPricePerToken, 1e-15) + require.InDelta(t, tc.cacheRead, pricing.CacheReadPricePerToken, 1e-15) + require.InDelta(t, tc.cacheWrite, pricing.CacheCreationPricePerToken, 1e-15) + require.InDelta(t, tc.input*2, pricing.InputPricePerTokenPriority, 1e-15) + require.InDelta(t, tc.output*2, pricing.OutputPricePerTokenPriority, 1e-15) + require.Equal(t, 272000, pricing.LongContextInputThreshold) + require.Equal(t, 2.0, pricing.LongContextInputMultiplier) + require.Equal(t, 1.5, pricing.LongContextOutputMultiplier) + alias, err := svc.GetModelPricing("openai/" + tc.model + "-max") + require.NoError(t, err) + require.Equal(t, pricing.InputPricePerToken, alias.InputPricePerToken) + }) + } + } + svc := &PricingService{pricingData: map[string]*LiteLLMModelPricing{"gpt-6": misleading, "gpt-6-astra": misleading, "gpt-5.4": misleading}} + for _, unknown := range []string{"gpt-6-future", "gpt-6-solstice", "gpt-6-luna-2099-01-01"} { + require.Nil(t, svc.GetModelPricing(unknown), unknown) + } + custom := &LiteLLMModelPricing{InputCostPerToken: 7e-6} + svc.pricingData["gpt-6-sol-provider"] = custom + require.Same(t, custom, svc.GetModelPricing("gpt-6-sol-provider"), "explicit provider price cards remain authoritative") +} + +func TestGPT6NamedPriceBoundaryTiersAndManualOverrides(t *testing.T) { + for _, tc := range []struct { + model string + input, output, cacheRead, cacheWrite float64 + }{ + {"gpt-6-sol", 2e-6, 10e-6, 0.2e-6, 2.5e-6}, + {"gpt-6-luna", 0.1e-6, 0.5e-6, 0.01e-6, 0.125e-6}, + } { + svc := NewBillingService(&config.Config{}, nil) + for _, inputTotal := range []int{272000, 272001} { + for _, tier := range []struct { + name string + scale float64 + }{{"", 1}, {"priority", 2}, {"flex", 0.5}} { + tokens := UsageTokens{InputTokens: 100000, CacheCreationTokens: 100000, CacheReadTokens: inputTotal - 200000, OutputTokens: 10} + cost, err := svc.CalculateCostWithServiceTier(tc.model, tokens, 1, tier.name) + require.NoError(t, err) + long := inputTotal > 272000 + require.Equal(t, long, cost.LongContextBillingApplied) + inScale, outScale := tier.scale, tier.scale + if long { + inScale *= 2 + outScale *= 1.5 + } + require.InDelta(t, 100000*tc.input*inScale, cost.InputCost, 1e-12) + require.InDelta(t, 100000*tc.cacheWrite*inScale, cost.CacheCreationCost, 1e-12) + require.InDelta(t, float64(inputTotal-200000)*tc.cacheRead*inScale, cost.CacheReadCost, 1e-12) + require.InDelta(t, 10*tc.output*outScale, cost.OutputCost, 1e-12) + } + } + input, output, zero := 17e-6, 19e-6, 0.0 + manual, err := svc.GetModelPricingWithChannel(tc.model, &ChannelModelPricing{InputPrice: &input, OutputPrice: &output, CacheWritePrice: &zero}) + require.NoError(t, err) + require.Equal(t, input, manual.InputPricePerToken) + require.Equal(t, output, manual.OutputPricePerToken) + require.Zero(t, manual.CacheCreationPricePerToken) + original, err := svc.GetModelPricing(tc.model) + require.NoError(t, err) + require.Equal(t, tc.input, original.InputPricePerToken) + } +} diff --git a/backend/internal/service/openai_model_alias.go b/backend/internal/service/openai_model_alias.go index f34a28abac9f..5711a283ffa7 100644 --- a/backend/internal/service/openai_model_alias.go +++ b/backend/internal/service/openai_model_alias.go @@ -27,6 +27,9 @@ func normalizeKnownOpenAICodexModel(model string) string { if normalized == "" { return "" } + if named := openai.GPT6NamedModel(normalized); named != "" { + return named + } if mapped := getNormalizedCodexModel(normalized); mapped != "" { return mapped @@ -40,6 +43,8 @@ func normalizeKnownOpenAICodexModel(model string) string { switch { case normalized == "gpt-6" || normalized == "gpt-6-astra": return "gpt-6-astra" + case strings.HasPrefix(normalized, "gpt-6-"): + return "" case strings.Contains(normalized, "gpt-5.6-sol"): return "gpt-5.6-sol" case strings.Contains(normalized, "gpt-5.6-terra"): @@ -106,6 +111,10 @@ func isOpenAIGPT6AstraModel(model string) bool { return normalized == "gpt-6" || normalized == "gpt-6-astra" || strings.HasPrefix(normalized, "gpt-6-astra-") } +func isOpenAIGPT6SolOrLunaModel(model string) bool { + return openai.GPT6NamedModel(model) != "" +} + func appendUsageBillingModelCandidate(candidates []string, seen map[string]struct{}, model string) []string { trimmed := strings.TrimSpace(model) if trimmed == "" { diff --git a/backend/internal/service/openai_plugin_transport.go b/backend/internal/service/openai_plugin_transport.go index bf5c8e54f2fc..1e7d52084eab 100644 --- a/backend/internal/service/openai_plugin_transport.go +++ b/backend/internal/service/openai_plugin_transport.go @@ -48,7 +48,9 @@ func (s *AccountTestService) doOpenAIAccountTestUpstream( account *Account, useTLSFallback bool, ) (*http.Response, error) { - if s.pluginManager != nil { + model, _ := request.Context().Value(codexRoutingModelKey{}).(string) + qualifiedRoute := s.openAIGatewayService != nil && s.openAIGatewayService.codexRoutingApplies(account, model) + if s.pluginManager != nil && !qualifiedRoute { response, handled, err := s.pluginManager.RoundTripOpenAIOAuth(request.Context(), request, proxyURL, account) if handled { return response, err @@ -63,7 +65,12 @@ func (s *AccountTestService) doOpenAIAccountTestUpstream( if observer := codexWireObserverFromContext(wire.Context()); observer != nil { observer(wire) } - if useTLSFallback { + if s.openAIGatewayService != nil && account.IsOpenAIOAuthLike() { + if response, handled, routingErr := s.openAIGatewayService.doQualifiedCodexUpstream(wire, account, proxyURL); handled { + return response, routingErr + } + } + if useTLSFallback && !account.IsOpenAIOAuthLike() { return s.httpUpstream.DoWithTLS( wire, proxyURL, @@ -72,5 +79,9 @@ func (s *AccountTestService) doOpenAIAccountTestUpstream( s.tlsFPProfileService.ResolveTLSProfile(account), ) } - return s.httpUpstream.Do(wire, proxyURL, account.ID, account.Concurrency) + response, err := s.httpUpstream.Do(wire, proxyURL, account.ID, account.Concurrency) + if err == nil && isOpenAICodexTicketAccount(account) && s.openAIGatewayService != nil { + s.openAIGatewayService.observeCodexWire(wire.Context(), account, wire, response, nil) + } + return response, err } diff --git a/backend/internal/service/openai_request_integrity.go b/backend/internal/service/openai_request_integrity.go index 7500cd6466fe..a4a92045a127 100644 --- a/backend/internal/service/openai_request_integrity.go +++ b/backend/internal/service/openai_request_integrity.go @@ -219,7 +219,11 @@ func (s *OpenAIGatewayService) checkRequestIntegrity(c *gin.Context, account *Ac "account_id", account.ID, "path", path, "stage", stage, "reason", "body_too_large") return nil } - field, err := compareRequestIntegrity(account, opts, original, final) + cleanFinal, promptErr := restorePromptRulesForIntegrity(c, final) + if promptErr != nil { + return promptErr + } + field, err := compareRequestIntegrity(account, opts, original, cleanFinal) if err != nil { // One side is not a JSON object; report the shape, never the bytes. field = "json" diff --git a/backend/internal/service/openai_ws_forwarder_ingress.go b/backend/internal/service/openai_ws_forwarder_ingress.go index c065299f56a6..a99be9a22bb5 100644 --- a/backend/internal/service/openai_ws_forwarder_ingress.go +++ b/backend/internal/service/openai_ws_forwarder_ingress.go @@ -138,8 +138,14 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( } } strictCindyContinuation := IsCindyAPIKeyAccount(account.Platform, account.Type, account.Credentials) || legacyLaxaContinuation - forceHTTPBridge := account.Platform == PlatformGrok + // A routing Cookie qualification belongs to the verified HTTP connection. + // A new native WS socket cannot inherit that connection's exit evidence. + _, cookieRoutingModel := resolveOpenAIForwardMappedModels(account, gjson.GetBytes(firstClientMessage, "model").String(), false) + forceHTTPBridge := account.Platform == PlatformGrok || s.codexRoutingApplies(account, cookieRoutingModel) modeRouterV2Enabled := s != nil && s.cfg != nil && s.cfg.Gateway.OpenAIWS.ModeRouterV2Enabled + if modeRouterV2Enabled && account.Platform != PlatformGrok && account.ResolveOpenAIResponsesWebSocketV2Mode(s.cfg.Gateway.OpenAIWS.IngressModeDefault) == OpenAIWSIngressModeOff { + return NewOpenAIWSClientCloseError(coderws.StatusPolicyViolation, "websocket mode is disabled for this account", nil) + } ingressMode := OpenAIWSIngressModeCtxPool if modeRouterV2Enabled && !forceHTTPBridge { ingressMode = account.ResolveOpenAIResponsesWebSocketV2Mode(s.cfg.Gateway.OpenAIWS.IngressModeDefault) @@ -201,6 +207,9 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( if forceHTTPBridge { wsHost = "xai-http-bridge" wsPath = "/v1/responses" + if account.Platform != PlatformGrok { + wsHost, wsPath = "qualified-http-bridge", "/backend-api/codex/responses" + } } else { var err error wsURL, err = s.buildOpenAIResponsesWSURL(account) @@ -229,6 +238,7 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( requestedReasoningEffort *string } ingressSessionOriginalModel := "" + nativeRoutingConnection := false applyPayloadMutation := func(current []byte, path string, value any) ([]byte, error) { next, err := sjson.SetBytes(current, path, value) @@ -533,8 +543,9 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( } normalized = policyApplied beginBusinessSystemPromptRequestTurn(c) + rememberPromptRequestedModel(c, raw) businessPromptApplied := false - if updatedPromptPayload, application, promptErr := s.applyBusinessSystemPromptForRequest( + if updatedPromptPayload, application, promptErr := s.prepareBusinessPromptWSIngress( c, normalized, account, BusinessSystemPromptProtocolResponses, isOpenAIResponsesCompactPath(c), ); promptErr != nil { if errors.Is(promptErr, ErrBusinessSystemPromptUnavailable) { @@ -595,6 +606,11 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( return openAIWSClientPayload{}, NewOpenAIWSClientCloseError(coderws.StatusPolicyViolation, integrityErr.Error(), integrityErr) } ingressSessionOriginalModel = originalModel + if nativeRoutingConnection { + if routingErr := s.guardCodexRoutingNativeModel(account, upstreamModel); routingErr != nil { + return openAIWSClientPayload{}, routingErr + } + } return openAIWSClientPayload{ payloadRaw: normalized, @@ -757,7 +773,14 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( bridgeReplayVerified := false bridgeBaselineResponseID := "" bridgeOwnedTurnState := openAIWSHTTPBridgeTurnState{accountID: account.ID} + bridgeLogicalTurn := "" for turn := 1; ; turn++ { + stageCodexRoutingTurn(c, currentBridgePayload.payloadRaw) + currentLogicalTurn := codexRoutingTurnID(c) + if currentLogicalTurn == "" || currentLogicalTurn != bridgeLogicalTurn { + turnState, bridgeOwnedTurnState.value = "", "" + } + bridgeLogicalTurn = currentLogicalTurn if turn > 1 && hooks != nil && hooks.BeforeRequest != nil { if err := hooks.BeforeRequest(turn, currentBridgePayload.payloadRaw, currentBridgePayload.originalModel); err != nil { return err @@ -931,6 +954,7 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( // Native ingress can retry the first turn once only while no downstream // output has been emitted. Always hold metadata-only preamble frames so a // failed attempt cannot leak response IDs before that retry decision. + nativeRoutingConnection = true nativeMatcher := (*OpenAIRefusalMatcher)(nil) if refusalRuntime.RewriteEnabled() { nativeMatcher = refusalRuntime.Matcher @@ -1216,13 +1240,21 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient( } return wroteDownstream } - if err := lease.WriteJSONWithContextTimeout(ctx, json.RawMessage(payload), s.openAIWSWriteTimeout()); err != nil { + wirePayload, promptErr := s.finalizeBusinessPromptWSIngress(c, account, payload) + if promptErr != nil { + return nil, businessPromptWSCloseError(promptErr) + } + if routingErr := s.guardCodexRoutingNativeModel(account, gjson.GetBytes(wirePayload, "model").String()); routingErr != nil { + return nil, routingErr + } + if err := lease.WriteJSONWithContextTimeout(ctx, json.RawMessage(wirePayload), s.openAIWSWriteTimeout()); err != nil { return nil, wrapOpenAIWSIngressTurnError( "write_upstream", fmt.Errorf("write upstream websocket request: %w", err), false, ) } + s.observeNativeCodexWS(ctx, account, wsHeaders, lease.HandshakeHeaders(), wirePayload, lease.ConnID()) if debugEnabled { logOpenAIWSModeDebug( "ingress_ws_turn_request_sent account_id=%d turn=%d conn_id=%s payload_bytes=%d", diff --git a/backend/internal/service/openai_ws_forwarder_v2.go b/backend/internal/service/openai_ws_forwarder_v2.go index e61309e29cf8..6b524eba5284 100644 --- a/backend/internal/service/openai_ws_forwarder_v2.go +++ b/backend/internal/service/openai_ws_forwarder_v2.go @@ -103,6 +103,10 @@ func (s *OpenAIGatewayService) forwardOpenAIWSV2WithScope( } setOpenAIWSTurnMetadata(payload, turnMetadata) applyStagedCodexFingerprintClientMetadata(c, account, payload) + if promptErr := validateBusinessSystemPromptFinal(c, payloadAsJSONBytes(payload), BusinessSystemPromptProtocolResponses); promptErr != nil { + return nil, promptErr + } + observePromptRulesFinalFromRequest(c, account, BusinessSystemPromptProtocolResponses) // Final response.create payload versus the client body Forward staged. The // envelope edits above (type/stream/store/background, client_metadata) are // outside the compared set; the marshal only happens when a snapshot exists. @@ -388,6 +392,12 @@ func (s *OpenAIGatewayService) forwardOpenAIWSV2WithScope( s.commitOpenAIWSSessionTurnState(c, account, stateStore, groupID, sessionHash, handshakeTurnState) } + if model, _ := payload["model"].(string); model != "" { + if routingErr := s.guardCodexRoutingNativeModel(account, model); routingErr != nil { + return nil, routingErr + } + } + s.observeNativeCodexWS(ctx, account, wsHeaders, lease.HandshakeHeaders(), nil, lease.ConnID()) if err := s.performOpenAIWSGeneratePrewarm( ctx, lease, @@ -413,6 +423,7 @@ func (s *OpenAIGatewayService) forwardOpenAIWSV2WithScope( ) return nil, wrapOpenAIWSFallback("write_request", err) } + s.observeNativeCodexWS(ctx, account, wsHeaders, lease.HandshakeHeaders(), codexWSMetadataBody(payload), lease.ConnID()) if debugEnabled { logOpenAIWSModeDebug( "write_request_sent account_id=%d conn_id=%s stream=%v payload_bytes=%d previous_response_id_present=%v", diff --git a/backend/internal/service/openai_ws_http_bridge.go b/backend/internal/service/openai_ws_http_bridge.go index 6d3cf36f9ee0..f16f5090d1a2 100644 --- a/backend/internal/service/openai_ws_http_bridge.go +++ b/backend/internal/service/openai_ws_http_bridge.go @@ -584,6 +584,7 @@ func (s *OpenAIGatewayService) proxyOpenAIWSHTTPBridgeTurn( c.Set("openai_passthrough", true) c.Set("openai_ws_http_bridge", true) } + upstreamReq = upstreamReq.WithContext(context.WithValue(upstreamReq.Context(), codexRoutingIngressKey{}, "ws")) // Bridge turns have no PrepareRequest: compare the frame the bridge received // with the plaintext body just built, before zstd in doOpenAICodexUpstream. diff --git a/backend/internal/service/openai_ws_v2_passthrough_adapter.go b/backend/internal/service/openai_ws_v2_passthrough_adapter.go index 121b7934066f..d0b55a13165e 100644 --- a/backend/internal/service/openai_ws_v2_passthrough_adapter.go +++ b/backend/internal/service/openai_ws_v2_passthrough_adapter.go @@ -901,6 +901,14 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2PassthroughAttempt( return NewOpenAIWSClientCloseError(coderws.StatusPolicyViolation, blocked.Message, blocked) } firstClientMessage = updatedFirst + beginBusinessSystemPromptRequestTurn(c) + if initialRequestModel != "" { + businessSystemPromptRequestSet(c, promptRequestedModelContextKey, initialRequestModel) + } + firstClientMessage, policyErr = s.finalizeBusinessPromptForSend(c, account, firstClientMessage, BusinessSystemPromptProtocolResponses, isOpenAIResponsesCompactPath(c)) + if policyErr != nil { + return businessPromptWSCloseError(policyErr) + } // Last rewrite of the first frame is done; compare before it is written upstream. if integrityErr := s.checkRequestIntegrity(c, account, "ws_passthrough", "first_frame", integrityOriginalFirst, firstClientMessage, requestIntegrityOptions{ UpstreamModel: capturedSessionModel, @@ -1058,6 +1066,11 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2PassthroughAttempt( if !ok { return errors.New("openai ws passthrough upstream connection does not support frame relay") } + observedConnectionID := "passthrough-" + codexRoutingDigest(capturedSessionModel, headers.Get("session-id"), time.Now().UTC().Format(time.RFC3339Nano)) + s.observeNativeCodexWS(ctx, account, headers, handshakeHeaders, nil, observedConnectionID) + upstreamFrameConn = &codexObservedNativeFrameConn{FrameConn: upstreamFrameConn, observe: func(frameCtx context.Context, payload []byte) { + s.observeNativeCodexWS(frameCtx, account, headers, handshakeHeaders, payload, observedConnectionID) + }} relayUpstreamFrameConn := &openAIWSPassthroughFirstOutputFrameConn{ inner: upstreamFrameConn, activeReadTimeout: s.openAIWSPassthroughIdleTimeout(), @@ -1096,6 +1109,7 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2PassthroughAttempt( interTurnIdleTimeout: s.openAIWSIngressInterTurnIdleTimeout(), interTurnStarted: make(chan struct{}, 1), restoreResponseModel: func(payload []byte) []byte { + payload = s.rewriteBusinessSystemPromptJSONForRequest(c, payload, BusinessSystemPromptProtocolResponses) eventType := strings.TrimSpace(gjson.GetBytes(payload, "type").String()) if !openAIWSEventMayContainModel(eventType) { return payload @@ -1303,6 +1317,16 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2PassthroughAttempt( } } out, blocked, policyErr := s.applyOpenAIFastPolicyToWSResponseCreate(ctx, account, model, payload) + if isResponseCreate && policyErr == nil && blocked == nil { + beginBusinessSystemPromptRequestTurn(c) + if requestModelForThisFrame != "" { + businessSystemPromptRequestSet(c, promptRequestedModelContextKey, requestModelForThisFrame) + } + out, policyErr = s.finalizeBusinessPromptForSend(c, account, out, BusinessSystemPromptProtocolResponses, isOpenAIResponsesCompactPath(c)) + if policyErr != nil { + return payload, nil, businessPromptWSCloseError(policyErr) + } + } // Last rewrite of the frame is done; compare before it is written // upstream. Runs on the client->upstream goroutine; gin Context.Set is // mutex-guarded. @@ -1332,6 +1356,17 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2PassthroughAttempt( // extractOpenAIServiceTierFromBody 返回 nil；这里有意 // 覆盖（Store(nil)），因为 OpenAI 上游对该帧实际不传 // service_tier 时按 default 处理，billing 应如实反映。 + if policyErr == nil && blocked == nil && (isResponseCreate || eventType == "session.update") { + finalModel := model + if isResponseCreate { + if selected := strings.TrimSpace(gjson.GetBytes(out, "model").String()); selected != "" { + finalModel = selected + } + } + if routingErr := s.guardCodexRoutingNativeModel(account, finalModel); routingErr != nil { + return out, nil, routingErr + } + } if policyErr == nil && blocked == nil && isResponseCreate { usageMeta.updateFromResponseCreate(out, model, requestModelForThisFrame) responseCreateAtCopy := responseCreateAt @@ -1376,6 +1411,9 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2PassthroughAttempt( relayClientConn = &openAIRefusalRecoveryWSFrameConn{inner: policyClientConn, output: refusalOutput} } upstreamFirstMessageSent := false + if routingErr := s.guardCodexRoutingNativeModel(account, capturedSessionModel); routingErr != nil { + return routingErr + } firstWriteCtx, cancelFirstWrite := context.WithTimeout(ctx, s.openAIWSWriteTimeout()) firstWriteErr := relayUpstreamFrameConn.WriteFrame(firstWriteCtx, coderws.MessageText, firstClientMessage) cancelFirstWrite() diff --git a/backend/internal/service/plugin_codex_identity.go b/backend/internal/service/plugin_codex_identity.go index c880454aafec..c73239ee6a5c 100644 --- a/backend/internal/service/plugin_codex_identity.go +++ b/backend/internal/service/plugin_codex_identity.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "errors" + "github.com/Wei-Shaw/sub2api/internal/pkg/openai" "time" extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" @@ -83,7 +84,11 @@ func resolveCodexOutboundIdentityForAccountContext(ctx context.Context, account if result.UserAgent == "" { return codexOutboundIdentity{}, ErrExtensionOperationUnavailable } - return codexOutboundIdentity{userAgent: result.UserAgent, originator: codexTUIOriginator, version: canonical.version}, nil + originator, paired, valid := openai.PairCodexClientIdentity(result.UserAgent) + if !valid { + return codexOutboundIdentity{}, ErrExtensionOperationUnavailable + } + return codexOutboundIdentity{userAgent: paired, originator: originator, version: openai.CodexUserAgentVersion(paired)}, nil } func codexIdentityPolicyAvailable(ctx context.Context, accountType string, accountID int64) (bool, error) { diff --git a/backend/internal/service/plugin_codex_transport.go b/backend/internal/service/plugin_codex_transport.go index 7735e75afe28..783691c88a71 100644 --- a/backend/internal/service/plugin_codex_transport.go +++ b/backend/internal/service/plugin_codex_transport.go @@ -37,6 +37,9 @@ func prepareCodexTransport(req *http.Request, account *Account) (*http.Request, if req == nil || req.URL == nil || account == nil || !account.IsOpenAIOAuthLike() { return req, nil } + if _, ok := req.Context().Value(codexIdentityBodyKey{}).(codexIdentityBodyObservation); !ok { + req = req.WithContext(context.WithValue(req.Context(), codexIdentityBodyKey{}, inspectCodexIdentityBody(req))) + } if err := requireCodexIdentityPolicy(req.Context(), account); err != nil { return nil, err } diff --git a/backend/internal/service/plugin_extension_accounts.go b/backend/internal/service/plugin_extension_accounts.go index 716e8c0b4c8d..20cbb3e1567d 100644 --- a/backend/internal/service/plugin_extension_accounts.go +++ b/backend/internal/service/plugin_extension_accounts.go @@ -67,6 +67,8 @@ func (s *OpenAIGatewayService) ResolveExtensionIdentity(ctx context.Context, que return nil, err } ensureCodexIdentityHeaders(headers) - enforceCodexIdentityHeaders(headers) + if err := enforceCodexIdentityHeadersForAccountContext(ctx, headers, a, codexAccountIdentityOverrideUA(a)); err != nil { + return nil, err + } return &extensionv1.OutboundIdentity{AccountID: a.ID, Identity: CodexTicketAccountIdentity(a), Token: token, Headers: headers, ProxyURL: resolveAccountProxyURL(a)}, nil } diff --git a/backend/internal/service/plugin_extension_package_test.go b/backend/internal/service/plugin_extension_package_test.go index 60205fa3f0bb..a4f33517644d 100644 --- a/backend/internal/service/plugin_extension_package_test.go +++ b/backend/internal/service/plugin_extension_package_test.go @@ -27,7 +27,7 @@ func TestFirstPartyExtensionSignedPackageContainsIndependentRuntimeAndUI(t *test defer func() { _ = file.Close() }() cfg := testPluginConfig(t.TempDir(), false) cfg.Plugins.TrustedPublishers = map[string]string{keyID: public} - installer := NewPluginPackageInstaller(cfg, PluginHostInfo{Version: "0.2.7", BuildType: "release"}) + installer := NewPluginPackageInstaller(cfg, PluginHostInfo{Version: "0.2.7-codexrip.2", BuildType: "release"}) installed, err := installer.Install(context.Background(), file, nil) require.NoError(t, err) require.Equal(t, "codexrip.codex-runtime", installed.PluginKey) diff --git a/backend/internal/service/plugin_extension_state.go b/backend/internal/service/plugin_extension_state.go index b7e0c41736e5..1cae4f1df2f1 100644 --- a/backend/internal/service/plugin_extension_state.go +++ b/backend/internal/service/plugin_extension_state.go @@ -41,7 +41,7 @@ func (h *pluginExtensionHost) Call(ctx context.Context, in extensionv1.HostInvoc if h.installation != nil && h.installation.RuntimeGeneration > 0 { ctx = WithPluginExecution(ctx, h.installation) } - if (in.Operation == extensionv1.HostResolveIdentity || in.Operation == extensionv1.HostLeaseAcquire || in.Operation == extensionv1.HostStateDue || in.Operation == extensionv1.HostJobSubmit || in.Operation == extensionv1.HostMetricsQuery) && h.active != nil && !h.active() { + if (in.Operation == extensionv1.HostResolveIdentity || in.Operation == extensionv1.HostLeaseAcquire || in.Operation == extensionv1.HostStateDue || in.Operation == extensionv1.HostJobSubmit || in.Operation == extensionv1.HostMetricsQuery || isCodexRoutingHostOperation(in.Operation)) && h.active != nil && !h.active() { return extensionv1.Result{}, status.Error(codes.Unavailable, "plugin capability is no longer active") } if h.state == nil && in.Operation != extensionv1.HostMetricsQuery { @@ -67,6 +67,9 @@ func (h *pluginExtensionHost) Call(ctx context.Context, in extensionv1.HostInvoc } var value any var err error + if isCodexRoutingHostOperation(in.Operation) { + return h.callCodexRouting(ctx, in) + } switch in.Operation { case extensionv1.HostMetricsQuery: var request extensionv1.AccountQuery @@ -99,6 +102,9 @@ func (h *pluginExtensionHost) Call(ctx context.Context, in extensionv1.HostInvoc if json.Unmarshal(in.Payload, &req) != nil || validatePluginKVNamespace(req.Namespace) != nil || req.Limit < 1 || req.Limit > 100 { return extensionv1.Result{}, status.Error(codes.InvalidArgument, "invalid due-state query") } + if req.Namespace == codexRoutingPrivateNamespace { + return extensionv1.Result{}, status.Error(codes.PermissionDenied, "host-owned routing material is private") + } value, err = h.state.DueExtensionStates(ctx, h.key, req) case extensionv1.HostAccountRead, extensionv1.HostAccountList, extensionv1.HostResolveIdentity, extensionv1.HostFinishObservation: if h.directory == nil { @@ -154,6 +160,9 @@ func (h *pluginExtensionHost) Call(ctx context.Context, in extensionv1.HostInvoc if json.Unmarshal(in.Payload, &req) != nil || validatePluginKVNamespace(req.Namespace) != nil || validatePluginKVKey(req.Key) != nil || req.ExpectedRevision < 0 { return extensionv1.Result{}, status.Error(codes.InvalidArgument, "invalid state request") } + if req.Namespace == codexRoutingPrivateNamespace { + return extensionv1.Result{}, status.Error(codes.PermissionDenied, "host-owned routing material is private") + } if in.Operation == extensionv1.HostStateRead { value, err = h.state.ReadExtensionState(ctx, h.key, req) } else { @@ -211,6 +220,9 @@ func (h *pluginExtensionHost) Call(ctx context.Context, in extensionv1.HostInvoc } func pluginHostOperationUsesAccountScope(operation extensionv1.HostOperation) bool { + if isCodexRoutingHostOperation(operation) { + return true + } switch operation { case extensionv1.HostAccountRead, extensionv1.HostAccountList, extensionv1.HostResolveIdentity, extensionv1.HostMetricsQuery, extensionv1.HostStateCompareSwap: diff --git a/backend/internal/service/plugin_manager.go b/backend/internal/service/plugin_manager.go index c7c094f2322a..4766deafe682 100644 --- a/backend/internal/service/plugin_manager.go +++ b/backend/internal/service/plugin_manager.go @@ -69,6 +69,8 @@ type PluginManager struct { reconcileDone chan struct{} route atomic.Pointer[pluginRoute] extensions atomic.Pointer[pluginExtensionRegistry] + codexDemandMu sync.Mutex + codexDemandAt map[string]time.Time } func NewPluginManager(repo PluginRepository, encryptor SecretEncryptor, cfg *config.Config, hostInfo PluginHostInfo, kvStore PluginKVStore) *PluginManager { diff --git a/backend/internal/service/plugin_request.go b/backend/internal/service/plugin_request.go index 7c5c61c2f085..78c92b2bb2c8 100644 --- a/backend/internal/service/plugin_request.go +++ b/backend/internal/service/plugin_request.go @@ -45,12 +45,13 @@ func (m *PluginManager) ApplyRequestHeaders(ctx context.Context, account *Accoun if result.Code != "" { return errors.New("plugin request prerequisite unavailable") } - var changes struct { - Headers map[string]string `json:"headers"` - } + var changes extensionv1.CodexRoutingInjection if json.Unmarshal(result.Payload, &changes) != nil { return errors.New("invalid plugin header result") } + if changes.Qualification != nil && (registry.installations[id].PluginKey != codexRuntimePluginKey || !changes.Qualification.Valid(time.Now(), account.ID, CodexTicketAccountIdentity(account), model)) { + return errors.New("invalid routing qualification reference") + } seen := map[string]bool{} for name, value := range changes.Headers { lower := strings.ToLower(name) diff --git a/backend/internal/service/plugin_scheduling.go b/backend/internal/service/plugin_scheduling.go index 191b2323414d..275f5b05b08a 100644 --- a/backend/internal/service/plugin_scheduling.go +++ b/backend/internal/service/plugin_scheduling.go @@ -66,6 +66,11 @@ func (m *PluginManager) SchedulingDecision(account *Account, model string, now t if projection.Identity != CodexTicketAccountIdentity(account) { observed = false } + // Legacy length-only grants cannot survive a runtime cutover into the + // Cookie qualification policy, even before its background migration. + if installation.PluginKey == codexRuntimePluginKey && constraint.Effect == "allow" && constraint.Reason != "routing_verified" { + observed = false + } if observed && constraint.Until != nil && !now.Before(*constraint.Until) { observed = false } diff --git a/backend/internal/service/pricing_service.go b/backend/internal/service/pricing_service.go index 2834e94d5b52..1e736cd2873d 100644 --- a/backend/internal/service/pricing_service.go +++ b/backend/internal/service/pricing_service.go @@ -1456,6 +1456,20 @@ func (s *PricingService) matchByModelFamily(model string) *LiteLLMModelPricing { // 5. gpt-5.4* -> 业务静态兜底价 // 6. 最终回退到 DefaultTestModel (gpt-5.1-codex) func (s *PricingService) matchOpenAIModel(model string) *LiteLLMModelPricing { + if named := openai.GPT6NamedModel(model); named != "" { + if pricing, ok := s.pricingData[named]; ok { + return pricing + } + if named == "gpt-6-sol" { + return openAIGPT6SolFallbackPricing + } + return openAIGPT6LunaFallbackPricing + } + // A future named GPT-6 is not the numeric gpt-6 (Astra) alias, nor the + // default test model. Exact custom price cards were already considered. + if strings.HasPrefix(model, "gpt-6-") && !isOpenAIGPT6AstraModel(model) { + return nil + } if strings.HasPrefix(model, "gpt-5.3-codex-spark") { if pricing, ok := s.pricingData["gpt-5.1-codex"]; ok { logger.LegacyPrintf("service.pricing", "[Pricing][SparkBilling] %s -> %s billing", model, "gpt-5.1-codex") diff --git a/backend/internal/service/upstream_models.go b/backend/internal/service/upstream_models.go index 547b5a4552c8..5fb679b423ff 100644 --- a/backend/internal/service/upstream_models.go +++ b/backend/internal/service/upstream_models.go @@ -48,10 +48,12 @@ type UpstreamModelMetadataSnapshot struct { } type UpstreamModelCatalog struct { - Models []string `json:"models"` - Metadata map[string]UpstreamModelMetadata `json:"metadata,omitempty"` - Warnings []UpstreamModelSyncWarning `json:"warnings,omitempty"` - CapacityRows []AccountModelContextCapacityRow `json:"capacity_rows"` + Models []string `json:"models"` + // ModelListSource describes the IDs, independently of enriched capabilities. + ModelListSource string `json:"model_list_source"` + Metadata map[string]UpstreamModelMetadata `json:"metadata,omitempty"` + Warnings []UpstreamModelSyncWarning `json:"warnings,omitempty"` + CapacityRows []AccountModelContextCapacityRow `json:"capacity_rows"` } type UpstreamModelSyncWarning struct { @@ -226,6 +228,10 @@ func (s *AccountTestService) SyncUpstreamModelCatalog(ctx context.Context, accou ) } catalog := &UpstreamModelCatalog{Models: models, Metadata: make(map[string]UpstreamModelMetadata)} + catalog.ModelListSource = "upstream" + if !liveListAvailable { + catalog.ModelListSource = "configured" + } extraUpdates := make(map[string]any) if len(body) > 0 { // Keep only values actually declared by this upstream in the raw capacity diff --git a/backend/internal/service/upstream_models_test.go b/backend/internal/service/upstream_models_test.go index d4ed6a005316..4c1a8f38b36a 100644 --- a/backend/internal/service/upstream_models_test.go +++ b/backend/internal/service/upstream_models_test.go @@ -471,6 +471,7 @@ func TestSyncUpstreamModelCatalogEnrichesOpenCodeIDOnlyListAndPersistsSnapshot(t catalog, err := svc.SyncUpstreamModelCatalog(context.Background(), account) require.NoError(t, err) require.Equal(t, []string{"x-preview-f-free"}, catalog.Models) + require.Equal(t, "upstream", catalog.ModelListSource, "registry enrichment does not change the source of model IDs") require.Len(t, upstream.requests, 2) require.Equal(t, "https://opencode.ai/zen/v1/models", upstream.requests[0].URL.String()) require.Equal(t, []string{"account-secret"}, headerValuesEqualFold(upstream.requests[0].Header, "X-Custom-Account-Header")) @@ -552,6 +553,7 @@ func TestSyncUpstreamModelCatalogUsesConfiguredModelsWhenListEndpointUnsupported require.NoError(t, err) require.Contains(t, account.GetUpstreamModelMetadataSnapshot().Models, "old-live-model", "an unavailable model-list endpoint is not evidence of removal") require.Equal(t, []string{"glm-5.3"}, catalog.Models) + require.Equal(t, "configured", catalog.ModelListSource, "configured IDs are not evidence of upstream availability") require.Empty(t, catalog.Warnings) require.Len(t, upstream.requests, 2) require.Equal(t, "https://provider.example/v1/models", upstream.requests[0].URL.String()) diff --git a/backend/internal/service/wire.go b/backend/internal/service/wire.go index f38fcd35d341..521ea8072609 100644 --- a/backend/internal/service/wire.go +++ b/backend/internal/service/wire.go @@ -55,8 +55,12 @@ func ProvideBusinessSystemPromptService( bus BusinessSystemPromptRevisionBus, remoteSkillRegistry *RemoteSkillRegistryService, remoteSkillRegistryBus RemoteSkillRegistryRevisionBus, + accountRepo AccountRepository, + cfg *config.Config, ) (*BusinessSystemPromptService, error) { svc := NewBusinessSystemPromptService(store, bus) + svc.SetAccountRepository(accountRepo) + svc.previewConfig = cfg svc.SetRemoteSkillRegistryService(remoteSkillRegistry) svc.SetRemoteSkillRegistryRevisionBus(remoteSkillRegistryBus) return svc, nil diff --git a/backend/migrations/253_prompt_rule_policies.sql b/backend/migrations/253_prompt_rule_policies.sql new file mode 100644 index 000000000000..fe54d58147e7 --- /dev/null +++ b/backend/migrations/253_prompt_rule_policies.sql @@ -0,0 +1,18 @@ +-- Rule definitions share the existing runtime revision transaction. Content +-- remains in immutable template versions; account.extra stores references only. +CREATE TABLE IF NOT EXISTS system_prompt_rule_policies ( + id SMALLINT PRIMARY KEY REFERENCES system_prompt_runtime(id) ON DELETE RESTRICT CHECK (id = 1), + policy JSONB NOT NULL CHECK (jsonb_typeof(policy) = 'object') +); +INSERT INTO system_prompt_rule_policies (id, policy) +SELECT 1, jsonb_build_object( + 'version', 1, + 'default_rule_ids', jsonb_build_array('legacy-default'), + 'rules', jsonb_build_array(jsonb_build_object( + 'id', 'legacy-default', 'name', 'Default / 默认规则', 'enabled', true, + 'template_id', COALESCE(active_template_id, 0), 'version_id', COALESCE(active_version_id, 0), + 'follow_active', true, 'order', 100, 'delivery', 'native_control', + 'position', 'control_append', 'model_match', 'upstream', 'models', '[]'::jsonb + )) +) FROM system_prompt_runtime WHERE id = 1 +ON CONFLICT (id) DO NOTHING; diff --git a/backend/migrations/prompt_rule_policies_migration_test.go b/backend/migrations/prompt_rule_policies_migration_test.go new file mode 100644 index 000000000000..74ae820d14ca --- /dev/null +++ b/backend/migrations/prompt_rule_policies_migration_test.go @@ -0,0 +1,25 @@ +package migrations + +import ( + "os" + "strings" + "testing" +) + +func TestPromptRuleMigrationPreservesRuntimeIntent(t *testing.T) { + raw, err := os.ReadFile("253_prompt_rule_policies.sql") + if err != nil { + t.Fatal(err) + } + sql := string(raw) + for _, expected := range []string{"'legacy-default'", "'follow_active', true", "'native_control'", "'control_append'", "'models', '[]'::jsonb", "ON CONFLICT (id) DO NOTHING"} { + if !strings.Contains(sql, expected) { + t.Fatalf("missing legacy migration contract %q", expected) + } + } + for _, forbidden := range []string{"UPDATE accounts", "UPDATE system_prompt_runtime", "expose_server_prompt", "compact_enabled"} { + if strings.Contains(sql, forbidden) { + t.Fatalf("migration changed existing intent: %s", forbidden) + } + } +} diff --git a/backend/pkg/extensionapi/ui/client.ts b/backend/pkg/extensionapi/ui/client.ts index b5b28121fea2..90afea14f9ac 100644 --- a/backend/pkg/extensionapi/ui/client.ts +++ b/backend/pkg/extensionapi/ui/client.ts @@ -1,6 +1,8 @@ import { computed, createApp, ref, readonly, watch, onScopeDispose, toRaw, type Component } from 'vue' import { createI18n } from 'vue-i18n' import { extensionAvailabilityKey, extensionUnavailableMessageKey } from './context' +import { createPluginPresentation } from './presentation' +import { createPluginSizing } from './sizing' import './bridge.js' export interface UIContext { @@ -111,32 +113,15 @@ export function useNotifications() { } } -function applyPresentation(context: UIContext) { - document.documentElement.classList.toggle('dark', context.theme === 'dark') - const current = document.documentElement.style - for (let index = current.length - 1; index >= 0; index--) { - const key = current[index]! - if (/^--(?:ui|theme)-/.test(key)) current.removeProperty(key) - } - for (const [key, value] of Object.entries(context.theme_tokens || {})) { - if (/^--(?:ui|theme)-[a-z0-9-]+$/.test(key) && value.length <= 512 && !/url\s*\(/i.test(value)) current.setProperty(key, value) - } - for (const element of document.querySelectorAll('[data-plugin-theme]')) element.remove() - for (const path of context.theme_stylesheets || []) { - if (!/^\/api\/v1\/settings\/plugins\/\d+\/theme\/[a-f0-9]+\//.test(path) || /[\\\s]/.test(path)) continue - const link = document.createElement('link') - link.rel = 'stylesheet'; link.href = path; link.dataset.pluginTheme = 'true' - document.head.append(link) - } -} - // A plugin owns its page and locale messages. The public SDK supplies only // rendering, presentation context and named host operations. export async function mountPlugin(App: Component, messages: Record) { const client = bridge() const context = sharedContext context.value = await client.context() - applyPresentation(context.value) + const scheduleSizing = { run: () => {} } + const presentation = createPluginPresentation(document, () => scheduleSizing.run()) + presentation.update(context.value) const i18n = createI18n({ legacy: false, locale: String(context.value.locale || 'zh').startsWith('zh') ? 'zh' : 'en', fallbackLocale: 'en', messages }) const app = createApp(App) app.use(i18n) @@ -145,28 +130,9 @@ export async function mountPlugin(App: Component, messages: Record { context.value = next; root.inert = next.retained_controls !== true && next.available === false; applyPresentation(next); i18n.global.locale.value = String(next.locale).startsWith('zh') ? 'zh' : 'en' }) - const resize = () => { - let bottom = root.getBoundingClientRect().bottom - for (const menu of document.querySelectorAll('[role="listbox"], [role="menu"]')) { - const box = menu.getBoundingClientRect() - if (box.height) bottom = Math.max(bottom, box.bottom) - } - // Teleported dialogs have no measurable height inside #app. Use their - // natural content height, including the currently clipped scroll body, - // so a small frame does not permanently keep its own dialog collapsed. - for (const panel of document.querySelectorAll('[role="dialog"] .modal-content')) { - const body = panel.querySelector('.modal-body') - const natural = panel.scrollHeight + (body ? Math.max(0, body.scrollHeight - body.clientHeight) : 0) - if (panel.getBoundingClientRect().height) bottom = Math.max(bottom, natural + 32) - observer.observe(panel) - } - client.resize(Math.ceil(bottom) + (context.value.layout === 'inline' ? 0 : 24)) - } + const stop = client.onContextChange(next => { context.value = next; root.inert = next.retained_controls !== true && next.available === false; presentation.update(next); i18n.global.locale.value = String(next.locale).startsWith('zh') ? 'zh' : 'en' }) if (context.value.layout === 'inline') document.body.style.minHeight = '0' - const observer = new ResizeObserver(resize) - const mutations = new MutationObserver(resize) - observer.observe(root) - mutations.observe(document.body, { childList: true, subtree: true }) - window.addEventListener('pagehide', () => { stop(); observer.disconnect(); mutations.disconnect(); app.unmount(); client.dispose() }, { once: true }) + const sizing = createPluginSizing(root, height => client.resize(height), () => context.value.layout === 'inline') + scheduleSizing.run = sizing.schedule + window.addEventListener('pagehide', () => { stop(); sizing.dispose(); presentation.dispose(); app.unmount(); client.dispose() }, { once: true }) } diff --git a/backend/pkg/extensionapi/ui/presentation.ts b/backend/pkg/extensionapi/ui/presentation.ts new file mode 100644 index 000000000000..f1c6dac56d68 --- /dev/null +++ b/backend/pkg/extensionapi/ui/presentation.ts @@ -0,0 +1,35 @@ +import { createStylesheetController, pluginThemeURL } from './stylesheets' + +interface Presentation { + theme?: string + theme_tokens?: Record + theme_stylesheets?: string[] +} + +export function createPluginPresentation(doc: Document, changed: () => void) { + const ownedTokens = new Set() + const stylesheets = createStylesheetController(doc, changed) + function update(context: Presentation) { + doc.documentElement.classList.toggle('dark', context.theme === 'dark') + const style = doc.documentElement.style + const next = new Map(Object.entries(context.theme_tokens || {}).filter(([key, value]) => + /^--(?:ui|theme)-[a-z0-9-]+$/.test(key) && typeof value === 'string' && value.length <= 512 && !/url\s*\(/i.test(value))) + for (const key of ownedTokens) if (!next.has(key)) { style.removeProperty(key); ownedTokens.delete(key) } + for (const [key, value] of next) { + if (style.getPropertyValue(key) !== value) style.setProperty(key, value) + ownedTokens.add(key) + } + const desired = new Map() + for (const value of context.theme_stylesheets || []) { + const href = pluginThemeURL(value) + if (!href) continue + // A new digest replaces the same plugin asset, rather than removing its + // old stylesheet before the replacement has loaded. + const key = href.replace(/\/theme\/[a-f0-9]{64}\//, '/theme/') + desired.set(key, href) + } + void stylesheets.sync(desired) + changed() + } + return { update, dispose: stylesheets.dispose } +} diff --git a/backend/pkg/extensionapi/ui/sizing.ts b/backend/pkg/extensionapi/ui/sizing.ts new file mode 100644 index 000000000000..9c61eaf78ea7 --- /dev/null +++ b/backend/pkg/extensionapi/ui/sizing.ts @@ -0,0 +1,54 @@ +/** Intrinsic iframe content sizing; viewport height must never be its input. */ +export function createPluginSizing(root: HTMLElement, send: (height: number) => void, inline: () => boolean) { + const doc = root.ownerDocument + const view = doc.defaultView! + const panels = new Set() + let frame: number | null = null + let stopped = false + let previous: number | undefined + + function measure() { + frame = null + if (stopped) return + const rootTop = Math.max(0, root.getBoundingClientRect().top + view.scrollY) + let bottom = rootTop + Math.max(root.offsetHeight, root.scrollHeight) + for (const menu of doc.querySelectorAll('[role="listbox"], [role="menu"]')) { + const box = menu.getBoundingClientRect() + if (box.height) bottom = Math.max(bottom, box.bottom + view.scrollY) + } + const present = new Set(doc.querySelectorAll('[role="dialog"] .modal-content')) + for (const panel of panels) if (!present.has(panel)) { observer.unobserve(panel); panels.delete(panel) } + for (const panel of present) { + if (!panels.has(panel)) { panels.add(panel); observer.observe(panel) } + if (!panel.getBoundingClientRect().height) continue + const body = panel.querySelector('.modal-body') + const natural = panel.scrollHeight + (body ? Math.max(0, body.scrollHeight - body.clientHeight) : 0) + bottom = Math.max(bottom, natural + 32) + } + const height = Math.max(inline() ? 0 : 120, Math.min(1200, Math.ceil(bottom) + (inline() ? 0 : 24))) + if (height !== previous) { previous = height; send(height) } + } + function schedule() { + if (!stopped && frame === null) frame = view.requestAnimationFrame(measure) + } + const observer = new ResizeObserver(schedule) + const mutations = new MutationObserver(schedule) + observer.observe(root) + mutations.observe(doc.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['class', 'style', 'hidden', 'open'] }) + view.addEventListener('resize', schedule) + doc.fonts?.addEventListener('loadingdone', schedule) + void doc.fonts?.ready.then(schedule) + schedule() + return { + schedule, + dispose() { + stopped = true + if (frame !== null) view.cancelAnimationFrame(frame) + observer.disconnect() + mutations.disconnect() + view.removeEventListener('resize', schedule) + doc.fonts?.removeEventListener('loadingdone', schedule) + panels.clear() + } + } +} diff --git a/backend/pkg/extensionapi/ui/stylesheets.ts b/backend/pkg/extensionapi/ui/stylesheets.ts new file mode 100644 index 000000000000..9e31091c7f4c --- /dev/null +++ b/backend/pkg/extensionapi/ui/stylesheets.ts @@ -0,0 +1,113 @@ +interface PendingStylesheet { + href: string + promise: Promise + cancel: () => void +} + +interface StylesheetEntry { + active?: HTMLLinkElement + pending?: PendingStylesheet +} + +export function pluginThemeURL(value: unknown): string | null { + if (typeof value !== 'string' || !/^\/api\/v1\/settings\/plugins\/[1-9]\d*\/theme\/[a-f0-9]{64}\/[a-zA-Z0-9_./-]+\.css$/.test(value) || value.split('/').includes('..')) return null + return value +} + +async function preloadThemeFonts(link: HTMLLinkElement): Promise { + if (typeof FontFace === 'undefined' || !link.sheet) return + const base = new URL(link.href) + const directory = new URL('.', base).pathname + const fonts: Promise[] = [] + for (const rule of Array.from(link.sheet.cssRules)) { + if (rule.type !== CSSRule.FONT_FACE_RULE) continue + const style = (rule as CSSFontFaceRule).style + let valid = true + const source = style.getPropertyValue('src').replace(/url\(\s*(['"]?)(.*?)\1\s*\)/g, (_match, _quote, path: string) => { + const url = new URL(path, base) + if (url.origin !== base.origin || !url.pathname.startsWith(directory) || !url.pathname.endsWith('.woff2')) valid = false + return `url("${url.href}")` + }) + if (!valid || !source.includes('url(')) continue + const family = style.getPropertyValue('font-family').replace(/^['"]|['"]$/g, '') + const face = new FontFace(family, source, { weight: style.getPropertyValue('font-weight') || 'normal', style: style.getPropertyValue('font-style') || 'normal' }) + fonts.push(face.load()) + } + await Promise.all(fonts) +} + +/** Keep the last loaded appearance until its replacement is ready. */ +export function createStylesheetController(doc: Document, changed: () => void = () => {}) { + const entries = new Map() + let disposed = false + + function sync(desired: ReadonlyMap): Promise { + if (disposed) return Promise.resolve() + for (const [key, entry] of entries) { + if (desired.has(key)) continue + entry.pending?.cancel() + entry.active?.remove() + entries.delete(key) + changed() + } + const loading: Promise[] = [] + for (const [key, href] of desired) { + let entry = entries.get(key) + if (!entry) { entry = {}; entries.set(key, entry) } + if (entry.active && !entry.active.isConnected) entry.active = undefined + if (entry.pending?.href === href) { loading.push(entry.pending.promise); continue } + entry.pending?.cancel() + if (entry.active?.getAttribute('href') === href) continue + + const link = doc.createElement('link') + link.rel = 'stylesheet' + link.crossOrigin = 'anonymous' + link.href = href + link.dataset.pluginTheme = key + // Fetch without applying a partially replaced theme to the current page. + link.media = 'not all' + const current = entry + let complete!: (success: boolean) => void + let loaded!: () => void + const promise = new Promise(resolve => { + let timer = setTimeout(() => complete(false), 1500) + let finished = false + loaded = () => { + if (finished) return + clearTimeout(timer) + // Fonts are substantially larger than CSS. Their asynchronous load + // has its own deadline while the current theme remains usable. + timer = setTimeout(() => complete(false), 15000) + void preloadThemeFonts(link).then(() => complete(true), () => complete(false)) + } + complete = success => { + if (finished) return + finished = true + clearTimeout(timer) + link.onload = link.onerror = null + if (success && !disposed && entries.get(key) === current) { + link.media = '' + current.active?.remove() + current.active = link + changed() + } else link.remove() + current.pending = undefined + resolve() + } + }) + current.pending = { href, promise, cancel: () => complete(false) } + link.onload = loaded + link.onerror = () => complete(false) + doc.head.append(link) + loading.push(promise) + } + return Promise.all(loading).then(() => {}) + } + + function dispose() { + disposed = true + for (const entry of entries.values()) { entry.pending?.cancel(); entry.active?.remove() } + entries.clear() + } + return { sync, dispose } +} diff --git a/backend/pkg/extensionapi/v1/codex_identity.go b/backend/pkg/extensionapi/v1/codex_identity.go index d9ae9b5fdd4b..32495da4e35f 100644 --- a/backend/pkg/extensionapi/v1/codex_identity.go +++ b/backend/pkg/extensionapi/v1/codex_identity.go @@ -3,16 +3,20 @@ package extensionv1 // Profile fields are persisted by the host. Their generation and interpretation // belong to the Codex domain process; no credential is part of this contract. type CodexClientProfile struct { - Version int `json:"v"` - OSType string `json:"os_type"` - OSVersion string `json:"os_version"` - Arch string `json:"arch"` - Terminal string `json:"terminal"` - Sandbox string `json:"sandbox"` - GeneratedAt string `json:"generated_at,omitempty"` + Source string `json:"source,omitempty"` + Originator string `json:"originator,omitempty"` + ClientVersion string `json:"client_version,omitempty"` + Version int `json:"v"` + OSType string `json:"os_type"` + OSVersion string `json:"os_version"` + Arch string `json:"arch"` + Terminal string `json:"terminal"` + Sandbox string `json:"sandbox"` + GeneratedAt string `json:"generated_at,omitempty"` } type CodexIdentityQuery struct { + Preset string `json:"preset,omitempty"` Seed string `json:"seed,omitempty"` Profile CodexClientProfile `json:"profile,omitempty"` Version string `json:"version,omitempty"` diff --git a/backend/pkg/extensionapi/v1/codex_routing.go b/backend/pkg/extensionapi/v1/codex_routing.go new file mode 100644 index 000000000000..60a87b3e7e16 --- /dev/null +++ b/backend/pkg/extensionapi/v1/codex_routing.go @@ -0,0 +1,110 @@ +package extensionv1 + +import "time" + +// Routing operations are named, account-scoped host IO. They never accept a +// destination URL, arbitrary request body, credential, or arbitrary Cookie. +const ( + HostCodexRoutingScope HostOperation = "codex.routing.scope" + HostCodexRoutingProbe HostOperation = "codex.routing.probe" + HostCodexRoutingCheck HostOperation = "codex.routing.check" + HostCodexRoutingCleanup HostOperation = "codex.routing.cleanup" + CodexRoutingSchema = 2 + CodexRoutingMaxAge = 120 * time.Second + CodexRoutingRefreshLead = 20 * time.Second +) + +type CodexRoutingScope struct { + AccountID int64 `json:"account_id"` + Identity string `json:"identity"` + ProfileHash string `json:"profile_hash"` + RouteHash string `json:"route_hash"` + RouteEvidence string `json:"route_evidence"` + ConnectionLeaseID string `json:"connection_lease_id,omitempty"` + Transport string `json:"transport"` +} + +// SameOwner intentionally excludes account.updated_at: writing a projection +// changes that timestamp without changing any outbound identity or route. +func (s CodexRoutingScope) SameOwner(other CodexRoutingScope) bool { + return s.AccountID > 0 && s.AccountID == other.AccountID && s.Identity != "" && s.Identity == other.Identity && + s.ProfileHash != "" && s.ProfileHash == other.ProfileHash && s.RouteHash != "" && s.RouteHash == other.RouteHash +} + +type CodexRoutingBundleRef struct { + Key string `json:"key"` + Revision int64 `json:"revision"` + ExpiresAt time.Time `json:"expires_at"` + ConnectionLeaseID string `json:"connection_lease_id,omitempty"` +} + +type CodexRoutingQuery struct { + AccountID int64 `json:"account_id"` + Model string `json:"model,omitempty"` + Transport string `json:"transport,omitempty"` + Stage string `json:"stage,omitempty"` // acquire or verify + OperationID string `json:"operation_id,omitempty"` + Bundle *CodexRoutingBundleRef `json:"bundle,omitempty"` + Scope *CodexRoutingScope `json:"scope,omitempty"` +} + +// All observation fields are safe for an authenticated read-only account view. +// Cookie and STATE values, tokens, proxy URLs and response text are excluded. +type CodexRoutingObservation struct { + Stage string `json:"stage"` + Code string `json:"code"` + HTTPStatus int `json:"http_status,omitempty"` + RequestedModel string `json:"requested_model,omitempty"` + ResponseModel string `json:"response_model,omitempty"` + Completed bool `json:"completed"` + ModelMatched bool `json:"model_matched"` + StateLength int `json:"state_length,omitempty"` + CookieNames []string `json:"cookie_names,omitempty"` + ObservedAt time.Time `json:"observed_at"` + DurationMS int64 `json:"duration_ms,omitempty"` + Transport string `json:"transport,omitempty"` + CookieSent bool `json:"cookie_sent"` +} + +type CodexRoutingProbeResult struct { + Scope CodexRoutingScope `json:"scope"` + Bundle *CodexRoutingBundleRef `json:"bundle,omitempty"` + Observation CodexRoutingObservation `json:"observation"` + Valid bool `json:"valid"` +} + +type CodexRoutingQualification struct { + Scope CodexRoutingScope `json:"scope"` + Bundle CodexRoutingBundleRef `json:"bundle"` + Model string `json:"model"` + VerifiedAt time.Time `json:"verified_at"` + ExpiresAt time.Time `json:"expires_at"` +} + +func (q *CodexRoutingQualification) Valid(now time.Time, id int64, identity, model string) bool { + return q != nil && q.Scope.AccountID == id && q.Scope.Identity == identity && q.Model == model && + q.Bundle.Key != "" && q.Bundle.Revision > 0 && !q.VerifiedAt.IsZero() && !q.VerifiedAt.After(now) && + now.Before(q.ExpiresAt) && !q.ExpiresAt.After(q.Bundle.ExpiresAt) && !q.ExpiresAt.After(q.VerifiedAt.Add(CodexRoutingMaxAge)) +} + +// The host applies only a reference to a host-verified private bundle. Generic +// plugin header mutations continue to reject Cookie and Set-Cookie. +type CodexRoutingInjection struct { + Headers map[string]string `json:"headers"` + Qualification *CodexRoutingQualification `json:"routing_qualification,omitempty"` +} + +type CodexRoutingDemand struct { + AccountID int64 `json:"account_id"` + Model string `json:"model"` + Transport string `json:"transport,omitempty"` +} + +type CodexRoutingResponse struct { + AccountID int64 `json:"account_id"` + Identity string `json:"identity"` + Model string `json:"model"` + Qualification CodexRoutingQualification `json:"qualification"` + Observation CodexRoutingObservation `json:"observation"` + Replacement *CodexRoutingQualification `json:"replacement,omitempty"` +} diff --git a/backend/pkg/extensionapi/v1/prompt.go b/backend/pkg/extensionapi/v1/prompt.go index f54cf0b5b8d1..ed8a71462a32 100644 --- a/backend/pkg/extensionapi/v1/prompt.go +++ b/backend/pkg/extensionapi/v1/prompt.go @@ -3,32 +3,34 @@ package extensionv1 import "time" type BusinessSystemPromptSnapshot struct { - Enabled bool `json:"enabled"` - ExposeServerPrompt bool `json:"expose_server_prompt"` - CompactEnabled bool `json:"compact_enabled"` - TemplateID int64 `json:"template_id"` - VersionID int64 `json:"version_id"` - TemplateVersion int64 `json:"template_version"` - Revision int64 `json:"revision"` - Body string `json:"body,omitempty"` - SHA256 string `json:"sha256"` - ByteLength int `json:"byte_length"` - CompositionMode string `json:"composition_mode"` - BundleID string `json:"bundle_id,omitempty"` - BundleManifestSHA256 string `json:"bundle_manifest_sha256,omitempty"` - RegistryRevision int64 `json:"registry_revision,omitempty"` - RegistryRawTreeSHA256 string `json:"registry_raw_tree_sha256,omitempty"` - RegistryEffectiveTreeSHA256 string `json:"registry_effective_tree_sha256,omitempty"` - RegistryPromptRawSHA256 string `json:"registry_prompt_raw_sha256,omitempty"` - RegistryPromptEffectiveSHA256 string `json:"registry_prompt_effective_sha256,omitempty"` - RegistryUpstreamSourceID string `json:"registry_upstream_source_id,omitempty"` - RegistryUpstreamRoot string `json:"registry_upstream_root,omitempty"` - RegistryPublicRoot string `json:"registry_public_root,omitempty"` - BundleAvailable bool `json:"bundle_available"` - BundleDegraded bool `json:"bundle_degraded"` - DegradedReason string `json:"degraded_reason,omitempty"` - Degraded bool `json:"degraded"` - UpdatedAt time.Time `json:"updated_at"` + RulePolicy *PromptRulePolicy `json:"rule_policy,omitempty"` + ResolvedRules []ResolvedPromptRule `json:"resolved_rules,omitempty"` + Enabled bool `json:"enabled"` + ExposeServerPrompt bool `json:"expose_server_prompt"` + CompactEnabled bool `json:"compact_enabled"` + TemplateID int64 `json:"template_id"` + VersionID int64 `json:"version_id"` + TemplateVersion int64 `json:"template_version"` + Revision int64 `json:"revision"` + Body string `json:"body,omitempty"` + SHA256 string `json:"sha256"` + ByteLength int `json:"byte_length"` + CompositionMode string `json:"composition_mode"` + BundleID string `json:"bundle_id,omitempty"` + BundleManifestSHA256 string `json:"bundle_manifest_sha256,omitempty"` + RegistryRevision int64 `json:"registry_revision,omitempty"` + RegistryRawTreeSHA256 string `json:"registry_raw_tree_sha256,omitempty"` + RegistryEffectiveTreeSHA256 string `json:"registry_effective_tree_sha256,omitempty"` + RegistryPromptRawSHA256 string `json:"registry_prompt_raw_sha256,omitempty"` + RegistryPromptEffectiveSHA256 string `json:"registry_prompt_effective_sha256,omitempty"` + RegistryUpstreamSourceID string `json:"registry_upstream_source_id,omitempty"` + RegistryUpstreamRoot string `json:"registry_upstream_root,omitempty"` + RegistryPublicRoot string `json:"registry_public_root,omitempty"` + BundleAvailable bool `json:"bundle_available"` + BundleDegraded bool `json:"bundle_degraded"` + DegradedReason string `json:"degraded_reason,omitempty"` + Degraded bool `json:"degraded"` + UpdatedAt time.Time `json:"updated_at"` // Effective fields are attached to an immutable request-scoped copy. They // are never persisted or returned by the runtime API. @@ -38,41 +40,51 @@ type BusinessSystemPromptSnapshot struct { } type BusinessSystemPromptTarget struct { - AccountID int64 `json:"account_id,omitempty"` - Platform string `json:"platform"` - AccountType string `json:"account_type,omitempty"` - Protocol string `json:"protocol"` - Compact bool `json:"compact"` + RequestedModel string `json:"requested_model,omitempty"` + UpstreamModel string `json:"upstream_model,omitempty"` + ProviderPlatform string `json:"provider_platform,omitempty"` + ProviderProfile string `json:"provider_profile,omitempty"` + BindingJSON string `json:"binding_json,omitempty"` + AccountID int64 `json:"account_id,omitempty"` + Platform string `json:"platform"` + AccountType string `json:"account_type,omitempty"` + Protocol string `json:"protocol"` + Compact bool `json:"compact"` } type BusinessSystemPromptApplication struct { - PreserveInstructionsEcho bool `json:"preserve_instructions_echo,omitempty"` - Applied bool `json:"applied"` - Carrier string `json:"carrier"` - ClientInstructions string `json:"client_instructions"` - ServerInstructions string `json:"server_instructions"` - ExposeServerPrompt bool `json:"expose_server_prompt"` - CompactEnabled bool `json:"compact_enabled"` - TemplateID int64 `json:"template_id"` - VersionID int64 `json:"version_id"` - TemplateVersion int64 `json:"template_version"` - Revision int64 `json:"revision"` - SHA256 string `json:"sha256"` - BaseSHA256 string `json:"base_sha256,omitempty"` - EffectiveSHA256 string `json:"effective_sha256,omitempty"` - EffectiveByteLength int `json:"effective_byte_length,omitempty"` - CompositionMode string `json:"composition_mode,omitempty"` - BundleID string `json:"bundle_id,omitempty"` - BundleManifestSHA256 string `json:"bundle_manifest_sha256,omitempty"` - BundleRevision int64 `json:"bundle_revision,omitempty"` - BundleRawTreeSHA256 string `json:"bundle_raw_tree_sha256,omitempty"` - BundleEffectiveTreeSHA256 string `json:"bundle_effective_tree_sha256,omitempty"` - BundlePromptRawSHA256 string `json:"bundle_prompt_raw_sha256,omitempty"` - BundlePromptEffectiveSHA256 string `json:"bundle_prompt_effective_sha256,omitempty"` - BundleUpstreamSourceID string `json:"bundle_upstream_source_id,omitempty"` - BundleUpstreamRoot string `json:"bundle_upstream_root,omitempty"` - BundlePublicRoot string `json:"bundle_public_root,omitempty"` - Degraded bool `json:"degraded,omitempty"` + RulesPlan *PromptRulesPlan `json:"rules_plan,omitempty"` + OriginalInstructionsExists bool `json:"-"` + FinalInstructions string `json:"-"` + PublicInstructions string `json:"-"` + PublicInstructionsExists bool `json:"-"` + PreserveInstructionsEcho bool `json:"preserve_instructions_echo,omitempty"` + Applied bool `json:"applied"` + Carrier string `json:"carrier"` + ClientInstructions string `json:"client_instructions"` + ServerInstructions string `json:"server_instructions"` + ExposeServerPrompt bool `json:"expose_server_prompt"` + CompactEnabled bool `json:"compact_enabled"` + TemplateID int64 `json:"template_id"` + VersionID int64 `json:"version_id"` + TemplateVersion int64 `json:"template_version"` + Revision int64 `json:"revision"` + SHA256 string `json:"sha256"` + BaseSHA256 string `json:"base_sha256,omitempty"` + EffectiveSHA256 string `json:"effective_sha256,omitempty"` + EffectiveByteLength int `json:"effective_byte_length,omitempty"` + CompositionMode string `json:"composition_mode,omitempty"` + BundleID string `json:"bundle_id,omitempty"` + BundleManifestSHA256 string `json:"bundle_manifest_sha256,omitempty"` + BundleRevision int64 `json:"bundle_revision,omitempty"` + BundleRawTreeSHA256 string `json:"bundle_raw_tree_sha256,omitempty"` + BundleEffectiveTreeSHA256 string `json:"bundle_effective_tree_sha256,omitempty"` + BundlePromptRawSHA256 string `json:"bundle_prompt_raw_sha256,omitempty"` + BundlePromptEffectiveSHA256 string `json:"bundle_prompt_effective_sha256,omitempty"` + BundleUpstreamSourceID string `json:"bundle_upstream_source_id,omitempty"` + BundleUpstreamRoot string `json:"bundle_upstream_root,omitempty"` + BundlePublicRoot string `json:"bundle_public_root,omitempty"` + Degraded bool `json:"degraded,omitempty"` } type PromptPlanRequest struct { diff --git a/backend/pkg/extensionapi/v1/prompt_rules.go b/backend/pkg/extensionapi/v1/prompt_rules.go new file mode 100644 index 000000000000..4a7f4ccdf236 --- /dev/null +++ b/backend/pkg/extensionapi/v1/prompt_rules.go @@ -0,0 +1,71 @@ +package extensionv1 + +// PromptRule references immutable template content. Account bindings contain +// only rule IDs; customer history and account credentials are never policy RPCs. +type PromptRule struct { + ID string `json:"id"` + Name string `json:"name"` + Enabled bool `json:"enabled"` + TemplateID int64 `json:"template_id"` + VersionID int64 `json:"version_id"` + FollowActive bool `json:"follow_active,omitempty"` + Order int `json:"order"` + Delivery string `json:"delivery"` + Position string `json:"position"` + ModelMatch string `json:"model_match"` + Models []string `json:"models"` +} + +type PromptRulePolicy struct { + Version int `json:"version"` + Rules []PromptRule `json:"rules"` + DefaultRuleIDs []string `json:"default_rule_ids"` +} + +type PromptAccountBinding struct { + Mode string `json:"mode"` + RuleIDs []string `json:"rule_ids"` +} + +type ResolvedPromptRule struct { + Rule PromptRule `json:"rule"` + Body string `json:"body"` + SHA256 string `json:"sha256"` + PreserveEcho bool `json:"preserve_echo,omitempty"` +} + +type PromptRulePlacement struct { + PreserveEcho bool `json:"preserve_echo,omitempty"` + RuleID string `json:"rule_id"` + TemplateID int64 `json:"template_id"` + VersionID int64 `json:"version_id"` + Delivery string `json:"delivery"` + Position string `json:"position"` + Carrier string `json:"carrier"` + Role string `json:"role,omitempty"` + Body string `json:"body"` + SHA256 string `json:"sha256"` +} + +type PromptRuleDecision struct { + RuleID string `json:"rule_id"` + Reason string `json:"reason"` +} + +type PromptRulesPlan struct { + SHA256 string `json:"sha256"` + Placements []PromptRulePlacement `json:"placements"` + Skipped []PromptRuleDecision `json:"skipped"` +} + +const ( + PromptDeliveryNative = "native_control" + PromptDeliverySystem = "system" + PromptDeliveryDeveloper = "developer" + PromptPositionControlPrepend = "control_prepend" + PromptPositionControlAppend = "control_append" + PromptPositionConversationHead = "conversation_head" + PromptPositionConversationTail = "conversation_tail" + PromptRulesMaxCount = 32 + PromptRulesMaxBytes = 256 << 10 +) diff --git a/backend/resources/model-pricing/model_prices_and_context_window.json b/backend/resources/model-pricing/model_prices_and_context_window.json index 86737ecd40ee..82902d70bce6 100644 --- a/backend/resources/model-pricing/model_prices_and_context_window.json +++ b/backend/resources/model-pricing/model_prices_and_context_window.json @@ -5041,6 +5041,100 @@ "supports_web_search": true, "supports_xhigh_reasoning_effort": true }, + "gpt-6-sol": { + "input_cost_per_token": 2e-06, + "output_cost_per_token": 1e-05, + "cache_read_input_token_cost": 2e-07, + "cache_creation_input_token_cost": 2.5e-06, + "long_context_input_token_threshold": 272000, + "long_context_input_cost_multiplier": 2.0, + "long_context_output_cost_multiplier": 1.5, + "litellm_provider": "openai", + "mode": "chat", + "context_window": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_none_reasoning_effort": true, + "supports_minimal_reasoning_effort": false, + "supports_function_calling": true, + "supports_parallel_function_calling": true, + "supports_native_streaming": true, + "supports_vision": true, + "supports_service_tier": true, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "input_cost_per_token_priority": 4e-06, + "input_cost_per_token_flex": 1e-06, + "input_cost_per_token_batches": 1e-06, + "output_cost_per_token_priority": 2e-05, + "output_cost_per_token_flex": 5e-06, + "output_cost_per_token_batches": 5e-06, + "cache_read_input_token_cost_priority": 4e-07, + "cache_read_input_token_cost_flex": 1e-07, + "cache_read_input_token_cost_batches": 1e-07, + "cache_creation_input_token_cost_priority": 5e-06, + "cache_creation_input_token_cost_flex": 1.25e-06, + "cache_creation_input_token_cost_batches": 1.25e-06 + }, + "gpt-6-luna": { + "input_cost_per_token": 1e-07, + "output_cost_per_token": 5e-07, + "cache_read_input_token_cost": 1e-08, + "cache_creation_input_token_cost": 1.25e-07, + "long_context_input_token_threshold": 272000, + "long_context_input_cost_multiplier": 2.0, + "long_context_output_cost_multiplier": 1.5, + "litellm_provider": "openai", + "mode": "chat", + "context_window": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_none_reasoning_effort": true, + "supports_minimal_reasoning_effort": false, + "supports_function_calling": true, + "supports_parallel_function_calling": true, + "supports_native_streaming": true, + "supports_vision": true, + "supports_service_tier": true, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "input_cost_per_token_priority": 2e-07, + "input_cost_per_token_flex": 5e-08, + "input_cost_per_token_batches": 5e-08, + "output_cost_per_token_priority": 1e-06, + "output_cost_per_token_flex": 2.5e-07, + "output_cost_per_token_batches": 2.5e-07, + "cache_read_input_token_cost_priority": 2e-08, + "cache_read_input_token_cost_flex": 5e-09, + "cache_read_input_token_cost_batches": 5e-09, + "cache_creation_input_token_cost_priority": 2.5e-07, + "cache_creation_input_token_cost_flex": 6.25e-08, + "cache_creation_input_token_cost_batches": 6.25e-08 + }, "gpt-5.6-sol": { "cache_creation_input_token_cost": 6.25e-06, "cache_creation_input_token_cost_batches": 3.125e-06, diff --git a/frontend/src/api/admin/accounts.ts b/frontend/src/api/admin/accounts.ts index b7788f2daae9..678dc95f78ac 100644 --- a/frontend/src/api/admin/accounts.ts +++ b/frontend/src/api/admin/accounts.ts @@ -631,6 +631,7 @@ export async function getAccountTestPlan(id: number, signal?: AbortSignal, view? export interface SyncUpstreamModelsResult { models: string[] + model_list_source?: 'upstream' | 'configured' metadata?: Record warnings?: UpstreamModelSyncWarning[] capacity_rows?: ModelContextCapacityRow[] diff --git a/frontend/src/components/account/ModelContextCapacityField.vue b/frontend/src/components/account/ModelContextCapacityField.vue index e7b175f1251a..ba8f65048acb 100644 --- a/frontend/src/components/account/ModelContextCapacityField.vue +++ b/frontend/src/components/account/ModelContextCapacityField.vue @@ -112,9 +112,12 @@ const preview = computed<{ value: number | null; source: string }>(() => { const formattedValue = computed(() => formatContextCapacity(preview.value.value)) const fieldWidth = computed(() => `${Math.max(6, formattedValue.value.length + 2)}ch`) const inputValid = computed(() => parseContextCapacityInput(inputValue.value).valid) -const sourceLabel = computed(() => ['custom', 'official', 'upstream', 'default', 'protected', 'invalid'].includes(preview.value.source) - ? t(`${key}.sources.${preview.value.source}`) - : t(`${key}.unknown`)) +const sourceLabel = computed(() => { + if (boundRow.value?.reason === 'codex_catalog_reference') return t(`${key}.sources.codex_reference`) + return ['custom', 'official', 'upstream', 'default', 'protected', 'invalid'].includes(preview.value.source) + ? t(`${key}.sources.${preview.value.source}`) + : t(`${key}.unknown`) +}) const detailsTitle = computed(() => { const row = boundRow.value const details = [t(`${key}.effective`), `${formattedValue.value} · ${sourceLabel.value}`] diff --git a/frontend/src/components/account/__tests__/ModelContextCapacityField.spec.ts b/frontend/src/components/account/__tests__/ModelContextCapacityField.spec.ts index 06c100801450..82283ba54b7e 100644 --- a/frontend/src/components/account/__tests__/ModelContextCapacityField.spec.ts +++ b/frontend/src/components/account/__tests__/ModelContextCapacityField.spec.ts @@ -31,6 +31,19 @@ function mountField(row: ModelContextCapacityRow | undefined = capacityRow(), dr } describe('ModelContextCapacityField', () => { + it('labels the GPT-6 OAuth fallback as a Codex reference and keeps it read-only', () => { + const wrapper = mountField(capacityRow({ + upstream_model_id: 'gpt-6-sol', aliases: [], editable: false, upstream: undefined, + automatic_context_window: 272000, effective_context_window: 272000, + automatic_source: 'protected', effective_source: 'protected', max_context_window: 872000, + reason: 'codex_catalog_reference' + }), undefined, 'gpt-6-sol') + expect(wrapper.get('[data-testid="context-capacity-value"]').text()).toBe('[272K]') + expect(wrapper.get('[data-testid="context-capacity-source"]').text()).toContain('sources.codex_reference') + expect(wrapper.find('button').exists()).toBe(false) + expect(wrapper.emitted('commit')).toBeUndefined() + }) + it('explains the selected GPT reference without rewriting a namespaced model ID', () => { const modelId = 'team/gpt-6' const row = capacityRow({ diff --git a/frontend/src/components/account/__tests__/ModelWhitelistSelector.spec.ts b/frontend/src/components/account/__tests__/ModelWhitelistSelector.spec.ts index 5b3abd9eb9f9..a3155923766a 100644 --- a/frontend/src/components/account/__tests__/ModelWhitelistSelector.spec.ts +++ b/frontend/src/components/account/__tests__/ModelWhitelistSelector.spec.ts @@ -160,6 +160,12 @@ describe('ModelWhitelistSelector', () => { expect(syncUpstreamModels).not.toHaveBeenCalled() expect(syncUpstreamModelsPreview).not.toHaveBeenCalled() expect(wrapper.emitted('update:capacityDrafts')).toBeUndefined() + const selected = wrapper.emitted('update:modelValue')![0][0] as string[] + expect(selected).toContain('gpt-6-sol') + expect(selected).toContain('gpt-6-luna') + await wrapper.setProps({ modelValue: selected }) + await wrapper.get('[data-testid="fill-related-models"]').trigger('click') + expect(wrapper.emitted('update:modelValue')![1][0]).toEqual(selected) wrapper.unmount() }) diff --git a/frontend/src/components/admin/account/AccountDetailsDrawer.vue b/frontend/src/components/admin/account/AccountDetailsDrawer.vue index cf9305ad177f..f60f3a1e54d0 100644 --- a/frontend/src/components/admin/account/AccountDetailsDrawer.vue +++ b/frontend/src/components/admin/account/AccountDetailsDrawer.vue @@ -77,6 +77,12 @@ :context="{ account_id: account.id, view_props: { accountId: account.id, folderId: account.management_folder?.id, tagIds: (account.tags || []).map(tag => tag.id), folders, tags } }" @event="name => { if (name === 'changed') refreshTaxonomyAccount() }" /> + + + +

{{ t('admin.accounts.capacityAndUsage') }}

@@ -157,6 +163,8 @@ import { provideAccountViewContext, useAccountViewOperation } from '@/composables/useAccountViewContext' import { accountAPIForView } from '@/api/admin/accounts' import ExtensionWidget from '@/components/plugins/ExtensionWidget.vue' +import AccountPromptBindingPanel from './AccountPromptBindingPanel.vue' +import CodexFingerprintPanel from './CodexFingerprintPanel.vue' import { computed, onMounted, onUnmounted } from 'vue' import { useI18n } from 'vue-i18n' import { adminAPI } from '@/api/admin' diff --git a/frontend/src/components/admin/account/AccountPromptBindingPanel.vue b/frontend/src/components/admin/account/AccountPromptBindingPanel.vue new file mode 100644 index 000000000000..081de0797263 --- /dev/null +++ b/frontend/src/components/admin/account/AccountPromptBindingPanel.vue @@ -0,0 +1,10 @@ + + diff --git a/frontend/src/components/admin/account/CodexFingerprintPanel.vue b/frontend/src/components/admin/account/CodexFingerprintPanel.vue new file mode 100644 index 000000000000..187b5eabd258 --- /dev/null +++ b/frontend/src/components/admin/account/CodexFingerprintPanel.vue @@ -0,0 +1,130 @@ + + + diff --git a/frontend/src/components/admin/account/__tests__/CodexFingerprintPanel.spec.ts b/frontend/src/components/admin/account/__tests__/CodexFingerprintPanel.spec.ts new file mode 100644 index 000000000000..30e843049b40 --- /dev/null +++ b/frontend/src/components/admin/account/__tests__/CodexFingerprintPanel.spec.ts @@ -0,0 +1,50 @@ +import { flushPromises, mount } from '@vue/test-utils' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import CodexFingerprintPanel from '../CodexFingerprintPanel.vue' + +const mocks = vi.hoisted(() => ({ get: vi.fn(), put: vi.fn() })) +vi.mock('@/api/client', () => ({ apiClient: mocks })) +vi.mock('vue-i18n', () => ({ useI18n: () => ({ locale: { value: 'en' } }) })) + +const fixture = (agent = 'configured-agent') => ({ + configured: { identity_source: 'account', profile_source: 'legacy_generated', profile_schema: 1, user_agent: agent, originator: 'codex-tui', version: '0.156.0', fingerprint_mode_effective: 'device', account_revision: '2026-09-23T00:00:00Z' }, + cookie_max_age_seconds: 120, + models: [], + captured_reference: { client_version: '0.156.0', user_agent: 'captured-reference' } +}) + +describe('CodexFingerprintPanel', () => { + beforeEach(() => { vi.clearAllMocks() }) + it('reads only on open and keeps unknown observations distinct from configured values', async () => { + mocks.get.mockResolvedValue({ data: fixture() }) + const wrapper = mount(CodexFingerprintPanel, { props: { accountId: 7 } }) + await flushPromises() + expect(mocks.get).toHaveBeenCalledTimes(1) + expect(mocks.get).toHaveBeenCalledWith('/admin/accounts/7/codex-fingerprint') + expect(mocks.put).not.toHaveBeenCalled() + expect(wrapper.text()).toContain('No final request observation') + expect(wrapper.text()).toContain('configured-agent') + expect(wrapper.text()).toContain('legacy_generated') + wrapper.unmount() + }) + it('ignores a late response for the previous account', async () => { + let finish: (result: unknown) => void = () => {} + mocks.get.mockImplementationOnce(() => new Promise(resolve => { finish = resolve })).mockResolvedValueOnce({ data: fixture('second-account') }) + const wrapper = mount(CodexFingerprintPanel, { props: { accountId: 7 } }) + await wrapper.setProps({ accountId: 8 }); await flushPromises() + finish({ data: fixture('old-account') }); await flushPromises() + expect(wrapper.text()).toContain('second-account'); expect(wrapper.text()).not.toContain('old-account') + wrapper.unmount() + }) + it('shows final transport and digest differences without claiming a TLS match', async () => { + mocks.get.mockResolvedValue({ data: { ...fixture(), + captured_reference: { client_version: '0.156.0', user_agent: 'captured-reference', binary_sha256: 'c'.repeat(64), captured_at: '2026-09-23T00:00:00Z', transport_scope: 'loopback', responses: [{ method: 'GET', transport: { client_hello: { alpn: ['http/1.1'] } } }] }, + models: [{ model: 'gpt-6-sol', phase: 'ready', enrolled: false, failed_cycles: 0, qualified: true, verified_at: '2026-09-23T00:00:42Z' }], + observed: { observed_at: '2026-09-23T00:01:00Z', ingress: 'ws', transport: 'http', http_protocol: 'HTTP/1.1', user_agent: 'wire-agent', originator: 'codex_exec', version: '0.156.0', tls_implementation: 'go-crypto-tls', request_encoding: 'zstd', cookie_names: ['__cflb'], cookie_versions: { __cflb: 'd'.repeat(16) }, connection_evidence: 'short-hash', identity_fields: { session: { header_digest: 'aaaaaaaaaaaaaaaa', body_digest: 'bbbbbbbbbbbbbbbb', consistency: 'mismatch' } } } } }) + const wrapper = mount(CodexFingerprintPanel, { props: { accountId: 7 } }); await flushPromises() + expect(wrapper.text()).toContain('ws → http'); expect(wrapper.text()).toContain('Header/body mismatch'); expect(wrapper.text()).toContain('aaaaaaaaaaaaaaaa'); expect(wrapper.text()).toContain('Not captured') + expect(wrapper.text()).toContain('c'.repeat(64)); expect(wrapper.text()).toContain('d'.repeat(16)); expect(wrapper.text()).toContain('2026-09-23T00:00:42Z') + expect(wrapper.text()).toContain('codex_exec'); expect(wrapper.text()).toContain('client_hello') + expect(mocks.put).not.toHaveBeenCalled(); wrapper.unmount() + }) +}) diff --git a/frontend/src/components/keys/UseKeyModal.vue b/frontend/src/components/keys/UseKeyModal.vue index b71db74cf430..f52178beae6d 100644 --- a/frontend/src/components/keys/UseKeyModal.vue +++ b/frontend/src/components/keys/UseKeyModal.vue @@ -1329,6 +1329,18 @@ function generateOpenCodeConfig(platform: string, baseUrl: string, apiKey: strin } } const openaiModels = { + 'gpt-6-sol': { + name: 'GPT-6 Sol', + limit: { context: 1050000, output: 128000 }, + options: { store: false }, + variants: { none: {}, low: {}, medium: {}, high: {}, xhigh: {}, max: {} } + }, + 'gpt-6-luna': { + name: 'GPT-6 Luna', + limit: { context: 1050000, output: 128000 }, + options: { store: false }, + variants: { none: {}, low: {}, medium: {}, high: {}, xhigh: {}, max: {} } + }, 'gpt-6': { name: 'GPT-6 (Astra)', limit: { diff --git a/frontend/src/components/keys/__tests__/UseKeyModal.spec.ts b/frontend/src/components/keys/__tests__/UseKeyModal.spec.ts index cd67548ee9c6..f0160736fb2b 100644 --- a/frontend/src/components/keys/__tests__/UseKeyModal.spec.ts +++ b/frontend/src/components/keys/__tests__/UseKeyModal.spec.ts @@ -629,6 +629,14 @@ describe('UseKeyModal', () => { const parsed = JSON.parse(wrapper.find('pre code').text()) const models = parsed.provider.openai.models + for (const [id, name] of [['gpt-6-sol', 'GPT-6 Sol'], ['gpt-6-luna', 'GPT-6 Luna']]) { + expect(models[id]).toEqual({ + name, + limit: { context: 1050000, output: 128000 }, + options: { store: false }, + variants: { none: {}, low: {}, medium: {}, high: {}, xhigh: {}, max: {} } + }) + } for (const model of ['gpt-5.6', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna']) { expect(models[model]).toBeDefined() expect(models[model].variants).toHaveProperty('max') diff --git a/frontend/src/components/plugins/PluginFrame.vue b/frontend/src/components/plugins/PluginFrame.vue index ff457f98b021..bda0f3a30f98 100644 --- a/frontend/src/components/plugins/PluginFrame.vue +++ b/frontend/src/components/plugins/PluginFrame.vue @@ -203,7 +203,14 @@ async function loadSession() { } catch (value) { if (generation === version) { error.value = failure(value); loading.value = false } } } -watch(() => [auth.user?.id, auth.isAdmin, auth.isAuthenticated, props.pluginId, props.context.account_id, props.context.contribution_id], loadSession, { immediate: true, flush: 'sync' }) +watch([ + () => auth.user?.id, + () => auth.isAdmin, + () => auth.isAuthenticated, + () => props.pluginId, + () => props.context.account_id, + () => props.context.contribution_id, +], loadSession, { immediate: true, flush: 'sync' }) watch(() => [admission.value.allowed, originAvailable()], ([allowed, origin]) => { if (allowed && origin && !session.value && !loading.value) void loadSession() }) diff --git a/frontend/src/components/plugins/__tests__/PluginFrame.precondition.spec.ts b/frontend/src/components/plugins/__tests__/PluginFrame.precondition.spec.ts index 82fa243b5097..bd48363c6d5a 100644 --- a/frontend/src/components/plugins/__tests__/PluginFrame.precondition.spec.ts +++ b/frontend/src/components/plugins/__tests__/PluginFrame.precondition.spec.ts @@ -36,6 +36,20 @@ beforeEach(() => { afterEach(() => { wrapper?.unmount(); wrapper = undefined; vi.restoreAllMocks() }) describe('plugin host-owned read-time preconditions', () => { + it('keeps the iframe session when refreshed context has the same identity', async () => { + await setup({ account_id: 3, contribution_id: 'classification', count: 1 }) + const frame = wrapper!.get('iframe').element + expect(calls.session).toHaveBeenCalledTimes(1) + await wrapper!.setProps({ context: { account_id: 3, contribution_id: 'classification', count: 2 } }) + await flushPromises() + expect(calls.session).toHaveBeenCalledTimes(1) + expect(wrapper!.get('iframe').element).toBe(frame) + await wrapper!.setProps({ context: { account_id: 4, contribution_id: 'classification', count: 2 } }) + await flushPromises() + expect(calls.session).toHaveBeenCalledTimes(2) + expect(wrapper!.get('iframe').element).not.toBe(frame) + }) + it('keeps the draft and read version on conflict; only an explicit load refreshes it', async () => { const { send, posted } = await setup({ mode: 'configuration' }) const draft = { value: 'my unsaved edit', nested: { preserved: true } } diff --git a/frontend/src/components/plugins/__tests__/presentationStability.spec.ts b/frontend/src/components/plugins/__tests__/presentationStability.spec.ts new file mode 100644 index 000000000000..44321787cfb2 --- /dev/null +++ b/frontend/src/components/plugins/__tests__/presentationStability.spec.ts @@ -0,0 +1,64 @@ +import { afterEach, expect, it, vi } from 'vitest' +import { createPluginPresentation } from '@sub2api/plugin-ui/presentation' +import { createPluginSizing } from '@sub2api/plugin-ui/sizing' + +afterEach(() => { vi.restoreAllMocks(); vi.unstubAllGlobals(); document.body.replaceChildren(); document.documentElement.removeAttribute('style') }) + +it('reuses stylesheet nodes and theme variables across repeated data-only context updates', () => { + const presentation = createPluginPresentation(document, vi.fn()) + const context = { theme: 'dark', theme_tokens: { '--ui-font': 'fixture-font' }, theme_stylesheets: [`/api/v1/settings/plugins/7/theme/${'a'.repeat(64)}/assets/theme.css`] } + presentation.update(context) + const link = document.querySelector('link[data-plugin-theme]')! + link.dispatchEvent(new Event('load')) + const set = vi.spyOn(document.documentElement.style, 'setProperty') + const remove = vi.spyOn(document.documentElement.style, 'removeProperty') + for (let i = 0; i < 4; i++) presentation.update({ ...context }) + expect(document.querySelector('link[data-plugin-theme]')).toBe(link) + expect(set).not.toHaveBeenCalled() + expect(remove).not.toHaveBeenCalled() + presentation.update({ ...context, theme_tokens: {} }) + expect(remove).toHaveBeenCalledWith('--ui-font') + presentation.dispose() +}) + +it('coalesces measurement, ignores scroll offsets, and shrinks after an overlay closes', () => { + let resize!: () => void + let mutate!: () => void + const unobserve = vi.fn() + vi.stubGlobal('ResizeObserver', class { constructor(callback: () => void) { resize = callback } observe() {} unobserve = unobserve; disconnect() {} }) + vi.stubGlobal('MutationObserver', class { constructor(callback: () => void) { mutate = callback } observe() {} disconnect() {} }) + const frames = new Map() + let sequence = 0 + vi.spyOn(window, 'requestAnimationFrame').mockImplementation(callback => { frames.set(++sequence, callback); return sequence }) + vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(id => { frames.delete(id) }) + function paint() { const callbacks = [...frames.values()]; frames.clear(); callbacks.forEach(callback => callback(0)) } + const root = document.createElement('div') + document.body.append(root) + let scroll = 0 + vi.spyOn(window, 'scrollY', 'get').mockImplementation(() => scroll) + vi.spyOn(root, 'getBoundingClientRect').mockImplementation(() => new DOMRect(0, -scroll, 600, 100)) + Object.defineProperties(root, { offsetHeight: { value: 100 }, scrollHeight: { value: 100 } }) + const send = vi.fn() + const sizing = createPluginSizing(root, send, () => true) + resize(); mutate(); resize() + expect(frames.size).toBe(1) + paint() + expect(send).toHaveBeenLastCalledWith(100) + scroll = 30 + resize(); mutate(); paint() + expect(send).toHaveBeenCalledTimes(1) + const dialog = document.createElement('div') + dialog.setAttribute('role', 'dialog') + dialog.innerHTML = '
' + const panel = dialog.firstElementChild as HTMLElement + vi.spyOn(panel, 'getBoundingClientRect').mockReturnValue(new DOMRect(0, 0, 500, 350)) + Object.defineProperty(panel, 'scrollHeight', { value: 350 }) + document.body.append(dialog) + mutate(); paint() + expect(send).toHaveBeenLastCalledWith(382) + dialog.remove(); mutate(); paint() + expect(send).toHaveBeenLastCalledWith(100) + expect(unobserve).toHaveBeenCalledWith(panel) + resize(); sizing.dispose(); paint() + expect(send).toHaveBeenCalledTimes(3) +}) diff --git a/frontend/src/components/plugins/__tests__/theme.spec.ts b/frontend/src/components/plugins/__tests__/theme.spec.ts index 9373c8825bb3..4725aecee592 100644 --- a/frontend/src/components/plugins/__tests__/theme.spec.ts +++ b/frontend/src/components/plugins/__tests__/theme.spec.ts @@ -1,11 +1,12 @@ import { afterEach, describe, expect, it, vi } from 'vitest' import type { PluginContribution } from '@/api/admin/plugins' -import { applyPluginThemeContributions } from '../theme' +import { applyPluginThemeContributions, refreshPluginThemes } from '../theme' +import { publicContributions } from '@/api/admin/plugins' vi.mock('@/api/admin/plugins', () => ({ publicContributions: vi.fn(async () => []) })) const contribution = (): PluginContribution => ({ id: 'theme', plugin_id: 7, permission: 'public', slot: 'theme', label: { en: 'Theme' }, available: true, stylesheet_url: `/api/v1/settings/plugins/7/theme/${'a'.repeat(64)}/assets/theme.css` }) -afterEach(() => { document.querySelectorAll('[data-plugin-theme]').forEach(link => link.remove()) }) +afterEach(async () => { await applyPluginThemeContributions([]); vi.clearAllMocks(); vi.unstubAllGlobals() }) describe('plugin stylesheets', () => { it('loads a declared theme, keeps the loaded resource, and removes it on failure or disable', async () => { @@ -30,4 +31,75 @@ describe('plugin stylesheets', () => { expect(document.querySelector('link[data-plugin-theme]')).toBeNull() } }) + + it('keeps the loaded theme on replacement failure and switches only after load', async () => { + const item = contribution() + const initial = applyPluginThemeContributions([item]) + const previous = document.querySelector('link[data-plugin-theme]')! + previous.dispatchEvent(new Event('load')) + await initial + const next = { ...item, stylesheet_url: item.stylesheet_url!.replace('a'.repeat(64), 'b'.repeat(64)) } + const failed = applyPluginThemeContributions([next]) + const pending = document.querySelectorAll('link[data-plugin-theme]')[1] + expect(previous.isConnected).toBe(true) + expect(pending.media).toBe('not all') + pending.dispatchEvent(new Event('error')) + await failed + expect(previous.isConnected).toBe(true) + const updated = applyPluginThemeContributions([next]) + const replacement = document.querySelectorAll('link[data-plugin-theme]')[1] + replacement.dispatchEvent(new Event('load')) + await updated + expect(previous.isConnected).toBe(false) + expect(replacement.media).toBe('') + }) + + it('keeps appearance on a registry network failure but removes an explicitly disabled theme', async () => { + const item = contribution() + const initial = applyPluginThemeContributions([item]) + const link = document.querySelector('link[data-plugin-theme]')! + link.dispatchEvent(new Event('load')) + await initial + vi.mocked(publicContributions).mockRejectedValueOnce(new Error('offline')) + await refreshPluginThemes() + expect(link.isConnected).toBe(true) + vi.mocked(publicContributions).mockResolvedValueOnce([{ ...item, available: false }]) + await refreshPluginThemes() + expect(link.isConnected).toBe(false) + }) + + it('does not resurrect a pending stylesheet after it is disabled', async () => { + const pending = applyPluginThemeContributions([contribution()]) + const link = document.querySelector('link[data-plugin-theme]')! + await applyPluginThemeContributions([]) + link.dispatchEvent(new Event('load')) + await pending + expect(document.querySelector('link[data-plugin-theme]')).toBeNull() + }) + + it('retains the old font face until replacement fonts have finished loading', async () => { + const item = contribution() + const initial = applyPluginThemeContributions([item]) + const previous = document.querySelector('link[data-plugin-theme]')! + previous.dispatchEvent(new Event('load')) + await initial + let loaded!: () => void + vi.stubGlobal('FontFace', class { + load() { return new Promise(resolve => { loaded = resolve }) } + }) + const updated = applyPluginThemeContributions([{ ...item, stylesheet_url: item.stylesheet_url!.replace('a'.repeat(64), 'c'.repeat(64)) }]) + const replacement = document.querySelectorAll('link[data-plugin-theme]')[1] + const style = document.createElement('div').style + style.setProperty('font-family', 'Fixture') + style.setProperty('src', 'url("fonts/Fixture.woff2")') + Object.defineProperty(replacement, 'sheet', { value: { cssRules: [{ type: CSSRule.FONT_FACE_RULE, style }] } }) + replacement.dispatchEvent(new Event('load')) + await Promise.resolve() + expect(previous.isConnected).toBe(true) + expect(replacement.media).toBe('not all') + loaded() + await updated + expect(previous.isConnected).toBe(false) + expect(replacement.media).toBe('') + }) }) diff --git a/frontend/src/components/plugins/theme.ts b/frontend/src/components/plugins/theme.ts index 32ea9366587f..15e8f3d4c3eb 100644 --- a/frontend/src/components/plugins/theme.ts +++ b/frontend/src/components/plugins/theme.ts @@ -1,38 +1,22 @@ import { publicContributions, type PluginContribution } from '@/api/admin/plugins' +import { createStylesheetController, pluginThemeURL } from '@sub2api/plugin-ui/stylesheets' let flight: Promise | null = null let dirty = false -function themeURL(value: string | undefined): string | null { - if (!value || !/^\/api\/v1\/settings\/plugins\/[1-9]\d*\/theme\/[a-f0-9]{64}\/[a-zA-Z0-9_./-]+\.css$/.test(value) || value.split('/').includes('..')) return null - return value -} +let stylesheets: ReturnType | undefined export function applyPluginThemeContributions(items: PluginContribution[]): Promise { - const links = new Map(Array.from(document.querySelectorAll('link[data-plugin-theme]')).map(link => [link.dataset.pluginTheme!, link])) - const loading: Promise[] = [] + const desired = new Map() for (const item of items) { if (item.slot !== 'theme' || item.permission !== 'public' || !item.available) continue - const href = themeURL(item.stylesheet_url) + const href = pluginThemeURL(item.stylesheet_url) if (!href) continue const key = `${item.plugin_id}:${item.id}` - const previous = links.get(key) - links.delete(key) - if (previous?.getAttribute('href') === href) continue - previous?.remove() - const link = document.createElement('link') - link.rel = 'stylesheet' - link.dataset.pluginTheme = key - link.href = href - loading.push(new Promise(resolve => { - const timer = setTimeout(() => { link.remove(); resolve() }, 1500) - link.onload = () => { clearTimeout(timer); resolve() } - link.onerror = () => { clearTimeout(timer); link.remove(); resolve() } - })) - document.head.append(link) + desired.set(key, href) } - for (const link of links.values()) link.remove() - return Promise.all(loading).then(() => {}) + stylesheets ||= createStylesheetController(document) + return stylesheets.sync(desired) } export function refreshPluginThemes(): Promise { @@ -40,7 +24,9 @@ export function refreshPluginThemes(): Promise { dirty = false flight = (async () => { try { await applyPluginThemeContributions(await publicContributions()) } - catch { await applyPluginThemeContributions([]) } + // A failed metadata read does not revoke the last loaded appearance. + // Explicit unavailable/removed contributions are handled by sync above. + catch { /* keep the last successful appearance */ } finally { flight = null; if (dirty) void refreshPluginThemes() } })() return flight diff --git a/frontend/src/composables/__tests__/useModelWhitelist.spec.ts b/frontend/src/composables/__tests__/useModelWhitelist.spec.ts index df9f347d5aa4..6aaf1952ca45 100644 --- a/frontend/src/composables/__tests__/useModelWhitelist.spec.ts +++ b/frontend/src/composables/__tests__/useModelWhitelist.spec.ts @@ -17,12 +17,16 @@ describe('useModelWhitelist', () => { expect(models).toContain('gpt-5.6') expect(models).toContain('gpt-6') expect(models).toContain('gpt-6-astra') + expect(models).toContain('gpt-6-sol') + expect(models).toContain('gpt-6-luna') }) it('openai 预设映射包含 GPT-6 别名和 Astra', () => { expect(getPresetMappingsByPlatform('openai')).toEqual(expect.arrayContaining([ expect.objectContaining({ label: 'GPT-6', from: 'gpt-6', to: 'gpt-6' }), - expect.objectContaining({ label: 'GPT-6 Astra', from: 'gpt-6-astra', to: 'gpt-6-astra' }) + expect.objectContaining({ label: 'GPT-6 Astra', from: 'gpt-6-astra', to: 'gpt-6-astra' }), + expect.objectContaining({ label: 'GPT-6 Sol', from: 'gpt-6-sol', to: 'gpt-6-sol' }), + expect.objectContaining({ label: 'GPT-6 Luna', from: 'gpt-6-luna', to: 'gpt-6-luna' }) ])) }) diff --git a/frontend/src/composables/useModelWhitelist.ts b/frontend/src/composables/useModelWhitelist.ts index 31a5565a2e6a..b20c27647ca6 100644 --- a/frontend/src/composables/useModelWhitelist.ts +++ b/frontend/src/composables/useModelWhitelist.ts @@ -10,7 +10,7 @@ const openaiModels = [ // GPT-5.6 系列 'gpt-5.6', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', // GPT-6 系列 - 'gpt-6', 'gpt-6-astra', + 'gpt-6', 'gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', // GPT-5.5 系列 'gpt-5.5', // GPT-5.4 系列 @@ -309,6 +309,8 @@ const openaiPresetMappings = [ { label: 'GPT-5.6 Terra', from: 'gpt-5.6-terra', to: 'gpt-5.6-terra', color: 'bg-lime-100 text-lime-700 hover:bg-lime-200 dark:bg-lime-900/30 dark:text-lime-400' }, { label: 'GPT-5.6 Luna', from: 'gpt-5.6-luna', to: 'gpt-5.6-luna', color: 'bg-sky-100 text-sky-700 hover:bg-sky-200 dark:bg-sky-900/30 dark:text-sky-400' }, { label: 'GPT-6 Astra', from: 'gpt-6-astra', to: 'gpt-6-astra', color: 'bg-fuchsia-100 text-fuchsia-700 hover:bg-fuchsia-200 dark:bg-fuchsia-900/30 dark:text-fuchsia-400' }, + { label: 'GPT-6 Sol', from: 'gpt-6-sol', to: 'gpt-6-sol', color: 'bg-orange-100 text-orange-700 hover:bg-orange-200 dark:bg-orange-900/30 dark:text-orange-400' }, + { label: 'GPT-6 Luna', from: 'gpt-6-luna', to: 'gpt-6-luna', color: 'bg-sky-100 text-sky-700 hover:bg-sky-200 dark:bg-sky-900/30 dark:text-sky-400' }, { label: 'GPT-5.5', from: 'gpt-5.5', to: 'gpt-5.5', color: 'bg-amber-100 text-amber-700 hover:bg-amber-200 dark:bg-amber-900/30 dark:text-amber-400' }, { label: 'GPT-5.4', from: 'gpt-5.4', to: 'gpt-5.4', color: 'bg-rose-100 text-rose-700 hover:bg-rose-200 dark:bg-rose-900/30 dark:text-rose-400' }, { label: 'Haiku→5.4', from: 'claude-haiku-4-5-20251001', to: 'gpt-5.4', color: 'bg-emerald-100 text-emerald-700 hover:bg-emerald-200 dark:bg-emerald-900/30 dark:text-emerald-400' }, diff --git a/frontend/src/i18n/locales/en/admin/accounts.ts b/frontend/src/i18n/locales/en/admin/accounts.ts index 5b7f4fb5c129..c2d37b73884f 100644 --- a/frontend/src/i18n/locales/en/admin/accounts.ts +++ b/frontend/src/i18n/locales/en/admin/accounts.ts @@ -17,7 +17,7 @@ export default {accounts: { textTestPrompt: { label: 'Text test prompt', hint: 'Blank uses hi. Remembered only for this site and administrator in this browser.', reset: 'Restore default', tooLong: 'Prompt exceeds 8192 characters. Shorten it to continue.' }, tickets: { stages: { request: 'Request', configuration: 'Configuration', lifecycle: 'Task state', account_auth: 'Account authentication', proxy_auth: 'Proxy authentication', proxy_protocol: 'Proxy protocol', proxy_dns: 'Proxy DNS', proxy_connect: 'Proxy connection', tls: 'TLS certificate', ticket_validation: 'Ticket validation', upstream_http: 'Upstream HTTP', persistence: 'Persistence' }, - title: 'Harvest 292 / renewal', description: 'One request per account and model. Valid tickets are skipped by default. Success enrolls renewal at 1 minute before expiry, with one retry at 1 minute after expiry. Harvesting continues when this window is minimized.', + title: 'Cookie routing / renewal', description: 'Each account/model cycle has at most one acquisition and one business-route verification. Valid qualifications are skipped. Cookies live at most 120 seconds; demand renewal starts 20 seconds early and stops after two failed cycles.', disabled: 'The ticket switch is off.', force: 'Harvest again even with a valid ticket', ineligible: 'Not eligible: requires a non-shadow OpenAI OAuth or Setup Token account.', valid: 'Valid', stop: 'Stop automatic renewal', start: 'Start harvesting', limit: 'Select up to 100 accounts.', loadFailed: 'Could not load accounts or ticket configuration.', submitFailed: 'Operation failed. Check the current status before retrying.', next: 'Next renewal', last: 'Last attempt', length: 'Ticket length', expires: 'Expires', @@ -95,6 +95,7 @@ export default {accounts: { upstream: 'Upstream', default: 'Default', protected: 'Provider-managed', + codex_reference: 'Codex reference', invalid: 'Invalid draft' }, basis: { @@ -1014,7 +1015,7 @@ export default {accounts: { codexFingerprintDevice: 'Device only', codexFingerprintSession: 'Device + Session', codexFingerprintFull: 'Full convergence', - codexTurnTicket: 'Codex 292 ticket', + codexTurnTicket: 'Codex Cookie route', codexTurnTicketDesc: 'Ticket status for the configured models. Requests are paused without a valid ticket only when fail-closed is enabled.', codexTurnTicketMissing: 'No valid ticket; requests remain allowed', codexTurnTicketReady: '{time} left', diff --git a/frontend/src/i18n/locales/zh/admin/accounts.ts b/frontend/src/i18n/locales/zh/admin/accounts.ts index be0fa6f044dd..487f333f8d7f 100644 --- a/frontend/src/i18n/locales/zh/admin/accounts.ts +++ b/frontend/src/i18n/locales/zh/admin/accounts.ts @@ -17,9 +17,9 @@ export default {accounts: { textTestPrompt: { label: '文本测试提示词', hint: '留空使用 hi；仅当前站点和管理员浏览器记忆。', reset: '恢复默认', tooLong: '提示词超过8192字符，请缩短后重试。' }, tickets: { stages: { request: '请求', configuration: '配置检查', lifecycle: '任务状态', account_auth: '账号鉴权', proxy_auth: '代理鉴权', proxy_protocol: '代理协议', proxy_dns: '代理DNS', proxy_connect: '代理连接', tls: 'TLS证书', ticket_validation: '票据校验', upstream_http: '上游HTTP', persistence: '持久化' }, - title: '打292 / 管理续期', description: '每个账号和模型仅请求一次；有效票默认跳过。成功后在到期前1分钟续期，失败仅在到期后1分钟再试一次。收起窗口后仍继续执行。', + title: 'Cookie 路由 / 管理续获', description: '每个账号和模型每周期最多一次采集和一次业务出口复验；有效资格默认跳过。Cookie 最长120秒，按需提前20秒续获，连续失败两周期停止。', disabled: '票据总开关未开启。', force: '重新打票（已有有效票据也执行一次）', ineligible: '不适用：仅 OpenAI OAuth/Setup Token 非影子账号。', - valid: '有效', stop: '停止自动续期', start: '开始打292', limit: '一次最多选择100个账号。', loadFailed: '无法读取账号或票据配置。', + valid: '有效', stop: '停止自动续期', start: '采集并复验', limit: '一次最多选择100个账号。', loadFailed: '无法读取账号或票据配置。', submitFailed: '操作失败，请查看状态后重试。', next: '下次续期', last: '最近尝试', length: '票据长度', expires: '到期时间', states: { idle: '待手动打票', ready: '自动续期待命', retry: '等待到期后重试', stopped: '自动续期已停止', manual_running: '手动打票中', pre_running: '到期前续期中', post_running: '到期后重试中' } }, @@ -95,6 +95,7 @@ export default {accounts: { upstream: '上游', default: '默认', protected: '供应商专用', + codex_reference: 'Codex 参考', invalid: '草稿无效' }, basis: { @@ -1096,11 +1097,11 @@ export default {accounts: { codexFingerprintDevice: '仅设备', codexFingerprintSession: '设备+会话', codexFingerprintFull: '完全收敛', - codexTurnTicket: 'Codex 292 门票', + codexTurnTicket: 'Codex Cookie 路由', codexTurnTicketDesc: '显示已配置模型的门票状态。仅在启用缺票拦截时，没有有效门票的模型才会暂停调度。', codexTurnTicketMissing: '暂无有效门票，仍允许请求', codexTurnTicketReady: '剩余 {time}', - codexTurnTicketPaused: '未打到 292，该模型已暂停', + codexTurnTicketPaused: '该模型尚无有效 Cookie 路由资格', codexImageTool: 'Codex 图片桥接策略', codexImageToolDesc: '统一控制 Codex /responses 文本请求的 hosted image_generation 桥接和客户端图片工具声明。hosted 工具自动注入仅适用于非 Responses Lite 请求；账号级策略优先于渠道和全局配置，不影响独立图片生成接口。', diff --git a/plugins/account-tools/cmd/plugin/main.go b/plugins/account-tools/cmd/plugin/main.go index 3cc9d585767b..f02cc5813ae0 100644 --- a/plugins/account-tools/cmd/plugin/main.go +++ b/plugins/account-tools/cmd/plugin/main.go @@ -5,7 +5,7 @@ import ( extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) -var version = "0.2.7" +var version = "0.2.8" func main() { extensionv1.Serve(extensionv1.Definition{ID: "codexrip.account-tools", Version: version, Capabilities: []string{extensionv1.CapabilityAdmin, extensionv1.CapabilityUI}}, policy.New()) diff --git a/plugins/account-tools/manifest.source.json b/plugins/account-tools/manifest.source.json index eec1999b6ee2..2d813a77ee03 100644 --- a/plugins/account-tools/manifest.source.json +++ b/plugins/account-tools/manifest.source.json @@ -2,10 +2,10 @@ "schema_version": 1, "id": "codexrip.account-tools", "name": "账号工具", - "version": "0.2.7", + "version": "0.2.8", "description": "账号分类操作策略与连接测试选项", "author": "HTExplicit", - "requires": { "sub2api": ">=0.2.7-0 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, "ui_bridge": 1, "extension_api": 1 }, + "requires": { "sub2api": ">=0.2.7-codexrip.2 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, "ui_bridge": 1, "extension_api": 1 }, "capabilities": [ { "id": "extensions.admin.v1", "platform": "*", "account_type": "*" }, { "id": "extensions.ui.v1", "platform": "*", "account_type": "*" } diff --git a/plugins/account-tools/ui/src/locales/en-accounts.ts b/plugins/account-tools/ui/src/locales/en-accounts.ts index 10669bd63d47..f2e55c9ca1fb 100644 --- a/plugins/account-tools/ui/src/locales/en-accounts.ts +++ b/plugins/account-tools/ui/src/locales/en-accounts.ts @@ -3,7 +3,7 @@ export default {accounts: { textTestPrompt: { label: 'Text test prompt', hint: 'Blank uses hi. Remembered only for this site and administrator in this browser.', reset: 'Restore default', tooLong: 'Prompt exceeds 8192 characters. Shorten it to continue.' }, tickets: { stages: { request: 'Request', configuration: 'Configuration', lifecycle: 'Task state', account_auth: 'Account authentication', proxy_auth: 'Proxy authentication', proxy_protocol: 'Proxy protocol', proxy_dns: 'Proxy DNS', proxy_connect: 'Proxy connection', tls: 'TLS certificate', ticket_validation: 'Ticket validation', upstream_http: 'Upstream HTTP', persistence: 'Persistence' }, - title: 'Harvest 292 / renewal', description: 'One request per account and model. Valid tickets are skipped by default. Success enrolls renewal at 1 minute before expiry, with one retry at 1 minute after expiry. Harvesting continues when this window is minimized.', + title: 'Cookie routing / renewal', description: 'Each account/model cycle has at most one acquisition and one business-route verification. Valid qualifications are skipped. Cookies live at most 120 seconds; demand renewal starts 20 seconds early and stops after two failed cycles.', disabled: 'The ticket switch is off.', force: 'Harvest again even with a valid ticket', ineligible: 'Not eligible: requires a non-shadow OpenAI OAuth or Setup Token account.', valid: 'Valid', stop: 'Stop automatic renewal', start: 'Start harvesting', limit: 'Select up to 100 accounts.', loadFailed: 'Could not load accounts or ticket configuration.', submitFailed: 'Operation failed. Check the current status before retrying.', next: 'Next renewal', last: 'Last attempt', length: 'Ticket length', expires: 'Expires', @@ -81,6 +81,7 @@ export default {accounts: { upstream: 'Upstream', default: 'Default', protected: 'Provider-managed', + codex_reference: 'Codex reference', invalid: 'Invalid draft' }, basis: { @@ -1000,7 +1001,7 @@ export default {accounts: { codexFingerprintDevice: 'Device only', codexFingerprintSession: 'Device + Session', codexFingerprintFull: 'Full convergence', - codexTurnTicket: 'Codex 292 ticket', + codexTurnTicket: 'Codex Cookie route', codexTurnTicketDesc: 'Ticket status for the configured models. Requests are paused without a valid ticket only when fail-closed is enabled.', codexTurnTicketMissing: 'No valid ticket; requests remain allowed', codexTurnTicketReady: '{time} left', diff --git a/plugins/account-tools/ui/src/locales/zh-accounts.ts b/plugins/account-tools/ui/src/locales/zh-accounts.ts index 289eb1573c35..ef04765ff1c7 100644 --- a/plugins/account-tools/ui/src/locales/zh-accounts.ts +++ b/plugins/account-tools/ui/src/locales/zh-accounts.ts @@ -3,9 +3,9 @@ export default {accounts: { textTestPrompt: { label: '文本测试提示词', hint: '留空使用 hi；仅当前站点和管理员浏览器记忆。', reset: '恢复默认', tooLong: '提示词超过8192字符，请缩短后重试。' }, tickets: { stages: { request: '请求', configuration: '配置检查', lifecycle: '任务状态', account_auth: '账号鉴权', proxy_auth: '代理鉴权', proxy_protocol: '代理协议', proxy_dns: '代理DNS', proxy_connect: '代理连接', tls: 'TLS证书', ticket_validation: '票据校验', upstream_http: '上游HTTP', persistence: '持久化' }, - title: '打292 / 管理续期', description: '每个账号和模型仅请求一次；有效票默认跳过。成功后在到期前1分钟续期，失败仅在到期后1分钟再试一次。收起窗口后仍继续执行。', + title: 'Cookie 路由 / 管理续获', description: '每个账号和模型每周期最多一次采集和一次业务出口复验；有效资格默认跳过。Cookie 最长120秒，按需提前20秒续获，连续失败两周期停止。', disabled: '票据总开关未开启。', force: '重新打票（已有有效票据也执行一次）', ineligible: '不适用：仅 OpenAI OAuth/Setup Token 非影子账号。', - valid: '有效', stop: '停止自动续期', start: '开始打292', limit: '一次最多选择100个账号。', loadFailed: '无法读取账号或票据配置。', + valid: '有效', stop: '停止自动续期', start: '采集并复验', limit: '一次最多选择100个账号。', loadFailed: '无法读取账号或票据配置。', submitFailed: '操作失败，请查看状态后重试。', next: '下次续期', last: '最近尝试', length: '票据长度', expires: '到期时间', states: { idle: '待手动打票', ready: '自动续期待命', retry: '等待到期后重试', stopped: '自动续期已停止', manual_running: '手动打票中', pre_running: '到期前续期中', post_running: '到期后重试中' } }, @@ -81,6 +81,7 @@ export default {accounts: { upstream: '上游', default: '默认', protected: '供应商专用', + codex_reference: 'Codex 参考', invalid: '草稿无效' }, basis: { @@ -1082,11 +1083,11 @@ export default {accounts: { codexFingerprintDevice: '仅设备', codexFingerprintSession: '设备+会话', codexFingerprintFull: '完全收敛', - codexTurnTicket: 'Codex 292 门票', + codexTurnTicket: 'Codex Cookie 路由', codexTurnTicketDesc: '显示已配置模型的门票状态。仅在启用缺票拦截时，没有有效门票的模型才会暂停调度。', codexTurnTicketMissing: '暂无有效门票，仍允许请求', codexTurnTicketReady: '剩余 {time}', - codexTurnTicketPaused: '未打到 292，该模型已暂停', + codexTurnTicketPaused: '该模型尚无有效 Cookie 路由资格', codexImageTool: 'Codex 图片桥接策略', codexImageToolDesc: '统一控制 Codex /responses 文本请求的 hosted image_generation 桥接和客户端图片工具声明。hosted 工具自动注入仅适用于非 Responses Lite 请求；账号级策略优先于渠道和全局配置，不影响独立图片生成接口。', diff --git a/plugins/admin-observability/cmd/plugin/main.go b/plugins/admin-observability/cmd/plugin/main.go index 7b3cc29ef533..8787854619a3 100644 --- a/plugins/admin-observability/cmd/plugin/main.go +++ b/plugins/admin-observability/cmd/plugin/main.go @@ -5,7 +5,7 @@ import ( extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) -var version = "0.2.7" +var version = "0.2.8" func main() { extensionv1.Serve(extensionv1.Definition{ID: "codexrip.admin-observability", Version: version, Capabilities: []string{extensionv1.CapabilityObservability, extensionv1.CapabilityAdmin, extensionv1.CapabilityUI}}, policy.New()) diff --git a/plugins/admin-observability/manifest.source.json b/plugins/admin-observability/manifest.source.json index d6ac7127ff32..573974e5dd76 100644 --- a/plugins/admin-observability/manifest.source.json +++ b/plugins/admin-observability/manifest.source.json @@ -2,11 +2,11 @@ "schema_version": 1, "id": "codexrip.admin-observability", "name": "界面与观测", - "version": "0.2.7", + "version": "0.2.8", "description": "账号流量观测规则与指标展示", "author": "HTExplicit", "requires": { - "sub2api": ">=0.2.7-0 <0.2.8", + "sub2api": ">=0.2.7-codexrip.2 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, diff --git a/plugins/cindy-provider/cmd/plugin/main.go b/plugins/cindy-provider/cmd/plugin/main.go index 899bef88d004..02ac2e19267e 100644 --- a/plugins/cindy-provider/cmd/plugin/main.go +++ b/plugins/cindy-provider/cmd/plugin/main.go @@ -5,7 +5,7 @@ import ( extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) -var version = "0.2.7" +var version = "0.2.8" func main() { extensionv1.Serve(extensionv1.Definition{ID: "codexrip.cindy-provider", Version: version, Capabilities: []string{extensionv1.CapabilityProvider, extensionv1.CapabilityAdmin}}, catalog.New()) diff --git a/plugins/cindy-provider/manifest.source.json b/plugins/cindy-provider/manifest.source.json index 08477fdd3cd2..aec1b6e8d25b 100644 --- a/plugins/cindy-provider/manifest.source.json +++ b/plugins/cindy-provider/manifest.source.json @@ -2,11 +2,11 @@ "schema_version": 1, "id": "codexrip.cindy-provider", "name": "Cindy Provider", - "version": "0.2.7", + "version": "0.2.8", "description": "Cindy 模型目录、协议能力、价格参考及账号健康判定", "author": "HTExplicit", "requires": { - "sub2api": ">=0.2.7-0 <0.2.8", + "sub2api": ">=0.2.7-codexrip.2 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, diff --git a/plugins/codex-runtime/cmd/plugin/main.go b/plugins/codex-runtime/cmd/plugin/main.go index 6736344d9f96..8601e4a2c376 100644 --- a/plugins/codex-runtime/cmd/plugin/main.go +++ b/plugins/codex-runtime/cmd/plugin/main.go @@ -5,7 +5,7 @@ import ( extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) -var version = "0.2.7" +var version = "0.2.8" func main() { extensionv1.Serve(extensionv1.Definition{ID: "codexrip.codex-runtime", Version: version, diff --git a/plugins/codex-runtime/internal/tickets/cutover_test.go b/plugins/codex-runtime/internal/tickets/cutover_test.go index e75257b6298b..e1b4a4e06f4a 100644 --- a/plugins/codex-runtime/internal/tickets/cutover_test.go +++ b/plugins/codex-runtime/internal/tickets/cutover_test.go @@ -30,7 +30,10 @@ func TestCanceledHarvestCannotPublishLateTicket(t *testing.T) { module.prepareProxy = func(context.Context, *extensionv1.Client, string, bool) (*http.Client, *ProxyResult, error) { return &http.Client{}, &ProxyResult{}, nil } - module.requestTicket = func(_ context.Context, _ *http.Client, identity extensionv1.OutboundIdentity, model string) (*Ticket, Outcome) { + host.probe = func(query extensionv1.CodexRoutingQuery) extensionv1.CodexRoutingProbeResult { + if query.Stage != "verify" { + return testRoutingProbe(host.account, query) + } if cancelByConfig { if err := module.ApplyConfig(context.Background(), json.RawMessage(`{"enabled":false}`)); err != nil { t.Fatal(err) @@ -40,8 +43,7 @@ func TestCanceledHarvestCannotPublishLateTicket(t *testing.T) { } else { cancel() } - now := time.Now().UTC() - return &Ticket{AccountID: identity.AccountID, Identity: identity.Identity, Model: model, State: "gAAAAA" + strings.Repeat("a", 286), CapturedAt: now, ExpiresAt: now.Add(TTL)}, Outcome{Success: true, Code: "ticket_ready"} + return testRoutingProbe(host.account, query) } raw, _ := json.Marshal(Operation{AccountID: 7, Model: "gpt-6-astra", OperationID: "cancel-me"}) result, err := module.Invoke(ctx, extensionv1.Invocation{Capability: extensionv1.CapabilityAdmin, Operation: "harvest", Payload: raw}) @@ -56,7 +58,7 @@ func TestCanceledHarvestCannotPublishLateTicket(t *testing.T) { stored := host.state[stateKey(7, "gpt-6-astra")] host.mu.Unlock() var state State - if json.Unmarshal(stored.Value, &state) != nil || state.Ticket != nil || state.NextAt != nil || state.Phase != "stopped" { + if json.Unmarshal(stored.Value, &state) != nil || state.Qualification != nil || state.NextAt != nil || state.Phase != "stopped" { t.Fatalf("canceled attempt enrolled: %s", stored.Value) } }) @@ -68,27 +70,41 @@ func TestTicketAdmissionAndInjectionShareIdentityValidityAndScope(t *testing.T) account := extensionv1.Account{ID: 7, Platform: "openai", Type: "setup-token", Identity: "principal", Status: "disabled"} for _, tc := range []struct { name string - change func(*Ticket, *extensionv1.SchedulingRequest) + change func(*extensionv1.CodexRoutingQualification, *extensionv1.SchedulingRequest) allow, inject bool }{ - {"valid", func(*Ticket, *extensionv1.SchedulingRequest) {}, true, true}, - {"expired", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.ExpiresAt = now }, false, false}, - {"wrong_length", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.State += "a" }, false, false}, - {"wrong_prefix", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.State = strings.Repeat("x", Length) }, false, false}, - {"wrong_owner", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.Identity = "other" }, false, false}, - {"wrong_account", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.AccountID++ }, false, false}, - {"wrong_model", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.Model = "gpt-5.6-sol" }, false, false}, - {"future_capture", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.CapturedAt = now.Add(time.Minute) }, false, false}, - {"excessive_ttl", func(t *Ticket, _ *extensionv1.SchedulingRequest) { t.ExpiresAt = now.Add(2 * time.Hour) }, false, false}, - {"ungated_model", func(_ *Ticket, r *extensionv1.SchedulingRequest) { r.Model = "gpt-5.5" }, true, false}, - {"shadow", func(_ *Ticket, r *extensionv1.SchedulingRequest) { r.Account.Shadow = true }, true, false}, - {"apikey", func(_ *Ticket, r *extensionv1.SchedulingRequest) { r.Account.Type = "apikey" }, true, false}, + {"valid", func(*extensionv1.CodexRoutingQualification, *extensionv1.SchedulingRequest) {}, true, true}, + {"expired", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { q.ExpiresAt = now }, false, false}, + {"missing_bundle", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { q.Bundle.Key = "" }, false, false}, + {"missing_revision", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { + q.Bundle.Revision = 0 + }, false, false}, + {"wrong_owner", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { + q.Scope.Identity = "other" + }, false, false}, + {"wrong_account", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { q.Scope.AccountID++ }, false, false}, + {"wrong_model", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { + q.Model = "gpt-5.6-sol" + }, false, false}, + {"future_verification", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { + q.VerifiedAt = now.Add(time.Minute) + }, false, false}, + {"excessive_ttl", func(q *extensionv1.CodexRoutingQualification, _ *extensionv1.SchedulingRequest) { + q.ExpiresAt = now.Add(2 * time.Hour) + }, false, false}, + {"ungated_model", func(_ *extensionv1.CodexRoutingQualification, r *extensionv1.SchedulingRequest) { r.Model = "gpt-5.5" }, true, false}, + {"shadow", func(_ *extensionv1.CodexRoutingQualification, r *extensionv1.SchedulingRequest) { + r.Account.Shadow = true + }, true, false}, + {"apikey", func(_ *extensionv1.CodexRoutingQualification, r *extensionv1.SchedulingRequest) { + r.Account.Type = "apikey" + }, true, false}, } { t.Run(tc.name, func(t *testing.T) { - ticket := &Ticket{AccountID: account.ID, Identity: account.Identity, Model: "gpt-6-astra", State: "gAAAAA" + strings.Repeat("a", 286), CapturedAt: now, ExpiresAt: now.Add(TTL)} - request := extensionv1.SchedulingRequest{Account: account, Model: ticket.Model, Now: now} - tc.change(ticket, &request) - rawState, _ := json.Marshal(State{Identity: account.Identity, Ticket: ticket}) + qualification := &extensionv1.CodexRoutingQualification{Scope: testRoutingScope(account), Model: "gpt-6-astra", VerifiedAt: now, ExpiresAt: now.Add(time.Minute), Bundle: extensionv1.CodexRoutingBundleRef{Key: "bundle.test", Revision: 1, ExpiresAt: now.Add(time.Minute)}} + request := extensionv1.SchedulingRequest{Account: account, Model: qualification.Model, Now: now} + tc.change(qualification, &request) + rawState, _ := json.Marshal(State{Schema: 2, Identity: account.Identity, Qualification: qualification}) host := &memoryHost{account: account, state: map[string]extensionv1.StateResult{stateKey(account.ID, "gpt-6-astra"): {Found: true, Value: rawState}}} module := NewModule() module.SetHost(testHostClient(t, host)) @@ -112,8 +128,8 @@ func TestTicketAdmissionAndInjectionShareIdentityValidityAndScope(t *testing.T) if (injection.Code == "") != tc.allow { t.Fatalf("injection disagrees with admission: %+v", injection) } - if strings.Contains(string(injection.Payload), ticket.State) != tc.inject { - t.Fatal("unexpected ticket injection") + if strings.Contains(string(injection.Payload), "routing_qualification") != tc.inject || strings.Contains(string(injection.Payload), "x-codex-turn-state") { + t.Fatal("unexpected opaque-state injection or missing qualification reference") } }) } diff --git a/plugins/codex-runtime/internal/tickets/module.go b/plugins/codex-runtime/internal/tickets/module.go index 71dccd813cf9..287e447fd3ca 100644 --- a/plugins/codex-runtime/internal/tickets/module.go +++ b/plugins/codex-runtime/internal/tickets/module.go @@ -24,6 +24,7 @@ import ( ) type Config struct { + RoutingSchema int `json:"routing_schema"` Enabled bool `json:"enabled"` FailClosed bool `json:"fail_closed"` ProxyURL string `json:"proxy_url"` @@ -33,32 +34,31 @@ type Config struct { } type Module struct { - mu sync.RWMutex - config Config - host *extensionv1.Client - epoch context.Context - cancel context.CancelFunc - slots chan struct{} - requestTicket func(context.Context, *http.Client, extensionv1.OutboundIdentity, string) (*Ticket, Outcome) - prepareProxy func(context.Context, *extensionv1.Client, string, bool) (*http.Client, *ProxyResult, error) + mu sync.RWMutex + config Config + host *extensionv1.Client + epoch context.Context + cancel context.CancelFunc + slots chan struct{} + prepareProxy func(context.Context, *extensionv1.Client, string, bool) (*http.Client, *ProxyResult, error) } func NewModule() *Module { ctx, cancel := context.WithCancel(context.Background()) - return &Module{config: Config{FailClosed: true, Models: []string{"gpt-6-astra", "gpt-5.6-sol"}, RequestZstd: true}, epoch: ctx, cancel: cancel, slots: make(chan struct{}, 5), requestTicket: probe, prepareProxy: prepareProxy} + return &Module{config: Config{RoutingSchema: 2, FailClosed: true, Models: []string{"gpt-6-astra", "gpt-6-sol", "gpt-6-luna"}, RequestZstd: true}, epoch: ctx, cancel: cancel, slots: make(chan struct{}, 5), prepareProxy: prepareProxy} } func (m *Module) SetHost(host *extensionv1.Client) { m.mu.Lock(); defer m.mu.Unlock(); m.host = host } func (m *Module) ValidateConfig(_ context.Context, raw json.RawMessage) (json.RawMessage, error) { - cfg := Config{FailClosed: true, Models: []string{"gpt-6-astra", "gpt-5.6-sol"}, RequestZstd: true} + cfg := Config{RoutingSchema: 2, FailClosed: true, Models: []string{"gpt-6-astra", "gpt-6-sol", "gpt-6-luna"}, RequestZstd: true} var fields map[string]json.RawMessage if json.Unmarshal(raw, &fields) != nil || fields == nil || json.Unmarshal(raw, &cfg) != nil { return nil, errors.New("invalid codex runtime configuration") } for key, value := range fields { switch key { - case "enabled", "fail_closed", "proxy_url", "proxy_protocol", "models", "request_zstd": + case "enabled", "fail_closed", "proxy_url", "proxy_protocol", "models", "request_zstd", "routing_schema": if bytes.Equal(bytes.TrimSpace(value), []byte("null")) { return nil, errors.New("null codex runtime setting") } @@ -66,6 +66,14 @@ func (m *Module) ValidateConfig(_ context.Context, raw json.RawMessage) (json.Ra return nil, errors.New("unknown codex runtime setting") } } + if cfg.RoutingSchema < 0 || cfg.RoutingSchema > 2 { + return nil, errors.New("unsupported routing schema") + } + _, schemaPresent := fields["routing_schema"] + if (!schemaPresent || cfg.RoutingSchema < 2) && len(cfg.Models) == 2 && slices.Contains(cfg.Models, "gpt-6-astra") && slices.Contains(cfg.Models, "gpt-5.6-sol") { + cfg.Models = append(cfg.Models, "gpt-6-sol", "gpt-6-luna") + } + cfg.RoutingSchema = 2 if len(cfg.Models) == 0 || len(cfg.Models) > 32 { return nil, errors.New("ticket model list required") } @@ -104,7 +112,8 @@ func (m *Module) ApplyConfig(ctx context.Context, raw json.RawMessage) error { m.cancel() m.epoch, m.cancel = context.WithCancel(context.Background()) m.config = cfg - if cfg.Enabled && m.host != nil { + if m.host != nil { + go m.migrateRoutingStates(m.epoch, m.host, cfg) go m.renew(m.epoch, m.host, cfg) } return nil @@ -124,6 +133,11 @@ func (m *Module) renew(ctx context.Context, host *extensionv1.Client, cfg Config } func (m *Module) renewOnce(ctx context.Context, host *extensionv1.Client, cfg Config) { + var redacted map[string]int + _ = hostCall(ctx, host, extensionv1.HostCodexRoutingCleanup, struct{}{}, &redacted) + if !cfg.Enabled { + return + } var due []extensionv1.DueState if hostCall(ctx, host, extensionv1.HostStateDue, extensionv1.DueStateRequest{Namespace: "tickets", Limit: 100}, &due) != nil { return @@ -135,7 +149,8 @@ func (m *Module) renewOnce(ctx context.Context, host *extensionv1.Client, cfg Co continue } running := state.Phase == "manual_running" || state.Phase == "pre_running" || state.Phase == "post_running" - if !running && (state.Ticket == nil || (state.Phase != "ready" && state.Phase != "retry")) { + state.migrateRouting() + if !running && (!state.Enrolled || state.Phase == "stopped") { continue } // The namespace key remains available when a first attempt crashed before @@ -147,6 +162,13 @@ func (m *Module) renewOnce(ctx context.Context, host *extensionv1.Client, cfg Co } for _, model := range cfg.Models { if record.Key == stateKey(id, model) { + if !running && !hasRoutingDemand(ctx, host, id, model) { + // Remove dormant rows from the due index; otherwise the first + // hundred idle accounts can starve a later demanded account. + state.NextAt = nil + _, _ = writeState(ctx, host, id, model, state, record.Revision) + continue + } queue <- Operation{AccountID: id, Model: model} break } @@ -172,7 +194,7 @@ func (m *Module) renewOnce(ctx context.Context, host *extensionv1.Client, cfg Co func (m *Module) Status(context.Context) (json.RawMessage, error) { m.mu.RLock() defer m.mu.RUnlock() - return json.Marshal(map[string]any{"enabled": m.config.Enabled, "proxy_configured": m.config.ProxyURL != "", "models": m.config.Models, "request_zstd": m.config.RequestZstd}) + return json.Marshal(map[string]any{"enabled": m.config.Enabled, "proxy_configured": m.config.ProxyURL != "", "models": m.config.Models, "request_zstd": m.config.RequestZstd, "routing_schema": extensionv1.CodexRoutingSchema, "cookie_max_age_seconds": 120, "refresh_lead_seconds": 20}) } type Operation struct { @@ -183,11 +205,12 @@ type Operation struct { } type Outcome struct { - Success bool `json:"success"` - Code string `json:"code"` - HTTPStatus int `json:"http_status,omitempty"` - ObservedLength int `json:"observed_length,omitempty"` - ExpiresAt *time.Time `json:"expires_at,omitempty"` + Success bool `json:"success"` + Code string `json:"code"` + HTTPStatus int `json:"http_status,omitempty"` + ObservedLength int `json:"observed_length,omitempty"` + ExpiresAt *time.Time `json:"expires_at,omitempty"` + Observation *extensionv1.CodexRoutingObservation `json:"observation,omitempty"` } func (m *Module) Invoke(ctx context.Context, in extensionv1.Invocation) (extensionv1.Result, error) { @@ -221,6 +244,18 @@ func (m *Module) Invoke(ctx context.Context, in extensionv1.Invocation) (extensi var value any var err error switch { + case in.Capability == extensionv1.CapabilityRequest && in.Operation == "codex.routing.demand": + var req extensionv1.CodexRoutingDemand + if json.Unmarshal(in.Payload, &req) != nil || req.AccountID <= 0 || !slices.Contains(cfg.Models, req.Model) { + return extensionv1.Result{}, errors.New("invalid routing demand") + } + value, err = m.recordRoutingDemand(ctx, host, cfg, req) + case in.Capability == extensionv1.CapabilityRequest && in.Operation == "codex.routing.observe": + var req extensionv1.CodexRoutingResponse + if json.Unmarshal(in.Payload, &req) != nil { + return extensionv1.Result{}, errors.New("invalid routing observation") + } + value, err = observeRoutingResponse(ctx, host, req) case in.Capability == extensionv1.CapabilityScheduling && in.Operation == "describe": rules := []extensionv1.SchedulingRule{} if cfg.Enabled && cfg.FailClosed { @@ -260,7 +295,7 @@ func (m *Module) Invoke(ctx context.Context, in extensionv1.Invocation) (extensi if readErr != nil { return extensionv1.Result{}, readErr } - if !state.Ticket.Valid(req.Now, req.Account.ID, req.Account.Identity, req.Model) { + if !state.Qualification.Valid(req.Now, req.Account.ID, req.Account.Identity, req.Model) { decision = extensionv1.SchedulingDecision{Allowed: false, Reason: "ticket_missing", Scope: req.Model} } } @@ -270,19 +305,34 @@ func (m *Module) Invoke(ctx context.Context, in extensionv1.Invocation) (extensi if json.Unmarshal(in.Payload, &req) != nil { return extensionv1.Result{}, errors.New("invalid ticket injection request") } - headers := map[string]string{} + injection := extensionv1.CodexRoutingInjection{Headers: map[string]string{}} if cfg.Enabled && slices.Contains(cfg.Models, req.Model) && Eligible(req.Account.Platform, req.Account.Type, req.Account.Shadow) { - state, _, readErr := readState(ctx, host, req.Account.ID, req.Model) + state, revision, readErr := readState(ctx, host, req.Account.ID, req.Model) if readErr != nil { return extensionv1.Result{}, readErr } - if state.Ticket.Valid(req.Now, req.Account.ID, req.Account.Identity, req.Model) { - headers["x-codex-turn-state"] = state.Ticket.State + if state.Qualification.Valid(req.Now, req.Account.ID, req.Account.Identity, req.Model) { + var checked extensionv1.CodexRoutingProbeResult + q := state.Qualification + if checkErr := hostCall(ctx, host, extensionv1.HostCodexRoutingCheck, extensionv1.CodexRoutingQuery{AccountID: req.Account.ID, Model: req.Model, Transport: q.Scope.Transport, Bundle: &q.Bundle, Scope: &q.Scope}, &checked); checkErr != nil || !checked.Valid { + if state.Phase != "manual_running" && state.Phase != "pre_running" && state.Phase != "post_running" { + state.Qualification, state.ExpiresAt = nil, nil + state.LastCode = "routing_stale" + if state.Phase != "stopped" && state.Enrolled { + state.Phase = "needs_cookie_verification" + now := time.Now().UTC() + state.NextAt = &now + } + _, _ = writeState(ctx, host, req.Account.ID, req.Model, state, revision) + } + return extensionv1.Result{Code: "routing_stale"}, nil + } + injection.Qualification = q } else if cfg.FailClosed { return extensionv1.Result{Code: "ticket_missing"}, nil } } - value = map[string]any{"headers": headers} + value = injection case in.Capability == extensionv1.CapabilityAdmin && in.Operation == "harvest", in.Capability == extensionv1.CapabilityJobs && in.Operation == "renew": var req Operation if json.Unmarshal(in.Payload, &req) != nil || req.AccountID <= 0 { @@ -354,6 +404,7 @@ func readState(ctx context.Context, host *extensionv1.Client, id int64, model st if err == nil && result.Found { err = json.Unmarshal(result.Value, &state) } + state.migrateRouting() return state, result.Revision, err } @@ -367,19 +418,19 @@ func writeState(ctx context.Context, host *extensionv1.Client, id int64, model s if state.LastAttemptAt != nil && (state.Phase == "manual_running" || state.Phase == "pre_running" || state.Phase == "post_running") { // Index an abandoned attempt for recovery after its execution lease, but // keep NextAt in the domain state empty: this is never a retry permission. - recoverAt := state.LastAttemptAt.Add(30 * time.Second) + recoverAt := state.LastAttemptAt.Add(75 * time.Second) request.NextAt = &recoverAt } if state.Identity != "" { constraint := extensionv1.SchedulingConstraint{Model: model, Effect: "deny", Reason: "ticket_missing"} - if state.Ticket.Valid(time.Now().UTC(), id, state.Identity, model) { + if state.Qualification.Valid(time.Now().UTC(), id, state.Identity, model) { constraint.Effect = "allow" - constraint.Until = &state.Ticket.ExpiresAt - constraint.Reason = "ticket_ready" + constraint.Until = &state.Qualification.ExpiresAt + constraint.Reason = "routing_verified" } - observation := extensionv1.AccountObservation{Key: model, Kind: "codex_ticket", State: state.Phase, ExpiresAt: state.ExpiresAt, NextAt: state.NextAt, CheckedAt: state.LastAttemptAt, Code: state.LastCode} - if state.Ticket != nil { - observation.Count = len(state.Ticket.State) + observation := extensionv1.AccountObservation{Key: model, Kind: "codex_routing", State: state.Phase, ExpiresAt: state.ExpiresAt, NextAt: state.NextAt, CheckedAt: state.LastAttemptAt, Code: state.LastCode} + if state.Observation != nil { + observation.Count = state.Observation.StateLength } request.Projection = &extensionv1.AccountProjection{AccountID: id, Identity: state.Identity, Scheduling: []extensionv1.SchedulingConstraint{constraint}, Observations: []extensionv1.AccountObservation{observation}} } @@ -390,192 +441,6 @@ func writeState(ctx context.Context, host *extensionv1.Client, id int64, model s return result.Revision, err } -func (m *Module) harvest(ctx, epoch context.Context, host *extensionv1.Client, cfg Config, req Operation, manual bool) (Outcome, error) { - if !cfg.Enabled { - return Outcome{Code: "ticket_disabled"}, nil - } - if !slices.Contains(cfg.Models, req.Model) { - return Outcome{Code: "ticket_model_invalid"}, nil - } - if cfg.ProxyURL == "" { - return Outcome{Code: "ticket_proxy_missing"}, nil - } - if manual && (req.OperationID == "" || len(req.OperationID) > 256) { - return Outcome{Code: "ticket_operation_required"}, nil - } - select { - case m.slots <- struct{}{}: - defer func() { <-m.slots }() - case <-ctx.Done(): - return Outcome{Code: "ticket_canceled"}, nil - } - ctx, cancel := context.WithTimeout(ctx, 25*time.Second) - defer cancel() - var account extensionv1.Account - if err := hostCall(ctx, host, extensionv1.HostAccountRead, extensionv1.AccountQuery{AccountID: req.AccountID}, &account); err != nil { - return Outcome{}, err - } - if !Eligible(account.Platform, account.Type, account.Shadow) { - return Outcome{Code: "ticket_ineligible"}, nil - } - var nonce [16]byte - if _, err := rand.Read(nonce[:]); err != nil { - return Outcome{}, err - } - lease := extensionv1.LeaseRequest{Namespace: "tickets", Key: stateKey(req.AccountID, req.Model), Owner: hex.EncodeToString(nonce[:]), TTLSeconds: 30} - var acquired extensionv1.LeaseResult - if err := hostCall(ctx, host, extensionv1.HostLeaseAcquire, lease, &acquired); err != nil { - return Outcome{}, err - } - if !acquired.Acquired { - return Outcome{Code: "ticket_busy"}, nil - } - lease.Generation = acquired.Generation - defer func() { - releaseCtx, releaseCancel := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second) - defer releaseCancel() - var result extensionv1.LeaseResult - _ = hostCall(releaseCtx, host, extensionv1.HostLeaseRelease, lease, &result) - }() - state, revision, err := readState(ctx, host, req.AccountID, req.Model) - if err != nil { - return Outcome{}, err - } - now := time.Now().UTC() - if manual && !req.Force && state.Ticket.Valid(now, account.ID, account.Identity, req.Model) { - return Outcome{Success: true, Code: "ticket_skipped", ExpiresAt: &state.Ticket.ExpiresAt}, nil - } - if req.OperationID != "" && state.OperationID == req.OperationID { - return Outcome{Code: "ticket_interrupted"}, nil - } - if (state.Identity != "" && state.Identity != account.Identity) || (state.Ticket != nil && state.Ticket.Identity != account.Identity) { - state = State{Phase: "stopped", Identity: account.Identity} - revision, err = writeState(ctx, host, req.AccountID, req.Model, state, revision) - if err != nil { - return Outcome{}, err - } - if !manual { - return Outcome{Code: "ticket_stale"}, nil - } - } - // Owning a fresh lease proves no previous process still owns this attempt. - // Never replay its automatic stage; only a new explicit manual operation may - // enroll it again. - if state.Phase == "manual_running" || state.Phase == "pre_running" || state.Phase == "post_running" { - state.Stop() - state.LastCode = "ticket_interrupted" - revision, err = writeState(ctx, host, req.AccountID, req.Model, state, revision) - if err != nil { - return Outcome{}, err - } - if !manual { - return Outcome{Code: "ticket_interrupted"}, nil - } - } - state.Identity = account.Identity - if err = state.Begin(now, manual); err != nil { - if errors.Is(err, ErrNotDue) && state.Phase == "retry" { - if _, writeErr := writeState(ctx, host, req.AccountID, req.Model, state, revision); writeErr != nil { - return Outcome{}, writeErr - } - } - return Outcome{Code: err.Error()}, nil - } - state.OperationID = req.OperationID - revision, err = writeState(ctx, host, req.AccountID, req.Model, state, revision) - if err != nil { - return Outcome{}, err - } - var identity extensionv1.OutboundIdentity - outcome := Outcome{Code: "ticket_token"} - var ticket *Ticket - client, proxyResult, proxyErr := m.prepareProxy(ctx, host, cfg.ProxyURL, false) - if client != nil { - defer client.CloseIdleConnections() - } - if proxyErr != nil { - outcome.Code = "ticket_proxy_connect" - if proxyResult != nil && proxyResult.Code != "" { - outcome.Code = proxyResult.Code - } - } else if err = hostCall(ctx, host, extensionv1.HostResolveIdentity, extensionv1.AccountQuery{AccountID: account.ID, PrepareCredentials: true}, &identity); err == nil { - if identity.ObservationID != "" { - defer func() { - endCtx, endCancel := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second) - defer endCancel() - var result map[string]bool - _ = hostCall(endCtx, host, extensionv1.HostFinishObservation, extensionv1.AccountQuery{AccountID: account.ID, ObservationID: identity.ObservationID}, &result) - }() - } - if identity.Identity == account.Identity { - ticket, outcome = m.requestTicket(ctx, client, identity, req.Model) - } else { - outcome.Code = "ticket_stale" - } - } - finishCtx, finishCancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) - defer finishCancel() - var current extensionv1.Account - if err := hostCall(finishCtx, host, extensionv1.HostAccountRead, extensionv1.AccountQuery{AccountID: account.ID}, ¤t); err != nil || current.Identity != account.Identity { - return Outcome{Code: "ticket_stale"}, nil - } - // Cancellation revokes this attempt, even when an upstream returned a - // successful header at the same time. Retain the spent stage durably without - // publishing the late ticket or enrolling it for renewal. - if ctx.Err() != nil || epoch.Err() != nil { - ticket = nil - outcome = Outcome{Code: "ticket_canceled"} - } - state.Complete(time.Now().UTC(), ticket, outcome.Code) - if _, err = writeState(finishCtx, host, req.AccountID, req.Model, state, revision); err != nil { - return Outcome{Code: "ticket_persist"}, err - } - return outcome, nil -} - -func probe(ctx context.Context, client *http.Client, identity extensionv1.OutboundIdentity, model string) (*Ticket, Outcome) { - body, _ := json.Marshal(map[string]any{"model": model, "store": false, "stream": true, "instructions": "Reply with exactly: pong", "input": []any{map[string]any{"role": "user", "content": []any{map[string]any{"type": "input_text", "text": "ping"}}}}}) - req, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://chatgpt.com/backend-api/codex/responses", bytes.NewReader(body)) - if err != nil { - return nil, Outcome{Code: "ticket_transport"} - } - req.Header = http.Header(identity.Headers).Clone() - if req.Header == nil { - req.Header = make(http.Header) - } - req.Header.Set("Authorization", "Bearer "+identity.Token) - req.Header.Set("Accept", "text/event-stream") - req.Header.Set("Content-Type", "application/json") - req.Header.Set("OpenAI-Beta", "responses=experimental") - applyHarvestIdentity(req.Header, model) - req.Header.Set("session_id", newSessionID()) - req.Close = true - response, err := client.Do(req) - if err != nil { - return nil, Outcome{Code: "ticket_transport"} - } - defer response.Body.Close() - value := strings.TrimSpace(response.Header.Get("x-codex-turn-state")) - outcome := Outcome{Code: "ticket_upstream", HTTPStatus: response.StatusCode, ObservedLength: len(value)} - if response.StatusCode != http.StatusOK { - return nil, outcome - } - if len(value) != Length { - outcome.Code = "ticket_length" - return nil, outcome - } - if !strings.HasPrefix(value, "gAAAAA") { - outcome.Code = "ticket_prefix" - return nil, outcome - } - now := time.Now().UTC() - ticket := &Ticket{State: value, AccountID: identity.AccountID, Identity: identity.Identity, Model: model, CapturedAt: now, ExpiresAt: now.Add(TTL)} - outcome.Success = true - outcome.Code = "ticket_ready" - outcome.ExpiresAt = &ticket.ExpiresAt - return ticket, outcome -} - func newSessionID() string { var value [16]byte _, _ = rand.Read(value[:]) diff --git a/plugins/codex-runtime/internal/tickets/module_test.go b/plugins/codex-runtime/internal/tickets/module_test.go index 1778cf60a4c0..0a3f40e14379 100644 --- a/plugins/codex-runtime/internal/tickets/module_test.go +++ b/plugins/codex-runtime/internal/tickets/module_test.go @@ -5,7 +5,6 @@ import ( "encoding/json" "errors" "net" - "net/http" "strings" "sync" "sync/atomic" @@ -19,12 +18,14 @@ import ( ) type memoryHost struct { - mu sync.Mutex - state map[string]extensionv1.StateResult - lease map[string]int64 - sequence int64 - account extensionv1.Account - due []extensionv1.DueState + mu sync.Mutex + state map[string]extensionv1.StateResult + lease map[string]int64 + sequence int64 + account extensionv1.Account + due []extensionv1.DueState + probe func(extensionv1.CodexRoutingQuery) extensionv1.CodexRoutingProbeResult + checkInvalid bool } func TestInvalidConfigurationCannotStopCurrentTicketEpoch(t *testing.T) { @@ -62,10 +63,25 @@ func TestTransportSettingDoesNotDependOnTicketAcquisitionSwitch(t *testing.T) { } func (h *memoryHost) Call(_ context.Context, in extensionv1.HostInvocation) (extensionv1.Result, error) { + if in.Operation == extensionv1.HostCodexRoutingProbe { + var query extensionv1.CodexRoutingQuery + if json.Unmarshal(in.Payload, &query) != nil { + return extensionv1.Result{}, errors.New("invalid probe") + } + value := h.probe(query) + raw, err := json.Marshal(value) + return extensionv1.Result{Payload: raw}, err + } h.mu.Lock() defer h.mu.Unlock() var value any switch in.Operation { + case extensionv1.HostAccountList: + value = []extensionv1.Account{} + case extensionv1.HostCodexRoutingScope: + value = testRoutingScope(h.account) + case extensionv1.HostCodexRoutingCheck: + value = extensionv1.CodexRoutingProbeResult{Valid: !h.checkInvalid} case extensionv1.HostAccountRead: value = h.account case extensionv1.HostResolveIdentity: @@ -75,11 +91,15 @@ func (h *memoryHost) Call(_ context.Context, in extensionv1.HostInvocation) (ext if err := json.Unmarshal(in.Payload, &req); err != nil { return extensionv1.Result{}, err } - current := h.state[req.Key] + key := req.Key + if req.Namespace != "tickets" { + key = req.Namespace + ":" + key + } + current := h.state[key] current.Applied = false if in.Operation == extensionv1.HostStateCompareSwap && current.Revision == req.ExpectedRevision { current = extensionv1.StateResult{Found: true, Applied: true, Revision: current.Revision + 1, Value: append([]byte(nil), req.Value...)} - h.state[req.Key] = current + h.state[key] = current } value = current case extensionv1.HostStateDue: @@ -133,18 +153,10 @@ func TestModulePersistsManualLifecycleAndNeverReturnsTicketToAdmin(t *testing.T) } t.Cleanup(func() { module.mu.Lock(); module.cancel(); module.mu.Unlock() }) var requests atomic.Int32 - material := "gAAAAA" + strings.Repeat("a", 286) - module.prepareProxy = func(context.Context, *extensionv1.Client, string, bool) (*http.Client, *ProxyResult, error) { - return &http.Client{}, &ProxyResult{NetworkReachable: true}, nil - } - module.requestTicket = func(_ context.Context, _ *http.Client, identity extensionv1.OutboundIdentity, model string) (*Ticket, Outcome) { + material := "secret-cookie-material" + host.probe = func(query extensionv1.CodexRoutingQuery) extensionv1.CodexRoutingProbeResult { requests.Add(1) - if identity.Token != "test-only" || identity.Identity != "principal" { - t.Error("wrong prepared credential") - } - now := time.Now().UTC() - ticket := &Ticket{State: material, AccountID: identity.AccountID, Identity: identity.Identity, Model: model, CapturedAt: now, ExpiresAt: now.Add(TTL)} - return ticket, Outcome{Success: true, Code: "ticket_ready", ObservedLength: 292, HTTPStatus: 200, ExpiresAt: &ticket.ExpiresAt} + return testRoutingProbe(host.account, query) } invoke := func(capability, operation string, payload any) extensionv1.Result { t.Helper() @@ -160,12 +172,12 @@ func TestModulePersistsManualLifecycleAndNeverReturnsTicketToAdmin(t *testing.T) if strings.Contains(string(result.Payload), material) || !strings.Contains(string(result.Payload), `"success":true`) { t.Fatalf("unsafe/failed admin outcome: %s", result.Payload) } - if requests.Load() != 1 { - t.Fatal("first manual attempt not singular") + if requests.Load() != 2 { + t.Fatal("one acquisition and one verification required") } request.OperationID = "manual-2" invoke(extensionv1.CapabilityAdmin, "harvest", request) - if requests.Load() != 1 { + if requests.Load() != 2 { t.Fatal("valid ticket caused another upstream request") } admission := extensionv1.SchedulingRequest{Account: host.account, Model: request.Model, Now: time.Now().UTC()} @@ -175,8 +187,8 @@ func TestModulePersistsManualLifecycleAndNeverReturnsTicketToAdmin(t *testing.T) t.Fatal("prepared inactive credential was not available for ticket admission") } result = invoke(extensionv1.CapabilityRequest, "inject", admission) - if !strings.Contains(string(result.Payload), material) { - t.Fatal("internal request hook did not supply the stored ticket") + if strings.Contains(string(result.Payload), material) || !strings.Contains(string(result.Payload), "routing_qualification") || strings.Contains(string(result.Payload), "x-codex-turn-state") { + t.Fatal("internal request hook must return only qualification reference") } invoke(extensionv1.CapabilityAdmin, "stop", request) host.mu.Lock() @@ -195,7 +207,17 @@ func TestModulePersistsManualLifecycleAndNeverReturnsTicketToAdmin(t *testing.T) host.mu.Lock() after := host.state[stateKey(7, request.Model)] host.mu.Unlock() - if after.Revision != stored.Revision || requests.Load() != 1 { + if after.Revision != stored.Revision || requests.Load() != 2 { t.Fatal("configuration changes resurrected stopped renewal") } } + +func testRoutingScope(account extensionv1.Account) extensionv1.CodexRoutingScope { + return extensionv1.CodexRoutingScope{AccountID: account.ID, Identity: account.Identity, ProfileHash: "profile", RouteHash: "route", Transport: "http"} +} + +func testRoutingProbe(account extensionv1.Account, query extensionv1.CodexRoutingQuery) extensionv1.CodexRoutingProbeResult { + scope := testRoutingScope(account) + scope.ConnectionLeaseID, scope.RouteEvidence = "physical-connection", "connection" + return extensionv1.CodexRoutingProbeResult{Scope: scope, Valid: true, Bundle: &extensionv1.CodexRoutingBundleRef{Key: "bundle.reference", Revision: 1, ExpiresAt: time.Now().Add(100 * time.Second), ConnectionLeaseID: scope.ConnectionLeaseID}, Observation: extensionv1.CodexRoutingObservation{Stage: query.Stage, Code: "routing_verified", RequestedModel: query.Model, ResponseModel: query.Model, Completed: true, ModelMatched: true, StateLength: 312, HTTPStatus: 200}} +} diff --git a/plugins/codex-runtime/internal/tickets/outcome.go b/plugins/codex-runtime/internal/tickets/outcome.go index 4859d2cb1794..9accb785c119 100644 --- a/plugins/codex-runtime/internal/tickets/outcome.go +++ b/plugins/codex-runtime/internal/tickets/outcome.go @@ -11,6 +11,12 @@ import ( func (o Outcome) MarshalJSON() ([]byte, error) { type wire Outcome message := map[string]string{ + "routing_verified": "Cookie 已通过同账号业务出口完整响应验证", "routing_candidate": "已取得候选 Cookie，尚未获得业务出口资格", + "routing_model_mismatch": "完整响应模型不匹配，未发布路由资格", "routing_incomplete": "响应未完整结束或缺少原始模型，未发布路由资格", + "routing_cookie_missing": "响应未给出可用路由 Cookie", "routing_cookie_expired": "Cookie 已到期，需要重新验证", + "routing_transport": "采集或业务出口验证连接失败", "routing_stale": "账号主体、出口、指纹或 Cookie 代次已变化", + "routing_cookie_deleted": "上游已撤销路由 Cookie", "routing_budget_spent": "本次验证的固定调用预算已使用", + "routing_upstream": "上游拒绝路由验证请求", "routing_connection_unknown": "无法绑定经过验证的实际连接", "ticket_ready": "已取得有效292票据", "ticket_skipped": "已有有效票据，本次跳过", "ticket_stopped": "自动续期已停止", "ticket_disabled": "票据功能已关闭", "ticket_model_invalid": "模型不在票据配置范围内", "ticket_proxy_missing": "尚未配置采集代理", "ticket_busy": "账号和模型已有进行中的操作", "ticket_interrupted": "前次请求结果未确认，未重复发送", "ticket_not_due": "未到续期时间", diff --git a/plugins/codex-runtime/internal/tickets/proxy_test.go b/plugins/codex-runtime/internal/tickets/proxy_test.go index 4e78251860be..da1290d58500 100644 --- a/plugins/codex-runtime/internal/tickets/proxy_test.go +++ b/plugins/codex-runtime/internal/tickets/proxy_test.go @@ -140,9 +140,18 @@ func TestProxyPreflightAndHarvestUseSamePinnedTransport(t *testing.T) { if result.Success || !result.NetworkReachable || result.HTTPStatus != 405 || result.CertificateTrust != "proxy_certificate_pinned" { t.Fatalf("preflight confused transport success with inference success: %+v", result) } - ticket, outcome := probe(ctx, client, extensionv1.OutboundIdentity{AccountID: 7, Identity: "subject", Token: "synthetic-oauth"}, "gpt-6-astra") - if !outcome.Success || ticket == nil || ticket.State != material { - t.Fatalf("pinned harvest failed: %+v", outcome) + request, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://chatgpt.com/backend-api/codex/responses", strings.NewReader(`{"model":"synthetic-model"}`)) + if err != nil { + t.Fatal(err) + } + request.Header.Set("Authorization", "Bearer synthetic-oauth") + response, err := client.Do(request) + if err != nil { + t.Fatal(err) + } + _ = response.Body.Close() + if response.StatusCode != http.StatusOK || response.Header.Get("x-codex-turn-state") != material { + t.Fatal("authenticated request did not use the pinned transport") } mu.Lock() defer mu.Unlock() diff --git a/plugins/codex-runtime/internal/tickets/routing.go b/plugins/codex-runtime/internal/tickets/routing.go new file mode 100644 index 000000000000..37fb5ed7c79b --- /dev/null +++ b/plugins/codex-runtime/internal/tickets/routing.go @@ -0,0 +1,249 @@ +package tickets + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "slices" + "strconv" + "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +func (m *Module) harvest(ctx, epoch context.Context, host *extensionv1.Client, cfg Config, req Operation, manual bool) (Outcome, error) { + if !cfg.Enabled { + return Outcome{Code: "ticket_disabled"}, nil + } + if !slices.Contains(cfg.Models, req.Model) { + return Outcome{Code: "ticket_model_invalid"}, nil + } + if cfg.ProxyURL == "" { + return Outcome{Code: "ticket_proxy_missing"}, nil + } + if manual && (req.OperationID == "" || len(req.OperationID) > 256) { + return Outcome{Code: "ticket_operation_required"}, nil + } + select { + case m.slots <- struct{}{}: + defer func() { <-m.slots }() + case <-ctx.Done(): + return Outcome{Code: "ticket_canceled"}, nil + } + ctx, cancel := context.WithTimeout(ctx, 60*time.Second) + defer cancel() + var account extensionv1.Account + if err := hostCall(ctx, host, extensionv1.HostAccountRead, extensionv1.AccountQuery{AccountID: req.AccountID}, &account); err != nil { + return Outcome{}, err + } + if !Eligible(account.Platform, account.Type, account.Shadow) { + return Outcome{Code: "ticket_ineligible"}, nil + } + // Cookie jars are account-scoped, not model-scoped. Serialize all models of + // one account while retaining independent per-model qualification records. + lease := extensionv1.LeaseRequest{Namespace: "routing-account", Key: strconv.FormatInt(account.ID, 10), Owner: newSessionID(), TTLSeconds: 75} + var acquired extensionv1.LeaseResult + if err := hostCall(ctx, host, extensionv1.HostLeaseAcquire, lease, &acquired); err != nil { + return Outcome{}, err + } + if !acquired.Acquired { + return Outcome{Code: "ticket_busy"}, nil + } + lease.Generation = acquired.Generation + defer func() { + finish, stop := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second) + defer stop() + var released extensionv1.LeaseResult + _ = hostCall(finish, host, extensionv1.HostLeaseRelease, lease, &released) + }() + state, revision, err := readState(ctx, host, account.ID, req.Model) + if err != nil { + return Outcome{}, err + } + now := time.Now().UTC() + if req.OperationID != "" && state.OperationID == req.OperationID { + return Outcome{Code: "ticket_interrupted"}, nil + } + if state.Identity != "" && state.Identity != account.Identity { + state = State{Schema: extensionv1.CodexRoutingSchema, Identity: account.Identity, Phase: "stopped"} + if !manual { + _, err = writeState(ctx, host, account.ID, req.Model, state, revision) + return Outcome{Code: "ticket_stale"}, err + } + } + if state.Phase == "manual_running" || state.Phase == "pre_running" || state.Phase == "post_running" { + state.Stop() + state.LastCode = "ticket_interrupted" + revision, err = writeState(ctx, host, account.ID, req.Model, state, revision) + if err != nil { + return Outcome{}, err + } + if !manual { + return Outcome{Code: "ticket_interrupted"}, nil + } + } + if manual && !req.Force && state.Qualification.Valid(now, account.ID, account.Identity, req.Model) { + var checked extensionv1.CodexRoutingProbeResult + q := state.Qualification + if hostCall(ctx, host, extensionv1.HostCodexRoutingCheck, extensionv1.CodexRoutingQuery{AccountID: account.ID, Model: req.Model, Scope: &q.Scope, Bundle: &q.Bundle, Transport: q.Scope.Transport}, &checked) == nil && checked.Valid { + return Outcome{Success: true, Code: "ticket_skipped", ExpiresAt: &q.ExpiresAt}, nil + } + } + state.Identity = account.Identity + if err = state.beginRouting(now, manual); err != nil { + return Outcome{Code: err.Error()}, nil + } + if req.OperationID == "" { + req.OperationID = fmt.Sprintf("renew-%s", lease.Owner) + } + state.OperationID = req.OperationID + revision, err = writeState(ctx, host, account.ID, req.Model, state, revision) + if err != nil { + return Outcome{}, err + } + observation := extensionv1.CodexRoutingObservation{Stage: "configuration", Code: "routing_unavailable", RequestedModel: req.Model, ObservedAt: now} + var scope extensionv1.CodexRoutingScope + var qualified *extensionv1.CodexRoutingQualification + if scopeErr := hostCall(ctx, host, extensionv1.HostCodexRoutingScope, extensionv1.CodexRoutingQuery{AccountID: account.ID, Transport: "http"}, &scope); scopeErr == nil && scope.Identity == account.Identity { + query := extensionv1.CodexRoutingQuery{AccountID: account.ID, Model: req.Model, Transport: "http", Stage: "acquire", OperationID: req.OperationID, Scope: &scope} + var candidate extensionv1.CodexRoutingProbeResult + if err := hostCall(ctx, host, extensionv1.HostCodexRoutingProbe, query, &candidate); err == nil { + observation = candidate.Observation + if candidate.Valid && candidate.Bundle != nil && candidate.Scope.SameOwner(scope) { + query.Stage, query.Bundle = "verify", candidate.Bundle + var result extensionv1.CodexRoutingProbeResult + if err := hostCall(ctx, host, extensionv1.HostCodexRoutingProbe, query, &result); err == nil { + observation = result.Observation + if result.Valid && result.Bundle != nil && result.Scope.SameOwner(scope) && result.Observation.Completed && result.Observation.ModelMatched && result.Observation.ResponseModel == req.Model && result.Scope.ConnectionLeaseID != "" { + verified := time.Now().UTC() + qualified = &extensionv1.CodexRoutingQualification{Scope: result.Scope, Bundle: *result.Bundle, Model: req.Model, VerifiedAt: verified, ExpiresAt: result.Bundle.ExpiresAt} + } + } else { + observation.Code = "routing_transport" + } + } + } else { + observation.Code = "routing_transport" + } + } + finish, stop := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) + defer stop() + var current extensionv1.Account + if err := hostCall(finish, host, extensionv1.HostAccountRead, extensionv1.AccountQuery{AccountID: account.ID}, ¤t); err != nil || current.Identity != account.Identity { + return Outcome{Code: "ticket_stale"}, nil + } + if ctx.Err() != nil || epoch.Err() != nil { + qualified = nil + observation.Code = "ticket_canceled" + } + state.completeRouting(time.Now().UTC(), qualified, observation) + if _, err := writeState(finish, host, account.ID, req.Model, state, revision); err != nil { + return Outcome{Code: "ticket_persist"}, err + } + return Outcome{Success: qualified != nil, Code: observation.Code, HTTPStatus: observation.HTTPStatus, ObservedLength: observation.StateLength, ExpiresAt: state.ExpiresAt, Observation: &observation}, nil +} + +func (m *Module) migrateRoutingStates(ctx context.Context, host *extensionv1.Client, cfg Config) { + var accounts []extensionv1.Account + if hostCall(ctx, host, extensionv1.HostAccountList, extensionv1.AccountQuery{Platform: "openai", IncludeInactive: true}, &accounts) != nil { + return + } + for _, account := range accounts { + if !Eligible(account.Platform, account.Type, account.Shadow) { + continue + } + for _, model := range cfg.Models { + var record extensionv1.StateResult + if hostCall(ctx, host, extensionv1.HostStateRead, extensionv1.StateRequest{Namespace: "tickets", Key: stateKey(account.ID, model)}, &record) != nil { + continue + } + if !record.Found { + _, _ = writeState(ctx, host, account.ID, model, State{Schema: 2, Identity: account.Identity, Phase: "needs_cookie_verification"}, 0) + continue + } + var state State + if json.Unmarshal(record.Value, &state) != nil || state.Schema >= extensionv1.CodexRoutingSchema { + continue + } + state.migrateRouting() + _, _ = writeState(ctx, host, account.ID, model, state, record.Revision) + } + } +} + +type routingDemand struct { + At time.Time `json:"at"` +} + +func hasRoutingDemand(ctx context.Context, host *extensionv1.Client, id int64, model string) bool { + var record extensionv1.StateResult + var demand routingDemand + return hostCall(ctx, host, extensionv1.HostStateRead, extensionv1.StateRequest{Namespace: "routing-demand", Key: stateKey(id, model)}, &record) == nil && record.Found && json.Unmarshal(record.Value, &demand) == nil && time.Since(demand.At) >= 0 && time.Since(demand.At) <= extensionv1.CodexRoutingMaxAge +} + +func (m *Module) recordRoutingDemand(ctx context.Context, host *extensionv1.Client, cfg Config, request extensionv1.CodexRoutingDemand) (any, error) { + state, revision, err := readState(ctx, host, request.AccountID, request.Model) + if err != nil || !cfg.Enabled || !state.Enrolled || state.Phase == "stopped" { + return map[string]bool{"enqueued": false}, err + } + key := stateKey(request.AccountID, request.Model) + var previous extensionv1.StateResult + if err := hostCall(ctx, host, extensionv1.HostStateRead, extensionv1.StateRequest{Namespace: "routing-demand", Key: key}, &previous); err != nil { + return nil, err + } + var old routingDemand + if previous.Found && state.NextAt != nil && json.Unmarshal(previous.Value, &old) == nil && time.Since(old.At) < 10*time.Second { + return map[string]bool{"enqueued": true}, nil + } + raw, _ := json.Marshal(routingDemand{At: time.Now().UTC()}) + var saved extensionv1.StateResult + err = hostCall(ctx, host, extensionv1.HostStateCompareSwap, extensionv1.StateRequest{Namespace: "routing-demand", Key: key, ExpectedRevision: previous.Revision, Value: raw}, &saved) + if err == nil && saved.Applied && state.NextAt == nil && state.Phase != "manual_running" && state.Phase != "pre_running" && state.Phase != "post_running" { + due := time.Now().UTC() + if state.ExpiresAt != nil && state.ExpiresAt.Add(-extensionv1.CodexRoutingRefreshLead).After(due) { + due = state.ExpiresAt.Add(-extensionv1.CodexRoutingRefreshLead) + } + if state.Phase == "retry" && state.LastAttemptAt != nil && state.LastAttemptAt.Add(extensionv1.CodexRoutingRefreshLead).After(due) { + due = state.LastAttemptAt.Add(extensionv1.CodexRoutingRefreshLead) + } + state.NextAt = &due + _, err = writeState(ctx, host, request.AccountID, request.Model, state, revision) + } + return map[string]bool{"enqueued": err == nil && saved.Applied}, err +} + +func observeRoutingResponse(ctx context.Context, host *extensionv1.Client, req extensionv1.CodexRoutingResponse) (any, error) { + if req.AccountID <= 0 || req.Identity == "" || req.Model == "" { + return nil, errors.New("invalid routing response") + } + state, revision, err := readState(ctx, host, req.AccountID, req.Model) + if err != nil { + return nil, err + } + q := state.Qualification + if q == nil || state.Identity != req.Identity || q.Bundle.Key != req.Qualification.Bundle.Key || q.Bundle.Revision != req.Qualification.Bundle.Revision { + return map[string]bool{"applied": false}, nil + } + if state.Phase == "manual_running" || state.Phase == "pre_running" || state.Phase == "post_running" { + return map[string]bool{"applied": false}, nil + } + state.Observation, state.LastCode = &req.Observation, req.Observation.Code + if replacement := req.Replacement; replacement != nil && req.Observation.Completed && req.Observation.ModelMatched && replacement.Valid(time.Now(), req.AccountID, req.Identity, req.Model) && replacement.Scope.SameOwner(q.Scope) { + state.Qualification, state.ExpiresAt = replacement, &replacement.ExpiresAt + if state.Phase == "ready" { + due := replacement.ExpiresAt.Add(-extensionv1.CodexRoutingRefreshLead) + state.NextAt = &due + } + } + if !req.Observation.Completed || !req.Observation.ModelMatched || req.Observation.ResponseModel != req.Model || req.Observation.Code == "routing_cookie_deleted" { + state.Qualification, state.ExpiresAt = nil, nil + if state.Phase != "stopped" && state.Phase != "manual_running" && state.Phase != "pre_running" && state.Phase != "post_running" { + state.Phase = "needs_cookie_verification" + now := time.Now().UTC() + state.NextAt = &now + } + } + _, err = writeState(ctx, host, req.AccountID, req.Model, state, revision) + return map[string]bool{"applied": err == nil}, err +} diff --git a/plugins/codex-runtime/internal/tickets/routing_test.go b/plugins/codex-runtime/internal/tickets/routing_test.go new file mode 100644 index 000000000000..2bb8f36ad5ee --- /dev/null +++ b/plugins/codex-runtime/internal/tickets/routing_test.go @@ -0,0 +1,107 @@ +package tickets + +import ( + "context" + "encoding/json" + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" + "testing" + "time" +) + +func TestRoutingConfigMigratesOnlyUnversionedExactDefaults(t *testing.T) { + module := NewModule() + defer module.cancel() + raw, err := module.ValidateConfig(context.Background(), []byte(`{"models":["gpt-6-astra","gpt-5.6-sol"]}`)) + if err != nil { + t.Fatal(err) + } + var cfg Config + if json.Unmarshal(raw, &cfg) != nil || len(cfg.Models) != 4 || cfg.RoutingSchema != 2 { + t.Fatal("old exact defaults were not migrated") + } + for _, input := range []string{`{"models":["custom-model"]}`, `{"routing_schema":2,"models":["gpt-6-astra","gpt-5.6-sol"]}`} { + raw, err := module.ValidateConfig(context.Background(), []byte(input)) + if err != nil { + t.Fatal(err) + } + var updated Config + _ = json.Unmarshal(raw, &updated) + if len(updated.Models) > 2 { + t.Fatal("custom/explicitly edited model list was expanded") + } + } +} + +func TestRoutingMigrationAndTwoFailuresPreserveStop(t *testing.T) { + for _, phase := range []string{"ready", "retry", "stopped", "manual_running"} { + state := State{Phase: phase, Ticket: &Ticket{State: "old292"}} + state.migrateRouting() + if state.Ticket != nil || state.Qualification != nil { + t.Fatal("legacy state became qualification") + } + if phase == "ready" || phase == "retry" { + if !state.Enrolled || state.Phase != "needs_cookie_verification" { + t.Fatal("enrollment intent lost") + } + } else if state.Phase != phase { + t.Fatal("spent state revived") + } + } + now := time.Now() + state := State{Schema: 2, Enrolled: true, Phase: "pre_running"} + state.completeRouting(now, nil, extensionv1.CodexRoutingObservation{Code: "routing_model_mismatch"}) + if state.Failures != 1 || state.Phase != "retry" { + t.Fatal("first failure should be bounded retry") + } + state.Phase = "pre_running" + state.completeRouting(now, nil, extensionv1.CodexRoutingObservation{Code: "routing_model_mismatch"}) + if state.Phase != "stopped" || state.NextAt != nil || state.Failures != 2 { + t.Fatal("second failure did not stop") + } + state.migrateRouting() + if state.beginRouting(now.Add(time.Hour), false) == nil { + t.Fatal("restart revived stopped renewal") + } +} + +func TestRoutingStaleHostReferenceWithdrawsOnlyItsQualification(t *testing.T) { + account := extensionv1.Account{ID: 7, Identity: "owner", Platform: "openai", Type: "oauth"} + now := time.Now().UTC() + q := &extensionv1.CodexRoutingQualification{Scope: testRoutingScope(account), Model: "gpt-6-astra", VerifiedAt: now, ExpiresAt: now.Add(time.Minute), Bundle: extensionv1.CodexRoutingBundleRef{Key: "bundle.stale", Revision: 1, ExpiresAt: now.Add(time.Minute)}} + raw, _ := json.Marshal(State{Schema: 2, Identity: "owner", Phase: "ready", Enrolled: true, Qualification: q}) + host := &memoryHost{account: account, checkInvalid: true, state: map[string]extensionv1.StateResult{stateKey(7, "gpt-6-astra"): {Found: true, Revision: 1, Value: raw}}} + module := NewModule() + defer module.cancel() + module.SetHost(testHostClient(t, host)) + module.config.Enabled = true + raw, _ = json.Marshal(extensionv1.SchedulingRequest{Account: account, Model: "gpt-6-astra", Now: now}) + result, err := module.Invoke(context.Background(), extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "inject", Payload: raw}) + if err != nil || result.Code != "routing_stale" { + t.Fatal("stale bundle was accepted") + } + var state State + if json.Unmarshal(host.state[stateKey(7, "gpt-6-astra")].Value, &state) != nil || state.Qualification != nil || state.Phase != "needs_cookie_verification" || !state.Enrolled || state.Failures != 0 { + t.Fatal("stale reference did not withdraw exactly the old qualification") + } +} + +func TestRoutingDemandRearmsAnEnrolledDormantState(t *testing.T) { + account := extensionv1.Account{ID: 7, Identity: "owner", Platform: "openai", Type: "oauth"} + state := State{Schema: 2, Identity: "owner", Phase: "ready", Enrolled: true} + raw, _ := json.Marshal(state) + key := stateKey(7, "gpt-6-astra") + host := &memoryHost{account: account, state: map[string]extensionv1.StateResult{key: {Found: true, Revision: 1, Value: raw}}} + module := NewModule() + defer module.cancel() + client := testHostClient(t, host) + _, err := module.recordRoutingDemand(context.Background(), client, Config{Enabled: true}, extensionv1.CodexRoutingDemand{AccountID: 7, Model: "gpt-6-astra"}) + if err != nil { + t.Fatal(err) + } + if json.Unmarshal(host.state[key].Value, &state) != nil || state.NextAt == nil || !state.Enrolled || state.Failures != 0 { + t.Fatal("demand did not rearm dormant due index") + } + if !hasRoutingDemand(context.Background(), client, 7, "gpt-6-astra") { + t.Fatal("demand was not separately persisted") + } +} diff --git a/plugins/codex-runtime/internal/tickets/state.go b/plugins/codex-runtime/internal/tickets/state.go index 4cebcaa97469..670daff4b99c 100644 --- a/plugins/codex-runtime/internal/tickets/state.go +++ b/plugins/codex-runtime/internal/tickets/state.go @@ -4,6 +4,8 @@ import ( "errors" "strings" "time" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) const Length = 292 @@ -30,15 +32,72 @@ func (t *Ticket) Valid(now time.Time, accountID int64, identity, model string) b // State includes the spent automatic attempt before any network IO. A process // restart resumes only persisted pending stages, never a running/spent attempt. type State struct { - Identity string `json:"identity"` - OperationID string `json:"operation_id,omitempty"` - Phase string `json:"phase"` - NextAt *time.Time `json:"next_attempt_at,omitempty"` - ExpiresAt *time.Time `json:"expires_at,omitempty"` - ManualWasEnrolled bool `json:"manual_was_enrolled,omitempty"` - LastCode string `json:"last_code,omitempty"` - LastAttemptAt *time.Time `json:"last_attempt_at,omitempty"` - Ticket *Ticket `json:"ticket,omitempty"` + Schema int `json:"schema,omitempty"` + Enrolled bool `json:"enrolled,omitempty"` + Failures int `json:"failures,omitempty"` + Qualification *extensionv1.CodexRoutingQualification `json:"qualification,omitempty"` + Observation *extensionv1.CodexRoutingObservation `json:"observation,omitempty"` + Identity string `json:"identity"` + OperationID string `json:"operation_id,omitempty"` + Phase string `json:"phase"` + NextAt *time.Time `json:"next_attempt_at,omitempty"` + ExpiresAt *time.Time `json:"expires_at,omitempty"` + ManualWasEnrolled bool `json:"manual_was_enrolled,omitempty"` + LastCode string `json:"last_code,omitempty"` + LastAttemptAt *time.Time `json:"last_attempt_at,omitempty"` + Ticket *Ticket `json:"ticket,omitempty"` +} + +func (s *State) migrateRouting() { + if s.Schema >= extensionv1.CodexRoutingSchema { + return + } + s.Schema = extensionv1.CodexRoutingSchema + s.Enrolled = s.Phase == "ready" || s.Phase == "retry" + if s.Enrolled { + s.Phase = "needs_cookie_verification" + now := time.Now().UTC() + s.NextAt = &now + } + // Old STATE is never a Cookie qualification. Keep stopped/running markers + // and operation IDs so migration cannot resurrect a spent attempt. + s.Ticket, s.Qualification, s.ExpiresAt = nil, nil, nil +} + +func (s *State) beginRouting(now time.Time, manual bool) error { + if s.Phase == "manual_running" || s.Phase == "pre_running" || s.Phase == "post_running" { + return ErrRunning + } + if !manual && (!s.Enrolled || s.Phase == "stopped" || s.Failures >= 2 || s.NextAt == nil || now.Before(*s.NextAt)) { + return ErrNotDue + } + s.ManualWasEnrolled = s.Enrolled + s.Phase = "pre_running" + if manual { + s.Phase = "manual_running" + } + s.LastAttemptAt, s.NextAt = &now, nil + return nil +} + +func (s *State) completeRouting(now time.Time, q *extensionv1.CodexRoutingQualification, observation extensionv1.CodexRoutingObservation) { + manual := s.Phase == "manual_running" + s.Observation, s.LastCode = &observation, observation.Code + if q != nil { + s.Qualification, s.ExpiresAt = q, &q.ExpiresAt + s.Enrolled, s.Failures, s.Phase = true, 0, "ready" + due := q.ExpiresAt.Add(-extensionv1.CodexRoutingRefreshLead) + s.NextAt = &due + return + } + s.Failures++ + if (manual && !s.ManualWasEnrolled) || s.Failures >= 2 || observation.Code == "ticket_canceled" || observation.Code == "ticket_interrupted" { + s.Stop() + return + } + s.Phase = "retry" + due := now.Add(extensionv1.CodexRoutingRefreshLead) + s.NextAt = &due } func (s *State) Begin(now time.Time, manual bool) error { diff --git a/plugins/codex-runtime/manifest.source.json b/plugins/codex-runtime/manifest.source.json index 9940f600ad5f..b61ea5df697e 100644 --- a/plugins/codex-runtime/manifest.source.json +++ b/plugins/codex-runtime/manifest.source.json @@ -2,11 +2,11 @@ "schema_version": 1, "id": "codexrip.codex-runtime", "name": "Codex 运行扩展", - "version": "0.2.7", - "description": "292票据、有限续期与代理诊断", + "version": "0.2.8", + "description": "Cookie 路由资格、按需有界续获与出站指纹", "author": "HTExplicit", "requires": { - "sub2api": ">=0.2.7-0 <0.2.8", + "sub2api": ">=0.2.7-codexrip.2 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, @@ -27,7 +27,7 @@ { "id": "extensions.jobs.v1", "platform": "openai", "account_type": "setup-token" } ], "operations": { - "extensions.request.v1": ["inject", "codex.identity.available", "codex.identity.plan", "codex.identity.derive", "codex.identity.validate", "codex.identity.agent", "codex.identity.sandbox", "codex.transport.plan"], + "extensions.request.v1": ["inject", "codex.routing.demand", "codex.routing.observe", "codex.identity.available", "codex.identity.plan", "codex.identity.derive", "codex.identity.validate", "codex.identity.agent", "codex.identity.sandbox", "codex.transport.plan"], "extensions.recovery.v1": ["codex.recovery.available", "codex.recovery.enabled", "codex.recovery.rejection", "codex.recovery.select", "codex.replay.rules"] }, "contributions": [ @@ -39,7 +39,7 @@ }, { "id": "ticket-harvest", "slot": "account.actions", "capability": "extensions.credentials.v1", "action": "harvest", "entrypoint": "ui/index.html", "permission": "admin", - "label": { "zh": "采集292票据", "en": "Acquire 292 tickets" }, + "label": { "zh": "采集并验证 Cookie 路由", "en": "Acquire and verify Cookie route" }, "account_filter": { "platforms": ["openai"], "types": ["oauth", "setup-token"], "exclude_shadows": true } }, { @@ -48,7 +48,7 @@ "account_filter": { "platforms": ["openai"], "types": ["oauth", "setup-token"], "exclude_shadows": true } } ], - "resources": [{ "name": "ops.error.diagnostics", "capability": "extensions.recovery.v1", "permission": "admin" }], + "resources": [{ "name": "ops.error.diagnostics", "capability": "extensions.recovery.v1", "permission": "admin" }, { "name": "codex.fingerprint", "capability": "extensions.request.v1", "permission": "admin" }, { "name": "codex.fingerprint.profile", "capability": "extensions.request.v1", "permission": "admin" }, { "name": "codex.routing.validate", "capability": "extensions.credentials.v1", "permission": "admin" }], "runtimes": {}, "ui": { "entrypoint": "ui/index.html" }, "files": {} diff --git a/plugins/codex-runtime/profile/identity.go b/plugins/codex-runtime/profile/identity.go index 4a86d69d8156..d384e4b7fc49 100644 --- a/plugins/codex-runtime/profile/identity.go +++ b/plugins/codex-runtime/profile/identity.go @@ -31,7 +31,11 @@ func Invoke(ctx context.Context, in extensionv1.Invocation) (extensionv1.Result, if query.Seed == "" || len(query.Seed) > 1024 { return extensionv1.Result{}, errors.New("invalid identity seed") } - result.Profile, result.Valid = extensionv1.CodexClientProfile(deriveCodexClientIdentity(query.Seed)), true + identity := capturedCodexClientIdentity() + if query.Preset == "legacy" { + identity = deriveCodexClientIdentity(query.Seed) + } + result.Profile, result.Valid = extensionv1.CodexClientProfile(identity), true case "codex.identity.validate": result.Valid = codexClientIdentity(query.Profile).valid() case "codex.identity.plan": @@ -93,6 +97,9 @@ var ( // windows_sandbox=Windows、seccomp=Ubuntu），版本/架构/终端形态受限且不含空白或 // CR/LF。持久化值或外部写入的坏值一律视为缺失并重新按种子派生，避免脏值进入 UA。 func (id codexClientIdentity) valid() bool { + if id.Version == 2 { + return id == capturedCodexClientIdentity() || (id.GeneratedAt != "" && func() bool { id.GeneratedAt = ""; return id == capturedCodexClientIdentity() }()) + } if id.Version != codexClientIdentitySchemaVersion { return false } @@ -144,6 +151,9 @@ func codexSandboxForUserAgent(userAgent string) string { // 首段版本、尾部括号组版本与 version 头必须同源（codex-rs 三处都取同一个 // CARGO_PKG_VERSION）。 func (id codexClientIdentity) UserAgent(version string) string { + if id.Version == 2 { + return "codex_exec/0.156.0 (Windows 10.0.26220; x86_64) dumb (codex_exec; 0.156.0)" + } version = strings.TrimSpace(version) return fmt.Sprintf("%s/%s (%s %s; %s) %s (%s; %s)", codexTUIOriginator, version, id.OSType, id.OSVersion, id.Arch, id.Terminal, codexTUIOriginator, version) @@ -153,6 +163,12 @@ func (id codexClientIdentity) UserAgent(version string) string { // clientInfo.name，codex-rs tui/src/lib.rs）。 const codexTUIOriginator = "codex-tui" +// This is a reference-derived application profile, not a claim that the +// gateway's Go transport was captured from the native client. +func capturedCodexClientIdentity() codexClientIdentity { + return codexClientIdentity{Version: 2, Source: "reference_derived_windows_cli", Originator: "codex_exec", ClientVersion: "0.156.0", OSType: "Windows", OSVersion: "10.0.26220", Arch: "x86_64", Terminal: "dumb", Sandbox: "windows_sandbox"} +} + // deriveCodexClientIdentity 从种子确定性派生一份自洽身份。分布按真实 TUI 用户 // 的大致构成加权：macOS 60%（arm64 为主），Windows 25%，Ubuntu 15%；终端与 // 系统匹配，sandbox 标签与系统匹配。 diff --git a/plugins/codex-runtime/profile/identity_test.go b/plugins/codex-runtime/profile/identity_test.go index 42c7cdb1cfd1..3178856bcd1f 100644 --- a/plugins/codex-runtime/profile/identity_test.go +++ b/plugins/codex-runtime/profile/identity_test.go @@ -29,3 +29,28 @@ func TestIdentityPolicyPreservesDeterminismAndProtocolPairing(t *testing.T) { t.Fatal("invalid version accepted") } } + +func TestIdentityCapturedDefaultPreservesExplicitLegacyProfiles(t *testing.T) { + query, _ := json.Marshal(extensionv1.CodexIdentityQuery{Seed: "account-seed"}) + result, err := Invoke(context.Background(), extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "codex.identity.derive", Payload: query}) + if err != nil { + t.Fatal(err) + } + var value extensionv1.CodexIdentityResult + if json.Unmarshal(result.Payload, &value) != nil || value.Profile.Version != 2 || value.Profile.Source != "reference_derived_windows_cli" { + t.Fatal("new account did not receive explicit captured-reference profile") + } + profile := codexClientIdentity(value.Profile) + if !profile.valid() || !strings.HasPrefix(profile.UserAgent("0.145.0"), "codex_exec/0.156.0 ") { + t.Fatal("captured reference version changed") + } + legacy := deriveCodexClientIdentity("old-seed") + query, _ = json.Marshal(extensionv1.CodexIdentityQuery{Seed: "old-seed", Profile: extensionv1.CodexClientProfile(legacy), Version: "0.156.0"}) + result, err = Invoke(context.Background(), extensionv1.Invocation{Capability: extensionv1.CapabilityRequest, Operation: "codex.identity.plan", Payload: query}) + if err != nil { + t.Fatal(err) + } + if json.Unmarshal(result.Payload, &value) != nil || value.Profile.Version != 1 || value.Profile.OSType != legacy.OSType || !strings.HasPrefix(value.UserAgent, "codex-tui/0.156.0 ") { + t.Fatal("legacy profile was silently migrated") + } +} diff --git a/plugins/codex-runtime/ui/assets/app.js b/plugins/codex-runtime/ui/assets/app.js index 5bd74321233c..bcf7a2c27a71 100644 --- a/plugins/codex-runtime/ui/assets/app.js +++ b/plugins/codex-runtime/ui/assets/app.js @@ -19,11 +19,11 @@ return control } const configuration = context.mode === 'configuration' || context.mode === 'admin.settings' - app.append(el('h2', configuration ? text('Codex 运行设置', 'Codex runtime settings') : text('账号票据操作', 'Account ticket operation'))) + app.append(el('h2', configuration ? text('Codex 运行设置', 'Codex runtime settings') : text('Cookie 路由操作', 'Cookie route operation'))) if (configuration) { let config = await bridge.config() const enabled = el('input'); enabled.type = 'checkbox'; enabled.checked = !!config.enabled - const toggle = el('label', '', 'check'); toggle.append(enabled, document.createTextNode(text('启用票据采集与续期', 'Enable ticket acquisition and renewal'))); app.append(toggle) + const toggle = el('label', '', 'check'); toggle.append(enabled, document.createTextNode(text('启用 Cookie 采集与业务出口复验', 'Enable Cookie acquisition and route verification'))); app.append(toggle) const compression = el('input'); compression.type = 'checkbox'; compression.checked = config.request_zstd !== false const compressionToggle = el('label', '', 'check'); compressionToggle.append(compression, document.createTextNode(text('压缩 Codex Responses 请求体', 'Compress Codex Responses requests'))); app.append(compressionToggle) const address = el('textarea'); address.rows = 4; address.autocomplete = 'off'; address.spellcheck = false; address.value = config.proxy_url || '' @@ -48,7 +48,7 @@ controls.append(button(text('清除代理并停用票据', 'Clear proxy and stop tickets'), async () => { config = await bridge.save({ ...config, proxy_url: '', enabled: false }); address.value = ''; enabled.checked = false; show(text('已清除并关闭', 'Cleared and disabled')) })) - app.append(controls, el('p', text('连接测试验证代理与证书；成功连接不代表已取得292票据。', 'Connection tests verify the proxy and certificate; they do not acquire a 292 ticket.'), 'muted')) + app.append(controls, el('p', text('连接测试验证代理与证书；成功连接不代表 Cookie 路由已验证。', 'Connection tests verify the proxy and certificate; they do not verify the Cookie route.'), 'muted')) const actions = el('div', '', 'actions') actions.append(button(text('保存设置', 'Save settings'), async () => { config = await bridge.save({ ...config, enabled: enabled.checked, proxy_url: address.value, proxy_protocol: protocol.value, request_zstd: compression.checked }) @@ -60,12 +60,12 @@ const settings = JSON.parse(status.status_json || '{}') const accountIDs = context.account_id ? [context.account_id] : context.account_ids || [] if (accountIDs.length > 100) throw new Error(text('一次最多操作 100 个账号。', 'At most 100 accounts can be operated at once.')) - app.append(el('p', text(`已选择 ${accountIDs.length} 个账号。每个账号和模型最多请求一次；有效旧票默认跳过。`, `${accountIDs.length} accounts selected. Each account/model is attempted once; valid tickets are skipped by default.`), 'muted')) + app.append(el('p', text(`已选择 ${accountIDs.length} 个账号。每个账号和模型每周期最多一次采集加一次业务出口复验；有效资格默认跳过。`, `${accountIDs.length} accounts selected. Each account/model cycle has one acquisition and one business-route verification; valid qualifications are skipped.`), 'muted')) const modelBox = el('div', '', 'models'), choices = [] for (const model of settings.models || []) { const check = el('input'); check.type = 'checkbox'; check.value = model; check.checked = true; choices.push(check); const label = el('label', '', 'check'); label.append(check, document.createTextNode(model)); modelBox.append(label) } app.append(modelBox) const force = el('input'); force.type = 'checkbox' - if (context.operation !== 'stop') { const label = el('label', '', 'check'); label.append(force, document.createTextNode(text('重新采集仍有效的票据', 'Replace tickets that are still valid'))); app.append(label) } + if (context.operation !== 'stop') { const label = el('label', '', 'check'); label.append(force, document.createTextNode(text('重新采集并复验仍有效的资格', 'Reacquire and verify a still-valid route'))); app.append(label) } let operationKey = null const actions = el('div', '', 'actions') actions.append(button(context.operation === 'stop' ? text('停止续期', 'Stop renewal') : text('开始采集', 'Start acquisition'), async () => { diff --git a/plugins/image-tools/cmd/plugin/main.go b/plugins/image-tools/cmd/plugin/main.go index 284caf396feb..c480d49b02fc 100644 --- a/plugins/image-tools/cmd/plugin/main.go +++ b/plugins/image-tools/cmd/plugin/main.go @@ -5,7 +5,7 @@ import ( extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) -var version = "0.2.7" +var version = "0.2.8" func main() { extensionv1.Serve(extensionv1.Definition{ID: "codexrip.image-tools", Version: version, Capabilities: []string{extensionv1.CapabilityRequest, extensionv1.CapabilityAdmin}}, policy.New()) diff --git a/plugins/image-tools/manifest.source.json b/plugins/image-tools/manifest.source.json index dc1709dfb16d..5d2e8e92a01a 100644 --- a/plugins/image-tools/manifest.source.json +++ b/plugins/image-tools/manifest.source.json @@ -2,10 +2,10 @@ "schema_version": 1, "id": "codexrip.image-tools", "name": "图像工具", - "version": "0.2.7", + "version": "0.2.8", "description": "Image Studio 请求计划、模型能力和 Responses 图像桥接策略", "author": "HTExplicit", - "requires": { "sub2api": ">=0.2.7-0 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, "ui_bridge": 1, "extension_api": 1 }, + "requires": { "sub2api": ">=0.2.7-codexrip.2 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, "ui_bridge": 1, "extension_api": 1 }, "capabilities": [ { "id": "extensions.request.v1", "platform": "*", "account_type": "*" }, { "id": "extensions.admin.v1", "platform": "*", "account_type": "*" } diff --git a/plugins/model-policy/catalog/catalog_data.go b/plugins/model-policy/catalog/catalog_data.go index 2b1c52898362..9ac27f8072e7 100644 --- a/plugins/model-policy/catalog/catalog_data.go +++ b/plugins/model-policy/catalog/catalog_data.go @@ -30,6 +30,18 @@ const ( gptSnapshotAliasSelection = " 官方 API 文档列出的默认日期快照为同一型号的精确别名（2026-09-17 核实），沿用本行容量；其他日期后缀不推断。" ) +const GPT6ContextCapacityReferenceCommit = "4b664e0ef0397f82e68c60088a90fcd035deb796" +const GPT6ContextCapacityReferenceSource = "https://github.com/openai/codex/blob/" + GPT6ContextCapacityReferenceCommit + "/codex-rs/models-manager/models.json" +const GPT6ContextCapacityReferenceVerifiedAt = "2026-09-23" + +func gpt6CodexCapacityReference() *ModelContextCapacityReference { + return &ModelContextCapacityReference{ + Product: "codex_subscription", SourceURL: GPT6ContextCapacityReferenceSource, + Release: GPT6ContextCapacityReferenceCommit, VerifiedAt: GPT6ContextCapacityReferenceVerifiedAt, + ContextWindow: 272000, MaxContextWindow: 872000, + } +} + const ( claudeContextSource = "https://platform.claude.com/docs/en/build-with-claude/context-windows" claudeIntegerSource = "https://www-cdn.anthropic.com/78073f739564e986ff3e28522761a7a0b4484f84.pdf#page=30" @@ -81,6 +93,24 @@ var officialModelContextCapacityCatalog = []OfficialModelContextCapacity{ Reference: codexModelContextCapacityReference(272000, 872000), Conditions: gptLongContextSelection, }, + { + ModelID: "gpt-6-sol", Provider: "openai", Product: "api", + ModelContextCapacity: ModelContextCapacity{ContextWindow: 1050000, MaxOutputTokens: 128000, CapacityBasis: "total_context"}, + SourceURL: "https://developers.openai.com/api/docs/models/gpt-6-sol", + VerifiedAt: GPT6ContextCapacityReferenceVerifiedAt, + OriginalText: "1,050,000 context window; 128,000 max output tokens", + Reference: gpt6CodexCapacityReference(), + Conditions: "API 规格与 Codex 订阅目录分开：订阅回退默认 272000、最大 872000；账号实际目录优先，打包参考不代表账号实测。", + }, + { + ModelID: "gpt-6-luna", Provider: "openai", Product: "api", + ModelContextCapacity: ModelContextCapacity{ContextWindow: 1050000, MaxOutputTokens: 128000, CapacityBasis: "total_context"}, + SourceURL: "https://developers.openai.com/api/docs/models/gpt-6-luna", + VerifiedAt: GPT6ContextCapacityReferenceVerifiedAt, + OriginalText: "1,050,000 context window; 128,000 max output tokens", + Reference: gpt6CodexCapacityReference(), + Conditions: "API 规格与 Codex 订阅目录分开：订阅回退默认 272000、最大 872000；账号实际目录优先，打包参考不代表账号实测。", + }, { ModelID: "gpt-5.6-sol", Aliases: []string{"gpt-5.6"}, Provider: "openai", Product: "api", ModelContextCapacity: ModelContextCapacity{ContextWindow: 1050000, MaxOutputTokens: 128000, CapacityBasis: "total_context"}, diff --git a/plugins/model-policy/catalog/module_test.go b/plugins/model-policy/catalog/module_test.go index f7446327da6f..16bf21a4f776 100644 --- a/plugins/model-policy/catalog/module_test.go +++ b/plugins/model-policy/catalog/module_test.go @@ -45,3 +45,26 @@ func TestCatalogSnapshotCannotMutateActiveReferences(t *testing.T) { t.Fatal("unknown configuration accepted") } } + +func TestGPT6NamedModelReferencesSeparateAPIAndCodex(t *testing.T) { + for _, model := range []string{"gpt-6-sol", "gpt-6-luna"} { + query := extensionv1.CatalogQuery{Candidates: []string{model}, Platform: "openai", AccountType: "apikey", Scheme: "https", Host: "api.openai.com"} + match, err := New().ResolveCatalog(context.Background(), query) + if err != nil || match.Entry == nil { + t.Fatalf("%s: reference unavailable: %v", model, err) + } + entry := match.Entry + if entry.Product != "api" || entry.ContextWindow != 1050000 || entry.MaxOutputTokens != 128000 || entry.MaxInputTokens != 0 || len(entry.Aliases) != 0 { + t.Fatalf("%s: incorrect API capacity or invented alias: %+v", model, entry) + } + ref := entry.Reference + if ref == nil || ref.ContextWindow != 272000 || ref.MaxContextWindow != 872000 || ref.SourceURL != GPT6ContextCapacityReferenceSource || ref.Release != GPT6ContextCapacityReferenceCommit { + t.Fatalf("%s: incorrect subscription reference: %+v", model, ref) + } + query.Candidates = []string{model + "-2099-01-01"} + unknown, err := New().ResolveCatalog(context.Background(), query) + if err != nil || unknown.Entry != nil { + t.Fatal("unpublished dated snapshots must not inherit capacity") + } + } +} diff --git a/plugins/model-policy/cmd/plugin/main.go b/plugins/model-policy/cmd/plugin/main.go index 7e1114847ddc..796d7aa6b463 100644 --- a/plugins/model-policy/cmd/plugin/main.go +++ b/plugins/model-policy/cmd/plugin/main.go @@ -5,7 +5,7 @@ import ( extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) -var version = "0.2.7" +var version = "0.2.8" func main() { extensionv1.Serve(extensionv1.Definition{ID: "codexrip.model-policy", Version: version, Capabilities: []string{extensionv1.CapabilityCatalog, extensionv1.CapabilityAdmin}}, catalog.New()) diff --git a/plugins/model-policy/manifest.source.json b/plugins/model-policy/manifest.source.json index 4a383baa8c3f..b5a1b8914061 100644 --- a/plugins/model-policy/manifest.source.json +++ b/plugins/model-policy/manifest.source.json @@ -2,11 +2,11 @@ "schema_version": 1, "id": "codexrip.model-policy", "name": "模型目录与容量策略", - "version": "0.2.7", + "version": "0.2.8", "description": "精确模型别名、供应商范围与经过核对的容量参考", "author": "HTExplicit", "requires": { - "sub2api": ">=0.2.7-0 <0.2.8", + "sub2api": ">=0.2.7-codexrip.2 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, diff --git a/plugins/prompt-skills/cmd/plugin/main.go b/plugins/prompt-skills/cmd/plugin/main.go index f97e4cb21fc3..1f11cb857050 100644 --- a/plugins/prompt-skills/cmd/plugin/main.go +++ b/plugins/prompt-skills/cmd/plugin/main.go @@ -5,7 +5,7 @@ import ( extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" ) -var version = "0.2.7" +var version = "0.2.8" func main() { extensionv1.Serve(extensionv1.Definition{ID: "codexrip.prompt-skills", Version: version, Capabilities: []string{extensionv1.CapabilityRequest, extensionv1.CapabilityAdmin}}, policy.New()) diff --git a/plugins/prompt-skills/manifest.source.json b/plugins/prompt-skills/manifest.source.json index 5fb68038e668..d453e3352631 100644 --- a/plugins/prompt-skills/manifest.source.json +++ b/plugins/prompt-skills/manifest.source.json @@ -2,16 +2,21 @@ "schema_version": 1, "id": "codexrip.prompt-skills", "name": "提示词与技能策略", - "version": "0.2.7", + "version": "0.2.8", "description": "提示词完整性、应用范围与协议载体策略", "author": "HTExplicit", - "requires": { "sub2api": ">=0.2.7-0 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, "ui_bridge": 1, "extension_api": 1 }, + "requires": { "sub2api": ">=0.2.7-codexrip.2 <0.2.8", "tested_sub2api_versions": [], "plugin_protocol": 1, "transport_api": 1, "ui_bridge": 1, "extension_api": 1 }, "capabilities": [ { "id": "extensions.request.v1", "platform": "openai", "account_type": "*" }, { "id": "extensions.admin.v1", "platform": "*", "account_type": "*" } ], - "operations": { "extensions.request.v1": ["prompt.plan", "prompt.availability", "prompt.composition", "prompt.template", "prompt.publication.plan", "prompt.seeds", "prompt.source.fetch", "prompt.source.validate", "skills.capture", "skills.prompt.seed", "skills.profile", "skills.seed.index", "skills.seed.chunk", "skills.manifest.validate", "skills.tree.check", "skills.file.plan", "skills.publication.plan", "skills.storage.plan"] }, + "operations": { "extensions.request.v1": ["prompt.plan", "prompt.rules.validate", "prompt.availability", "prompt.composition", "prompt.template", "prompt.publication.plan", "prompt.seeds", "prompt.source.fetch", "prompt.source.validate", "skills.capture", "skills.prompt.seed", "skills.profile", "skills.seed.index", "skills.seed.chunk", "skills.manifest.validate", "skills.tree.check", "skills.file.plan", "skills.publication.plan", "skills.storage.plan"] }, "resources": [ + { "name": "prompts.rules.read", "capability": "extensions.request.v1", "permission": "admin" }, + { "name": "prompts.rules.update", "capability": "extensions.request.v1", "permission": "admin" }, + { "name": "prompts.rules.preview", "capability": "extensions.admin.v1", "permission": "admin" }, + { "name": "prompts.bindings.read", "capability": "extensions.admin.v1", "permission": "admin" }, + { "name": "prompts.bindings.update", "capability": "extensions.admin.v1", "permission": "admin" }, { "name": "prompts.list", "capability": "extensions.request.v1", "permission": "admin" }, { "name": "prompts.create", "capability": "extensions.request.v1", "permission": "admin" }, { "name": "prompts.runtime.read", "capability": "extensions.request.v1", "permission": "admin" }, @@ -36,6 +41,8 @@ { "name": "prompts.rollback", "capability": "extensions.request.v1", "permission": "admin" } ], "contributions": [ + { "id": "prompt-account-binding-action", "slot": "account.actions", "capability": "extensions.admin.v1", "entrypoint": "ui/compiled/index.html", "events": ["changed"], "permission": "admin", "account_filter": { "platforms": ["openai", "cindy"], "types": ["oauth", "setup-token", "apikey"] }, "label": { "zh": "账号提示词", "en": "Account prompts" } }, + { "id": "prompt-account-binding", "slot": "surface", "capability": "extensions.admin.v1", "entrypoint": "ui/compiled/index.html", "events": ["changed"], "permission": "admin", "label": { "zh": "账号提示词", "en": "Account prompts" } }, { "id": "prompt-management", "slot": "surface", "capability": "extensions.request.v1", "entrypoint": "ui/compiled/index.html", "permission": "admin", "label": { "zh": "提示词与技能管理", "en": "Prompt and skill management" } }, { "id": "prompt-policy", "slot": "admin.settings", "capability": "extensions.admin.v1", "action": "prompt.describe", "entrypoint": "ui/index.html", "permission": "admin", "label": { "zh": "提示词应用策略", "en": "Prompt application policy" } } ], diff --git a/plugins/prompt-skills/policy/module.go b/plugins/prompt-skills/policy/module.go index 5b73615ef6a9..a06410d87037 100644 --- a/plugins/prompt-skills/policy/module.go +++ b/plugins/prompt-skills/policy/module.go @@ -33,6 +33,9 @@ func validateBusinessSystemPromptBodyWithLimit(body string, limit int) (string, return extensionv1.ValidateTextDocument(body, limit) } func Plan(snapshot BusinessSystemPromptSnapshot, target BusinessSystemPromptTarget, hasInstructions bool) (BusinessSystemPromptApplication, error) { + if snapshot.RulePolicy != nil { + return planRules(snapshot, target) + } bundleManifestSHA256 := snapshot.BundleManifestSHA256 if snapshot.CompositionMode == BusinessSystemPromptCompositionCodexSkillHybrid { bundleManifestSHA256 = snapshot.RegistryEffectiveTreeSHA256 @@ -167,6 +170,18 @@ func (m *Module) Invoke(ctx context.Context, in extensionv1.Invocation) (extensi return m.invokeSource(ctx, in) } if in.Operation != "prompt.plan" { + if in.Operation == "prompt.rules.validate" { + var policy extensionv1.PromptRulePolicy + if json.Unmarshal(in.Payload, &policy) != nil { + return extensionv1.Result{}, errors.New("invalid prompt rule policy") + } + normalized, err := ValidateRulePolicy(policy) + if err != nil { + return extensionv1.Result{Code: "prompt_rules_invalid", HTTPStatus: 422, Message: err.Error()}, nil + } + raw, err := json.Marshal(normalized) + return extensionv1.Result{Payload: raw}, err + } return invokeManagement(in.Operation, in.Payload) } var request extensionv1.PromptPlanRequest @@ -176,6 +191,9 @@ func (m *Module) Invoke(ctx context.Context, in extensionv1.Invocation) (extensi request.Snapshot.BaseSHA256, request.Snapshot.EffectiveSHA256, request.Snapshot.EffectiveByteLength = request.BaseSHA256, request.EffectiveSHA256, request.EffectiveByteLength application, err := Plan(request.Snapshot, request.Target, request.HasInstructions) if err != nil { + if errors.Is(err, ErrPromptDeliveryUnsupported) { + return extensionv1.Result{Code: "prompt_delivery_unsupported", HTTPStatus: 422, Message: "The selected prompt delivery is not supported by this destination"}, nil + } return extensionv1.Result{Code: "prompt_unavailable", Message: "Configured prompt is unavailable"}, nil } raw, err := json.Marshal(application) diff --git a/plugins/prompt-skills/policy/rules.go b/plugins/prompt-skills/policy/rules.go new file mode 100644 index 000000000000..314f05d63b80 --- /dev/null +++ b/plugins/prompt-skills/policy/rules.go @@ -0,0 +1,227 @@ +package policy + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "regexp" + "slices" + "sort" + "strings" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +var ruleIDPattern = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$`) +var ErrPromptDeliveryUnsupported = errors.New("prompt_delivery_unsupported") + +func ValidateRulePolicy(input extensionv1.PromptRulePolicy) (extensionv1.PromptRulePolicy, error) { + if input.Version != 1 || len(input.Rules) > extensionv1.PromptRulesMaxCount { + return input, errors.New("invalid prompt rule policy version or rule count") + } + if input.Rules == nil { + input.Rules = []extensionv1.PromptRule{} + } + if input.DefaultRuleIDs == nil { + input.DefaultRuleIDs = []string{} + } + seen := map[string]bool{} + for i := range input.Rules { + r := &input.Rules[i] + if r.Models == nil { + r.Models = []string{} + } + if !ruleIDPattern.MatchString(r.ID) || seen[r.ID] || strings.TrimSpace(r.Name) == "" || len(r.Name) > 200 { + return input, errors.New("invalid or duplicate prompt rule") + } + seen[r.ID] = true + if !r.FollowActive && (r.TemplateID < 1 || r.VersionID < 1) { + return input, errors.New("rule requires an immutable template version") + } + if !slices.Contains([]string{extensionv1.PromptDeliveryNative, extensionv1.PromptDeliverySystem, extensionv1.PromptDeliveryDeveloper}, r.Delivery) { + return input, errors.New("invalid prompt delivery") + } + if !slices.Contains([]string{extensionv1.PromptPositionControlPrepend, extensionv1.PromptPositionControlAppend, extensionv1.PromptPositionConversationHead, extensionv1.PromptPositionConversationTail}, r.Position) { + return input, errors.New("invalid prompt position") + } + if r.Delivery == extensionv1.PromptDeliveryNative && strings.HasPrefix(r.Position, "conversation_") { + return input, fmt.Errorf("%w: native control has no conversation position", ErrPromptDeliveryUnsupported) + } + if r.ModelMatch == "" { + r.ModelMatch = "upstream" + } + if r.ModelMatch != "upstream" && r.ModelMatch != "requested" { + return input, errors.New("invalid model matching basis") + } + if len(r.Models) > 128 { + return input, errors.New("too many model selectors") + } + models := map[string]bool{} + for _, model := range r.Models { + if strings.TrimSpace(model) != model || model == "" || len(model) > 256 || models[model] { + return input, errors.New("invalid model selector") + } + models[model] = true + } + } + selected := map[string]bool{} + for _, id := range input.DefaultRuleIDs { + if !seen[id] || selected[id] { + return input, errors.New("invalid default rule reference") + } + selected[id] = true + } + sort.SliceStable(input.Rules, func(i, j int) bool { + if input.Rules[i].Order == input.Rules[j].Order { + return input.Rules[i].ID < input.Rules[j].ID + } + return input.Rules[i].Order < input.Rules[j].Order + }) + return input, nil +} + +func ValidateAccountBinding(binding extensionv1.PromptAccountBinding, policy extensionv1.PromptRulePolicy) (extensionv1.PromptAccountBinding, error) { + if binding.Mode == "" { + binding.Mode = "inherit" + } + if binding.RuleIDs == nil { + binding.RuleIDs = []string{} + } + if binding.Mode != "inherit" && binding.Mode != "off" && binding.Mode != "custom" { + return binding, errors.New("invalid account prompt mode") + } + if binding.Mode != "custom" && len(binding.RuleIDs) > 0 { + return binding, errors.New("only custom binding can select rules") + } + seen := map[string]bool{} + for _, id := range binding.RuleIDs { + if seen[id] || !slices.ContainsFunc(policy.Rules, func(rule extensionv1.PromptRule) bool { return rule.ID == id }) { + return binding, errors.New("unknown or duplicate account prompt rule") + } + seen[id] = true + } + return binding, nil +} + +func planRules(snapshot BusinessSystemPromptSnapshot, target BusinessSystemPromptTarget) (BusinessSystemPromptApplication, error) { + application := BusinessSystemPromptApplication{Revision: snapshot.Revision, ExposeServerPrompt: snapshot.ExposeServerPrompt, CompactEnabled: snapshot.CompactEnabled, RulesPlan: &extensionv1.PromptRulesPlan{Placements: []extensionv1.PromptRulePlacement{}, Skipped: []extensionv1.PromptRuleDecision{}}} + policy, err := ValidateRulePolicy(*snapshot.RulePolicy) + if err != nil { + return application, err + } + scopeReason := "" + if !snapshot.Enabled { + scopeReason = "global_disabled" + } else if target.Platform != PlatformOpenAI { + scopeReason = "platform_excluded" + } else if target.Compact && !snapshot.CompactEnabled { + scopeReason = "compact_disabled" + } + if scopeReason != "" { + for _, rule := range policy.Rules { + application.RulesPlan.Skipped = append(application.RulesPlan.Skipped, extensionv1.PromptRuleDecision{RuleID: rule.ID, Reason: scopeReason}) + } + return finishRulesPlan(application, 0), nil + } + binding := extensionv1.PromptAccountBinding{Mode: "inherit"} + if target.BindingJSON != "" && json.Unmarshal([]byte(target.BindingJSON), &binding) != nil { + return application, errors.New("invalid account prompt binding") + } + binding, err = ValidateAccountBinding(binding, policy) + if err != nil { + return application, err + } + selected := policy.DefaultRuleIDs + if binding.Mode == "off" { + selected = nil + } else if binding.Mode == "custom" { + selected = binding.RuleIDs + } + resolved := map[string]extensionv1.ResolvedPromptRule{} + for _, rule := range snapshot.ResolvedRules { + resolved[rule.Rule.ID] = rule + } + total := 0 + for _, rule := range policy.Rules { + reason := "" + switch { + case !snapshot.Enabled: + reason = "global_disabled" + case target.Platform != PlatformOpenAI: + reason = "platform_excluded" + case target.Compact && !snapshot.CompactEnabled: + reason = "compact_disabled" + case !slices.Contains(selected, rule.ID): + reason = "account_scope" + case !rule.Enabled: + reason = "rule_disabled" + } + model := target.UpstreamModel + if rule.ModelMatch == "requested" { + model = target.RequestedModel + } + if reason == "" && len(rule.Models) > 0 && !slices.Contains(rule.Models, model) { + reason = "model_scope" + } + if reason != "" { + application.RulesPlan.Skipped = append(application.RulesPlan.Skipped, extensionv1.PromptRuleDecision{RuleID: rule.ID, Reason: reason}) + continue + } + content, ok := resolved[rule.ID] + if !ok { + return application, fmt.Errorf("%w: unresolved template version", ErrBusinessSystemPromptUnavailable) + } + hash, size, validationErr := extensionv1.ValidateTextDocument(content.Body, extensionv1.PromptRulesMaxBytes) + if validationErr != nil || hash != content.SHA256 { + return application, fmt.Errorf("%w: invalid rule content", ErrBusinessSystemPromptUnavailable) + } + total += size + if total > extensionv1.PromptRulesMaxBytes { + return application, errors.New("compiled prompt rules exceed limit") + } + placement := extensionv1.PromptRulePlacement{RuleID: rule.ID, TemplateID: content.Rule.TemplateID, VersionID: content.Rule.VersionID, Delivery: rule.Delivery, Position: rule.Position, Body: strings.TrimSpace(content.Body), SHA256: hash, PreserveEcho: content.PreserveEcho} + switch target.Protocol { + case BusinessSystemPromptProtocolResponses: + if rule.Delivery == extensionv1.PromptDeliveryNative { + placement.Carrier = "instructions" + } else { + placement.Carrier, placement.Role = "input", rule.Delivery + } + case BusinessSystemPromptProtocolChat: + placement.Carrier, placement.Role = "messages", rule.Delivery + if rule.Delivery == extensionv1.PromptDeliveryNative { + placement.Role = "system" + } + default: + return application, fmt.Errorf("%w: protocol does not have a supported control carrier", ErrPromptDeliveryUnsupported) + } + if (target.AccountType == "oauth" || target.AccountType == "setup-token") && rule.Delivery == extensionv1.PromptDeliverySystem { + return application, fmt.Errorf("%w: Codex OAuth requires native instructions or developer messages", ErrPromptDeliveryUnsupported) + } + application.RulesPlan.Placements = append(application.RulesPlan.Placements, placement) + } + application.PreserveInstructionsEcho = application.PreserveInstructionsEcho || snapshot.ExposeServerPrompt + if len(application.RulesPlan.Placements) > 0 && !application.PreserveInstructionsEcho { + application.PreserveInstructionsEcho = true + for _, placement := range application.RulesPlan.Placements { + if !placement.PreserveEcho { + application.PreserveInstructionsEcho = false + break + } + } + } + return finishRulesPlan(application, total), nil +} + +func finishRulesPlan(application BusinessSystemPromptApplication, total int) BusinessSystemPromptApplication { + raw, _ := json.Marshal(application.RulesPlan.Placements) + digest := sha256.Sum256(raw) + application.RulesPlan.SHA256 = hex.EncodeToString(digest[:]) + application.Applied = len(application.RulesPlan.Placements) > 0 + application.SHA256, application.EffectiveSHA256 = application.RulesPlan.SHA256, application.RulesPlan.SHA256 + application.EffectiveByteLength = total + application.Carrier = "rule_plan" + return application +} diff --git a/plugins/prompt-skills/policy/rules_test.go b/plugins/prompt-skills/policy/rules_test.go new file mode 100644 index 000000000000..87d990c1acc7 --- /dev/null +++ b/plugins/prompt-skills/policy/rules_test.go @@ -0,0 +1,100 @@ +package policy + +import ( + "errors" + "testing" + + extensionv1 "github.com/Wei-Shaw/sub2api/pkg/extensionapi/v1" +) + +func ruleSnapshot(delivery, position string) BusinessSystemPromptSnapshot { + rule := extensionv1.PromptRule{ID: "rule", Name: "Rule", Enabled: true, TemplateID: 1, VersionID: 2, Delivery: delivery, Position: position, ModelMatch: "upstream"} + hash, _, _ := extensionv1.ValidateTextDocument("site", 100) + return BusinessSystemPromptSnapshot{Enabled: true, Revision: 1, RulePolicy: &extensionv1.PromptRulePolicy{Version: 1, Rules: []extensionv1.PromptRule{rule}, DefaultRuleIDs: []string{"rule"}}, ResolvedRules: []extensionv1.ResolvedPromptRule{{Rule: rule, Body: "site", SHA256: hash}}} +} + +func TestPromptRulesDeliveryPositionMatrix(t *testing.T) { + for _, delivery := range []string{"native_control", "system", "developer"} { + for _, position := range []string{"control_prepend", "control_append", "conversation_head", "conversation_tail"} { + for _, protocol := range []string{"responses", "chat"} { + t.Run(delivery+"/"+position+"/"+protocol, func(t *testing.T) { + application, err := Plan(ruleSnapshot(delivery, position), BusinessSystemPromptTarget{Platform: "openai", AccountType: "apikey", Protocol: protocol}, true) + if delivery == "native_control" && (position == "conversation_head" || position == "conversation_tail") { + if !errors.Is(err, ErrPromptDeliveryUnsupported) { + t.Fatalf("expected explicit unsupported error, got %v", err) + } + return + } + if err != nil || !application.Applied { + t.Fatalf("expected plan: %+v, %v", application, err) + } + placement := application.RulesPlan.Placements[0] + if protocol == "chat" && (placement.Carrier != "messages" || placement.Role == "native_control") { + t.Fatal("Chat must use a real role even if instructions exists") + } + }) + } + } + } +} + +func TestPromptRulesAccountModelAndOAuthScope(t *testing.T) { + snapshot := ruleSnapshot("system", "conversation_tail") + target := BusinessSystemPromptTarget{Platform: "openai", AccountType: "oauth", Protocol: "responses"} + if _, err := Plan(snapshot, target, false); !errors.Is(err, ErrPromptDeliveryUnsupported) { + t.Fatal(err) + } + target.BindingJSON = `{"mode":"off","rule_ids":[]}` + if result, err := Plan(snapshot, target, false); err != nil || result.Applied { + t.Fatal("off account must bypass incompatible rules", err) + } + target.BindingJSON, target.AccountType = "", "apikey" + snapshot.RulePolicy.Rules[0].Models = []string{"mapped"} + target.RequestedModel, target.UpstreamModel = "alias", "other" + if result, err := Plan(snapshot, target, false); err != nil || result.Applied { + t.Fatal(err) + } + target.UpstreamModel = "mapped" + if result, err := Plan(snapshot, target, false); err != nil || !result.Applied { + t.Fatal(err) + } +} + +func TestPromptRulesDisabledDoesNotResolveInvalidAccountOrContent(t *testing.T) { + snapshot := ruleSnapshot("system", "conversation_tail") + snapshot.Enabled, snapshot.ResolvedRules = false, nil + application, err := Plan(snapshot, BusinessSystemPromptTarget{Platform: "openai", AccountType: "oauth", Protocol: "responses", BindingJSON: "malformed-old-binding"}, false) + if err != nil || application.Applied { + t.Fatalf("disabled policy must not affect forwarding: %v", err) + } + if application.RulesPlan.Skipped[0].Reason != "global_disabled" { + t.Fatal("missing explicit skip reason") + } +} + +func TestPromptRulesPublicEchoDoesNotExposePrivateSibling(t *testing.T) { + snapshot := ruleSnapshot("native_control", "control_append") + snapshot.ResolvedRules[0].PreserveEcho = true + privateRule := snapshot.RulePolicy.Rules[0] + privateRule.ID, privateRule.Name = "private", "Private rule" + snapshot.RulePolicy.Rules = append(snapshot.RulePolicy.Rules, privateRule) + snapshot.RulePolicy.DefaultRuleIDs = append(snapshot.RulePolicy.DefaultRuleIDs, privateRule.ID) + hash, _, _ := extensionv1.ValidateTextDocument("private", 100) + snapshot.ResolvedRules = append(snapshot.ResolvedRules, extensionv1.ResolvedPromptRule{Rule: privateRule, Body: "private", SHA256: hash}) + application, err := Plan(snapshot, BusinessSystemPromptTarget{Platform: "openai", AccountType: "apikey", Protocol: "responses"}, true) + if err != nil { + t.Fatal(err) + } + if application.PreserveInstructionsEcho { + t.Fatal("one public skill must not expose a private sibling rule") + } + public := 0 + for _, placement := range application.RulesPlan.Placements { + if placement.PreserveEcho { + public++ + } + } + if public != 1 { + t.Fatalf("expected one individually public rule, got %d", public) + } +} diff --git a/plugins/prompt-skills/ui/src/AccountPromptBinding.vue b/plugins/prompt-skills/ui/src/AccountPromptBinding.vue new file mode 100644 index 000000000000..ca71a57acd3d --- /dev/null +++ b/plugins/prompt-skills/ui/src/AccountPromptBinding.vue @@ -0,0 +1,60 @@ + + diff --git a/plugins/prompt-skills/ui/src/App.vue b/plugins/prompt-skills/ui/src/App.vue index 745880192e3e..d73a8bd7a021 100644 --- a/plugins/prompt-skills/ui/src/App.vue +++ b/plugins/prompt-skills/ui/src/App.vue @@ -1,4 +1,6 @@