mirror of
https://github.com/zyycn/codex-proxy-rs.git
synced 2026-11-21 16:01:32 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
3d834c9e93 | ||
|
|
8d282dcdf9 | ||
|
|
38446e8a0c | ||
|
|
1173f6263d | ||
|
|
f4bed2077f | ||
|
|
4a8b839780 | ||
|
|
f02bc80f15 | ||
|
|
32a95a9702 | ||
|
|
cc80401d5e | ||
|
|
8cc6b50d85 | ||
|
|
83521e82f5 | ||
|
|
ba8745a714 | ||
|
|
84bcd0e1c0 | ||
|
|
7459c16a3a | ||
|
|
3b4fb390c7 | ||
|
|
bb440a3cbb | ||
|
|
89b6d2256f | ||
|
|
ba2afe67d0 | ||
|
|
976359ad26 | ||
|
|
832858dade | ||
|
|
4d4c1e48ce | ||
|
|
9f873f5ac2 | ||
|
|
4bc59f32a1 | ||
|
|
4c5d2bc97e | ||
|
|
5033d9f19a |
@@ -1,6 +1,6 @@
|
||||
---
|
||||
name: cpr-dev-guide
|
||||
description: Codex Proxy RS 开发、修复、排障、代码审查和文档修改入口;页面、样式、文案、接口、调度、数据库及宿主 SDK、Runtime、插件接入均适用;PR、Issue、独立网关插件与发版叠加对应技能
|
||||
description: Codex Proxy RS 的需求评估、排障、开发、代码审查与文档维护入口
|
||||
---
|
||||
|
||||
# 开发指南
|
||||
@@ -12,39 +12,37 @@ description: Codex Proxy RS 开发、修复、排障、代码审查和文档修
|
||||
- 先写读者需要知道的事实或动作。删掉一句不影响理解、判断或操作,就删;标题、正文和通知不重复同一信息
|
||||
- 保留会改变决定的条件、权限、后果和恢复步骤。错误通知只说已知问题,有明确办法才补一句;后端返回的提示在后端改,前端不重复解释。上游原文、用户内容和诊断事实保持原样
|
||||
|
||||
## 核实问题根因与宿主职责
|
||||
|
||||
评估功能建议、排障、开发和审查时,先按[问题与方案依据](../../../CONTRIBUTING.md#问题与方案依据)核实使用者要完成什么、当前行为造成了什么影响。反馈直接给出改法时,先弄清提出这个改法的原因
|
||||
|
||||
排查故障时,从症状沿实际调用链回溯,定位行为最早偏离预期的环节,用源码、诊断或对照复现说明触发条件如何导致结果。原因尚未确定时,区分已知事实与假设,指出哪项证据能区分可能原因。确认根因后,在负责该行为的模块修复,用原触发场景验证
|
||||
|
||||
涉及 Codex 时,以对应版本的官方源码核实客户端行为,默认透明转发,只做必要适配。建议宿主接管已有决定时,指出需要它介入的网关职责或实际约束。若只是个别部署希望采用不同策略,说明不建议内置的原因。实现可行性不能证明宿主应当承担这项需求
|
||||
|
||||
## 先确定领域与必读规范
|
||||
|
||||
按用户意图、受影响行为与对象初判,定位后按实际文件复核,不要求用户说出“前端”“后端”或技能名。**所有命中行共同构成本次必读规范,先读完再确定方案、修改或给出审查结论**;跨领域叠加,不能只选最像当前步骤的一行
|
||||
|
||||
职责边界决定问题由谁修复;即使代码位于账号、调度或 API 模块,只要影响插件接入或为插件增加处理,也命中插件边界。确定方案时说明相关业务事实的归属及已有实现的复用依据,不能以功能恢复或测试通过替代职责判断
|
||||
按受影响行为和实际文件执行下表所有命中项。流程引用首次完整读取,长文档按标题定位指定章节
|
||||
|
||||
| 领域或操作,行为影响与文件路径满足其一即可 | 确定方案前读取与执行 |
|
||||
| --- | --- |
|
||||
| 调整页面、弹窗、表单、按钮、文案、样式或交互;目标在 `frontend/`、`modules/ui/`、插件前端,或是 `.vue` 文件 | [前端流程](references/frontend.md),局部修改同样按影响范围检查组件复用、文案、Token、样式、视觉状态和运行证据 |
|
||||
| 开发、排查或审查插件接入、宿主 SDK、Runtime、扩展接口或独立网关插件;目标在 `backend/crates/gateway-plugin/`、`modules/plugins/` | 完整读取[插件职责边界](references/plugin-boundaries.md)及所用 [SDK](../../../backend/crates/gateway-plugin/sdk/README.md) 类型与能力合同;宿主维护自身合同、资源与稳定性,插件业务错误在插件侧修复,不在宿主、SDK 或 Runtime 中补偿;独立插件开发、排查、审查另用 [cpr-plugin-dev](../cpr-plugin-dev/SKILL.md) |
|
||||
| 插件接入、SDK、Runtime、扩展接口或独立网关插件,含账号、调度或 API 中为插件新增的处理;目标在 `backend/crates/gateway-plugin/`、`modules/plugins/` | [插件职责边界](references/plugin-boundaries.md)及所用 [SDK](../../../backend/crates/gateway-plugin/sdk/README.md) 类型与能力合同;独立插件开发、排查或审查同时执行 [cpr-plugin-dev](../cpr-plugin-dev/SKILL.md) |
|
||||
| 开发、排查或审查服务端接口、路由、调度、账号与用量规则、持久化、后台任务或协议行为;目标是 `backend/` 中的实现、配置、迁移,或 Rust 源码 | [Workspace 边界](../../../docs/architecture.md#3-workspace-边界)的模块与依赖规则、所属模块及[后端自审](../../../docs/architecture.md#后端自审);Rust 使用 `$rust-best-practices` 和下方后端注释要求,宿主 Rust 同时读取 [Rust 模块组织约定](../../../docs/architecture.md#32-rust-模块组织约定) |
|
||||
| 修改页面接口调用,或开发、排查、审查面向管理端或模型客户端的 HTTP/WS API 合同 | [API](../../../docs/api.md)对应章节;优先复用已有接口,核对调用方 → 服务端解析 → 实际查询或执行,不能只凭前端类型认定参数生效;按实际改动叠加前后端规范 |
|
||||
| 新增、修改或审查客户端可见错误、失败提示、后台任务状态文案 | 下方[错误文案](#错误文案),并按实际出口核对[错误与诊断三层边界](../../../docs/architecture.md#错误与诊断三层边界) |
|
||||
| 模块或调用链变更 | [Workspace 边界](../../../docs/architecture.md#3-workspace-边界)及所属模块章节,不通读整份架构 |
|
||||
| 新增、调整、清理或审查测试 | 下方[测试维护](#测试维护),按当前行为、职责归属与已有覆盖判断保留、合并或删除 |
|
||||
| 修改部署行为、`deploy/` 配置或数据库迁移 | 按范围读取[部署](../../../deploy/README.md)、[迁移](../../../backend/migrations/README.md)对应章节 |
|
||||
| 修改或审查文档;实现或审查用法、公开合同、职责、约束或运维操作的变化 | [文档检查](references/documentation.md)及相关章节,尚无文档差异时也检查是否漏更;纯文档任务不默认读取代码开发、页面验收或发布流程 |
|
||||
| 修改或审查文档;实现或审查用法、公开合同、职责、约束或运维操作的变化 | [文档检查](references/documentation.md),按最终行为核对是否漏更;纯文档任务只补读核实所述事实需要的领域条款 |
|
||||
| 代码审查,包括 PR 审查 | [审查标准](../../../CONTRIBUTING.md#审查标准),叠加被审查行为所属领域的规范;审查默认只读 |
|
||||
| PR / Issue / 发版 | 按当前意图选 [PR](../cpr-github-pr/SKILL.md)、[Issue](../cpr-github-issue/SKILL.md)或[发版](../cpr-release/SKILL.md),普通提交不创建 PR |
|
||||
|
||||
纯文档任务按文档分支执行;核实文中的合同与职责时读对应领域条款,不因提及代码路径或语言加载实现、构建与页面验收流程
|
||||
|
||||
首次命中的流程引用完整读取,并落实其中指定的必读章节;长文档先用 `rg -n '^#{1,4} ' 文件` 定位,分段读取指定章节,避免输出截断。`#章节` 不会自动截取,“按需”仅用于未命中的领域和后续操作资料,不能省略必读规范;读取记录与验证证据的复用按 [任务延续与收尾](../../../AGENTS.md#任务延续与收尾) 执行
|
||||
|
||||
## 参考仓库的优先级
|
||||
|
||||
开发、排障和代码审查先按[问题与方案依据](../../../CONTRIBUTING.md#问题与方案依据)核实问题与方案。涉及 Codex 行为时执行其中的官方行为优先约束:对应版本的官方源码优先,以透明转发和最小必要适配为默认方案,先判断偏离是否必要再评价实现
|
||||
|
||||
## 执行与收尾
|
||||
|
||||
1. 遵守已提供的 [AGENTS.md](../../../AGENTS.md),按其 CodeGraph 约定定位代码;确认工作区、任务范围与已有改动,找到事实归属、同类实现和调用链,补齐上表命中规范及[项目约定](../../../CONTRIBUTING.md#项目约定)对应条目后再修改
|
||||
2. 以最终差异重新匹配上表,补齐新增领域的规范并检查实际实现,再处理本次引入的职责越界、重复规则、冗余状态与无依据分支;删除或替换功能时一并清理失效的配置、类型、调用、测试与文档,已部署数据和公开合同仍遵守所属迁移及兼容规则;仅审查时报告,不自行修复
|
||||
3. 按最终行为执行[文档检查](references/documentation.md),核对所属正文及相关概述、示例和引用,在本任务内完成必要同步;不以尚无文档差异跳过检查。内部重构等未改变文档所述事实时无需改文档;常规文档只写当前状态,普通开发不自动修改 `release/notes.md`
|
||||
3. 在本任务内同步受影响的文档、示例和引用
|
||||
4. 按变更范围执行[验证](../../../CONTRIBUTING.md#验证)及其停止条件,后端命令见[验证命令](../../../docs/architecture.md#验证命令);复用仍适用的验证证据与用户已确定的验收分工,区分通过、失败、跳过与未执行
|
||||
5. 交付前按[首要写作要求](#首要写作要求言简意赅)通读本次新增或修改的文字。交代实际结果与验证缺口;前端按[前端流程](references/frontend.md)核对运行证据,后端按上表检查生命周期,不把构建通过当作行为验收
|
||||
6. 按授权完成提交与交付;提交前按[提交约定](../../../CONTRIBUTING.md#项目约定)准备提交信息与实际共同作者署名,提交后核对实际提交消息,PR 的 AI 披露不能替代提交署名
|
||||
|
||||
@@ -7,32 +7,11 @@
|
||||
- 以当前目标分支及任务内工作区的实现、配置和有效运行证据核实行为;提交记录用于发现待核实的主题,不能直接当作现行事实或按提交顺序组织正文。按 [CodeGraph 约定](../../../../AGENTS.md#codegraph)同步索引后定位,证据不足时报告缺口,不把计划或推测写成已支持能力
|
||||
- 开发任务按最终行为检查哪些用法、合同、职责、约束或运维操作需要同步,即使尚无 Markdown 差异也要检查;独立文档更新按用户范围核对现行说明,不等到发版时再补普通开发所需的文档
|
||||
- 沿同一事实查找所属正文及相关概述、示例和引用,重点核对“支持/不支持”等能力声明、默认值、配置模板和命令。概述保留必要摘要并链接详细合同;不能只更新详细章节,留下 README 或示例中的矛盾说明,也不扩展为无关全仓改写
|
||||
|
||||
## 写之前
|
||||
|
||||
先确定读者、必须说明的当前事实与所属章节,再决定是否需要修改及详略;文档职责与更新条件按上节核对。涉及合同或职责说明时,补读所属架构、API 或 SDK 的对应条款,核实事实;不因文档提及实现而执行无关的开发与构建流程
|
||||
|
||||
在所属章节就地替换失效说明,先组织读者现在需要的操作、结果和限制,不从变更摘要改写正文。仅介绍被替代实现、修复动机或修改经过的段落直接删除;删掉“新增”“此前”“不再”等词后仍在回答变更经过的内容,也不保留
|
||||
|
||||
## 逐段验收
|
||||
|
||||
检查工作区和暂存区中本任务的最终文档差异,并连同受影响章节及相关概述、示例通读,按内容用途处理,不只搜索关键词:
|
||||
|
||||
| 段落回答的问题 | 处理 |
|
||||
| --- | --- |
|
||||
| 现在如何使用、配置或理解结果 | 保留当前事实与必要边界,放回所属章节 |
|
||||
| 谁负责状态、事务、资源和失败处理 | 放入所属架构章节,避免在 API 或部署文档复述实现 |
|
||||
| 这次做了什么、以前怎样、为什么这样修、跑过哪些测试 | 移入 PR、Issue 或任务报告,不以换成现在时的方式留在常规文档 |
|
||||
| 特定配置或数据状态下如何升级、恢复 | 写明适用条件、操作及限制,删除演变过程 |
|
||||
| 别处已完整说明的事实 | 合并或改为必要摘要与链接 |
|
||||
|
||||
脱离提交日期、Issue 和本次任务背景后,读者仍应能独立理解正文
|
||||
|
||||
业务中的请求历史、审计记录、旧数据兼容与回滚操作是当前功能,不能因含“历史”“旧”等词而删除
|
||||
- 涉及合同或职责时核对所属架构、API 或 SDK 条款,在所属章节就地修订。审计记录、旧数据兼容和回滚仍是现行能力时,保留读者需要的说明
|
||||
|
||||
## 交付检查
|
||||
|
||||
- 完成上述逐段验收及[行文检查](../../../../CONTRIBUTING.md#层次与行文),发现问题先处理,未完成内容审查不能称文档已检查
|
||||
- 通读工作区与暂存区中本任务的最终差异、受影响章节及相关概述和示例,按[层次与行文](../../../../CONTRIBUTING.md#层次与行文)逐段验收
|
||||
- 检查相对链接、章节锚点、表格与命令示例,`git diff --check` 或构建通过不能代替内容审查
|
||||
- 交付时简述已同步的文档范围;涉及更新条件却未改文档时,说明现有内容为何仍准确或还有什么缺口。仅报告实际核对范围,不把链接检查通过称为事实核实,也不把检查记录写进常规文档
|
||||
|
||||
|
||||
@@ -32,7 +32,8 @@
|
||||
对照最终差异和实际页面核对适用项,不以读取过规范代替检查:
|
||||
|
||||
- **复用与范围**:是否沿用参考页面和基础组件,已有组件能承载时不手写替代控件;共用缺陷按职责修复,修复后清理本次已失效的页面补丁,不顺带重排无关区域或新增重复入口
|
||||
- **文案与层级**:标点是否合规,标题、状态和帮助是否重复,详细说明与当前决策必需提示的位置是否合适
|
||||
- **核对位置与对齐**时,结合周围内容查看实际页面或 PR 截图,确认操作归属一眼可辨,对照相邻行列检查边缘、文字基线和组间留白。发现错位时指出具体控件、对齐参照和受影响的状态
|
||||
- **精简文案**,删去重复说明,压短必要提示,检查自写文案中的句号和分号
|
||||
- **样式与状态**:是否使用对应 Token 与 utility,局部样式是否符合适用边界,受影响的主题、窄屏及交互状态是否正确
|
||||
- **查询与动作**:区分首次加载、刷新、分页、单行与批量操作,核对 loading、禁用状态的影响范围;沿用请求层错误处理,不在页面叠加同一错误的提示
|
||||
- **运行证据**:按界面验证核对截图与实际交互,证据对应当前实现;页面 PR 的可访问图片和 Draft 条件按该节执行
|
||||
|
||||
@@ -11,20 +11,18 @@ description: 草拟、创建、补充或回复 GitHub Issue,包括缺陷、功
|
||||
|
||||
草拟只准备正文,明确创建或提交才发布;已有授权直接执行,自动命中技能本身不授权远程写入
|
||||
|
||||
补充已有 Issue 先读原帖和讨论,按授权更新或追加,不重复新建;无法推断的目标或关键事实才向用户补齐
|
||||
补充已有 Issue 按授权更新原帖或追加评论
|
||||
|
||||
## 按动作读取与核实
|
||||
|
||||
目标、授权、事实与脱敏要求适用于草拟、提交和回复;按下列动作读取必需规则与证据,再组织正文。症状反馈可保留未知根因,进入技术排查或方案判断时补齐对应规范
|
||||
|
||||
- 新建 Issue 时,读取本仓库的[提交 Issue](../../../CONTRIBUTING.md#提交-issue)及本次匹配的一张表单:[接口问题](../../../.github/ISSUE_TEMPLATE/api-bug-report.yml)、[常规问题](../../../.github/ISSUE_TEMPLATE/general-bug-report.yml)或[功能建议](../../../.github/ISSUE_TEMPLATE/feature-request.yml);协作规则提案可用普通 Issue
|
||||
- 回复时读取原帖、相关讨论与支撑答复的证据,按下方回复口吻组织内容,不套用新建 Issue 的表单
|
||||
- 补充或回复时先读原帖和讨论,按 [GitHub 回复口吻](../../../CONTRIBUTING.md#github-回复口吻)决定答复内容和是否追问
|
||||
- 其他仓库读取它自己的相关规则与实际模板,长文档先定位标题再截取,不预读全部模板或 CONTRIBUTING
|
||||
- 搜索同场景 open/closed Issues、相关 PR 和发布记录,区分主分支修复与已发布修复,不凭标题判断重复;没有新证据时返回已有链接,用户仍要求新建则按其要求处理
|
||||
- 新建或判断重复时查找同场景的 open/closed Issues 和相关 PR,按实际场景核对。已有相同反馈且无新证据时返回原链接,用户仍要求新建则按其要求处理。答复修复状态时核对发布记录,区分已合入和已发布
|
||||
- 需要技术排查、判断实现方案或修改时执行 [cpr-dev-guide](../cpr-dev-guide/SKILL.md)的领域必读,不能仅凭症状建议跨职责补偿;提交症状反馈不以找到根因为前提
|
||||
- 引用上游行为或提出方案时执行[问题与方案依据](../../../CONTRIBUTING.md#问题与方案依据),注明适用版本、来源与缺口
|
||||
|
||||
## 正文与证据
|
||||
## 新建 Issue 的正文
|
||||
|
||||
标题说明症状或期望行为,区分发生问题的部署版本、实测结果、预期结果与根因假设
|
||||
|
||||
@@ -34,22 +32,14 @@ YAML 表单按 `attributes.label` 和字段顺序组织正文,手工核对必
|
||||
|
||||
未知信息如实标明,影响理解或复现的关键事实先补齐,不提交原始 YAML、占位答案或未确认的勾选项
|
||||
|
||||
日志和附件仅含定位所需的脱敏片段,不公开凭据、完整配置或请求转储,不擅自修改代理、TUN、证书环境取证
|
||||
|
||||
附件须获授权且可访问,本机路径不算附件;labels 和 assignees 仅按模板或用户要求设置,并确认实际存在
|
||||
labels 和 assignees 仅按模板或用户要求设置,并确认实际存在
|
||||
|
||||
Issue 可记录复现、排查和变更经过;涉及常规文档修改时执行[文档检查](../cpr-dev-guide/references/documentation.md)
|
||||
|
||||
## 回复口吻
|
||||
|
||||
草拟、发布或修改 Issue 回复时,按 [GitHub 回复口吻](../../../CONTRIBUTING.md#github-回复口吻)将核实结果写成面向提问者的交流答复,具体口吻规则集中维护在该节
|
||||
|
||||
按平常回帖的口吻写,语气自然、委婉,说清判断和原因,少用铺垫、转折和自我说明;暂不采纳或提出不同意见时说明具体原因
|
||||
|
||||
发送或更新前从提问者视角通读:判断和原因是否清楚,建议是否便于尝试,补充材料的用途是否明确。删去不影响理解的客套、重复解释和过程说明;发现生硬时调整整句,不能仅加缓和词,保留已核实的结论
|
||||
|
||||
## 发布与收尾
|
||||
|
||||
日志和附件只含定位所需的脱敏片段,不公开凭据、完整配置或请求转储,不擅自修改代理、TUN、证书环境取证。附件须获授权且可访问,本机路径不算附件
|
||||
|
||||
使用可用连接器或 `gh`,不为提交反馈安装工具、修改仓库配置或启用服务
|
||||
|
||||
多行正文通过结构化字段或 UTF-8 文件传递,以下变量须先从已确认的目标与正文赋值:
|
||||
@@ -58,6 +48,6 @@ Issue 可记录复现、排查和变更经过;涉及常规文档修改时执
|
||||
gh issue create --repo "$issue_repo" --title "$issue_title" --body-file "$issue_body_file"
|
||||
```
|
||||
|
||||
发布前核对目标、必填内容、脱敏与重复记录,更新时保留无关原文;不擅自评论、重开或关闭重复 Issue
|
||||
发布前核对目标和脱敏内容,新建时确认必填项,更新时保留无关原文;不擅自评论、重开或关闭重复 Issue
|
||||
|
||||
超时或结果不明确时先查询远端再重试,发布后回读确认并返回链接;仅草拟或发布失败时提供正文并注明未提交
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
interface:
|
||||
display_name: "cpr-github-issue"
|
||||
short_description: "整理、提交或补充 Issue,核对复现、重复反馈与发布范围"
|
||||
default_prompt: "使用 $cpr-github-issue 按当前请求整理、提交或补充 Issue,核对目标、复现证据、重复记录和脱敏,不将草拟自动变成发布。"
|
||||
short_description: "草拟、提交或回复 GitHub Issue,处理缺陷反馈和功能建议"
|
||||
default_prompt: "使用 $cpr-github-issue 按当前请求整理反馈或回复已有 Issue"
|
||||
policy:
|
||||
allow_implicit_invocation: true
|
||||
|
||||
@@ -17,8 +17,6 @@ description: 准备、创建、更新或审查 GitHub PR,含回复讨论与处
|
||||
|
||||
为本仓库拟写或更新 PR 标题时,完整标题使用英文,沿用提交信息的 Conventional Commits 格式,例如 `fix(store): preserve client key ledgers after deletion`
|
||||
|
||||
涉及上游行为的判断按[问题与方案依据](../../../CONTRIBUTING.md#问题与方案依据)执行
|
||||
|
||||
## 按模式读取
|
||||
|
||||
先完成上述范围判断,再按当前动作与差异涉及的领域叠加下表。命中的流程引用完整读取,长文档读取指定章节;只复用已实际读取且仍适用的内容,单纯整理正文或回复不扩展为完整实现审查
|
||||
@@ -28,22 +26,17 @@ description: 准备、创建、更新或审查 GitHub PR,含回复讨论与处
|
||||
| 只整理标题或描述 | 当前 PR、最终 diff、实际模板、[AI 披露](../../../CONTRIBUTING.md#ai-使用披露),在授权范围内改文案,不自行修改实现;不读取推送或审查流程 |
|
||||
| 创建或更新 PR | [创建流程](references/create.md)、[PR 流程](../../../CONTRIBUTING.md#pr-流程)与[规则文件保护](../../../CONTRIBUTING.md#规则文件保护) |
|
||||
| 审查 PR | [审查流程](references/review.md)、[审查标准](../../../CONTRIBUTING.md#审查标准) |
|
||||
| 回复讨论或审查意见 | 目标评论、相关上下文与实际处理结果,按下方回复口吻答复;仅回复不加载创建或完整审查流程 |
|
||||
| 回复讨论或审查意见 | 读取目标评论和相关上下文,按[GitHub 回复口吻](../../../CONTRIBUTING.md#github-回复口吻)答复实际处理结果 |
|
||||
| 实现自审、审查或修改代码与文档 | 执行 [cpr-dev-guide](../cpr-dev-guide/SKILL.md)的领域必读与对应检查,包括后端、插件、测试和 API 等命中项;只读审查同样执行,不能仅核对 PR 正文与 CI |
|
||||
| 含前端改动 | [前端流程](../cpr-dev-guide/references/frontend.md),核对适用规范与当前实现的运行证据 |
|
||||
| 含文档改动 | [文档检查](../cpr-dev-guide/references/documentation.md) |
|
||||
|
||||
## 回复口吻
|
||||
|
||||
草拟和发布 PR 讨论、审查意见的回复时,执行 [GitHub 回复口吻](../../../CONTRIBUTING.md#github-回复口吻)
|
||||
|
||||
## 创建与审查的公共核对
|
||||
|
||||
- 按[问题与方案依据](../../../CONTRIBUTING.md#问题与方案依据)核实触发条件、发生版本与目标分支现状,分别判断问题是否成立、是否属于目标项目职责及方案是否必要
|
||||
- 核对最新目标分支及同场景 open/closed PR、Issue,按实际行为和测试判断重复,不凭标题下结论,也不擅自关闭他人 PR
|
||||
- 自审或审查覆盖完整差异与调用链,前端与文档按模式表检查
|
||||
- 核对[AI 使用披露](../../../CONTRIBUTING.md#ai-使用披露),填写实际工具与模型,不猜型号;必需截图或型号待补时保留 Draft
|
||||
- 验证结果对应实际 head,区分通过、失败、跳过与未执行;无文档改动时只核对现有说明是否失真
|
||||
- 自审或审查覆盖完整差异和调用链,按[验证](../../../CONTRIBUTING.md#验证)执行适用检查,确认结果对应当前 head
|
||||
- 核对[界面验证](../../../CONTRIBUTING.md#界面验证)要求的截图和 [AI 使用披露](../../../CONTRIBUTING.md#ai-使用披露),必需材料待补时保留 Draft
|
||||
|
||||
远程操作优先使用可用连接器,`gh` 显式指定 `--repo`,多行正文使用结构化字段或 `--body-file`
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
interface:
|
||||
display_name: "cpr-github-pr"
|
||||
short_description: "提交、更新与审查 PR,核对问题、自审、页面截图和 AI 模型披露"
|
||||
default_prompt: "使用 $cpr-github-pr 按当前请求准备、提交、更新或审查 PR,实现自审与审查叠加开发指南的领域规范,核实问题、方案、验证、页面截图和 AI 模型披露。"
|
||||
short_description: "准备、更新或审查 GitHub PR,回复讨论和审查意见"
|
||||
default_prompt: "使用 $cpr-github-pr 按当前请求准备、更新、审查 PR 或回复讨论"
|
||||
policy:
|
||||
allow_implicit_invocation: true
|
||||
|
||||
@@ -6,16 +6,12 @@
|
||||
不用提交日志拼接正文,也不假定仓库一定有模板。
|
||||
2. 更新并确认 base/head,查看相对 merge-base 的完整差异和待提交内容;核对仓库的受保护文件与准入规则。
|
||||
只纳入任务范围的文件和提交;需要整理时用独立功能分支,保留用户其他改动,不擅自改写已发布历史。
|
||||
3. 已完成的改动也须按入口公共核对复核问题与方案。原问题不成立时不包装成已修复的缺陷,证据不足时保留结论。
|
||||
实现与自审按 [cpr-dev-guide](../../cpr-dev-guide/SKILL.md)执行,包括适用的后端生命周期和前端检查;需要修正时只修改已授权范围。
|
||||
4. 查找同一来源仓库、head 和 base 的现有 PR;已存在则复用其链接,不重复创建。
|
||||
3. 查找同一来源仓库、head 和 base 的现有 PR;已存在则复用其链接,不重复创建。
|
||||
更新现有标题或正文须在本次整理/更新请求范围内。
|
||||
5. 按[验证](../../../../CONTRIBUTING.md#验证)执行适用检查,记录对应提交或工作区状态;文档、页面证据与模型披露按入口核对。
|
||||
6. 将任务范围内的提交推送到正确远端,核对远端 head。标题遵循项目约定,正文先说明问题成立的依据和最终行为,
|
||||
再给必要的设计取舍、自审结论、验证与遗留事项,按模板附页面截图和 AI 使用情况。涉及上游行为时,按[问题与方案依据](../../../../CONTRIBUTING.md#问题与方案依据)写明官方源码位置、版本、处理方式及本次方案关系。按规模压缩,不强填无关章节。
|
||||
7. 明确要求草稿或仍有阻塞项时创建或保持 Draft PR,并解释原因;必需截图或 AI 模型披露待补时也不标为可审阅。具备审查条件且未要求草稿时创建普通 PR。
|
||||
4. 将任务范围内的提交推送到正确远端,核对远端 head。按实际模板写明问题依据、最终行为、自审与验证结果,附上适用的审阅材料
|
||||
5. 明确要求草稿或仍有阻塞项时创建或保持 Draft PR,并说明原因;具备审查条件且未要求草稿时创建普通 PR。
|
||||
GitHub Draft 状态与“只写本地草稿正文”不同,后者不创建远程对象。
|
||||
8. 创建或更新后回读正文与附件,核对链接、base、head、草稿状态、模型披露和最新检查结果。网络超时或结果不确定时先查询远端,再决定是否重试。
|
||||
6. 创建或更新后回读正文与附件,核对链接、base、head、草稿状态、模型披露和最新检查结果。网络超时或结果不确定时先查询远端,再决定是否重试。
|
||||
|
||||
CLI 示例中的变量必须先根据上述检查赋值;`pr_body_file` 是精确写入 UTF-8 正文的临时文件:
|
||||
|
||||
|
||||
@@ -4,20 +4,10 @@
|
||||
|
||||
1. 获取 PR 的 base/head SHA、描述、文件差异、已有讨论及 CI 状态。记录实际审查的 head,使用 merge-base 差异。
|
||||
需要源码上下文时先遵守目标仓库的定位规则;需检出时使用隔离工作区,保留用户当前分支和运行环境。
|
||||
按实际行为与文件执行 [cpr-dev-guide](../../cpr-dev-guide/SKILL.md)的领域必读,再判断方案与实现;只读审查也核对职责边界与生命周期。
|
||||
2. 按入口公共核对在目标分支基线核实问题,区分原有问题、环境或配置差异与 PR 新引入的问题,说明主分支已覆盖的部分。
|
||||
3. 按[问题与方案依据](../../../../CONTRIBUTING.md#问题与方案依据)评估解决方向,涉及上游时说明官方处理方式及本次方案关系;缺少必要性依据的偏离明确指出,不因测试通过就认定方案合理。
|
||||
4. 按[审查标准](../../../../CONTRIBUTING.md#审查标准)追踪完整调用链,找到共享业务事实、同类实现及已有验证。
|
||||
对既有特殊分支查清服务的场景,再判断本次改动是否引入或加重问题。
|
||||
主动检查本次变更新引入或加重的冗余与代码异味,说明具体位置、维护成本或行为影响及最小修复方向;
|
||||
不能仅因功能可用、CI 通过而略过,也不把个人写法偏好判为缺陷。
|
||||
5. 前端改动执行[前端流程](../../cpr-dev-guide/references/frontend.md),浏览器可用时检查相关交互;缺少必需截图时要求补齐并列为未具备审阅条件。
|
||||
6. 核对 CI 与本地证据是否覆盖当前 head;根据风险补充必要验证,不触发无关部署或真实账号业务请求。
|
||||
文档差异按[文档检查](../../cpr-dev-guide/references/documentation.md)核对最终 diff。
|
||||
核对 AI 使用与模型披露,缺项明确指出。工具不可用、集成测试跳过或环境不足时具体说明影响范围。
|
||||
7. 按审查标准用中文输出问题是否成立、方案是否合理及对应依据,再列实现问题与验证缺口;复用建议指出具体已有实现。
|
||||
没有问题的类别可省略,未发现问题时直接说明并交代覆盖范围。
|
||||
8. 结束前核对 head 是否变化。发生变化时检查新增差异并更新结论,或明确结论只适用于原 SHA。
|
||||
2. 对照目标分支区分原有问题、环境差异和本次引入或加重的问题。修改既有特殊分支时,查清它原先服务的场景
|
||||
3. 根据风险补充必要验证。浏览器可用时实测受影响的交互,避免触发无关部署或真实账号业务请求
|
||||
4. 用中文说明问题是否成立、方案是否合理,再报告可定位的实现问题与验证缺口。建议复用时指出已有实现;未发现问题时交代实际覆盖范围
|
||||
5. 结束前复核 head。发生变化时检查新增差异并更新结论,或明确结论只适用于原 SHA
|
||||
|
||||
审查本身不修改源码、不发表评论、不提交 GitHub 的批准或请求修改状态。
|
||||
用户明确要求发布时,先复核当前 head 和重复评论,再通过结构化字段或 `--body-file` 发布对应内容;
|
||||
|
||||
@@ -1,17 +1,13 @@
|
||||
---
|
||||
name: cpr-plugin-dev
|
||||
description: 开发、修复、排查、审查或打包 Codex Proxy RS 独立网关插件,含处理器、清单与插件页面;仅改宿主能力时使用 cpr-dev-guide 的插件边界,不适用于 Codex 插件或 Vue 插件
|
||||
description: Codex Proxy RS 独立网关插件的开发、排障、审查与打包
|
||||
---
|
||||
|
||||
# 网关插件开发
|
||||
|
||||
## 先读职责边界
|
||||
|
||||
插件在独立项目中通过公开 SDK 实现业务,插件业务错误在插件侧修复;宿主维护自身合同、资源与稳定性,不猜测插件意图、不补造业务数据,不在宿主、SDK 或 Runtime 中增加插件专属补偿
|
||||
|
||||
开发、排查和审查先完整读取[插件职责边界](../cpr-dev-guide/references/plugin-boundaries.md),再选择实现步骤;已有处理器修复和页面改动也执行,不以是否新增能力为条件。需要新增宿主能力时,先界定可独立使用的基础接口及其职责;必要的协议保护与资源回收仍由宿主负责
|
||||
|
||||
同时执行 [cpr-dev-guide](../cpr-dev-guide/SKILL.md)的领域必读与收尾要求;已实际读取且仍适用的内容复用,不递归重读入口。仅构建、打包或分发已有插件时按对应操作读取,若需诊断或修改行为,再补齐开发分支
|
||||
开发、排查或审查独立插件时,执行 [cpr-dev-guide](../cpr-dev-guide/SKILL.md) 并先读[插件职责边界](../cpr-dev-guide/references/plugin-boundaries.md),包括修改已有处理器或页面。仅构建、打包或分发已有插件时,按下表读取对应步骤
|
||||
|
||||
## 范围与合同
|
||||
|
||||
|
||||
@@ -61,6 +61,6 @@ release/publish "$release_version"
|
||||
工作流附加的安装说明和自动提交列表按其当前配置处理,不用它们替代手写的中文变更说明。
|
||||
- 回读 `main:release/version.yaml` 的 `published`。正式版参与同一大版本四个普通通道的比较;RC 参与 RC、Beta、Alpha,Beta 参与 Beta、Alpha,Alpha 只参与自身。实验版只推进 `exp["X.Y.Z"]`。有通道推进时应有 `chore(release): update release channels to <version>` 提交;重复执行或较旧版本未推进任何通道时无提交
|
||||
- 通道表写入失败时,确认该版本已公开、工作流能写入 `main`,再按已有授权执行 `gh workflow run release.yml --ref main -f tag="v$release_version" -f index_only=true`。恢复任务重新校验公开附件、读取并合并当前清单,不重新打包或改 tag
|
||||
- v3.42.0 在线升级:首个包含新更新器的 3.x 正式版公开并通过校验后,从该次通道提交取出 `release/version.yaml`,将顶层 `version` 设为该正式版,作为同名附件上传到该 Release。回读附件,确认 3.x 稳定通道指向该版本且安装包可用,再手动将已有 `update-index` 正文改为 `{"current":"<该正式版>"}`。此后保留该页与附件,无需再编辑
|
||||
- 保留 v3.42.0 在线升级使用的 `update-index` 页面和 v3.42.1 的 `version.yaml` 附件
|
||||
- 返回版本、tag 对应提交、Release/工作流链接及实际结果。失败、仍在构建或缺失产物时明确说明,不能称为发布成功;
|
||||
Release 和镜像已生成也不表示用户的运行实例已经升级。
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
| 任务意图与常见说法 | 必用技能 |
|
||||
| --- | --- |
|
||||
| 开发、修复、排障、代码审查、改文档;包括“改弹窗/样式/文案”“修接口/调度/数据库”等省略请求 | [cpr-dev-guide](.agents/skills/cpr-dev-guide/SKILL.md),按实际操作和文件匹配规范,跨前后端同时执行 |
|
||||
| 需求评估、排障、开发、修复、代码审查、改文档,包括“看下这个 Issue”“改弹窗/样式/文案”“修接口/调度/数据库” | [cpr-dev-guide](.agents/skills/cpr-dev-guide/SKILL.md),按实际操作和文件匹配规范,跨前后端同时执行 |
|
||||
| 提交/提个 PR、准备或更新 PR、看下 PR、回复 PR 讨论、处理 PR 审查意见 | [cpr-github-pr](.agents/skills/cpr-github-pr/SKILL.md);实现自审、审查或修改同时执行 cpr-dev-guide |
|
||||
| 提 Issue、反馈到仓库、把问题或建议整理成 Issue、补充或回复 Issue | [cpr-github-issue](.agents/skills/cpr-github-issue/SKILL.md) |
|
||||
| 写、修或审查独立网关插件,排查插件接入、打包插件 | [cpr-plugin-dev](.agents/skills/cpr-plugin-dev/SKILL.md),同时执行 cpr-dev-guide;仅改宿主能力时由 cpr-dev-guide 加载插件边界 |
|
||||
|
||||
+4
-10
@@ -21,17 +21,11 @@
|
||||
|
||||
### GitHub 回复口吻
|
||||
|
||||
AI 草拟、发布或修改 Issue、PR 讨论及审查意见的回复时,以一起排查问题、讨论方案的口吻交流:
|
||||
Issue 和 PR 回帖直接回应对方遇到的问题,有不同意见时结合具体场景说明理由。语气自然、委婉,用短句,少用句号。说明个人判断或行动时用“我”,确需提问时称呼一次“佬”
|
||||
|
||||
- 围绕问题、事实和结论展开,能自然省略主语时省略;需要说明个人判断或行动归属时用“我”,避免反复以“我”起句或强调自己,不用“我们”“本助手”代称自己
|
||||
- 普通回复直接回应问题,不加问候语或称呼;向对方提问时称呼“佬”,同一条回复不重复称呼
|
||||
- 先接住对方想完成的事和遇到的困难,再给出核实结果与建议;回复让对方感到问题被理解、有下一步可做,避免一上来归类、纠正或划定责任
|
||||
- 给出操作建议时说明它能帮助判断什么,措辞自然、委婉,不靠堆叠缓和词修饰命令
|
||||
- 回应已有能力、暂不支持或未采纳的建议时,结合场景说明可用入口或具体原因,有可行替代办法时一并说明,再交代必要边界;避免只回复“已有功能”“重复问题”“不在范围内”等结论
|
||||
- 需要补充材料或配合操作时,先利用已有信息,只询问仍缺少的部分,说明用途和最小范围;例如“佬,方便再观察几次吗?如果还出现,可以附一下对应请求的诊断包,便于对照终态用量”
|
||||
- 澄清误解或提出不同意见时,从观察和依据说起,照顾对方的使用环境与理解路径,避免责备、反问或居高临下的判断;已确认的事实保持明确,尚未确认的原因保留余地
|
||||
- 使用自然短句,简单回复用短段,并列信息较多时再分点;少用句号,避免客服套话、机械模板和空泛保证
|
||||
- 排查、复现、修改和验证的完成状态与实际一致;未采纳的意见说明依据,未确认、待处理或未验证的内容如实交代,说清结论、限制和下一步
|
||||
- 用法问题给出操作入口,功能取舍或关闭 Issue 说明与该场景相关的原因,有可行替代办法时再提。问题已答清即可结束
|
||||
- 排障先看原帖、已有材料和自己能核实的实现或发布记录。回复只附有助于理解结论或采取行动的排查信息,如相关版本、复现结果或脱敏片段。区分推测和实测
|
||||
- 只有缺失信息会改变判断或处理方式,且只能由对方提供时才追问。说清需要哪一项、用来区分什么情况
|
||||
|
||||
## 问题与方案依据
|
||||
|
||||
|
||||
Generated
+6
-6
@@ -3006,9 +3006,9 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
|
||||
|
||||
[[package]]
|
||||
name = "openssl"
|
||||
version = "0.10.80"
|
||||
version = "0.10.82"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a45fa2aa886c42762255da344f0a0d313e254066c46aad76f300c3d3da62d967"
|
||||
checksum = "4de8111e94a56adca7ebfe6c365b6d42f99deb69b74b6becacd4204e2f193aa2"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"cfg-if",
|
||||
@@ -3052,9 +3052,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "openssl-sys"
|
||||
version = "0.9.116"
|
||||
version = "0.9.118"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
|
||||
checksum = "19c413d6ec9ebaf5e1c829d355cb3e9f783778d700f135be0921d52fce3c60ae"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"libc",
|
||||
@@ -4797,7 +4797,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "tokio-tungstenite"
|
||||
version = "0.28.0"
|
||||
source = "git+https://github.com/openai-oss-forks/tokio-tungstenite?rev=0e5b2d73aa18dd9f0a50ee9ff199d5aef7594186#0e5b2d73aa18dd9f0a50ee9ff199d5aef7594186"
|
||||
source = "git+https://github.com/openai-oss-forks/tokio-tungstenite?rev=7447c427513cfe685f236e1ac0513c4ea3dd9c0b#7447c427513cfe685f236e1ac0513c4ea3dd9c0b"
|
||||
dependencies = [
|
||||
"futures-util",
|
||||
"log",
|
||||
@@ -5006,7 +5006,7 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
|
||||
[[package]]
|
||||
name = "tungstenite"
|
||||
version = "0.27.0"
|
||||
source = "git+https://github.com/openai-oss-forks/tungstenite-rs?rev=4fffad30fe373adbdcffab9545e9e9bf4f2fc19f#4fffad30fe373adbdcffab9545e9e9bf4f2fc19f"
|
||||
source = "git+https://github.com/openai-oss-forks/tungstenite-rs?rev=bc589d684755a8c02da0fc7e58d0861cbfc306f1#bc589d684755a8c02da0fc7e58d0861cbfc306f1"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"data-encoding",
|
||||
|
||||
@@ -23,6 +23,7 @@ pub mod provider_credentials;
|
||||
pub mod proxies;
|
||||
pub mod quota_forecast;
|
||||
pub mod quota_forecast_sampling;
|
||||
pub mod quota_history;
|
||||
pub mod reset_credit_automation;
|
||||
pub mod retention;
|
||||
pub mod settings;
|
||||
|
||||
@@ -158,7 +158,7 @@ impl OtherRequestOutcome {
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
|
||||
pub struct UsageFilter {
|
||||
pub client_api_key_name: Option<String>,
|
||||
pub provider_account_name: Option<String>,
|
||||
pub provider_account_search: Option<String>,
|
||||
pub client_api_key_ref: Option<String>,
|
||||
pub request_id: Option<String>,
|
||||
pub provider_account_ref: Option<String>,
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
//! 单个额度桶的历史观测;原始文档只在宿主内交给 Provider 解释
|
||||
|
||||
use chrono::{DateTime, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use super::{observability::TimeRange, provider_credentials::ProviderDocument};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct QuotaHistoryQuery {
|
||||
pub window_key: String,
|
||||
pub range: TimeRange,
|
||||
pub cursor: Option<QuotaHistoryCursor>,
|
||||
}
|
||||
|
||||
impl QuotaHistoryQuery {
|
||||
/// 起点基线最多回看一个查询区间
|
||||
pub fn scan_start(&self) -> DateTime<Utc> {
|
||||
self.range
|
||||
.start
|
||||
.checked_sub_signed(self.range.end - self.range.start)
|
||||
.unwrap_or(DateTime::<Utc>::MIN_UTC)
|
||||
}
|
||||
}
|
||||
|
||||
/// 完成时间可能相同,继续读取时保留数据库精度和请求 ID
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct QuotaHistoryCursor {
|
||||
pub completed_at: DateTime<Utc>,
|
||||
pub id: String,
|
||||
}
|
||||
|
||||
pub struct QuotaDocumentPage {
|
||||
pub documents: Vec<(DateTime<Utc>, ProviderDocument)>,
|
||||
pub next_cursor: Option<QuotaHistoryCursor>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct QuotaReading {
|
||||
pub plan_type: Option<String>,
|
||||
pub used_percent: f64,
|
||||
pub reset_at: Option<DateTime<Utc>>,
|
||||
}
|
||||
|
||||
pub type QuotaHistoryParser = fn(&ProviderDocument, &str) -> Option<QuotaReading>;
|
||||
|
||||
pub struct QuotaHistoryPoint {
|
||||
pub observed_at: DateTime<Utc>,
|
||||
pub reading: QuotaReading,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct QuotaHistoryPage {
|
||||
pub samples: Vec<QuotaHistoryPoint>,
|
||||
pub baseline: Option<QuotaHistoryPoint>,
|
||||
pub next_cursor: Option<QuotaHistoryCursor>,
|
||||
}
|
||||
|
||||
impl QuotaHistoryPage {
|
||||
pub fn from_documents(
|
||||
page: QuotaDocumentPage,
|
||||
query: &QuotaHistoryQuery,
|
||||
parse: QuotaHistoryParser,
|
||||
) -> Self {
|
||||
let mut result = Self {
|
||||
next_cursor: page.next_cursor,
|
||||
..Self::default()
|
||||
};
|
||||
for (observed_at, document) in page.documents {
|
||||
let Some(reading) = parse(&document, &query.window_key) else {
|
||||
continue;
|
||||
};
|
||||
let point = QuotaHistoryPoint {
|
||||
observed_at,
|
||||
reading,
|
||||
};
|
||||
if observed_at < query.range.start {
|
||||
// 倒序扫描遇到的第一个同桶读数就是最近基线,无需再向前翻页
|
||||
result.baseline = Some(point);
|
||||
result.next_cursor = None;
|
||||
break;
|
||||
}
|
||||
result.samples.push(point);
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
@@ -34,6 +34,12 @@ pub trait PluginAccountAccess: Send + Sync {
|
||||
Err(AdminError::unavailable("插件额度事实查询暂不可用"))
|
||||
}
|
||||
|
||||
async fn quota_history(
|
||||
&self,
|
||||
account: &ProviderAccountId,
|
||||
query: crate::model::quota_history::QuotaHistoryQuery,
|
||||
) -> Result<crate::model::quota_history::QuotaHistoryPage, AdminError>;
|
||||
|
||||
/// 通过 Provider 原生管理路径刷新额度;不向插件暴露凭据或执行额度重置
|
||||
async fn refresh_quota(
|
||||
&self,
|
||||
|
||||
@@ -349,6 +349,11 @@ pub trait ProviderAdmin: Send + Sync {
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
/// 历史文档由 Provider 按稳定窗口键解释,不支持的 Provider 不扫描请求记录
|
||||
fn quota_history_parser(&self) -> Option<crate::model::quota_history::QuotaHistoryParser> {
|
||||
None
|
||||
}
|
||||
|
||||
/// 历史观测的协议字段仅由具体 Provider 解释;不支持时保留累计估算
|
||||
fn quota_forecast_observation(
|
||||
&self,
|
||||
|
||||
@@ -180,6 +180,16 @@ pub trait AccountStore:
|
||||
windows: &[AccountUsageWindowQuery],
|
||||
) -> AdminStoreResult<Vec<AccountUsageWindowResult>>;
|
||||
|
||||
/// 按完成时间倒序读取一页保留的请求观测,不按本地计费结果筛选
|
||||
async fn quota_documents(
|
||||
&self,
|
||||
account: &gateway_core::account::ProviderAccountId,
|
||||
provider: &gateway_core::routing::ProviderKind,
|
||||
created_at: DateTime<Utc>,
|
||||
range: TimeRange,
|
||||
before: Option<&crate::model::quota_history::QuotaHistoryCursor>,
|
||||
) -> AdminStoreResult<crate::model::quota_history::QuotaDocumentPage>;
|
||||
|
||||
/// 从同一数据库语句取得截止快照的累计用量和有界历史观测
|
||||
async fn load_quota_forecast_history(
|
||||
&self,
|
||||
|
||||
@@ -126,6 +126,46 @@ impl PluginAccountAccess for DefaultPluginAccountAccess {
|
||||
self.quota(account_id, false).await
|
||||
}
|
||||
|
||||
async fn quota_history(
|
||||
&self,
|
||||
account_id: &ProviderAccountId,
|
||||
query: crate::model::quota_history::QuotaHistoryQuery,
|
||||
) -> Result<crate::model::quota_history::QuotaHistoryPage, AdminError> {
|
||||
use crate::model::{observability::TimeRange, quota_history::QuotaHistoryPage};
|
||||
|
||||
let account = self
|
||||
.accounts
|
||||
.load_account_record(account_id)
|
||||
.await
|
||||
.map_err(|error| map_store_error(error, "plugin quota history"))?
|
||||
.ok_or_else(|| AdminError::not_found("账号不存在"))?;
|
||||
let Some(parse) = self
|
||||
.provider(&account.provider_kind)?
|
||||
.quota_history_parser()
|
||||
else {
|
||||
return Ok(QuotaHistoryPage::default());
|
||||
};
|
||||
let start = query.scan_start().max(account.created_at);
|
||||
if start >= query.range.end {
|
||||
return Ok(QuotaHistoryPage::default());
|
||||
}
|
||||
let page = self
|
||||
.accounts
|
||||
.quota_documents(
|
||||
account_id,
|
||||
&account.provider_kind,
|
||||
account.created_at,
|
||||
TimeRange {
|
||||
start,
|
||||
end: query.range.end,
|
||||
},
|
||||
query.cursor.as_ref(),
|
||||
)
|
||||
.await
|
||||
.map_err(|error| map_store_error(error, "plugin quota history"))?;
|
||||
Ok(QuotaHistoryPage::from_documents(page, &query, parse))
|
||||
}
|
||||
|
||||
async fn refresh_quota(
|
||||
&self,
|
||||
account_id: &ProviderAccountId,
|
||||
|
||||
@@ -845,6 +845,17 @@ impl AccountStore for FakeAccountStore {
|
||||
.clone())
|
||||
}
|
||||
|
||||
async fn quota_documents(
|
||||
&self,
|
||||
_: &gateway_core::account::ProviderAccountId,
|
||||
_: &gateway_core::routing::ProviderKind,
|
||||
_: chrono::DateTime<chrono::Utc>,
|
||||
_: gateway_admin::model::observability::TimeRange,
|
||||
_: Option<&gateway_admin::model::quota_history::QuotaHistoryCursor>,
|
||||
) -> AdminStoreResult<gateway_admin::model::quota_history::QuotaDocumentPage> {
|
||||
unreachable!("测试不读取历史额度文档")
|
||||
}
|
||||
|
||||
async fn load_quota_forecast_history(
|
||||
&self,
|
||||
window: &AccountUsageWindowQuery,
|
||||
|
||||
@@ -546,6 +546,17 @@ impl AccountStore for UnavailableStore {
|
||||
Err(unavailable("account quota window usage"))
|
||||
}
|
||||
|
||||
async fn quota_documents(
|
||||
&self,
|
||||
_: &gateway_core::account::ProviderAccountId,
|
||||
_: &gateway_core::routing::ProviderKind,
|
||||
_: chrono::DateTime<chrono::Utc>,
|
||||
_: gateway_admin::model::observability::TimeRange,
|
||||
_: Option<&gateway_admin::model::quota_history::QuotaHistoryCursor>,
|
||||
) -> AdminStoreResult<gateway_admin::model::quota_history::QuotaDocumentPage> {
|
||||
unreachable!("测试不读取历史额度文档")
|
||||
}
|
||||
|
||||
async fn load_quota_forecast_history(
|
||||
&self,
|
||||
_: &AccountUsageWindowQuery,
|
||||
|
||||
@@ -32,7 +32,7 @@ impl DashboardQuery {
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
pub struct UsageQuery {
|
||||
pub client_api_key_name: Option<String>,
|
||||
pub account_name: Option<String>,
|
||||
pub account_search: Option<String>,
|
||||
pub status: Option<String>,
|
||||
pub current_page: Option<u32>,
|
||||
pub page_size: Option<u16>,
|
||||
@@ -339,7 +339,7 @@ pub(crate) fn dashboard_today_range(
|
||||
pub(crate) fn usage_filter(query: &UsageQuery) -> domain::UsageFilter {
|
||||
domain::UsageFilter {
|
||||
client_api_key_name: non_empty(query.client_api_key_name.clone()),
|
||||
provider_account_name: non_empty(query.account_name.clone()),
|
||||
provider_account_search: non_empty(query.account_search.clone()),
|
||||
provider_kind: non_empty(query.provider.clone()),
|
||||
model_contains: non_empty(query.model.clone()),
|
||||
..Default::default()
|
||||
|
||||
@@ -19,7 +19,6 @@ use crate::openai::generation::{
|
||||
};
|
||||
|
||||
const OPENAI_SUBAGENT_KEY: &str = "x-openai-subagent";
|
||||
const CODEX_TURN_METADATA_KEY: &str = "x-codex-turn-metadata";
|
||||
const PASSTHROUGH_HEADERS_CONTEXT_KEY: &str = "opaque_request_headers";
|
||||
const DOWNSTREAM_WEBSOCKET_CONNECTION_ID_CONTEXT_KEY: &str = "downstream_websocket_connection_id";
|
||||
|
||||
@@ -36,9 +35,7 @@ pub(super) enum RequestDecodeSource {
|
||||
pub struct OpenAiRequestHeaders {
|
||||
turn_state: Option<String>,
|
||||
turn_metadata: Option<String>,
|
||||
beta_features: Option<String>,
|
||||
version: Option<String>,
|
||||
include_timing_metrics: Option<String>,
|
||||
codex_window_id: Option<String>,
|
||||
parent_thread_id: Option<String>,
|
||||
downstream_websocket_connection_id: Option<String>,
|
||||
@@ -62,9 +59,7 @@ impl OpenAiRequestHeaders {
|
||||
Self {
|
||||
turn_state: header_string(headers, "x-codex-turn-state"),
|
||||
turn_metadata: header_string(headers, "x-codex-turn-metadata"),
|
||||
beta_features: header_string(headers, "x-codex-beta-features"),
|
||||
version: header_string(headers, "version"),
|
||||
include_timing_metrics: header_string(headers, "x-responsesapi-include-timing-metrics"),
|
||||
codex_window_id: header_string(headers, "x-codex-window-id"),
|
||||
parent_thread_id: header_string(headers, "x-codex-parent-thread-id"),
|
||||
downstream_websocket_connection_id: None,
|
||||
@@ -120,22 +115,18 @@ impl OpenAiRequestHeaders {
|
||||
fn protocol_context(
|
||||
&self,
|
||||
use_websocket: Option<bool>,
|
||||
frame_turn_metadata: Option<&String>,
|
||||
source: RequestDecodeSource,
|
||||
) -> Map<String, Value> {
|
||||
let mut context = Map::new();
|
||||
insert_protocol_context(&mut context, "turn_state", self.turn_state.as_ref());
|
||||
insert_protocol_context(
|
||||
&mut context,
|
||||
"turn_metadata",
|
||||
frame_turn_metadata.or(self.turn_metadata.as_ref()),
|
||||
);
|
||||
insert_protocol_context(&mut context, "beta_features", self.beta_features.as_ref());
|
||||
insert_protocol_context(&mut context, "turn_metadata", self.turn_metadata.as_ref());
|
||||
if matches!(source, RequestDecodeSource::WebSocketFrame) {
|
||||
context.insert(
|
||||
gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY.to_owned(),
|
||||
Value::Bool(true),
|
||||
);
|
||||
}
|
||||
insert_protocol_context(&mut context, "version", self.version.as_ref());
|
||||
insert_protocol_context(
|
||||
&mut context,
|
||||
"include_timing_metrics",
|
||||
self.include_timing_metrics.as_ref(),
|
||||
);
|
||||
insert_protocol_context(
|
||||
&mut context,
|
||||
"codex_window_id",
|
||||
@@ -338,11 +329,7 @@ pub(super) fn decode_request_object(
|
||||
.unwrap_or(ContinuationIntent::None);
|
||||
|
||||
request_headers.apply_subagent(&mut object);
|
||||
let frame_turn_metadata = match source {
|
||||
RequestDecodeSource::Http => None,
|
||||
RequestDecodeSource::WebSocketFrame => frame_turn_metadata(&object),
|
||||
};
|
||||
let protocol_context = request_headers.protocol_context(use_websocket, frame_turn_metadata);
|
||||
let protocol_context = request_headers.protocol_context(use_websocket, source);
|
||||
|
||||
let semantics =
|
||||
gateway_protocol::openai::codex_responses_request_semantics(&object, &protocol_context);
|
||||
@@ -381,16 +368,6 @@ pub(super) fn decode_request_object(
|
||||
})
|
||||
}
|
||||
|
||||
fn frame_turn_metadata(body: &Map<String, Value>) -> Option<&String> {
|
||||
body.get("client_metadata")
|
||||
.and_then(Value::as_object)
|
||||
.and_then(|metadata| metadata.get(CODEX_TURN_METADATA_KEY))
|
||||
.and_then(|value| match value {
|
||||
Value::String(value) if !value.trim().is_empty() => Some(value),
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
|
||||
fn inject_subagent_metadata(body: &mut Map<String, Value>, subagent: &str) {
|
||||
let metadata = body
|
||||
.entry("client_metadata".to_owned())
|
||||
|
||||
@@ -74,13 +74,11 @@ pub(crate) async fn responses_websocket(
|
||||
&headers,
|
||||
connect_info.map(|Extension(ConnectInfo(address))| address),
|
||||
);
|
||||
let request_headers = OpenAiRequestHeaders::from_headers(&headers);
|
||||
ResponsesWebSocketAdapter::new(service).upgrade_with_client_context(
|
||||
websocket,
|
||||
client,
|
||||
client_ip,
|
||||
user_agent,
|
||||
request_headers,
|
||||
headers,
|
||||
middleware.map(|Extension(plan)| plan),
|
||||
lifetime.map(|Extension(lifetime)| lifetime),
|
||||
@@ -107,7 +105,6 @@ impl ResponsesWebSocketAdapter {
|
||||
client: AuthenticatedClient,
|
||||
client_ip: Option<IpAddr>,
|
||||
user_agent: Option<String>,
|
||||
request_headers: OpenAiRequestHeaders,
|
||||
raw_headers: HeaderMap,
|
||||
middleware: Option<FrozenMiddlewarePlan>,
|
||||
lifetime: Option<Arc<crate::middleware::CallLifetime>>,
|
||||
@@ -130,7 +127,6 @@ impl ResponsesWebSocketAdapter {
|
||||
connection_id,
|
||||
client_ip,
|
||||
user_agent,
|
||||
request_headers,
|
||||
raw_headers,
|
||||
lifecycle: self.service.lifecycle(),
|
||||
connection_guard,
|
||||
@@ -150,7 +146,6 @@ struct ResponsesWebSocketSession {
|
||||
connection_id: String,
|
||||
client_ip: Option<IpAddr>,
|
||||
user_agent: Option<String>,
|
||||
request_headers: OpenAiRequestHeaders,
|
||||
raw_headers: HeaderMap,
|
||||
lifecycle: Arc<dyn ConnectionLifecycle>,
|
||||
connection_guard: Box<dyn ConnectionGuard>,
|
||||
@@ -164,8 +159,7 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
|
||||
connection_id,
|
||||
client_ip,
|
||||
user_agent,
|
||||
request_headers,
|
||||
raw_headers,
|
||||
mut raw_headers,
|
||||
lifecycle,
|
||||
connection_guard,
|
||||
middleware,
|
||||
@@ -178,8 +172,6 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
|
||||
let cancellation = lifecycle.cancellation().child_token();
|
||||
let _connection_cancellation =
|
||||
crate::middleware::websocket::CancelOnDrop(Some(cancellation.clone()));
|
||||
let request_headers =
|
||||
request_headers.with_downstream_websocket_connection_id(connection_id.clone());
|
||||
// 帧中间件可能改写终态,此时不能据原始响应关闭下游连接
|
||||
let reconnect_for_replay = !middleware
|
||||
.as_ref()
|
||||
@@ -241,31 +233,32 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
|
||||
continue;
|
||||
}
|
||||
request_count = request_count.saturating_add(1);
|
||||
// 初步解码只保留路由事实,避免整份正文跨越准入等待和响应交付
|
||||
let model_hint = match decode_response_create_with_context(&payload, &request_headers) {
|
||||
Ok(decoded) => Some(decoded.metadata().requested_model().to_owned()),
|
||||
Err(error) => {
|
||||
trace_rejected_request(
|
||||
&correlation_id,
|
||||
connection.id(),
|
||||
&payload,
|
||||
"decode",
|
||||
&error.to_string(),
|
||||
);
|
||||
if send_protocol_error(
|
||||
&mut connection,
|
||||
StatusCode::BAD_REQUEST,
|
||||
error.protocol_body(),
|
||||
&correlation_id,
|
||||
)
|
||||
.await
|
||||
== ForwardOutcome::Disconnect
|
||||
{
|
||||
break;
|
||||
// 初步解码只取帧中的模型,实际执行使用该帧当前生效的请求头
|
||||
let model_hint =
|
||||
match decode_response_create_with_context(&payload, &OpenAiRequestHeaders::default()) {
|
||||
Ok(decoded) => Some(decoded.metadata().requested_model().to_owned()),
|
||||
Err(error) => {
|
||||
trace_rejected_request(
|
||||
&correlation_id,
|
||||
connection.id(),
|
||||
&payload,
|
||||
"decode",
|
||||
&error.to_string(),
|
||||
);
|
||||
if send_protocol_error(
|
||||
&mut connection,
|
||||
StatusCode::BAD_REQUEST,
|
||||
error.protocol_body(),
|
||||
&correlation_id,
|
||||
)
|
||||
.await
|
||||
== ForwardOutcome::Disconnect
|
||||
{
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
};
|
||||
};
|
||||
// deadline 与 Text 可能同时就绪;在任何上游执行开始前再次封住该竞争窗口
|
||||
if connection.is_expired() {
|
||||
trace_rejected_request(
|
||||
@@ -336,6 +329,9 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe
|
||||
headers: encode_headers(&raw_headers),
|
||||
body: Bytes::from(payload),
|
||||
};
|
||||
// 握手的轮次头只属于首次执行,复用连接时由各 response.create 携带本轮数据
|
||||
raw_headers.remove("x-codex-turn-state");
|
||||
raw_headers.remove("x-codex-turn-metadata");
|
||||
let service_for_terminal = service.clone();
|
||||
let replay_for_terminal = replay.clone();
|
||||
let connection_id_for_terminal = connection.id().to_owned();
|
||||
|
||||
@@ -1300,6 +1300,17 @@ impl AccountStore for UnusedStore {
|
||||
Err(unavailable("account quota window usage"))
|
||||
}
|
||||
|
||||
async fn quota_documents(
|
||||
&self,
|
||||
_: &gateway_core::account::ProviderAccountId,
|
||||
_: &gateway_core::routing::ProviderKind,
|
||||
_: chrono::DateTime<chrono::Utc>,
|
||||
_: gateway_admin::model::observability::TimeRange,
|
||||
_: Option<&gateway_admin::model::quota_history::QuotaHistoryCursor>,
|
||||
) -> AdminStoreResult<gateway_admin::model::quota_history::QuotaDocumentPage> {
|
||||
unreachable!("测试不读取历史额度文档")
|
||||
}
|
||||
|
||||
async fn load_quota_forecast_history(
|
||||
&self,
|
||||
_: &AccountUsageWindowQuery,
|
||||
|
||||
@@ -917,7 +917,7 @@ pub(super) fn usage_record_with_account(
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn usage_route_should_forward_name_and_model_contains_filters() {
|
||||
async fn usage_route_should_forward_record_text_filters() {
|
||||
use axum::{
|
||||
body::Body,
|
||||
http::{Request, StatusCode, header},
|
||||
@@ -933,7 +933,7 @@ async fn usage_route_should_forward_name_and_model_contains_filters() {
|
||||
.with_state(fixture.state())
|
||||
.oneshot(
|
||||
Request::builder()
|
||||
.uri("/api/admin/usage/records?model=%20coding%20&clientApiKeyName=%20Key%20%25%20&accountName=%20Account%20Name%20")
|
||||
.uri("/api/admin/usage/records?model=%20coding%20&clientApiKeyName=%20Key%20%25%20&accountSearch=%20alice%40%20")
|
||||
.header(header::COOKIE, "cpr_session=valid-session")
|
||||
.header("x-request-id", "req_usage_other_outcome")
|
||||
.body(Body::empty())
|
||||
@@ -947,10 +947,7 @@ async fn usage_route_should_forward_name_and_model_contains_filters() {
|
||||
let filter = &observations.records.last().expect("usage query").filter;
|
||||
assert_eq!(filter.client_api_key_name.as_deref(), Some("Key %"));
|
||||
assert_eq!(filter.model_contains.as_deref(), Some("coding"));
|
||||
assert_eq!(
|
||||
filter.provider_account_name.as_deref(),
|
||||
Some("Account Name")
|
||||
);
|
||||
assert_eq!(filter.provider_account_search.as_deref(), Some("alice@"));
|
||||
assert!(filter.client_api_key_ref.is_none());
|
||||
assert!(filter.provider_account_ref.is_none());
|
||||
}
|
||||
|
||||
@@ -45,6 +45,14 @@ impl Drop for TestServer {
|
||||
async fn connect(
|
||||
trace: Arc<AtomicFailureTrace>,
|
||||
response_headers: Vec<ProviderResponseHeader>,
|
||||
) -> (TestSocket, TestServer) {
|
||||
connect_with_headers(trace, response_headers, axum::http::HeaderMap::new()).await
|
||||
}
|
||||
|
||||
async fn connect_with_headers(
|
||||
trace: Arc<AtomicFailureTrace>,
|
||||
response_headers: Vec<ProviderResponseHeader>,
|
||||
opening_headers: axum::http::HeaderMap,
|
||||
) -> (TestSocket, TestServer) {
|
||||
let execution = Arc::new(AtomicFailureExecution {
|
||||
client: authenticated_client("sk_ws_atomic"),
|
||||
@@ -66,6 +74,7 @@ async fn connect(
|
||||
request
|
||||
.headers_mut()
|
||||
.insert(AUTHORIZATION, "Bearer sk_ws_atomic".parse().unwrap());
|
||||
request.headers_mut().extend(opening_headers);
|
||||
let (socket, response) = connect_async(request).await.expect("upgrade WebSocket");
|
||||
assert_eq!(response.status(), StatusCode::SWITCHING_PROTOCOLS);
|
||||
(socket, server)
|
||||
@@ -518,13 +527,32 @@ async fn errors_on_a_reused_connection_keep_their_own_upstream_ids() {
|
||||
initial_errors: Mutex::new(VecDeque::from(errors)),
|
||||
..AtomicFailureTrace::default()
|
||||
});
|
||||
let (mut socket, _server) = connect(trace, Vec::new()).await;
|
||||
let mut opening = axum::http::HeaderMap::new();
|
||||
opening.insert(
|
||||
"x-codex-turn-state",
|
||||
axum::http::HeaderValue::from_static("opening"),
|
||||
);
|
||||
opening.insert(
|
||||
"x-codex-turn-metadata",
|
||||
axum::http::HeaderValue::from_static(r#"{"request_kind":"turn"}"#),
|
||||
);
|
||||
let (mut socket, _server) = connect_with_headers(Arc::clone(&trace), Vec::new(), opening).await;
|
||||
for request_id in ["req_first", "req_second"] {
|
||||
send_request(&mut socket).await;
|
||||
let error = next_error(&mut socket).await;
|
||||
assert_eq!(error["headers"]["x-request-id"], request_id);
|
||||
assert_eq!(error["headers"]["x-gateway-request-id"], "req_ws_atomic");
|
||||
}
|
||||
assert_eq!(
|
||||
*trace.request_turn_headers.lock().unwrap(),
|
||||
[
|
||||
[
|
||||
Some("opening".to_owned()),
|
||||
Some(r#"{"request_kind":"turn"}"#.to_owned())
|
||||
],
|
||||
[None, None]
|
||||
]
|
||||
);
|
||||
assert_no_duplicate_failure(&mut socket).await;
|
||||
socket.close(None).await.unwrap();
|
||||
}
|
||||
|
||||
@@ -168,21 +168,31 @@ fn response_create_should_preserve_compaction_trigger_for_openai() {
|
||||
|
||||
#[test]
|
||||
fn response_create_should_prefer_frame_turn_metadata_over_opening_headers() {
|
||||
let frame = r#"{"request_kind":"turn","tool_namespaces_info":{"workspace":{}}}"#;
|
||||
let opening = r#"{"request_kind":"compaction"}"#;
|
||||
let decoded = decode_response_create_with_turn_header(
|
||||
json!({
|
||||
"type": "response.create",
|
||||
"model": "smart-code",
|
||||
"input": "hello",
|
||||
"client_metadata": {
|
||||
"x-codex-turn-metadata": r#"{"request_kind":"turn"}"#
|
||||
"x-codex-turn-metadata": frame
|
||||
}
|
||||
}),
|
||||
r#"{"request_kind":"compaction"}"#,
|
||||
opening,
|
||||
);
|
||||
let Operation::Generate(request) = decoded.operation() else {
|
||||
panic!("Responses must map to Generate");
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
request.protocol_payload().context()["turn_metadata"],
|
||||
opening
|
||||
);
|
||||
assert_eq!(
|
||||
request.protocol_payload().body()["client_metadata"]["x-codex-turn-metadata"],
|
||||
frame
|
||||
);
|
||||
let semantics = codex_responses_request_semantics(
|
||||
request.protocol_payload().body(),
|
||||
request.protocol_payload().context(),
|
||||
@@ -308,6 +318,7 @@ struct AtomicFailureTrace {
|
||||
committed: AtomicBool,
|
||||
finalized: AtomicBool,
|
||||
downstream_websocket_connection_ids: Mutex<Vec<String>>,
|
||||
request_turn_headers: Mutex<Vec<[Option<String>; 2]>>,
|
||||
initial_errors: Mutex<std::collections::VecDeque<EngineError>>,
|
||||
first_batch: Mutex<Option<CoordinatedEvent>>,
|
||||
session_drops: Arc<AtomicUsize>,
|
||||
@@ -437,6 +448,11 @@ impl ExecutionService for AtomicFailureExecution {
|
||||
.get("downstream_websocket_connection_id")
|
||||
.and_then(Value::as_str)
|
||||
{
|
||||
let context = generate.protocol_payload().context();
|
||||
self.trace.request_turn_headers.lock().unwrap().push(
|
||||
["turn_state", "turn_metadata"]
|
||||
.map(|key| context.get(key).and_then(Value::as_str).map(str::to_owned)),
|
||||
);
|
||||
self.trace
|
||||
.downstream_websocket_connection_ids
|
||||
.lock()
|
||||
|
||||
@@ -1947,7 +1947,7 @@ where
|
||||
let store = Arc::clone(self.engine.store());
|
||||
let request_id = self.request_id.clone();
|
||||
let persisted = self.request_persisted;
|
||||
// 错误、账号 lease 与决策 future 都跨 next_event 的取消保留
|
||||
// 错误、尝试记录与决策 future 都跨 next_event 的取消保留
|
||||
// 在持久化及策略回调完成前,不能再次拉流或建立新的 attempt
|
||||
self.current = Some(current);
|
||||
self.pending_stream_failure = Some(PendingStreamFailure {
|
||||
@@ -2440,6 +2440,9 @@ where
|
||||
}
|
||||
|
||||
async fn finish_interruption(&mut self, error: &EngineError) -> Result<(), EngineError> {
|
||||
if let Some(current) = self.current.as_mut() {
|
||||
current.stream.abort();
|
||||
}
|
||||
// 结算 I/O 可能继续等待,先冻结交付事实以保持终态与实际 HTTP 状态一致
|
||||
self.response_commit.finish();
|
||||
let (outcome, gateway_error) = match error {
|
||||
|
||||
@@ -982,11 +982,19 @@ impl AttemptContext {
|
||||
model: Option<&str>,
|
||||
candidates: &'a [AccountCandidate],
|
||||
context: &mut AccountSelectionContext,
|
||||
ownership: policy::AccountScheduleOwnership<'_>,
|
||||
) -> Result<Option<AccountSelection<'a>>, policy::AccountPolicyError> {
|
||||
match self.request.request_policy() {
|
||||
Some(policy) => {
|
||||
policy
|
||||
.select_account(self.attempt_index, provider, model, candidates, context)
|
||||
.select_account(
|
||||
self.attempt_index,
|
||||
provider,
|
||||
model,
|
||||
candidates,
|
||||
context,
|
||||
ownership,
|
||||
)
|
||||
.await
|
||||
}
|
||||
None => Ok(crate::account::AccountSelector.select(candidates, context)),
|
||||
|
||||
@@ -115,10 +115,29 @@ pub enum ModelRouteDecision {
|
||||
Reject,
|
||||
}
|
||||
|
||||
/// Provider 在本轮选号中已解析的归属,仅用于向插件投影候选关系
|
||||
#[derive(Debug, Default, Clone, Copy)]
|
||||
pub struct AccountScheduleOwnership<'a> {
|
||||
pub bound_account: Option<&'a ProviderAccountId>,
|
||||
pub follow_only: bool,
|
||||
pub pinned_account: Option<&'a ProviderAccountId>,
|
||||
}
|
||||
|
||||
/// 本轮内置选号如何对待这个候选;显式选号仍受宿主资格和固定归属约束
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum AccountScheduleRole {
|
||||
Ordinary,
|
||||
Preferred,
|
||||
FollowOnly,
|
||||
Pinned,
|
||||
}
|
||||
|
||||
/// 账号调度插件可见的单个候选事实,不包含凭据或账号资料
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct AccountScheduleCandidate {
|
||||
account_id: ProviderAccountId,
|
||||
session_bound: bool,
|
||||
role: AccountScheduleRole,
|
||||
available: bool,
|
||||
weight: u16,
|
||||
in_flight: u32,
|
||||
@@ -131,6 +150,16 @@ pub struct AccountScheduleCandidate {
|
||||
}
|
||||
|
||||
impl AccountScheduleCandidate {
|
||||
#[must_use]
|
||||
pub const fn session_bound(&self) -> bool {
|
||||
self.session_bound
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub const fn role(&self) -> AccountScheduleRole {
|
||||
self.role
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub const fn available(&self) -> bool {
|
||||
self.available
|
||||
@@ -469,6 +498,7 @@ impl RequestPolicyContext {
|
||||
model: Option<&str>,
|
||||
candidates: &'a [AccountCandidate],
|
||||
context: &mut AccountSelectionContext,
|
||||
ownership: AccountScheduleOwnership<'_>,
|
||||
) -> Result<Option<AccountSelection<'a>>, AccountPolicyError> {
|
||||
let eligible = AccountSelector.policy_candidates(candidates, context);
|
||||
if eligible.is_empty() {
|
||||
@@ -476,19 +506,33 @@ impl RequestPolicyContext {
|
||||
}
|
||||
let projected = eligible
|
||||
.iter()
|
||||
.map(|candidate| AccountScheduleCandidate {
|
||||
account_id: candidate.account.id().clone(),
|
||||
available: AccountSelector
|
||||
.scheduling_blocker(candidate, context)
|
||||
.is_none(),
|
||||
weight: candidate.account.weight().get(),
|
||||
in_flight: candidate.signals.in_flight,
|
||||
maximum_concurrency: context.concurrency_limit(candidate).get(),
|
||||
last_started_at: candidate.signals.last_started_at,
|
||||
quota_reset_at: candidate.signals.quota_reset_at,
|
||||
quota_remaining_rank: candidate.signals.quota_remaining_rank,
|
||||
failure_rate_basis_points: candidate.signals.failure_rate_basis_points,
|
||||
first_output_latency_ms: candidate.signals.first_output_latency_ms,
|
||||
.map(|candidate| {
|
||||
let id = Some(candidate.account.id());
|
||||
let session_bound = ownership.bound_account == id;
|
||||
AccountScheduleCandidate {
|
||||
session_bound,
|
||||
role: if ownership.pinned_account == id {
|
||||
AccountScheduleRole::Pinned
|
||||
} else if session_bound && ownership.follow_only {
|
||||
AccountScheduleRole::FollowOnly
|
||||
} else if context.preferred_account.as_ref() == id {
|
||||
AccountScheduleRole::Preferred
|
||||
} else {
|
||||
AccountScheduleRole::Ordinary
|
||||
},
|
||||
account_id: candidate.account.id().clone(),
|
||||
available: AccountSelector
|
||||
.scheduling_blocker(candidate, context)
|
||||
.is_none(),
|
||||
weight: candidate.account.weight().get(),
|
||||
in_flight: candidate.signals.in_flight,
|
||||
maximum_concurrency: context.concurrency_limit(candidate).get(),
|
||||
last_started_at: candidate.signals.last_started_at,
|
||||
quota_reset_at: candidate.signals.quota_reset_at,
|
||||
quota_remaining_rank: candidate.signals.quota_remaining_rank,
|
||||
failure_rate_basis_points: candidate.signals.failure_rate_basis_points,
|
||||
first_output_latency_ms: candidate.signals.first_output_latency_ms,
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
let decision = self
|
||||
|
||||
@@ -250,8 +250,7 @@ const MAX_NATIVE_RESPONSE_EVENTS_PER_INPUT: usize = 64;
|
||||
/// 这样 Coordinator 可以先持久化 attempt,再越过发送屏障
|
||||
pub struct ProviderStream {
|
||||
metadata: ProviderCallMetadata,
|
||||
events: EventStream,
|
||||
_lease: Box<dyn ResourceLease>,
|
||||
source: Option<ProviderStreamSource>,
|
||||
native_response_translator: Option<Box<dyn NativeResponseTranslator>>,
|
||||
account_feedback: Option<ProviderStreamAccountFeedback>,
|
||||
account_protection: Option<super::account_protection::AttemptProtection>,
|
||||
@@ -259,7 +258,12 @@ pub struct ProviderStream {
|
||||
Option<futures::future::BoxFuture<'static, Option<Result<ProviderEvent, ProviderError>>>>,
|
||||
validator: Result<EventSequenceValidator, EventSequenceError>,
|
||||
strict_canonical_seen: bool,
|
||||
terminated: bool,
|
||||
}
|
||||
|
||||
// 事件流内部也可能持有同一租约,结束读取时须一并丢弃
|
||||
struct ProviderStreamSource {
|
||||
events: EventStream,
|
||||
_lease: Box<dyn ResourceLease>,
|
||||
}
|
||||
|
||||
struct ProviderStreamAccountFeedback {
|
||||
@@ -360,18 +364,25 @@ impl ProviderStream {
|
||||
{
|
||||
Self {
|
||||
metadata,
|
||||
events: Box::pin(events),
|
||||
_lease: Box::new(lease),
|
||||
source: Some(ProviderStreamSource {
|
||||
events: Box::pin(events),
|
||||
_lease: Box::new(lease),
|
||||
}),
|
||||
native_response_translator: None,
|
||||
account_feedback: None,
|
||||
account_protection: None,
|
||||
protection_feedback: None,
|
||||
validator: Ok(EventSequenceValidator::new()),
|
||||
strict_canonical_seen: false,
|
||||
terminated: false,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn abort(&mut self) {
|
||||
self.source.take();
|
||||
self.account_protection.take();
|
||||
self.protection_feedback.take();
|
||||
}
|
||||
|
||||
/// 在第一次发送前捕获反馈栅栏,诊断调用由协调器排除
|
||||
#[must_use]
|
||||
pub async fn with_account_error_protection(
|
||||
@@ -425,6 +436,15 @@ impl ProviderStream {
|
||||
/// source/target 格式不一致、单事件展开越界、终态被丢弃或 Provider 转换失败时
|
||||
/// 返回错误
|
||||
pub fn translate_native_response(
|
||||
&mut self,
|
||||
event: ProviderEvent,
|
||||
terminal: bool,
|
||||
) -> Result<Vec<ProviderEvent>, ProviderError> {
|
||||
self.translate_event(event, terminal)
|
||||
.inspect_err(|_| self.abort())
|
||||
}
|
||||
|
||||
fn translate_event(
|
||||
&mut self,
|
||||
mut event: ProviderEvent,
|
||||
terminal: bool,
|
||||
@@ -979,8 +999,12 @@ impl Stream for ProviderStream {
|
||||
};
|
||||
}
|
||||
let result = this.poll_event(context);
|
||||
let upstream_finished = matches!(&result, Poll::Ready(Some(Err(_)) | None));
|
||||
if upstream_finished {
|
||||
this.source.take();
|
||||
}
|
||||
// 客户端可在成功终态后停止拉取,不能依赖之后的 EOF 才清除保护证据
|
||||
let protection_terminal = matches!(&result, Poll::Ready(Some(Err(_)) | None))
|
||||
let protection_terminal = upstream_finished
|
||||
|| (matches!(&result, Poll::Ready(Some(Ok(_))))
|
||||
&& this
|
||||
.account_protection
|
||||
@@ -1003,14 +1027,14 @@ impl ProviderStream {
|
||||
context: &mut Context<'_>,
|
||||
) -> Poll<Option<Result<ProviderEvent, ProviderError>>> {
|
||||
let this = self;
|
||||
if this.terminated {
|
||||
let Some(source) = this.source.as_mut() else {
|
||||
return Poll::Ready(None);
|
||||
}
|
||||
};
|
||||
if let Some(feedback) = this.account_feedback.as_mut() {
|
||||
feedback.start();
|
||||
}
|
||||
|
||||
match this.events.as_mut().poll_next(context) {
|
||||
match source.events.as_mut().poll_next(context) {
|
||||
Poll::Pending => Poll::Pending,
|
||||
Poll::Ready(Some(Ok(event))) => {
|
||||
// 纯 wire 流的 facts 仍只是旁路观测;一旦交付 canonical-only
|
||||
@@ -1025,7 +1049,6 @@ impl ProviderStream {
|
||||
}
|
||||
}
|
||||
if this.strict_canonical_seen && this.validator.is_err() {
|
||||
this.terminated = true;
|
||||
let error =
|
||||
ProviderError::new(ProviderErrorKind::Protocol, UpstreamSendState::Sent);
|
||||
if let Some(feedback) = this.account_feedback.as_mut() {
|
||||
@@ -1042,14 +1065,12 @@ impl ProviderStream {
|
||||
Poll::Ready(Some(Ok(event)))
|
||||
}
|
||||
Poll::Ready(Some(Err(error))) => {
|
||||
this.terminated = true;
|
||||
if let Some(feedback) = this.account_feedback.as_mut() {
|
||||
feedback.report_failure(&error);
|
||||
}
|
||||
Poll::Ready(Some(Err(error)))
|
||||
}
|
||||
Poll::Ready(None) => {
|
||||
this.terminated = true;
|
||||
let validation = if this.strict_canonical_seen {
|
||||
this.validator
|
||||
.as_ref()
|
||||
|
||||
@@ -299,14 +299,17 @@ fn complete_success_is_reported_once_but_unfinished_drop_is_not_success() {
|
||||
Ok(gateway_core::event::GatewayEvent::Started(response.clone()).into()),
|
||||
Ok(gateway_core::event::GatewayEvent::Completed(response).into()),
|
||||
]);
|
||||
let mut completed = ProviderStream::new(metadata(), events, ())
|
||||
let released = Arc::new(AtomicUsize::new(0));
|
||||
let mut completed = ProviderStream::new(metadata(), events, Lease(released.clone()))
|
||||
.with_account_error_protection(store.clone(), Arc::new(policy().compile()), 5)
|
||||
.await;
|
||||
assert!(completed.next().await.unwrap().is_ok());
|
||||
assert_eq!(store.successes.load(Ordering::SeqCst), 0);
|
||||
assert!(completed.next().await.unwrap().is_ok());
|
||||
assert_eq!(store.successes.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(released.load(Ordering::SeqCst), 0);
|
||||
assert!(completed.next().await.is_none());
|
||||
assert_eq!(released.load(Ordering::SeqCst), 1);
|
||||
assert!(completed.next().await.is_none());
|
||||
assert_eq!(store.successes.load(Ordering::SeqCst), 1);
|
||||
});
|
||||
@@ -351,27 +354,27 @@ fn stalled_begin_and_feedback_are_bounded_and_preserve_original_failure() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelling_pending_feedback_releases_lease_and_does_not_report_success() {
|
||||
fn failed_stream_releases_lease_while_protection_feedback_is_pending() {
|
||||
futures::executor::block_on(async {
|
||||
let store = Arc::new(Feedback {
|
||||
stalled_feedback: true,
|
||||
..Feedback::default()
|
||||
});
|
||||
let released = Arc::new(AtomicUsize::new(0));
|
||||
let mut stream = ProviderStream::new(
|
||||
metadata(),
|
||||
stream::iter([Err(failure("invalid_prompt"))]),
|
||||
Lease(released.clone()),
|
||||
)
|
||||
.with_account_error_protection(store.clone(), Arc::new(policy().compile()), 5)
|
||||
.await;
|
||||
let lease = Arc::new(Lease(released.clone()));
|
||||
let events = stream::unfold(Arc::clone(&lease), |lease| async move {
|
||||
Some((Err(failure("invalid_prompt")), lease))
|
||||
});
|
||||
let mut stream = ProviderStream::new(metadata(), events, lease)
|
||||
.with_account_error_protection(store.clone(), Arc::new(policy().compile()), 5)
|
||||
.await;
|
||||
assert!(
|
||||
timeout(Duration::from_millis(10), stream.next())
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
drop(stream);
|
||||
assert_eq!(released.load(Ordering::SeqCst), 1);
|
||||
drop(stream);
|
||||
assert_eq!(store.successes.load(Ordering::SeqCst), 0);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -898,7 +898,7 @@ impl Provider for ScriptedProvider {
|
||||
futures::stream::iter(items.into_iter().map(canonical_provider_event))
|
||||
.chain(futures::stream::pending()),
|
||||
),
|
||||
(),
|
||||
TrackedLease(Arc::clone(&self.released_leases)),
|
||||
))
|
||||
}
|
||||
Script::ObservedStream { account_id, items } => {
|
||||
@@ -3402,7 +3402,16 @@ fn recovered_credential_retries_the_same_account_exactly_once() {
|
||||
CancellationToken::new(),
|
||||
))
|
||||
.expect("start execution");
|
||||
block_on(session.collect_uncommitted()).expect("recovered account succeeds");
|
||||
let (release, gate) = oneshot::channel();
|
||||
*store.intermediate_gate.lock().unwrap() = Some(gate);
|
||||
block_on(async {
|
||||
let mut collect = Box::pin(session.collect_uncommitted());
|
||||
assert!(futures::poll!(collect.as_mut()).is_pending());
|
||||
assert_eq!(provider.contexts.lock().unwrap().len(), 1);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
|
||||
release.send(()).unwrap();
|
||||
collect.await.expect("recovered account succeeds");
|
||||
});
|
||||
block_on(session.commit_downstream(Some(200))).expect("commit response");
|
||||
|
||||
let contexts = provider.contexts.lock().expect("contexts lock");
|
||||
@@ -5408,7 +5417,7 @@ fn delivered_prelude_allows_retry_without_control_until_non_replayable_delivery(
|
||||
fn cancellation_before_pending_delivery_commit_reaches_terminal_state() {
|
||||
let operation = generate_operation();
|
||||
let route_plan = plan(&operation);
|
||||
let (coordinator, store, _) = coordinator(vec![Script::Stream {
|
||||
let (coordinator, store, provider) = coordinator(vec![Script::Stream {
|
||||
account_id: "acct_first",
|
||||
items: complete_stream(None),
|
||||
}]);
|
||||
@@ -5429,7 +5438,15 @@ fn cancellation_before_pending_delivery_commit_reaches_terminal_state() {
|
||||
CommitRequirement::CommitBeforeDelivery
|
||||
);
|
||||
|
||||
block_on(session.cancel_and_finalize()).expect("cancel finalization");
|
||||
let (release, gate) = oneshot::channel();
|
||||
*store.send_gate.lock().unwrap() = Some(gate);
|
||||
block_on(async {
|
||||
let mut cancel = Box::pin(session.cancel_and_finalize());
|
||||
assert!(futures::poll!(cancel.as_mut()).is_pending());
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
|
||||
release.send(()).unwrap();
|
||||
cancel.await.expect("cancel finalization");
|
||||
});
|
||||
|
||||
assert!(session.is_finalized());
|
||||
let state = store.state.lock().expect("store lock");
|
||||
@@ -5946,7 +5963,7 @@ fn interrupted_stream_failure_preserves_the_original_attempt_and_retry_decision(
|
||||
let mut resumed = Box::pin(session.next_event());
|
||||
assert!(futures::poll!(resumed.as_mut()).is_pending());
|
||||
assert_eq!(provider.contexts.lock().unwrap().len(), 1);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
|
||||
release
|
||||
.send(())
|
||||
.expect("the original write still owns its receiver");
|
||||
@@ -6144,6 +6161,7 @@ fn charged_terminal_write_resumes_without_replacing_success_failure_or_send_fact
|
||||
assert!(futures::poll!(collect.as_mut()).is_pending());
|
||||
} else {
|
||||
session.collect_uncommitted().await.unwrap();
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
|
||||
let mut commit = Box::pin(session.commit_downstream(Some(200)));
|
||||
assert!(futures::poll!(commit.as_mut()).is_pending());
|
||||
}
|
||||
@@ -6187,7 +6205,7 @@ fn charged_terminal_write_resumes_without_replacing_success_failure_or_send_fact
|
||||
fn deadline_after_commit_is_persisted_as_incomplete() {
|
||||
let operation = generate_operation();
|
||||
let route_plan = plan(&operation);
|
||||
let (coordinator, store, _) = coordinator(vec![Script::HangingStream {
|
||||
let (coordinator, store, provider) = coordinator(vec![Script::HangingStream {
|
||||
account_id: "acct_first",
|
||||
items: vec![Ok(GatewayEvent::Started(ResponseMeta::new(
|
||||
"response-1",
|
||||
@@ -6215,6 +6233,7 @@ fn deadline_after_commit_is_persisted_as_incomplete() {
|
||||
let error = block_on(session.next_event()).expect_err("deadline elapses mid-stream");
|
||||
|
||||
assert!(matches!(error, EngineError::Deadline));
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 1);
|
||||
let state = store.state.lock().expect("store lock");
|
||||
assert_eq!(state.finalizations[0].outcome, ExecutionOutcome::Incomplete);
|
||||
assert!(state.finalizations[0].committed);
|
||||
@@ -6491,8 +6510,6 @@ fn connection_recovery_rotates_only_after_retrying_the_first_account() {
|
||||
assert_eq!(context.transport(), AttemptTransport::Fallback);
|
||||
}
|
||||
assert_eq!(store.state.lock().unwrap().intermediate_failures, 2);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 2);
|
||||
drop(session);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
|
||||
}
|
||||
|
||||
@@ -6556,8 +6573,6 @@ fn connection_recovery_keeps_one_account_and_http_transport_until_success() {
|
||||
let state = store.state.lock().unwrap();
|
||||
assert_eq!(state.intermediate_failures, 3);
|
||||
assert_eq!(state.finalizations[0].outcome, ExecutionOutcome::Succeeded);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
|
||||
drop(session);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 4);
|
||||
},
|
||||
)));
|
||||
@@ -6654,8 +6669,6 @@ fn connection_recovery_does_not_delay_existing_account_rotation() {
|
||||
let state = store.state.lock().unwrap();
|
||||
assert_eq!(state.intermediate_failures, 2);
|
||||
assert_eq!(state.finalizations[0].outcome, ExecutionOutcome::Succeeded);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 2);
|
||||
drop(session);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
|
||||
}
|
||||
|
||||
@@ -6749,8 +6762,6 @@ fn connection_recovery_exhaustion_preserves_transport_failure() {
|
||||
store.state.lock().unwrap().finalizations[0].attempt_count,
|
||||
4
|
||||
);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 3);
|
||||
drop(session);
|
||||
assert_eq!(provider.released_leases.load(Ordering::SeqCst), 4);
|
||||
}
|
||||
|
||||
|
||||
@@ -1955,6 +1955,7 @@ impl NativeResponseTranslator for FailingNativeResponseTranslator {
|
||||
|
||||
struct FailingNativeResponseProvider {
|
||||
calls: Arc<AtomicUsize>,
|
||||
lease: Arc<()>,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
@@ -2010,7 +2011,7 @@ impl Provider for FailingNativeResponseProvider {
|
||||
GatewayEvent::Completed(response),
|
||||
)),
|
||||
]),
|
||||
(),
|
||||
Arc::clone(&self.lease),
|
||||
)
|
||||
.with_native_response_translator(FailingNativeResponseTranslator::default()))
|
||||
}
|
||||
@@ -2020,8 +2021,10 @@ impl Provider for FailingNativeResponseProvider {
|
||||
fn native_response_failure_after_downstream_commit_is_not_replayed() {
|
||||
block_on(async {
|
||||
let calls = Arc::new(AtomicUsize::new(0));
|
||||
let lease = Arc::new(());
|
||||
let provider_index = ProviderRegistry::new([Arc::new(FailingNativeResponseProvider {
|
||||
calls: Arc::clone(&calls),
|
||||
lease: Arc::clone(&lease),
|
||||
}) as Arc<dyn Provider>])
|
||||
.unwrap();
|
||||
let generation = super::extensions::reference("native-response-failure");
|
||||
@@ -2054,6 +2057,7 @@ fn native_response_failure_after_downstream_commit_is_not_replayed() {
|
||||
}));
|
||||
started.session.commit_downstream(Some(200)).await.unwrap();
|
||||
|
||||
let active_refs = Arc::strong_count(&lease);
|
||||
let error = started.session.next_event().await.unwrap_err();
|
||||
assert!(matches!(
|
||||
error,
|
||||
@@ -2061,6 +2065,7 @@ fn native_response_failure_after_downstream_commit_is_not_replayed() {
|
||||
if error.kind() == ProviderErrorKind::Protocol
|
||||
&& error.send_state() == UpstreamSendState::Sent
|
||||
));
|
||||
assert_eq!(Arc::strong_count(&lease), active_refs - 1);
|
||||
assert_eq!(calls.load(Ordering::SeqCst), 1);
|
||||
started.session.detach_finalize().await;
|
||||
});
|
||||
@@ -2352,6 +2357,7 @@ impl Provider for PolicySelectingProvider {
|
||||
.map(UpstreamModelId::as_str),
|
||||
&candidates,
|
||||
&mut selection,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
{
|
||||
|
||||
@@ -131,6 +131,7 @@ fn scheduler_can_override_soft_affinity_and_reports_the_override() {
|
||||
Some("demo-model"),
|
||||
&candidates,
|
||||
&mut context(),
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -156,6 +157,7 @@ fn delegated_scheduler_keeps_builtin_affinity() {
|
||||
None,
|
||||
&candidates,
|
||||
&mut context(),
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -195,6 +197,7 @@ fn explicit_plugin_choices_override_native_soft_affinity() {
|
||||
None,
|
||||
&candidates,
|
||||
&mut selection_context,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -226,6 +229,7 @@ fn scheduler_cannot_select_outside_the_hard_bound_candidate_pool() {
|
||||
None,
|
||||
&candidates,
|
||||
&mut context,
|
||||
Default::default(),
|
||||
)
|
||||
.await;
|
||||
assert!(matches!(result, Err(AccountPolicyError::Fault)));
|
||||
@@ -257,6 +261,7 @@ fn filtered_delegation_preserves_native_weights_and_affinity_on_remaining_accoun
|
||||
None,
|
||||
&candidates,
|
||||
&mut context,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -298,7 +303,8 @@ fn filtered_delegation_covers_busy_candidates_and_does_not_persist_between_selec
|
||||
&ProviderKind::new("openai").unwrap(),
|
||||
None,
|
||||
&candidates,
|
||||
&mut selection
|
||||
&mut selection,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -316,6 +322,7 @@ fn filtered_delegation_covers_busy_candidates_and_does_not_persist_between_selec
|
||||
None,
|
||||
&candidates,
|
||||
&mut context(),
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -344,6 +351,7 @@ fn filtering_all_candidates_is_terminal_even_when_the_only_candidate_is_busy_or_
|
||||
None,
|
||||
&candidates,
|
||||
&mut context,
|
||||
Default::default(),
|
||||
)
|
||||
.await;
|
||||
assert!(matches!(result, Err(AccountPolicyError::Filtered)));
|
||||
@@ -368,6 +376,7 @@ fn filtering_ids_outside_the_host_candidate_pool_is_a_policy_fault() {
|
||||
None,
|
||||
&candidates,
|
||||
&mut context,
|
||||
Default::default(),
|
||||
)
|
||||
.await;
|
||||
assert!(matches!(result, Err(AccountPolicyError::Fault)));
|
||||
@@ -386,6 +395,7 @@ fn empty_filter_preserves_native_affinity_and_busy_candidates_cannot_be_picked()
|
||||
None,
|
||||
&candidates,
|
||||
&mut context(),
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
@@ -400,6 +410,7 @@ fn empty_filter_preserves_native_affinity_and_busy_candidates_cannot_be_picked()
|
||||
None,
|
||||
&candidates,
|
||||
&mut context,
|
||||
Default::default(),
|
||||
)
|
||||
.await;
|
||||
assert!(matches!(result, Err(AccountPolicyError::Fault)));
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
"protocol_versions": [7],
|
||||
"capabilities": [
|
||||
{ "capability": "frontend_authentication", "versions": [2] },
|
||||
{ "capability": "scheduler", "versions": [3] },
|
||||
{ "capability": "scheduler", "versions": [4] },
|
||||
{ "capability": "model_router", "versions": [2] },
|
||||
{ "capability": "model_catalog", "versions": [2] },
|
||||
{ "capability": "retry_policy", "versions": [2] },
|
||||
|
||||
@@ -7,8 +7,8 @@ use futures::future::BoxFuture;
|
||||
use gateway_core::{
|
||||
account::ProviderAccountId,
|
||||
engine::policy::{
|
||||
AccountScheduleDecision, AccountScheduleInput, ModelRouteDecision, ModelRouteInput,
|
||||
RequestPolicyFault, RequestPolicyPlan,
|
||||
AccountScheduleDecision, AccountScheduleInput, AccountScheduleRole, ModelRouteDecision,
|
||||
ModelRouteInput, RequestPolicyFault, RequestPolicyPlan,
|
||||
},
|
||||
identity::ProviderKind,
|
||||
operation::{Operation, ProviderHttpHeader},
|
||||
@@ -20,6 +20,7 @@ use gateway_plugin_sdk::{
|
||||
AccountScheduleCandidate as WireAccountScheduleCandidate,
|
||||
AccountScheduleDecision as WireAccountScheduleDecision,
|
||||
AccountScheduleRequest as WireAccountScheduleRequest,
|
||||
AccountScheduleRole as WireAccountScheduleRole,
|
||||
ModelRouteDecision as WireModelRouteDecision, ModelRouteRequest, PolicyHeader,
|
||||
},
|
||||
};
|
||||
@@ -183,6 +184,13 @@ async fn schedule_with_entry(
|
||||
.iter()
|
||||
.map(|candidate| WireAccountScheduleCandidate {
|
||||
account_id: candidate.account_id().as_str().to_owned(),
|
||||
session_bound: candidate.session_bound(),
|
||||
role: match candidate.role() {
|
||||
AccountScheduleRole::Ordinary => WireAccountScheduleRole::Ordinary,
|
||||
AccountScheduleRole::Preferred => WireAccountScheduleRole::Preferred,
|
||||
AccountScheduleRole::FollowOnly => WireAccountScheduleRole::FollowOnly,
|
||||
AccountScheduleRole::Pinned => WireAccountScheduleRole::Pinned,
|
||||
},
|
||||
available: candidate.available(),
|
||||
weight: candidate.weight(),
|
||||
in_flight: candidate.in_flight(),
|
||||
|
||||
@@ -98,6 +98,7 @@ impl PluginData {
|
||||
next_cursor: page.next_cursor.map(|id| id.as_str().to_owned()),
|
||||
})
|
||||
}
|
||||
data::QUOTA_HISTORY => return self.quota_history(payload).await,
|
||||
data::QUOTA_GET | data::QUOTA_REFRESH | data::QUOTA_DETAILS => {
|
||||
let accounts = self.accounts.upgrade().map_err(map_admin_error)?;
|
||||
let query: data::QuotaFactsQuery =
|
||||
@@ -162,4 +163,67 @@ impl PluginData {
|
||||
payload,
|
||||
})
|
||||
}
|
||||
|
||||
async fn quota_history(&self, payload: &[u8]) -> Result<RpcReply, PluginFault> {
|
||||
use gateway_admin::model::{
|
||||
observability::TimeRange,
|
||||
quota_history::{QuotaHistoryPoint, QuotaHistoryQuery},
|
||||
};
|
||||
|
||||
let wire: data::QuotaHistoryQuery =
|
||||
serde_json::from_slice(payload).map_err(|_| invalid())?;
|
||||
let id = ProviderAccountId::new(wire.account_id).map_err(|_| invalid())?;
|
||||
let time = |ms| chrono::DateTime::from_timestamp_millis(ms).ok_or_else(invalid);
|
||||
let range =
|
||||
TimeRange::new(time(wire.start_ms)?, time(wire.end_ms)?).map_err(|_| invalid())?;
|
||||
if wire.start_ms < 0
|
||||
|| wire.window_key.is_empty()
|
||||
|| wire.window_key.len() > 256
|
||||
|| wire.window_key.chars().any(char::is_control)
|
||||
{
|
||||
return Err(invalid());
|
||||
}
|
||||
let query = QuotaHistoryQuery {
|
||||
window_key: wire.window_key,
|
||||
range,
|
||||
cursor: wire
|
||||
.cursor
|
||||
.as_deref()
|
||||
.map(serde_json::from_str)
|
||||
.transpose()
|
||||
.map_err(|_| invalid())?,
|
||||
};
|
||||
if query.cursor.as_ref().is_some_and(|c| {
|
||||
c.completed_at >= range.end
|
||||
|| c.completed_at < query.scan_start()
|
||||
|| c.id.is_empty()
|
||||
|| c.id.contains('\0')
|
||||
}) {
|
||||
return Err(invalid());
|
||||
}
|
||||
let page = self
|
||||
.accounts
|
||||
.upgrade()
|
||||
.map_err(map_admin_error)?
|
||||
.quota_history(&id, query)
|
||||
.await
|
||||
.map_err(map_admin_error)?;
|
||||
let sample = |p: QuotaHistoryPoint| data::QuotaHistorySample {
|
||||
observed_at_ms: p.observed_at.timestamp_millis(),
|
||||
used_percent: p.reading.used_percent,
|
||||
reset_at_ms: p.reading.reset_at.map(|at| at.timestamp_millis()),
|
||||
plan_type: p.reading.plan_type,
|
||||
};
|
||||
super::admin::encode(&data::QuotaHistoryPage {
|
||||
schema_version: 1,
|
||||
samples: page.samples.into_iter().map(sample).collect(),
|
||||
baseline: page.baseline.map(sample),
|
||||
next_cursor: page
|
||||
.next_cursor
|
||||
.as_ref()
|
||||
.map(serde_json::to_string)
|
||||
.transpose()
|
||||
.map_err(|_| invalid())?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -216,6 +216,7 @@ impl CallbackHandler for PluginCallbacks {
|
||||
| gateway_plugin_sdk::call::data::KEYS_GET
|
||||
| gateway_plugin_sdk::call::data::QUOTA_GET
|
||||
| gateway_plugin_sdk::call::data::QUOTA_REFRESH
|
||||
| gateway_plugin_sdk::call::data::QUOTA_HISTORY
|
||||
| gateway_plugin_sdk::call::data::QUOTA_DETAILS
|
||||
) {
|
||||
return data.call(&method, params, &payload).await;
|
||||
|
||||
@@ -15,6 +15,17 @@ struct BudgetAccountAccess {
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl gateway_admin::ports::plugin_accounts::PluginAccountAccess for BudgetAccountAccess {
|
||||
async fn quota_history(
|
||||
&self,
|
||||
_: &gateway_core::account::ProviderAccountId,
|
||||
_: gateway_admin::model::quota_history::QuotaHistoryQuery,
|
||||
) -> Result<
|
||||
gateway_admin::model::quota_history::QuotaHistoryPage,
|
||||
gateway_admin::model::AdminError,
|
||||
> {
|
||||
unreachable!("账号提交不读取额度历史")
|
||||
}
|
||||
|
||||
async fn list(
|
||||
&self,
|
||||
_: gateway_admin::model::provider_credentials::PluginAccountListQuery,
|
||||
|
||||
@@ -75,6 +75,30 @@ fn account() -> AccountRecord {
|
||||
|
||||
#[async_trait]
|
||||
impl PluginAccountAccess for Facts {
|
||||
async fn quota_history(
|
||||
&self,
|
||||
id: &ProviderAccountId,
|
||||
query: gateway_admin::model::quota_history::QuotaHistoryQuery,
|
||||
) -> Result<gateway_admin::model::quota_history::QuotaHistoryPage, AdminError> {
|
||||
use gateway_admin::model::quota_history::{
|
||||
QuotaHistoryPage, QuotaHistoryPoint, QuotaReading,
|
||||
};
|
||||
assert_eq!(id.as_str(), "acct_facts");
|
||||
assert_eq!(query.window_key, "weekly");
|
||||
assert!(query.cursor.is_none());
|
||||
Ok(QuotaHistoryPage {
|
||||
samples: vec![QuotaHistoryPoint {
|
||||
observed_at: query.range.start,
|
||||
reading: QuotaReading {
|
||||
plan_type: None,
|
||||
used_percent: 12.5,
|
||||
reset_at: None,
|
||||
},
|
||||
}],
|
||||
..Default::default()
|
||||
})
|
||||
}
|
||||
|
||||
async fn refresh_quota(
|
||||
&self,
|
||||
account: &ProviderAccountId,
|
||||
@@ -201,6 +225,9 @@ async fn management_facts_validate_queries_without_permission_declarations() {
|
||||
{"method":"host.data.accounts.list","query":{"provider_id":"openai","cursor":"acct_before","limit":1}},
|
||||
{"method":"host.data.quota.get","query":{"account_id":"acct_facts"}},
|
||||
{"method":"host.data.quota.details","query":{"account_id":"acct_facts"}},
|
||||
{"method":"host.data.quota.history","query":{"account_id":"acct_facts","window_key":"weekly","start_ms":1000,"end_ms":2000}},
|
||||
{"method":"host.data.quota.history","query":{"account_id":"acct_facts","window_key":"weekly","start_ms":2000,"end_ms":1000}},
|
||||
{"method":"host.data.quota.history","query":{"account_id":"acct_facts","window_key":"weekly","start_ms":1000,"end_ms":2000,"cursor":"invalid"}},
|
||||
{"method":"host.data.accounts.list","query":{"limit":0}},
|
||||
{"method":"host.data.accounts.list","query":{"limit":65535}},
|
||||
{"method":"host.data.quota.get","query":{"account_id":"acct_facts","sql":"SELECT secret"}}
|
||||
@@ -269,7 +296,12 @@ async fn management_facts_validate_queries_without_permission_declarations() {
|
||||
Some("123456789.123456789")
|
||||
);
|
||||
assert!(!result[2].to_string().contains("provider-internal-fixture"));
|
||||
for invalid in &result.as_array().unwrap()[3..] {
|
||||
let history: gateway_plugin_sdk::call::data::QuotaHistoryPage =
|
||||
serde_json::from_value(result[3].clone()).unwrap();
|
||||
assert_eq!(history.samples[0].used_percent, 12.5);
|
||||
assert_eq!(history.samples[0].observed_at_ms, 1000);
|
||||
assert_eq!(history.samples[0].reset_at_ms, None);
|
||||
for invalid in &result.as_array().unwrap()[4..] {
|
||||
assert_eq!(invalid["error"], "invalid_input");
|
||||
}
|
||||
|
||||
|
||||
@@ -682,6 +682,7 @@ async fn scheduler_cannot_pick_outside_the_host_projected_priority_tier() {
|
||||
Some("upstream-a"),
|
||||
&candidates,
|
||||
&mut selection,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
|
||||
@@ -306,6 +306,7 @@ async fn data_plane_http_callbacks_keep_the_frozen_body_budget_across_publicatio
|
||||
None,
|
||||
&[candidate("acct_high", 100)],
|
||||
&mut selection_context(),
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
//! 验证真实插件进程的候选过滤、繁忙投影与非法决定边界
|
||||
|
||||
use super::*;
|
||||
use gateway_core::engine::policy::AccountPolicyError;
|
||||
use gateway_core::engine::policy::{AccountPolicyError, AccountScheduleOwnership};
|
||||
|
||||
#[tokio::test]
|
||||
async fn scheduler_filter_contract_covers_busy_candidates_and_rejects_out_of_scope_ids() {
|
||||
@@ -44,6 +44,10 @@ async fn scheduler_filter_contract_covers_busy_candidates_and_rejects_out_of_sco
|
||||
None,
|
||||
&candidates,
|
||||
&mut selection,
|
||||
AccountScheduleOwnership {
|
||||
bound_account: Some(candidates[0].account.id()),
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await;
|
||||
match expected {
|
||||
@@ -60,8 +64,13 @@ async fn scheduler_filter_contract_covers_busy_candidates_and_rejects_out_of_sco
|
||||
request["request"]["candidates"].as_array().unwrap().len(),
|
||||
2
|
||||
);
|
||||
assert_eq!(request["request"]["candidates"][0]["available"], false);
|
||||
assert_eq!(request["request"]["candidates"][1]["available"], true);
|
||||
let candidates = &request["request"]["candidates"];
|
||||
assert_eq!(candidates[0]["available"], false);
|
||||
assert_eq!(candidates[0]["session_bound"], true);
|
||||
assert_eq!(candidates[0]["role"], "preferred");
|
||||
assert_eq!(candidates[1]["available"], true);
|
||||
assert_eq!(candidates[1]["session_bound"], false);
|
||||
assert_eq!(candidates[1]["role"], "ordinary");
|
||||
drop(policy);
|
||||
drop(generation);
|
||||
super::super::wait_until_empty(cache.path()).await;
|
||||
|
||||
@@ -107,6 +107,7 @@ async fn callbacks_are_dispatched_in_every_stage_without_permission_declarations
|
||||
"host.data.accounts.list",
|
||||
"host.data.keys.get",
|
||||
"host.data.quota.get",
|
||||
"host.data.quota.history",
|
||||
"host.groups.ensure",
|
||||
"host.groups.change_members",
|
||||
"host.keys.ensure",
|
||||
|
||||
@@ -23,7 +23,7 @@ SDK 包版本为 `0.1.0`,独立于网关版本,处于实验阶段。能力
|
||||
| `call::upstream_adapter` | 内置 OpenAI / xAI 的[受管上游适配器](docs/upstream-adapters.md)注册、执行、出站与续接合同 |
|
||||
| `call::policy` | 模型路由、账号调度与重试决策合同 |
|
||||
| `call::catalog` | 固定 Provider 的直接别名与适配模型注册合同,见[模型目录](docs/capabilities.md#模型目录) |
|
||||
| `call::data` | 最小账号事实与已有额度观测的只读合同 |
|
||||
| `call::data` | 账号事实、当前额度与历史额度观测 |
|
||||
| `call::observation` | 请求完成、用量、费用与实际上游 WebSocket 响应事件的统一观察合同 |
|
||||
| `call::host` | 账号、私有状态、受管 HTTP、模型、亲和、日志及调用内流的宿主回调合同 |
|
||||
| `call::management` | 管理 API、页面与资源声明、公开回调,以及 CLI 命令与待保存账号 |
|
||||
|
||||
@@ -89,6 +89,7 @@ Provider 固定为宿主内置的 OpenAI 与 xAI。宿主开放以下 11 类扩
|
||||
| `call.host.quota_details(query)` | `host.data.quota.details` | `QuotaFactsQuery { account_id }`:读取完整额度事实,包含窗口归属、触顶和点数 |
|
||||
| `call.host.check_access(query)` | `host.data.access.check` | `AccessQuery { client_key_id, account_ids, upstream_model }`:读取 Key 对指定账号及可选上游模型的冻结授权 |
|
||||
| `call.host.verify_client(request)` | `host.client.verify` | `VerifyClientRequest { authorization }`:复用入口认证,返回 `VerifiedClient { client_key_id }` |
|
||||
| `call.host.quota_history(query)` | `host.data.quota.history` | 按账号、窗口键和时间范围分页读取已保留的额度观测 |
|
||||
| `call.host.quota_facts(query)` | `host.data.quota.get` | `QuotaFactsQuery { account_id }`:读取 Provider 现有观测,不访问上游刷新 |
|
||||
| `call.host.key_facts(query)` | `host.data.keys.get` | `ClientKeyFactsQuery { client_key_id }`:读取当前 Key 的启用状态及显式分组 ID,不返回密钥 |
|
||||
|
||||
@@ -108,6 +109,16 @@ SDK 解析响应时忽略未知字段,包含账号分页、账号及额度窗
|
||||
`quota_details` 保留 Provider 已解释的 `limit_reached`、窗口 `group`、`label`、`limit_id`、`limit_name`、`role`
|
||||
及点数 `has_credits`、`unlimited`、`balance`;缺失值仍为 `null`,不返回上游原始文档,不发起刷新
|
||||
|
||||
`quota_history(QuotaHistoryQuery { account_id, window_key, start_ms, end_ms, cursor })` 按请求完成时间倒序返回
|
||||
`[start_ms, end_ms)` 内的同桶读数。窗口键与 `quota_details` 相同,区间最长 366 天。每个样本包含
|
||||
`observed_at_ms`、`used_percent` 和当时观测到的 `reset_at_ms`、`plan_type`,后两项可为 `null`。
|
||||
首次省略游标;即使 `samples` 为空,只要有 `next_cursor` 就沿用原查询继续。末页的 `baseline` 是起点前最近的同桶读数,
|
||||
最多向前查一个等长区间。例如查最近 48 小时,基线最多再向前找 48 小时;没有基线时返回 `null`
|
||||
|
||||
历史来自保留的已结束请求,不含独立额度刷新。Provider 未提供可解析的同桶观测时没有样本。
|
||||
缺样不代表零;跨重置或套餐变更不能直接相减。这是观测记录,不是精确消耗账本。
|
||||
分页不冻结数据,长区间建议在后台读取并复用结果
|
||||
|
||||
`verify_client` 使用当前请求设置和原认证计划,包含外部 principal 到 Key 的映射;没有 HTTP 入口时使用当前发布配置。
|
||||
认证可以调用认证插件,继续扣减父预算并响应取消;验证成功不做推理准入、账号租约、使用记录或计费。
|
||||
授权原文只作本次认证输入,不进入返回值
|
||||
@@ -653,9 +664,20 @@ middleware 的 `next` 最多调用一次,重试与额外模型执行通过独
|
||||
### 路由、调度与观察
|
||||
|
||||
`policy.route_model` 和 `policy.schedule_account` 只提出决定,宿主随后复核 Key 规则、模型能力、账号资格和租约。
|
||||
`scheduler` 必须声明 `version: 3`。`candidates` 已按 Key 范围、模型权限、账号状态和原生续写绑定收窄,
|
||||
`scheduler` 必须声明 `version: 4`。`candidates` 已按 Key 范围、模型权限、账号状态和原生续写绑定收窄,
|
||||
同时包含暂时繁忙但可以等待的账号;`available` 表示本次可以立即尝试租约,不保证租约一定成功
|
||||
|
||||
每个候选的 `session_bound` 表示它是否为 Provider 已查到的本次会话绑定账号。仅匹配缓存偏好不算会话绑定。`role` 表示本轮选号如何使用它:
|
||||
|
||||
| `role` | 含义 |
|
||||
| --- | --- |
|
||||
| `ordinary` | 普通候选。宽松模式下已有绑定也可以是普通候选 |
|
||||
| `preferred` | 内置选号优先考虑,允许选择其他账号。xAI 的会话偏好由评分得出,不表示已有持久绑定 |
|
||||
| `follow_only` | 委托内置选号时只跟随这个绑定账号,插件仍可显式选择其他合格候选 |
|
||||
| `pinned` | 本次尝试已固定账号,例如原生续接;插件不能改选其他账号 |
|
||||
|
||||
关系只标在本轮可见候选上,繁忙不抹去关系,候选中没有绑定标记也不能断定是新会话。角色不授予账号资格,不代表已取得租约
|
||||
|
||||
- `Pick { account_id }` 显式选号,只能指定 `available: true` 的候选
|
||||
- `Delegate` 将完整候选交给宿主现有调度
|
||||
- `DelegateFiltered { exclude_account_ids }` 排除列出的候选,再委托内置权重、Smart 评分和亲和选择;仅接受本次候选 ID,重复 ID 合并,空列表等同于 `Delegate`
|
||||
|
||||
@@ -54,7 +54,7 @@ RPC v7 的帧布局、编码与会话生命周期见[通信边界](../README.md#
|
||||
| 能力 | 当前版本 |
|
||||
| --- | --- |
|
||||
| `middleware` | `6` |
|
||||
| `scheduler` | `3` |
|
||||
| `scheduler` | `4` |
|
||||
| `upstream_adapter` | `5` |
|
||||
| `frontend_authentication`、`model_router`、`retry_policy`、`observer`、`management` | `2` |
|
||||
| `model_catalog` | `2` |
|
||||
|
||||
@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
|
||||
|
||||
pub const ACCOUNTS_LIST: &str = "host.data.accounts.list";
|
||||
pub const QUOTA_REFRESH: &str = "host.quota_observations.refresh";
|
||||
pub const QUOTA_HISTORY: &str = "host.data.quota.history";
|
||||
pub const QUOTA_GET: &str = "host.data.quota.get";
|
||||
pub const KEYS_GET: &str = "host.data.keys.get";
|
||||
pub const CLIENT_VERIFY: &str = "host.client.verify";
|
||||
@@ -93,6 +94,35 @@ pub struct QuotaFactsQuery {
|
||||
pub account_id: String,
|
||||
}
|
||||
|
||||
/// UTC 毫秒半开区间;续页沿用原查询并原样传回游标
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct QuotaHistoryQuery {
|
||||
pub account_id: String,
|
||||
pub window_key: String,
|
||||
pub start_ms: i64,
|
||||
pub end_ms: i64,
|
||||
pub cursor: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
pub struct QuotaHistorySample {
|
||||
pub plan_type: Option<String>,
|
||||
pub observed_at_ms: i64,
|
||||
pub used_percent: f64,
|
||||
pub reset_at_ms: Option<i64>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
pub struct QuotaHistoryPage {
|
||||
pub schema_version: u32,
|
||||
/// 请求完成时间倒序;空页也可能需要继续
|
||||
pub samples: Vec<QuotaHistorySample>,
|
||||
/// 最后一页才可能包含起点前的最近同桶观测
|
||||
pub baseline: Option<QuotaHistorySample>,
|
||||
pub next_cursor: Option<String>,
|
||||
}
|
||||
|
||||
/// Provider 已有快照的必要投影;空观测时间表示没有可用样本,不代表额度为零
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
pub struct QuotaFacts {
|
||||
|
||||
@@ -72,11 +72,23 @@ pub enum ModelRouteDecision {
|
||||
Reject,
|
||||
}
|
||||
|
||||
/// 宿主在本轮调度中赋予候选的角色,与实时容量和已有会话绑定分开
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum AccountScheduleRole {
|
||||
Ordinary,
|
||||
Preferred,
|
||||
FollowOnly,
|
||||
Pinned,
|
||||
}
|
||||
|
||||
/// 候选账号的即时调度指标;凭据和账号资料通过宿主账号接口读取
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct AccountScheduleCandidate {
|
||||
pub account_id: String,
|
||||
pub session_bound: bool,
|
||||
pub role: AccountScheduleRole,
|
||||
/// false 表示仅可等待,仍可被过滤,但不能作为本轮 Pick 的结果
|
||||
pub available: bool,
|
||||
pub weight: u16,
|
||||
|
||||
@@ -33,7 +33,7 @@ impl Capability {
|
||||
| Self::RetryPolicy
|
||||
| Self::Observer
|
||||
| Self::Management => &[2],
|
||||
Self::Scheduler => &[3],
|
||||
Self::Scheduler => &[4],
|
||||
Self::UpstreamAdapter => &[5],
|
||||
Self::CommandLine | Self::Maintenance => &[1],
|
||||
}
|
||||
|
||||
@@ -75,6 +75,17 @@ impl HostClient {
|
||||
payload_call(self, data::QUOTA_GET, query).await
|
||||
}
|
||||
|
||||
/// 按账号、额度桶和时间范围读取已保留的观测,不刷新上游
|
||||
///
|
||||
/// # Errors
|
||||
/// 账号不存在、查询无效或宿主读取失败时返回错误
|
||||
pub async fn quota_history(
|
||||
&self,
|
||||
query: data::QuotaHistoryQuery,
|
||||
) -> Result<data::QuotaHistoryPage, PluginFault> {
|
||||
payload_call(self, data::QUOTA_HISTORY, query).await
|
||||
}
|
||||
|
||||
/// 读取已有额度窗口标签、触顶与点数事实,不触发刷新或补算
|
||||
///
|
||||
/// # Errors
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
//! 验证插件路由和账号调度决策的类型合同与附加字段透传边界
|
||||
|
||||
use gateway_plugin_sdk::call::policy::{
|
||||
AccountScheduleCandidate, AccountScheduleDecision, AccountScheduleRequest, ModelRouteDecision,
|
||||
ModelRouteRequest, PolicyHeader,
|
||||
AccountScheduleCandidate, AccountScheduleDecision, AccountScheduleRequest, AccountScheduleRole,
|
||||
ModelRouteDecision, ModelRouteRequest, PolicyHeader,
|
||||
};
|
||||
use serde_json::json;
|
||||
|
||||
@@ -49,6 +49,8 @@ fn route_and_scheduler_decisions_ignore_unused_fields() {
|
||||
model: Some("gpt-5".into()),
|
||||
candidates: vec![AccountScheduleCandidate {
|
||||
account_id: "acct_candidate".into(),
|
||||
session_bound: true,
|
||||
role: AccountScheduleRole::Preferred,
|
||||
available: true,
|
||||
weight: 10,
|
||||
in_flight: 1,
|
||||
|
||||
@@ -136,7 +136,7 @@ fn capability_contract_versions_are_checked_independently_of_rpc_version() {
|
||||
(Capability::Middleware, Stage::Request, 6, true),
|
||||
(Capability::Management, Stage::Management, 2, false),
|
||||
(Capability::UpstreamAdapter, Stage::Upstream, 5, true),
|
||||
(Capability::Scheduler, Stage::Scheduling, 3, false),
|
||||
(Capability::Scheduler, Stage::Scheduling, 4, false),
|
||||
(Capability::ModelCatalog, Stage::Registration, 2, false),
|
||||
] {
|
||||
for mut manifest in [source_manifest(), packaged_manifest()] {
|
||||
@@ -286,7 +286,7 @@ fn contribution_ids_are_owned_unique_and_stage_bounded() {
|
||||
Capability::Scheduler,
|
||||
ContributionDeclaration {
|
||||
id: "9acme.request-tags.scheduler".into(),
|
||||
version: 3,
|
||||
version: 4,
|
||||
stages: vec![Stage::Scheduling],
|
||||
input_formats: Vec::new(),
|
||||
output_formats: Vec::new(),
|
||||
|
||||
@@ -6,6 +6,38 @@ const MULTI_AGENT_MODE_OPEN_TAG: &str = "<multi_agent_mode>";
|
||||
const MULTI_AGENT_MODE_CLOSE_TAG: &str = "</multi_agent_mode>";
|
||||
const PROACTIVE_MULTI_AGENT_MODE_PREFIX: &str = "Proactive multi-agent delegation is active.";
|
||||
|
||||
/// 标记实际入站的 Responses WS 帧,独立于出站传输偏好
|
||||
pub const WEBSOCKET_FRAME_CONTEXT_KEY: &str = "websocket_frame";
|
||||
|
||||
/// 当前帧携带的完整元数据仅用于解释正文,握手或 HTTP 头保留各自的出站值
|
||||
#[must_use]
|
||||
pub fn observed_turn_metadata<'a>(
|
||||
body: &'a Map<String, Value>,
|
||||
header: Option<&'a str>,
|
||||
websocket_frame: bool,
|
||||
) -> Option<&'a str> {
|
||||
if websocket_frame && let Some(frame) = client_metadata_string(body, "x-codex-turn-metadata") {
|
||||
return Some(frame);
|
||||
}
|
||||
header
|
||||
}
|
||||
|
||||
/// HTTP 请求使用本次请求头,WS 帧使用本次正文或首次握手头
|
||||
#[must_use]
|
||||
pub fn context_turn_metadata<'a>(
|
||||
body: &'a Map<String, Value>,
|
||||
context: &'a Map<String, Value>,
|
||||
) -> Option<&'a str> {
|
||||
observed_turn_metadata(
|
||||
body,
|
||||
context.get("turn_metadata").and_then(Value::as_str),
|
||||
context
|
||||
.get(WEBSOCKET_FRAME_CONTEXT_KEY)
|
||||
.and_then(Value::as_bool)
|
||||
== Some(true),
|
||||
)
|
||||
}
|
||||
|
||||
/// 各 Codex 端点共用的显式根会话身份
|
||||
/// 连接边界的 session_id 优先,
|
||||
/// 正文及官方 metadata 只做回退;不从 turn、window 或请求内容猜测归属
|
||||
@@ -24,9 +56,7 @@ pub fn codex_account_session_id(
|
||||
client_metadata_string(body, "session_id")
|
||||
.map(str::to_owned)
|
||||
.or_else(|| request_turn_metadata(body).and_then(turn_metadata_session_id))
|
||||
.or_else(|| {
|
||||
non_empty_string(context.get("turn_metadata")).and_then(turn_metadata_session_id)
|
||||
})
|
||||
.or_else(|| context_turn_metadata(body, context).and_then(turn_metadata_session_id))
|
||||
.or_else(|| non_empty_string(body.get("session_id")).map(str::to_owned))
|
||||
.or_else(|| codex_session_id(body, context))
|
||||
}
|
||||
@@ -40,9 +70,7 @@ pub fn codex_account_thread_id(
|
||||
client_metadata_string(body, "thread_id")
|
||||
.map(str::to_owned)
|
||||
.or_else(|| request_turn_metadata(body).and_then(turn_metadata_thread_id))
|
||||
.or_else(|| {
|
||||
non_empty_string(context.get("turn_metadata")).and_then(turn_metadata_thread_id)
|
||||
})
|
||||
.or_else(|| context_turn_metadata(body, context).and_then(turn_metadata_thread_id))
|
||||
.or_else(|| codex_thread_id(body, context))
|
||||
}
|
||||
|
||||
@@ -64,7 +92,7 @@ pub fn codex_turn_id(body: &Map<String, Value>, context: &Map<String, Value>) ->
|
||||
client_metadata_string(body, "turn_id")
|
||||
.map(str::to_owned)
|
||||
.or_else(|| request_turn_metadata(body).and_then(turn_metadata_turn_id))
|
||||
.or_else(|| non_empty_string(context.get("turn_metadata")).and_then(turn_metadata_turn_id))
|
||||
.or_else(|| context_turn_metadata(body, context).and_then(turn_metadata_turn_id))
|
||||
.or_else(|| codex_identity_field(body, context, "turn_id"))
|
||||
}
|
||||
|
||||
@@ -90,7 +118,8 @@ fn codex_identity_field(
|
||||
.or_else(|| client_metadata_string(body, field))
|
||||
.map(str::to_owned)
|
||||
.or_else(|| {
|
||||
let metadata = non_empty_string(context.get("turn_metadata"))
|
||||
let metadata = context_turn_metadata(body, context)
|
||||
.filter(|value| !value.trim().is_empty())
|
||||
.or_else(|| request_turn_metadata(body))?;
|
||||
let metadata: Value = serde_json::from_str(metadata).ok()?;
|
||||
non_empty_string(metadata.get(field)).map(str::to_owned)
|
||||
@@ -127,7 +156,7 @@ pub fn codex_responses_request_semantics(
|
||||
) -> CodexResponsesRequestSemantics {
|
||||
codex_responses_request_semantics_with_turn_metadata(
|
||||
body,
|
||||
context.get("turn_metadata").and_then(Value::as_str),
|
||||
context_turn_metadata(body, context),
|
||||
None,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -21,9 +21,10 @@ mod headers;
|
||||
pub mod sse;
|
||||
|
||||
pub use codex::{
|
||||
CodexResponsesRequestSemantics, codex_account_session_id, codex_account_thread_id,
|
||||
codex_responses_request_semantics, codex_responses_request_semantics_with_turn_metadata,
|
||||
codex_session_id, codex_thread_id, codex_turn_id, turn_metadata_session_id,
|
||||
CodexResponsesRequestSemantics, WEBSOCKET_FRAME_CONTEXT_KEY, codex_account_session_id,
|
||||
codex_account_thread_id, codex_responses_request_semantics,
|
||||
codex_responses_request_semantics_with_turn_metadata, codex_session_id, codex_thread_id,
|
||||
codex_turn_id, context_turn_metadata, observed_turn_metadata, turn_metadata_session_id,
|
||||
turn_metadata_thread_id, turn_metadata_turn_id,
|
||||
};
|
||||
pub use headers::{
|
||||
|
||||
@@ -32,7 +32,7 @@ pub fn request_observation(
|
||||
OPENAI_PROTOCOL => {
|
||||
let semantics = codex_responses_request_semantics_with_turn_metadata(
|
||||
body,
|
||||
context.get("turn_metadata").and_then(Value::as_str),
|
||||
crate::openai::context_turn_metadata(body, context),
|
||||
previous_reasoning_effort_override,
|
||||
);
|
||||
RequestObservation {
|
||||
|
||||
@@ -36,10 +36,8 @@ impl AnalyticsSnapshot<'_> {
|
||||
|| filter.attempt_index.is_some()
|
||||
|| filter.status_code.is_some()
|
||||
|| filter.outcome.is_some()
|
||||
|| filter.search.is_some()
|
||||
|| filter.model_contains.is_some()
|
||||
|| filter.client_api_key_name.is_some()
|
||||
|| filter.provider_account_name.is_some()
|
||||
|| filter.needs_observation_text()
|
||||
|| matches!(
|
||||
dimension,
|
||||
Some(DiagnosticDimension::Failure | DiagnosticDimension::Status)
|
||||
|
||||
@@ -1232,10 +1232,8 @@ pub(super) fn collection_for(
|
||||
|| filter.attempt_index.is_some()
|
||||
|| filter.response_id.is_some()
|
||||
|| filter.upstream_request_id.is_some()
|
||||
|| filter.search.is_some()
|
||||
|| filter.model_contains.is_some()
|
||||
|| filter.client_api_key_name.is_some()
|
||||
|| filter.provider_account_name.is_some()
|
||||
|| filter.needs_observation_text()
|
||||
{
|
||||
return None;
|
||||
}
|
||||
@@ -1286,21 +1284,15 @@ pub(crate) fn push_analytics_filter(
|
||||
alias: &str,
|
||||
) {
|
||||
let mut typed = filter.clone();
|
||||
typed.search = None;
|
||||
typed.client_api_key_name = None;
|
||||
typed.provider_account_name = None;
|
||||
let text = UsageRecordFilter {
|
||||
client_api_key_name: typed.client_api_key_name.take(),
|
||||
provider_account_search: typed.provider_account_search.take(),
|
||||
search: typed.search.take(),
|
||||
..Default::default()
|
||||
};
|
||||
push_usage_filter(query, &typed, alias);
|
||||
if filter.search.is_some()
|
||||
|| filter.client_api_key_name.is_some()
|
||||
|| filter.provider_account_name.is_some()
|
||||
{
|
||||
if text.needs_observation_text() {
|
||||
query.push(format!(" and exists(select 1 from model_request_observations searched where searched.id={alias}.id"));
|
||||
let text = UsageRecordFilter {
|
||||
client_api_key_name: filter.client_api_key_name.clone(),
|
||||
provider_account_name: filter.provider_account_name.clone(),
|
||||
search: filter.search.clone(),
|
||||
..Default::default()
|
||||
};
|
||||
push_usage_filter(query, &text, "searched");
|
||||
query.push(")");
|
||||
}
|
||||
|
||||
@@ -19,7 +19,7 @@ pub(crate) fn store_usage_filter(filter: admin_observability::UsageFilter) -> Us
|
||||
UsageRecordFilter {
|
||||
model_contains: filter.model_contains,
|
||||
client_api_key_name: filter.client_api_key_name,
|
||||
provider_account_name: filter.provider_account_name,
|
||||
provider_account_search: filter.provider_account_search,
|
||||
client_api_key_ref: filter.client_api_key_ref,
|
||||
request_id: filter.request_id,
|
||||
provider_account_ref: filter.provider_account_ref,
|
||||
|
||||
@@ -40,7 +40,7 @@ pub(crate) fn observability_page_offset(
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||
pub struct UsageRecordFilter {
|
||||
pub client_api_key_name: Option<String>,
|
||||
pub provider_account_name: Option<String>,
|
||||
pub provider_account_search: Option<String>,
|
||||
pub client_api_key_ref: Option<String>,
|
||||
pub request_id: Option<String>,
|
||||
pub provider_account_ref: Option<String>,
|
||||
@@ -58,6 +58,12 @@ pub struct UsageRecordFilter {
|
||||
}
|
||||
|
||||
impl UsageRecordFilter {
|
||||
pub(super) fn needs_observation_text(&self) -> bool {
|
||||
self.search.is_some()
|
||||
|| self.client_api_key_name.is_some()
|
||||
|| self.provider_account_search.is_some()
|
||||
}
|
||||
|
||||
pub fn validate(&self) -> StoreResult<()> {
|
||||
for (value, field) in [
|
||||
(
|
||||
@@ -65,8 +71,8 @@ impl UsageRecordFilter {
|
||||
"client API key name filter",
|
||||
),
|
||||
(
|
||||
self.provider_account_name.as_deref(),
|
||||
"provider account name filter",
|
||||
self.provider_account_search.as_deref(),
|
||||
"provider account search filter",
|
||||
),
|
||||
(self.client_api_key_ref.as_deref(), "client API key filter"),
|
||||
(self.request_id.as_deref(), "request ID filter"),
|
||||
|
||||
@@ -11,18 +11,10 @@ pub(crate) fn push_usage_filter(
|
||||
filter: &UsageRecordFilter,
|
||||
alias: &str,
|
||||
) {
|
||||
for (column, value) in [
|
||||
("client_api_key_name_snapshot", &filter.client_api_key_name),
|
||||
(
|
||||
"provider_account_name_snapshot",
|
||||
&filter.provider_account_name,
|
||||
),
|
||||
] {
|
||||
if let Some(value) = value {
|
||||
query.push(format!(" and {alias}.{column} like "));
|
||||
query.push_bind(literal_contains_pattern(value));
|
||||
query.push(" escape '\\'");
|
||||
}
|
||||
if let Some(value) = &filter.client_api_key_name {
|
||||
query.push(format!(" and {alias}.client_api_key_name_snapshot like "));
|
||||
query.push_bind(literal_contains_pattern(value));
|
||||
query.push(" escape '\\'");
|
||||
}
|
||||
if let Some(value) = &filter.client_api_key_ref {
|
||||
query.push(format!(" and {alias}.client_api_key_ref = "));
|
||||
@@ -51,11 +43,23 @@ pub(crate) fn push_usage_filter(
|
||||
query.push_bind(value.clone());
|
||||
query.push(")");
|
||||
}
|
||||
if let Some(value) = &filter.model_contains {
|
||||
for (value, first, second) in [
|
||||
(
|
||||
&filter.provider_account_search,
|
||||
"provider_account_name_snapshot",
|
||||
"provider_account_email_snapshot",
|
||||
),
|
||||
(
|
||||
&filter.model_contains,
|
||||
"requested_model_id",
|
||||
"upstream_model_id",
|
||||
),
|
||||
] {
|
||||
let Some(value) = value else { continue };
|
||||
let pattern = literal_contains_pattern(value);
|
||||
query.push(format!(" and ({alias}.requested_model_id like "));
|
||||
query.push(format!(" and ({alias}.{first} like "));
|
||||
query.push_bind(pattern.clone());
|
||||
query.push(format!(" escape '\\' or {alias}.upstream_model_id like "));
|
||||
query.push(format!(" escape '\\' or {alias}.{second} like "));
|
||||
query.push_bind(pattern);
|
||||
query.push(" escape '\\')");
|
||||
}
|
||||
|
||||
@@ -235,10 +235,11 @@ impl AccountStore for PgAdminAccountStore {
|
||||
account_id: &CoreProviderAccountId,
|
||||
) -> AdminStoreResult<Option<AccountRecord>> {
|
||||
self.accounts
|
||||
.load_provider_account(account_id.as_str())
|
||||
.list_provider_account_summaries(None, true, Some(&[account_id.as_str()]), None)
|
||||
.await
|
||||
.map_err(|error| admin_store_error(ENTITY, error))?
|
||||
.map(|record| admin_account_record(record.summary))
|
||||
.pop()
|
||||
.map(admin_account_record)
|
||||
.transpose()
|
||||
}
|
||||
|
||||
@@ -455,6 +456,26 @@ impl AccountStore for PgAdminAccountStore {
|
||||
self.usage_by_windows(windows).await
|
||||
}
|
||||
|
||||
async fn quota_documents(
|
||||
&self,
|
||||
account: &gateway_core::account::ProviderAccountId,
|
||||
provider: &gateway_core::routing::ProviderKind,
|
||||
created_at: chrono::DateTime<chrono::Utc>,
|
||||
range: gateway_admin::model::observability::TimeRange,
|
||||
before: Option<&gateway_admin::model::quota_history::QuotaHistoryCursor>,
|
||||
) -> AdminStoreResult<gateway_admin::model::quota_history::QuotaDocumentPage> {
|
||||
super::quota_history::documents(
|
||||
&self.pool,
|
||||
&self.query_budget,
|
||||
account,
|
||||
provider,
|
||||
created_at,
|
||||
range,
|
||||
before,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
async fn load_quota_forecast_history(
|
||||
&self,
|
||||
window: &AccountUsageWindowQuery,
|
||||
|
||||
@@ -61,6 +61,7 @@ mod mapping;
|
||||
mod model_catalogs;
|
||||
mod quota;
|
||||
mod quota_forecast;
|
||||
mod quota_history;
|
||||
mod quota_warmup;
|
||||
mod repository;
|
||||
mod reset_credit_automation;
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
//! 按账号完成时间索引分页读取历史观测;过滤窗口的协议字段由 Provider 解释
|
||||
|
||||
use futures::TryStreamExt as _;
|
||||
use gateway_admin::model::quota_history::{QuotaDocumentPage, QuotaHistoryCursor};
|
||||
|
||||
use super::*;
|
||||
|
||||
pub(super) async fn documents(
|
||||
pool: &PgPool,
|
||||
budget: &crate::postgres::ObservabilityQueryBudget,
|
||||
account: &CoreProviderAccountId,
|
||||
provider: &gateway_core::routing::ProviderKind,
|
||||
created_at: DateTime<Utc>,
|
||||
range: TimeRange,
|
||||
before: Option<&QuotaHistoryCursor>,
|
||||
) -> AdminStoreResult<QuotaDocumentPage> {
|
||||
const PAGE_SIZE: usize = 64;
|
||||
const PAGE_BYTES: usize = 2 * 1024 * 1024;
|
||||
|
||||
let (until, last_id) = before.map_or((range.end, ""), |c| (c.completed_at, c.id.as_str()));
|
||||
budget
|
||||
.run(pool, "read quota documents", |mut connection| async move {
|
||||
let mut rows = sqlx::query_as::<_, (DateTime<Utc>, String, String)>(
|
||||
"select completed_at,id,provider_observation_json::text from model_requests
|
||||
where provider_account_ref=$1 and provider_kind=$2 and started_at >= $3
|
||||
and completed_at >= $4 and completed_at < $5 and (completed_at,id) < ($6,$7)
|
||||
and outcome <> 'running' and provider_observation_json is not null
|
||||
order by completed_at desc,id desc limit $8",
|
||||
)
|
||||
.bind(account.as_str())
|
||||
.bind(provider.as_str())
|
||||
.bind(created_at)
|
||||
.bind(range.start)
|
||||
.bind(range.end)
|
||||
.bind(until)
|
||||
.bind(last_id)
|
||||
.bind((PAGE_SIZE + 1) as i64)
|
||||
.fetch(&mut *connection);
|
||||
let mut documents = Vec::new();
|
||||
let mut bytes = 0;
|
||||
let mut last = None;
|
||||
while let Some((completed_at, id, json)) = rows
|
||||
.try_next()
|
||||
.await
|
||||
.map_err(|error| postgres_unavailable("read quota documents", error))?
|
||||
{
|
||||
// 首份文档独占一页也要前进,否则大文档会卡住所有后续页
|
||||
if documents.len() == PAGE_SIZE
|
||||
|| (!documents.is_empty() && bytes + json.len() > PAGE_BYTES)
|
||||
{
|
||||
return Ok(QuotaDocumentPage {
|
||||
documents,
|
||||
next_cursor: last,
|
||||
});
|
||||
}
|
||||
bytes += json.len();
|
||||
let document = serde_json::from_str(&json)
|
||||
.map_err(|_| invalid("invalid provider observation"))?;
|
||||
documents.push((
|
||||
completed_at,
|
||||
ProviderDocument::new(OpaqueProviderData::new(document)),
|
||||
));
|
||||
last = Some(QuotaHistoryCursor { completed_at, id });
|
||||
}
|
||||
Ok(QuotaDocumentPage {
|
||||
documents,
|
||||
next_cursor: None,
|
||||
})
|
||||
})
|
||||
.await
|
||||
.map_err(|error| admin_store_error(ENTITY, error))
|
||||
}
|
||||
@@ -961,6 +961,69 @@ async fn usage_search_should_ignore_request_ids_and_preserve_exact_filters() {
|
||||
database.close().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn usage_account_filter_matches_only_historical_names_and_emails() {
|
||||
use admin_observability::UsageRecordStatus::{All, Error, Success};
|
||||
|
||||
let Some(database) = TestDatabase::create("usage_account_filter").await else {
|
||||
return;
|
||||
};
|
||||
let now = Utc::now();
|
||||
seed_observability_facts(&database.pool, now)
|
||||
.await
|
||||
.expect("seed observability facts");
|
||||
seed_calculated_billing_facts(&database.pool, now)
|
||||
.await
|
||||
.expect("seed unrelated request");
|
||||
sqlx::query(
|
||||
"update model_requests set request_observation_json = jsonb_set(
|
||||
request_observation_json, '{account}', case when id = 'req_observe_success'
|
||||
then jsonb_build_object('email', $1::text)
|
||||
else jsonb_build_object('name', $2::text) end)
|
||||
where id in ('req_observe_success', 'req_observe_failed')",
|
||||
)
|
||||
.bind(r"alice_%\ops@example.invalid")
|
||||
.bind("alice team")
|
||||
.execute(&database.pool)
|
||||
.await
|
||||
.expect("set email-only and name-only snapshots");
|
||||
super::drain_analytics(&database.pool).await;
|
||||
|
||||
let range = ObservabilityRange::new(now - TimeDelta::hours(1), now).expect("range");
|
||||
let repo = observability_repository(&database.pool);
|
||||
for (status, search, page, total, expected_id) in [
|
||||
(Success, r"_%\", 1, 1, Some("req_observe_success")),
|
||||
(Error, "team", 1, 1, Some("req_observe_failed")),
|
||||
(All, "alice", 1, 2, Some("req_observe_failed")),
|
||||
(All, "alice", 2, 2, Some("req_observe_success")),
|
||||
(Error, "@example", 1, 0, None),
|
||||
(All, "ALICE", 1, 0, None),
|
||||
(All, "alice%ops", 1, 0, None),
|
||||
(All, "public-model", 1, 0, None),
|
||||
] {
|
||||
let result = repo
|
||||
.list_usage_records(UsageRecordQuery {
|
||||
status,
|
||||
range,
|
||||
filter: UsageRecordFilter {
|
||||
provider_account_search: Some(search.to_owned()),
|
||||
..Default::default()
|
||||
},
|
||||
current_page: page,
|
||||
page_size: ObservabilityPageSize::new(1).expect("page size"),
|
||||
})
|
||||
.await
|
||||
.expect("filter usage by account snapshot");
|
||||
assert_eq!(result.total, total, "{status:?} {search} page {page}");
|
||||
assert_eq!(
|
||||
result.items.first().map(|item| item.id.as_str()),
|
||||
expected_id,
|
||||
"{status:?} {search} page {page}"
|
||||
);
|
||||
}
|
||||
database.close().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn usage_search_should_match_account_email_and_name_substrings() {
|
||||
let Some(database) = TestDatabase::create("usage_account_contains").await else {
|
||||
@@ -2207,7 +2270,7 @@ async fn admin_observability_adapter_preserves_utc_queries_metrics_costs_and_det
|
||||
filter: admin_observability::UsageFilter {
|
||||
model_contains: None,
|
||||
client_api_key_name: None,
|
||||
provider_account_name: None,
|
||||
provider_account_search: Some("@example.invalid".to_owned()),
|
||||
client_api_key_ref: Some("key_observe".to_owned()),
|
||||
request_id: Some("req_observe_success".to_owned()),
|
||||
provider_account_ref: Some("acct_observe".to_owned()),
|
||||
|
||||
@@ -13,6 +13,7 @@ mod deletion;
|
||||
mod protection_revision;
|
||||
mod quota;
|
||||
mod quota_forecast;
|
||||
mod quota_history;
|
||||
mod timestamps;
|
||||
mod usage_projection;
|
||||
|
||||
|
||||
@@ -0,0 +1,162 @@
|
||||
//! 验证历史额度按账号与完成时间翻页,保留重置和最近有效基线
|
||||
|
||||
use gateway_admin::model::quota_history::{QuotaHistoryPage, QuotaHistoryQuery, QuotaReading};
|
||||
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn quota_history_pages_sparse_tied_observations_through_the_nearest_baseline() {
|
||||
let Some(db) = TestDatabase::create("quota_history").await else {
|
||||
return;
|
||||
};
|
||||
let store = admin_account_store(&db.pool);
|
||||
let id = ProviderAccountId::new("acct_history").unwrap();
|
||||
let mut saved = account(id.as_str(), "history");
|
||||
saved.enabled = false;
|
||||
PgProviderAccountRepository::new(db.pool.clone())
|
||||
.insert_provider_account(saved)
|
||||
.await
|
||||
.unwrap();
|
||||
let record = store.load_account_record(&id).await.unwrap().unwrap();
|
||||
let created = record.created_at;
|
||||
let provider = record.provider_kind;
|
||||
let start = chrono::DateTime::from_timestamp(created.timestamp() + 3600, 0).unwrap();
|
||||
let range = TimeRange::new(start, start + TimeDelta::minutes(10)).unwrap();
|
||||
let tied = start + TimeDelta::microseconds(1_123_456);
|
||||
let before_reset = start.timestamp() + 1;
|
||||
let after_reset = before_reset + 604800;
|
||||
let weekly = |percent, reset| json!({"weekly":[percent,reset]});
|
||||
let row = |key: String, at, doc| (key, "acct_history", "openai", at, doc);
|
||||
|
||||
// 同一微秒的请求跨页时,继续扫描才能找到其中唯一的同桶读数
|
||||
let mut rows: Vec<_> = (0..66)
|
||||
.map(|i| {
|
||||
row(
|
||||
format!("tied_{i:02}"),
|
||||
tied,
|
||||
if i == 0 {
|
||||
weekly(3, after_reset)
|
||||
} else {
|
||||
json!({})
|
||||
},
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
rows.extend([
|
||||
row("start".into(), start, weekly(96, before_reset)),
|
||||
row("end".into(), range.end, weekly(90, after_reset)),
|
||||
row(
|
||||
"wrong_window".into(),
|
||||
start - TimeDelta::microseconds(1),
|
||||
json!({"daily":[60,before_reset]}),
|
||||
),
|
||||
row(
|
||||
"baseline".into(),
|
||||
start - TimeDelta::minutes(1),
|
||||
weekly(94, before_reset),
|
||||
),
|
||||
row(
|
||||
"older".into(),
|
||||
start - TimeDelta::minutes(2),
|
||||
weekly(80, before_reset),
|
||||
),
|
||||
row(
|
||||
"outside_lookback".into(),
|
||||
start - TimeDelta::minutes(11),
|
||||
json!({"unknown":[75,before_reset]}),
|
||||
),
|
||||
(
|
||||
"other".into(),
|
||||
"acct_other",
|
||||
"openai",
|
||||
tied,
|
||||
weekly(90, after_reset),
|
||||
),
|
||||
(
|
||||
"other_provider".into(),
|
||||
"acct_history",
|
||||
"other",
|
||||
tied,
|
||||
weekly(88, after_reset),
|
||||
),
|
||||
]);
|
||||
for (request_id, account_id, provider_kind, at, doc) in rows {
|
||||
seed_model_request(
|
||||
&db.pool,
|
||||
ModelRequestSeed {
|
||||
request_id: &request_id,
|
||||
account_id,
|
||||
provider_kind,
|
||||
model: "gpt-test",
|
||||
total_tokens: 1,
|
||||
cost_amount: "1",
|
||||
started_at: at - TimeDelta::seconds(1),
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query("update model_requests set provider_observation_json=$2 where id=$1")
|
||||
.bind(request_id)
|
||||
.bind(doc)
|
||||
.execute(&db.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
for key in ["weekly", "unknown"] {
|
||||
let mut query = QuotaHistoryQuery {
|
||||
window_key: key.into(),
|
||||
range,
|
||||
cursor: None,
|
||||
};
|
||||
let scan = TimeRange {
|
||||
start: query.scan_start(),
|
||||
end: range.end,
|
||||
};
|
||||
let mut samples = Vec::new();
|
||||
let mut pages = 0;
|
||||
let baseline = loop {
|
||||
let raw = store
|
||||
.quota_documents(&id, &provider, created, scan, query.cursor.as_ref())
|
||||
.await
|
||||
.unwrap();
|
||||
let page = QuotaHistoryPage::from_documents(raw, &query, |doc, key| {
|
||||
let pair = doc.expose_to_provider().expose_to_provider().get(key)?;
|
||||
Some(QuotaReading {
|
||||
used_percent: pair[0].as_f64()?,
|
||||
reset_at: chrono::DateTime::from_timestamp(pair[1].as_i64()?, 0),
|
||||
plan_type: None,
|
||||
})
|
||||
});
|
||||
pages += 1;
|
||||
if pages == 1 {
|
||||
assert!(page.samples.is_empty() && page.next_cursor.is_some());
|
||||
}
|
||||
samples.extend(page.samples.into_iter().map(|p| {
|
||||
(
|
||||
p.observed_at,
|
||||
p.reading.used_percent,
|
||||
p.reading.reset_at.unwrap().timestamp(),
|
||||
)
|
||||
}));
|
||||
query.cursor = page.next_cursor;
|
||||
if query.cursor.is_none() {
|
||||
break page.baseline;
|
||||
}
|
||||
assert!(pages < 4, "游标未前进");
|
||||
};
|
||||
if key == "weekly" {
|
||||
assert_eq!(
|
||||
samples,
|
||||
[(tied, 3.0, after_reset), (start, 96.0, before_reset)]
|
||||
);
|
||||
let base = baseline.unwrap();
|
||||
assert_eq!(
|
||||
(base.observed_at, base.reading.used_percent),
|
||||
(start - TimeDelta::minutes(1), 94.0)
|
||||
);
|
||||
} else {
|
||||
assert!(samples.is_empty() && baseline.is_none());
|
||||
}
|
||||
}
|
||||
db.close().await;
|
||||
}
|
||||
@@ -1452,13 +1452,14 @@ async fn queued_history_keeps_frozen_identity_after_configuration_deletion() {
|
||||
if published {
|
||||
super::drain_analytics(&database.pool).await;
|
||||
}
|
||||
for (key_name, account_name, expected) in [
|
||||
for (key_name, account_search, expected) in [
|
||||
(Some("Original Key"), None, 1),
|
||||
(None, Some("Original Account"), 1),
|
||||
(Some("Original Key"), Some("Original Account"), 1),
|
||||
(Some("Original"), None, 1),
|
||||
(Some("ginal K"), None, 1),
|
||||
(None, Some("ginal Acc"), 1),
|
||||
(None, Some("old@"), 1),
|
||||
(Some("queued_key"), None, 0),
|
||||
(None, Some("queued_account"), 0),
|
||||
(Some("Original Account"), None, 0),
|
||||
@@ -1473,7 +1474,7 @@ async fn queued_history_keeps_frozen_identity_after_configuration_deletion() {
|
||||
started_at,
|
||||
UsageRecordFilter {
|
||||
client_api_key_name: key_name.map(str::to_owned),
|
||||
provider_account_name: account_name.map(str::to_owned),
|
||||
provider_account_search: account_search.map(str::to_owned),
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
@@ -1481,7 +1482,7 @@ async fn queued_history_keeps_frozen_identity_after_configuration_deletion() {
|
||||
let page = repository.list_usage_records(query).await.unwrap();
|
||||
assert_eq!(
|
||||
page.total, expected,
|
||||
"published={published}, key={key_name:?}, account={account_name:?}, status={status:?}"
|
||||
"published={published}, key={key_name:?}, account={account_search:?}, status={status:?}"
|
||||
);
|
||||
assert_eq!(page.items.len() as u64, expected);
|
||||
if expected == 1 {
|
||||
|
||||
@@ -59,10 +59,10 @@ tokio-rustls = { version = "=0.26.4", default-features = false }
|
||||
tokio-util = { version = "0.7.18", features = ["rt"] }
|
||||
tower-service = "0.3.3"
|
||||
tower-layer = "0.3.3"
|
||||
# 官方 Codex WebSocket 需要上游尚未发布的 proxy 与 permessage-deflate 实现,固定到已审计提交。
|
||||
tokio-tungstenite = { git = "https://github.com/openai-oss-forks/tokio-tungstenite", rev = "0e5b2d73aa18dd9f0a50ee9ff199d5aef7594186", features = ["proxy", "rustls-tls-native-roots"] }
|
||||
# 官方 fork 支持代理连接和分帧消息的 permessage-deflate,两个提交须配套
|
||||
tokio-tungstenite = { git = "https://github.com/openai-oss-forks/tokio-tungstenite", rev = "7447c427513cfe685f236e1ac0513c4ea3dd9c0b", features = ["proxy", "rustls-tls-native-roots"] }
|
||||
tracing = "0.1.44"
|
||||
tungstenite = { git = "https://github.com/openai-oss-forks/tungstenite-rs", rev = "4fffad30fe373adbdcffab9545e9e9bf4f2fc19f", features = ["deflate", "proxy"] }
|
||||
tungstenite = { git = "https://github.com/openai-oss-forks/tungstenite-rs", rev = "bc589d684755a8c02da0fc7e58d0861cbfc306f1", features = ["deflate", "proxy"] }
|
||||
url = "2.5.8"
|
||||
uuid = { version = "1.23.3", features = ["v4", "v7"] }
|
||||
# 静态链接 XZ 解码器,不要求部署环境安装 liblzma。
|
||||
@@ -73,8 +73,8 @@ zstd = "=0.14.3"
|
||||
zip = { version = "9.0.4", default-features = false, features = ["deflate-flate2"] }
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
openssl = "=0.10.80"
|
||||
openssl-sys = { version = "=0.9.116", features = ["vendored"] }
|
||||
openssl = "=0.10.82"
|
||||
openssl-sys = { version = "=0.9.118", features = ["vendored"] }
|
||||
|
||||
[dev-dependencies]
|
||||
gateway-host = { path = "../../gateway-host" }
|
||||
|
||||
@@ -265,8 +265,7 @@ impl ProviderAdmin for OpenAiAdminProvider {
|
||||
}
|
||||
|
||||
fn plan_type_display(&self, plan_type: &str) -> String {
|
||||
// Pro 系列按套餐类型区分展示,其他套餐遵循官方 KnownPlan::display_name
|
||||
// 只映射展示名称,原始套餐值与未知套餐保持不变
|
||||
// Pro 三档沿用管理端短名,其余已知套餐使用 Codex /status 的名称
|
||||
match plan_type.to_ascii_lowercase().as_str() {
|
||||
"free" => "Free",
|
||||
"go" => "Go",
|
||||
@@ -274,16 +273,17 @@ impl ProviderAdmin for OpenAiAdminProvider {
|
||||
"pro" => "Pro",
|
||||
"prolite" => "ProLite",
|
||||
"promax" => "ProMax",
|
||||
"team" => "Team",
|
||||
"self_serve_business_prolite" => "Self Serve Business ProLite",
|
||||
"self_serve_business_usage_based" => "Self Serve Business Usage Based",
|
||||
"business" => "Business",
|
||||
"ent26" | "enterprise" | "hc" => "Enterprise",
|
||||
"team" | "self_serve_business_usage_based" => "Business",
|
||||
"self_serve_business_prolite" => "Business Premium",
|
||||
"business" | "ent26" | "enterprise" | "hc" | "enterprise_cbp_usage_based" => {
|
||||
"Enterprise"
|
||||
}
|
||||
"enterprise_cbp_automation" => "Enterprise (Automation)",
|
||||
"enterprise_cbp_usage_based" => "Enterprise CBP Usage Based",
|
||||
"edu" | "education" => "Edu",
|
||||
"edu_plus" => "Edu Plus",
|
||||
"edu_pro" => "Edu Pro",
|
||||
"sci" => "Academic Researchers",
|
||||
"sci_plus" => "Academic Researchers Plus",
|
||||
_ => plan_type,
|
||||
}
|
||||
.to_owned()
|
||||
@@ -797,35 +797,31 @@ impl ProviderAdmin for OpenAiAdminProvider {
|
||||
}
|
||||
}
|
||||
|
||||
fn quota_history_parser(
|
||||
&self,
|
||||
) -> Option<gateway_admin::model::quota_history::QuotaHistoryParser> {
|
||||
Some(quota::history_reading)
|
||||
}
|
||||
|
||||
fn quota_forecast_observation(
|
||||
&self,
|
||||
document: &ProviderDocument,
|
||||
window: &ProviderQuotaWindow,
|
||||
) -> Option<QuotaForecastObservation> {
|
||||
use gateway_protocol::openai::events::parse_rate_limit_headers;
|
||||
|
||||
if window.local_usage_attribution != QuotaLocalUsageAttribution::AccountWide {
|
||||
return None;
|
||||
}
|
||||
let value = document
|
||||
.expose_to_provider()
|
||||
.expose_to_provider()
|
||||
.get("rateLimitHeaders")?;
|
||||
let headers: Vec<(String, String)> = serde_json::from_value(value.clone()).ok()?;
|
||||
let parsed = parse_rate_limit_headers(&headers)?;
|
||||
let limit = parsed.limits.get(window.limit_id.as_deref()?)?;
|
||||
let observed = match window.role? {
|
||||
ProviderQuotaWindowRole::Primary => limit.primary?,
|
||||
ProviderQuotaWindowRole::Secondary => limit.secondary?,
|
||||
ProviderQuotaWindowRole::Monthly => return None,
|
||||
};
|
||||
if observed.window_minutes?.checked_mul(60)? != window.window_seconds? {
|
||||
let (observed, plan_type) = quota::history_window(document, &window.key)?;
|
||||
if Some(observed.source()) != window.limit_id.as_deref()
|
||||
|| Some(quota_role(observed.role())) != window.role
|
||||
|| observed.window_seconds()? != window.window_seconds?
|
||||
{
|
||||
return None;
|
||||
}
|
||||
Some(QuotaForecastObservation {
|
||||
used_percent: observed.used_percent,
|
||||
reset_at: DateTime::<Utc>::from_timestamp(observed.reset_at?, 0)?,
|
||||
plan_type: parsed.plan_type,
|
||||
used_percent: observed.used_percent()?,
|
||||
reset_at: observed.reset_at()?,
|
||||
plan_type,
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! 管理端批量读取原生额度,不在列表查询中访问上游
|
||||
//! 管理端额度快照与历史请求观测的只读投影
|
||||
|
||||
use super::*;
|
||||
|
||||
@@ -74,3 +74,29 @@ impl OpenAiAdminProvider {
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn history_window(
|
||||
document: &ProviderDocument,
|
||||
key: &str,
|
||||
) -> Option<(crate::credential::CodexQuotaWindow, Option<String>)> {
|
||||
let headers = document
|
||||
.expose_to_provider()
|
||||
.expose_to_provider()
|
||||
.get("rateLimitHeaders")?;
|
||||
let headers: Vec<(String, String)> = serde::Deserialize::deserialize(headers).ok()?;
|
||||
let parsed = gateway_protocol::openai::events::parse_rate_limit_headers(&headers)?;
|
||||
let window = crate::credential::observed_quota_window(&parsed, key)?;
|
||||
Some((window, parsed.plan_type))
|
||||
}
|
||||
|
||||
pub(super) fn history_reading(
|
||||
document: &ProviderDocument,
|
||||
key: &str,
|
||||
) -> Option<gateway_admin::model::quota_history::QuotaReading> {
|
||||
let (window, plan_type) = history_window(document, key)?;
|
||||
Some(gateway_admin::model::quota_history::QuotaReading {
|
||||
plan_type,
|
||||
used_percent: window.used_percent()?,
|
||||
reset_at: window.reset_at(),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -33,7 +33,7 @@ use crate::transport::{CodexBackendClient, CodexCatalogModel, CodexRequestContex
|
||||
|
||||
const MAX_RESPONSE_ETAG_BYTES: usize = 256;
|
||||
const ACCOUNT_CATALOG_CACHE_TTL: Duration = Duration::from_secs(5 * 60);
|
||||
const CATALOG_REFRESH_AFTER: Duration = Duration::from_secs(30 * 60);
|
||||
const CATALOG_REFRESH_AFTER: Duration = Duration::from_hours(1);
|
||||
const MAX_ACCOUNT_CATALOG_MODELS: usize = 2_048;
|
||||
const MODEL_CATALOG_TIMEOUT: Duration = Duration::from_secs(15);
|
||||
|
||||
@@ -137,14 +137,31 @@ impl CatalogContent {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct AccountEntry {
|
||||
observed_at: SystemTime,
|
||||
content: Arc<CatalogContent>,
|
||||
etag: Option<String>,
|
||||
// 目录返回不同版本时,触发这次查询的标记只用于去重
|
||||
trigger_etag: Option<String>,
|
||||
// 响应只确认这份目录的刷新期限,正文观测时间仍用于并发发布和持久化
|
||||
etag_confirmed_at: std::sync::Mutex<Option<tokio::time::Instant>>,
|
||||
}
|
||||
|
||||
type Entries = BTreeMap<CodexCatalogScope, AccountEntry>;
|
||||
impl AccountEntry {
|
||||
fn recognizes_etag(&self, etag: &str) -> bool {
|
||||
self.etag.as_deref() == Some(etag) || self.trigger_etag.as_deref() == Some(etag)
|
||||
}
|
||||
|
||||
fn is_fresh(&self, now: SystemTime) -> bool {
|
||||
now.duration_since(self.observed_at)
|
||||
.is_ok_and(|age| age < CATALOG_REFRESH_AFTER)
|
||||
|| self.etag_confirmed_at.lock().is_ok_and(|confirmed| {
|
||||
confirmed.is_some_and(|at| at.elapsed() < CATALOG_REFRESH_AFTER)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type Entries = BTreeMap<CodexCatalogScope, Arc<AccountEntry>>;
|
||||
|
||||
pub struct CodexCredentialCatalogSnapshot {
|
||||
models: Vec<CodexCatalogModel>,
|
||||
@@ -551,7 +568,7 @@ impl CodexCredentialCatalogService {
|
||||
revision: account.revision(),
|
||||
plan: account.plan_type().map(str::to_owned),
|
||||
observed_at,
|
||||
etag: etag.clone().or(fetched.etag),
|
||||
etag: fetched.etag.or_else(|| etag.clone()),
|
||||
};
|
||||
if !self
|
||||
.repository
|
||||
@@ -577,7 +594,9 @@ impl CodexCredentialCatalogService {
|
||||
AccountEntry {
|
||||
observed_at,
|
||||
content,
|
||||
trigger_etag: etag.filter(|tag| Some(tag) != observed.etag.as_ref()),
|
||||
etag: observed.etag,
|
||||
etag_confirmed_at: Default::default(),
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
@@ -37,11 +37,13 @@ impl CodexCredentialCatalogService {
|
||||
};
|
||||
entries.insert(
|
||||
scope,
|
||||
AccountEntry {
|
||||
Arc::new(AccountEntry {
|
||||
observed_at: a.observed_at,
|
||||
content: content.clone(),
|
||||
etag: a.etag,
|
||||
},
|
||||
trigger_etag: None,
|
||||
etag_confirmed_at: Default::default(),
|
||||
}),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -119,15 +121,21 @@ impl CodexCredentialCatalogService {
|
||||
.cache
|
||||
.write()
|
||||
.map_err(|_| CodexCredentialCatalogError::Cache)?;
|
||||
if state.pending.get(&scope).map(String::as_str) == Some(etag)
|
||||
|| !state.pending.contains_key(&scope)
|
||||
&& state
|
||||
.snapshot
|
||||
.as_ref()
|
||||
.and_then(|s| s.entries.get(&scope))
|
||||
.and_then(|e| e.etag.as_deref())
|
||||
== Some(etag)
|
||||
let pending = state.pending.get(&scope);
|
||||
if pending.is_some_and(|tag| tag == etag) {
|
||||
return Ok(false);
|
||||
}
|
||||
if let Some(entry) = state.snapshot.as_ref().and_then(|s| s.entries.get(&scope))
|
||||
&& entry.recognizes_etag(etag)
|
||||
{
|
||||
// 已收到变更时,迟到的旧标记不能覆盖待刷新版本
|
||||
if pending.is_none() && entry.etag.as_deref() == Some(etag) {
|
||||
let mut confirmed_at = entry
|
||||
.etag_confirmed_at
|
||||
.lock()
|
||||
.map_err(|_| CodexCredentialCatalogError::Cache)?;
|
||||
*confirmed_at = Some(tokio::time::Instant::now());
|
||||
}
|
||||
return Ok(false);
|
||||
}
|
||||
state.pending.insert(scope, etag.to_owned());
|
||||
@@ -166,7 +174,7 @@ impl CodexCredentialCatalogService {
|
||||
.get(&scope)
|
||||
.is_none_or(|old| old.observed_at < entry.observed_at)
|
||||
{
|
||||
entries.insert(scope, entry);
|
||||
entries.insert(scope, Arc::new(entry));
|
||||
}
|
||||
}
|
||||
self.publish(revision, entries)?;
|
||||
@@ -205,7 +213,7 @@ impl CodexCredentialCatalogService {
|
||||
return true;
|
||||
};
|
||||
// 发布其他账号时保留通知,只有该账号更新的观测才能确认 ETag
|
||||
entry.etag.as_deref() != Some(tag)
|
||||
!entry.recognizes_etag(tag)
|
||||
|| old
|
||||
.as_ref()
|
||||
.and_then(|s| s.entries.get(scope))
|
||||
@@ -278,10 +286,7 @@ impl CodexCredentialCatalogService {
|
||||
.into_iter()
|
||||
.filter(|(scope, _)| {
|
||||
pending.contains_key(scope)
|
||||
|| !entries.get(scope).is_some_and(|e| {
|
||||
now.duration_since(e.observed_at)
|
||||
.is_ok_and(|age| age < CATALOG_REFRESH_AFTER)
|
||||
})
|
||||
|| !entries.get(scope).is_some_and(|entry| entry.is_fresh(now))
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
if due.is_empty() {
|
||||
|
||||
@@ -59,6 +59,7 @@ pub use oauth::{
|
||||
pub use profile_statistics::{
|
||||
CodexCredentialProfileService, CodexProfileAvatarError, CodexProfileStatisticsError,
|
||||
};
|
||||
pub(crate) use quota::observed_quota_window;
|
||||
pub use quota::{
|
||||
CodexAccountQuotaSnapshot, CodexCredentialQuotaError, CodexCredentialQuotaService,
|
||||
CodexInitialSyncDelays, CodexQuotaFact, CodexQuotaRefreshPolicy, CodexQuotaSyncSummary,
|
||||
|
||||
@@ -18,6 +18,7 @@ mod warmup;
|
||||
|
||||
const BUCKET_USAGE_FIELD: &str = "_cpr_bucket_last_used_at";
|
||||
|
||||
pub(crate) use passive::observed_quota_window;
|
||||
pub use reset_credits::CodexResetCreditsError;
|
||||
use reset_credits::ResetCreditLocks;
|
||||
use scheduling::CodexQuotaSchedulingProjection;
|
||||
|
||||
@@ -151,6 +151,18 @@ impl CodexCredentialQuotaService {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn observed_quota_window(
|
||||
parsed: &ParsedRateLimits,
|
||||
key: &str,
|
||||
) -> Option<CodexQuotaWindow> {
|
||||
// 只解释本次响应,不借用当前快照补全旧观测或把具名桶镜像当作账号额度
|
||||
let (quota, _) = merge_passive_quota(Map::new(), std::slice::from_ref(parsed), None);
|
||||
snapshot::quota_windows("a)
|
||||
.ok()?
|
||||
.into_iter()
|
||||
.find(|window| window.key() == key)
|
||||
}
|
||||
|
||||
fn merge_passive_quota(
|
||||
mut quota: Map<String, Value>,
|
||||
observations: &[ParsedRateLimits],
|
||||
|
||||
@@ -416,16 +416,7 @@ pub(crate) fn parse_account_quota_snapshot(
|
||||
) -> Result<CodexAccountQuotaSnapshot, CodexCredentialQuotaError> {
|
||||
let object = canonical_quota_object(usage)?;
|
||||
let fact = parse_codex_quota_object(&object)?;
|
||||
let mut windows = Vec::new();
|
||||
for limit in canonical_rate_limits(&object)? {
|
||||
parse_rate_limit_windows(
|
||||
&limit.source,
|
||||
limit.account_wide,
|
||||
limit.limit_name.as_deref(),
|
||||
limit.rate_limit,
|
||||
&mut windows,
|
||||
)?;
|
||||
}
|
||||
let mut windows = quota_windows(&object)?;
|
||||
windows.sort_by(|left, right| {
|
||||
quota_source_order(left.source())
|
||||
.cmp("a_source_order(right.source()))
|
||||
@@ -610,6 +601,22 @@ fn is_codex_limit_id(value: &str) -> bool {
|
||||
value.trim().eq_ignore_ascii_case("codex")
|
||||
}
|
||||
|
||||
pub(super) fn quota_windows(
|
||||
object: &Map<String, Value>,
|
||||
) -> Result<Vec<CodexQuotaWindow>, CodexCredentialQuotaError> {
|
||||
let mut windows = Vec::new();
|
||||
for limit in canonical_rate_limits(object)? {
|
||||
parse_rate_limit_windows(
|
||||
&limit.source,
|
||||
limit.account_wide,
|
||||
limit.limit_name.as_deref(),
|
||||
limit.rate_limit,
|
||||
&mut windows,
|
||||
)?;
|
||||
}
|
||||
Ok(windows)
|
||||
}
|
||||
|
||||
fn parse_rate_limit_windows(
|
||||
source: &str,
|
||||
account_wide: bool,
|
||||
|
||||
@@ -19,7 +19,10 @@ use gateway_core::account::{
|
||||
use gateway_core::concurrency::{
|
||||
CapacityWait, ConcurrencyQueuePolicy, ConcurrencyWaitQueue, QueueRejection, WaitPriority,
|
||||
};
|
||||
use gateway_core::engine::{AttemptContext, ContinuationAttempt, policy::AccountPolicyError};
|
||||
use gateway_core::engine::{
|
||||
AttemptContext, ContinuationAttempt,
|
||||
policy::{AccountPolicyError, AccountScheduleOwnership},
|
||||
};
|
||||
use gateway_core::provider_ports::{
|
||||
ProviderAccountAdmission, ProviderConcurrencyPool, ProviderCooldownPort, ProviderCooldownScope,
|
||||
ProviderLeaseAcquisition, ProviderLeaseGuard, ProviderLeasePort, ProviderLeaseRequest,
|
||||
@@ -1157,6 +1160,27 @@ impl CodexCredentialSelector {
|
||||
}
|
||||
let mut shortest_retry = None;
|
||||
let mut busy_accounts = std::collections::BTreeSet::new();
|
||||
let binding_wait_error = |rejection| {
|
||||
if rejection == QueueRejection::Timeout
|
||||
&& follow_only
|
||||
&& pinned_account.is_none()
|
||||
&& let Some(account) = binding.as_ref().map(ProviderSessionBinding::account_id)
|
||||
&& !account_ids.contains(account)
|
||||
{
|
||||
// 仅在本次授权范围内区分明确的模型限制,其余资格缺失不推测原因
|
||||
let reason = match (model.model(), request.attempt.account_scope()) {
|
||||
(Some(model), Some(scope))
|
||||
if scope.allows(account) && !scope.allows_model(account, model) =>
|
||||
{
|
||||
"The parent session's account does not allow the requested model."
|
||||
}
|
||||
_ => "The parent session's account cannot serve this request.",
|
||||
};
|
||||
CredentialSelectionError::IneligibleSessionAccountTimeout(reason)
|
||||
} else {
|
||||
CredentialSelectionError::QueueRejected(rejection)
|
||||
}
|
||||
};
|
||||
loop {
|
||||
let preferred = pinned_account
|
||||
.clone()
|
||||
@@ -1185,6 +1209,14 @@ impl CodexCredentialSelector {
|
||||
model.model(),
|
||||
&candidates,
|
||||
&mut context,
|
||||
AccountScheduleOwnership {
|
||||
bound_account: binding
|
||||
.as_ref()
|
||||
.filter(|_| !cache_preference)
|
||||
.map(ProviderSessionBinding::account_id),
|
||||
follow_only,
|
||||
pinned_account: pinned_account.as_ref(),
|
||||
},
|
||||
)
|
||||
.await
|
||||
{
|
||||
@@ -1206,7 +1238,10 @@ impl CodexCredentialSelector {
|
||||
// 目标已有空位,恢复完整容量观测后再尝试准入
|
||||
refresh_candidates = true;
|
||||
} else if follow_only || wait_candidates.contains(queued) {
|
||||
waiting.wait(std::slice::from_ref(queued)).await?;
|
||||
waiting
|
||||
.wait(std::slice::from_ref(queued))
|
||||
.await
|
||||
.map_err(binding_wait_error)?;
|
||||
} else {
|
||||
refresh_candidates = true;
|
||||
}
|
||||
@@ -1303,7 +1338,8 @@ impl CodexCredentialSelector {
|
||||
// 冷却、排除、停用或当前账号不在本次范围时也只等待根线程恢复或迁移
|
||||
waiting
|
||||
.wait(std::slice::from_ref(binding.account_id()))
|
||||
.await?;
|
||||
.await
|
||||
.map_err(binding_wait_error)?;
|
||||
continue 'capacity;
|
||||
}
|
||||
if !diagnostic && queue_policy.max_waiting > 0 && !wait_candidates.is_empty() {
|
||||
@@ -2359,6 +2395,8 @@ pub enum CredentialSelectionError {
|
||||
SessionBound(#[source] Box<CredentialSelectionError>),
|
||||
#[error(transparent)]
|
||||
QueueRejected(#[from] QueueRejection),
|
||||
#[error("{0} Timed out waiting for the session to switch accounts.")]
|
||||
IneligibleSessionAccountTimeout(&'static str),
|
||||
#[error("no eligible Codex account")]
|
||||
NoEligibleCredential,
|
||||
#[error("upstream safety policy temporarily excludes accounts for this session")]
|
||||
|
||||
@@ -434,10 +434,6 @@ pub(super) struct OpenAiSessionState {
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub(super) oauth_identity: Option<String>,
|
||||
pub(super) conversation_id: Option<String>,
|
||||
#[serde(default)]
|
||||
pub(super) turn_state: Option<String>,
|
||||
#[serde(default)]
|
||||
pub(super) client_turn_id: Option<String>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub(super) reasoning_effort_override: Option<String>,
|
||||
pub(super) continuation_scope: OpenAiContinuationScope,
|
||||
@@ -456,20 +452,12 @@ pub(super) struct OpenAiSessionCapture {
|
||||
pub(super) credential_revision: Option<u64>,
|
||||
pub(super) oauth_identity: Option<String>,
|
||||
pub(super) conversation_id: Option<String>,
|
||||
pub(super) turn_state: Option<String>,
|
||||
pub(super) client_turn_id: Option<String>,
|
||||
pub(super) reasoning_effort_override: Option<String>,
|
||||
pub(super) response_store: bool,
|
||||
pub(super) oversized_http: bool,
|
||||
pub(super) continuation_scope: Option<OpenAiContinuationScope>,
|
||||
}
|
||||
|
||||
pub(super) fn same_client_turn(previous: Option<&str>, current: Option<&str>) -> bool {
|
||||
previous
|
||||
.zip(current)
|
||||
.is_some_and(|(previous, current)| !previous.is_empty() && previous == current)
|
||||
}
|
||||
|
||||
pub(super) fn decode_openai_session_state(request: &GenerateRequest) -> Option<OpenAiSessionState> {
|
||||
request
|
||||
.provider_session_state(PROVIDER_NAME)
|
||||
@@ -505,8 +493,6 @@ fn encode_openai_session_capture(
|
||||
credential_revision: capture.credential_revision,
|
||||
oauth_identity: capture.oauth_identity.clone(),
|
||||
conversation_id: capture.conversation_id.clone(),
|
||||
turn_state: capture.turn_state.clone(),
|
||||
client_turn_id: capture.client_turn_id.clone(),
|
||||
reasoning_effort_override: capture.reasoning_effort_override.clone(),
|
||||
continuation_scope,
|
||||
})
|
||||
@@ -938,7 +924,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
|
||||
} else {
|
||||
OpenAiContinuationScope::ReplayRequired
|
||||
});
|
||||
capture.turn_state = response.turn_state.clone().or(capture.turn_state.clone());
|
||||
}
|
||||
let mut observation_state = OpenAiResponseObservationState::from_backend_response(
|
||||
&response,
|
||||
@@ -1070,7 +1055,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
|
||||
};
|
||||
let metadata_merge = merge_response_metadata_updates(
|
||||
response_metadata_updates.as_ref(),
|
||||
&mut session_capture,
|
||||
&mut observation_state,
|
||||
)
|
||||
.await;
|
||||
@@ -1148,7 +1132,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
|
||||
};
|
||||
let metadata_merge = merge_response_metadata_updates(
|
||||
response_metadata_updates.as_ref(),
|
||||
&mut session_capture,
|
||||
&mut observation_state,
|
||||
)
|
||||
.await;
|
||||
@@ -1354,7 +1337,6 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
|
||||
}
|
||||
let metadata_changed = merge_response_metadata_updates(
|
||||
response_metadata_updates.as_ref(),
|
||||
&mut session_capture,
|
||||
&mut observation_state,
|
||||
)
|
||||
.await
|
||||
@@ -1417,12 +1399,8 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream {
|
||||
|
||||
async fn merge_response_metadata_updates(
|
||||
updates: Option<&CodexResponseMetadataUpdates>,
|
||||
session_capture: &mut Option<OpenAiSessionCapture>,
|
||||
observation_state: &mut OpenAiResponseObservationState,
|
||||
) -> Option<bool> {
|
||||
let turn_state = updates?.lock().await.turn_state.take()?;
|
||||
if let Some(capture) = session_capture.as_mut() {
|
||||
capture.turn_state = Some(turn_state.clone());
|
||||
}
|
||||
Some(observation_state.merge_client_header("x-codex-turn-state", &turn_state))
|
||||
}
|
||||
|
||||
@@ -86,7 +86,7 @@ use crate::transport::protocol::responses::{
|
||||
};
|
||||
use crate::transport::request::{
|
||||
CodexRequestEncodeError, RequestAccountScope, align_structured_location_fields,
|
||||
clear_request_turn_state, encode_generate_request, scope_request_to_account,
|
||||
encode_generate_request, scope_request_to_account,
|
||||
};
|
||||
use crate::transport::session::CodexSessionIdentity;
|
||||
use crate::transport::usage::normalize_service_tier;
|
||||
@@ -240,19 +240,6 @@ impl CodexProvider {
|
||||
if let Some(identity) = &self.session_identity {
|
||||
identity.prepare_local_conversation(&mut upstream);
|
||||
}
|
||||
if let Some(previous_session) = previous_session.as_ref() {
|
||||
if same_client_turn(
|
||||
previous_session.client_turn_id.as_deref(),
|
||||
upstream.client_turn_id.as_deref(),
|
||||
) {
|
||||
upstream.turn_state = upstream
|
||||
.turn_state
|
||||
.take()
|
||||
.or_else(|| previous_session.turn_state.clone());
|
||||
} else {
|
||||
clear_request_turn_state(&mut upstream);
|
||||
}
|
||||
}
|
||||
let session_affinity =
|
||||
derive_codex_session_affinity(&upstream, context.client_api_key_ref());
|
||||
let cyber_policy_session_key =
|
||||
@@ -1144,8 +1131,6 @@ impl CodexProvider {
|
||||
)
|
||||
.then_some(lease.account().revision().get()),
|
||||
conversation_id: upstream_request.local_conversation_id.clone(),
|
||||
turn_state: upstream_request.turn_state.clone(),
|
||||
client_turn_id: upstream_request.client_turn_id.clone(),
|
||||
reasoning_effort_override: upstream_request
|
||||
.semantics(
|
||||
previous_session
|
||||
|
||||
@@ -701,8 +701,6 @@ pub(super) fn codex_request_context<'a>(
|
||||
request_id,
|
||||
turn_state: request.turn_state.as_deref(),
|
||||
turn_metadata: request.turn_metadata.as_deref(),
|
||||
beta_features: request.beta_features.as_deref(),
|
||||
include_timing_metrics: request.include_timing_metrics.as_deref(),
|
||||
version: request.version.as_deref(),
|
||||
codex_window_id: request.codex_window_id.as_deref(),
|
||||
parent_thread_id: request.parent_thread_id.as_deref(),
|
||||
@@ -711,7 +709,6 @@ pub(super) fn codex_request_context<'a>(
|
||||
session_id: request.client_session_id.as_deref(),
|
||||
thread_id: request.client_thread_id.as_deref(),
|
||||
client_request_id: request.client_request_id.as_deref(),
|
||||
turn_id: request.client_turn_id.as_deref(),
|
||||
account_selection,
|
||||
}
|
||||
}
|
||||
@@ -818,6 +815,15 @@ fn selection_failure(error: &CredentialSelectionError) -> ProviderError {
|
||||
CredentialSelectionError::QueueRejected(error) => {
|
||||
provider_error(error.provider_kind(), UpstreamSendState::NotSent)
|
||||
}
|
||||
CredentialSelectionError::IneligibleSessionAccountTimeout(_) => provider_error(
|
||||
ProviderErrorKind::ConcurrencyQueueTimeout,
|
||||
UpstreamSendState::NotSent,
|
||||
)
|
||||
.with_client_visible_upstream_error(ClientVisibleUpstreamError::new(
|
||||
error.to_string(),
|
||||
None,
|
||||
None,
|
||||
)),
|
||||
CredentialSelectionError::CapacityUnavailable { retry_after } => {
|
||||
let error = provider_error(
|
||||
ProviderErrorKind::AccountCapacityUnavailable,
|
||||
|
||||
@@ -22,7 +22,7 @@ pub(crate) fn follows_session_with_headers(
|
||||
}
|
||||
gateway_protocol::openai::codex_responses_request_semantics_with_turn_metadata(
|
||||
body,
|
||||
metadata.or_else(|| context.get("turn_metadata").and_then(Value::as_str)),
|
||||
metadata.or_else(|| gateway_protocol::openai::context_turn_metadata(body, context)),
|
||||
None,
|
||||
)
|
||||
.subagent_kind
|
||||
|
||||
@@ -472,10 +472,6 @@ pub struct CodexRequestContext<'a> {
|
||||
pub turn_state: Option<&'a str>,
|
||||
/// 客户端 turn metadata;其中 installation ID 已按当前账号处理
|
||||
pub turn_metadata: Option<&'a str>,
|
||||
/// x-codex-beta-features 头值
|
||||
pub beta_features: Option<&'a str>,
|
||||
/// x-responsesapi-include-timing-metrics 头值
|
||||
pub include_timing_metrics: Option<&'a str>,
|
||||
/// 下游 `version` 扩展头;存在时上游值由 Desktop 版本画像统一生成
|
||||
pub version: Option<&'a str>,
|
||||
/// 客户端 window ID
|
||||
@@ -492,8 +488,6 @@ pub struct CodexRequestContext<'a> {
|
||||
pub thread_id: Option<&'a str>,
|
||||
/// 客户端逻辑 request ID;缺失时使用代理请求 ID
|
||||
pub client_request_id: Option<&'a str>,
|
||||
/// 客户端 turn ID
|
||||
pub turn_id: Option<&'a str>,
|
||||
/// 账号亲和选择结果;仅用于结构化遥测,不参与 transport 决策
|
||||
pub account_selection: CodexAccountSelectionTelemetry<'a>,
|
||||
}
|
||||
@@ -514,8 +508,6 @@ impl<'a> CodexRequestContext<'a> {
|
||||
request_id,
|
||||
turn_state: None,
|
||||
turn_metadata: None,
|
||||
beta_features: None,
|
||||
include_timing_metrics: None,
|
||||
version: None,
|
||||
codex_window_id: None,
|
||||
parent_thread_id: None,
|
||||
@@ -524,7 +516,6 @@ impl<'a> CodexRequestContext<'a> {
|
||||
session_id: None,
|
||||
thread_id: None,
|
||||
client_request_id: None,
|
||||
turn_id: None,
|
||||
account_selection: CodexAccountSelectionTelemetry::NONE,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -211,11 +211,6 @@ impl CodexBackendClient {
|
||||
("x-codex-window-id", context.codex_window_id),
|
||||
("x-codex-turn-state", context.turn_state),
|
||||
("x-codex-turn-metadata", context.turn_metadata),
|
||||
("x-codex-beta-features", context.beta_features),
|
||||
(
|
||||
"x-responsesapi-include-timing-metrics",
|
||||
context.include_timing_metrics,
|
||||
),
|
||||
("x-codex-parent-thread-id", context.parent_thread_id),
|
||||
(
|
||||
X_OPENAI_MEMGEN_REQUEST_HEADER,
|
||||
|
||||
@@ -56,10 +56,10 @@ pub(super) struct DesktopArtifact {
|
||||
pub etag: &'static str,
|
||||
}
|
||||
|
||||
// 官方 npm 稳定标签及六个平台依赖;核验于 2026-11-14T02:09:52Z
|
||||
// 官方 npm 稳定版本及六个平台依赖,核验于 2026-11-19T00:51:11Z
|
||||
pub(super) const CLI_RELEASE: CoreRelease = CoreRelease {
|
||||
version: "0.169.0",
|
||||
verified_at_millis: 1_794_622_192_000,
|
||||
version: "0.170.0",
|
||||
verified_at_millis: 1_795_049_471_000,
|
||||
};
|
||||
|
||||
// macOS arm64 ZIP;核验于 2026-11-14T02:09:52Z
|
||||
|
||||
@@ -50,8 +50,6 @@ pub struct CodexResponsesRequest {
|
||||
pub client_thread_id: Option<String>,
|
||||
/// 客户端 request ID,仅保留在受控本地上下文
|
||||
pub client_request_id: Option<String>,
|
||||
/// 客户端 turn ID,仅保留在受控本地上下文
|
||||
pub client_turn_id: Option<String>,
|
||||
/// 连接池和 affinity 使用的本地会话身份,不发送上游
|
||||
pub local_conversation_id: Option<String>,
|
||||
/// 变体身份键
|
||||
@@ -70,12 +68,10 @@ pub struct CodexResponsesRequest {
|
||||
pub turn_state: Option<String>,
|
||||
/// turn metadata 透传头
|
||||
pub turn_metadata: Option<String>,
|
||||
/// beta features 透传头
|
||||
pub beta_features: Option<String>,
|
||||
/// 实际入站为 WS 帧时,观测优先使用本帧的轮次元数据
|
||||
pub(crate) websocket_frame: bool,
|
||||
/// 下游 `version` 扩展头;存在时上游值由 Desktop 版本画像统一生成
|
||||
pub version: Option<String>,
|
||||
/// timing metrics 透传头
|
||||
pub include_timing_metrics: Option<String>,
|
||||
/// Responses Lite 请求语义;HTTP 使用 header,WebSocket 使用 client metadata 投影
|
||||
pub responses_lite: Option<String>,
|
||||
/// Memory consolidation 请求语义;HTTP 与 WebSocket opening 均使用 header
|
||||
@@ -605,7 +601,6 @@ impl CodexResponsesRequest {
|
||||
client_account_follow_only: false,
|
||||
client_thread_id: None,
|
||||
client_request_id: None,
|
||||
client_turn_id: None,
|
||||
local_conversation_id: None,
|
||||
variant_identity: None,
|
||||
client_ip: None,
|
||||
@@ -615,9 +610,8 @@ impl CodexResponsesRequest {
|
||||
force_http_sse: false,
|
||||
turn_state: None,
|
||||
turn_metadata: None,
|
||||
beta_features: None,
|
||||
websocket_frame: false,
|
||||
version: None,
|
||||
include_timing_metrics: None,
|
||||
responses_lite: None,
|
||||
memgen_request: None,
|
||||
codex_window_id: None,
|
||||
@@ -774,7 +768,11 @@ impl CodexResponsesRequest {
|
||||
) -> CodexRequestSemantics {
|
||||
codex_responses_request_semantics_with_turn_metadata(
|
||||
self.body(),
|
||||
self.turn_metadata.as_deref(),
|
||||
gateway_protocol::openai::observed_turn_metadata(
|
||||
self.body(),
|
||||
self.turn_metadata.as_deref(),
|
||||
self.websocket_frame,
|
||||
),
|
||||
previous_reasoning_effort_override,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -198,7 +198,7 @@ pub fn websocket_response_create_payload(request: &CodexResponsesRequest) -> Val
|
||||
Value::Object(payload)
|
||||
}
|
||||
|
||||
/// 借用原始 body 序列化 `response.create` 帧,不复制字段
|
||||
/// 借用原始 body 序列化 `response.create` 消息,不复制字段
|
||||
///
|
||||
/// 输出与序列化 [`websocket_response_create_payload`] 的合并 Map 逐字节一致:
|
||||
/// body 自带 `type` 键时以 body 值置于首位,其余字段按插入顺序原样透传
|
||||
@@ -224,7 +224,7 @@ impl serde::Serialize for ResponseCreateFrame<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
/// 生成 Responses WebSocket `response.create` 文本帧内容
|
||||
/// 生成 Responses WebSocket `response.create` 消息的完整文本
|
||||
pub fn websocket_response_create_payload_text(
|
||||
request: &CodexResponsesRequest,
|
||||
) -> Result<String, serde_json::Error> {
|
||||
|
||||
@@ -22,7 +22,6 @@ use crate::transport::protocol::responses::{
|
||||
};
|
||||
|
||||
pub(crate) const PASSTHROUGH_HEADERS_CONTEXT_KEY: &str = "opaque_request_headers";
|
||||
const TURN_ID_CLIENT_METADATA_KEY: &str = "turn_id";
|
||||
const THREAD_SPAWN_SUBAGENT_KIND: &str = "thread_spawn";
|
||||
const THREAD_SPAWN_CONVERSATION_PREFIX: &str = "thread-spawn:";
|
||||
const ENVIRONMENT_CONTEXT_CONTENT_KIND: &str = "environments.environment_context";
|
||||
@@ -256,14 +255,11 @@ fn extract_request_context(request: &mut CodexResponsesRequest) {
|
||||
let context = ExtractedRequestContext::from_body(request.body());
|
||||
request.turn_state = context.turn_state;
|
||||
request.turn_metadata = context.turn_metadata;
|
||||
request.beta_features = context.beta_features;
|
||||
request.version = context.version;
|
||||
request.include_timing_metrics = context.include_timing_metrics;
|
||||
request.codex_window_id = context.codex_window_id;
|
||||
request.parent_thread_id = context.parent_thread_id;
|
||||
request.client_conversation_id = context.conversation_id;
|
||||
request.client_request_id = context.client_request_id;
|
||||
request.client_turn_id = context.turn_id;
|
||||
request.responses_lite = context.responses_lite;
|
||||
request.memgen_request = context.memgen_request;
|
||||
}
|
||||
@@ -271,14 +267,11 @@ fn extract_request_context(request: &mut CodexResponsesRequest) {
|
||||
struct ExtractedRequestContext {
|
||||
turn_state: Option<String>,
|
||||
turn_metadata: Option<String>,
|
||||
beta_features: Option<String>,
|
||||
version: Option<String>,
|
||||
include_timing_metrics: Option<String>,
|
||||
codex_window_id: Option<String>,
|
||||
parent_thread_id: Option<String>,
|
||||
conversation_id: Option<String>,
|
||||
client_request_id: Option<String>,
|
||||
turn_id: Option<String>,
|
||||
responses_lite: Option<String>,
|
||||
memgen_request: Option<String>,
|
||||
}
|
||||
@@ -287,26 +280,18 @@ impl ExtractedRequestContext {
|
||||
fn from_body(body: &Map<String, Value>) -> Self {
|
||||
let client_metadata = body.get("client_metadata").and_then(Value::as_object);
|
||||
Self {
|
||||
// 官方 downstream WebSocket 无法逐帧更新 HTTP header,因此把
|
||||
// response.metadata 返回的 turn state 放回下一帧 client_metadata
|
||||
// Provider 仍会在账号/turn 归属确定后决定是否允许复用该状态
|
||||
// 下游 WS 在每个 response.create 的 client_metadata 回传本轮路由状态
|
||||
turn_state: body_string(body, "turnState").or_else(|| {
|
||||
client_metadata.and_then(|metadata| {
|
||||
string_value(metadata.get(X_CODEX_TURN_STATE_CLIENT_METADATA_KEY))
|
||||
})
|
||||
}),
|
||||
turn_metadata: body_string(body, "turnMetadata"),
|
||||
beta_features: body_string(body, "betaFeatures"),
|
||||
version: body_string(body, "version"),
|
||||
include_timing_metrics: body_string(body, "includeTimingMetrics"),
|
||||
codex_window_id: body_string(body, "codexWindowId"),
|
||||
parent_thread_id: body_string(body, "parentThreadId"),
|
||||
conversation_id: body_string(body, "conversation_id"),
|
||||
client_request_id: body_string(body, "x-client-request-id"),
|
||||
turn_id: body_string(body, "turn_id").or_else(|| {
|
||||
client_metadata
|
||||
.and_then(|metadata| string_value(metadata.get(TURN_ID_CLIENT_METADATA_KEY)))
|
||||
}),
|
||||
// Responses Lite 在 WebSocket body 中的这个键是官方 header 投影,
|
||||
// 不是普通上下文字段的 metadata 回退
|
||||
responses_lite: client_metadata.and_then(|metadata| {
|
||||
@@ -452,8 +437,8 @@ fn normalize_conversation_anchor_text(text: &str) -> String {
|
||||
rest.to_owned()
|
||||
}
|
||||
|
||||
/// 已确认换轮或换号时,各 wire 入口同步清理原有路由 token
|
||||
pub(crate) fn clear_request_turn_state(request: &mut CodexResponsesRequest) {
|
||||
/// 明确换号时,同步清除请求头与正文中的原账号路由 token
|
||||
fn clear_request_turn_state(request: &mut CodexResponsesRequest) {
|
||||
request.turn_state = None;
|
||||
request.passthrough_headers.remove("x-codex-turn-state");
|
||||
for key in TURN_STATE_KEYS {
|
||||
@@ -745,20 +730,24 @@ fn replace_metadata_field(metadata: &mut Map<String, Value>, key: &str, value: O
|
||||
// 请求头的场景)
|
||||
fn apply_protocol_context(request: &mut CodexResponsesRequest, context: &Map<String, Value>) {
|
||||
request.passthrough_headers = decode_passthrough_headers(context);
|
||||
request.turn_state =
|
||||
context_string(context, "turn_state").or_else(|| request.turn_state.take());
|
||||
request.websocket_frame = context
|
||||
.get(gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY)
|
||||
.and_then(Value::as_bool)
|
||||
== Some(true);
|
||||
request.turn_metadata =
|
||||
context_string(context, "turn_metadata").or_else(|| request.turn_metadata.take());
|
||||
request.beta_features =
|
||||
context_string(context, "beta_features").or_else(|| request.beta_features.take());
|
||||
request.version = context_string(context, "version").or_else(|| request.version.take());
|
||||
request.include_timing_metrics = context_string(context, "include_timing_metrics")
|
||||
.or_else(|| request.include_timing_metrics.take());
|
||||
request.codex_window_id =
|
||||
context_string(context, "codex_window_id").or_else(|| request.codex_window_id.take());
|
||||
request.downstream_websocket_connection_id =
|
||||
context_string(context, "downstream_websocket_connection_id")
|
||||
.or_else(|| request.downstream_websocket_connection_id.take());
|
||||
if request.downstream_websocket_connection_id.is_some() && request.turn_state.is_some() {
|
||||
// 当前帧的路由状态优先于握手值,原始握手头也不能覆盖出站投影
|
||||
request.passthrough_headers.remove("x-codex-turn-state");
|
||||
} else if let Some(state) = context_string(context, "turn_state") {
|
||||
request.turn_state = Some(state);
|
||||
}
|
||||
request.parent_thread_id =
|
||||
context_string(context, "parent_thread_id").or_else(|| request.parent_thread_id.take());
|
||||
let prompt_cache_key = request.prompt_cache_key().map(ToOwned::to_owned);
|
||||
@@ -773,8 +762,6 @@ fn apply_protocol_context(request: &mut CodexResponsesRequest, context: &Map<Str
|
||||
request.client_thread_id = gateway_protocol::openai::codex_thread_id(request.body(), context);
|
||||
request.client_request_id =
|
||||
context_string(context, "client_request_id").or_else(|| request.client_request_id.take());
|
||||
request.client_turn_id =
|
||||
context_string(context, "turn_id").or_else(|| request.client_turn_id.take());
|
||||
request.responses_lite =
|
||||
context_string(context, "responses_lite").or_else(|| request.responses_lite.take());
|
||||
request.memgen_request =
|
||||
|
||||
@@ -251,6 +251,27 @@ struct PricingRule {
|
||||
// 已按 https://developers.openai.com/api/docs/deprecations 核验至 2026-09-13,
|
||||
// 移除已关闭的型号;仅宣布弃用但尚未到关闭日期的型号继续保留
|
||||
const PRICING_RULES: &[PricingRule] = &[
|
||||
// GPT-6.2 的 Ultrafast 使用官方价目表中的 6 倍常规价,核验日期 2026-11-18
|
||||
PricingRule {
|
||||
model: "gpt-6.2-astra",
|
||||
pricing: ModelPricing::new(80_000, 400_000, 4_000)
|
||||
.with_cache_write(125)
|
||||
.with_fast(160_000, 800_000, 8_000)
|
||||
.with_ultrafast(480_000, 2_400_000, 24_000)
|
||||
.with_long(160_000, 600_000, 8_000)
|
||||
.with_long_fast(320_000, 1_200_000, 16_000)
|
||||
.with_long_ultrafast(960_000, 3_600_000, 48_000),
|
||||
},
|
||||
PricingRule {
|
||||
model: "gpt-6.2-sol",
|
||||
pricing: ModelPricing::new(20_000, 100_000, 1_000)
|
||||
.with_cache_write(125)
|
||||
.with_fast(40_000, 200_000, 2_000)
|
||||
.with_ultrafast(120_000, 600_000, 6_000)
|
||||
.with_long(40_000, 150_000, 2_000)
|
||||
.with_long_fast(80_000, 300_000, 4_000)
|
||||
.with_long_ultrafast(240_000, 900_000, 12_000),
|
||||
},
|
||||
// Astra:https://developers.openai.com/api/docs/models/gpt-6-astra
|
||||
// 已于 2026-09-09 对照官方价目表核验
|
||||
PricingRule {
|
||||
@@ -924,7 +945,13 @@ fn reasoning_model(model: &str) -> bool {
|
||||
model.starts_with("gpt-5")
|
||||
|| matches!(
|
||||
model,
|
||||
"gpt-6-astra" | "gpt-6.1-sol" | "gpt-6.1-terra" | "gpt-6-sol" | "gpt-6-luna"
|
||||
"gpt-6.2-astra"
|
||||
| "gpt-6.2-sol"
|
||||
| "gpt-6-astra"
|
||||
| "gpt-6.1-sol"
|
||||
| "gpt-6.1-terra"
|
||||
| "gpt-6-sol"
|
||||
| "gpt-6-luna"
|
||||
)
|
||||
|| model.starts_with("o1")
|
||||
|| model.starts_with("o3")
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Responses WebSocket endpoint、opening handshake 与首帧发送
|
||||
//! Responses WebSocket endpoint、opening handshake 与请求发送
|
||||
|
||||
use std::{error::Error as _, io, time::Duration};
|
||||
|
||||
@@ -95,7 +95,7 @@ impl CodexWebSocketConnection {
|
||||
}
|
||||
}
|
||||
|
||||
/// 构造 Responses WebSocket opening 与首个 `response.create` 文本帧
|
||||
/// 构造 Responses WebSocket opening 与首条 `response.create` 消息
|
||||
pub fn responses_create_request(
|
||||
base_url: &str,
|
||||
websocket_key: &str,
|
||||
|
||||
@@ -147,7 +147,7 @@ impl CodexWebSocketRequest {
|
||||
&self.connection
|
||||
}
|
||||
|
||||
/// 返回将要发送的首个文本帧
|
||||
/// 返回将要发送的完整 `response.create` 文本
|
||||
pub fn payload_text(&self) -> &str {
|
||||
&self.payload_text
|
||||
}
|
||||
|
||||
@@ -11,9 +11,13 @@ use std::sync::{
|
||||
};
|
||||
use std::time::Duration;
|
||||
|
||||
use bytes::Bytes;
|
||||
use futures::{Sink, SinkExt, Stream, StreamExt};
|
||||
use tokio::{sync::mpsc, task::JoinHandle, time::Instant};
|
||||
use tokio_tungstenite::tungstenite::Message;
|
||||
use tungstenite::{
|
||||
Message,
|
||||
protocol::frame::{Fragment, Frame, coding::Data},
|
||||
};
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::{
|
||||
@@ -311,7 +315,7 @@ impl PumpedWebSocket {
|
||||
}
|
||||
}
|
||||
|
||||
/// 通过 pump 发送一帧,区分未开始发送与底层传输失败
|
||||
/// 通过 pump 发送一条消息,区分未开始发送与底层传输失败
|
||||
pub(crate) async fn send(&self, message: Message) -> Result<(), CodexWebSocketExchangeError> {
|
||||
if self.is_closed() {
|
||||
return Err(CodexWebSocketExchangeError::SendNotStarted);
|
||||
@@ -613,7 +617,7 @@ async fn handle_command(
|
||||
return None;
|
||||
}
|
||||
let is_close = matches!(message, Message::Close(_));
|
||||
let result = inner.send(message).await;
|
||||
let result = write_message(inner, message).await;
|
||||
let transport_error = result
|
||||
.as_ref()
|
||||
.err()
|
||||
@@ -629,6 +633,31 @@ async fn handle_command(
|
||||
}
|
||||
}
|
||||
|
||||
/// 同一命令内逐帧写完大文本,保持一条消息的压缩上下文和发送回执
|
||||
async fn write_message(
|
||||
inner: &mut RawWsStream,
|
||||
message: Message,
|
||||
) -> Result<(), tungstenite::Error> {
|
||||
const FRAGMENT_BYTES: usize = 1024 * 1024;
|
||||
let mut remaining = match message {
|
||||
Message::Text(text) if text.len() > FRAGMENT_BYTES => Bytes::from(text),
|
||||
other => return inner.send(other).await,
|
||||
};
|
||||
let mut opcode = Data::Text;
|
||||
while !remaining.is_empty() {
|
||||
let payload = remaining.split_to(remaining.len().min(FRAGMENT_BYTES));
|
||||
let fragment = if remaining.is_empty() {
|
||||
Fragment::Final
|
||||
} else {
|
||||
Fragment::More
|
||||
};
|
||||
let frame = Frame::message_fragment(payload, opcode, fragment);
|
||||
inner.send(Message::Frame(frame)).await?;
|
||||
opcode = Data::Continue;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn record_activity(lifecycle: &Mutex<PumpLifecycleState>, observed_at: Instant) {
|
||||
lifecycle
|
||||
.lock()
|
||||
|
||||
@@ -69,7 +69,7 @@ const COMPLETED_SESSION_SSE: &str = concat!(
|
||||
);
|
||||
|
||||
#[tokio::test]
|
||||
async fn plan_display_should_distinguish_pro_tiers_and_preserve_other_official_names() {
|
||||
async fn plan_display_uses_pro_short_names_and_codex_status_labels_for_other_known_plans() {
|
||||
let config = valid_config();
|
||||
let bundle = provider_openai::initialize(
|
||||
config.config.clone(),
|
||||
@@ -86,25 +86,25 @@ async fn plan_display_should_distinguish_pro_tiers_and_preserve_other_official_n
|
||||
("free", "Free"),
|
||||
("go", "Go"),
|
||||
("plus", "Plus"),
|
||||
("team", "Team"),
|
||||
("self_serve_business_prolite", "Self Serve Business ProLite"),
|
||||
(
|
||||
"self_serve_business_usage_based",
|
||||
"Self Serve Business Usage Based",
|
||||
),
|
||||
("business", "Business"),
|
||||
("team", "Business"),
|
||||
("self_serve_business_prolite", "Business Premium"),
|
||||
("self_serve_business_usage_based", "Business"),
|
||||
("business", "Enterprise"),
|
||||
("ent26", "Enterprise"),
|
||||
("enterprise", "Enterprise"),
|
||||
("hc", "Enterprise"),
|
||||
("enterprise_cbp_automation", "Enterprise (Automation)"),
|
||||
("enterprise_cbp_usage_based", "Enterprise CBP Usage Based"),
|
||||
("enterprise_cbp_usage_based", "Enterprise"),
|
||||
("edu", "Edu"),
|
||||
("education", "Edu"),
|
||||
("edu_plus", "Edu Plus"),
|
||||
("edu_pro", "Edu Pro"),
|
||||
("future_plan", "future_plan"),
|
||||
("sci", "Academic Researchers"),
|
||||
("sci_plus", "Academic Researchers Plus"),
|
||||
("SCI_PLUS", "Academic Researchers Plus"),
|
||||
("Future_Plan", "Future_Plan"),
|
||||
] {
|
||||
assert_eq!(admin.plan_type_display(raw), display);
|
||||
assert_eq!(admin.plan_type_display(raw), display, "{raw}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -352,6 +352,33 @@ async fn quota_forecast_observation_reuses_protocol_parser_and_keeps_window_iden
|
||||
.unwrap()
|
||||
.clone(),
|
||||
));
|
||||
let history = provider.quota_history_parser().unwrap();
|
||||
let short = history(&document, "codex:18000s").unwrap();
|
||||
assert_eq!(short.used_percent, 4.0);
|
||||
assert_eq!(short.reset_at.unwrap().timestamp(), 1_789_218_647);
|
||||
assert!(history(&document, "other:18000s").is_none());
|
||||
let named = ProviderDocument::new(OpaqueProviderData::new(
|
||||
json!({
|
||||
"rateLimitHeaders": [
|
||||
["x-codex-primary-used-percent","23"],["x-codex-primary-window-minutes","1"],
|
||||
["x-feature-primary-used-percent","23"],["x-feature-primary-window-minutes","1"],
|
||||
["x-feature-secondary-used-percent","56"],["x-feature-secondary-window-minutes","1"]
|
||||
]
|
||||
})
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.clone(),
|
||||
));
|
||||
assert!(history(&named, "codex:60s").is_none());
|
||||
assert!(history(&named, "feature:60s").is_none());
|
||||
let primary = history(&named, "feature:60s:primary_window").unwrap();
|
||||
assert_eq!((primary.used_percent, primary.reset_at), (23.0, None));
|
||||
assert_eq!(
|
||||
history(&named, "feature:60s:secondary_window")
|
||||
.unwrap()
|
||||
.used_percent,
|
||||
56.0
|
||||
);
|
||||
let observed = provider
|
||||
.quota_forecast_observation(&document, &window)
|
||||
.unwrap();
|
||||
@@ -496,13 +523,18 @@ async fn copying_builtin_prices_keeps_cache_read_and_write_fallback_costs() {
|
||||
for model in [
|
||||
"gpt-4",
|
||||
"gpt-4o",
|
||||
"gpt-6.2-astra",
|
||||
"gpt-6.2-sol",
|
||||
"gpt-6-astra",
|
||||
"gpt-6.1-sol",
|
||||
"gpt-6.1-terra",
|
||||
"gpt-6-sol",
|
||||
"gpt-6-luna",
|
||||
] {
|
||||
let ultrafast_supported = matches!(model, "gpt-6-astra" | "gpt-6.1-sol");
|
||||
let ultrafast_supported = matches!(
|
||||
model,
|
||||
"gpt-6.2-astra" | "gpt-6.2-sol" | "gpt-6-astra" | "gpt-6.1-sol"
|
||||
);
|
||||
for band in ["ultrafast", "long_ultrafast"] {
|
||||
assert_eq!(prices[model].bands.contains_key(band), ultrafast_supported);
|
||||
}
|
||||
|
||||
@@ -738,6 +738,108 @@ async fn invalidation_queues_background_refresh_without_an_upstream_etag() {
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn matching_etag_renews_only_its_account_until_the_next_change_or_expiry() {
|
||||
use gateway_core::account::AccountCatalogObservation;
|
||||
use std::time::{Duration, SystemTime};
|
||||
|
||||
let store = Arc::new(MemoryAccountStore::default());
|
||||
let active = seed_account(&store, "acct_active").await;
|
||||
let idle = seed_account(&store, "acct_idle").await;
|
||||
let document = [&[0_u8][..], OFFICIAL_FIXTURE].concat();
|
||||
let old_tag = r#""v1""#;
|
||||
let new_tag = r#""v2""#;
|
||||
let observed_at = SystemTime::now() - Duration::from_mins(61);
|
||||
for account in [&active, &idle] {
|
||||
assert!(
|
||||
store
|
||||
.save_account_catalog(
|
||||
&AccountCatalogObservation {
|
||||
account_id: account.id().clone(),
|
||||
revision: account.revision(),
|
||||
plan: account.plan_type().map(str::to_owned),
|
||||
observed_at,
|
||||
etag: Some(old_tag.to_owned()),
|
||||
},
|
||||
&document
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
);
|
||||
}
|
||||
let server = MockServer::start().await;
|
||||
for account in [&active, &idle] {
|
||||
Mock::given(method("GET"))
|
||||
.and(path("/codex/models"))
|
||||
.and(header(
|
||||
"chatgpt-account-id",
|
||||
format!("chatgpt-{}", account.id()),
|
||||
))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(200)
|
||||
.insert_header("etag", old_tag)
|
||||
.set_body_raw(OFFICIAL_FIXTURE, "application/json"),
|
||||
)
|
||||
.expect(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
}
|
||||
let service = service_with_catalog_cache(&store, server.uri(), catalog_cache());
|
||||
service.restore().await.unwrap();
|
||||
assert!(!service.observe_response_etag(&active, old_tag).unwrap());
|
||||
service.refresh_catalogs().await.unwrap();
|
||||
let requests = server.received_requests().await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert_eq!(
|
||||
requests[0].headers["chatgpt-account-id"],
|
||||
"chatgpt-acct_idle"
|
||||
);
|
||||
|
||||
tokio::time::pause();
|
||||
tokio::time::advance(Duration::from_mins(59)).await;
|
||||
service.refresh_catalogs().await.unwrap();
|
||||
assert_eq!(server.received_requests().await.unwrap().len(), 1);
|
||||
tokio::time::advance(Duration::from_mins(1)).await;
|
||||
tokio::time::resume();
|
||||
service.refresh_catalogs().await.unwrap();
|
||||
server.verify().await;
|
||||
|
||||
server.reset().await;
|
||||
Mock::given(method("GET"))
|
||||
.and(path("/codex/models"))
|
||||
.and(header("chatgpt-account-id", "chatgpt-acct_active"))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(200)
|
||||
.insert_header("etag", new_tag)
|
||||
.set_body_json(
|
||||
serde_json::json!({"models":[{"slug":"active-only","display_name":"Active"}]}),
|
||||
),
|
||||
)
|
||||
.expect(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
assert!(!service.observe_response_etag(&active, old_tag).unwrap());
|
||||
assert!(
|
||||
service
|
||||
.observe_response_etag(&active, "change-hint")
|
||||
.unwrap()
|
||||
);
|
||||
assert!(!service.observe_response_etag(&active, old_tag).unwrap());
|
||||
service.refresh_catalogs().await.unwrap();
|
||||
assert!(
|
||||
!service
|
||||
.observe_response_etag(&active, "change-hint")
|
||||
.unwrap()
|
||||
);
|
||||
assert!(!service.observe_response_etag(&active, new_tag).unwrap());
|
||||
service.refresh_catalogs().await.unwrap();
|
||||
assert_eq!(
|
||||
service.cached_account_models(&active).unwrap().unwrap(),
|
||||
["active-only"]
|
||||
);
|
||||
server.verify().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn simultaneous_periodic_refreshes_share_the_completed_scan() {
|
||||
let store = Arc::new(MemoryAccountStore::default());
|
||||
|
||||
@@ -48,13 +48,15 @@ fn isolation_payload() -> ProtocolPayload {
|
||||
turn_metadata.insert("parent_response_id".to_owned(), json!("client-correlation"));
|
||||
turn_metadata.insert("workspace".to_owned(), json!("/工作区"));
|
||||
turn_metadata.insert("future".to_owned(), json!({"traceparent":"business-value"}));
|
||||
let mut frame_metadata = turn_metadata.clone();
|
||||
frame_metadata.insert("tool_namespaces_info".into(), json!({"workspace":{}}));
|
||||
let mut body = json!({
|
||||
"model": "gpt-5.4",
|
||||
"input": isolation_history(),
|
||||
"client_metadata": {
|
||||
"parent_response_id": "resp_parent_old",
|
||||
"guardian_credits_requested": "true",
|
||||
"x-codex-turn-metadata": Value::Object(turn_metadata.clone()).to_string(),
|
||||
"x-codex-turn-metadata": Value::Object(frame_metadata).to_string(),
|
||||
"turnMetadata": turn_metadata,
|
||||
"mcp_attribution": r#"{"status":"complete","sources":[]}"#
|
||||
}
|
||||
@@ -86,6 +88,10 @@ fn isolation_payload() -> ProtocolPayload {
|
||||
ProtocolPayload::json_object("openai", body.as_object().unwrap().clone())
|
||||
.unwrap()
|
||||
.with_context(Map::from_iter([
|
||||
(
|
||||
gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY.into(),
|
||||
json!(true),
|
||||
),
|
||||
("opaque_request_headers".to_owned(), json!(headers)),
|
||||
(
|
||||
"turn_metadata".to_owned(),
|
||||
@@ -155,7 +161,6 @@ fn assert_isolated_request(
|
||||
&body["turnMetadata"],
|
||||
&body["turn_metadata"],
|
||||
&body["client_metadata"]["turnMetadata"],
|
||||
&body["client_metadata"]["x-codex-turn-metadata"],
|
||||
] {
|
||||
let actual = match metadata {
|
||||
Value::String(raw) => serde_json::from_str(raw).unwrap(),
|
||||
@@ -163,6 +168,15 @@ fn assert_isolated_request(
|
||||
};
|
||||
assert_eq!(actual, Value::Object(expected_turn_metadata.clone()));
|
||||
}
|
||||
let mut expected_frame_metadata = expected_turn_metadata.clone();
|
||||
expected_frame_metadata.insert("tool_namespaces_info".into(), json!({"workspace":{}}));
|
||||
let frame = body["client_metadata"]["x-codex-turn-metadata"]
|
||||
.as_str()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(frame).unwrap(),
|
||||
Value::Object(expected_frame_metadata)
|
||||
);
|
||||
let header = headers["x-codex-turn-metadata"].to_str().unwrap();
|
||||
assert!(header.is_ascii());
|
||||
assert_eq!(
|
||||
|
||||
@@ -2053,8 +2053,6 @@ async fn provider_should_override_unclassified_time_contexts_over_websocket() {
|
||||
}
|
||||
|
||||
async fn capture_turn_state_request(
|
||||
request_id: &str,
|
||||
previous_turn_id: Option<&str>,
|
||||
current_turn_id: Option<&str>,
|
||||
client_turn_state: Option<&str>,
|
||||
) -> wiremock::Request {
|
||||
@@ -2072,18 +2070,19 @@ async fn capture_turn_state_request(
|
||||
.expect(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let mut session_state = Map::from_iter([
|
||||
let session_state = Map::from_iter([
|
||||
("account_id".to_owned(), json!(account_id)),
|
||||
("conversation_id".to_owned(), json!("conversation")),
|
||||
("turn_state".to_owned(), json!("previous-turn-state")),
|
||||
("client_turn_id".to_owned(), json!("turn-same")),
|
||||
("continuation_scope".to_owned(), json!("persisted")),
|
||||
]);
|
||||
if let Some(previous_turn_id) = previous_turn_id {
|
||||
session_state.insert("client_turn_id".to_owned(), json!(previous_turn_id));
|
||||
}
|
||||
let mut protocol_context = Map::from_iter([("use_websocket".to_owned(), json!(false))]);
|
||||
if let Some(current_turn_id) = current_turn_id {
|
||||
protocol_context.insert("turn_id".to_owned(), json!(current_turn_id));
|
||||
protocol_context.insert(
|
||||
"turn_metadata".to_owned(),
|
||||
Value::String(json!({"turn_id": current_turn_id}).to_string()),
|
||||
);
|
||||
}
|
||||
if let Some(client_turn_state) = client_turn_state {
|
||||
protocol_context.insert("turn_state".to_owned(), json!(client_turn_state));
|
||||
@@ -2095,6 +2094,7 @@ async fn capture_turn_state_request(
|
||||
let mut body = Map::from_iter([
|
||||
("model".to_owned(), json!("gpt-5.4")),
|
||||
("input".to_owned(), json!("current input")),
|
||||
("previous_response_id".to_owned(), json!("resp_previous")),
|
||||
("client_metadata".to_owned(), json!({"custom":"preserved"})),
|
||||
]);
|
||||
if let Some(state) = client_turn_state {
|
||||
@@ -2119,7 +2119,7 @@ async fn capture_turn_state_request(
|
||||
let mut stream = provider_with_base_url(&store, server.uri())
|
||||
.execute(
|
||||
planned_request("openai", operation),
|
||||
context(request_id, CancellationToken::new()),
|
||||
context("req_client_turn_state", CancellationToken::new()),
|
||||
)
|
||||
.await
|
||||
.expect("prepare turn-state provider stream");
|
||||
@@ -7093,78 +7093,29 @@ async fn missing_affinity_full_request_should_preserve_client_turn_state() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn matching_turn_id_should_restore_previous_turn_state() {
|
||||
let request = capture_turn_state_request(
|
||||
"req_restore_same_turn_state",
|
||||
Some("turn-same"),
|
||||
Some("turn-same"),
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_eq!(
|
||||
captured_header_values(&request, "x-codex-turn-state"),
|
||||
vec![b"previous-turn-state".to_vec()]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn matching_turn_id_should_prefer_an_explicit_client_echo_over_saved_provider_state() {
|
||||
let request = capture_turn_state_request(
|
||||
"req_use_client_turn_state",
|
||||
Some("turn-same"),
|
||||
Some("turn-same"),
|
||||
Some("client-turn-state"),
|
||||
)
|
||||
.await;
|
||||
|
||||
assert_eq!(
|
||||
captured_header_values(&request, "x-codex-turn-state"),
|
||||
vec![b"client-turn-state".to_vec()]
|
||||
);
|
||||
let body = captured_request_body(&request);
|
||||
for key in ["turnState", "turn_state", "x-codex-turn-state"] {
|
||||
assert_eq!(body[key], "client-turn-state");
|
||||
assert_eq!(body["client_metadata"][key], "client-turn-state");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn new_or_unidentified_turn_should_not_restore_previous_turn_state() {
|
||||
for (request_id, previous_turn_id, current_turn_id, client_turn_state) in [
|
||||
(
|
||||
"req_new_turn_state",
|
||||
Some("turn-old"),
|
||||
Some("turn-new"),
|
||||
Some("stale-client-turn-state"),
|
||||
),
|
||||
(
|
||||
"req_unidentified_turn_state",
|
||||
None,
|
||||
Some("turn-new"),
|
||||
Some("stale-client-turn-state"),
|
||||
),
|
||||
(
|
||||
"req_missing_current_turn_state",
|
||||
Some("turn-old"),
|
||||
None,
|
||||
Some("stale-client-turn-state"),
|
||||
),
|
||||
async fn same_account_continuation_forwards_only_the_current_request_turn_state() {
|
||||
// 旧版会话中可能仍有保存的轮次和 token
|
||||
for (turn, supplied) in [
|
||||
(Some("turn-same"), None),
|
||||
(Some("turn-same"), Some("client-turn-state")),
|
||||
(Some("turn-new"), Some("client-turn-state")),
|
||||
(None, Some("client-turn-state")),
|
||||
] {
|
||||
let request = capture_turn_state_request(
|
||||
request_id,
|
||||
previous_turn_id,
|
||||
current_turn_id,
|
||||
client_turn_state,
|
||||
)
|
||||
.await;
|
||||
assert!(captured_header_values(&request, "x-codex-turn-state").is_empty());
|
||||
let request = capture_turn_state_request(turn, supplied).await;
|
||||
let headers = captured_header_values(&request, "x-codex-turn-state");
|
||||
assert_eq!(
|
||||
headers,
|
||||
supplied
|
||||
.map(|value| value.as_bytes())
|
||||
.into_iter()
|
||||
.collect::<Vec<_>>()
|
||||
);
|
||||
let body = captured_request_body(&request);
|
||||
for key in ["turnState", "turn_state", "x-codex-turn-state"] {
|
||||
assert!(body.get(key).is_none(), "stale body state: {key}");
|
||||
assert!(
|
||||
body["client_metadata"].get(key).is_none(),
|
||||
"stale metadata state: {key}"
|
||||
assert_eq!(body.get(key).and_then(Value::as_str), supplied);
|
||||
assert_eq!(
|
||||
body["client_metadata"].get(key).and_then(Value::as_str),
|
||||
supplied
|
||||
);
|
||||
}
|
||||
assert_eq!(body["input"][0]["content"][0]["text"], "current input");
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user