Compare commits

..
14 Commits
Author SHA1 Message Date
ZyyandCodex ba8745a714 chore: bump version to 3.52.0
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 12:33:24 +08:00
84bcd0e1c0 feat(usage): filter request records by account name or email (#735)
Co-authored-by: Zyy <zyycn@users.noreply.github.com>
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 11:51:02 +08:00
ZyyandCodex 7459c16a3a docs(deploy): specify minimum PostgreSQL version
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 11:41:32 +08:00
ZyyandCodex 3b4fb390c7 fix(ci): allowlist the unpatched picomatch advisory
Co-authored-by: Codex <noreply@openai.com>
2026-11-18 11:03:02 +08:00
ZyyandCodex bb440a3cbb feat(usage): add GPT-6.2 list prices and distinguish Ultrafast requests
Use regular Ultrafast rates for Astra and Sol. Show a double bolt for Ultrafast requests and remove backgrounds from error origin icons.

Co-authored-by: Codex <noreply@openai.com>
2026-11-18 10:55:09 +08:00
github-actions[bot] 89b6d2256f chore(release): update release channels to 3.51.0 2026-11-17 11:01:29 +00:00
ZyyandCodex ba2afe67d0 chore: bump version to 3.51.0
Co-authored-by: Codex <noreply@openai.com>
2026-11-17 18:43:26 +08:00
ZyyandCodex 976359ad26 fix(openai): explain strict session timeouts for ineligible accounts
Report when the bound account cannot use the requested model while a child waits for its parent to switch accounts. Keep the existing queue timeout code and strict affinity behavior.

Refs: #732

Co-authored-by: Codex <noreply@openai.com>
2026-11-17 17:23:16 +08:00
ZyyandCodex 832858dade feat(plugins): expose historical quota observations by window
Let plugins page through retained account observations and find a prior baseline without reading raw provider documents or refreshing upstream. Reuse provider window identities and the existing completion index, preserving resets and gaps.

Co-authored-by: Codex <noreply@openai.com>
2026-11-17 17:06:55 +08:00
ZyyandCodex 4d4c1e48ce feat(plugins)!: expose account binding and selection roles to schedulers
Scheduler v4 reports session ownership separately from native selection preferences and pins. Only eligible candidates are annotated, and cache preferences do not imply a session binding.

BREAKING CHANGE: scheduler plugins must declare capability version 4 and accept the new candidate fields.

Co-authored-by: Codex <noreply@openai.com>
2026-11-17 16:48:06 +08:00
ZyyandCodex 9f873f5ac2 fix(ui): narrow the key usage model filter
Co-authored-by: Codex <noreply@openai.com>
2026-11-17 14:23:32 +08:00
ZyyandCodex 4bc59f32a1 feat(ui): adopt shared action menus and refine quota settings
Pin UI v0.12.0 and use its keyboard-accessible menus for account, API key and proxy actions. Keep quota validation on submit and align a compact inline warmup switch with each bucket title.

Co-authored-by: Codex <noreply@openai.com>
2026-11-17 12:21:15 +08:00
ZyyandCodex 4c5d2bc97e docs: streamline project skills and clarify review and reply guidance
Co-authored-by: Codex <noreply@openai.com>
2026-11-17 12:21:15 +08:00
github-actions[bot] 5033d9f19a chore(release): update release channels to 3.50.0 2026-11-16 11:59:49 +00:00
102 changed files with 1479 additions and 470 deletions
+13 -15
View File
@@ -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 条件按该节执行
+8 -18
View File
@@ -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
+3 -10
View File
@@ -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` 发布对应内容;
+2 -6
View 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 和镜像已生成也不表示用户的运行实例已经升级。
+1 -1
View File
@@ -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
View File
@@ -21,17 +21,11 @@
### GitHub 回复口吻
AI 草拟、发布或修改 Issue、PR 讨论及审查意见的回复时,以一起排查问题、讨论方案的口吻交流:
Issue 和 PR 回帖直接回应对方遇到的问题,有不同意见时结合具体场景说明理由。语气自然、委婉,用短句,少用句号。说明个人判断或行动时用“我”,确需提问时称呼一次“佬”
- 围绕问题、事实和结论展开,能自然省略主语时省略;需要说明个人判断或行动归属时用“我”,避免反复以“我”起句或强调自己,不用“我们”“本助手”代称自己
- 普通回复直接回应问题,不加问候语或称呼;向对方提问时称呼“佬”,同一条回复不重复称呼
- 先接住对方想完成的事和遇到的困难,再给出核实结果与建议;回复让对方感到问题被理解、有下一步可做,避免一上来归类、纠正或划定责任
- 给出操作建议时说明它能帮助判断什么,措辞自然、委婉,不靠堆叠缓和词修饰命令
- 回应已有能力、暂不支持或未采纳的建议时,结合场景说明可用入口或具体原因,有可行替代办法时一并说明,再交代必要边界;避免只回复“已有功能”“重复问题”“不在范围内”等结论
- 需要补充材料或配合操作时,先利用已有信息,只询问仍缺少的部分,说明用途和最小范围;例如“佬,方便再观察几次吗?如果还出现,可以附一下对应请求的诊断包,便于对照终态用量”
- 澄清误解或提出不同意见时,从观察和依据说起,照顾对方的使用环境与理解路径,避免责备、反问或居高临下的判断;已确认的事实保持明确,尚未确认的原因保留余地
- 使用自然短句,简单回复用短段,并列信息较多时再分点;少用句号,避免客服套话、机械模板和空泛保证
- 排查、复现、修改和验证的完成状态与实际一致;未采纳的意见说明依据,未确认、待处理或未验证的内容如实交代,说清结论、限制和下一步
- 用法问题给出操作入口,功能取舍或关闭 Issue 说明与该场景相关的原因,有可行替代办法时再提。问题已答清即可结束
- 排障先看原帖、已有材料和自己能核实的实现或发布记录。回复只附有助于理解结论或采取行动的排查信息,如相关版本、复现结果或脱敏片段。区分推测和实测
- 只有缺失信息会改变判断或处理方式,且只能由对方提供时才追问。说清需要哪一项、用来区分什么情况
## 问题与方案依据
@@ -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()
@@ -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());
}
@@ -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
@@ -2352,6 +2352,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",
+1 -1
View File
@@ -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(),
@@ -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 {
@@ -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(),
})
}
@@ -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(&quota)
.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(&quota_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")]
@@ -818,6 +818,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,
@@ -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")
@@ -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);
}
@@ -1,6 +1,7 @@
//! 验证会话主账号偏好、严格绑定、最终请求身份与轮次关联
use super::*;
use gateway_core::engine::policy::AccountScheduleRole;
#[tokio::test]
async fn session_affinity_storage_tolerates_delays_but_rejects_expired_requests_before_sending() {
@@ -852,6 +853,10 @@ async fn child_queue_timeout_does_not_rebind_or_allow_provider_fallback() {
.err()
.expect("queue timeout");
assert_eq!(error.kind(), ProviderErrorKind::ConcurrencyQueueTimeout);
assert_eq!(
gateway_core::error::GatewayError::from_provider(&error).client_message(),
"Request queue wait timed out."
);
assert!(error.retry_is_prohibited());
assert_eq!(affinity.binding_count(), 1);
assert!(server.received_requests().await.unwrap().is_empty());
@@ -859,6 +864,7 @@ async fn child_queue_timeout_does_not_rebind_or_allow_provider_fallback() {
#[derive(Debug)]
struct SessionScheduler {
expected_owner: (bool, AccountScheduleRole),
decision: gateway_core::engine::policy::AccountScheduleDecision,
}
impl gateway_core::engine::policy::RequestPolicyPlan for SessionScheduler {
@@ -884,12 +890,17 @@ impl gateway_core::engine::policy::RequestPolicyPlan for SessionScheduler {
gateway_core::engine::policy::RequestPolicyFault,
>,
> {
assert!(
input
for (id, (bound, role)) in [
("acct_subagent_a", self.expected_owner),
("acct_subagent_b", (false, AccountScheduleRole::Ordinary)),
] {
let candidate = input
.candidates()
.iter()
.any(|candidate| candidate.account_id().as_str() == "acct_subagent_b")
);
.find(|candidate| candidate.account_id().as_str() == id)
.unwrap();
assert_eq!((candidate.session_bound(), candidate.role()), (bound, role));
}
let decision = self.decision.clone();
Box::pin(async move { Ok(decision) })
}
@@ -902,15 +913,20 @@ impl gateway_core::routing::extensions::ExtensionSetLease for SessionExtensionLe
}
#[tokio::test]
async fn child_binding_respects_filtered_delegation_and_explicit_plugin_choices() {
async fn scheduler_distinguishes_session_bindings_from_cache_preferences_and_keeps_native_selection()
{
use AccountScheduleRole::{FollowOnly, Ordinary, Preferred};
use gateway_core::account::AccountAffinity;
use gateway_core::engine::policy::RequestPolicyContext;
use gateway_core::routing::extensions::{ExtensionSetId, ExtensionSetReference};
for (choice, mode) in [
("delegate", AccountAffinity::Strict),
("pick", AccountAffinity::Strict),
("filter", AccountAffinity::Strict),
("filter", AccountAffinity::Preferred),
for (choice, mode, expected_owner) in [
("delegate", AccountAffinity::Strict, (true, FollowOnly)),
("pick", AccountAffinity::Strict, (true, FollowOnly)),
("filter", AccountAffinity::Strict, (true, FollowOnly)),
("filter", AccountAffinity::Preferred, (true, Preferred)),
("filter", AccountAffinity::Relaxed, (true, Ordinary)),
("cache", AccountAffinity::Preferred, (false, Preferred)),
("new", AccountAffinity::Preferred, (false, Ordinary)),
] {
let store = Arc::new(MemoryAccountStore::default());
create_account(&store, "acct_subagent_a").await;
@@ -923,11 +939,27 @@ async fn child_binding_respects_filtered_delegation_and_explicit_plugin_choices(
server.uri(),
leases.clone(),
);
let cache_request = || {
let payload = ProtocolPayload::json_object(
"openai",
json!({"prompt_cache_key": "shared", "input": "hello"})
.as_object()
.unwrap()
.clone(),
)
.unwrap();
Operation::Generate(GenerateRequest::from_protocol_payload(payload))
};
let seed = if choice == "cache" {
cache_request()
} else {
turn_request("root", "root-turn")
};
drop(
provider
.clone()
.execute(
planned_request("openai", turn_request("root", "root-turn")),
planned_request("openai", seed),
context("req_plugin_root", CancellationToken::new()),
)
.await
@@ -943,11 +975,12 @@ async fn child_binding_respects_filtered_delegation_and_explicit_plugin_choices(
let key = ClientApiKeyId::new("key_openai_contract").unwrap();
let policy = RequestPolicyContext::new(
Arc::new(SessionScheduler {
expected_owner,
decision: match choice {
"pick" => gateway_core::engine::policy::AccountScheduleDecision::Pick(
ProviderAccountId::new("acct_subagent_b").unwrap(),
),
"filter" => {
"filter" | "cache" | "new" => {
gateway_core::engine::policy::AccountScheduleDecision::DelegateFiltered(
BTreeSet::from([ProviderAccountId::new("acct_subagent_a").unwrap()]),
)
@@ -976,7 +1009,15 @@ async fn child_binding_respects_filtered_delegation_and_explicit_plugin_choices(
let mut pending = Box::pin(provider.clone().execute(
planned_request(
"openai",
Operation::Generate(generate_with_session_context("root", Some("child"), None)),
match choice {
"cache" => cache_request(),
"new" => turn_request("separate-session", "separate-turn"),
_ => Operation::Generate(generate_with_session_context(
"root",
Some("child"),
None,
)),
},
),
attempt,
));
@@ -991,7 +1032,7 @@ async fn child_binding_respects_filtered_delegation_and_explicit_plugin_choices(
error.send_state(),
gateway_core::upstream::UpstreamSendState::NotSent
);
} else if choice == "pick" || choice == "filter" {
} else if choice != "delegate" {
let stream = timeout(Duration::from_secs(2), pending)
.await
.unwrap()
@@ -1406,26 +1447,31 @@ async fn relaxed_and_preferred_session_requests_apply_distinct_scheduling_polici
}
#[tokio::test]
async fn preferred_child_can_claim_without_a_root_and_model_access_can_split_accounts() {
async fn child_model_mismatch_waits_for_the_parent_or_splits_by_affinity_mode() {
use gateway_core::account::{AccountModelAccess, AccountModelAccessMode};
let store = Arc::new(MemoryAccountStore::default());
create_account(&store, "acct_subagent_a").await;
let affinity = Arc::new(MemorySessionAffinity::default());
let provider = provider_with_affinity(&store, affinity.clone());
let select = |thread, model: &'static str, scope| {
let preferred = |scope| preferred_context("req_preferred_model", scope);
let select = |thread, model: &'static str, attempt| {
provider.clone().execute(
planned_request_for_model(
"openai",
Operation::Generate(generate_with_session_context("root", Some(thread), None)),
model,
),
preferred_context("req_preferred_model", scope),
attempt,
)
};
drop(
select("early-child", "gpt-5.4", contract_account_scope())
.await
.unwrap(),
select(
"early-child",
"gpt-5.4",
preferred(contract_account_scope()),
)
.await
.unwrap(),
);
assert_eq!(
affinity.binding_count(),
@@ -1433,7 +1479,7 @@ async fn preferred_child_can_claim_without_a_root_and_model_access_can_split_acc
"the first session request claims the shared primary"
);
drop(
select("root", "gpt-5.4", contract_account_scope())
select("root", "gpt-5.4", preferred(contract_account_scope()))
.await
.unwrap(),
);
@@ -1463,7 +1509,44 @@ async fn preferred_child_can_claim_without_a_root_and_model_access_can_split_acc
Arc::new(directory),
ClientRoutingScope::all_accounts(),
));
let child = select("model-child", "gpt-5.5", scope.clone())
for (scope, reason) in [
(
scope.clone(),
"The parent session's account does not allow the requested model.",
),
(
Arc::new(scope.excluding_account(ProviderAccountId::new("acct_subagent_a").unwrap())),
"The parent session's account cannot serve this request.",
),
] {
let strict = context_with_affinity_policy(
"req_strict_model",
scope,
account_policy().with_queue(gateway_core::concurrency::ConcurrencyQueuePolicy {
max_waiting: 1,
timeout: Duration::from_millis(120),
}),
);
let error = select("model-child", "gpt-5.5", strict)
.await
.err()
.expect("strict child waits for the parent to switch accounts");
assert_eq!(error.kind(), ProviderErrorKind::ConcurrencyQueueTimeout);
assert!(error.retry_is_prohibited());
let gateway = gateway_core::error::GatewayError::from_provider(&error);
assert_eq!(
gateway.client_message(),
format!("{reason} Timed out waiting for the session to switch accounts.")
);
assert!(
error
.error_details()
.unwrap()
.contains(gateway.client_message())
);
}
let child = select("model-child", "gpt-5.5", preferred(scope.clone()))
.await
.unwrap();
assert_eq!(
@@ -1472,7 +1555,7 @@ async fn preferred_child_can_claim_without_a_root_and_model_access_can_split_acc
);
drop(child);
assert_eq!(
select("root", "gpt-5.4", scope)
select("root", "gpt-5.4", preferred(scope))
.await
.unwrap()
.metadata()
@@ -546,6 +546,8 @@ fn decoder_should_use_non_reasoning_preview_web_search_price() {
fn gpt_6_decoders_should_use_reasoning_preview_web_search_price() {
let tools = vec![json!({ "type": "web_search_preview" })];
for model in [
"gpt-6.2-astra",
"gpt-6.2-sol",
"gpt-6-astra",
"gpt-6.1-sol",
"gpt-6.1-terra",
@@ -82,6 +82,28 @@ fn astra_billing_should_preserve_components_across_tiers_and_context_boundary()
fn gpt_6_models_should_use_published_prices_across_tiers_and_context_boundary() {
// 每档依次核对每百万 Token 的输入、缓存读取、缓存写入和输出价格
for (model, cases) in [
(
"gpt-6.2-astra",
[
(None, 272_000, ["8", "0.4", "10", "40"]),
(None, 272_001, ["16", "0.8", "20", "60"]),
(Some("fast"), 272_000, ["16", "0.8", "20", "80"]),
(Some("priority"), 272_001, ["32", "1.6", "40", "120"]),
(Some("ultrafast"), 272_000, ["48", "2.4", "60", "240"]),
(Some("ultrafast"), 272_001, ["96", "4.8", "120", "360"]),
],
),
(
"gpt-6.2-sol",
[
(None, 272_000, ["2", "0.1", "2.5", "10"]),
(None, 272_001, ["4", "0.2", "5", "15"]),
(Some("fast"), 272_000, ["4", "0.2", "5", "20"]),
(Some("priority"), 272_001, ["8", "0.4", "10", "30"]),
(Some("ultrafast"), 272_000, ["12", "0.6", "15", "60"]),
(Some("ultrafast"), 272_001, ["24", "1.2", "30", "90"]),
],
),
(
"gpt-6.1-sol",
[
@@ -457,6 +479,10 @@ fn billing_should_not_inherit_prices_for_unknown_models_or_tiers() {
("gpt-5.5-cyber", 272_001, None),
("gpt-5.6-cyber", 1, Some("fast")),
("gpt-5.3-codex", 1, Some("flex")),
("gpt-6.2-astra", 1, Some("flex")),
("gpt-6.2-astra", 272_001, Some("flex")),
("gpt-6.2-sol", 1, Some("flex")),
("gpt-6.2-sol", 272_001, Some("flex")),
("gpt-6-astra", 1, Some("auto")),
("gpt-6-astra", 1, Some("future")),
("gpt-6.1-terra", 1, Some("ultrafast")),
@@ -11,7 +11,7 @@ use gateway_core::account::{
QuotaEvidence, QuotaState,
};
use gateway_core::concurrency::{CapacityWait, ConcurrencyQueuePolicy, ConcurrencyWaitQueue};
use gateway_core::engine::policy::AccountPolicyError;
use gateway_core::engine::policy::{AccountPolicyError, AccountScheduleOwnership};
use gateway_core::provider_ports::{
ProviderCooldown, ProviderCooldownPort, ProviderCooldownScope, ProviderLeaseAcquisition,
ProviderLeasePort, ProviderLeaseRequest, ProviderSchedulingLeaseRequest,
@@ -325,6 +325,10 @@ impl GrokAccountSessionSelector {
Some(request.upstream_model().as_str()),
&candidates,
&mut context,
AccountScheduleOwnership {
pinned_account: request.required_account(),
..Default::default()
},
)
.await
}
@@ -334,7 +334,16 @@ async fn filtered_scheduling_covers_lease_retry_waiting_and_pinned_terminal_reje
assert!(leases.acquired.lock().unwrap().is_empty());
assert_eq!(transport.calls.load(Ordering::SeqCst), 0);
if mode == "pin" {
assert_eq!(seen.lock().unwrap()[0].candidates().len(), 1);
let seen = seen.lock().unwrap();
let [owner] = seen[0].candidates() else {
panic!("native continuation must have one visible owner");
};
assert_eq!(owner.account_id(), &account_id("filter-a"));
assert_eq!(
owner.role(),
gateway_core::engine::policy::AccountScheduleRole::Pinned
);
assert!(!owner.session_bound());
}
} else {
let stream = result.expect("allowed account");
+4 -2
View File
@@ -223,6 +223,8 @@ docker compose -f deploy/compose.yaml stats --no-stream
## 部署结构
PostgreSQL 最低版本为 16,默认 Compose 使用 PostgreSQL 18
```mermaid
flowchart LR
Client[客户端 / 管理浏览器] -->|HTTPS| Proxy[反向代理]
@@ -320,7 +322,7 @@ store:
## Windows 二进制部署
发行包提供 Windows x64(`windows_amd64`)和 ARM64(`windows_arm64`)版本,按运行机器的 CPU 架构选择。
需先准备可访问的 PostgreSQL 和 Redis,创建数据库及用户;使用数据库备份功能时,还需将匹配服务端版本的 `pg_dump` 加入 `PATH`
需先按[数据库版本要求](#部署结构)准备 PostgreSQL,创建数据库及用户,并确保 Redis 可访问。使用数据库备份功能时,还需将匹配服务端版本的 `pg_dump` 加入 `PATH`
从 [Release 附件](https://github.com/zyycn/codex-proxy-rs/releases) 下载对应的
`codex-proxy-rs_<version>_windows_<arch>.tar.gz`,解压后保留 `codex-proxy-rs.exe`、`web/dist`、`deploy` 和 `plugins/official` 的目录关系。
@@ -964,7 +966,7 @@ exp 不进入正式版、alpha、beta 或 rc,普通实例也不能选择 Exp
其他通道的版本及发布说明,手动检查显示“当前没有可用更新”。检查失败单独报告,不能当作没有更新
alpha、beta、rc、exp 在 GitHub 标记为 Pre-release,不覆盖 GitHub Latest 或镜像 `latest`。
升级前核对目标版本的数据库要求;可连续升级的发行线与约束见[迁移冻结规则](../backend/migrations/README.md#冻结规则)
升级前确认 PostgreSQL 满足目标版本的[部署要求](#部署结构)。可连续升级的发行线与约束见[迁移冻结规则](../backend/migrations/README.md#冻结规则)
### 管理端在线更新
+7 -5
View File
@@ -2108,7 +2108,8 @@ OpenAI Key 的 `installationSeed` 接受带连字符的 UUID,保存时规范
运行设置可以分别启用 Key 与账号的有界排队。Key 并发满时按 Key 等待;OpenAI 优先亲和下会话请求优先主账号,
繁忙时先按调度策略选择可用账号,临时分流不改写会话绑定;没有可立即使用的账号时才按配置排队。严格亲和下已有绑定的后代线程只等待当前会话账号,
根线程迁移后跟随新账号。绑定缺失时,任何有可靠会话身份的请求都可按调度策略原子首绑,后续请求沿用该绑定
根线程迁移后跟随新账号。子线程因绑定账号的模型权限受限而等待换号时,超时提示会指出模型限制,错误码仍为 `concurrency_queue_timeout`。
绑定缺失时,任何有可靠会话身份的请求都可按调度策略原子首绑,后续请求沿用该绑定
严格亲和下的后代线程始终启用账号排队,沿用 `accountQueueTimeoutSeconds` 和请求截止时间;
`maxWaitingPerAccount` 为 0 时使用每队列 1,000 人上限,否则沿用配置的上限。
@@ -2419,7 +2420,8 @@ Token,范围 0~1000000、最多四位小数。`"0"` 表示免费,缺少整
`bands` 可用键为 `standard`、`fast`、`ultrafast`、`flex`、`long_standard`、`long_fast`、`long_ultrafast`、`long_flex`、`image`。
OpenAI 长上下文为输入超过 272000 Token,xAI 为输入达到 200000 Token;仍按 Provider 支持的
模型与服务档位判断是否能估算。OpenAI 内置 Ultrafast 价目覆盖 `gpt-6-astra` 与 `gpt-6.1-sol`。
模型与服务档位判断是否能估算。OpenAI 内置 Ultrafast 价目覆盖 `gpt-6-astra`、`gpt-6.1-sol`、
`gpt-6.2-astra` 和 `gpt-6.2-sol`,均按对应上下文标准价的 6 倍估算。
xAI 不接受 `flex`、`long_flex`、`ultrafast`、`long_ultrafast`、`image`。图像端点的 `standard`
用于文本输入,`image` 用于图像 Token;不能用文本输出单价替代图像输出单价。用量无法完整拆分时不估算
@@ -2788,7 +2790,7 @@ Dashboard 的 `accountUsage[]` 返回稳定指标 `metric=requests|tokens`、可
Dashboard 默认 `period=today`,用量、诊断和错误查询默认 `period=7d`,范围参数遵循[页面时间合同](#页面时间合同)。
Dashboard 返回原始 `asOf` 及 `asOfDisplay`,作为当前数据的查询锚点
请求明细列表接受 `currentPage`、`pageSize`、时间范围、`provider`、`clientApiKeyName`、`accountName`、`model` 和 `status`。
请求明细列表接受 `currentPage`、`pageSize`、时间范围、`provider`、`clientApiKeyName`、`accountSearch`、`model` 和 `status`。
汇总和洞察接受时间范围与 `provider`;性能和成本另要求 `metric`,诊断另接受 `dimension`、`model` 和 `statusCode`。
各接口拒绝未知参数,明细筛选不改变顶部统计范围
@@ -2858,8 +2860,8 @@ HTTP SSE 请求可能在返回 HTTP 200 后流内失败;WebSocket 已升级时
管理端请求列表与详情保留 `requestedModel`(客户端请求)与 `upstreamModel`(网关发送)
请求明细的 `clientApiKeyName`、`accountName` 按字面量包含匹配请求保存的历史名称快照,区分大小写,
不解析为 ID,也不依赖当前配置是否存在。`model` 按字面量包含匹配请求模型或上游模型,`%`、`_` 和 `\` 按普通字符处理
请求明细的 `clientApiKeyName` 匹配 Key 名称,`accountSearch` 匹配账号名称或邮箱。
这些筛选仅使用历史快照,可与时间、状态等条件组合。`model` 匹配请求模型或上游模型。以上文本筛选均按区分大小写的字面量包含匹配,`%`、`_` 和 `\` 按普通字符处理
运维错误列表的 `search` 使用字面量包含匹配,`%`、`_` 和 `\` 按普通字符处理,不支持密钥值或可见前缀搜索。
请求详情通过 `/api/admin/usage/records/detail?id=...` 查询
+3 -1
View File
@@ -1175,7 +1175,9 @@ Admin 按卡片与所选指标向 Store 请求计数、金额或分布,缓存
预测数值复用统计投影的十五分钟开始时间桶,并以账号与五分钟完成时间桶分组。
完整完成时间桶合并累计量,跨采样截止值的小桶、开始时间边界和重建区间读取窄事实;
同一快照撤销待投影旧版本并加入当前源版本。预测采样保留请求完成状态,不按恢复标记排除请求;其他业务统计排除恢复请求。
Provider 文档按账号和完成时间索引读取,每个采样槽只保留最后一份
Provider 文档按账号和完成时间索引读取,预测每个采样槽只保留最后一份。
插件的[额度历史查询](../backend/crates/gateway-plugin/sdk/docs/capabilities.md#基础事实)沿同一索引分页,由 Provider 解释所选窗口;
它保留重置前后的读数,不计算预测或累计消耗
### 请求记录与交付
+2 -3
View File
@@ -41,12 +41,11 @@
- **先沿用已有设计**:先看原页面和最接近的同类实现,复用布局、控件、操作位置与状态展示,新增能力优先融入原有操作路径
只有现有设计无法承载本次任务时才改变结构,并说明具体问题,不以个人审美或设计技能中的通用建议为由重做页面
- **按作用范围摆放操作**,例如单行操作沿用表格已有的行操作区,整表操作沿用列表工具栏。同层内容沿用相邻区域的对齐边线,同组控件保持一致的间距,换行后仍能看出标签、控件与操作的对应关系
- **页面文案言简意赅**,控件含义清楚就省去说明。必要的限制、失败原因和操作后果就近简述,用法和示例放在文档中
- **文案不使用句号和分号**:自行编写的标题、标签、按钮、表单帮助、空状态、提示和错误文案不使用 `。`、句末 `.`、`;` 或 `;`,优先写成短语或简短分句
需要表达多个要点时,按内容关系拆成字段、短行或列表,不把长段落机械替换成逗号串
这项约定针对界面文案,URL、版本号、小数、代码、原始日志和用户输入保留原样
- **页面直显以简洁为主**:标题、标签、按钮使用简短明确的名称或动作,说明只补必要信息,不重复标题、字段值和操作已能表达的内容,不同时用多种说明形式解释同一事实
页面保留当前决策必需的短提示,详细规则、背景原因、示例和低频帮助优先收进已有 Popover 或就近的帮助入口,不把实现细节写成用户教程
重要说明可以在 Popover 中展开,但影响当前选择的关键限制、错误原因和不可逆后果需在操作处保留简明提示,不能全部藏起来
- **按内容选择提示方式**:Tooltip 用于短名称或单句补充,Popover 用于需要阅读、多段说明或含链接的内容,复用项目现有组件
帮助入口需可识别、可通过键盘和触屏打开,图标提供可访问名称,不依赖悬停才能读到必要内容
- **避免大字报**:不堆叠超大标题、口号、整屏介绍、重复副标题或大段说明卡片,页面尽快进入数据、筛选和操作
+1 -1
View File
@@ -17,7 +17,7 @@
},
"dependencies": {
"@boxicons/vue": "1.0.1",
"@codex-proxy/ui": "github:zyycn/codex-proxy-ui#v0.11.0",
"@codex-proxy/ui": "github:zyycn/codex-proxy-ui#v0.12.0",
"@fontsource-variable/inter": "^5.3.0",
"@fontsource-variable/jetbrains-mono": "^5.3.0",
"@lucide/vue": "^1.73.0",
+6 -6
View File
@@ -195,8 +195,8 @@ importers:
specifier: 1.0.1
version: 1.0.1(vue@3.5.45(typescript@6.0.3))
'@codex-proxy/ui':
specifier: github:zyycn/codex-proxy-ui#v0.11.0
version: https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/68458e62e7fb9fadbacea75ce48522f2ba85b8b2(axios@1.21.1(debug@4.4.3))(change-case@5.4.4)(jiti@2.7.0)(postcss@8.5.30)(vite@8.3.8(@types/node@26.6.6)(jiti@2.7.0)(yaml@2.9.0))(vue@3.5.45(typescript@6.0.3))(yaml@2.9.0)
specifier: github:zyycn/codex-proxy-ui#v0.12.0
version: https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/8ffe8a2386603961f48e7fb12ba03be7a81539ec(axios@1.21.1(debug@4.4.3))(change-case@5.4.4)(jiti@2.7.0)(postcss@8.5.30)(vite@8.3.8(@types/node@26.6.6)(jiti@2.7.0)(yaml@2.9.0))(vue@3.5.45(typescript@6.0.3))(yaml@2.9.0)
'@fontsource-variable/inter':
specifier: ^5.3.0
version: 5.3.0
@@ -456,9 +456,9 @@ packages:
resolution: {integrity: sha512-dlT1m5e/0yUL0kRNcQn7yGLVThkgbB0Ga/1AmfDDC/8ik6AIiSf2QLQO2zPYvefsHP0aFgxO93cVLCCfDp7kzQ==}
engines: {node: '>= 20.12.0'}
'@codex-proxy/ui@https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/68458e62e7fb9fadbacea75ce48522f2ba85b8b2':
resolution: {gitHosted: true, integrity: sha512-VSw6WQntuIQmVLY1uMCouUKYbUZyzT4zDmA7CJ/fWT/yBZwvaH+i16SAp++twYYIvKwYMBR6WmNlV7RA6zXKOw==, tarball: https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/68458e62e7fb9fadbacea75ce48522f2ba85b8b2}
version: 0.11.0
'@codex-proxy/ui@https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/8ffe8a2386603961f48e7fb12ba03be7a81539ec':
resolution: {gitHosted: true, integrity: sha512-7QCwJyfOkLDKjmCGh2zwsvbFV2c1fcUlJSpDXsGg9vrZBdsbx9CQtgYwlnsuUm0Oj6wUgrZ4l3YUCBheIzQJkQ==, tarball: https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/8ffe8a2386603961f48e7fb12ba03be7a81539ec}
version: 0.12.0
engines: {node: '>=24'}
peerDependencies:
vite: ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0
@@ -3571,7 +3571,7 @@ snapshots:
fast-wrap-ansi: 0.2.2
sisteransi: 1.0.5
'@codex-proxy/ui@https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/68458e62e7fb9fadbacea75ce48522f2ba85b8b2(axios@1.21.1(debug@4.4.3))(change-case@5.4.4)(jiti@2.7.0)(postcss@8.5.30)(vite@8.3.8(@types/node@26.6.6)(jiti@2.7.0)(yaml@2.9.0))(vue@3.5.45(typescript@6.0.3))(yaml@2.9.0)':
'@codex-proxy/ui@https://codeload.github.com/zyycn/codex-proxy-ui/tar.gz/8ffe8a2386603961f48e7fb12ba03be7a81539ec(axios@1.21.1(debug@4.4.3))(change-case@5.4.4)(jiti@2.7.0)(postcss@8.5.30)(vite@8.3.8(@types/node@26.6.6)(jiti@2.7.0)(yaml@2.9.0))(vue@3.5.45(typescript@6.0.3))(yaml@2.9.0)':
dependencies:
'@ant-design/colors': 8.0.1
'@ant-design/fast-color': 3.0.1
+5
View File
@@ -1,5 +1,10 @@
autoInstallPeers: false
# picomatch 只在构建工具链中使用,未进入发布产物。上游发布修复后升级并移除此例外
audit:
ignore:
- GHSA-fc5q-39xc-vjpf
# Git 依赖通过 prepack 生成产物;信任自有 UI 仓库,实际提交仍由锁文件固定。
allowBuilds:
'@codex-proxy/ui@git+https://github.com/zyycn/codex-proxy-ui.git': true
+1 -1
View File
@@ -425,7 +425,7 @@ interface PageQuery {
type UsagePageQuery = UsageRangeQuery & PageQuery & {
clientApiKeyName?: string
accountName?: string
accountSearch?: string
model?: string
status?: UsageRecordStatus
}
+17
View File
@@ -0,0 +1,17 @@
<script setup lang="ts">
import { ZDropdown, ZIconButton } from '@codex-proxy/ui'
import { MoreHorizontal } from '@lucide/vue'
defineProps<{ label: string, menuClass: string, disabled?: boolean, loading?: boolean }>()
</script>
<template>
<ZDropdown :menu-class="menuClass">
<template #reference="{ trigger }">
<ZIconButton v-bind="trigger" size="small" :aria-label="label" :disabled="disabled" :loading="loading" :class="trigger['aria-expanded'] ? 'bg-z-bg-text-active text-z-text' : undefined">
<MoreHorizontal class="size-4" />
</ZIconButton>
</template>
<slot />
</ZDropdown>
</template>
@@ -9,12 +9,22 @@ import UsageDetailPopover from '@/components/usage/UsageDetailPopover.vue'
import { usageBillingText } from './shared/presenter'
const props = defineProps<{
record: Pick<UsageListRecord, 'billing'>
record: Pick<UsageListRecord, 'billing'> & Partial<Pick<UsageListRecord, 'serviceTier'>>
}>()
const { t } = useI18n({ useScope: 'global' })
const billing = computed(() => props.record.billing)
const speedMode = computed(() => {
const tier = props.record.serviceTier ?? billing.value?.serviceTierDisplay.toLowerCase()
if (tier === 'fast' || tier === 'priority')
return 'Fast'
if (tier === 'ultrafast')
return 'Ultrafast'
return null
})
const speedModeLabel = computed(() => t('usage.billing.speedMode', { mode: speedMode.value }))
const billingItems = computed(() => {
const value = billing.value
if (!value)
@@ -137,17 +147,19 @@ function itemValueClass(tone?: string, accent?: boolean) {
{{ usageBillingText(record) }}
</span>
<div v-if="billing" class="flex items-center gap-1">
<div v-if="billing || speedMode" class="flex shrink-0 items-center gap-1">
<span
v-if="billing.serviceTierDisplay === 'Fast'"
class="inline-flex size-4 items-center justify-center rounded-full bg-z-warning-container text-z-warning-on-container"
:title="t('usage.billing.fastMode')"
v-if="speedMode"
class="inline-flex h-4 items-center rounded-full bg-z-warning-container px-0.5 text-z-warning-on-container"
:title="speedModeLabel"
role="img"
:aria-label="t('usage.billing.fastMode')"
:aria-label="speedModeLabel"
>
<Zap class="size-3" stroke-width="2.2" aria-hidden="true" />
<Zap v-if="speedMode === 'Ultrafast'" class="size-3" stroke-width="2.2" aria-hidden="true" />
</span>
<UsageDetailPopover
v-if="billing"
:title="billing.longContextBillingApplied ? t('usage.billing.longContextBillingDetails') : t('usage.billing.billingDetails')"
:trigger-label="billing.longContextBillingApplied ? t('usage.billing.viewLongContextBillingDetails') : t('usage.billing.viewCostDetails')"
:tone="billing.longContextBillingApplied ? 'warning' : 'primary'"
@@ -26,7 +26,7 @@ const outcome = computed(() => usageErrorTitle(props.record))
<div class="min-w-0 py-0.5">
<div class="flex min-w-0 items-center gap-2">
<span
class="inline-flex size-5 shrink-0 items-center justify-center rounded-z-sm"
class="inline-flex size-5 shrink-0 items-center justify-center"
:class="origin.className"
role="img"
:aria-label="origin.label"
@@ -24,22 +24,22 @@ export function usageErrorOrigin(record: Pick<UsageErrorFacts, 'errorOrigin'>) {
const origins = {
proxy: {
label: t('usage.error.origin.proxy'),
className: 'bg-z-blue-container text-z-blue-on-container',
className: 'text-z-blue-text',
hint: null,
},
upstream: {
label: t('usage.error.origin.upstream'),
className: 'bg-z-error-container text-z-error-on-container',
className: 'text-z-error-text',
hint: null,
},
connection: {
label: t('usage.error.origin.connection'),
className: 'bg-z-warning-container text-z-warning-on-container',
className: 'text-z-warning-text',
hint: t('usage.error.origin.connectionHint'),
},
unknown: {
label: t('usage.error.origin.unknown'),
className: 'bg-z-fill-tertiary text-z-text-secondary',
className: 'text-z-text-secondary',
hint: t('usage.error.origin.unknownHint'),
},
}
+1 -1
View File
@@ -11,7 +11,7 @@
"empty": "No observed quota buckets",
"invalid": "Enter a whole number from 1 to 100 or leave blank for no limit",
"limit": "Scheduling limit",
"warmup": "Auto warmup",
"warmup": "Warmup",
"model": "Warmup model",
"modelPlaceholder": "Select model",
"invalidModel": "Enter a valid warmup model ID",
+1 -1
View File
@@ -45,7 +45,7 @@
"cacheReadCost": "Cache read cost",
"cacheWriteCost": "Cache write cost",
"cacheWriteUnitPrice": "Cache write unit price",
"fastMode": "Fast mode",
"speedMode": "{mode} mode",
"longContextBillingDetails": "Long-context cost details",
"billingDetails": "Cost details",
"viewLongContextBillingDetails": "View long-context cost details",
@@ -11,7 +11,7 @@
"empty": "没有已观测的额度桶",
"invalid": "请输入 1~100 的整数,留空表示不限制",
"limit": "调度上限",
"warmup": "自动预热",
"warmup": "预热",
"model": "预热模型",
"modelPlaceholder": "选择模型",
"invalidModel": "请输入有效的预热模型 ID",
+1 -1
View File
@@ -45,7 +45,7 @@
"cacheReadCost": "缓存读取费用",
"cacheWriteCost": "缓存写入费用",
"cacheWriteUnitPrice": "缓存写入单价",
"fastMode": "Fast 模式",
"speedMode": "{mode} 模式",
"longContextBillingDetails": "长上下文计费明细",
"billingDetails": "计费明细",
"viewLongContextBillingDetails": "查看长上下文计费明细",
@@ -11,7 +11,7 @@
"empty": "沒有已觀測的額度桶",
"invalid": "請輸入 1~100 的整數,留空表示不限制",
"limit": "排程上限",
"warmup": "自動預熱",
"warmup": "預熱",
"model": "預熱模型",
"modelPlaceholder": "選擇模型",
"invalidModel": "請輸入有效的預熱模型 ID",
+1 -1
View File
@@ -45,7 +45,7 @@
"cacheReadCost": "緩存讀取費用",
"cacheWriteCost": "緩存寫入費用",
"cacheWriteUnitPrice": "緩存寫入單價",
"fastMode": "Fast 模式",
"speedMode": "{mode} 模式",
"longContextBillingDetails": "長上下文計費明細",
"billingDetails": "計費明細",
"viewLongContextBillingDetails": "查看長上下文計費明細",
@@ -1,12 +1,13 @@
<script setup lang="ts">
import type { Account } from '@/api'
import { ZIconButton, ZMenuItem, ZPopover } from '@codex-proxy/ui'
import { ZIconButton, ZMenuItem } from '@codex-proxy/ui'
import { Download, KeyRound, MoreHorizontal, Pencil, Power, RefreshCw, RotateCcw, Trash2, Wifi } from '@lucide/vue'
import { Download, KeyRound, Pencil, Power, RefreshCw, RotateCcw, Trash2, Wifi } from '@lucide/vue'
import { computed } from 'vue'
import { useI18n } from 'vue-i18n'
import RowActionMenu from '@/components/RowActionMenu.vue'
const props = defineProps<{
account: Account
@@ -53,81 +54,71 @@ const credentialEligible = computed(() => props.account.authenticationKind === '
<Trash2 class="size-3.5 text-z-error" />
</ZIconButton>
<ZPopover placement="bottom-end">
<template #reference="{ open }">
<ZIconButton size="small" :aria-label="t('accounts.actions.moreActions')" :pressed="open">
<MoreHorizontal class="size-4" />
</ZIconButton>
</template>
<template #default="{ close }">
<div class="w-40 p-1.5">
<ZMenuItem
:loading="testing"
:disabled="testing"
@click.stop="(close(), emit('test', account))"
>
<template #icon>
<Wifi class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.connectionTest.title') }}
</ZMenuItem>
<ZMenuItem
:loading="togglingScheduling"
:disabled="togglingScheduling"
@click.stop="(close(), emit('toggleScheduling', account))"
>
<template #icon>
<Power class="size-3.5 text-z-text-quaternary" />
</template>
{{ account.enabled ? t('accounts.actions.disableScheduling') : t('accounts.actions.enableScheduling') }}
</ZMenuItem>
<ZMenuItem
v-if="credentialEligible"
:loading="refreshing"
:disabled="refreshing"
@click.stop="(close(), emit('refresh', account.id))"
>
<template #loading>
<RefreshCw class="size-3.5 animate-spin text-z-text-quaternary motion-reduce:animate-none" />
</template>
<template #icon>
<RefreshCw class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.refreshToken') }}
</ZMenuItem>
<ZMenuItem v-if="credentialEligible" @click.stop="(close(), emit('reauthorize', account))">
<template #icon>
<KeyRound class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.reauthorize') }}
</ZMenuItem>
<ZMenuItem
v-if="account.provider === 'openai' && account.authenticationKind === 'oauth'"
:loading="downloadingCatalog"
:disabled="downloadingCatalog"
@click.stop="(close(), emit('downloadModelCatalog', account))"
>
<template #loading>
<RefreshCw class="size-3.5 animate-spin text-z-text-quaternary motion-reduce:animate-none" />
</template>
<template #icon>
<Download class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.downloadModelCatalog') }}
</ZMenuItem>
<ZMenuItem
:loading="recovering"
:disabled="recovering"
@click.stop="(close(), emit('recover', account.id))"
>
<template #icon>
<RotateCcw class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.restoreState') }}
</ZMenuItem>
</div>
</template>
</ZPopover>
<RowActionMenu :label="t('accounts.actions.moreActions')" menu-class="w-40 p-1.5">
<ZMenuItem
:loading="testing"
:disabled="testing"
@click.stop="emit('test', account)"
>
<template #icon>
<Wifi class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.connectionTest.title') }}
</ZMenuItem>
<ZMenuItem
:loading="togglingScheduling"
:disabled="togglingScheduling"
@click.stop="emit('toggleScheduling', account)"
>
<template #icon>
<Power class="size-3.5 text-z-text-quaternary" />
</template>
{{ account.enabled ? t('accounts.actions.disableScheduling') : t('accounts.actions.enableScheduling') }}
</ZMenuItem>
<ZMenuItem
v-if="credentialEligible"
:loading="refreshing"
:disabled="refreshing"
@click.stop="emit('refresh', account.id)"
>
<template #loading>
<RefreshCw class="size-3.5 animate-spin text-z-text-quaternary motion-reduce:animate-none" />
</template>
<template #icon>
<RefreshCw class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.refreshToken') }}
</ZMenuItem>
<ZMenuItem v-if="credentialEligible" @click.stop="emit('reauthorize', account)">
<template #icon>
<KeyRound class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.reauthorize') }}
</ZMenuItem>
<ZMenuItem
v-if="account.provider === 'openai' && account.authenticationKind === 'oauth'"
:loading="downloadingCatalog"
:disabled="downloadingCatalog"
@click.stop="emit('downloadModelCatalog', account)"
>
<template #loading>
<RefreshCw class="size-3.5 animate-spin text-z-text-quaternary motion-reduce:animate-none" />
</template>
<template #icon>
<Download class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.downloadModelCatalog') }}
</ZMenuItem>
<ZMenuItem
:loading="recovering"
:disabled="recovering"
@click.stop="emit('recover', account.id)"
>
<template #icon>
<RotateCcw class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('accounts.actions.restoreState') }}
</ZMenuItem>
</RowActionMenu>
</div>
</template>
@@ -1,8 +1,9 @@
<script setup lang="ts">
import type { FormRule } from '@codex-proxy/ui'
import type { Account, AccountQuotaBucketSettings } from '@/api'
import { ZButton, ZDialog, ZFormItem, ZInput, ZSelect, ZSwitch } from '@codex-proxy/ui'
import { ZButton, ZDialog, ZForm, ZFormItem, ZInput, ZSelect, ZSwitch } from '@codex-proxy/ui'
import { SlidersHorizontal } from '@lucide/vue'
import { computed, ref, shallowRef } from 'vue'
import { computed, ref, shallowRef, useId, useTemplateRef } from 'vue'
import { useI18n } from 'vue-i18n'
import { batchUpdateAccounts, getAccountModels, getAccountQuota } from '@/api'
import { quotaWindowLabel } from '@/components/account/account-usage-window/presenter'
@@ -21,6 +22,8 @@ const props = defineProps<{ account: Account }>()
const emit = defineEmits<{ accountUpdated: [account: Account] }>()
const { t } = useI18n({ useScope: 'global' })
const open = shallowRef(false)
const formId = useId()
const formRef = useTemplateRef<InstanceType<typeof ZForm>>('formElement')
const draft = ref<BucketDraft[]>([])
const { loading, run } = useAsyncAction()
const { loading: loadingModels, run: loadModels } = useAsyncAction()
@@ -33,11 +36,18 @@ const modelOptions = computed(() => {
}
return Array.from(options, ([value, label]) => ({ value, label }))
})
const invalidLimit = computed(() => draft.value.some(row => row.limit !== '' && !/^(?:[1-9]\d?|100)$/.test(row.limit)))
const invalidModel = computed(() => draft.value.some(row => row.warmup && (!row.model.trim() || row.model.trim().length > 128 || /\p{Cc}/u.test(row.model))))
const invalid = computed(() => invalidLimit.value || invalidModel.value)
const limitRule = computed<FormRule>(() => ({
validator: (_rule, value: string) => value === '' || /^(?:[1-9]\d?|100)$/.test(value),
message: t('accounts.quotaSettings.invalid'),
}))
const modelRule = computed<FormRule>(() => ({
required: true,
validator: (_rule, value: string) => Boolean(value.trim()) && value.trim().length <= 128 && !/\p{Cc}/u.test(value),
message: t('accounts.quotaSettings.invalidModel'),
}))
async function edit() {
formRef.value?.clearValidate()
const windows = new Map(props.account.quota.windows.filter(window => window.accountWide).map(window => [window.key, window]))
const keys = new Set([
...windows.keys(),
@@ -68,7 +78,7 @@ async function edit() {
}
async function save() {
if (invalid.value)
if (loading.value || !draft.value.length || !await formRef.value?.validate().catch(() => false))
return
const accountId = props.account.id
const settings: Record<string, AccountQuotaBucketSettings> = Object.fromEntries(draft.value
@@ -105,37 +115,46 @@ async function save() {
<SlidersHorizontal class="size-3.5" />
</QuotaActionButton>
<ZDialog v-model="open" :title="t('accounts.quotaSettings.title')" :description="t('accounts.quotaSettings.subtitle')" width="32rem" :close-on-click-modal="!loading" :close-on-press-escape="!loading" :show-close="!loading">
<div class="grid gap-4">
<ZForm :id="formId" ref="formElement" :model="draft" :validate-on-rule-change="false" :show-message="false" class="gap-4" scroll-to-error focus-on-error novalidate @submit="save">
<p v-if="!draft.length" class="m-0 text-z-sm text-z-text-secondary">
{{ t('accounts.quotaSettings.empty') }}
</p>
<section v-for="row in draft" :key="row.key" class="relative grid gap-3 rounded-z bg-z-fill-quaternary p-3" :aria-label="row.label">
<h3 class="m-0 pr-32 text-z-sm font-heavy text-z-text">
{{ row.label }}
</h3>
<ZSwitch v-model="row.warmup" class="absolute! top-2 right-3" :label="t('accounts.quotaSettings.warmup')" :aria-label="`${row.label} · ${t('accounts.quotaSettings.warmup')}`" :disabled="loading" />
<section v-for="(row, index) in draft" :key="row.key" class="grid gap-3 rounded-z bg-z-fill-quaternary p-3" :aria-label="row.label">
<div class="flex items-center justify-between gap-3">
<h3 class="m-0 min-w-0 wrap-anywhere text-z-sm font-heavy text-z-text">
{{ row.label }}
</h3>
<ZSwitch
v-model="row.warmup"
size="small"
inline-prompt
class="w-12 [&:lang(en)]:w-18"
width="100%"
:active-text="t('accounts.quotaSettings.warmup')"
:inactive-text="t('accounts.quotaSettings.warmup')"
:aria-label="`${row.label} · ${t('accounts.quotaSettings.warmup')}`"
:disabled="loading"
/>
</div>
<div class="grid gap-3 sm:grid-cols-2">
<ZFormItem :label="t('accounts.quotaSettings.limit')">
<ZInput v-model="row.limit" type="number" min="1" max="100" step="1" :aria-label="`${row.label} · ${t('accounts.quotaSettings.limit')}`" :placeholder="t('accounts.quotaSettings.unlimited')" :disabled="loading">
<ZFormItem :label="t('accounts.quotaSettings.limit')" :prop="`${index}.limit`" :rules="limitRule">
<ZInput v-model="row.limit" :validate-event="false" type="number" min="1" max="100" step="1" :aria-label="`${row.label} · ${t('accounts.quotaSettings.limit')}`" :placeholder="t('accounts.quotaSettings.unlimited')" :disabled="loading" @update:model-value="formRef?.clearValidate(`${index}.limit`)">
<template #suffix>
%
</template>
</ZInput>
</ZFormItem>
<ZFormItem v-if="row.warmup" :label="t('accounts.quotaSettings.model')" required>
<ZSelect v-model="row.model" class="w-full" :options="modelOptions" :aria-label="`${row.label} · ${t('accounts.quotaSettings.model')}`" :placeholder="t('accounts.quotaSettings.modelPlaceholder')" :empty-text="t('accounts.connectionTest.noModels')" :disabled="loading || loadingModels" />
<ZFormItem v-if="row.warmup" :label="t('accounts.quotaSettings.model')" :prop="`${index}.model`" :rules="modelRule">
<ZSelect v-model="row.model" :validate-event="false" class="w-full" :options="modelOptions" :aria-label="`${row.label} · ${t('accounts.quotaSettings.model')}`" :placeholder="t('accounts.quotaSettings.modelPlaceholder')" :empty-text="t('accounts.connectionTest.noModels')" :disabled="loading || loadingModels" @update:model-value="formRef?.clearValidate(`${index}.model`)" />
</ZFormItem>
</div>
</section>
<p v-if="invalid" class="m-0 text-z-xs text-z-error" role="alert">
{{ invalidLimit ? t('accounts.quotaSettings.invalid') : t('accounts.quotaSettings.invalidModel') }}
</p>
</div>
</ZForm>
<template #footer>
<ZButton :disabled="loading" @click="open = false">
{{ t('common.actions.cancel') }}
</ZButton>
<ZButton type="primary" :disabled="!draft.length || invalid" :loading="loading" @click="save">
<ZButton type="primary" native-type="submit" :form="formId" :disabled="!draft.length" :loading="loading">
{{ t('common.actions.save') }}
</ZButton>
</template>
+1 -1
View File
@@ -28,7 +28,7 @@ const { showConfig, configKey, configuring, apiBaseUrl, openConfig, copyConfig }
<KeyUsageHeader v-model:period="period" v-model:refresh-interval="refreshInterval" :name="overview?.key.name" :prefix="overview?.key.prefix" :refreshing="refreshing || overviewLoading" :configuring="configuring" @refresh="refresh" @configure="openConfig" />
<div class="flex flex-wrap items-center justify-between gap-3">
<span v-if="overview" class="text-z-sm text-z-text-tertiary">{{ t('usage.page.updated', { asOfDisplay: overview.asOfDisplay }) }}</span>
<ZInput id="key-usage-model" v-model="model" class="ml-auto w-full min-w-0 sm:w-md sm:flex-none" :placeholder="t('usage.filters.modelPlaceholder')" :aria-label="t('usage.filters.modelPlaceholder')" :maxlength="128">
<ZInput id="key-usage-model" v-model="model" class="ml-auto w-full min-w-0 sm:w-75 sm:flex-none" :placeholder="t('usage.filters.modelPlaceholder')" :aria-label="t('usage.filters.modelPlaceholder')" :maxlength="128">
<template #prefix>
<Search class="size-4.5 text-z-text-tertiary" />
</template>
@@ -1,11 +1,12 @@
<script setup lang="ts">
import type { ApiKey } from '@/api'
import { ZIconButton, ZMenuItem, ZPopover } from '@codex-proxy/ui'
import { ZIconButton, ZMenuItem } from '@codex-proxy/ui'
import { MoreHorizontal, Pencil, Power, RotateCcw, Terminal, Trash2, Upload } from '@lucide/vue'
import { Pencil, Power, RotateCcw, Terminal, Trash2, Upload } from '@lucide/vue'
import { useI18n } from 'vue-i18n'
import RowActionMenu from '@/components/RowActionMenu.vue'
defineProps<{
apiKey: ApiKey
@@ -46,40 +47,31 @@ const { t } = useI18n({ useScope: 'global' })
<Terminal class="size-3.5 text-z-primary-text" />
</ZIconButton>
<ZPopover placement="bottom-end">
<template #reference="{ open }">
<ZIconButton size="small" :aria-label="t('keys.actions.moreActions')" :pressed="open">
<MoreHorizontal class="size-4" />
</ZIconButton>
</template>
<template #default="{ close }">
<div class="w-36 p-1.5">
<ZMenuItem @click.stop="(close(), emit('resetBudget', apiKey))">
<template #icon>
<RotateCcw class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('keys.actions.resetUsedCredit') }}
</ZMenuItem>
<ZMenuItem :disabled="revealing" @click.stop="(close(), emit('importClient', apiKey))">
<template #icon>
<Upload class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('keys.configuration.importTo') }}
</ZMenuItem>
<ZMenuItem :loading="updatingStatus" @click.stop="(close(), emit('toggle', apiKey))">
<template #icon>
<Power class="size-3.5" :class="apiKey.enabled ? 'text-z-warning' : 'text-z-success'" />
</template>
{{ apiKey.enabled ? t('keys.actions.disableKey') : t('keys.actions.enableKey') }}
</ZMenuItem>
<ZMenuItem type="danger" :disabled="deleting" @click.stop="(close(), emit('delete', apiKey))">
<template #icon>
<Trash2 class="size-3.5" />
</template>
{{ t('keys.actions.deleteKey') }}
</ZMenuItem>
</div>
</template>
</ZPopover>
<RowActionMenu :label="t('keys.actions.moreActions')" menu-class="w-36 p-1.5">
<ZMenuItem @click.stop="emit('resetBudget', apiKey)">
<template #icon>
<RotateCcw class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('keys.actions.resetUsedCredit') }}
</ZMenuItem>
<ZMenuItem :disabled="revealing" @click.stop="emit('importClient', apiKey)">
<template #icon>
<Upload class="size-3.5 text-z-text-quaternary" />
</template>
{{ t('keys.configuration.importTo') }}
</ZMenuItem>
<ZMenuItem :loading="updatingStatus" @click.stop="emit('toggle', apiKey)">
<template #icon>
<Power class="size-3.5" :class="apiKey.enabled ? 'text-z-warning' : 'text-z-success'" />
</template>
{{ apiKey.enabled ? t('keys.actions.disableKey') : t('keys.actions.enableKey') }}
</ZMenuItem>
<ZMenuItem type="danger" :disabled="deleting" @click.stop="emit('delete', apiKey)">
<template #icon>
<Trash2 class="size-3.5" />
</template>
{{ t('keys.actions.deleteKey') }}
</ZMenuItem>
</RowActionMenu>
</div>
</template>
@@ -1,9 +1,10 @@
<script setup lang="ts">
import type { OutboundProxyRecord } from '@/api'
import { ZIconButton, ZMenuItem, ZPopover } from '@codex-proxy/ui'
import { MoreHorizontal, Pencil, Power, Trash2, Wifi } from '@lucide/vue'
import { ZIconButton, ZMenuItem } from '@codex-proxy/ui'
import { Pencil, Power, Trash2, Wifi } from '@lucide/vue'
import { useI18n } from 'vue-i18n'
import RowActionMenu from '@/components/RowActionMenu.vue'
defineProps<{
proxy: OutboundProxyRecord
@@ -30,28 +31,19 @@ const { t } = useI18n({ useScope: 'global' })
<ZIconButton size="small" :aria-label="t('proxies.actions.edit')" :disabled="testing || updating" @click="emit('edit', proxy)">
<Pencil class="size-3.5 text-z-link" />
</ZIconButton>
<ZPopover placement="bottom-end">
<template #reference="{ open }">
<ZIconButton size="small" :aria-label="t('proxies.actions.moreActionsFor', { name: proxy.name })" :pressed="open" :disabled="testing || updating" :loading="updating">
<MoreHorizontal class="size-4" />
</ZIconButton>
</template>
<template #default="{ close }">
<div class="w-36 p-1.5">
<ZMenuItem :disabled="testing || updating" @click="(close(), emit('toggle', proxy))">
<template #icon>
<Power class="size-3.5" :class="proxy.enabled ? 'text-z-warning' : 'text-z-success'" />
</template>
{{ proxy.enabled ? t('proxies.actions.disableProxy') : t('proxies.actions.enableProxy') }}
</ZMenuItem>
<ZMenuItem type="danger" :disabled="testing || updating" @click="(close(), emit('delete', proxy))">
<template #icon>
<Trash2 class="size-3.5" />
</template>
{{ t('proxies.actions.deleteProxy') }}
</ZMenuItem>
</div>
</template>
</ZPopover>
<RowActionMenu :label="t('proxies.actions.moreActionsFor', { name: proxy.name })" menu-class="w-36 p-1.5" :disabled="testing || updating" :loading="updating">
<ZMenuItem :disabled="testing || updating" @click="emit('toggle', proxy)">
<template #icon>
<Power class="size-3.5" :class="proxy.enabled ? 'text-z-warning' : 'text-z-success'" />
</template>
{{ proxy.enabled ? t('proxies.actions.disableProxy') : t('proxies.actions.enableProxy') }}
</ZMenuItem>
<ZMenuItem type="danger" :disabled="testing || updating" @click="emit('delete', proxy)">
<template #icon>
<Trash2 class="size-3.5" />
</template>
{{ t('proxies.actions.deleteProxy') }}
</ZMenuItem>
</RowActionMenu>
</div>
</template>
@@ -30,7 +30,7 @@ export function useUsageRecordsTable(options: UseUsageRecordsTableOptions) {
clientApiKeyName: filterField.value === 'key'
? value
: undefined,
accountName: filterField.value === 'account'
accountSearch: filterField.value === 'account'
? value
: undefined,
model: filterField.value === 'model'
@@ -74,7 +74,7 @@ export function useUsageRecordsTable(options: UseUsageRecordsTableOptions) {
function filterChanged() {
const filter = filterParams.value
return tableParams.clientApiKeyName !== filter.clientApiKeyName
|| tableParams.accountName !== filter.accountName
|| tableParams.accountSearch !== filter.accountSearch
|| tableParams.model !== filter.model
}

Some files were not shown because too many files have changed in this diff Show More