mirrors2/openteam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

M0-M4: 推倒重来基线(基建+用户/密钥/核心代理+前端+管理后台+三协议互转)

Browse Source 
- 后端 Go+Gin+GORM: 配置(OT_ env)/SQLite/Postgres 双驱动、用户体系(argon2id+JWT access/refresh)、
  API Key(sk- 48位, 仅存 SHA-256 哈希)
- 代理网关: /v1/chat/completions、/v1/responses、/v1/messages、/v1/models;错误按客户端协议返回
- 三协议互转(convert 包): Chat↔Messages↔Responses 请求/响应 + 流式 SSE 逐事件转换(直通优先)
- 用量计费: 异步批量记账、余额扣减、balance_logs、usage_daily 日聚合
- 管理 API: 用户/渠道 CRUD+测试+模型导入/模型定价+绑定/统计/系统配置
- 前端 Vue3+TS+Tailwind(taste-skill 设计 tokens): Landing/登录注册/控制台/管理后台,
  自建组件+Phosphor 图标+自建 SVG 趋势图, 已过 web-design-guidelines 复查
- mock 上游: OpenAI+Anthropic 双协议模拟(含流式)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Sakurasan
2026-08-15 15:34:06 +08:00
co-authored by Claude
parent b25e9ec8a7
commit ec4de8d913
92 changed files with 6203 additions and 3064 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+7
View File
@@ -7,6 +7,13 @@ dist/
# Go
server/bin/
server/data/
scripts/mockupstream/bin/
# TypeScript 增量构建产物
*.tsbuildinfo
web/vite.config.js
web/vite.config.d.ts
web/node_modules/.tmp/
# 环境与密钥
.env
Makefile
+2 -2
View File
@@ -1,4 +1,4 @@
.PHONY: run build test mock-upstream tidy
.PHONY: run build test tidy mock-upstream web-dev web-build
run:
cd server && go run ./cmd/server
@@ -14,7 +14,7 @@ tidy:
# 本地 mock OpenAI 上游（联调用，无需真实 key）
mock-upstream:
cd scripts && go run ./mockupstream
cd scripts/mockupstream && go run .
# 前端
web-dev:
PLANNING.md
+256 -262
View File
@@ -1,8 +1,9 @@
# 大模型中转站（OpenRouter-like）规划文档
> 版本：v0.2 · 2026-08-15 · 状态：规划（未开始编码）
> 版本：v0.3 · 2026-08-15 · 状态：规划（决策已定：推倒重来）
>
> 本文档是项目蓝图，覆盖技术选型、系统架构、核心功能、数据模型、API 设计、前端设计方向与开发里程碑。编码开始前，本文档应与团队确认一遍。
> 技术栈：**Go + Vue3 + Tailwind CSS**，前端按 **taste-skill** 定义设计方向。
> 本文档是项目蓝图。编码前先与团队对齐；旧实现仅作参考（§2）。
---
@@ -12,11 +13,21 @@
一个自托管的 **LLM API 中转网关**，功能对标 OpenRouter / one-api：
- 对下游用户暴露**统一的、OpenAI 兼容**的 API 入口，背后接入多个上游渠道（OpenAI、Anthropic、兼容第三方等）。
- 对下游用户暴露**统一的、OpenAI 兼容的 API 入口**，背后接入多个上游渠道（OpenAI、Anthropic、兼容第三方等）。
- 对外提供三套协议入口：**OpenAI Responses API、OpenAI Chat Completions、Anthropic Messages**，覆盖两大生态的 SDK 与客户端。
- 内置用户体系、API Key 管理、用量统计与计费（充值暂缓，见 §4.5）。
- 内置用户体系、API Key 管理、用量统计与计费（充值暂缓，见 §5.5）。
### 1.2 核心价值
### 1.2 三大板块（对应用户的诉求）
| 板块 | 面向 | 核心功能 |
| --- | --- | --- |
| **大模型代理** | 下游开发者 | 三套协议入口 + 协议互转 + 渠道接入 + 负载均衡/健康检查/故障转移 + `/v1/models` |
| **后台管理** | 管理员面板 / 普通用户 | 注册登录、角色（admin/user）、API Key、渠道管理、用户管理、充值审核 |
| **用量计费** | 管理员 / 普通用户 | token 统计、计价、余额、请求流水、日聚合报表 |
> MVP 顺序即此三板块的骨架：**先把"代理 + 用户 + 记账"跑通**，再补管理后台与渠道体系，最后是协议转换与充值。
### 1.3 核心价值
| 对用户 | 对管理员 |
| --- | --- |
@@ -24,7 +35,7 @@
| 查询用量、成本明细 | 管理用户、审核充值、看全局营收 |
| 配额/余额控制 | 渠道健康检查、负载均衡、故障转移 |
### 1.3 对外协议（明确范围）
### 1.4 对外协议（明确范围）
| 端点 | 协议 | 说明 |
| --- | --- | --- |
@@ -33,72 +44,97 @@
| `POST /v1/messages` | Anthropic Messages | Claude 生态原生格式，含流式与工具调用 |
| `GET /v1/models` | OpenAI 风格模型列表 | 对外列出可用模型；也用于渠道侧自动导入模型列表 |
> 三套协议之间可**互相转换**：例如客户端按 Responses 调用 `claude-sonnet-5`，网关会转换成 Anthropic 协议打给 Anthropic 渠道，再以 Responses 流式返回；同理可反向。协议与渠道匹配时走**直通**（见 4.1.3）。
> 三套协议之间可**互相转换**：例如客户端按 Responses 调用 `claude-sonnet-5`，网关会转换成 Anthropic 协议打给 Anthropic 渠道，再以 Responses 流式返回；同理可反向。协议与渠道匹配时走**直通**（见 §5.1.3）。
### 1.5 首版范围（MVP）
| 纳入（按序） | 暂缓 |
| --- | --- |
| M1 核心代理（chat/completions + responses + models，直通） | 充值（**待定**，见 §5.5） |
| M2 用户体系 + API Key + 记账 | 在线支付、审计报表、多实例 |
| M3 管理后台（渠道/用户/模型/用量） | 邀请码（配置开关预留） |
| M4 协议转换（messages 端点 + 三协议互转） | 组织/团队（多租户） |
| M5 渠道体系完善（LB/健康/重试/模型导入） | viewer 只读角色 |
---
## 1.4 首版范围（MVP）
## 2. 当前状态（已定：推倒重来）
| 纳入 | 暂缓 |
> git 历史 `HEAD`（b25e9ec）中有一份旧 M0+M1 实现，但**当前工作区已清空**（仅剩 `.env`、`.env.example`、`.gitignore`）。已确认**推倒重来**：旧实现只作参考，不直接恢复使用。
### 2.1 旧实现可参考点（不复用代码，参考设计）
| 模块 | 值得借鉴的设计 |
| --- | --- |
| 大模型代理（三套协议 + 渠道 + 转换） | 充值（**暂停**，见 §4.5） |
| 用户管理（注册/登录/角色/API Key） | 邀请码（配置开关预留） |
| 用量计费（token 统计、计价、余额、流水） | 在线支付、审计报表、多实例 |
| 渠道管理（API 类型、模型导入、健康检查） | 组织/团队（多租户） |
| 管理后台（用户/渠道/模型/全局用量） | |
| 数据模型 | `store/models.go` 已覆盖 §6 全部表结构，字段命名/类型可直接照搬 |
| 代理直通 | 直通模式实现（鉴权 → 余额 → 选渠道 → 透传 → 记账）的链路划分 |
| 记账 | `usage.Recorder` 异步批量落库 + 队列满同步兜底的模式 |
| API Key | SHA-256 哈希存储 + 前缀展示 + 明文一次性展示 |
| 前端 | 页面清单与路由结构可参考；视觉按 taste-skill 重做 |
## 2. 技术选型
### 2.2 重做范围（按 §10 里程碑）
### 2.1 后端（Go）
- M0 基建、M1 用户+密钥+核心代理：**重做**（可参考旧实现，不复用）
- 其余里程碑（M2–M6）：按规划新增
### 2.3 决策记录
| 决策项 | 结论 |
| --- | --- |
| 工作区恢复方式 | **推倒重来**（2026-08-15 确认） |
---
## 3. 技术选型
### 3.1 后端（Go）
| 项 | 选型 | 理由 |
| --- | --- | --- |
| 语言/运行时 | Go 1.23+ | 高并发流式转发、低内存、部署为单二进制 |
| Web 框架 | Gin | 生态成熟，中间件丰富；代理层可用标准库 `net/http` 做流式读写 |
| ORM | GORM | 简单、迁移工具内建；后期可换 sqlc |
| 数据库 | PostgreSQL 15+（开发可 SQLite 起步） | JSON/数组字段、数值精度对计费友好；单一存储，无额外部署 |
| 缓存/限流 | Redis 7 | token bucket 限流、热点数据、分布式计数器 |
| 认证 | JWT（访问令牌）+ 刷新令牌 HttpOnly Cookie | 见 4.3 |
| 语言/运行时 | Go 1.23+ | 高并发流式转发、低内存、单二进制部署 |
| Web 框架 | Gin | 生态成熟、中间件丰富；代理层用标准库 `net/http` 做流式读写 |
| ORM | GORM | 简单、迁移内建；模型已按 v0.3 建好 |
| 数据库 | PostgreSQL 15+（开发可 SQLite 起步） | JSON/数组、numeric 精度对计费友好；单存储 |
| 缓存/限流 | Redis 7（起步可内存计数降级） | token bucket 限流、热点、分布式计数器 |
| 认证 | JWT access（2h）+ refresh cookie（7d） | 见 §5.3 |
| 密码 | argon2id | 现代 KDF |
| 配置 | viper + `.env` | 密钥进环境变量，不进代码库 |
| 日志 | zap | 结构化日志，含请求 trace |
| 上游密钥加密 | AES-GCM（主密钥来自环境变量） | 渠道 key 落库前加密 |
| 配置 | viper + `.env`（`OT_` 前缀） | 密钥进环境变量 |
| 日志 | zap | 结构化日志 + request_id |
| 渠道密钥加密 | AES-GCM（主密钥环境变量） | 落库前加密 |
### 2.2 前端（Vue 3）
### 3.2 前端（Vue 3 + Tailwind）
| 项 | 选型 | 理由 |
| --- | --- | --- |
| 框架 | Vue 3 + TypeScript + Vite | 团队栈、构建快 |
| 状态 | Pinia | 官方推荐 |
| 路由 | Vue Router | 标准 |
| 样式 | Tailwind CSS + **taste-skill 产出的设计 tokens** | 自建设计系统，避免套模板 |
| 组件基座 | Ark UI（headless）+ 自建基础组件 | 无头组件可控性强，符合 taste-skill 的 anti-slop 取向 |
| 图表 | ECharts（vue-echarts） | 用量/营收图表 |
| HTTP | axios + TanStack Query | 缓存、重试、请求状态管理 |
| 样式 | **Tailwind CSS** + taste-skill 产出的设计 tokens | 见 §8；自建设计系统，不套模板 |
| 组件 | **自建基础组件**（Button/Input/Table/Modal/Toast…）+ 必要 headless 原语 | 贴合设计 tokens，避免重型 UI 库的"模板感" |
| 图表 | ECharts（vue-echarts） | 用量/营收图表，暗色对齐 tokens |
| HTTP | axios + TanStack Query | 缓存、重试、请求状态 |
> 说明：不选用 Element Plus 这类"完整模板感"较重的库，管理后台的表格/表单由自建组件提供，视觉由 taste-skill 统一定调。
### 3.3 部署
### 2.3 部署
- Docker Compose 起步：`nginx`（静态资源 + 反代） + `api`（Go） + `postgres` + `redis`。
- Docker Compose 起步：`nginx`（静态资源 + 反代）+ `api`（Go）+ `postgres` + `redis`。
- 单实例起步（记账时序简单），需要时再做多实例（见 §9 风险）。
---
## 3. 系统架构
## 4. 系统架构
### 3.1 模块划分
### 4.1 模块划分
```
┌─────────────────────────────────────────────────────────────┐
│ 前端 web (Vue3) │
│ Landing / 登录注册 / 控制台(密钥·用量·充值) / 管理后台 │
│ 前端 web (Vue3 + Tailwind) │
│ Landing / 登录注册 / 控制台(密钥·用量) / 管理后台(渠道·用户·) │
└──────────────────────────┬──────────────────────────────────┘
│ HTTP/JSON（管理 API）
┌──────────────────────────▼──────────────────────────────────┐
│ Go API 服务 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────────────┐ │
│ │ 认证/用户 │ │ API Key │ │ 用量/计费 │ │ 充值(暂停) │ │
│ │ 认证/用户 │ │ API Key │ │ 用量/计费 │ │ 充值(待定) │ │
│ └──────────┘ └──────────┘ └──────────┘ └────────────────┘ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ API 网关（代理核心） │ │
@@ -117,7 +153,7 @@
└────────────────┘ └─────────────────┘
```
### 3.2 一次代理请求的完整链路
### 4.2 一次代理请求的完整链路
```
Client Go 网关 上游渠道(如 Anthropic)
@@ -137,19 +173,19 @@ Client Go 网关 上游渠道(如 A
```
关键点：
- **记账是异步的**：请求完成后写入 `usage_logs`，批量落库，不阻塞响应。
- **流式响应不整体缓冲**：用 `io.Pipe` 边读上游边写客户端；Token 计数取流结束时的 usage 字段（OpenAI 末块 / Claude `message_delta`）。
- **只转发请求体与必要头**：`Authorization` 一律替换为渠道 key，不向客户端暴露上游信息。
- **记账异步**：请求完成后写 `usage_logs`，批量落库，不阻塞响应。
- **流式不整体缓冲**：`io.Pipe` 边读上游边写客户端；Token 计数取流结束时的 usage（OpenAI 末块 / Claude `message_delta`）。
- **只转发必要体/头**：`Authorization` 一律替换为渠道 key，不向客户端暴露上游信息。
---
## 4. 核心功能设计
## 5. 核心功能设计
### 4.1 API 网关 / 格式转换
### 5.1 API 网关 / 协议转换
#### 4.1.1 内部统一格式（标准模型）
#### 5.1.1 内部统一格式（标准模型）
网关内部使用 **OpenAI Chat Completions 形状** 作为"标准中间模型"，三套协议都先转成它、再转成目标协议：
网关内部使用 **OpenAI Chat Completions 形状**作为"标准中间模型"，三套协议都先转成它、再转成目标协议：
```
OpenAI /v1/responses ──┐
@@ -157,122 +193,121 @@ OpenAI /v1/chat/completions ─┼──▶ 标准模型（OpenAI chat 形状）
Anthropic /v1/messages ──┘
```
这样新增一种上游渠道（如 Gemini）只需写**一对**转换器（标准模型 ↔ 渠道格式），不用为每个协议组合写转换器；Responses 与 Chat、Messages 与 Chat 之间各维护一个转换适配器。
新增上游渠道（如 Gemini）只需写**一对**转换器（标准模型 ↔ 渠道格式），而非为每个协议组合写转换器。
#### 4.1.2 转换映射要点
#### 5.1.2 转换映射要点
**Chat ↔ Claude Messages**
| 维度 | OpenAI chat ↔ Claude messages |
| --- | --- |
| system | OpenAI `messages[role=system]` ↔ Claude `system` 参数（支持数组/文本） |
| 消息 | `assistant.tool_calls` ↔ `content` 中的 `tool_use` 块；`role=tool` ↔ `tool_result` 块 |
| system | `messages[role=system]` ↔ Claude `system` 参数（支持数组/文本） |
| 消息 | `assistant.tool_calls` ↔ `content` 的 `tool_use` 块；`role=tool` ↔ `tool_result` 块 |
| 工具 | `tools[{type:function,name,description,parameters}]` ↔ `tools[{name,description,input_schema}]` |
| 采样 | `temperature`（OpenAI 0–2，Claude 0–1，越界按目标协议 clamp）、`top_p` |
| 长度 | `max_tokens` ↔ `max_tokens`（Claude 必填，缺失时给默认值） |
| 采样 | `temperature`（OpenAI 0–2，Claude 0–1，按目标协议 clamp）、`top_p` |
| 长度 | `max_tokens` ↔ `max_tokens`（Claude 必填，缺失给默认值） |
| 停止 | `stop` ↔ `stop_sequences`（数组对齐） |
| 流式 | OpenAI SSE `data: {chunk}` + `[DONE]` ↔ Claude 事件流 `message_start / content_block_delta / message_delta / message_stop`，逐事件互转 |
| 用量 | `usage.prompt_tokens/completion_tokens` ↔ `usage.input_tokens/output_tokens`，并映射 Claude 的缓存 token |
| 用量 | `usage.prompt_tokens/completion_tokens` ↔ `usage.input_tokens/output_tokens`，映射 Claude 缓存 token |
**Responses ↔ Chat**（Responses 结构化能力更多，映射如下）
**Responses ↔ Chat**
| Responses 字段 | Chat 对应 |
| --- | --- |
| `instructions` | `messages[0].system` |
| `input[]`（`input_text` / `input_image` / `input_file`） | `messages[]`（user 多模态 content 数组） |
| `input[]` 中 `function_call` / `function_call_output` 条目 | `assistant.tool_calls` / `role=tool` 消息 |
| `output[]` 中 `message` / `function_call` / `reasoning` 条目 | `choices[].message` / `tool_calls`（reasoning 跨协议丢弃） |
| `tools[{type:function,name,description,parameters}]` | `tools[{type:function,...}]`（结构相同） |
| `output_format` / `text.format` | `response_format` |
| `input[]`（`input_text`/`input_image`/`input_file`） | `messages[]`（user 多模态 content 数组） |
| `input[]` 中 `function_call`/`function_call_output` | `assistant.tool_calls` / `role=tool` |
| `output[]`（`message`/`function_call`/`reasoning`） | `choices[].message` / `tool_calls`（reasoning 跨协议丢弃） |
| `tools[{type:function,...}]` | 结构相同 |
| `output_format`/`text.format` | `response_format` |
| `max_output_tokens` | `max_tokens` |
| `previous_response_id` | 仅直通 OpenAI 渠道可用；跨协议时降级（见 4.1.3） |
| `previous_response_id` | 仅直通 OpenAI 可用；跨协议降级（见 5.1.3） |
| `reasoning.effort` | 仅直通或特定渠道，跨协议丢弃 |
| 流式事件 `response.created / output_text.delta / function_call_arguments.delta / response.completed` | chat SSE `data: {delta}` + `[DONE]`，逐事件互转 |
| 流式事件 `response.created/output_text.delta/function_call_arguments.delta/response.completed` | chat SSE `data: {delta}` + `[DONE]` |
#### 4.1.3 直通（passthrough）与转换策略
#### 5.1.3 直通与转换策略
- **直通优先**：客户端协议与渠道原生协议一致时直接透传报文（仅做鉴权/限额/记账），**不转格式**——保证 Responses 的 `previous_response_id`、`reasoning`、结构化输出等新能力在 OpenAI 渠道上零损失。
- **转换路径**：协议不匹配时才经标准模型转换（如 Responses → Anthropic 渠道、Messages → OpenAI 渠道）。
- **直通优先**：客户端协议 = 渠道原生协议时直接透传（仅鉴权/限额/记账），不转格式——保证 Responses 的 `previous_response_id`、`reasoning`、结构化输出零损失。
- **转换路径**：协议不匹配时才经标准模型转换。
- **有损边界（文档明示）**：
- `previous_response_id`、`reasoning.effort` 跨协议时**降级或丢弃**，错误响应中提示。
- Anthropic 渠道不接收 `response_format` 类结构化约束，降级为 prompt 提示或丢弃。
- Claude 的 thinking 块在 OpenAI 协议侧丢弃（无法表达）。
- `previous_response_id`、`reasoning.effort` 跨协议降级/丢弃，错误响应中提示。
- Anthropic 渠道不接收 `response_format` 类约束，降级为 prompt 或丢弃。
- Claude thinking 块在 OpenAI 协议侧丢弃。
- **转换标记**：转换过的请求/响应加 `x-converted: true` 头，便于排查。
#### 4.1.4 错误响应统一
#### 5.1.4 错误响应统一
无论上游是什么错误，都按**客户端请求的协议**返回错误体：
按**客户端请求的协议**返回错误体：
- OpenAI 格式：`{"error":{"message","type","param","code"}}` + 映射过的 HTTP 状态码。
- Claude 格式：`{"type":"error","error":{"type","message"}}`。
- 状态码映射：上游 `429` → `429`（附 `retry-after`）、上游 `5xx` → 触发重试后返回 `502/504`、`400`（含 context length 超限）→ 原样返回、余额不足 → `402`。
- OpenAI：`{"error":{"message","type","param","code"}}` + 映射过的状态码。
- Claude：`{"type":"error","error":{"type","message"}}`。
- 状态码映射：上游 `429` → `429`（附 `retry-after`）；上游 `5xx` → 重试后 `502/504`；`400`（含 context 超限）→ 原样；余额不足 → `402`。
### 4.2 渠道系统
### 5.2 渠道系统
| 能力 | 设计 |
| --- | --- |
| 渠道 CRUD | 管理员增删改：名称、**API 类型**（openai / anthropic / compatible）、base_url、上游 key（AES-GCM 加密存储）、超时、并发上限 |
| API 类型选择 | 新增渠道时选择类型，决定支持的原生协议（决定直通还是转换）与模型列表导入方式 |
| 模型列表导入 | 渠道支持 `GET /v1/models` 时提供"拉取模型列表"按钮，自动导入可用模型到全局模型库并生成绑定；不支持该端点的渠道（部分第三方）可手动录入 |
| 模型绑定 | 模型(全局) ↔ 渠道(多个) 多对多，每个绑定记录 `upstream_model` 名、权重/优先级 |
| 负载均衡 | 按权重 + 优先级 + 健康状态选择渠道；健康渠道优先 |
| 健康检查 | 定时用最廉价模型发一次测试请求（非流式），连续失败 N 次进入 cooldown，恢复后再放回 |
| 重试/故障转移 | 仅对"可安全重试"的失败（网络错误、429、5xx、超时、上游连接断开**且尚未写出响应头**）；对 400/context 类错误不重试。流式一旦已向客户端写出首字节，放弃重试 |
| 并发控制 | 每渠道信号量限制最大并发，超限排队或溢出到其他渠道 |
| 渠道 CRUD | 管理员增删改：名称、**API 类型**（openai/anthropic/compatible）、base_url、上游 key（AES-GCM 加密）、超时、并发上限 |
| API 类型 | 决定原生协议（直通 or 转换）与模型导入方式 |
| 模型导入 | 渠道支持 `GET /v1/models` 时"拉取模型列表"自动导入并绑定；否则手动录入 |
| 模型绑定 | 模型(全局) ↔ 渠道(多个) 多对多，绑定记录 `upstream_model`、权重 |
| 负载均衡 | 权重 + 优先级 + 健康状态选渠道 |
| 健康检查 | 定时用最廉价模型发测试请求，连续失败 N 次进 cooldown，恢复后放回 |
| 重试/故障转移 | 仅对可安全重试的失败（网络错误、429、5xx、超时、上游断开**且未写出响应头**）；流式已写出首字节即放弃重试 |
| 并发控制 | 每渠道信号量限最大并发，超限排队或溢出到其他渠道 |
### 4.3 认证与用户
### 5.3 认证与用户
#### 4.3.1 角色
#### 5.3.1 角色
| 角色 | 权限 |
| --- | --- |
| `admin` | 全部；渠道管理、模型定价、用户管理、余额调整、充值审核、全局用量 |
| `user` | 创建/管理自己的 API Key、查询用量、充值、查看余额 |
| `user` | 创建/管理自己的 API Key、查询用量、查看余额 |
> 预留 `viewer`（只读运营）角色，首版不做。
#### 4.3.2 会话
#### 5.3.2 会话
- 登录：用户名/邮箱 + 密码（argon2id 校验）。
- 颁发：短时访问令牌（JWT，如 2h，存内存）+ 刷新令牌（存 HttpOnly Cookie，7d）。
- 注册：**开放注册，可切换**——默认 `open`，配置项 `registration.mode` 切到 `invite` 即启用邀请码（管理员后台生成）。
- 颁发：短时 access（JWT，2h，内存）+ refresh（HttpOnly cookie，7d）。
- 注册：默认 `open`，配置 `registration.mode=invite` 启用邀请码（管理员后台生成）。
#### 4.3.3 API Key
#### 5.3.3 API Key
- 生成格式：`sk-` + 48 位随机字符（base62），**创建时仅展示一次**。
- 存储：库中只存 SHA-256 哈希 + 展示用前缀（如 `sk-aB3c…`）；请求时对 Bearer 哈希后查表。
- 附加能力：密钥级配额（每日 token 上限 / 每日请求数上限）、模型白名单、过期时间、启停。
- 格式：`sk-` + 48 位随机 base62，**创建时仅展示一次**。
- 存储：仅 SHA-256 哈希 + 展示前缀（如 `sk-aB3c…`）；请求时哈希后查表。
- 附加能力：密钥级配额（每日 token / 请求数）、模型白名单、过期时间、启停。
- 限额检查用 Redis 计数，与用户级限流叠加。
### 4.4 用量与计费
### 5.4 用量与计费
#### 4.4.1 Token 统计
#### 5.4.1 Token 统计
- 优先取上游响应中的 usage（OpenAI `usage` 字段、Claude `message_delta.usage`）。
- 上游缺失时 fallback：本地近似计数（按字符/字节估算，或引入 tiktoken-go 按模型分词）。
- Claude 渠道额外记录 `cache_read_input_tokens` / `cache_creation_input_tokens`，用于缓存计费。
- 优先取上游 usage（OpenAI `usage` / Claude `message_delta.usage`）。
- 缺失时 fallback：本地近似计数（字符/字节估算，或 tiktoken-go 按模型分词）。
- Claude 渠道额外记录 `cache_read_input_tokens`/`cache_creation_input_tokens`。
#### 4.4.2 计价
#### 5.4.2 计价
- 模型注册表（`models`）中每个模型配置：`input_price`、`output_price`、`cache_read_price`（按 **每百万 token**）。
- 单次成本 = `in×in_price + out×out_price + cache_read×cache_read_price`（统一以 USD 记账，前端按配置汇率显示）。
- 管理员可随时调价，历史用量按**当时价格**入账（用量表冗余快照价格字段）。
- 模型注册表（`models`）：`input_price`、`output_price`、`cache_read_price`（**每百万 token**）。
- 单次成本 = `in×in_price + out×out_price + cache_read×cache_read_price`（USD 记账，前端按汇率显示）。
- 调价不影响历史：用量表冗余快照价格。
#### 4.4.3 余额与扣费
#### 5.4.3 余额与扣费
- 预充值余额制：每次请求结束后异步扣费并写余额流水（`balance_logs`）。
- 扣费前先检查：余额 ≤ 0 时新请求返回 `402`。可选开关：按模型估算成本超余额即拦截（防止大单超额）。
- 余额为负不拒绝已进行的流式请求（流中途无法中断），但后续请求被拒。
- 预充值余额制：请求结束后异步扣费并写 `balance_logs`。
- 扣费前检查：余额 ≤ 0 → `402`。可选开关：按模型估算成本超余额即拦截。
- 流式请求进行中不中断（流中途无法停），后续请求被拒。
#### 4.4.4 用量查询
#### 5.4.4 用量查询
- `usage_logs`：请求级明细（用户、密钥、模型、渠道、token、成本、耗时、状态）。
- 聚合：日粒度预聚合表（`usage_daily`）支撑 Dashboard 图表，避免每次实时扫明细表。
- `usage_logs`：请求级明细（用户/密钥/模型/渠道/token/成本/耗时/状态）。
- 聚合：日粒度预聚合 `usage_daily` 支撑 Dashboard 图表，避免实时扫明细表。
### 4.5 充值（暂停开发）
### 5.5 充值（待定，暂缓开发）
> 已决定：**充值暂缓**，首版不做，先交付"代理 + 用户 + 计费"。方案（人工审核 / 在线支付）确定后再落地。
> 预留：`recharge_orders` / `balance_logs` 数据模型与订单状态机先行建好，后续接入不影响现有结构。
> 首版不做，先交付"代理 + 用户 + 计费"。数据模型与订单状态机**先行建好**，方案确定后接入不影响结构。
订单状态机（预留）：
@@ -282,191 +317,171 @@ pending(待审核) ──approve──▶ credited(已入账)
└──reject──▶ rejected └─（错误入账→adjust 冲正）
```
### 4.6 管理后台
管理员侧保留"查询充值 / 审核"接口占位。
### 5.6 管理后台
- 渠道管理：增删改、模型绑定、手动测试连接、健康状态查看。
- 模型管理：全局模型清单、多渠道绑定、价格设置、启停。
- 模型管理：全局清单、多渠道绑定、价格设置、启停。
- 用户管理：列表/搜索、改角色/状态、调整余额、重置密码。
- 充值审核：待审订单列表、通过/驳回、流水留痕。
- 充值审核：待审订单、通过/驳回、流水留痕（后置）。
- 全局用量：跨用户查询、按模型/渠道/天聚合、营收统计。
- 系统配置：开放注册、邀请码、汇率、限流阈值、维护开关。
---
## 5. 数据模型
## 6. 数据模型
> 统一 `id` 为 bigint 自增（或 snowflake），时间用 UTC，金额/价格用 `numeric(20,8)`，token 用 `bigint`。
> 统一 `id` bigint 自增；时间 UTC；金额/价格 `numeric(20,8)`；token `bigint`。以下模型与 git HEAD 中 `store/models.go` 一致（已落地），字段名以代码为准。
### 5.1 users
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| id | bigint PK | |
| username / email | text UNIQUE | |
| password_hash | text | argon2id |
| role | enum(`user`,`admin`) | |
| balance | numeric(20,8) | 余额 |
| status | enum(`active`,`disabled`) | |
| invite_code | text nullable | 注册来源邀请码 |
| last_login_at / created_at / updated_at | timestamptz | |
### 6.1 users
`id, username UNIQUE, email UNIQUE, password_hash(argon2id), role(user|admin), balance numeric(20,8), status(active|disabled), invite_code?, last_login_at?, created_at, updated_at`
### 5.2 api_keys
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| id | bigint PK | |
| user_id | bigint FK | |
| name | text | 展示名 |
| key_hash | text UNIQUE | SHA-256 |
| key_prefix | text | `sk-aB3c…` |
| quota_tokens_per_day | bigint nullable | 密钥级限额 |
| quota_requests_per_day | int nullable | |
| allowed_models | jsonb nullable | 模型白名单 |
| expires_at | timestamptz nullable | |
| status | enum(`active`,`revoked`) | |
| last_used_at | timestamptz nullable | |
| created_at | timestamptz | |
### 6.2 api_keys
`id, user_id FK, name, key_hash UNIQUE(SHA-256), key_prefix, quota_tokens_per_day?, quota_requests_per_day?, allowed_models jsonb?, expires_at?, status(active|revoked), last_used_at?, created_at`
### 5.3 channels
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| id | bigint PK | |
| name | text | |
| provider | enum(`openai`,`anthropic`,`compatible`) | API 类型：决定原生协议与模型导入方式 |
| base_url | text | 上游地址 |
| api_key_enc | text | AES-GCM 密文 |
| weight / priority | int | 负载均衡权重 / 优先级 |
| timeout_ms | int | |
| max_concurrency | int | |
| health_status | enum(`healthy`,`degraded`,`cooldown`) | |
| enabled | bool | |
| created_at / updated_at | timestamptz | |
### 6.3 channels
`id, name, provider(openai|anthropic|compatible), base_url, api_key_enc(AES-GCM), weight, priority, timeout_ms, max_concurrency, health_status(healthy|degraded|cooldown), enabled, created_at, updated_at`
### 5.4 models + channel_model_bindings
`models`（全局模型 + 价格）：
| 字段 | 类型 |
| --- | --- |
| id, name(全局名如 `claude-sonnet-5`), display_name | |
| input_price / output_price / cache_read_price | numeric(20,8)（每百万 token） |
| enabled, sort | |
### 6.4 models + channel_model_bindings
- `models`：`id, name(全局名如 claude-sonnet-5), display_name, input_price, output_price, cache_read_price(每百万token), enabled, sort`
- `channel_model_bindings`：`id, channel_id FK, model_id FK, upstream_model, weight`
`channel_model_bindings`（多对多）：
| 字段 | 类型 |
| --- | --- |
| id, channel_id FK, model_id FK | |
| upstream_model | text（如 `us.anthropic.com:claude-sonnet-5`） |
| weight | int |
### 6.5 usage_logs（请求级明细，索引 `(user_id, created_at)`）
`id, request_id(上游id), user_id FK, key_id FK, channel_id FK, model_id FK, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, input_price, output_price, cache_read_price(快照), cost, latency_ms, status(success|error|canceled), error_code?, created_at`
### 5.5 usage_logs（请求级明细）
| 字段 | 类型 |
| --- | --- |
| id, request_id(上游 id), user_id FK, key_id FK, channel_id FK, model_id FK | |
| input_tokens / output_tokens / cache_read_tokens / cache_creation_tokens | bigint |
| input_price / output_price / cache_read_price | numeric(20,8) 快照 |
| cost | numeric(20,8) |
| latency_ms | int |
| status | enum(`success`,`error`,`canceled`) |
| error_code | text nullable |
| created_at | timestamptz，带索引 `(user_id, created_at)` |
### 6.6 usage_daily（日聚合）
`id, user_id FK, model_id FK, date, requests, input_tokens, output_tokens, cache_read_tokens, cost`
### 5.6 usage_daily（日聚合）
`id, user_id, model_id, date, requests, input_tokens, output_tokens, cache_read_tokens, cost`
### 6.7 recharge_orders（预留）
`id, user_id FK, amount, status(pending|credited|rejected), method(manual|online), transaction_id?, reviewed_by FK?, reviewed_at?, remark?, created_at`
### 5.7 recharge_orders
`id, user_id FK, amount numeric(20,8), status enum(pending/credited/rejected), method enum(manual/online), transaction_id, reviewed_by FK, reviewed_at, remark, created_at`
### 6.8 balance_logs（余额流水）
`id, user_id FK, change, balance_after, type(recharge|usage|refund|admin_adjust), ref_id?, created_at`
### 5.8 balance_logs（余额流水，幂等保证）
`id, user_id FK, change numeric(20,8), balance_after numeric(20,8), type enum(recharge/usage/refund/admin_adjust), ref_id, created_at`
### 5.9 system_configs
### 6.9 system_configs
`key text PK, value jsonb`
---
## 6. API 设计
## 7. API 设计
### 6.1 代理端点（对外，Bearer API Key 认证）
### 7.1 代理端点（对外，Bearer API Key 认证）
| 方法 | 路径 | 说明 |
| --- | --- | --- |
| POST | `/v1/responses` | OpenAI Responses API |
| POST | `/v1/chat/completions` | OpenAI Chat 格式 |
| POST | `/v1/messages` | Anthropic Messages |
| POST | `/v1/messages` | Anthropic Messages（M4 上） |
| GET | `/v1/models` | 可用模型列表（OpenAI 风格） |
### 6.2 管理 API（`/api/v1`，会话认证）
### 7.2 管理 API（`/api/v1`，会话认证）
**认证/用户**
- `POST auth/register` · `POST auth/login` · `POST auth/logout` · `GET auth/me`
- `GET user/profile` · `GET user/balance`
**认证/用户**：`POST auth/register|login|logout|refresh` · `GET auth/me` · `GET user/profile|balance|models`
**API Key**
- `GET/POST /keys` · `PATCH/DELETE /keys/:id`
**API Key**：`GET|POST /keys` · `PATCH|DELETE /keys/:id`
**用量**
- `GET /usage/summary`（今日/本月汇总）
- `GET /usage/stats?from&to&group=day|model`
- `GET /usage/logs?from&to&page&model&keyId`
**用量**：`GET /usage/summary` · `GET /usage/stats?from&to&group=day|model` · `GET /usage/logs?from&to&page&model&keyId`
**充值**
- `POST /recharges` · `GET /recharges`（暂停，接口预留）
**充值（预留）**：`POST /recharges` · `GET /recharges`
**管理后台（`/api/v1/admin`，仅 admin）**
- `GET/POST/PUT/DELETE /channels` · `POST /channels/:id/test`
- `GET/POST/PUT /models` · `PUT /models/:id/price`
- `GET|POST|PUT|DELETE /channels` · `POST /channels/:id/test`
- `GET|POST|PUT /models` · `PUT /models/:id/price`
- `GET /users` · `PATCH /users/:id` · `POST /users/:id/balance`
- `GET /recharges` · `POST /recharges/:id/approve|reject`（暂停，接口预留）
- `GET /recharges` · `POST /recharges/:id/approve|reject`（预留）
- `GET /usage` · `GET /stats/overview`
- `GET/PUT /config`
- `GET|PUT /config`
---
## 7. 前端设计（taste-skill）
## 8. 前端设计（taste-skill）
### 7.1 设计流程
### 8.1 设计流程
1. 前端阶段启动时**调用 taste-skill**：传入产品 brief 与页面清单，由它推断设计方向，产出：
- 设计 tokens：色板（含暗色/亮色）、字体系统、间距、圆角、阴影、栅格。
- 核心页面高保真方向（先做 3–5 个代表页，不一次铺开）。
2. 以 tokens 建立 Tailwind 主题（tailwind.config + CSS variables）与基础组件（Button / Table / Form / Modal / Nav）。
3. 按页面清单逐组实现，每个阶段结束用 **web-design-guidelines** 复查（对比度、可访问性、交互细节）。
- 设计 tokens：色板（含暗/亮色）、字体系统、间距、圆角、阴影、栅格。
- 3–5 个代表页的高保真方向（不一次铺开）。
2. 以 tokens 建立 Tailwind 主题（`tailwind.config` + CSS variables）与基础组件（Button/Table/Form/Modal/Nav）。
3. 按页面清单逐组实现，每阶段结束用 **web-design-guidelines** 复查（对比度、可访问性、交互细节）。
4. 设计评审迭代，**不套模板**。
### 7.2 预期设计方向（taste-skill 最终决定，此处为倾向）
### 8.2 预期设计方向（taste-skill 最终决定，此处为倾向）
开发者工具 / API 网关类产品：
开发者工具 / API 网关类产品，倾向：
- 深色优先、仪表盘质感；等宽字体点缀 token、端点、代码片段。
- 数据密度高的表格（用量、密钥、订单），克制的中性色 + 单一强调色。
- Landing 简洁可信：产品价值、端点示例、模型列表预览。
### 7.3 页面清单
### 8.3 页面清单
| 区域 | 页面 |
| --- | --- |
| 公开 | Landing · 登录 · 注册 |
| 用户 | Dashboard（余额/今日用量/最近请求/图表）· API Keys · 用量查询 · 充值（后置） · 个人设置 |
| 管理 | 运营总览 · 渠道管理（API 类型 + 模型导入） · 模型与定价 · 用户管理 · 充值审核（后置） · 全局用量 · 系统配置 |
| 用户 | Dashboard（余额/今日用量/最近请求/图表）· API Keys · 用量查询 · 个人设置 |
| 管理 | 运营总览 · 渠道管理（API 类型 + 模型导入）· 模型与定价 · 用户管理 · 充值审核（后置）· 全局用量 · 系统配置 |
### 7.4 前端工程注意点
### 8.4 前端工程注意点
- 流式调试体验：控制台页提供"用 curl / 请求编辑器"快速验证 key 与模型（可选，v2）。
- 图表统一用 ECharts，暗色主题与设计 tokens 对齐。
- 表格/表单为自建组件，行为一致性优先，后续可沉淀为内部组件库。
- 流式调试体验：控制台页提供"curl / 请求编辑器"快速验证 key 与模型（可选，v2）。
- 图表统一 ECharts，暗色主题对齐 tokens。
- 表格/表单为自建组件，行为一致性优先，可沉淀为内部组件库。
---
## 8. 非功能需求
## 9. 非功能需求
| 类别 | 要求 |
| --- | --- |
| 安全 | API Key 仅存哈希；渠道密钥加密存储；密码 argon2id；JWT 刷新令牌 HttpOnly；日志/错误信息脱敏（不泄露渠道 key、完整 key）；CORS 白名单；管理接口二次鉴权 |
| 安全 | API Key 仅存哈希；渠道密钥加密；密码 argon2id；JWT refresh HttpOnly；日志/错误脱敏（不泄渠道 key、完整 key）；CORS 白名单；管理接口二次鉴权 |
| 限流 | Redis token bucket：用户级 + 密钥级 + 全局并发保护 |
| 稳定性 | 渠道 cooldown + 重试；流式请求 client 断连即取消上游调用（ctx cancel）；上游超时兜底 |
| 稳定性 | 渠道 cooldown + 重试；流式 client 断连即取消上游（ctx cancel）；上游超时兜底 |
| 可观测 | zap 结构化日志 + request_id；Prometheus 指标（请求数/延迟/错误率/成本）；管理后台健康概览 |
| 性能 | 流式零缓冲转发；记账异步批量落库；聚合查询走预聚合表 |
| 性能 | 流式零缓冲转发；记账异步批量落库；聚合走预聚合表 |
| 合规 | 用户协议与数据留存说明；退款/冲正流程可追溯 |
---
## 9. 仓库结构（规划）
## 10. 里程碑与任务分解
> 目标：**MVP（M0–M3）先交付**；M4/M5 按需后置。每阶段含验收点。
### M0 基建（◻ 重做，参考旧实现）
配置、启动、DB 迁移、日志、CORS、健康检查、mock 上游。
**验收**：`make run` + `make mock-upstream` 起服务，`/healthz` OK。
### M1 用户 + 密钥 + 核心代理（◻ 重做，参考旧实现）
注册/登录/JWT、API Key、chat/responses/models 直通、基础记账扣费。
**验收**：curl 冒烟（注册→登录→建 key→对话→查用量）。
### M2 前端 MVP + 管理后台基础（✅ 已完成）
- 前端：taste-skill 定 tokens → Tailwind 主题 → 自建组件 → Landing/登录/注册/控制台（Dashboard/Keys/Usage）→ 管理后台（运营总览/渠道/模型/用户/配置）。
- 后端：渠道 CRUD + 测试 + 模型导入、模型管理 + 定价 + 绑定、全局用量/统计接口。
- 已过 web-design-guidelines 复查并修复（移动端侧栏、表格横向滚动、模态框焦点/滚动锁、focus-visible、aria 等）。
**验收**：用户在控制台建 key、发请求、看用量；管理员能加渠道、调价、看统计。
### M3 管理后台前端 + 计费完善（◻ 部分完成）
渠道/模型/用户/总览/配置页面已完成；`usage_daily` 趋势图已内建（自建 SVG）。待做：限流接入、加载骨架屏、按模型聚合报表增强。
### M4 协议转换（✅ 已完成）
- `convert` 包：Chat↔Messages↔Responses 请求/响应 JSON 转换 + 流式 SSE 逐行状态机转换器（含单测）。
- `/v1/messages` 端点；网关按"客户端协议 × 渠道 provider"自动转换，协议匹配直通。
- 流式 usage 合并记账（message_start input + message_delta output）；错误体按协议返回。
- mock 上游新增 Anthropic Messages 端点，端到端验证 8 种组合（三协议 × 直通/转换 × 流式/非流式）。
**验收**：chat 调 Claude、messages 调 OpenAI、responses 调 Claude 均正确，流式逐事件转换，usage 记账准确。
### M5 渠道体系完善（◻ 规划）
健康检查、负载均衡、重试/故障转移、并发控制、模型自动导入。
**验收**：杀一个渠道自动切换；连续失败进 cooldown 并恢复。
### M6 充值 + 审核（◻ 待定，接口/模型已预留）
充值订单、人工审核、流水留痕、前端页面。
**验收**：管理员审核充值→余额到账→流水可查。
---
## 11. 仓库结构（规划）
```
openteam/
@@ -481,58 +496,37 @@ openteam/
│ │ │ ├── openai/ # OpenAI Chat 格式编解码
│ │ │ ├── claude/ # Anthropic Messages 格式编解码
│ │ │ ├── convert/ # 标准模型 ↔ 各协议转换
│ │ │ └── stream/ # SSE 双向流式转发
│ │ ├── channel/ # 渠道、负载均衡、健康检查、重试
│ │ │ └── stream/ # SSE/事件流双向转发
│ │ ├── channel/ # 渠道、LB、健康检查、重试
│ │ ├── billing/ # 计价、余额、流水
│ │ ├── usage/ # 记账、聚合
│ │ ├── recharge/ # 订单（待定方案）
│ │ ├── recharge/ # 订单（待定）
│ │ ├── admin/ # 管理 API
│ │ ├── store/ # GORM models + repositories
│ │ └── pkg/ # jwt, crypto, ratelimit, tiktoken
├── web/ # Vue3 前端
│ ├── src/styles/ # taste-skill 设计 tokens
│ ├── src/components/ # 基础组件
│ ├── src/views/ # 页面
│ ├── src/views/ # 页面（含 admin/）
│ ├── src/stores/ · src/api/ · src/router/
├── deploy/ # docker-compose, nginx, Dockerfile
├── scripts/mockupstream/ # mock 上游（联调）
└── docs/
```
---
## 10. 开发里程碑
## 12. 开放决策项（编码前需确认）
| 里程碑 | 内容 | 验收标准 |
| --- | --- | --- |
| **M0 基建** | 仓库结构、配置、DB 迁移、JWT/密码工具、CI；taste-skill 启动产出设计 tokens | 空服务可启动，tokens 落地 |
| **M1 用户+密钥+核心代理** | 注册/登录/角色、API Key CRUD；`/v1/responses` 与 `/v1/chat/completions` 直连 OpenAI 渠道（非流式+流式，直通）；OpenAI 错误格式 | 用 curl 完成一次带流式的对话与一次 Responses 调用；密钥可建可吊销 |
| **M2 用量+计费** | 记账、token 统计、价格表、余额扣减、用量 API；前端 Dashboard/用量页 | 请求后余额正确变化，用量图表正确 |
| **M3 跨协议转换** | `/v1/messages` 代理；Responses ↔ Chat ↔ Messages 转换（含流式、工具调用）；Anthropic 渠道 | OpenAI 客户端调 Claude 模型、Anthropic 客户端调 OpenAI 模型均通 |
| **M4 渠道系统** | 渠道 CRUD（API 类型）、`/models` 模型导入、模型绑定、负载均衡、健康检查、重试/故障转移；管理后台渠道页 | 一个渠道挂掉自动切换；后台可加渠道、拉取模型并测试 |
| **M5 充值（暂停）** | 方案待定，首版不做；仅预留订单表与状态机 | — |
| **M6 打磨上线** | 限流、监控指标、审计日志、taste-skill 全站设计复查、docker-compose 部署、文档与测试补全 | 可对外交付部署 |
---
## 11. 风险与待定决策
| # | 事项 | 状态 | 说明 |
| # | 决策 | 选项 | 结论/倾向 |
| --- | --- | --- | --- |
| 1 | **充值** | ⏸ 暂停 | 首版不做，订单表与状态机预留，方案确定后再落地 |
| 2 | **注册策略** | ✅ 已确认 | 开放注册，配置可切换邀请码 |
| 3 | **协议范围** | ✅ 已确认 | Responses + Chat Completions + Anthropic Messages；去掉 legacy `/v1/completions` |
| 4 | **流式重试边界**：首字节发出后不可重试 | ✅ 已决策 | 仅连接建立前重试；文档明示 |
| 5 | **Responses 跨协议有损边界** | 🟡 实现中确认 | `previous_response_id`、`reasoning` 跨协议降级/丢弃，加 `x-converted` 头 |
| 6 | **模型列表导入差异** | 🟡 实现中确认 | 部分渠道无 `/v1/models`，需手动录入 fallback |
| 7 | **计费精度**：Claude 缓存 token、上游缺 usage | ✅ 已决策 | 冗余快照价格；近似计数 fallback |
| 8 | **多实例扩展**：记账时序 | 🟡 后置 | 单实例起步，必要时引入消息队列 |
| 9 | **合规**：数据留存、日志脱敏 | 🟡 上线前 | 隐私说明、审计日志 |
| 1 | **工作区恢复方式**（§2.3） | 从 git 恢复 / 推倒重来 | ✅ **推倒重来**（已定） |
| 2 | 限流起步 | Redis / 内存计数降级 | MVP 内存起步，Redis 后置 |
| 3 | Token 计数 fallback | 近似估算 / tiktoken-go | 起步近似，精确化后置 |
| 4 | 计费币种 | USD 记账 + 前端汇率 / 人民币 | USD 记账 |
| 5 | 充值方案（M6） | 人工审核 / 在线支付 | 人工审核起步 |
| 6 | 组件基座 | 纯自建 / headless 原语（Ark UI 等） | 纯自建起步 |
---
## 12. 下一步
范围已收敛：**代理（三协议）+ 用户管理 + 用量计费 + 渠道管理**，充值暂停。
1. 无阻塞性待定项，可按 **M0 → M1** 开始实施；taste-skill 先行产出设计方向，后端同时搭骨架。
2. 实施中确认两处细节：Responses 跨协议降级边界（§11 #5）、模型导入的渠道差异（#6）。
*本文档 v0.3 由 v0.2 修订：明确 Tailwind + taste-skill 选型、标注 M0+M1 状态、里程碑按"代理/管理/计费"三板块组织、补开放决策项；并已确认**推倒重来**（旧实现仅作参考）。*
README.md
+51 -38
View File
@@ -2,24 +2,32 @@
自托管的 LLM API 中转网关，功能对标 OpenRouter / one-api：统一 OpenAI 与 Anthropic 协议入口，背后对接多个上游渠道，内置用户体系、API Key 管理与用量计费。
> 规划文档见 [PLANNING.md](./PLANNING.md)。当前进度：**M0（基建）+ M1（用户+密钥+核心代理）已完成**。
> 规划文档见 [PLANNING.md](./PLANNING.md)。当前进度：**M0-M2 + M4 已完成**（基建 + 用户/密钥/核心代理 + 前端 MVP + 管理后台基础 + 三协议互转）。
## 功能（当前）
- **代理端点**（Bearer API Key）
- `POST /v1/chat/completions` — OpenAI Chat（非流式 + 流式 SSE）
- `POST /v1/responses` — OpenAI Responses API（非流式 + 流式事件）
- `POST /v1/messages` — Anthropic Messages API（非流式 + 流式事件）
- `GET /v1/models` — 可用模型列表
- 错误统一为 OpenAI 格式（401/402/404/429/502…）
- **用户体系**：注册（开放/邀请码可切换）、登录（JWT access + HttpOnly refresh cookie）、argon2id 密码
- **三协议互转**：客户端协议 × 渠道协议不匹配时自动转换（如 Chat 调用 Claude、Messages 调用 OpenAI、Responses 调用 Claude），流式逐事件转换；协议匹配时直通
- 错误按客户端协议返回（OpenAI 格式 / Anthropic 格式）
- **用户体系**：注册（开放/邀请码可切换，管理后台可改）、登录（JWT access + HttpOnly refresh cookie）、argon2id 密码
- **API Key**：`sk-` 48 位 base62，仅存 SHA-256 哈希，明文一次性展示；支持限额/过期/白名单字段
- **用量计费**：请求级 `usage_logs` 异步批量落库，按模型价格扣减余额，日粒度预聚合（`usage_daily`）
- **管理 API**：用户列表/角色/状态/余额调整、系统配置
- **前端**：Landing / 登录注册 / 控制台（仪表盘 + 密钥管理 + 用量明细）
- **管理 API**：渠道 CRUD + 连通测试 + 模型导入、模型管理 + 定价 + 渠道绑定、用户管理、全局用量/统计、系统配置
- **前端**（Vue3 + Tailwind，taste-skill 设计，深色优先）
- Landing / 登录 / 注册
- 控制台：Dashboard（余额/用量/趋势图）、API Keys、用量明细
- 管理后台：运营总览、渠道管理、模型与定价、用户管理、系统配置
- **后端**：Go + Gin + GORM，SQLite（开发）/ PostgreSQL（生产）
> 渠道健康检查/负载均衡/重试在 M5（见 PLANNING.md §10）。
## 快速开始（开发）
前置：Go 1.23+、Node 20+、pnpm。
前置：Go 1.23+。
```bash
# 1. 配置（复制并修改，至少设置上游 key）
@@ -29,13 +37,12 @@ cp .env.example .env
cd server && go run ./cmd/server
# 默认管理员 admin / admin123（生产务必修改）
# 3. 启动前端
cd web && pnpm i && pnpm dev # http://localhost:5173
# 4. 用 mock 上游联调（无需真实 key）
# 3. 用 mock 上游联调（无需真实 key，另开终端）
make mock-upstream # :9000 起一个模拟 OpenAI 服务
```
`.env` 中 `OT_PROXY_UPSTREAM_KEY` / `OT_PROXY_UPSTREAM_BASE_URL` 指向 mock 上游时，服务首次启动会自动创建默认渠道与示例模型。
### 冒烟测试（curl）
```bash
@@ -49,42 +56,48 @@ KEY=$(curl -s -X POST localhost:8080/api/v1/keys -H "Authorization: Bearer $TOKE
# 对话（非流式 + 流式）
curl -s localhost:8080/v1/chat/completions -H "Authorization: Bearer $KEY" \
-H 'Content-Type: application/json' -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"hi"}]}'
curl -sN localhost:8080/v1/chat/completions -H "Authorization: Bearer $KEY" \
-H 'Content-Type: application/json' -d '{"model":"gpt-4o-mini","stream":true,"messages":[{"role":"user","content":"hi"}]}'
-H 'Content-Type: application/json' \
-d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"你好"}],"stream":false}'
curl -N localhost:8080/v1/chat/completions -H "Authorization: Bearer $KEY" \
-H 'Content-Type: application/json' \
-d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"你好"}],"stream":true}'
# 用量
curl -s localhost:8080/api/v1/usage/summary -H "Authorization: Bearer $TOKEN"
curl -s "localhost:8080/api/v1/usage/logs?page_size=5" -H "Authorization: Bearer $TOKEN"
```
## 生产部署
### 前端（开发）
```bash
cp .env.example .env # 填写 JWT_SECRET / MASTER_KEY / 上游 key
docker compose -f deploy/docker-compose.yml up -d --build
cd web && pnpm i && pnpm dev # http://localhost:5173（/api、/v1 代理到 8080）
```
`nginx` 托管前端静态资源并反代 `/api` 与 `/v1`（SSE 关闭缓冲）。
### 测试
```bash
cd server && go test ./...
cd web && pnpm build # vue-tsc 类型检查 + 构建
```
## 仓库结构
```
server/ Go 后端（cmd + internal/{api,proxy,channel,usage,store,pkg}）
web/ Vue 3 前端（Vite + Tailwind v4 + Pinia + ECharts）
deploy/ docker-compose / Dockerfile / nginx
scripts/ mock 上游（联调用）
docs/ 文档
server/ # Go 后端
cmd/server/ # 入口
internal/
config/ # viper + env（OT_ 前缀）
store/ # GORM models + 连接
pkg/ # apikey / crypto / jwt / resp
api/ # 管理 API（认证、用户、密钥、用量、渠道/模型/管理后台）
proxy/ # 代理网关（鉴权、直通、流式、记账）
channel/ # 渠道选择与密钥解密
usage/ # 异步记账
web/ # Vue3 前端（Tailwind，taste-skill 设计 tokens）
src/
views/ # Landing / 登录注册 / console / admin
components/ # ui（Button/Input/Modal/Badge/Toast/TrendChart）+ layout
stores/ · api/ · router/ · lib/
scripts/mockupstream/ # mock 上游（联调）
deploy/ # Docker 部署（后续里程碑）
```
## 设计系统（taste-skill）
深色优先的开发者控制台：石墨墨底 + 暖白文本 + 单一信号铜色强调（信号灯意象）；UI 字体 Outfit，数据一律 JetBrains Mono（tabular numerals）。tokens 定义于 `web/src/style.css`（`@theme`），支持 `data-theme="light"` 切换。
## 路线图
| 里程碑 | 状态 |
| --- | --- |
| M0 基建（结构/配置/DB/工具/CI 前身） | ✅ |
| M1 用户 + 密钥 + 核心代理（chat/responses 直通） | ✅ |
| M2 用量 + 计费（记账/价格/前端图表） | 🟡 后端已备，前端图表就绪 |
| M3 跨协议转换（/v1/messages、Responses↔Chat↔Messages） | ⏳ |
| M4 渠道系统（导入/绑定/LB/健康检查/重试） | ⏳ |
| M5 充值（暂停，表结构已预留） | ⏸ |
| M6 打磨上线（限流/监控/审计/全站复查） | ⏳ |
deploy/Dockerfile.api
-15
View File
@@ -1,15 +0,0 @@
# API 镜像：多阶段构建 Go 二进制
FROM golang:1.26-alpine AS builder
WORKDIR /src
COPY server/go.mod server/go.sum ./
RUN go mod download
COPY server/ .
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/openteam ./cmd/server
FROM alpine:3.21
RUN adduser -D -u 10001 app
USER app
WORKDIR /app
COPY --from=builder /out/openteam /app/openteam
EXPOSE 8080
ENTRYPOINT ["/app/openteam"]
deploy/Dockerfile.web
-12
View File
@@ -1,12 +0,0 @@
# 前端镜像：构建静态资源 + nginx
FROM node:24-alpine AS builder
WORKDIR /src
COPY web/package.json web/pnpm-lock.yaml ./
RUN corepack enable && pnpm install --frozen-lockfile
COPY web/ .
RUN pnpm build
FROM nginx:1.27-alpine
COPY deploy/nginx.conf /etc/nginx/conf.d/default.conf
COPY --from=builder /src/dist /usr/share/nginx/html
EXPOSE 80
deploy/docker-compose.yml
-54
View File
@@ -1,54 +0,0 @@
# ===== openteam 单实例部署（nginx + api + postgres）=====
# 使用：cp .env.example ../.env 并修改密钥，然后 docker compose up -d
services:
api:
build:
context: ..
dockerfile: deploy/Dockerfile.api
restart: unless-stopped
environment:
OT_ENV: production
OT_PORT: "8080"
OT_DB_DRIVER: postgres
OT_DB_DSN: host=postgres user=openteam password=${OT_DB_PASSWORD:-openteam} dbname=openteam port=5432 sslmode=disable
OT_JWT_SECRET: ${OT_JWT_SECRET:?set in .env}
OT_MASTER_KEY: ${OT_MASTER_KEY:?set in .env}
OT_ADMIN_PASSWORD: ${OT_ADMIN_PASSWORD:-admin123}
OT_PROXY_UPSTREAM_KEY: ${OT_PROXY_UPSTREAM_KEY:-}
OT_PROXY_UPSTREAM_BASE_URL: ${OT_PROXY_UPSTREAM_BASE_URL:-https://api.openai.com}
OT_PROXY_DEFAULT_MODEL: ${OT_PROXY_DEFAULT_MODEL:-gpt-4o-mini}
depends_on:
postgres:
condition: service_healthy
# 预留 Redis（M6 限流）；当前单实例不依赖
# redis:
# image: redis:7-alpine
# restart: unless-stopped
postgres:
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_USER: openteam
POSTGRES_PASSWORD: ${OT_DB_PASSWORD:-openteam}
POSTGRES_DB: openteam
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U openteam"]
interval: 5s
timeout: 3s
retries: 10
web:
build:
context: ..
dockerfile: deploy/Dockerfile.web
restart: unless-stopped
ports:
- "${OT_HTTP_PORT:-80}:80"
depends_on:
- api
volumes:
pgdata:
deploy/nginx-public.conf
-45
View File
@@ -1,45 +0,0 @@
# openteam 公网部署（IP+端口方式）：宿主 8088 单端口入口
# nginx 容器使用 host 网络，反代走 loopback 避开 DNAT 干扰
server {
listen 8088;
server_name _;
root /usr/share/nginx/html;
index index.html;
# SPA 路由回退
location / {
try_files $uri $uri/ /index.html;
}
# 管理 API + 代理端点 → 本机 openteam（127.0.0.1 loopback 不经 iptables DNAT）
location /api/ {
proxy_pass http://127.0.0.1:8080;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_read_timeout 300s;
}
location /v1/ {
proxy_pass http://127.0.0.1:8080;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# SSE 流式透传：关闭缓冲
proxy_buffering off;
proxy_cache off;
proxy_read_timeout 300s;
}
# 静态资源缓存
location /assets/ {
expires 30d;
add_header Cache-Control "public, immutable";
}
gzip on;
gzip_types text/plain text/css application/json application/javascript image/svg+xml;
}
deploy/nginx.conf
-42
View File
@@ -1,42 +0,0 @@
server {
listen 80;
server_name _;
root /usr/share/nginx/html;
index index.html;
# SPA 路由回退
location / {
try_files $uri $uri/ /index.html;
}
# 管理 API + 代理端点 → Go 服务
location /api/ {
proxy_pass http://api:8080;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location /v1/ {
proxy_pass http://api:8080;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# SSE 流式透传：关闭缓冲
proxy_buffering off;
proxy_cache off;
proxy_read_timeout 300s;
}
# 静态资源缓存
location /assets/ {
expires 30d;
add_header Cache-Control "public, immutable";
}
gzip on;
gzip_types text/plain text/css application/json application/javascript image/svg+xml;
}
scripts/mockupstream/go.mod
+2 -2
View File
@@ -1,3 +1,3 @@
module mockupstream
module scripts/mockupstream
go 1.26.5
go 1.23.0
scripts/mockupstream/main.go
+52 -3
View File
@@ -1,5 +1,5 @@
// mockupstream 本地 mock OpenAI 上游服务（联调代理链路，无需真实 key）。
// 支持 /v1/chat/completions 与 /v1/responses，含流式与非流式。
// 支持 /v1/chat/completions 与 /v1/responses，含流式与非流式；/v1/models 返回模型列表。
package main
import (
@@ -46,13 +46,63 @@ func main() {
http.HandleFunc("/v1/models", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
fmt.Fprint(w, `{"object":"list","data":[{"id":"gpt-4o-mini","object":"model"},{"id":"gpt-4o","object":"model"}]}`)
fmt.Fprint(w, `{"object":"list","data":[{"id":"gpt-4o-mini","object":"model"},{"id":"gpt-4o","object":"model"},{"id":"claude-sonnet-5","object":"model"}]}`)
})
// Anthropic Messages 端点（provider=anthropic 的渠道走这里）
http.HandleFunc("/v1/messages", func(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(r.Body)
var req struct {
Model string `json:"model"`
Stream bool `json:"stream"`
}
_ = json.Unmarshal(body, &req)
if req.Stream {
streamMessages(w, req.Model)
return
}
replyMessages(w, req.Model)
})
log.Printf("mock upstream listening on %s", *addr)
log.Fatal(http.ListenAndServe(*addr, nil))
}
func replyMessages(w http.ResponseWriter, model string) {
w.Header().Set("Content-Type", "application/json")
resp := map[string]any{
"id": "msg_mock789",
"type": "message",
"role": "assistant",
"model": model,
"content": []any{map[string]any{"type": "text", "text": "这是 mock Anthropic 上游的回复。"}},
"stop_reason": "end_turn",
"usage": map[string]any{"input_tokens": 14, "output_tokens": 10},
}
_ = json.NewEncoder(w).Encode(resp)
}
func streamMessages(w http.ResponseWriter, model string) {
w.Header().Set("Content-Type", "text/event-stream")
fl, _ := w.(http.Flusher)
events := []map[string]any{
{"type": "message_start", "message": map[string]any{"id": "msg_mock789", "type": "message", "role": "assistant", "model": model, "content": []any{}, "usage": map[string]any{"input_tokens": 14, "output_tokens": 0}}},
{"type": "content_block_start", "index": 0, "content_block": map[string]any{"type": "text", "text": ""}},
{"type": "content_block_delta", "index": 0, "delta": map[string]any{"type": "text_delta", "text": "这是"}},
{"type": "content_block_delta", "index": 0, "delta": map[string]any{"type": "text_delta", "text": " Anthropic"}},
{"type": "content_block_stop", "index": 0},
{"type": "message_delta", "delta": map[string]any{"stop_reason": "end_turn", "stop_sequence": nil}, "usage": map[string]any{"output_tokens": 10}},
{"type": "message_stop"},
}
for _, e := range events {
b, _ := json.Marshal(e)
typ, _ := e["type"].(string)
fmt.Fprintf(w, "event: %s\ndata: %s\n\n", typ, b)
fl.Flush()
time.Sleep(40 * time.Millisecond)
}
}
func replyChat(w http.ResponseWriter, model string) {
w.Header().Set("Content-Type", "application/json")
resp := map[string]any{
@@ -80,7 +130,6 @@ func streamChat(w http.ResponseWriter, model string) {
"choices": []any{map[string]any{
"index": 0,
"delta": map[string]any{"content": c},
"finish_reason": nil,
}},
}
if i == len(chunks)-1 {
server/cmd/server/main.go
+2 -23
View File
@@ -9,6 +9,7 @@ import (
"net/http"
"os"
"os/signal"
"strconv"
"syscall"
"time"
@@ -34,7 +35,7 @@ func main() {
router := api.NewRouter(a, gw)
srv := &http.Server{
Addr: ":" + itoa(cfg.Port),
Addr: ":" + strconv.Itoa(cfg.Port),
Handler: router,
ReadHeaderTimeout: 10 * time.Second,
}
@@ -58,25 +59,3 @@ func main() {
}
a.Usage.Close()
}
func itoa(n int) string {
if n == 0 {
return "8080"
}
neg := n < 0
if neg {
n = -n
}
var b [12]byte
i := len(b)
for n > 0 {
i--
b[i] = byte('0' + n%10)
n /= 10
}
if neg {
i--
b[i] = '-'
}
return string(b[i:])
}
server/go.mod
+1 -1
View File
@@ -1,6 +1,6 @@
module github.com/openteam/server
go 1.26.5
go 1.25.0
require (
github.com/gin-gonic/gin v1.12.0
server/internal/api/admin.go
+53 -43
View File
@@ -2,7 +2,6 @@ package api
import (
"encoding/json"
"fmt"
"net/http"
"strconv"
"time"
@@ -11,6 +10,7 @@ import (
"github.com/openteam/server/internal/pkg/resp"
"github.com/openteam/server/internal/store"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
// AdminUsers GET /api/v1/admin/users — 用户列表（搜索、分页）。
@@ -38,7 +38,7 @@ func (h *Handler) AdminUsers(c *gin.Context) {
resp.OK(c, gin.H{"items": out, "total": total, "page": page, "page_size": size})
}
// AdminPatchUser PATCH /api/v1/admin/users/:id — 角色/状态/余额。
// AdminPatchUser PATCH /api/v1/admin/users/:id — 角色/状态。
func (h *Handler) AdminPatchUser(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
@@ -53,11 +53,6 @@ func (h *Handler) AdminPatchUser(c *gin.Context) {
resp.Fail(c, http.StatusBadRequest, "invalid input")
return
}
var u store.User
if err := h.a.DB.First(&u, id).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "user not found")
return
}
updates := map[string]any{}
if req.Role != nil {
if *req.Role != store.RoleUser && *req.Role != store.RoleAdmin {
@@ -73,42 +68,57 @@ func (h *Handler) AdminPatchUser(c *gin.Context) {
}
updates["status"] = *req.Status
}
if len(updates) > 0 {
h.a.DB.Model(&u).Updates(updates)
if len(updates) == 0 {
resp.OK(c, gin.H{"ok": true})
return
}
res := h.a.DB.Model(&store.User{}).Where("id = ?", id).Updates(updates)
if res.Error != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to update user")
return
}
if res.RowsAffected == 0 {
resp.Fail(c, http.StatusNotFound, "user not found")
return
}
resp.OK(c, gin.H{"ok": true})
}
// AdminAdjustBalance POST /api/v1/admin/users/:id/balance — 调整余额并写流水。
// AdminAdjustBalance POST /api/v1/admin/users/:id/balance — 手动调余额（写流水）。
func (h *Handler) AdminAdjustBalance(c *gin.Context) {
admin, _ := userFromContext(c)
admin := sessionUser(c)
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid user id")
return
}
var req struct {
Change float64 `json:"change" binding:"required"`
Amount float64 `json:"amount" binding:"required"`
Remark string `json:"remark"`
}
if err := c.ShouldBindJSON(&req); err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid input: change is required")
resp.Fail(c, http.StatusBadRequest, "invalid input: amount required")
return
}
var u store.User
if err := h.a.DB.First(&u, id).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "user not found")
if req.Amount == 0 {
resp.Fail(c, http.StatusBadRequest, "amount must not be zero")
return
}
newBalance := u.Balance + req.Change
ref := fmt.Sprintf("admin:%d:%d", admin.ID, time.Now().UnixNano())
err = h.a.DB.Transaction(func(tx *gorm.DB) error {
if err := tx.Model(&store.User{}).Where("id = ?", u.ID).Update("balance", newBalance).Error; err != nil {
var u store.User
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&u, id).Error; err != nil {
return err
}
newBalance := u.Balance + req.Amount
if err := tx.Model(&store.User{}).Where("id = ?", id).Update("balance", newBalance).Error; err != nil {
return err
}
ref := "admin:" + strconv.FormatUint(u.ID, 10) + ":" + time.Now().Format("20060102150405")
_ = admin.ID // 流水里不冗余管理员 ID；需要时再加
return tx.Create(&store.BalanceLog{
UserID: u.ID,
Change: req.Change,
Change: req.Amount,
BalanceAfter: newBalance,
Type: store.BalanceTypeAdminAdjust,
RefID: ref,
@@ -116,45 +126,45 @@ func (h *Handler) AdminAdjustBalance(c *gin.Context) {
}).Error
})
if err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to adjust balance")
resp.Fail(c, http.StatusNotFound, "user not found or failed to adjust")
return
}
resp.OK(c, gin.H{"ok": true, "balance": newBalance})
resp.OK(c, gin.H{"ok": true})
}
// AdminConfig GET /api/v1/admin/config
// AdminConfig GET /api/v1/admin/config — 全部系统配置。
func (h *Handler) AdminConfig(c *gin.Context) {
var cfgs []store.SystemConfig
h.a.DB.Find(&cfgs)
m := map[string]any{}
for _, cfg := range cfgs {
var v any
_ = json.Unmarshal([]byte(cfg.Value), &v)
m[cfg.Key] = v
if err := h.a.DB.Find(&cfgs).Error; err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to load config")
return
}
m["registration.mode"] = h.a.Cfg.Auth.RegistrationMode
resp.OK(c, gin.H{"config": m})
out := gin.H{}
for _, cfg := range cfgs {
out[cfg.Key] = json.RawMessage(cfg.Value)
}
resp.OK(c, gin.H{"config": out})
}
// AdminPutConfig PUT /api/v1/admin/config
// AdminPutConfig PUT /api/v1/admin/config — 整表覆盖（upsert）。
func (h *Handler) AdminPutConfig(c *gin.Context) {
var req struct {
Config map[string]any `json:"config"`
}
var req map[string]json.RawMessage
if err := c.ShouldBindJSON(&req); err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid input")
return
}
for k, v := range req.Config {
if k == "registration.mode" {
if v == "open" || v == "invite" {
h.a.Cfg.Auth.RegistrationMode = v.(string)
err := h.a.DB.Transaction(func(tx *gorm.DB) error {
for k, v := range req {
cfg := store.SystemConfig{Key: k, Value: string(v)}
if err := tx.Save(&cfg).Error; err != nil {
return err
}
continue
}
b, _ := json.Marshal(v)
cfg := store.SystemConfig{Key: k, Value: string(b)}
h.a.DB.Save(&cfg)
return nil
})
if err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to save config")
return
}
resp.OK(c, gin.H{"ok": true})
}
server/internal/api/admin_channels.go
+333
View File
@@ -0,0 +1,333 @@
package api
import (
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/openteam/server/internal/pkg/resp"
"github.com/openteam/server/internal/store"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
// AdminChannels GET /api/v1/admin/channels — 渠道列表（不返回加密 key，返回掩码）。
func (h *Handler) AdminChannels(c *gin.Context) {
var chs []store.Channel
if err := h.a.DB.Order("id ASC").Find(&chs).Error; err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to load channels")
return
}
out := make([]gin.H, 0, len(chs))
for _, ch := range chs {
masked := ""
if key, err := h.a.Enc.Decrypt(ch.APIKeyEnc); err == nil && len(key) > 8 {
masked = strings.Repeat("*", len(key)-4) + key[len(key)-4:]
} else if err == nil {
masked = "****"
}
out = append(out, gin.H{
"id": ch.ID, "name": ch.Name, "provider": ch.Provider, "base_url": ch.BaseURL,
"api_key_masked": masked, "weight": ch.Weight, "priority": ch.Priority,
"timeout_ms": ch.TimeoutMS, "max_concurrency": ch.MaxConcurrency,
"health_status": ch.HealthStatus, "enabled": ch.Enabled,
"created_at": ch.CreatedAt,
})
}
resp.OK(c, gin.H{"items": out})
}
type channelBody struct {
Name string `json:"name" binding:"required,min=1,max=64"`
Provider string `json:"provider" binding:"required"`
BaseURL string `json:"base_url" binding:"required"`
APIKey string `json:"api_key"`
Weight *int `json:"weight"`
Priority *int `json:"priority"`
TimeoutMS *int `json:"timeout_ms"`
MaxConcurrency *int `json:"max_concurrency"`
Enabled *bool `json:"enabled"`
}
func validateProvider(p string) bool {
return p == store.ChannelProviderOpenAI || p == store.ChannelProviderAnthropic || p == store.ChannelProviderCompatible
}
// AdminCreateChannel POST /api/v1/admin/channels
func (h *Handler) AdminCreateChannel(c *gin.Context) {
var req channelBody
if err := c.ShouldBindJSON(&req); err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid input: "+err.Error())
return
}
if !validateProvider(req.Provider) {
resp.Fail(c, http.StatusBadRequest, "provider must be openai, anthropic or compatible")
return
}
if req.APIKey == "" {
resp.Fail(c, http.StatusBadRequest, "api_key required")
return
}
enc, err := h.a.Enc.Encrypt(req.APIKey)
if err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to encrypt api key")
return
}
ch := store.Channel{
Name: req.Name, Provider: req.Provider, BaseURL: strings.TrimRight(req.BaseURL, "/"),
APIKeyEnc: enc, Weight: intOr(req.Weight, 1), Priority: intOr(req.Priority, 0),
TimeoutMS: intOr(req.TimeoutMS, 120000), MaxConcurrency: intOr(req.MaxConcurrency, 16),
HealthStatus: store.ChannelHealthHealthy, Enabled: boolOr(req.Enabled, true),
}
if err := h.a.DB.Create(&ch).Error; err != nil {
resp.Fail(c, http.StatusConflict, "failed to create channel (name may already exist)")
return
}
resp.Created(c, gin.H{"id": ch.ID, "name": ch.Name})
}
// AdminUpdateChannel PUT /api/v1/admin/channels/:id
func (h *Handler) AdminUpdateChannel(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid channel id")
return
}
var body struct {
Name *string `json:"name"`
Provider *string `json:"provider"`
BaseURL *string `json:"base_url"`
APIKey *string `json:"api_key"`
Weight *int `json:"weight"`
Priority *int `json:"priority"`
TimeoutMS *int `json:"timeout_ms"`
MaxConcurrency *int `json:"max_concurrency"`
HealthStatus *string `json:"health_status"`
Enabled *bool `json:"enabled"`
}
if err := c.ShouldBindJSON(&body); err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid input")
return
}
var ch store.Channel
if err := h.a.DB.First(&ch, id).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "channel not found")
return
}
updates := map[string]any{}
if body.Name != nil {
updates["name"] = *body.Name
}
if body.Provider != nil {
if !validateProvider(*body.Provider) {
resp.Fail(c, http.StatusBadRequest, "provider must be openai, anthropic or compatible")
return
}
updates["provider"] = *body.Provider
}
if body.BaseURL != nil {
updates["base_url"] = strings.TrimRight(*body.BaseURL, "/")
}
if body.APIKey != nil && *body.APIKey != "" {
enc, err := h.a.Enc.Encrypt(*body.APIKey)
if err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to encrypt api key")
return
}
updates["api_key_enc"] = enc
}
if body.Weight != nil {
updates["weight"] = *body.Weight
}
if body.Priority != nil {
updates["priority"] = *body.Priority
}
if body.TimeoutMS != nil {
updates["timeout_ms"] = *body.TimeoutMS
}
if body.MaxConcurrency != nil {
updates["max_concurrency"] = *body.MaxConcurrency
}
if body.HealthStatus != nil {
updates["health_status"] = *body.HealthStatus
}
if body.Enabled != nil {
updates["enabled"] = *body.Enabled
}
if len(updates) > 0 {
if err := h.a.DB.Model(&ch).Updates(updates).Error; err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to update channel")
return
}
}
resp.OK(c, gin.H{"ok": true})
}
// AdminDeleteChannel DELETE /api/v1/admin/channels/:id
func (h *Handler) AdminDeleteChannel(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid channel id")
return
}
res := h.a.DB.Delete(&store.Channel{}, id)
if res.Error != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to delete channel")
return
}
if res.RowsAffected == 0 {
resp.Fail(c, http.StatusNotFound, "channel not found")
return
}
// 清理模型绑定
h.a.DB.Where("channel_id = ?", id).Delete(&store.ChannelModelBinding{})
resp.OK(c, gin.H{"ok": true})
}
// AdminTestChannel POST /api/v1/admin/channels/:id/test — 请求渠道 /v1/models 测连通性。
func (h *Handler) AdminTestChannel(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid channel id")
return
}
var ch store.Channel
if err := h.a.DB.First(&ch, id).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "channel not found")
return
}
key, err := h.a.Enc.Decrypt(ch.APIKeyEnc)
if err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to decrypt channel key")
return
}
url := strings.TrimRight(ch.BaseURL, "/") + "/v1/models"
client := &http.Client{Timeout: 10 * time.Second}
req, _ := http.NewRequest(http.MethodGet, url, nil)
req.Header.Set("Authorization", "Bearer "+key)
req.Header.Set("Accept", "application/json")
start := time.Now()
resp2, err := client.Do(req)
status := store.ChannelHealthHealthy
msg := "ok"
latency := 0
if err != nil {
status = store.ChannelHealthCooldown
msg = err.Error()
} else {
latency = int(time.Since(start).Milliseconds())
if resp2.StatusCode < 200 || resp2.StatusCode >= 300 {
status = store.ChannelHealthCooldown
b, _ := io.ReadAll(io.LimitReader(resp2.Body, 1024))
msg = fmt.Sprintf("http %d: %s", resp2.StatusCode, strings.TrimSpace(string(b)))
}
resp2.Body.Close()
}
h.a.DB.Model(&store.Channel{}).Where("id = ?", ch.ID).Update("health_status", status)
if status != store.ChannelHealthHealthy {
resp.Fail(c, http.StatusBadGateway, msg)
return
}
resp.OK(c, gin.H{"ok": true, "latency_ms": latency, "message": msg})
}
// AdminImportChannelModels POST /api/v1/admin/channels/:id/models/import
// 拉取渠道 GET /v1/models，导入模型库并绑定。
func (h *Handler) AdminImportChannelModels(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid channel id")
return
}
var ch store.Channel
if err := h.a.DB.First(&ch, id).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "channel not found")
return
}
key, err := h.a.Enc.Decrypt(ch.APIKeyEnc)
if err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to decrypt channel key")
return
}
url := strings.TrimRight(ch.BaseURL, "/") + "/v1/models"
client := &http.Client{Timeout: 15 * time.Second}
req, _ := http.NewRequest(http.MethodGet, url, nil)
req.Header.Set("Authorization", "Bearer "+key)
resp2, err := client.Do(req)
if err != nil {
resp.Fail(c, http.StatusBadGateway, "failed to reach channel: "+err.Error())
return
}
defer resp2.Body.Close()
if resp2.StatusCode != http.StatusOK {
resp.Fail(c, http.StatusBadGateway, "channel returned http "+strconv.Itoa(resp2.StatusCode))
return
}
var list struct {
Data []struct {
ID string `json:"id"`
} `json:"data"`
}
if err := json.NewDecoder(resp2.Body).Decode(&list); err != nil {
resp.Fail(c, http.StatusBadGateway, "failed to parse model list")
return
}
if len(list.Data) == 0 {
resp.Fail(c, http.StatusNotFound, "channel returned no models")
return
}
imported := 0
err = h.a.DB.Transaction(func(tx *gorm.DB) error {
for _, item := range list.Data {
name := strings.TrimSpace(item.ID)
if name == "" {
continue
}
var m store.Model
if err := tx.Where("name = ?", name).FirstOrCreate(&m, store.Model{
Name: name, DisplayName: name, Enabled: true,
}).Error; err != nil {
return err
}
// upsert 绑定（upstream_model 默认同名）
var binding store.ChannelModelBinding
err := tx.Where("channel_id = ? AND model_id = ?", ch.ID, m.ID).First(&binding).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
binding = store.ChannelModelBinding{ChannelID: ch.ID, ModelID: m.ID, UpstreamModel: name, Weight: 1}
if err := tx.Create(&binding).Error; err != nil {
return err
}
}
imported++
}
return nil
})
if err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to import models")
return
}
resp.OK(c, gin.H{"imported": imported})
}
var _ = clause.Assignments // 保留 gorm/clause 引用（后续定价批处理用）
func intOr(p *int, def int) int {
if p == nil {
return def
}
return *p
}
func boolOr(p *bool, def bool) bool {
if p == nil {
return def
}
return *p
}
server/internal/api/admin_models.go
+199
View File
@@ -0,0 +1,199 @@
package api
import (
"errors"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"github.com/openteam/server/internal/pkg/resp"
"github.com/openteam/server/internal/store"
"gorm.io/gorm"
)
// AdminModels GET /api/v1/admin/models — 模型列表（含价格与渠道绑定）。
func (h *Handler) AdminModels(c *gin.Context) {
var ms []store.Model
if err := h.a.DB.Order("sort ASC, id ASC").Find(&ms).Error; err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to load models")
return
}
out := make([]gin.H, 0, len(ms))
for _, m := range ms {
var bindings []store.ChannelModelBinding
h.a.DB.Preload("Channel").Where("model_id = ?", m.ID).Find(&bindings)
chs := make([]gin.H, 0, len(bindings))
for _, b := range bindings {
chs = append(chs, gin.H{
"id": b.ID, "channel_id": b.ChannelID, "channel_name": b.Channel.Name,
"upstream_model": b.UpstreamModel, "weight": b.Weight,
})
}
out = append(out, gin.H{
"id": m.ID, "name": m.Name, "display_name": m.DisplayName,
"input_price": m.InputPrice, "output_price": m.OutputPrice, "cache_read_price": m.CacheReadPrice,
"enabled": m.Enabled, "sort": m.Sort, "channels": chs,
})
}
resp.OK(c, gin.H{"items": out})
}
// AdminCreateModel POST /api/v1/admin/models
func (h *Handler) AdminCreateModel(c *gin.Context) {
var req struct {
Name string `json:"name" binding:"required,min=1,max=128"`
DisplayName string `json:"display_name"`
InputPrice float64 `json:"input_price"`
OutputPrice float64 `json:"output_price"`
CacheReadPrice float64 `json:"cache_read_price"`
Enabled *bool `json:"enabled"`
}
if err := c.ShouldBindJSON(&req); err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid input: "+err.Error())
return
}
m := store.Model{
Name: req.Name, DisplayName: req.DisplayName,
InputPrice: req.InputPrice, OutputPrice: req.OutputPrice, CacheReadPrice: req.CacheReadPrice,
Enabled: boolOr(req.Enabled, true),
}
if m.DisplayName == "" {
m.DisplayName = m.Name
}
if err := h.a.DB.Create(&m).Error; err != nil {
resp.Fail(c, http.StatusConflict, "failed to create model (name may already exist)")
return
}
resp.Created(c, gin.H{"id": m.ID, "name": m.Name})
}
// AdminUpdateModel PUT /api/v1/admin/models/:id — 价格/展示名/启停/排序。
func (h *Handler) AdminUpdateModel(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid model id")
return
}
var req struct {
DisplayName *string `json:"display_name"`
InputPrice *float64 `json:"input_price"`
OutputPrice *float64 `json:"output_price"`
CacheReadPrice *float64 `json:"cache_read_price"`
Enabled *bool `json:"enabled"`
Sort *int `json:"sort"`
}
if err := c.ShouldBindJSON(&req); err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid input")
return
}
var m store.Model
if err := h.a.DB.First(&m, id).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "model not found")
return
}
updates := map[string]any{}
if req.DisplayName != nil {
updates["display_name"] = *req.DisplayName
}
if req.InputPrice != nil {
updates["input_price"] = *req.InputPrice
}
if req.OutputPrice != nil {
updates["output_price"] = *req.OutputPrice
}
if req.CacheReadPrice != nil {
updates["cache_read_price"] = *req.CacheReadPrice
}
if req.Enabled != nil {
updates["enabled"] = *req.Enabled
}
if req.Sort != nil {
updates["sort"] = *req.Sort
}
if len(updates) > 0 {
if err := h.a.DB.Model(&m).Updates(updates).Error; err != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to update model")
return
}
}
resp.OK(c, gin.H{"ok": true})
}
// AdminDeleteModel DELETE /api/v1/admin/models/:id
func (h *Handler) AdminDeleteModel(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid model id")
return
}
res := h.a.DB.Delete(&store.Model{}, id)
if res.Error != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to delete model")
return
}
if res.RowsAffected == 0 {
resp.Fail(c, http.StatusNotFound, "model not found")
return
}
h.a.DB.Where("model_id = ?", id).Delete(&store.ChannelModelBinding{})
resp.OK(c, gin.H{"ok": true})
}
// AdminCreateModelBinding POST /api/v1/admin/models/:id/bindings
func (h *Handler) AdminCreateModelBinding(c *gin.Context) {
modelID, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid model id")
return
}
var req struct {
ChannelID uint64 `json:"channel_id" binding:"required"`
UpstreamModel string `json:"upstream_model" binding:"required"`
Weight *int `json:"weight"`
}
if err := c.ShouldBindJSON(&req); err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid input: channel_id and upstream_model required")
return
}
var m store.Model
if err := h.a.DB.First(&m, modelID).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "model not found")
return
}
var ch store.Channel
if err := h.a.DB.First(&ch, req.ChannelID).Error; err != nil {
resp.Fail(c, http.StatusNotFound, "channel not found")
return
}
b := store.ChannelModelBinding{
ChannelID: req.ChannelID, ModelID: modelID,
UpstreamModel: req.UpstreamModel, Weight: intOr(req.Weight, 1),
}
if err := h.a.DB.Create(&b).Error; err != nil {
resp.Fail(c, http.StatusConflict, "binding may already exist")
return
}
resp.Created(c, gin.H{"id": b.ID})
}
// AdminDeleteModelBinding DELETE /api/v1/admin/models/:id/bindings/:bid
func (h *Handler) AdminDeleteModelBinding(c *gin.Context) {
bid, err := strconv.ParseUint(c.Param("bid"), 10, 64)
if err != nil {
resp.Fail(c, http.StatusBadRequest, "invalid binding id")
return
}
res := h.a.DB.Delete(&store.ChannelModelBinding{}, bid)
if res.Error != nil {
resp.Fail(c, http.StatusInternalServerError, "failed to delete binding")
return
}
if res.RowsAffected == 0 {
resp.Fail(c, http.StatusNotFound, "binding not found")
return
}
resp.OK(c, gin.H{"ok": true})
}
var _ = errors.Is
var _ = gorm.ErrRecordNotFound
server/internal/api/admin_stats.go
+102
View File
@@ -0,0 +1,102 @@
package api
import (
"strconv"
"time"
"github.com/gin-gonic/gin"
"github.com/openteam/server/internal/pkg/resp"
"github.com/openteam/server/internal/store"
)
// AdminStatsOverview GET /api/v1/admin/stats/overview — 运营总览。
func (h *Handler) AdminStatsOverview(c *gin.Context) {
now := time.Now().UTC()
today := now.Format("2006-01-02")
month := now.Format("2006-01")
var totalUsers int64
h.a.DB.Model(&store.User{}).Count(&totalUsers)
var totalKeys int64
h.a.DB.Model(&store.APIKey{}).Count(&totalKeys)
var totalChannels int64
h.a.DB.Model(&store.Channel{}).Count(&totalChannels)
var totalModels int64
h.a.DB.Model(&store.Model{}).Count(&totalModels)
// 全局今日/本月汇总（跨用户）
var todayReq, monthReq int64
var todayCost, monthCost float64
var todayTokens, monthTokens int64
h.a.DB.Model(&store.UsageDaily{}).Where("date = ?", today).
Select("COALESCE(SUM(requests),0), COALESCE(SUM(cost),0), COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens),0)").
Row().Scan(&todayReq, &todayCost, &todayTokens)
h.a.DB.Model(&store.UsageDaily{}).Where("date LIKE ?", month+"%").
Select("COALESCE(SUM(requests),0), COALESCE(SUM(cost),0), COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens),0)").
Row().Scan(&monthReq, &monthCost, &monthTokens)
// 近 14 天趋势（日粒度）
var days []struct {
Date string
Req int64
Cost float64
}
h.a.DB.Model(&store.UsageDaily{}).
Select("date, SUM(requests) req, SUM(cost) cost").
Where("date >= ?", now.AddDate(0, 0, -13).Format("2006-01-02")).
Group("date").Order("date").Scan(&days)
trend := make([]gin.H, 0, len(days))
for _, d := range days {
trend = append(trend, gin.H{"date": d.Date, "requests": d.Req, "cost": d.Cost})
}
resp.OK(c, gin.H{
"total_users": totalUsers, "total_keys": totalKeys,
"total_channels": totalChannels, "total_models": totalModels,
"today": gin.H{"requests": todayReq, "cost": todayCost, "tokens": todayTokens},
"month": gin.H{"requests": monthReq, "cost": monthCost, "tokens": monthTokens},
"trend_14d": trend,
})
}
// AdminUsage GET /api/v1/admin/usage — 全局用量日志（分页 + 过滤）。
func (h *Handler) AdminUsage(c *gin.Context) {
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
size, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
if page < 1 {
page = 1
}
if size < 1 || size > 100 {
size = 20
}
q := h.a.DB.Model(&store.UsageLog{})
if from := c.Query("from"); from != "" {
q = q.Where("created_at >= ?", from+" 00:00:00")
}
if to := c.Query("to"); to != "" {
q = q.Where("created_at <= ?", to+" 23:59:59")
}
if model := c.Query("model"); model != "" {
q = q.Where("model_name = ?", model)
}
if user := c.Query("user_id"); user != "" {
q = q.Where("user_id = ?", user)
}
var total int64
q.Count(&total)
var logs []store.UsageLog
q.Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&logs)
out := make([]gin.H, 0, len(logs))
for _, l := range logs {
var uname string
h.a.DB.Model(&store.User{}).Where("id = ?", l.UserID).Pluck("username", &uname)
out = append(out, gin.H{
"id": l.ID, "user": uname, "user_id": l.UserID, "model": l.ModelName, "protocol": l.Protocol,
"input_tokens": l.InputTokens, "output_tokens": l.OutputTokens,
"cache_read_tokens": l.CacheReadTokens, "cost": l.Cost,
"latency_ms": l.LatencyMS, "status": l.Status, "error_code": l.ErrorCode,
"created_at": l.CreatedAt,
})
}
resp.OK(c, gin.H{"items": out, "total": total, "page": page, "page_size": size})
}
server/internal/api/auth.go
+18 -8
View File
@@ -2,15 +2,16 @@
package api
import (
"encoding/json"
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/openteam/server/internal/app"
"github.com/openteam/server/internal/api/middleware"
"github.com/openteam/server/internal/pkg/resp"
"github.com/openteam/server/internal/store"
"gorm.io/gorm"
)
// Handler 聚合所有管理 API。
@@ -37,10 +38,21 @@ func (h *Handler) Register(c *gin.Context) {
resp.Fail(c, http.StatusBadRequest, "invalid input: "+err.Error())
return
}
if h.a.Cfg.Auth.RegistrationMode == "invite" {
// 注册模式优先读系统配置（管理后台可改），缺省用环境配置
mode := h.a.Cfg.Auth.RegistrationMode
var modeCfgRaw string
h.a.DB.Model(&store.SystemConfig{}).Where("key = ?", "registration_mode").Pluck("value", &modeCfgRaw)
var modeCfg string
_ = json.Unmarshal([]byte(modeCfgRaw), &modeCfg)
if modeCfg == "open" || modeCfg == "invite" {
mode = modeCfg
}
if mode == "invite" {
var icRaw string
h.a.DB.Model(&store.SystemConfig{}).Where("key = ?", "invite_codes").Pluck("value", &icRaw)
var ic string
h.a.DB.Model(&store.SystemConfig{}).Where("key = ?", "invite_codes").Pluck("value", &ic)
if !strings.Contains(ic, req.InviteCode) {
_ = json.Unmarshal([]byte(icRaw), &ic)
if req.InviteCode == "" || !strings.Contains(ic, req.InviteCode) {
resp.Fail(c, http.StatusForbidden, "valid invite code required")
return
}
@@ -182,16 +194,14 @@ func (h *Handler) publicUser(u *store.User) gin.H {
}
func sessionUser(c *gin.Context) *store.User {
u, _ := c.Get("session_user")
u, _ := c.Get(middleware.CtxSessionUser)
return u.(*store.User)
}
func userFromContext(c *gin.Context) (*store.User, bool) {
u, ok := c.Get("session_user")
u, ok := c.Get(middleware.CtxSessionUser)
if !ok {
return nil, false
}
return u.(*store.User), true
}
var _ = gorm.ErrRecordNotFound
server/internal/api/keys.go
+2 -2
View File
@@ -12,7 +12,7 @@ import (
)
type createKeyReq struct {
Name string `json:"name" binding:"required,min=1,max=64"`
Name *string `json:"name" binding:"required,min=1,max=64"`
QuotaTokensPerDay *int64 `json:"quota_tokens_per_day"`
QuotaRequestsPerDay *int `json:"quota_requests_per_day"`
AllowedModels []string `json:"allowed_models"`
@@ -38,7 +38,7 @@ func (h *Handler) CreateKey(c *gin.Context) {
}
k := store.APIKey{
UserID: u.ID,
Name: req.Name,
Name: *req.Name,
KeyHash: hash,
KeyPrefix: prefix,
QuotaTokensPerDay: req.QuotaTokensPerDay,
server/internal/api/router.go
+21 -1
View File
@@ -26,6 +26,7 @@ func NewRouter(a *app.App, gw *proxy.Gateway) *gin.Engine {
{
proxyGroup.Any("/chat/completions", gw.Auth, gw.Handle)
proxyGroup.Any("/responses", gw.Auth, gw.Handle)
proxyGroup.Any("/messages", gw.Auth, gw.Handle)
proxyGroup.Any("/models", gw.Auth, gw.Handle)
}
// 未匹配的 /v1/* 返回 OpenAI 风格 404（需先认证）
@@ -68,12 +69,31 @@ func NewRouter(a *app.App, gw *proxy.Gateway) *gin.Engine {
admin := api.Group("/admin", middleware.SessionAuth(a), middleware.AdminOnly)
{
// 用户
admin.GET("/users", h.AdminUsers)
admin.PATCH("/users/:id", h.AdminPatchUser)
admin.POST("/users/:id/balance", h.AdminAdjustBalance)
// 渠道
admin.GET("/channels", h.AdminChannels)
admin.POST("/channels", h.AdminCreateChannel)
admin.PUT("/channels/:id", h.AdminUpdateChannel)
admin.DELETE("/channels/:id", h.AdminDeleteChannel)
admin.POST("/channels/:id/test", h.AdminTestChannel)
admin.POST("/channels/:id/models/import", h.AdminImportChannelModels)
// 模型与定价
admin.GET("/models", h.AdminModels)
admin.POST("/models", h.AdminCreateModel)
admin.PUT("/models/:id", h.AdminUpdateModel)
admin.DELETE("/models/:id", h.AdminDeleteModel)
admin.POST("/models/:id/bindings", h.AdminCreateModelBinding)
admin.DELETE("/models/:id/bindings/:bid", h.AdminDeleteModelBinding)
// 统计与用量
admin.GET("/stats/overview", h.AdminStatsOverview)
admin.GET("/usage", h.AdminUsage)
// 配置
admin.GET("/config", h.AdminConfig)
admin.PUT("/config", h.AdminPutConfig)
// 渠道/模型/用量管理（M4）；充值审核（M5 预留）
// 充值审核（M6 预留）
}
}
server/internal/api/usage.go
+112
View File
@@ -0,0 +1,112 @@
package api
import (
"strconv"
"time"
"github.com/gin-gonic/gin"
"github.com/openteam/server/internal/pkg/resp"
"github.com/openteam/server/internal/store"
)
// UsageSummary GET /api/v1/usage/summary — 今日/本月汇总。
func (h *Handler) UsageSummary(c *gin.Context) {
u, _ := userFromContext(c)
now := time.Now().UTC()
today := now.Format("2006-01-02")
month := now.Format("2006-01")
var todayReq, monthReq int64
var todayTok, monthTok int64
var todayCost, monthCost float64
h.a.DB.Model(&store.UsageDaily{}).Where("user_id = ? AND date = ?", u.ID, today).
Select("COALESCE(SUM(requests),0), COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens),0), COALESCE(SUM(cost),0)").
Row().Scan(&todayReq, &todayTok, &todayCost)
h.a.DB.Model(&store.UsageDaily{}).Where("user_id = ? AND date LIKE ?", u.ID, month+"%").
Select("COALESCE(SUM(requests),0), COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens),0), COALESCE(SUM(cost),0)").
Row().Scan(&monthReq, &monthTok, &monthCost)
resp.OK(c, gin.H{
"today": gin.H{"requests": todayReq, "tokens": todayTok, "cost": todayCost},
"month": gin.H{"requests": monthReq, "tokens": monthTok, "cost": monthCost},
})
}
// UsageStats GET /api/v1/usage/stats?from&to&group=day|model
func (h *Handler) UsageStats(c *gin.Context) {
u, _ := userFromContext(c)
from := c.DefaultQuery("from", time.Now().Add(-30*24*time.Hour).Format("2006-01-02"))
to := c.DefaultQuery("to", time.Now().Format("2006-01-02"))
group := c.DefaultQuery("group", "day")
q := h.a.DB.Model(&store.UsageDaily{}).Where("user_id = ? AND date BETWEEN ? AND ?", u.ID, from, to)
out := make([]gin.H, 0, 64)
if group == "model" {
var rows []struct {
ModelID uint64
Requests int64
Tokens int64
Cost float64
}
q.Select("model_id, SUM(requests) requests, SUM(input_tokens+output_tokens+cache_read_tokens) tokens, SUM(cost) cost").
Group("model_id").Scan(&rows)
for _, r := range rows {
var m store.Model
name := strconv.FormatUint(r.ModelID, 10)
if h.a.DB.First(&m, r.ModelID).Error == nil {
name = m.Name
}
out = append(out, gin.H{"model": name, "requests": r.Requests, "tokens": r.Tokens, "cost": r.Cost})
}
} else {
var rows []struct {
Date string
Requests int64
Tokens int64
Cost float64
}
q.Select("date, SUM(requests) requests, SUM(input_tokens+output_tokens+cache_read_tokens) tokens, SUM(cost) cost").
Group("date").Order("date").Scan(&rows)
for _, r := range rows {
out = append(out, gin.H{"date": r.Date, "requests": r.Requests, "tokens": r.Tokens, "cost": r.Cost})
}
}
resp.OK(c, gin.H{"items": out})
}
// UsageLogs GET /api/v1/usage/logs?from&to&page&page_size&model
func (h *Handler) UsageLogs(c *gin.Context) {
u, _ := userFromContext(c)
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
size, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
if page < 1 {
page = 1
}
if size < 1 || size > 100 {
size = 20
}
q := h.a.DB.Model(&store.UsageLog{}).Where("user_id = ?", u.ID)
if from := c.Query("from"); from != "" {
q = q.Where("created_at >= ?", from+" 00:00:00")
}
if to := c.Query("to"); to != "" {
q = q.Where("created_at <= ?", to+" 23:59:59")
}
if model := c.Query("model"); model != "" {
q = q.Where("model_name = ?", model)
}
var total int64
q.Count(&total)
var logs []store.UsageLog
q.Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&logs)
out := make([]gin.H, 0, len(logs))
for _, l := range logs {
out = append(out, gin.H{
"id": l.ID, "request_id": l.RequestID, "model": l.ModelName, "protocol": l.Protocol,
"input_tokens": l.InputTokens, "output_tokens": l.OutputTokens,
"cache_read_tokens": l.CacheReadTokens, "cost": l.Cost,
"latency_ms": l.LatencyMS, "status": l.Status, "error_code": l.ErrorCode,
"created_at": l.CreatedAt,
})
}
resp.OK(c, gin.H{"items": out, "total": total, "page": page, "page_size": size})
}
server/internal/api/user.go
-102
View File
@@ -2,7 +2,6 @@ package api
import (
"net/http"
"strconv"
"time"
"github.com/gin-gonic/gin"
@@ -62,104 +61,3 @@ func (h *Handler) UserModels(c *gin.Context) {
}
resp.OK(c, gin.H{"items": out})
}
// UsageSummary GET /api/v1/usage/summary — 今日/本月汇总。
func (h *Handler) UsageSummary(c *gin.Context) {
u, _ := userFromContext(c)
now := time.Now().UTC()
today := now.Format("2006-01-02")
month := now.Format("2006-01")
var todayReq, monthReq int64
var todayTok, monthTok int64
var todayCost, monthCost float64
h.a.DB.Model(&store.UsageDaily{}).Where("user_id = ? AND date = ?", u.ID, today).
Select("COALESCE(SUM(requests),0), COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens),0), COALESCE(SUM(cost),0)").
Row().Scan(&todayReq, &todayTok, &todayCost)
h.a.DB.Model(&store.UsageDaily{}).Where("user_id = ? AND date LIKE ?", u.ID, month+"%").
Select("COALESCE(SUM(requests),0), COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens),0), COALESCE(SUM(cost),0)").
Row().Scan(&monthReq, &monthTok, &monthCost)
resp.OK(c, gin.H{
"today": gin.H{"requests": todayReq, "tokens": todayTok, "cost": todayCost},
"month": gin.H{"requests": monthReq, "tokens": monthTok, "cost": monthCost},
})
}
// UsageStats GET /api/v1/usage/stats?from&to&group=day|model
func (h *Handler) UsageStats(c *gin.Context) {
u, _ := userFromContext(c)
from := c.DefaultQuery("from", time.Now().Add(-30*24*time.Hour).Format("2006-01-02"))
to := c.DefaultQuery("to", time.Now().Format("2006-01-02"))
group := c.DefaultQuery("group", "day")
q := h.a.DB.Model(&store.UsageDaily{}).Where("user_id = ? AND date BETWEEN ? AND ?", u.ID, from, to)
out := make([]gin.H, 0, 64)
if group == "model" {
var rows []struct {
ModelID uint64
Requests int64
Tokens int64
Cost float64
}
q.Select("model_id, SUM(requests) requests, SUM(input_tokens+output_tokens+cache_read_tokens) tokens, SUM(cost) cost").
Group("model_id").Scan(&rows)
for _, r := range rows {
var m store.Model
name := strconv.FormatUint(r.ModelID, 10)
if h.a.DB.First(&m, r.ModelID).Error == nil {
name = m.Name
}
out = append(out, gin.H{"model": name, "requests": r.Requests, "tokens": r.Tokens, "cost": r.Cost})
}
} else {
var rows []struct {
Date string
Requests int64
Tokens int64
Cost float64
}
q.Select("date, SUM(requests) requests, SUM(input_tokens+output_tokens+cache_read_tokens) tokens, SUM(cost) cost").
Group("date").Order("date").Scan(&rows)
for _, r := range rows {
out = append(out, gin.H{"date": r.Date, "requests": r.Requests, "tokens": r.Tokens, "cost": r.Cost})
}
}
resp.OK(c, gin.H{"items": out})
}
// UsageLogs GET /api/v1/usage/logs?from&to&page&page_size&model
func (h *Handler) UsageLogs(c *gin.Context) {
u, _ := userFromContext(c)
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
size, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
if page < 1 {
page = 1
}
if size < 1 || size > 100 {
size = 20
}
q := h.a.DB.Model(&store.UsageLog{}).Where("user_id = ?", u.ID)
if from := c.Query("from"); from != "" {
q = q.Where("created_at >= ?", from+" 00:00:00")
}
if to := c.Query("to"); to != "" {
q = q.Where("created_at <= ?", to+" 23:59:59")
}
if model := c.Query("model"); model != "" {
q = q.Where("model_name = ?", model)
}
var total int64
q.Count(&total)
var logs []store.UsageLog
q.Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&logs)
out := make([]gin.H, 0, len(logs))
for _, l := range logs {
out = append(out, gin.H{
"id": l.ID, "request_id": l.RequestID, "model": l.ModelName, "protocol": l.Protocol,
"input_tokens": l.InputTokens, "output_tokens": l.OutputTokens,
"cache_read_tokens": l.CacheReadTokens, "cost": l.Cost,
"latency_ms": l.LatencyMS, "status": l.Status, "error_code": l.ErrorCode,
"created_at": l.CreatedAt,
})
}
resp.OK(c, gin.H{"items": out, "total": total, "page": page, "page_size": size})
}
server/internal/channel/channel.go
+9 -15
View File
@@ -1,6 +1,6 @@
// Package channel 渠道仓储：选择、加解密、健康过滤。
// M1 阶段实现最小选择逻辑（按优先级+权重取第一个健康启用的渠道），
// 负载均衡/健康检查/故障转移在 M4 完善。
// Package channel 渠道仓储：选择、密钥加解密、模型解析。
// M1 实现最小选择逻辑（优先级+权重取第一个健康启用的渠道）；
// 负载均衡/健康检查/故障转移在 M5 完善。
package channel
import (
@@ -48,21 +48,15 @@ func (s *Service) ResolveModel(modelName string) (*store.Channel, *store.Channel
}
var b store.ChannelModelBinding
if err := s.db.Where("model_id = ?", m.ID).
Joins("JOIN channels ON channels.id = channel_model_bindings.channel_id AND channels.enabled = ? AND channels.health_status = ?", true, store.ChannelHealthHealthy).
Order("channel_model_bindings.weight DESC").
First(&b).Error; err != nil {
Order("weight DESC, id ASC").First(&b).Error; err != nil {
return nil, nil, err
}
ch, err := s.Select()
if err != nil {
var ch store.Channel
if err := s.db.First(&ch, b.ChannelID).Error; err != nil {
return nil, nil, err
}
// 用绑定里的渠道（如果健康），否则回退默认渠道
if b.ChannelID != ch.ID {
var bound store.Channel
if err := s.db.First(&bound, b.ChannelID).Error; err == nil && bound.Enabled && bound.HealthStatus == store.ChannelHealthHealthy {
return &bound, &b, nil
if !ch.Enabled || ch.HealthStatus != store.ChannelHealthHealthy {
return nil, nil, ErrNoChannel
}
}
return ch, &b, nil
return &ch, &b, nil
}
server/internal/config/config.go
+3 -5
View File
@@ -1,4 +1,5 @@
// Package config 加载服务配置：.env / 环境变量 / 默认值（viper）。
// 所有项均可用环境变量 OT_<KEY> 覆盖（点号转下划线，如 db.driver → OT_DB_DRIVER）。
package config
import (
@@ -51,7 +52,8 @@ type ProxyConfig struct {
Timeout time.Duration
}
// loadDotEnv 读取 .env 文件并把 KEY=VALUE 注入环境变量（AutomaticEnv 会自动映射 OT_ 前缀）。
// loadDotEnv 读取 .env 并把 KEY=VALUE 注入环境变量（AutomaticEnv 自动映射 OT_ 前缀）。
// 已存在的环境变量优先，不覆盖。
func loadDotEnv() {
data, err := os.ReadFile(".env")
if err != nil {
@@ -110,10 +112,6 @@ func Load() (*Config, error) {
v.SetDefault("proxy.default_model", "gpt-4o-mini")
v.SetDefault("proxy.timeout", "120s")
// 支持读取 .env 文件（可选，不强制）
v.SetConfigFile(".env")
_ = v.ReadInConfig()
return &Config{
Env: v.GetString("env"),
Port: v.GetInt("port"),
server/internal/pkg/apikey/apikey.go
-4
View File
@@ -5,7 +5,6 @@ package apikey
import (
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"strings"
)
@@ -47,6 +46,3 @@ func Prefix(key string) string {
func Valid(key string) bool {
return strings.HasPrefix(key, prefix) && len(key) == len(prefix)+keyLen
}
// base64 占位，避免未使用导入告警
var _ = base64.StdEncoding
server/internal/pkg/apikey/apikey_test.go
+18 -14
View File
@@ -2,32 +2,36 @@ package apikey
import "testing"
func TestGenerate(t *testing.T) {
func TestGenerateValid(t *testing.T) {
plain, hash, prefix, err := Generate()
if err != nil {
t.Fatal(err)
t.Fatalf("Generate: %v", err)
}
if !Valid(plain) {
t.Fatalf("generated key invalid: %q", plain)
}
if len(plain) != 3+48 {
t.Fatalf("key length = %d, want 51", len(plain))
if len(plain) != len("sk-")+48 {
t.Fatalf("unexpected key length: %d", len(plain))
}
if Hash(plain) != hash {
t.Fatal("hash mismatch")
}
if len(prefix) > len(plain) || prefix != plain[:len(prefix)] {
t.Fatal("prefix must be prefix of plain key")
}
// 两次生成不重复
plain2, _, _, _ := Generate()
if plain == plain2 {
t.Fatal("keys should be unique")
if prefix != plain[:12] {
t.Fatalf("prefix mismatch: %s vs %s", prefix, plain[:12])
}
}
func TestValid(t *testing.T) {
if Valid("") || Valid("sk-short") || Valid("xxx") {
t.Fatal("invalid keys should be rejected")
func TestHashStable(t *testing.T) {
if Hash("sk-test") != Hash("sk-test") {
t.Fatal("hash not stable")
}
}
func TestValidRejects(t *testing.T) {
cases := []string{"", "sk-abc", "abc-123456789012345678901234567890123456789012345678", "sk-1234567890123456789012345678901234567890123456789"}
for _, c := range cases {
if Valid(c) {
t.Fatalf("expected invalid: %q", c)
}
}
}
server/internal/pkg/crypto/crypto.go
+7 -6
View File
@@ -14,6 +14,7 @@ import (
"golang.org/x/crypto/argon2"
)
// PasswordHasher argon2id 参数（来自配置）。
type PasswordHasher struct {
Time uint32
Memory uint32
@@ -26,7 +27,7 @@ func NewPasswordHasher(time, memory uint32, threads uint8, keyLen uint32, saltLe
return &PasswordHasher{Time: time, Memory: memory, Threads: threads, KeyLen: keyLen, SaltLen: saltLen}
}
// HashPassword argon2id 编码为 $argon2id$v=19$m=...,t=...,p=...$salt$hash
// HashPassword 编码为 $argon2id$v=19$m=...,t=...,p=...$salt$hash
func (h *PasswordHasher) HashPassword(password string) (string, error) {
salt := make([]byte, h.SaltLen)
if _, err := rand.Read(salt); err != nil {
@@ -38,14 +39,13 @@ func (h *PasswordHasher) HashPassword(password string) (string, error) {
h.Memory, h.Time, h.Threads, enc.EncodeToString(salt), enc.EncodeToString(key)), nil
}
// VerifyPassword 校验密码，返回是否匹配（常数时间比较）。
// VerifyPassword 校验密码，常数时间比较。
func (h *PasswordHasher) VerifyPassword(encoded, password string) (bool, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false, errors.New("invalid hash format")
}
var memory uint32
var time uint32
var memory, time uint32
var threads uint8
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &time, &threads); err != nil {
return false, err
@@ -66,6 +66,7 @@ func (h *PasswordHasher) VerifyPassword(encoded, password string) (bool, error)
// ---------------------------------------------------------------------------
// AES-GCM 渠道密钥加密
// Encryptor 用主密钥加解密渠道上游 key。
type Encryptor struct {
key []byte
}
@@ -76,8 +77,7 @@ func NewEncryptor(master string) *Encryptor {
switch len(key) {
case 16, 24, 32:
default:
sum := sha256Sum(master)
key = sum
key = sha256Sum(master)
}
return &Encryptor{key: key}
}
@@ -100,6 +100,7 @@ func (e *Encryptor) Encrypt(plain string) (string, error) {
return base64.StdEncoding.EncodeToString(append(nonce, ct...)), nil
}
// Decrypt 解析 Encrypt 的输出。
func (e *Encryptor) Decrypt(enc string) (string, error) {
raw, err := base64.StdEncoding.DecodeString(enc)
if err != nil {
server/internal/pkg/crypto/crypto_test.go
+19 -18
View File
@@ -3,42 +3,43 @@ package crypto
import "testing"
func TestPasswordHashRoundTrip(t *testing.T) {
h := NewPasswordHasher(3, 64*1024, 2, 32, 16)
h := NewPasswordHasher(1, 64*1024, 1, 32, 16)
hash, err := h.HashPassword("s3cret-password")
if err != nil {
t.Fatalf("hash: %v", err)
t.Fatalf("HashPassword: %v", err)
}
ok, err := h.VerifyPassword(hash, "s3cret-password")
if err != nil || !ok {
t.Fatalf("verify correct password: ok=%v err=%v", ok, err)
t.Fatalf("VerifyPassword correct: ok=%v err=%v", ok, err)
}
ok, _ = h.VerifyPassword(hash, "wrong-password")
if ok {
t.Fatal("wrong password should not verify")
t.Fatal("VerifyPassword accepted wrong password")
}
}
func TestEncryptDecrypt(t *testing.T) {
e := NewEncryptor("master-key-0123456789abcdef")
func TestEncryptorRoundTrip(t *testing.T) {
e := NewEncryptor("a-very-long-master-key-1234567890")
enc, err := e.Encrypt("sk-upstream-secret")
if err != nil {
t.Fatalf("encrypt: %v", err)
t.Fatalf("Encrypt: %v", err)
}
dec, err := e.Decrypt(enc)
if err != nil || dec != "sk-upstream-secret" {
t.Fatalf("decrypt: got %q err %v", dec, err)
if enc == "sk-upstream-secret" {
t.Fatal("ciphertext equals plaintext")
}
// 密文不可读
if dec == enc {
t.Fatal("ciphertext should differ from plaintext")
plain, err := e.Decrypt(enc)
if err != nil {
t.Fatalf("Decrypt: %v", err)
}
if plain != "sk-upstream-secret" {
t.Fatalf("round trip mismatch: %q", plain)
}
}
func TestShortMasterKeyDerived(t *testing.T) {
func TestEncryptorShortKeyDerived(t *testing.T) {
// 短主密钥应派生 32 字节而非报错
e := NewEncryptor("short")
enc, _ := e.Encrypt("x")
dec, err := e.Decrypt(enc)
if err != nil || dec != "x" {
t.Fatalf("short key derive failed: %v", err)
if _, err := e.Encrypt("x"); err != nil {
t.Fatalf("Encrypt with short key: %v", err)
}
}
server/internal/pkg/jwt/jwt.go
+1
View File
@@ -8,6 +8,7 @@ import (
"github.com/golang-jwt/jwt/v5"
)
// Claims 用户声明；Subject 字段区分 "access" / "refresh"。
type Claims struct {
UserID uint64 `json:"uid"`
Username string `json:"uname"`
server/internal/pkg/jwt/jwt_test.go
+22 -18
View File
@@ -5,37 +5,41 @@ import (
"time"
)
func TestSignParse(t *testing.T) {
func TestSignParseAccess(t *testing.T) {
m := NewManager("test-secret", "openteam", time.Hour, 24*time.Hour)
tok, exp, err := m.Sign(42, "alice", "admin", "access")
if err != nil {
t.Fatal(err)
t.Fatalf("Sign: %v", err)
}
if time.Until(exp) < 50*time.Minute {
t.Fatal("expiry too short")
if exp.Before(time.Now()) {
t.Fatal("expires in the past")
}
claims, err := m.Parse(tok)
if err != nil {
t.Fatal(err)
t.Fatalf("Parse: %v", err)
}
if claims.UserID != 42 || claims.Username != "alice" || claims.Role != "admin" || claims.Subject != "access" {
if claims.UserID != 42 || claims.Username != "alice" || claims.Role != "admin" {
t.Fatalf("claims mismatch: %+v", claims)
}
if claims.Subject != "access" {
t.Fatalf("subject mismatch: %s", claims.Subject)
}
}
func TestParseRejectsBadToken(t *testing.T) {
m := NewManager("test-secret", "openteam", time.Hour, 24*time.Hour)
if _, err := m.Parse("not-a-jwt"); err == nil {
t.Fatal("expected error for invalid token")
}
}
func TestExpiredToken(t *testing.T) {
m := NewManager("test-secret", "openteam", -time.Minute, time.Hour)
tok, _, _ := m.Sign(1, "a", "user", "access")
m := NewManager("test-secret", "openteam", -time.Hour, -time.Hour)
tok, _, err := m.Sign(1, "bob", "user", "access")
if err != nil {
t.Fatalf("Sign: %v", err)
}
if _, err := m.Parse(tok); err == nil {
t.Fatal("expired token should fail")
}
}
func TestWrongSecret(t *testing.T) {
m1 := NewManager("secret-a", "openteam", time.Hour, time.Hour)
m2 := NewManager("secret-b", "openteam", time.Hour, time.Hour)
tok, _, _ := m1.Sign(1, "a", "user", "access")
if _, err := m2.Parse(tok); err == nil {
t.Fatal("token signed with different secret should fail")
t.Fatal("expected error for expired token")
}
}
server/internal/pkg/resp/resp.go
-5
View File
@@ -32,8 +32,3 @@ func Created(c *gin.Context, data any) {
func Fail(c *gin.Context, status int, message string) {
c.JSON(status, Body{Error: &Error{Message: message}})
}
// FailCode 带错误码的业务错误
func FailCode(c *gin.Context, status int, code, message string) {
c.JSON(status, Body{Error: &Error{Message: message, Type: code}})
}
server/internal/proxy/convert/convert.go
+157
View File
@@ -0,0 +1,157 @@
// Package convert 三协议互转：OpenAI Chat / OpenAI Responses / Anthropic Messages。
// 网关以 OpenAI Chat 形状作为标准中间模型（PLANNING §5.1.1）。
// 请求与响应（非流式）走 JSON 转换；流式走逐行 SSE 转换（见 stream.go）。
package convert
import (
"encoding/json"
"fmt"
)
// 协议标识。
const (
ProtoChat = "chat"
ProtoMessages = "messages"
ProtoResponses = "responses"
)
// ConvertRequest 转换请求体。from==to 时原样返回。
func ConvertRequest(body []byte, from, to string) ([]byte, error) {
if from == to {
return body, nil
}
switch {
case from == ProtoMessages && to == ProtoChat:
return messagesToChatReq(body)
case from == ProtoChat && to == ProtoMessages:
return chatToMessagesReq(body)
case from == ProtoResponses && to == ProtoChat:
return responsesToChatReq(body)
case from == ProtoChat && to == ProtoResponses:
return chatToResponsesReq(body)
case from == ProtoResponses && to == ProtoMessages:
mid, err := responsesToChatReq(body)
if err != nil {
return nil, err
}
return chatToMessagesReq(mid)
case from == ProtoMessages && to == ProtoResponses:
mid, err := messagesToChatReq(body)
if err != nil {
return nil, err
}
return chatToResponsesReq(mid)
}
return nil, fmt.Errorf("unsupported request conversion %s->%s", from, to)
}
// ConvertResponse 转换响应体（非流式）。from==to 时原样返回。
func ConvertResponse(body []byte, from, to string) ([]byte, error) {
if from == to {
return body, nil
}
switch {
case from == ProtoMessages && to == ProtoChat:
return messagesToChatResp(body)
case from == ProtoChat && to == ProtoMessages:
return chatToMessagesResp(body)
case from == ProtoResponses && to == ProtoChat:
return responsesToChatResp(body)
case from == ProtoChat && to == ProtoResponses:
return chatToResponsesResp(body)
case from == ProtoResponses && to == ProtoMessages:
mid, err := responsesToChatResp(body)
if err != nil {
return nil, err
}
return chatToMessagesResp(mid)
case from == ProtoMessages && to == ProtoResponses:
mid, err := messagesToChatResp(body)
if err != nil {
return nil, err
}
return chatToResponsesResp(mid)
}
return nil, fmt.Errorf("unsupported response conversion %s->%s", from, to)
}
// NewStreamTransformer 构造流式逐行转换器：输入上游 SSE 一行，返回客户端 SSE 行。
// 返回 nil 表示丢弃该行；(from==to 时无需转换)。
func NewStreamTransformer(from, to string) func([]byte) []byte {
switch {
case from == ProtoMessages && to == ProtoChat:
return newMessagesToChat().line
case from == ProtoChat && to == ProtoMessages:
return newChatToMessages().line
case from == ProtoResponses && to == ProtoChat:
return newResponsesToChat().line
case from == ProtoChat && to == ProtoResponses:
return newChatToResponses().line
case from == ProtoResponses && to == ProtoMessages:
return newResponsesToMessages().line
case from == ProtoMessages && to == ProtoResponses:
return newMessagesToResponses().line
}
return nil
}
// ---------------------------------------------------------------------------
// 工具函数
// str 返回字符串字段；json.RawMessage 为字符串字面量时去引号。
func str(raw json.RawMessage) string {
if len(raw) == 0 || string(raw) == "null" {
return ""
}
var s string
if json.Unmarshal(raw, &s) == nil {
return s
}
// 数组/对象：尝试取 type=text 的 text
var arr []map[string]any
if json.Unmarshal(raw, &arr) == nil {
var parts []string
for _, b := range arr {
if t, _ := b["type"].(string); t == "text" || t == "input_text" || t == "output_text" {
if txt, _ := b["text"].(string); txt != "" {
parts = append(parts, txt)
}
}
}
return joinNonEmpty(parts, "\n")
}
return ""
}
func joinNonEmpty(parts []string, sep string) string {
out := ""
for i, p := range parts {
if p == "" {
continue
}
if out != "" {
out += sep
}
out += p
_ = i
}
return out
}
// rawJSON 安全取字段；不存在或 null 返回 nil。
func rawJSON(m map[string]json.RawMessage, key string) json.RawMessage {
raw, ok := m[key]
if !ok || string(raw) == "null" {
return nil
}
return raw
}
// decode 把 RawMessage 解到 map。
func decode(raw json.RawMessage) (map[string]any, error) {
var m map[string]any
if err := json.Unmarshal(raw, &m); err != nil {
return nil, err
}
return m, nil
}
server/internal/proxy/convert/convert_test.go
+308
View File
@@ -0,0 +1,308 @@
package convert
import (
"encoding/json"
"strings"
"testing"
)
func mustJSON(t *testing.T, v any) string {
t.Helper()
b, err := json.Marshal(v)
if err != nil {
t.Fatalf("marshal: %v", err)
}
return string(b)
}
func TestChatToMessagesReq(t *testing.T) {
in := `{
"model":"claude-sonnet-5",
"messages":[
{"role":"system","content":"你是助手"},
{"role":"user","content":"hi"},
{"role":"assistant","content":"hello","tool_calls":[{"id":"call_1","function":{"name":"get_weather","arguments":"{\"city\":\"sz\"}"}}]},
{"role":"tool","tool_call_id":"call_1","content":"sunny"}
],
"tools":[{"type":"function","function":{"name":"get_weather","description":"查天气","parameters":{"type":"object"}}}],
"max_tokens":100,
"stream":true
}`
out, err := ConvertRequest([]byte(in), ProtoChat, ProtoMessages)
if err != nil {
t.Fatalf("convert: %v", err)
}
var m map[string]any
if err := json.Unmarshal(out, &m); err != nil {
t.Fatalf("unmarshal out: %v\n%s", err, out)
}
if m["system"] != "你是助手" {
t.Fatalf("system = %v", m["system"])
}
if m["max_tokens"] != float64(100) {
t.Fatalf("max_tokens = %v", m["max_tokens"])
}
msgs := m["messages"].([]any)
if len(msgs) != 3 {
t.Fatalf("messages len = %d", len(msgs))
}
// assistant 含 tool_use 块
assistant := msgs[1].(map[string]any)
content := assistant["content"].([]any)
foundToolUse := false
for _, c := range content {
cm := c.(map[string]any)
if cm["type"] == "tool_use" {
foundToolUse = true
if cm["name"] != "get_weather" || cm["id"] != "call_1" {
t.Fatalf("tool_use mismatch: %v", cm)
}
}
}
if !foundToolUse {
t.Fatal("expected tool_use block")
}
// tool 消息 → user 消息的 tool_result 块
tool := msgs[2].(map[string]any)
if tool["role"] != "user" {
t.Fatalf("tool message role = %v", tool["role"])
}
}
func TestMessagesToChatReq(t *testing.T) {
in := `{
"model":"gpt-4o-mini",
"system":"你是助手",
"messages":[
{"role":"user","content":"hi"},
{"role":"assistant","content":[{"type":"text","text":"hello"},{"type":"tool_use","id":"call_1","name":"get_weather","input":{"city":"sz"}}]},
{"role":"user","content":[{"type":"tool_result","tool_use_id":"call_1","content":"sunny"}]}
],
"tools":[{"name":"get_weather","description":"查天气","input_schema":{"type":"object"}}],
"max_tokens":100,
"stream":false
}`
out, err := ConvertRequest([]byte(in), ProtoMessages, ProtoChat)
if err != nil {
t.Fatalf("convert: %v", err)
}
var m map[string]any
_ = json.Unmarshal(out, &m)
msgs := m["messages"].([]any)
// system + user + assistant + tool = 4 条
if len(msgs) != 4 {
t.Fatalf("messages len = %d: %s", len(msgs), out)
}
if msgs[0].(map[string]any)["role"] != "system" {
t.Fatal("expected system message first")
}
assistant := msgs[2].(map[string]any)
if tc := assistant["tool_calls"]; tc == nil {
t.Fatalf("expected tool_calls in assistant: %s", out)
}
tool := msgs[3].(map[string]any)
if tool["role"] != "tool" || tool["tool_call_id"] != "call_1" {
t.Fatalf("tool message mismatch: %v", tool)
}
}
func TestResponsesToChatReq(t *testing.T) {
in := `{
"model":"claude-sonnet-5",
"instructions":"你是助手",
"input":"hello",
"tools":[{"type":"function","name":"get_weather","description":"查天气","parameters":{"type":"object"}}],
"max_output_tokens":200,
"stream":false
}`
out, err := ConvertRequest([]byte(in), ProtoResponses, ProtoChat)
if err != nil {
t.Fatalf("convert: %v", err)
}
var m map[string]any
_ = json.Unmarshal(out, &m)
msgs := m["messages"].([]any)
if len(msgs) != 2 {
t.Fatalf("messages len = %d: %s", len(msgs), out)
}
if msgs[0].(map[string]any)["role"] != "system" {
t.Fatal("expected system from instructions")
}
if m["max_tokens"] != float64(200) {
t.Fatalf("max_tokens = %v", m["max_tokens"])
}
}
func TestChatToResponsesReq(t *testing.T) {
in := mustJSON(t, map[string]any{
"model": "gpt-4o",
"messages": []any{
map[string]any{"role": "system", "content": "sys"},
map[string]any{"role": "user", "content": "hi"},
},
"max_tokens": 300,
})
out, err := ConvertRequest([]byte(in), ProtoChat, ProtoResponses)
if err != nil {
t.Fatalf("convert: %v", err)
}
var m map[string]any
_ = json.Unmarshal(out, &m)
if m["instructions"] != "sys" {
t.Fatalf("instructions = %v", m["instructions"])
}
if m["max_output_tokens"] != float64(300) {
t.Fatalf("max_output_tokens = %v", m["max_output_tokens"])
}
}
func TestMessagesToChatResp(t *testing.T) {
in := `{"id":"msg_abc","type":"message","role":"assistant","model":"claude-sonnet-5",
"content":[{"type":"text","text":"你好"},{"type":"tool_use","id":"call_1","name":"get_weather","input":{"city":"sz"}}],
"stop_reason":"tool_use","usage":{"input_tokens":10,"output_tokens":5}}`
out, err := ConvertResponse([]byte(in), ProtoMessages, ProtoChat)
if err != nil {
t.Fatalf("convert: %v", err)
}
var m map[string]any
_ = json.Unmarshal(out, &m)
choices := m["choices"].([]any)
msg := choices[0].(map[string]any)["message"].(map[string]any)
if msg["content"] != "你好" {
t.Fatalf("content = %v", msg["content"])
}
if msg["tool_calls"] == nil {
t.Fatal("expected tool_calls")
}
if choices[0].(map[string]any)["finish_reason"] != "tool_calls" {
t.Fatalf("finish_reason = %v", choices[0].(map[string]any)["finish_reason"])
}
}
func TestChatToMessagesResp(t *testing.T) {
in := `{"id":"chatcmpl-xyz","object":"chat.completion","model":"gpt-4o",
"choices":[{"index":0,"message":{"role":"assistant","content":"hi"},"finish_reason":"stop"}],
"usage":{"prompt_tokens":3,"completion_tokens":2,"total_tokens":5}}`
out, err := ConvertResponse([]byte(in), ProtoChat, ProtoMessages)
if err != nil {
t.Fatalf("convert: %v", err)
}
var m map[string]any
_ = json.Unmarshal(out, &m)
if m["stop_reason"] != "end_turn" {
t.Fatalf("stop_reason = %v", m["stop_reason"])
}
content := m["content"].([]any)
if content[0].(map[string]any)["text"] != "hi" {
t.Fatalf("content = %v", content)
}
usage := m["usage"].(map[string]any)
if usage["input_tokens"] != float64(3) || usage["output_tokens"] != float64(2) {
t.Fatalf("usage = %v", usage)
}
}
// ---------------------------------------------------------------------------
// 流式转换
func feedLines(t *testing.T, transformer func([]byte) []byte, lines []string) string {
t.Helper()
var sb strings.Builder
for _, l := range lines {
if out := transformer([]byte(l)); out != nil {
sb.Write(out)
}
}
return sb.String()
}
func TestStreamMessagesToChat(t *testing.T) {
tf := newMessagesToChat().line
out := feedLines(t, tf, []string{
"event: message_start\n",
`data: {"type":"message_start","message":{"id":"msg_1","model":"claude-sonnet-5"}}` + "\n\n",
"event: content_block_delta\n",
`data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"你好"}}` + "\n\n",
"event: message_delta\n",
`data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":10,"output_tokens":5}}` + "\n\n",
"event: message_stop\n",
`data: {"type":"message_stop"}` + "\n\n",
})
if !strings.Contains(out, `"content":"你好"`) {
t.Fatalf("missing content chunk: %s", out)
}
if !strings.Contains(out, `"finish_reason":"stop"`) {
t.Fatalf("missing finish chunk: %s", out)
}
if !strings.Contains(out, `"usage"`) {
t.Fatalf("missing usage chunk: %s", out)
}
if !strings.Contains(out, "data: [DONE]") {
t.Fatalf("missing [DONE]: %s", out)
}
}
func TestStreamChatToMessages(t *testing.T) {
tf := newChatToMessages().line
out := feedLines(t, tf, []string{
`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","model":"gpt-4o","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}` + "\n\n",
`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","model":"gpt-4o","choices":[{"index":0,"delta":{"content":"你好"},"finish_reason":null}]}` + "\n\n",
`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","model":"gpt-4o","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}` + "\n\n",
`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","model":"gpt-4o","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":9}}` + "\n\n",
"data: [DONE]\n\n",
})
if !strings.Contains(out, "event: message_start") {
t.Fatalf("missing message_start: %s", out)
}
if !strings.Contains(out, `"text":"你好"`) || !strings.Contains(out, `"type":"text_delta"`) {
t.Fatalf("missing content delta: %s", out)
}
if !strings.Contains(out, `"stop_reason":"end_turn"`) {
t.Fatalf("missing message_delta: %s", out)
}
if !strings.Contains(out, "event: message_stop") {
t.Fatalf("missing message_stop: %s", out)
}
}
func TestStreamResponsesToMessages(t *testing.T) {
tf := newResponsesToMessages().line
out := feedLines(t, tf, []string{
"event: response.created\n",
`data: {"type":"response.created","response":{"id":"resp_1","model":"claude-sonnet-5"}}` + "\n\n",
"event: response.output_text.delta\n",
`data: {"type":"response.output_text.delta","delta":"hi"}` + "\n\n",
"event: response.completed\n",
`data: {"type":"response.completed","response":{"id":"resp_1","status":"completed","usage":{"input_tokens":7,"output_tokens":8}}}` + "\n\n",
})
if !strings.Contains(out, "event: message_start") {
t.Fatalf("missing message_start: %s", out)
}
if !strings.Contains(out, `"text":"hi"`) {
t.Fatalf("missing content: %s", out)
}
if !strings.Contains(out, "event: message_stop") {
t.Fatalf("missing message_stop: %s", out)
}
}
func TestStreamMessagesToResponses(t *testing.T) {
tf := newMessagesToResponses().line
out := feedLines(t, tf, []string{
"event: message_start\n",
`data: {"type":"message_start","message":{"id":"msg_1","model":"claude-sonnet-5"}}` + "\n\n",
"event: content_block_delta\n",
`data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hi"}}` + "\n\n",
"event: message_stop\n",
`data: {"type":"message_stop"}` + "\n\n",
})
if !strings.Contains(out, "event: response.created") {
t.Fatalf("missing response.created: %s", out)
}
if !strings.Contains(out, "event: response.output_text.delta") {
t.Fatalf("missing output_text.delta: %s", out)
}
if !strings.Contains(out, "event: response.completed") {
t.Fatalf("missing response.completed: %s", out)
}
}
server/internal/proxy/convert/json_chat.go
+457
View File
@@ -0,0 +1,457 @@
package convert
import (
"encoding/json"
"strings"
)
// ---------------------------------------------------------------------------
// 请求：Chat → Messages
type chatTool struct {
Type string `json:"type"`
Function struct {
Name string `json:"name"`
Description string `json:"description"`
Parameters json.RawMessage `json:"parameters"`
} `json:"function"`
}
type chatMsg struct {
Role string `json:"role"`
Content json.RawMessage `json:"content"`
ToolCallID string `json:"tool_call_id"`
ToolCalls []struct {
ID string `json:"id"`
Function struct {
Name string `json:"name"`
Arguments string `json:"arguments"`
} `json:"function"`
} `json:"tool_calls"`
}
type chatReq struct {
Model string `json:"model"`
Messages []chatMsg `json:"messages"`
Tools []chatTool `json:"tools"`
Temperature *float64 `json:"temperature"`
TopP *float64 `json:"top_p"`
MaxTokens *int `json:"max_tokens"`
Stop []string `json:"stop"`
Stream bool `json:"stream"`
}
// chatToMessagesReq 将 OpenAI Chat 请求转为 Anthropic Messages 请求。
func chatToMessagesReq(body []byte) ([]byte, error) {
var req chatReq
if err := json.Unmarshal(body, &req); err != nil {
return nil, err
}
out := map[string]any{
"model": req.Model,
"max_tokens": intOrNil(req.MaxTokens, 1024), // Anthropic 必填
}
if req.Stream {
out["stream"] = true
}
if req.Temperature != nil {
out["temperature"] = *req.Temperature
}
if req.TopP != nil {
out["top_p"] = *req.TopP
}
if len(req.Stop) > 0 {
out["stop_sequences"] = req.Stop
}
var system []string
msgs := make([]any, 0, len(req.Messages))
for _, m := range req.Messages {
if m.Role == "system" {
if s := str(m.Content); s != "" {
system = append(system, s)
}
continue
}
msgs = append(msgs, chatMsgToAnthropic(m))
}
if len(system) > 0 {
out["system"] = strings.Join(system, "\n")
}
out["messages"] = msgs
if len(req.Tools) > 0 {
tools := make([]any, 0, len(req.Tools))
for _, t := range req.Tools {
var params any
if len(t.Function.Parameters) > 0 && string(t.Function.Parameters) != "null" {
_ = json.Unmarshal(t.Function.Parameters, &params)
}
tools = append(tools, map[string]any{
"name": t.Function.Name,
"description": t.Function.Description,
"input_schema": params,
})
}
out["tools"] = tools
}
return json.Marshal(out)
}
// chatMsgToAnthropic 单条消息转 Anthropic 内容。
func chatMsgToAnthropic(m chatMsg) any {
switch m.Role {
case "assistant":
content := make([]any, 0, 2)
if s := str(m.Content); s != "" {
content = append(content, map[string]any{"type": "text", "text": s})
}
for _, tc := range m.ToolCalls {
var input any
if tc.Function.Arguments != "" {
_ = json.Unmarshal([]byte(tc.Function.Arguments), &input)
}
content = append(content, map[string]any{
"type": "tool_use",
"id": tc.ID,
"name": tc.Function.Name,
"input": input,
})
}
return map[string]any{"role": "assistant", "content": content}
case "tool":
return map[string]any{"role": "user", "content": []any{
map[string]any{"type": "tool_result", "tool_use_id": m.ToolCallID, "content": str(m.Content)},
}}
default: // user
var arr []map[string]any
if json.Unmarshal(m.Content, &arr) == nil && arr != nil {
blocks := make([]any, 0, len(arr))
for _, b := range arr {
switch b["type"] {
case "text", "input_text":
if t, _ := b["text"].(string); t != "" {
blocks = append(blocks, map[string]any{"type": "text", "text": t})
}
case "image_url":
var url string
if iu, ok := b["image_url"].(map[string]any); ok {
url, _ = iu["url"].(string)
}
if url != "" {
blocks = append(blocks, map[string]any{"type": "image", "source": map[string]any{"type": "url", "url": url}})
}
}
}
if len(blocks) > 0 {
return map[string]any{"role": "user", "content": blocks}
}
}
return map[string]any{"role": "user", "content": str(m.Content)}
}
}
// ---------------------------------------------------------------------------
// 请求：Messages → Chat
type messagesReq struct {
Model string `json:"model"`
System json.RawMessage `json:"system"`
Messages []struct {
Role string `json:"role"`
Content json.RawMessage `json:"content"`
} `json:"messages"`
Tools []struct {
Name string `json:"name"`
Description string `json:"description"`
InputSchema json.RawMessage `json:"input_schema"`
} `json:"tools"`
Temperature *float64 `json:"temperature"`
TopP *float64 `json:"top_p"`
MaxTokens *int `json:"max_tokens"`
StopSequence []string `json:"stop_sequences"`
Stream bool `json:"stream"`
}
// messagesToChatReq 将 Anthropic Messages 请求转为 OpenAI Chat 请求。
func messagesToChatReq(body []byte) ([]byte, error) {
var req messagesReq
if err := json.Unmarshal(body, &req); err != nil {
return nil, err
}
out := map[string]any{"model": req.Model}
if req.Stream {
out["stream"] = true
}
if req.Temperature != nil {
out["temperature"] = *req.Temperature
}
if req.TopP != nil {
out["top_p"] = *req.TopP
}
if req.MaxTokens != nil {
out["max_tokens"] = *req.MaxTokens
}
if len(req.StopSequence) > 0 {
out["stop"] = req.StopSequence
}
msgs := make([]any, 0, len(req.Messages)+1)
if s := str(req.System); s != "" {
msgs = append(msgs, map[string]any{"role": "system", "content": s})
}
for _, m := range req.Messages {
msgs = append(msgs, anthropicMsgToChat(m.Role, m.Content)...)
}
out["messages"] = msgs
if len(req.Tools) > 0 {
tools := make([]any, 0, len(req.Tools))
for _, t := range req.Tools {
tools = append(tools, map[string]any{
"type": "function",
"function": map[string]any{
"name": t.Name,
"description": t.Description,
"parameters": rawOrObject(t.InputSchema),
},
})
}
out["tools"] = tools
}
return json.Marshal(out)
}
// anthropicMsgToChat 将一条 Anthropic 消息拆成 0..N 条 Chat 消息。
func anthropicMsgToChat(role string, content json.RawMessage) []any {
// 块数组优先（tool_use / tool_result 需要分块解析）
var blocks []map[string]any
if json.Unmarshal(content, &blocks) == nil && blocks != nil {
var out []any
var textParts []string
var toolCalls []any
for _, b := range blocks {
switch b["type"] {
case "text":
if t, _ := b["text"].(string); t != "" {
textParts = append(textParts, t)
}
case "tool_use":
id, _ := b["id"].(string)
name, _ := b["name"].(string)
args, _ := json.Marshal(b["input"])
toolCalls = append(toolCalls, map[string]any{
"id": id,
"type": "function",
"function": map[string]any{
"name": name,
"arguments": string(args),
},
})
case "tool_result":
callID, _ := b["tool_use_id"].(string)
res := strField(b["content"])
out = append(out, map[string]any{"role": "tool", "tool_call_id": callID, "content": res})
}
}
if len(textParts) > 0 || len(toolCalls) > 0 {
msg := map[string]any{"role": role}
if len(textParts) > 0 {
msg["content"] = strings.Join(textParts, "")
}
if len(toolCalls) > 0 {
msg["tool_calls"] = toolCalls
}
out = append(out, msg)
}
if len(out) > 0 {
return out
}
}
// 纯文本
if s := str(content); s != "" {
return []any{map[string]any{"role": role, "content": s}}
}
return nil
}
// ---------------------------------------------------------------------------
// 响应：Messages → Chat
type messagesResp struct {
ID string `json:"id"`
Model string `json:"model"`
Content []struct {
Type string `json:"type"`
Text string `json:"text"`
ID string `json:"id"`
Name string `json:"name"`
Input json.RawMessage `json:"input"`
} `json:"content"`
StopReason string `json:"stop_reason"`
Usage struct {
InputTokens int64 `json:"input_tokens"`
OutputTokens int64 `json:"output_tokens"`
} `json:"usage"`
}
// messagesToChatResp 将 Anthropic Messages 响应（非流式）转为 Chat 响应。
func messagesToChatResp(body []byte) ([]byte, error) {
var r messagesResp
if err := json.Unmarshal(body, &r); err != nil {
return nil, err
}
var text string
var toolCalls []any
for _, c := range r.Content {
switch c.Type {
case "text":
text += c.Text
case "tool_use":
args, _ := json.Marshal(c.Input)
toolCalls = append(toolCalls, map[string]any{
"id": c.ID,
"type": "function",
"function": map[string]any{
"name": c.Name,
"arguments": string(args),
},
})
}
}
msg := map[string]any{"role": "assistant", "content": text}
if len(toolCalls) > 0 {
msg["tool_calls"] = toolCalls
}
return json.Marshal(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(r.ID, "msg_"),
"object": "chat.completion",
"model": r.Model,
"created": 0,
"choices": []any{map[string]any{
"index": 0,
"message": msg,
"finish_reason": messagesStopToChat(r.StopReason),
}},
"usage": map[string]any{
"prompt_tokens": r.Usage.InputTokens,
"completion_tokens": r.Usage.OutputTokens,
"total_tokens": r.Usage.InputTokens + r.Usage.OutputTokens,
},
})
}
// ---------------------------------------------------------------------------
// 响应：Chat → Messages
type chatResp struct {
ID string `json:"id"`
Model string `json:"model"`
Choices []struct {
Message struct {
Role string `json:"role"`
Content string `json:"content"`
ToolCalls []struct {
ID string `json:"id"`
Function struct {
Name string `json:"name"`
Arguments string `json:"arguments"`
} `json:"function"`
} `json:"tool_calls"`
} `json:"message"`
FinishReason string `json:"finish_reason"`
} `json:"choices"`
Usage struct {
PromptTokens int64 `json:"prompt_tokens"`
CompletionTokens int64 `json:"completion_tokens"`
} `json:"usage"`
}
// chatToMessagesResp 将 Chat 响应（非流式）转为 Messages 响应。
func chatToMessagesResp(body []byte) ([]byte, error) {
var r chatResp
if err := json.Unmarshal(body, &r); err != nil {
return nil, err
}
content := make([]any, 0, 2)
var finish = "end_turn"
if len(r.Choices) > 0 {
msg := r.Choices[0].Message
if msg.Content != "" {
content = append(content, map[string]any{"type": "text", "text": msg.Content})
}
for _, tc := range msg.ToolCalls {
var input any
_ = json.Unmarshal([]byte(tc.Function.Arguments), &input)
content = append(content, map[string]any{
"type": "tool_use",
"id": tc.ID,
"name": tc.Function.Name,
"input": input,
})
}
finish = chatStopToMessages(r.Choices[0].FinishReason)
}
return json.Marshal(map[string]any{
"id": "msg_" + strings.TrimPrefix(r.ID, "chatcmpl-"),
"type": "message",
"role": "assistant",
"model": r.Model,
"content": content,
"stop_reason": finish,
"usage": map[string]any{
"input_tokens": r.Usage.PromptTokens,
"output_tokens": r.Usage.CompletionTokens,
},
})
}
// ---------------------------------------------------------------------------
// 辅助
func intOrNil(p *int, def int) any {
if p == nil {
return def
}
return *p
}
func rawOrObject(raw json.RawMessage) any {
if len(raw) == 0 || string(raw) == "null" {
return map[string]any{}
}
var m map[string]any
if json.Unmarshal(raw, &m) == nil {
return m
}
return map[string]any{}
}
func strField(v any) string {
if s, ok := v.(string); ok {
return s
}
return ""
}
func messagesStopToChat(s string) string {
switch s {
case "tool_use":
return "tool_calls"
case "max_tokens":
return "length"
default:
return "stop"
}
}
func chatStopToMessages(s string) string {
switch s {
case "tool_calls":
return "tool_use"
case "length":
return "max_tokens"
default:
return "end_turn"
}
}
server/internal/proxy/convert/json_responses.go
+318
View File
@@ -0,0 +1,318 @@
package convert
import (
"encoding/json"
"strings"
)
// ---------------------------------------------------------------------------
// 请求：Responses → Chat
// responsesToChatReq 将 OpenAI Responses 请求转为 Chat 请求。
func responsesToChatReq(body []byte) ([]byte, error) {
var m map[string]json.RawMessage
if err := json.Unmarshal(body, &m); err != nil {
return nil, err
}
out := map[string]any{"model": str(rawJSON(m, "model"))}
if v, ok := m["stream"]; ok && string(v) == "true" {
out["stream"] = true
}
if v, ok := m["temperature"]; ok {
out["temperature"] = v
}
if v, ok := m["top_p"]; ok {
out["top_p"] = v
}
if v, ok := m["max_output_tokens"]; ok {
out["max_tokens"] = v
}
var msgs []any
if ins := str(rawJSON(m, "instructions")); ins != "" {
msgs = append(msgs, map[string]any{"role": "system", "content": ins})
}
msgs = append(msgs, responsesInputToChat(rawJSON(m, "input"))...)
out["messages"] = msgs
if raw := rawJSON(m, "tools"); raw != nil {
var tools []map[string]any
if json.Unmarshal(raw, &tools) == nil {
chatTools := make([]any, 0, len(tools))
for _, t := range tools {
chatTools = append(chatTools, map[string]any{
"type": "function",
"function": map[string]any{
"name": t["name"],
"description": t["description"],
"parameters": t["parameters"],
},
})
}
out["tools"] = chatTools
}
}
return json.Marshal(out)
}
// responsesInputToChat 把 Responses input 转成 Chat messages。
func responsesInputToChat(raw json.RawMessage) []any {
if len(raw) == 0 || string(raw) == "null" {
return nil
}
// 字符串输入
if s := str(raw); s != "" {
return []any{map[string]any{"role": "user", "content": s}}
}
var items []map[string]any
if err := json.Unmarshal(raw, &items); err != nil || items == nil {
return nil
}
var out []any
for _, item := range items {
switch item["type"] {
case "function_call":
var args any
_ = json.Unmarshal([]byte(strField(item["arguments"])), &args)
out = append(out, map[string]any{
"role": "assistant",
"content": "",
"tool_calls": []any{map[string]any{
"id": strField(item["call_id"]),
"type": "function",
"function": map[string]any{
"name": strField(item["name"]),
"arguments": strField(item["arguments"]),
},
}},
})
case "function_call_output":
out = append(out, map[string]any{
"role": "tool",
"tool_call_id": strField(item["call_id"]),
"content": strField(item["output"]),
})
default: // message 条目
role, _ := item["role"].(string)
if role == "" {
role = "user"
}
if content, ok := item["content"].(string); ok {
out = append(out, map[string]any{"role": role, "content": content})
} else if blocks, ok := item["content"].([]any); ok {
var text []string
for _, b := range blocks {
if bm, ok := b.(map[string]any); ok {
if t, _ := bm["text"].(string); t != "" {
text = append(text, t)
}
}
}
out = append(out, map[string]any{"role": role, "content": strings.Join(text, "")})
}
}
}
return out
}
// ---------------------------------------------------------------------------
// 请求：Chat → Responses
// chatToResponsesReq 将 Chat 请求转为 Responses 请求。
func chatToResponsesReq(body []byte) ([]byte, error) {
var req chatReq
if err := json.Unmarshal(body, &req); err != nil {
return nil, err
}
out := map[string]any{"model": req.Model}
if req.Stream {
out["stream"] = true
}
if req.Temperature != nil {
out["temperature"] = *req.Temperature
}
if req.TopP != nil {
out["top_p"] = *req.TopP
}
if req.MaxTokens != nil {
out["max_output_tokens"] = *req.MaxTokens
}
var system []string
var input []any
for _, m := range req.Messages {
if m.Role == "system" {
if s := str(m.Content); s != "" {
system = append(system, s)
}
continue
}
switch m.Role {
case "tool":
input = append(input, map[string]any{
"type": "function_call_output",
"call_id": m.ToolCallID,
"output": str(m.Content),
})
case "assistant":
if len(m.ToolCalls) > 0 {
for _, tc := range m.ToolCalls {
input = append(input, map[string]any{
"type": "function_call",
"call_id": tc.ID,
"name": tc.Function.Name,
"arguments": tc.Function.Arguments,
})
}
} else if s := str(m.Content); s != "" {
input = append(input, map[string]any{"type": "message", "role": "assistant", "content": []any{
map[string]any{"type": "input_text", "text": s},
}})
}
default:
if s := str(m.Content); s != "" {
input = append(input, map[string]any{"type": "message", "role": "user", "content": []any{
map[string]any{"type": "input_text", "text": s},
}})
}
}
}
if len(system) > 0 {
out["instructions"] = strings.Join(system, "\n")
}
if len(input) == 1 {
out["input"] = input[0] // 单条消息项
} else {
out["input"] = input
}
if len(req.Tools) > 0 {
tools := make([]any, 0, len(req.Tools))
for _, t := range req.Tools {
tools = append(tools, map[string]any{
"type": "function",
"name": t.Function.Name,
"description": t.Function.Description,
"parameters": rawOrObject(t.Function.Parameters),
})
}
out["tools"] = tools
}
return json.Marshal(out)
}
// ---------------------------------------------------------------------------
// 响应：Responses → Chat
// responsesToChatResp 将 Responses 响应（非流式）转为 Chat 响应。
func responsesToChatResp(body []byte) ([]byte, error) {
var m map[string]json.RawMessage
if err := json.Unmarshal(body, &m); err != nil {
return nil, err
}
var text string
var toolCalls []any
if raw := rawJSON(m, "output"); raw != nil {
var outputs []map[string]any
if json.Unmarshal(raw, &outputs) == nil {
for _, o := range outputs {
switch o["type"] {
case "message":
if content, ok := o["content"].([]any); ok {
for _, c := range content {
if cm, ok := c.(map[string]any); ok {
if t, _ := cm["text"].(string); t != "" {
text += t
}
}
}
}
case "function_call":
toolCalls = append(toolCalls, map[string]any{
"id": strField(o["call_id"]),
"type": "function",
"function": map[string]any{
"name": strField(o["name"]),
"arguments": strField(o["arguments"]),
},
})
}
}
}
}
msg := map[string]any{"role": "assistant", "content": text}
if len(toolCalls) > 0 {
msg["tool_calls"] = toolCalls
}
finish := "stop"
if string(rawJSON(m, "status")) == `"incomplete"` {
finish = "length"
}
var prompt, completion int64
if u := rawJSON(m, "usage"); u != nil {
var us struct {
InputTokens int64 `json:"input_tokens"`
OutputTokens int64 `json:"output_tokens"`
}
_ = json.Unmarshal(u, &us)
prompt, completion = us.InputTokens, us.OutputTokens
}
return json.Marshal(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(str(rawJSON(m, "id")), "resp_"),
"object": "chat.completion",
"model": str(rawJSON(m, "model")),
"choices": []any{map[string]any{"index": 0, "message": msg, "finish_reason": finish}},
"usage": map[string]any{
"prompt_tokens": prompt,
"completion_tokens": completion,
"total_tokens": prompt + completion,
},
})
}
// ---------------------------------------------------------------------------
// 响应：Chat → Responses
// chatToResponsesResp 将 Chat 响应（非流式）转为 Responses 响应。
func chatToResponsesResp(body []byte) ([]byte, error) {
var r chatResp
if err := json.Unmarshal(body, &r); err != nil {
return nil, err
}
output := make([]any, 0, 2)
var finish = "completed"
if len(r.Choices) > 0 {
msg := r.Choices[0].Message
if msg.Content != "" {
output = append(output, map[string]any{
"type": "message",
"role": "assistant",
"content": []any{map[string]any{"type": "output_text", "text": msg.Content}},
})
}
for _, tc := range msg.ToolCalls {
output = append(output, map[string]any{
"type": "function_call",
"call_id": tc.ID,
"name": tc.Function.Name,
"arguments": tc.Function.Arguments,
})
}
if r.Choices[0].FinishReason == "length" {
finish = "incomplete"
}
}
status := finish
return json.Marshal(map[string]any{
"id": "resp_" + strings.TrimPrefix(r.ID, "chatcmpl-"),
"object": "response",
"model": r.Model,
"status": status,
"output": output,
"usage": map[string]any{
"input_tokens": r.Usage.PromptTokens,
"output_tokens": r.Usage.CompletionTokens,
"total_tokens": r.Usage.PromptTokens + r.Usage.CompletionTokens,
},
})
}
server/internal/proxy/convert/stream.go
+478
View File
@@ -0,0 +1,478 @@
package convert
import (
"encoding/json"
"strings"
)
// sseState 记录上一行 event 名与通用状态。
type sseState struct {
event string
}
// parseLine 解析一行 SSE；返回是否 data 行及其内容、是否 [DONE]。
func (s *sseState) parseLine(line []byte) (isData bool, data string, done bool) {
str := strings.TrimRight(string(line), "\r\n")
switch {
case strings.HasPrefix(str, "event: "):
s.event = strings.TrimSpace(strings.TrimPrefix(str, "event: "))
return false, "", false
case str == "data: [DONE]":
return true, "[DONE]", true
case strings.HasPrefix(str, "data: "):
return true, strings.TrimPrefix(str, "data: "), false
default:
return false, "", false
}
}
func eventData(line string) map[string]any {
var m map[string]any
_ = json.Unmarshal([]byte(line), &m)
return m
}
func dataLine(obj any) []byte {
b, _ := json.Marshal(obj)
return append(append([]byte("data: "), b...), '\n', '\n')
}
func eventLine(name string, obj any) []byte {
b, _ := json.Marshal(obj)
out := append([]byte("event: "+name+"\ndata: "), b...)
return append(out, '\n', '\n')
}
// ---------------------------------------------------------------------------
// Messages → Chat
type messagesToChat struct {
sseState
id, model string
}
func newMessagesToChat() *messagesToChat { return &messagesToChat{} }
func (t *messagesToChat) line(line []byte) []byte {
isData, data, done := t.parseLine(line)
if !isData {
return nil
}
if done {
return []byte("data: [DONE]\n\n")
}
m := eventData(data)
evt, _ := m["type"].(string)
switch evt {
case "message_start":
msg, _ := m["message"].(map[string]any)
t.id, _ = msg["id"].(string)
t.model, _ = msg["model"].(string)
return dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "msg_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{map[string]any{"index": 0, "delta": map[string]any{"role": "assistant"}, "finish_reason": nil}},
})
case "content_block_delta":
delta, _ := m["delta"].(map[string]any)
text, _ := delta["text"].(string)
if text == "" {
return nil
}
return dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "msg_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{map[string]any{"index": 0, "delta": map[string]any{"content": text}, "finish_reason": nil}},
})
case "message_delta":
delta, _ := m["delta"].(map[string]any)
stop, _ := delta["stop_reason"].(string)
var out [][]byte
out = append(out, dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "msg_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{map[string]any{"index": 0, "delta": map[string]any{}, "finish_reason": messagesStopToChat(stop)}},
}))
if u, ok := m["usage"]; ok {
out = append(out, dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "msg_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{}, "usage": u,
}))
}
return joinLines(out)
case "message_stop":
return []byte("data: [DONE]\n\n")
}
return nil
}
func joinLines(lines [][]byte) []byte {
return []byte(strings.Join(func() []string {
var s []string
for _, l := range lines {
s = append(s, string(l))
}
return s
}(), ""))
}
// ---------------------------------------------------------------------------
// Chat → Messages
type chatToMessages struct {
sseState
started bool
blockStarted bool
model string
stopReason string
usage any
}
func newChatToMessages() *chatToMessages { return &chatToMessages{} }
func (t *chatToMessages) line(line []byte) []byte {
isData, data, done := t.parseLine(line)
if !isData {
return nil
}
if done {
// 汇聚最终 message_delta + content_block_stop + message_stop
md := map[string]any{"type": "message_delta", "delta": map[string]any{
"stop_reason": stopReasonOrEnd(t.stopReason), "stop_sequence": nil,
}}
if t.usage != nil {
md["usage"] = t.usage
}
var out [][]byte
out = append(out, eventLine("message_delta", md))
if t.blockStarted {
out = append(out, eventLine("content_block_stop", map[string]any{"type": "content_block_stop", "index": 0}))
}
out = append(out, eventLine("message_stop", map[string]any{"type": "message_stop"}))
return joinLines(out)
}
m := eventData(data)
// chat 块：delta / finish_reason 在 choices[0] 内
delta := map[string]any{}
if choices, ok := m["choices"].([]any); ok && len(choices) > 0 {
if c0, ok := choices[0].(map[string]any); ok {
if d, ok := c0["delta"].(map[string]any); ok {
delta = d
}
if fr, _ := c0["finish_reason"].(string); fr != "" {
t.stopReason = fr
}
}
}
if t.model == "" {
t.model, _ = m["model"].(string)
}
id, _ := m["id"].(string)
var out [][]byte
// 首个包含内容或角色的块前，先发 message_start + content_block_start
if !t.started {
role, _ := delta["role"].(string)
content, _ := delta["content"].(string)
if role == "assistant" || content != "" {
t.started = true
out = append(out, eventLine("message_start", map[string]any{
"type": "message_start",
"message": map[string]any{
"id": "msg_" + strings.TrimPrefix(id, "chatcmpl-"), "type": "message", "role": "assistant",
"model": t.model, "content": []any{}, "usage": map[string]any{"input_tokens": 0, "output_tokens": 0},
},
}))
out = append(out, eventLine("content_block_start", map[string]any{
"type": "content_block_start", "index": 0, "content_block": map[string]any{"type": "text", "text": ""},
}))
t.blockStarted = true
}
}
if content, _ := delta["content"].(string); content != "" {
if !t.started {
t.started = true
t.blockStarted = true
out = append(out, eventLine("message_start", map[string]any{
"type": "message_start",
"message": map[string]any{"id": "msg_" + strings.TrimPrefix(id, "chatcmpl-"), "type": "message", "role": "assistant", "model": t.model, "content": []any{}},
}))
out = append(out, eventLine("content_block_start", map[string]any{
"type": "content_block_start", "index": 0, "content_block": map[string]any{"type": "text", "text": ""},
}))
}
out = append(out, eventLine("content_block_delta", map[string]any{
"type": "content_block_delta", "index": 0, "delta": map[string]any{"type": "text_delta", "text": content},
}))
}
if u, ok := m["usage"]; ok {
t.usage = u
}
return joinLines(out)
}
func stopReasonOrEnd(s string) string {
if s == "" {
return "end_turn"
}
return chatStopToMessages(s)
}
// ---------------------------------------------------------------------------
// Responses → Messages
type responsesToMessages struct {
sseState
started bool
model string
usage any
}
func newResponsesToMessages() *responsesToMessages { return &responsesToMessages{} }
func (t *responsesToMessages) line(line []byte) []byte {
isData, data, done := t.parseLine(line)
if !isData || done {
return nil
}
m := eventData(data)
evt, _ := m["type"].(string)
if resp, ok := m["response"].(map[string]any); ok {
if t.model == "" {
t.model, _ = resp["model"].(string)
}
if u, ok := resp["usage"]; ok {
t.usage = u
}
}
var out [][]byte
switch evt {
case "response.created":
if !t.started {
t.started = true
id, _ := m["response"].(map[string]any)
rid := ""
if id != nil {
rid, _ = id["id"].(string)
}
out = append(out, eventLine("message_start", map[string]any{
"type": "message_start",
"message": map[string]any{
"id": "msg_" + strings.TrimPrefix(rid, "resp_"), "type": "message", "role": "assistant",
"model": t.model, "content": []any{},
},
}))
out = append(out, eventLine("content_block_start", map[string]any{
"type": "content_block_start", "index": 0, "content_block": map[string]any{"type": "text", "text": ""},
}))
}
case "response.output_text.delta":
delta, _ := m["delta"].(string)
if delta != "" {
out = append(out, eventLine("content_block_delta", map[string]any{
"type": "content_block_delta", "index": 0, "delta": map[string]any{"type": "text_delta", "text": delta},
}))
}
case "response.completed":
out = append(out, eventLine("message_delta", map[string]any{
"type": "message_delta", "delta": map[string]any{"stop_reason": "end_turn", "stop_sequence": nil},
}))
out = append(out, eventLine("content_block_stop", map[string]any{"type": "content_block_stop", "index": 0}))
out = append(out, eventLine("message_stop", map[string]any{"type": "message_stop"}))
}
return joinLines(out)
}
// ---------------------------------------------------------------------------
// Messages → Responses
type messagesToResponses struct {
sseState
model string
usage any
done bool
}
func newMessagesToResponses() *messagesToResponses { return &messagesToResponses{} }
func (t *messagesToResponses) line(line []byte) []byte {
isData, data, done := t.parseLine(line)
if !isData || done {
return nil
}
m := eventData(data)
evt, _ := m["type"].(string)
if msg, ok := m["message"].(map[string]any); ok {
if t.model == "" {
t.model, _ = msg["model"].(string)
}
if u, ok := msg["usage"]; ok {
t.usage = u
}
}
if u, ok := m["usage"]; ok {
t.usage = u
}
var out [][]byte
switch evt {
case "message_start":
id, _ := m["message"].(map[string]any)
rid := ""
if id != nil {
rid, _ = id["id"].(string)
}
out = append(out, eventLine("response.created", map[string]any{
"type": "response.created",
"response": map[string]any{
"id": "resp_" + strings.TrimPrefix(rid, "msg_"), "object": "response", "model": t.model, "status": "in_progress",
},
}))
case "content_block_delta":
delta, _ := m["delta"].(map[string]any)
text, _ := delta["text"].(string)
if text != "" {
out = append(out, eventLine("response.output_text.delta", map[string]any{
"type": "response.output_text.delta", "delta": text, "item_id": "msg_1", "output_index": 0, "content_index": 0,
}))
}
case "message_stop":
if !t.done {
t.done = true
out = append(out, eventLine("response.completed", map[string]any{
"type": "response.completed",
"response": map[string]any{
"id": "resp_stream", "object": "response", "model": t.model, "status": "completed", "usage": t.usage,
},
}))
}
}
return joinLines(out)
}
// ---------------------------------------------------------------------------
// Responses → Chat
type responsesToChat struct {
sseState
id, model string
}
func newResponsesToChat() *responsesToChat { return &responsesToChat{} }
func (t *responsesToChat) line(line []byte) []byte {
isData, data, done := t.parseLine(line)
if !isData {
return nil
}
if done {
return nil
}
m := eventData(data)
evt, _ := m["type"].(string)
if resp, ok := m["response"].(map[string]any); ok {
if t.model == "" {
t.model, _ = resp["model"].(string)
}
if t.id == "" {
t.id, _ = resp["id"].(string)
}
}
var out [][]byte
switch evt {
case "response.created":
out = append(out, dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "resp_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{map[string]any{"index": 0, "delta": map[string]any{"role": "assistant"}, "finish_reason": nil}},
}))
case "response.output_text.delta":
delta, _ := m["delta"].(string)
if delta != "" {
out = append(out, dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "resp_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{map[string]any{"index": 0, "delta": map[string]any{"content": delta}, "finish_reason": nil}},
}))
}
case "response.completed":
out = append(out, dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "resp_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{map[string]any{"index": 0, "delta": map[string]any{}, "finish_reason": "stop"}},
}))
if u, ok := m["response"].(map[string]any); ok {
if usage, ok := u["usage"]; ok {
out = append(out, dataLine(map[string]any{
"id": "chatcmpl-" + strings.TrimPrefix(t.id, "resp_"), "object": "chat.completion.chunk", "model": t.model,
"choices": []any{}, "usage": usage,
}))
}
}
out = append(out, []byte("data: [DONE]\n\n"))
}
return joinLines(out)
}
// ---------------------------------------------------------------------------
// Chat → Responses
type chatToResponses struct {
sseState
model string
usage any
done bool
}
func newChatToResponses() *chatToResponses { return &chatToResponses{} }
func (t *chatToResponses) line(line []byte) []byte {
isData, data, done := t.parseLine(line)
if !isData {
return nil
}
if done {
if !t.done {
t.done = true
return eventLine("response.completed", map[string]any{
"type": "response.completed",
"response": map[string]any{
"id": "resp_stream", "object": "response", "model": t.model, "status": "completed", "usage": t.usage,
},
})
}
return nil
}
m := eventData(data)
if t.model == "" {
t.model, _ = m["model"].(string)
}
if u, ok := m["usage"]; ok {
t.usage = u
}
delta := map[string]any{}
var finish string
if choices, ok := m["choices"].([]any); ok && len(choices) > 0 {
if c0, ok := choices[0].(map[string]any); ok {
if d, ok := c0["delta"].(map[string]any); ok {
delta = d
}
finish, _ = c0["finish_reason"].(string)
}
}
var out [][]byte
if role, _ := delta["role"].(string); role == "assistant" {
out = append(out, eventLine("response.created", map[string]any{
"type": "response.created",
"response": map[string]any{"id": "resp_stream", "object": "response", "model": t.model, "status": "in_progress"},
}))
}
if content, _ := delta["content"].(string); content != "" {
out = append(out, eventLine("response.output_text.delta", map[string]any{
"type": "response.output_text.delta", "delta": content, "item_id": "msg_1", "output_index": 0, "content_index": 0,
}))
}
if finish != "" && !t.done {
t.done = true
out = append(out, eventLine("response.completed", map[string]any{
"type": "response.completed",
"response": map[string]any{
"id": "resp_stream", "object": "response", "model": t.model, "status": "completed", "usage": t.usage,
},
}))
}
return joinLines(out)
}
server/internal/proxy/gateway.go
+86 -10
View File
@@ -1,5 +1,5 @@
// Package proxy API 网关核心：代理 /v1/chat/completions、/v1/responses、/v1/models。
// M1：对 OpenAI 渠道直通（passthrough），不转格式；M3 起加入协议转换。
// Package proxy API 网关核心：代理 /v1/chat/completions、/v1/responses、/v1/messages、/v1/models。
// M1 直通 OpenAI 渠道；M4 起按客户端协议 × 渠道协议自动转换（见 convert）。
package proxy
import (
@@ -12,6 +12,7 @@ import (
"github.com/openteam/server/internal/channel"
"github.com/openteam/server/internal/pkg/apikey"
"github.com/openteam/server/internal/pkg/crypto"
"github.com/openteam/server/internal/proxy/convert"
"github.com/openteam/server/internal/store"
"github.com/openteam/server/internal/usage"
"gorm.io/gorm"
@@ -43,29 +44,39 @@ func NewGateway(db *gorm.DB, enc *crypto.Encryptor, rec *usage.Recorder) *Gatewa
// Auth 代理鉴权中间件：Bearer sk-xxx → 哈希查表 → 校验状态/过期/模型白名单。
func (g *Gateway) Auth(c *gin.Context) {
// 先按路径确定客户端协议，保证 Auth 阶段错误也按协议格式返回
switch c.Request.URL.Path {
case "/v1/messages":
c.Set("protocol", convert.ProtoMessages)
case "/v1/responses":
c.Set("protocol", convert.ProtoResponses)
default:
c.Set("protocol", convert.ProtoChat)
}
auth := c.GetHeader("Authorization")
key := strings.TrimPrefix(auth, "Bearer ")
key = strings.TrimSpace(key)
if !apikey.Valid(key) {
openAIError(c, http.StatusUnauthorized, "invalid_api_key", "Invalid API key format. Expected: Bearer sk-...")
apiError(c, http.StatusUnauthorized, "invalid_api_key", "Invalid API key format. Expected: Bearer sk-...")
c.Abort()
return
}
hash := apikey.Hash(key)
var k store.APIKey
if err := g.db.Where("key_hash = ? AND status = ?", hash, store.KeyStatusActive).First(&k).Error; err != nil {
openAIError(c, http.StatusUnauthorized, "invalid_api_key", "Invalid API key")
apiError(c, http.StatusUnauthorized, "invalid_api_key", "Invalid API key")
c.Abort()
return
}
var u store.User
if err := g.db.First(&u, k.UserID).Error; err != nil || u.Status != store.UserStatusActive {
openAIError(c, http.StatusForbidden, "user_disabled", "User account is disabled")
apiError(c, http.StatusForbidden, "user_disabled", "User account is disabled")
c.Abort()
return
}
if k.ExpiresAt != nil && time.Now().After(*k.ExpiresAt) {
openAIError(c, http.StatusUnauthorized, "key_expired", "API key has expired")
apiError(c, http.StatusUnauthorized, "key_expired", "API key has expired")
c.Abort()
return
}
@@ -84,10 +95,12 @@ func (g *Gateway) Handle(c *gin.Context) {
g.chatCompletions(c)
case c.Request.URL.Path == "/v1/responses":
g.responses(c)
case c.Request.URL.Path == "/v1/messages":
g.messages(c)
case c.Request.URL.Path == "/v1/models" && c.Request.Method == http.MethodGet:
g.models(c)
default:
openAIError(c, http.StatusNotFound, "not_found", "Unknown endpoint: "+c.Request.URL.Path)
apiError(c, http.StatusNotFound, "not_found", "Unknown endpoint: "+c.Request.URL.Path)
}
}
@@ -95,7 +108,7 @@ func (g *Gateway) Handle(c *gin.Context) {
func (g *Gateway) models(c *gin.Context) {
var ms []store.Model
if err := g.db.Where("enabled = ?", true).Order("sort ASC, id ASC").Find(&ms).Error; err != nil {
openAIError(c, http.StatusInternalServerError, "internal_error", "failed to load models")
apiError(c, http.StatusInternalServerError, "internal_error", "failed to load models")
return
}
data := make([]gin.H, 0, len(ms))
@@ -110,12 +123,22 @@ func (g *Gateway) models(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{"object": "list", "data": data})
}
// selectChannel 选渠道：优先按模型绑定解析，退化为全局选渠道。
func (g *Gateway) selectChannel(c *gin.Context, model string) (*store.Channel, error) {
if model != "" {
if ch, _, err := g.ch.ResolveModel(model); err == nil {
return ch, nil
}
}
return g.ch.Select()
}
// resolveUser 取当前用户（含余额）。
func (g *Gateway) resolveUser(c *gin.Context) (*store.User, bool) {
uid, _ := c.Get(CtxUserID)
var u store.User
if err := g.db.First(&u, uid).Error; err != nil {
openAIError(c, http.StatusUnauthorized, "invalid_api_key", "Invalid API key")
apiError(c, http.StatusUnauthorized, "invalid_api_key", "Invalid API key")
return nil, false
}
return &u, true
@@ -124,10 +147,63 @@ func (g *Gateway) resolveUser(c *gin.Context) (*store.User, bool) {
// checkBalance 余额不足返回 402（PLANNING §4.4.3）。
func (g *Gateway) checkBalance(c *gin.Context, u *store.User) bool {
if u.Balance <= 0 {
openAIError(c, http.StatusPaymentRequired, "insufficient_balance", "Insufficient balance. Please recharge or contact admin.")
apiError(c, http.StatusPaymentRequired, "insufficient_balance", "Insufficient balance. Please recharge or contact admin.")
return false
}
return true
}
// ---------------------------------------------------------------------------
// 协议分派
// upstreamProtoFor 根据渠道 provider 与客户端协议确定上游协议与路径。
func upstreamProtoFor(provider, clientProto string) string {
switch provider {
case store.ChannelProviderAnthropic:
return convert.ProtoMessages
case store.ChannelProviderOpenAI:
if clientProto == convert.ProtoMessages {
return convert.ProtoChat
}
return clientProto
default: // compatible：假定 OpenAI Chat 形状
return convert.ProtoChat
}
}
func upstreamPath(proto string) string {
switch proto {
case convert.ProtoMessages:
return "/v1/messages"
case convert.ProtoResponses:
return "/v1/responses"
default:
return "/v1/chat/completions"
}
}
// upstreamPlan 描述一次代理请求的上游访问方式。
type upstreamPlan struct {
path string // 上游路径
body []byte // 已转换的请求体
lineConv func([]byte) []byte // 流式逐行转换（nil=直通）
bodyConv func([]byte) ([]byte, error) // 非流式响应体转换（nil=直通）
}
// prepareUpstream 计算上游访问计划：协议匹配直通，否则转换。
func prepareUpstream(provider, clientProto string, body []byte) (*upstreamPlan, error) {
up := upstreamProtoFor(provider, clientProto)
plan := &upstreamPlan{path: upstreamPath(up), body: body}
if up != clientProto {
converted, err := convert.ConvertRequest(body, clientProto, up)
if err != nil {
return nil, err
}
plan.body = converted
plan.lineConv = convert.NewStreamTransformer(up, clientProto)
plan.bodyConv = func(b []byte) ([]byte, error) { return convert.ConvertResponse(b, up, clientProto) }
}
return plan, nil
}
var errNoChannel = errors.New("no available channel")
server/internal/proxy/handlers.go
+65 -32
View File
@@ -1,11 +1,10 @@
package proxy
import (
"encoding/json"
"net/http"
"github.com/gin-gonic/gin"
"github.com/openteam/server/internal/store"
"github.com/openteam/server/internal/proxy/convert"
)
// chatCompletions POST /v1/chat/completions
@@ -17,27 +16,28 @@ func (g *Gateway) chatCompletions(c *gin.Context) {
if !g.checkBalance(c, u) {
return
}
br, body, err := parseBody(c)
if err != nil {
openAIError(c, http.StatusBadRequest, "invalid_request_error", "failed to read request body")
apiError(c, http.StatusBadRequest, "invalid_request_error", "failed to read request body")
return
}
c.Set("protocol", "chat")
c.Set("protocol", convert.ProtoChat)
c.Set("model_name", br.Model)
ch, err := g.ch.Select()
ch, err := g.selectChannel(c, br.Model)
if err != nil {
openAIError(c, http.StatusServiceUnavailable, "no_channel", "No available upstream channel")
apiError(c, http.StatusServiceUnavailable, "no_channel", "No available upstream channel")
g.recordError(c, nil, nil, now(), "no_channel")
return
}
plan, err := prepareUpstream(ch.Provider, convert.ProtoChat, body)
if err != nil {
apiError(c, http.StatusInternalServerError, "conversion_error", "Failed to convert request: "+err.Error())
return
}
sink := &usageSink{}
c.Set("usage_raw", &sinkHolder{sink: sink})
g.doPassthrough(c, ch, "/v1/chat/completions", body, br.Stream, func(raw json.RawMessage) {
sink.push(raw)
})
g.doProxy(c, ch, plan, br.Stream, sink)
}
// responses POST /v1/responses（OpenAI Responses API）
@@ -49,33 +49,61 @@ func (g *Gateway) responses(c *gin.Context) {
if !g.checkBalance(c, u) {
return
}
br, body, err := parseBody(c)
if err != nil {
openAIError(c, http.StatusBadRequest, "invalid_request_error", "failed to read request body")
apiError(c, http.StatusBadRequest, "invalid_request_error", "failed to read request body")
return
}
c.Set("protocol", "responses")
c.Set("protocol", convert.ProtoResponses)
c.Set("model_name", br.Model)
ch, err := g.ch.Select()
ch, err := g.selectChannel(c, br.Model)
if err != nil {
openAIError(c, http.StatusServiceUnavailable, "no_channel", "No available upstream channel")
apiError(c, http.StatusServiceUnavailable, "no_channel", "No available upstream channel")
g.recordError(c, nil, nil, now(), "no_channel")
return
}
// M1 仅支持 OpenAI 原生渠道直通；Anthropic 渠道的转换在 M3
if ch.Provider != store.ChannelProviderOpenAI {
openAIError(c, http.StatusNotImplemented, "conversion_pending",
"Responses protocol on this channel requires format conversion (planned in M3)")
plan, err := prepareUpstream(ch.Provider, convert.ProtoResponses, body)
if err != nil {
apiError(c, http.StatusInternalServerError, "conversion_error", "Failed to convert request: "+err.Error())
return
}
sink := &usageSink{}
c.Set("usage_raw", &sinkHolder{sink: sink})
g.doPassthrough(c, ch, "/v1/responses", body, br.Stream, func(raw json.RawMessage) {
sink.push(raw)
})
g.doProxy(c, ch, plan, br.Stream, sink)
}
// messages POST /v1/messages（Anthropic Messages API）
func (g *Gateway) messages(c *gin.Context) {
u, ok := g.resolveUser(c)
if !ok {
return
}
if !g.checkBalance(c, u) {
return
}
br, body, err := parseBody(c)
if err != nil {
apiError(c, http.StatusBadRequest, "invalid_request_error", "failed to read request body")
return
}
c.Set("protocol", convert.ProtoMessages)
c.Set("model_name", br.Model)
ch, err := g.selectChannel(c, br.Model)
if err != nil {
apiError(c, http.StatusServiceUnavailable, "no_channel", "No available upstream channel")
g.recordError(c, nil, nil, now(), "no_channel")
return
}
plan, err := prepareUpstream(ch.Provider, convert.ProtoMessages, body)
if err != nil {
apiError(c, http.StatusInternalServerError, "conversion_error", "Failed to convert request: "+err.Error())
return
}
sink := &usageSink{}
c.Set("usage_raw", &sinkHolder{sink: sink})
g.doProxy(c, ch, plan, br.Stream, sink)
}
// usageSinkHolder 桥接：gin context 里保存 sink 引用，供 finishUsage 读取最终 usage。
@@ -83,8 +111,17 @@ type sinkHolder struct {
sink *usageSink
}
// openAIError 按 OpenAI 错误格式返回（PLANNING §4.1.4）。
func openAIError(c *gin.Context, status int, code, message string) {
// apiError 按客户端协议返回错误体（PLANNING §5.1.4）。
func apiError(c *gin.Context, status int, code, message string) {
if p, _ := c.Get("protocol"); p == convert.ProtoMessages {
// Anthropic 格式
c.AbortWithStatusJSON(status, gin.H{
"type": "error",
"error": gin.H{"type": errorTypeFor(status), "message": message},
})
return
}
// OpenAI 格式
c.AbortWithStatusJSON(status, gin.H{
"error": gin.H{
"message": message,
@@ -99,14 +136,10 @@ func errorTypeFor(status int) string {
switch status {
case http.StatusUnauthorized:
return "authentication_error"
case http.StatusForbidden:
case http.StatusForbidden, http.StatusPaymentRequired:
return "permission_error"
case http.StatusNotFound:
case http.StatusNotFound, http.StatusBadRequest:
return "invalid_request_error"
case http.StatusBadRequest:
return "invalid_request_error"
case http.StatusPaymentRequired:
return "insufficient_quota"
case http.StatusTooManyRequests:
return "rate_limit_error"
default:
server/internal/proxy/passthrough.go
+121 -60
View File
@@ -43,24 +43,22 @@ func parseBody(c *gin.Context) (*bodyReq, []byte, error) {
return br, body, nil
}
// upstreamURL 组装上游地址：base_url + 客户端路径（/v1/chat/completions 等）。
// upstreamURL 组装上游地址：base_url + 路径。
func upstreamURL(ch *store.Channel, path string) string {
base := strings.TrimRight(ch.BaseURL, "/")
return base + path
return strings.TrimRight(ch.BaseURL, "/") + path
}
// doPassthrough 通用直通：替换 Authorization 为渠道密钥，转发请求。
// convert 回调用于改写请求体（M1 直通为原样；M3 转换时改写）。
func (g *Gateway) doPassthrough(c *gin.Context, ch *store.Channel, path string, body []byte, stream bool, outUsage func(usageRaw json.RawMessage)) {
// doProxy 通用代理：替换 Authorization 为渠道密钥，转发请求；按 plan 决定路径与转换。
func (g *Gateway) doProxy(c *gin.Context, ch *store.Channel, plan *upstreamPlan, stream bool, sink *usageSink) {
upKey, err := g.ch.UpstreamKey(ch)
if err != nil {
openAIError(c, http.StatusInternalServerError, "channel_error", "failed to decrypt channel key")
apiError(c, http.StatusInternalServerError, "channel_error", "failed to decrypt channel key")
return
}
upBody := body
// 流式 chat：注入 stream_options.include_usage，保证末块带 usage（OpenAI 行为）
if stream && path == "/v1/chat/completions" && !bytes.Contains(upBody, []byte(`"include_usage"`)) {
upBody := plan.body
// 直通 chat 流式：注入 stream_options.include_usage，保证末块带 usage（OpenAI 行为）
if stream && plan.path == "/v1/chat/completions" && plan.lineConv == nil && !bytes.Contains(upBody, []byte(`"include_usage"`)) {
var m map[string]any
if json.Unmarshal(upBody, &m) == nil {
m["stream_options"] = map[string]any{"include_usage": true}
@@ -72,9 +70,9 @@ func (g *Gateway) doPassthrough(c *gin.Context, ch *store.Channel, path string,
ctx, cancel := context.WithTimeout(c.Request.Context(), time.Duration(ch.TimeoutMS)*time.Millisecond)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodPost, upstreamURL(ch, path), bytes.NewReader(upBody))
req, err := http.NewRequestWithContext(ctx, http.MethodPost, upstreamURL(ch, plan.path), bytes.NewReader(upBody))
if err != nil {
openAIError(c, http.StatusInternalServerError, "internal_error", "failed to build upstream request")
apiError(c, http.StatusInternalServerError, "internal_error", "failed to build upstream request")
return
}
req.Header.Set("Content-Type", "application/json")
@@ -83,6 +81,9 @@ func (g *Gateway) doPassthrough(c *gin.Context, ch *store.Channel, path string,
if ua := c.GetHeader("User-Agent"); ua != "" {
req.Header.Set("User-Agent", ua)
}
if plan.path == "/v1/messages" {
req.Header.Set("anthropic-version", "2023-06-01")
}
// 透传 OpenAI 生态请求头（组织/项目等）
for _, h := range []string{"OpenAI-Organization", "OpenAI-Project", "OpenAI-Beta"} {
if v := c.GetHeader(h); v != "" {
@@ -99,55 +100,57 @@ func (g *Gateway) doPassthrough(c *gin.Context, ch *store.Channel, path string,
status = http.StatusGatewayTimeout
msg = "Upstream request timed out"
}
openAIError(c, status, "upstream_error", msg)
apiError(c, status, "upstream_error", msg)
g.recordError(c, ch, nil, start, "upstream_error")
return
}
defer resp.Body.Close()
// 非 2xx：透传上游错误体（OpenAI 格式），并记录 error 用量
// 非 2xx：透传上游错误体，并记录 error 用量
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
errBody, _ := io.ReadAll(resp.Body)
status := resp.StatusCode
// 上游 5xx → 网关 502/504（重试逻辑 M4）
if status >= 500 {
status = http.StatusBadGateway
}
c.DataFromReader(status, int64(len(errBody)), "application/json", bytes.NewReader(errBody), nil)
c.Header("Content-Type", "application/json")
c.DataFromReader(status, int64(len(errBody)), "application/json", bytes.NewReader(errBody), nil)
g.recordError(c, ch, resp, start, "upstream_http_"+strconv.Itoa(resp.StatusCode))
return
}
// 成功响应
c.Header("Content-Type", resp.Header.Get("Content-Type"))
c.Status(http.StatusOK)
if stream {
g.streamCopy(c, ch, resp.Body, start, outUsage)
g.streamCopy(c, ch, resp.Body, start, plan.lineConv, sink)
} else {
g.copyAndCapture(c, ch, resp.Body, start, outUsage)
g.copyAndCapture(c, ch, resp.Body, start, plan.bodyConv, sink)
}
}
// copyAndCapture 非流式：整体转发 + 解析 usage + 记账。
func (g *Gateway) copyAndCapture(c *gin.Context, ch *store.Channel, r io.Reader, start time.Time, outUsage func(json.RawMessage)) {
// copyAndCapture 非流式：整体转发（可转换）+ 解析 usage + 记账。
func (g *Gateway) copyAndCapture(c *gin.Context, ch *store.Channel, r io.Reader, start time.Time, bodyConv func([]byte) ([]byte, error), sink *usageSink) {
data, err := io.ReadAll(r)
if err != nil {
openAIError(c, http.StatusBadGateway, "upstream_error", "failed reading upstream response")
apiError(c, http.StatusBadGateway, "upstream_error", "failed reading upstream response")
g.recordError(c, ch, nil, start, "read_error")
return
}
// 尝试解析 usage（chat / responses 字段不同）
if usageRaw := extractUsage(data); usageRaw != nil {
outUsage(usageRaw)
if usageRaw := extractUsage(data); usageRaw != nil && sink != nil {
sink.push(usageRaw)
}
_, _ = c.Writer.Write(data)
out := data
if bodyConv != nil {
if converted, cerr := bodyConv(data); cerr == nil {
out = converted
}
}
_, _ = c.Writer.Write(out)
g.finishUsage(c, ch, start, store.UsageStatusSuccess, "")
}
// streamCopy 流式：边读上游 SSE 边写客户端，零缓冲转发；扫描 usage 行记账。
// 客户端断连（ctx cancel）即中止上游读取。
func (g *Gateway) streamCopy(c *gin.Context, ch *store.Channel, r io.Reader, start time.Time, outUsage func(json.RawMessage)) {
// streamCopy 流式：边读上游 SSE 边写客户端，零缓冲转发；按 lineConv 转换；扫描 usage 记账。
func (g *Gateway) streamCopy(c *gin.Context, ch *store.Channel, r io.Reader, start time.Time, lineConv func([]byte) []byte, sink *usageSink) {
w := c.Writer
flusher, ok := w.(http.Flusher)
if !ok {
@@ -158,19 +161,26 @@ func (g *Gateway) streamCopy(c *gin.Context, ch *store.Channel, r io.Reader, sta
for {
line, err := scanner.Next()
if line != nil {
if _, werr := w.Write(line); werr != nil {
// 客户端断开：取消上游（ctx cancel 由 request ctx 处理）
out := line
if lineConv != nil {
out = lineConv(line)
}
if out != nil {
if _, werr := w.Write(out); werr != nil {
g.recordError(c, ch, nil, start, "client_disconnect")
return
}
flusher.Flush()
if usageRaw := scanUsage(line); usageRaw != nil {
outUsage(usageRaw)
}
if usageRaw := scanUsage(line); usageRaw != nil && sink != nil {
sink.push(usageRaw)
}
}
if err != nil {
if err == io.EOF {
g.finishUsage(c, ch, start, store.UsageStatusSuccess, "")
} else if c.Request.Context().Err() != nil {
g.recordError(c, ch, nil, start, "client_disconnect")
} else {
g.recordError(c, ch, nil, start, "stream_read_error")
}
@@ -186,37 +196,34 @@ func (nopFlusher) Flush() {}
// ---------------------------------------------------------------------------
// usage 提取
// usageShape 兼容 chat (prompt/completion) 与 responses (input/output) 两种命名。
// usageShape 兼容 chat (prompt/completion)、responses (input/output)、messages (input/output) 命名。
type usageShape struct {
PromptTokens int64 `json:"prompt_tokens"`
CompletionTokens int64 `json:"completion_tokens"`
InputTokens int64 `json:"input_tokens"`
OutputTokens int64 `json:"output_tokens"`
TotalTokens int64 `json:"total_tokens"`
// Claude 缓存口径（M3 接入）
CacheReadInputTokens int64 `json:"cache_read_input_tokens"`
CacheCreationInputTokens int64 `json:"cache_creation_input_tokens"`
}
// extractUsage 从完整响应体提取 usage 子对象。
// extractUsage 从完整响应体提取 usage 子对象（chat / responses / messages）。
func extractUsage(data []byte) json.RawMessage {
var m map[string]json.RawMessage
if json.Unmarshal(data, &m) != nil {
return nil
}
if u, ok := m["usage"]; ok && string(u) != "null" {
if u := usageFromMap(m); u != nil {
return u
}
// responses 事件/响应：usage 嵌套在 response 对象内
if respRaw, ok := m["response"]; ok {
var resp map[string]json.RawMessage
if json.Unmarshal(respRaw, &resp) == nil {
if u, ok := resp["usage"]; ok && string(u) != "null" {
if u := usageFromMap(resp); u != nil {
return u
}
}
}
// chat 兜底：choices[].message.usage
if choices, ok := m["choices"]; ok {
var cs []map[string]json.RawMessage
if json.Unmarshal(choices, &cs) == nil {
@@ -224,7 +231,7 @@ func extractUsage(data []byte) json.RawMessage {
if msgRaw, ok := ch["message"]; ok {
var msg map[string]json.RawMessage
if json.Unmarshal(msgRaw, &msg) == nil {
if u, ok := msg["usage"]; ok && string(u) != "null" {
if u := usageFromMap(msg); u != nil {
return u
}
}
@@ -235,7 +242,7 @@ func extractUsage(data []byte) json.RawMessage {
return nil
}
// scanUsage 从 SSE 一行中提取 usage（OpenAI 末块 / responses completed 事件）。
// scanUsage 从 SSE 一行中提取 usage（OpenAI 末块 / responses completed / messages message_delta 等）。
func scanUsage(line []byte) json.RawMessage {
s := string(line)
if !strings.Contains(s, `"usage"`) {
@@ -252,14 +259,29 @@ func scanUsage(line []byte) json.RawMessage {
if json.Unmarshal([]byte(s), &m) != nil {
return nil
}
if u, ok := m["usage"]; ok && string(u) != "null" {
if u := usageFromMap(m); u != nil {
return u
}
// responses 流式：usage 在 response 对象内（response.completed 事件）
if respRaw, ok := m["response"]; ok {
var resp map[string]json.RawMessage
if json.Unmarshal(respRaw, &resp) == nil {
if u, ok := resp["usage"]; ok && string(u) != "null" {
if u := usageFromMap(resp); u != nil {
return u
}
}
}
return nil
}
// usageFromMap 从 map 顶层或 message 子对象中取 usage。
func usageFromMap(m map[string]json.RawMessage) json.RawMessage {
if u, ok := m["usage"]; ok && string(u) != "null" {
return u
}
if msgRaw, ok := m["message"]; ok {
var msg map[string]json.RawMessage
if json.Unmarshal(msgRaw, &msg) == nil {
if u, ok := msg["usage"]; ok && string(u) != "null" {
return u
}
}
@@ -268,7 +290,6 @@ func scanUsage(line []byte) json.RawMessage {
}
// sseScanner 按 SSE 行边界读取（兼容 \n 与 \r\n），保留原始行内容。
// 基于 bufio.Reader：行内可含任意内容，跨 chunk 自动拼接。
type sseScanner struct {
r *bufio.Reader
}
@@ -289,17 +310,43 @@ func (s *sseScanner) Next() ([]byte, error) {
// ---------------------------------------------------------------------------
// 记账
// usageSink 累积流式多次 usage（取最后一次，即最终值）。
// usageSink 累积多次 usage：合并各事件字段（message_start 给 input，message_delta 给 output）。
type usageSink struct {
last json.RawMessage
us usageShape
}
func (u *usageSink) push(raw json.RawMessage) {
if len(raw) > 0 {
u.last = raw
if len(raw) == 0 {
return
}
var t usageShape
if json.Unmarshal(raw, &t) != nil {
return
}
// 零值不覆盖：不同事件携带不同字段
if t.PromptTokens > 0 {
u.us.PromptTokens = t.PromptTokens
}
if t.CompletionTokens > 0 {
u.us.CompletionTokens = t.CompletionTokens
}
if t.InputTokens > 0 {
u.us.InputTokens = t.InputTokens
}
if t.OutputTokens > 0 {
u.us.OutputTokens = t.OutputTokens
}
if t.CacheReadInputTokens > 0 {
u.us.CacheReadInputTokens = t.CacheReadInputTokens
}
if t.CacheCreationInputTokens > 0 {
u.us.CacheCreationInputTokens = t.CacheCreationInputTokens
}
}
// Shape 返回合并后的用量。
func (u *usageSink) Shape() usageShape { return u.us }
// finishUsage 落账：计算成本并异步写入。
func (g *Gateway) finishUsage(c *gin.Context, ch *store.Channel, start time.Time, status, errCode string) {
uid, _ := c.Get(CtxUserID)
@@ -308,8 +355,8 @@ func (g *Gateway) finishUsage(c *gin.Context, ch *store.Channel, start time.Time
var us usageShape
if h, ok := c.Get("usage_raw"); ok {
if holder, ok := h.(*sinkHolder); ok && holder.sink != nil && len(holder.sink.last) > 0 {
_ = json.Unmarshal(holder.sink.last, &us)
if holder, ok := h.(*sinkHolder); ok && holder.sink != nil {
us = holder.sink.Shape()
}
}
@@ -340,20 +387,35 @@ func (g *Gateway) finishUsage(c *gin.Context, ch *store.Channel, start time.Time
p = "chat"
}
traceStr, _ := trace.(string)
errMsg := errCode
latency := int(time.Since(start).Milliseconds())
// 已写响应头但流中途出错：记 error
if status == store.UsageStatusSuccess && c.Writer.Status() >= 400 {
status = store.UsageStatusError
}
var errCodePtr *string
if errCode != "" {
errCodePtr = &errCode
}
var uidVal, kidVal uint64
if u, ok := uid.(uint64); ok {
uidVal = u
}
if k, ok := kid.(uint64); ok {
kidVal = k
}
var chID uint64
if ch != nil {
chID = ch.ID
}
g.rec.Record(&store.UsageLog{
RequestID: fmt.Sprintf("trace-%s", traceStr),
TraceID: traceStr,
UserID: uid.(uint64),
KeyID: kid.(uint64),
ChannelID: ch.ID,
UserID: uidVal,
KeyID: kidVal,
ChannelID: chID,
ModelID: modelID,
ModelName: mn,
Protocol: p,
@@ -367,16 +429,15 @@ func (g *Gateway) finishUsage(c *gin.Context, ch *store.Channel, start time.Time
Cost: cost,
LatencyMS: latency,
Status: status,
ErrorCode: &errMsg,
ErrorCode: errCodePtr,
CreatedAt: time.Now().UTC(),
})
}
// recordError 失败请求的记账（不产生扣费，status=error）。
func (g *Gateway) recordError(c *gin.Context, ch *store.Channel, resp *http.Response, start time.Time, code string) {
status := store.UsageStatusError
_ = resp
g.finishUsage(c, ch, start, status, code)
g.finishUsage(c, ch, start, store.UsageStatusError, code)
}
func now() time.Time { return time.Now() }
server/internal/proxy/stream_test.go
+84 -66
View File
@@ -3,105 +3,123 @@ package proxy
import (
"encoding/json"
"io"
"strings"
"testing"
)
func TestScanUsageChat(t *testing.T) {
line := []byte(`data: {"id":"x","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":9,"total_tokens":21}}`)
raw := scanUsage(line)
func TestSSEScannerSplitsLines(t *testing.T) {
input := "event: message\ndata: {\"a\":1}\n\n" +
"data: {\"b\":2}\r\n\r\n" +
"data: [DONE]\n\n"
s := newSSEScanner(strings.NewReader(input))
var lines []string
for {
line, err := s.Next()
if line != nil {
lines = append(lines, string(line))
}
if err == io.EOF {
break
}
if err != nil {
t.Fatalf("Next: %v", err)
}
}
want := []string{
"event: message\n",
"data: {\"a\":1}\n",
"\n",
"data: {\"b\":2}\r\n",
"\r\n",
"data: [DONE]\n",
"\n",
}
if len(lines) != len(want) {
t.Fatalf("line count = %d, want %d (lines: %q)", len(lines), len(want), lines)
}
for i := range want {
if lines[i] != want[i] {
t.Fatalf("line[%d] = %q, want %q", i, lines[i], want[i])
}
}
}
func TestScanUsageChatStream(t *testing.T) {
chunk := `data: {"id":"x","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":9,"total_tokens":21}}`
raw := scanUsage([]byte(chunk + "\n"))
if raw == nil {
t.Fatal("chat usage not detected")
t.Fatal("expected usage extracted")
}
var us usageShape
if err := json.Unmarshal(raw, &us); err != nil {
t.Fatal(err)
t.Fatalf("unmarshal: %v", err)
}
if us.PromptTokens != 12 || us.CompletionTokens != 9 {
t.Fatalf("usage mismatch: %+v", us)
}
}
func TestScanUsageResponsesNested(t *testing.T) {
line := []byte(`data: {"response":{"id":"r","status":"completed","usage":{"input_tokens":15,"output_tokens":11,"total_tokens":26}},"type":"response.completed"}`)
raw := scanUsage(line)
func TestScanUsageResponsesCompleted(t *testing.T) {
line := `data: {"type":"response.completed","response":{"id":"r1","status":"completed","usage":{"input_tokens":15,"output_tokens":11}}}`
raw := scanUsage([]byte(line + "\n"))
if raw == nil {
t.Fatal("responses nested usage not detected")
t.Fatal("expected usage extracted from response.completed")
}
var us usageShape
if err := json.Unmarshal(raw, &us); err != nil {
t.Fatal(err)
}
_ = json.Unmarshal(raw, &us)
if us.InputTokens != 15 || us.OutputTokens != 11 {
t.Fatalf("usage mismatch: %+v", us)
}
}
func TestScanUsageIgnoresNonData(t *testing.T) {
if scanUsage([]byte("event: response.completed")) != nil {
t.Fatal("event line should be ignored")
func TestScanUsageIgnoresNonUsage(t *testing.T) {
if raw := scanUsage([]byte(`data: {"type":"response.output_text.delta","delta":"hi"}`)); raw != nil {
t.Fatalf("expected nil for non-usage line, got %s", raw)
}
if scanUsage([]byte("data: [DONE]")) != nil {
t.Fatal("[DONE] should be ignored")
}
if scanUsage([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hi\"}}]}")) != nil {
t.Fatal("content chunk without usage should be ignored")
if raw := scanUsage([]byte(`data: [DONE]`)); raw != nil {
t.Fatal("expected nil for [DONE]")
}
}
func TestExtractUsageFromFullBody(t *testing.T) {
body := []byte(`{"id":"x","choices":[{"message":{"content":"hi"}}],"usage":{"prompt_tokens":1,"completion_tokens":2}}`)
raw := extractUsage(body)
func TestExtractUsageChatBody(t *testing.T) {
body := `{"id":"x","choices":[{"message":{"role":"assistant","content":"hi"}}],"usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3}}`
raw := extractUsage([]byte(body))
if raw == nil {
t.Fatal("usage not extracted from full body")
t.Fatal("expected usage")
}
if !strings.Contains(string(raw), `"prompt_tokens":1`) {
t.Fatalf("unexpected usage: %s", raw)
}
}
func TestExtractUsageResponsesNested(t *testing.T) {
// responses 顶层只有 response 对象，usage 嵌套其中
body := `{"id":"r1","object":"response","status":"completed","response":{"usage":{"input_tokens":7,"output_tokens":8}}}`
raw := extractUsage([]byte(body))
if raw == nil {
t.Fatal("expected nested usage")
}
var us usageShape
_ = json.Unmarshal(raw, &us)
if us.PromptTokens != 1 || us.CompletionTokens != 2 {
if us.InputTokens != 7 || us.OutputTokens != 8 {
t.Fatalf("usage mismatch: %+v", us)
}
}
func TestSSEScannerLines(t *testing.T) {
// 模拟分块写入的 SSE 流
data := "data: {\"a\":1}\n\ndata: {\"usage\":{\"input_tokens\":3}}\n\n"
parts := [][]byte{[]byte(data[:10]), []byte(data[10:20]), []byte(data[20:])}
reader := newChunkReader(parts)
s := newSSEScanner(reader)
var lines [][]byte
for {
line, err := s.Next()
if line != nil {
lines = append(lines, line)
func TestUsageSinkMergesFields(t *testing.T) {
// message_start 给 input，message_delta 给 output，合并后两者都在
s := &usageSink{}
s.push(json.RawMessage(`{"input_tokens":14,"output_tokens":0}`))
s.push(json.RawMessage(`{"output_tokens":10}`))
got := s.Shape()
if got.InputTokens != 14 || got.OutputTokens != 10 {
t.Fatalf("merge mismatch: %+v", got)
}
if err != nil {
break
}
}
if len(lines) != 4 {
t.Fatalf("expected 4 lines, got %d", len(lines))
}
// 合并后应能还原原始数据
joined := ""
for _, l := range lines {
joined += string(l)
}
if joined != string(data) {
t.Fatalf("stream corrupted:\n got: %q\nwant: %q", joined, data)
// chat 末块同时携带两字段
s2 := &usageSink{}
s2.push(json.RawMessage(`{"prompt_tokens":12,"completion_tokens":9}`))
g := s2.Shape()
if g.PromptTokens != 12 || g.CompletionTokens != 9 {
t.Fatalf("chat usage mismatch: %+v", g)
}
}
type chunkReader struct {
parts [][]byte
idx int
}
func newChunkReader(parts [][]byte) *chunkReader { return &chunkReader{parts: parts} }
func (r *chunkReader) Read(p []byte) (int, error) {
if r.idx >= len(r.parts) {
return 0, io.EOF
}
n := copy(p, r.parts[r.idx])
r.idx++
return n, nil
}
server/internal/store/db.go
+22
View File
@@ -2,6 +2,9 @@ package store
import (
"log"
"os"
"path/filepath"
"strings"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
@@ -16,6 +19,10 @@ func Open(driver, dsn string) (*gorm.DB, error) {
case "postgres":
dialector = postgresDialector(dsn)
default:
// 确保 SQLite 文件所在目录存在
if dir := sqliteDir(dsn); dir != "" {
_ = os.MkdirAll(dir, 0o755)
}
dialector = sqlite.Open(dsn)
}
@@ -32,3 +39,18 @@ func Open(driver, dsn string) (*gorm.DB, error) {
log.Printf("store: connected driver=%s (migrated)", driver)
return db, nil
}
// sqliteDir 提取 SQLite DSN 中的目录部分（忽略 file: 前缀与查询参数）。
func sqliteDir(dsn string) string {
d := dsn
if i := strings.IndexByte(d, '?'); i >= 0 {
d = d[:i]
}
if strings.HasPrefix(d, "file:") {
d = d[len("file:"):]
}
if d == "" || d == ":memory:" || strings.Contains(d, "::") {
return ""
}
return filepath.Dir(d)
}
server/internal/store/models.go
+12 -14
View File
@@ -1,10 +1,8 @@
// Package store 数据模型与仓储层（GORM）。
// 字段设计对应 PLANNING.md §5：金额/价格 numeric(20,8)，token bigint，时间 UTC。
// 字段设计对应 PLANNING.md §6：金额/价格 numeric(20,8)，token bigint，时间 UTC。
package store
import (
"time"
)
import "time"
// 角色 / 状态枚举（字符串存库，便于阅读与迁移）
const (
@@ -40,7 +38,7 @@ const (
RechargeMethodOnline = "online"
)
// User 用户（PLANNING §5.1）
// User 用户（PLANNING §6.1）
type User struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
Username string `gorm:"uniqueIndex;size:64;not null" json:"username"`
@@ -55,7 +53,7 @@ type User struct {
UpdatedAt time.Time `json:"updated_at"`
}
// APIKey 密钥（PLANNING §5.2）：库中只存 SHA-256 哈希 + 展示前缀
// APIKey 密钥（PLANNING §6.2）：库中只存 SHA-256 哈希 + 展示前缀
type APIKey struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
UserID uint64 `gorm:"index;not null" json:"user_id"`
@@ -72,7 +70,7 @@ type APIKey struct {
UpdatedAt time.Time `json:"updated_at"`
}
// Channel 上游渠道（PLANNING §5.3）
// Channel 上游渠道（PLANNING §6.3）
type Channel struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
Name string `gorm:"uniqueIndex;size:64;not null" json:"name"`
@@ -89,7 +87,7 @@ type Channel struct {
UpdatedAt time.Time `json:"updated_at"`
}
// Model 全局模型 + 定价（PLANNING §5.4，价格按每百万 token，USD）
// Model 全局模型 + 定价（PLANNING §6.4，价格按每百万 token，USD）
type Model struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
Name string `gorm:"uniqueIndex;size:128;not null" json:"name"`
@@ -103,7 +101,7 @@ type Model struct {
UpdatedAt time.Time `json:"updated_at"`
}
// ChannelModelBinding 渠道↔模型绑定（多对多，PLANNING §5.4）
// ChannelModelBinding 渠道↔模型绑定（多对多，PLANNING §6.4）
type ChannelModelBinding struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
ChannelID uint64 `gorm:"index:idx_ch_model,unique;not null" json:"channel_id"`
@@ -114,7 +112,7 @@ type ChannelModelBinding struct {
Model Model `gorm:"foreignKey:ModelID" json:"-"`
}
// UsageLog 请求级用量明细（PLANNING §5.5）
// UsageLog 请求级用量明细（PLANNING §6.5）
type UsageLog struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
RequestID string `gorm:"size:128" json:"request_id"` // 上游 request id
@@ -139,7 +137,7 @@ type UsageLog struct {
CreatedAt time.Time `gorm:"index" json:"created_at"`
}
// UsageDaily 日粒度预聚合（PLANNING §5.6）
// UsageDaily 日粒度预聚合（PLANNING §6.6）
type UsageDaily struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
UserID uint64 `gorm:"index:idx_daily_user_model,unique" json:"user_id"`
@@ -152,7 +150,7 @@ type UsageDaily struct {
Cost float64 `gorm:"type:numeric(20,8)" json:"cost"`
}
// RechargeOrder 充值订单（PLANNING §5.7，预留：首版不做充值）
// RechargeOrder 充值订单（PLANNING §6.7，预留：首版不做充值）
type RechargeOrder struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
UserID uint64 `gorm:"index;not null" json:"user_id"`
@@ -167,7 +165,7 @@ type RechargeOrder struct {
UpdatedAt time.Time `json:"updated_at"`
}
// BalanceLog 余额流水（PLANNING §5.8，幂等：ref_id + type 唯一）
// BalanceLog 余额流水（PLANNING §6.8，幂等：ref_id + type 唯一）
type BalanceLog struct {
ID uint64 `gorm:"primaryKey;autoIncrement" json:"id"`
UserID uint64 `gorm:"index:idx_balance_user;not null" json:"user_id"`
@@ -179,7 +177,7 @@ type BalanceLog struct {
CreatedAt time.Time `json:"created_at"`
}
// SystemConfig 系统配置（PLANNING §5.9）
// SystemConfig 系统配置（PLANNING §6.9）
type SystemConfig struct {
Key string `gorm:"primaryKey;size:64" json:"key"`
Value string `gorm:"type:jsonb;not null" json:"value"`
server/internal/usage/usage.go
+14 -6
View File
@@ -1,4 +1,5 @@
// Package usage 异步记账：请求完成后写入 usage_logs，批量落库（PLANNING §3.2）。
// 每个请求在 flush 时同步完成：写明细 + 扣余额 + 写流水 + 日聚合。
package usage
import (
@@ -11,6 +12,7 @@ import (
"gorm.io/gorm/clause"
)
// Recorder 异步记账器：缓冲队列 + 批量事务落库。
type Recorder struct {
db *gorm.DB
ch chan *store.UsageLog
@@ -36,7 +38,6 @@ func (r *Recorder) Record(l *store.UsageLog) {
select {
case r.ch <- l:
default:
// 队列积压：直接同步写，避免丢账
if err := r.flush([]*store.UsageLog{l}); err != nil {
log.Printf("usage: sync write failed: %v", err)
}
@@ -99,13 +100,15 @@ func (r *Recorder) flush(logs []*store.UsageLog) error {
if l.Status != store.UsageStatusSuccess || l.Cost <= 0 {
continue
}
// 扣余额（余额可为负，流式请求不中断；后续请求被拒）
// 扣余额（余额可为负：流式请求不中断；后续请求被拒）
var user store.User
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&user, l.UserID).Error; err != nil {
continue
}
newBalance := user.Balance - l.Cost
tx.Model(&store.User{}).Where("id = ?", l.UserID).Update("balance", newBalance)
if err := tx.Model(&store.User{}).Where("id = ?", l.UserID).Update("balance", newBalance).Error; err != nil {
continue
}
tx.Create(&store.BalanceLog{
UserID: l.UserID,
Change: -l.Cost,
@@ -127,9 +130,14 @@ func (r *Recorder) flush(logs []*store.UsageLog) error {
"cost": gorm.Expr("cost + ?", l.Cost),
}),
}).Create(&store.UsageDaily{
UserID: l.UserID, ModelID: l.ModelID, Date: date,
Requests: 1, InputTokens: l.InputTokens, OutputTokens: l.OutputTokens,
CacheReadTokens: l.CacheReadTokens, Cost: l.Cost,
UserID: l.UserID,
ModelID: l.ModelID,
Date: date,
Requests: 1,
InputTokens: l.InputTokens,
OutputTokens: l.OutputTokens,
CacheReadTokens: l.CacheReadTokens,
Cost: l.Cost,
})
}
return nil
web/.gitignore
-24
View File
@@ -1,24 +0,0 @@
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
lerna-debug.log*
node_modules
dist
dist-ssr
*.local
# Editor directories and files
.vscode/*
!.vscode/extensions.json
.idea
.DS_Store
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?
web/README.md
-5
View File
@@ -1,5 +0,0 @@
# Vue 3 + TypeScript + Vite
This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).
web/index.html
+3 -4
View File
@@ -1,12 +1,11 @@
<!doctype html>
<html lang="zh-CN">
<html lang="zh-CN" class="dark">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
<link rel="icon" href="/favicon.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta name="theme-color" content="#0c0d0f" />
<meta name="color-scheme" content="dark" />
<title>openteam · LLM 中转网关</title>
<title>openteam · LLM API 中转站</title>
</head>
<body>
<div id="app"></div>
web/package.json
+16 -19
View File
@@ -1,7 +1,7 @@
{
"name": "web",
"name": "openteam-web",
"private": true,
"version": "0.0.0",
"version": "0.1.0",
"type": "module",
"scripts": {
"dev": "vite",
@@ -9,24 +9,21 @@
"preview": "vite preview"
},
"dependencies": {
"@fontsource/jetbrains-mono": "^5.3.0",
"@fontsource/outfit": "^5.3.0",
"axios": "^1.19.0",
"echarts": "^6.1.0",
"pinia": "^4.0.3",
"vue": "^3.5.40",
"vue-echarts": "^8.1.0",
"vue-router": "^4.6.4"
"@fontsource-variable/geist": "^5.2.5",
"@fontsource-variable/geist-mono": "^5.2.5",
"@phosphor-icons/vue": "^2.2.1",
"axios": "^1.7.9",
"pinia": "^2.3.1",
"vue": "^3.5.13",
"vue-router": "^4.5.0"
},
"devDependencies": {
"@tailwindcss/vite": "^4.3.3",
"@types/node": "^24.13.3",
"@vitejs/plugin-vue": "^6.0.8",
"@vue/tsconfig": "^0.9.1",
"playwright": "^1.62.1",
"tailwindcss": "^4.3.3",
"typescript": "~6.0.2",
"vite": "^8.2.0",
"vue-tsc": "^3.3.8"
"@tailwindcss/vite": "^4.0.0",
"@types/node": "^22.10.0",
"@vitejs/plugin-vue": "^5.2.1",
"tailwindcss": "^4.0.0",
"typescript": "~5.6.2",
"vite": "^6.0.0",
"vue-tsc": "^2.1.10"
}
}
web/pnpm-lock.yaml
Generated
+625 -435
View File
File diff suppressed because it is too large Load Diff
web/public/favicon.svg
+4 -1
View File
@@ -1 +1,4 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="7" fill="#E5A13C"/><path d="M6 16h6l4-10 6 20 4-10h0" fill="none" stroke="#0C0D0F" stroke-width="3.2" stroke-linecap="round" stroke-linejoin="round"/></svg>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
<rect width="32" height="32" rx="7" fill="#0a0a0b"/>
<path d="M8 11h16M8 16h16M8 21h10" stroke="#34d399" stroke-width="2.4" stroke-linecap="round"/>
</svg>
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 250 B

After

Width:  |  Height:  |  Size: 221 B

web/public/icons.svg
-24
View File
@@ -1,24 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg">
<symbol id="bluesky-icon" viewBox="0 0 16 17">
<g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
<defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
</symbol>
<symbol id="discord-icon" viewBox="0 0 20 19">
<path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
</symbol>
<symbol id="documentation-icon" viewBox="0 0 21 20">
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
</symbol>
<symbol id="github-icon" viewBox="0 0 19 19">
<path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
</symbol>
<symbol id="social-icon" viewBox="0 0 20 20">
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
<path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
</symbol>
<symbol id="x-icon" viewBox="0 0 19 19">
<path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
</symbol>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 4.9 KiB

web/scripts/api_probe.cjs
-32
View File
@@ -1,32 +0,0 @@
const { chromium } = require('playwright')
async function main() {
const browser = await chromium.launch()
const page = await browser.newPage()
const uname = 'probe' + Date.now().toString().slice(-6)
await page.goto('http://localhost:5173/register', { waitUntil: 'networkidle' })
await page.fill('input[autocomplete="username"]', uname)
await page.fill('input[autocomplete="email"]', uname + '@test.com')
await page.fill('input[autocomplete="new-password"]', 'password123')
await page.locator('input[autocomplete="new-password"]').nth(1).fill('password123')
await page.click('button[type="submit"]')
await page.waitForURL('**/console/dashboard', { timeout: 10000 })
await page.waitForTimeout(500)
const results = await page.evaluate(async () => {
const out = {}
for (const [name, url] of Object.entries({
balance: '/api/v1/user/balance',
stats: '/api/v1/usage/stats?group=day',
logs: '/api/v1/usage/logs?page_size=8',
})) {
try {
const r = await fetch(url, { headers: { Authorization: 'Bearer ' + localStorage.getItem('ot_access') } })
const j = await r.json()
out[name] = { status: r.status, body: JSON.stringify(j).slice(0, 220) }
} catch (e) { out[name] = { err: String(e) } }
}
return out
})
console.log(JSON.stringify(results, null, 1))
await browser.close()
}
main().catch(e => { console.error(e); process.exit(1) })
web/scripts/debug.cjs
-29
View File
@@ -1,29 +0,0 @@
// 定位 pageerror 来源
const { chromium } = require('playwright')
async function main() {
const browser = await chromium.launch()
const page = await browser.newPage({ viewport: { width: 1440, height: 900 } })
page.on('console', (m) => { if (m.type() === 'error') console.log('CONSOLE ERR @', page.url(), '→', m.text().slice(0, 200)) })
page.on('pageerror', (e) => console.log('PAGE ERR @', page.url(), '→', e.stack?.split('\n').slice(0, 3).join(' | ')))
const uname = 'dbg' + Date.now().toString().slice(-6)
await page.goto('http://localhost:5173/register', { waitUntil: 'networkidle' })
await page.fill('input[autocomplete="username"]', uname)
await page.fill('input[autocomplete="email"]', uname + '@test.com')
await page.fill('input[autocomplete="new-password"]', 'password123')
await page.locator('input[autocomplete="new-password"]').nth(1).fill('password123')
await page.click('button[type="submit"]')
await page.waitForURL('**/console/dashboard', { timeout: 10000 })
await page.waitForTimeout(2500)
console.log('URL now:', page.url())
// 检查页面内容
const cards = await page.locator('.mt-6.grid .rounded-lg').count()
const chart = await page.locator('canvas').count()
const empty = await page.locator('text=暂无数据').count()
console.log('cards:', cards, 'canvas:', chart, 'emptyState:', empty)
const bodyText = (await page.locator('body').innerText()).slice(0, 300)
console.log('body:', bodyText.replace(/\n+/g, ' | '))
await browser.close()
}
main().catch((e) => { console.error(e); process.exit(1) })
web/scripts/shot.cjs
-52
View File
@@ -1,52 +0,0 @@
// 前端截图验证脚本：登录 → 仪表盘 → 密钥页
const { chromium } = require('playwright')
async function main() {
const browser = await chromium.launch()
const page = await browser.newPage({ viewport: { width: 1440, height: 900 } })
const shots = process.argv[2] || '/tmp/shots'
const fs = require('fs')
fs.mkdirSync(shots, { recursive: true })
// 1. Landing
await page.goto('http://localhost:5173/', { waitUntil: 'networkidle' })
await page.screenshot({ path: `${shots}/01-landing.png` })
// 2. 注册
await page.goto('http://localhost:5173/register', { waitUntil: 'networkidle' })
const uname = 'dave' + Date.now().toString().slice(-6)
await page.fill('input[autocomplete="username"]', uname)
await page.fill('input[autocomplete="email"]', uname + '@test.com')
await page.fill('input[autocomplete="new-password"]', 'password123')
await page.locator('input[autocomplete="new-password"]').nth(1).fill('password123')
await page.screenshot({ path: `${shots}/02-register.png` })
await page.click('button[type="submit"]')
await page.waitForURL('**/console/dashboard', { timeout: 10000 })
await page.waitForTimeout(1200)
// 3. 跳过登录（注册后已自动登录）—— 直接看仪表盘
await page.goto('http://localhost:5173/console/dashboard', { waitUntil: 'networkidle' })
await page.waitForTimeout(1500)
await page.screenshot({ path: `${shots}/03-dashboard.png` })
// 4. 密钥页
await page.goto('http://localhost:5173/console/keys', { waitUntil: 'networkidle' })
await page.screenshot({ path: `${shots}/04-keys.png` })
await page.click('text=新建密钥')
await page.waitForTimeout(400)
await page.fill('input[placeholder*="本地开发"]', 'playwright-test')
await page.screenshot({ path: `${shots}/05-key-modal.png` })
await page.click('button:has-text("创建")')
await page.waitForTimeout(600)
await page.screenshot({ path: `${shots}/06-key-created.png` })
// 5. 用量页
await page.goto('http://localhost:5173/console/usage', { waitUntil: 'networkidle' })
await page.waitForTimeout(800)
await page.screenshot({ path: `${shots}/07-usage.png` })
await browser.close()
console.log('done')
}
main().catch((e) => { console.error(e); process.exit(1) })
web/scripts/verify.cjs
-80
View File
@@ -1,80 +0,0 @@
// 前端渲染断言：检查关键元素与 console 错误
const { chromium } = require('playwright')
async function main() {
const browser = await chromium.launch()
const page = await browser.newPage({ viewport: { width: 1440, height: 900 } })
const errors = []
page.on('console', (m) => { if (m.type() === 'error') errors.push(page.url() + ' :: ' + m.text()) })
page.on('pageerror', (e) => errors.push('pageerror: ' + e.message))
async function check(name, url, selectors) {
await page.goto(url, { waitUntil: 'networkidle' })
await page.waitForTimeout(800)
const results = []
for (const [label, sel] of Object.entries(selectors)) {
const n = await page.locator(sel).count()
results.push(`${label}:${n}`)
}
console.log(`${name}: ${results.join(' ')}`)
}
await check('landing', 'http://localhost:5173/', {
nav: 'header nav',
hero: 'h1',
protocols: '#protocols .grid > div',
footer: 'footer',
})
await check('login', 'http://localhost:5173/login', {
username: 'input[autocomplete="username"]',
password: 'input[autocomplete="current-password"]',
submit: 'button[type="submit"]',
})
// 注册一个测试用户并进控制台
const uname = 'verify' + Date.now().toString().slice(-6)
await page.goto('http://localhost:5173/register', { waitUntil: 'networkidle' })
await page.fill('input[autocomplete="username"]', uname)
await page.fill('input[autocomplete="email"]', uname + '@test.com')
await page.fill('input[autocomplete="new-password"]', 'password123')
await page.locator('input[autocomplete="new-password"]').nth(1).fill('password123')
await page.click('button[type="submit"]')
await page.waitForURL('**/console/dashboard', { timeout: 10000 })
await page.waitForTimeout(1200)
await check('dashboard', 'http://localhost:5173/console/dashboard', {
sidebar: 'aside',
cards: '.mt-6.grid .rounded-lg',
chart: '.divide-y, canvas',
recent: '.divide-y',
navKeys: 'a[href="/console/keys"]',
balance: 'aside .text-mint-400',
})
await check('keys', 'http://localhost:5173/console/keys', {
table: 'table',
createBtn: 'button:has-text("新建密钥")',
})
await check('usage', 'http://localhost:5173/console/usage', {
table: 'table',
filter: 'select',
pagination: 'button:has-text("下一页")',
})
// 创建密钥弹窗
await page.goto('http://localhost:5173/console/keys', { waitUntil: 'networkidle' })
await page.click('button:has-text("新建密钥")')
await page.waitForTimeout(300)
await page.fill('input[placeholder*="本地开发"]', 'verify-key')
await page.click('button:has-text("创建")')
await page.waitForTimeout(600)
const created = await page.locator('code.text-mint-300').count()
console.log(`key-created-modal: oneTimeKey:${created}`)
console.log('console-errors:', errors.length ? errors.slice(0, 5) : 'none')
await browser.close()
}
main().catch((e) => { console.error(e); process.exit(1) })
web/scripts/wig-verify.cjs
-98
View File
@@ -1,98 +0,0 @@
// WIG 合规验证：语义标签 / aria / focus / modal 交互
const { chromium } = require('playwright')
async function main() {
const browser = await chromium.launch()
const page = await browser.newPage({ viewport: { width: 1440, height: 900 } })
const errors = []
page.on('pageerror', (e) => errors.push('pageerror: ' + e.message))
page.on('console', (m) => { if (m.type() === 'error') errors.push('console: ' + m.text().slice(0, 150)) })
const BASE = 'http://127.0.0.1:8088'
let pass = 0, fail = 0
const check = (name, ok) => { console.log(`${ok ? '✓' : '✗'} ${name}`); ok ? pass++ : fail++ }
// ---- Landing ----
await page.goto(BASE + '/', { waitUntil: 'networkidle' })
check('landing: h1 存在', await page.locator('h1').count() === 1)
check('landing: main 语义标签', await page.locator('main#landing-main').count() === 1)
check('landing: 导航用 router-link(<a>)', await page.locator('header nav a').count() >= 2)
check('landing: theme-color', await page.locator('meta[name="theme-color"]').count() === 1)
// ---- 注册（带字段级校验）----
const uname = 'wig' + Date.now().toString().slice(-6)
await page.goto(BASE + '/register', { waitUntil: 'networkidle' })
// 空提交 → 字段级错误
await page.click('button[type="submit"]')
await page.waitForTimeout(300)
check('register: 字段级错误显示', await page.locator('[role="alert"]').count() >= 1)
// 填错邮箱
await page.fill('input[name="username"]', uname)
await page.fill('input[name="email"]', 'not-an-email')
await page.fill('input[name="password"]', 'password123')
await page.fill('input[name="confirm"]', 'password123')
await page.click('button[type="submit"]')
await page.waitForTimeout(300)
check('register: 邮箱格式错误', await page.locator('text=邮箱格式不正确').count() === 1)
// 修正并提交
await page.fill('input[name="email"]', uname + '@test.com')
await page.click('button[type="submit"]')
await page.waitForURL('**/console/dashboard', { timeout: 10000 })
await page.waitForTimeout(1500)
// ---- Console ----
check('console: skip link', await page.locator('a[href="#main-content"]').count() === 1)
check('console: main 语义标签', await page.locator('main#main-content').count() === 1)
check('console: aside aria-label', await page.locator('aside[aria-label]').count() === 1)
check('console: 侧边栏卡片', await page.locator('section[aria-label="用量指标"] .rounded-lg').count() === 4)
check('console: 骨架屏已消失(loaded)', await page.locator('.animate-pulse').count() === 0)
// ---- Keys ----
await page.goto(BASE + '/console/keys', { waitUntil: 'networkidle' })
await page.waitForTimeout(500)
check('keys: 表格 caption', await page.locator('table caption.sr-only').count() === 1)
check('keys: 吊销按钮', await page.locator('button:has-text("吊销")').count() >= 0)
// 创建密钥 modal：Escape 关闭
await page.click('button:has-text("新建密钥")')
await page.waitForTimeout(300)
check('modal: dialog 打开', await page.locator('[role="dialog"]').count() === 1)
await page.keyboard.press('Escape')
await page.waitForTimeout(300)
check('modal: Escape 关闭', await page.locator('[role="dialog"]').count() === 0)
// 重新打开并创建
await page.click('button:has-text("新建密钥")')
await page.waitForTimeout(300)
await page.fill('input[name="key-name"]', 'wig-test')
await page.click('button:has-text("创建密钥")')
await page.waitForTimeout(600)
check('modal: 一次性明文展示', await page.locator('code.text-mint-300').count() === 1)
check('modal: 复制按钮 + toast', (await page.click('button:has-text("复制")'), true))
await page.waitForTimeout(300)
check('toast: aria-live 容器', await page.locator('[aria-live="polite"]').count() >= 1)
await page.click('button:has-text("完成")')
// ---- Usage ----
await page.goto(BASE + '/console/usage?model=gpt-4o-mini', { waitUntil: 'networkidle' })
await page.waitForTimeout(800)
check('usage: select 有 label', await page.locator('label:has(select)').count() === 1)
check('usage: URL 反映筛选状态', page.url().includes('model='))
check('usage: 分页 aria 标签', await page.locator('nav[aria-label="分页"]').count() === 1)
// ---- Tab 焦点可见性 ----
await page.goto(BASE + '/console/dashboard', { waitUntil: 'networkidle' })
await page.keyboard.press('Tab')
await page.waitForTimeout(200)
const focusedRing = await page.evaluate(() => {
const el = document.activeElement
if (!el) return 'none'
const s = getComputedStyle(el)
return s.outlineStyle === 'auto' || s.outlineWidth !== '0px' ? 'outline' : (s.boxShadow !== 'none' ? 'ring' : 'none')
})
check(`focus: Tab 首元素可见焦点 (${focusedRing})`, focusedRing !== 'none')
console.log(`\n结果: ${pass} 通过, ${fail} 失败`)
if (errors.length) console.log('控制台错误:', errors.slice(0, 5))
await browser.close()
process.exit(fail > 0 ? 1 : 0)
}
main().catch((e) => { console.error(e); process.exit(1) })
web/src/App.vue
+4 -8
View File
@@ -1,17 +1,13 @@
<script setup lang="ts">
import { useAuthStore } from './stores/auth'
import { onMounted } from 'vue'
import { useRouter } from 'vue-router'
import { useAuthStore } from '@/stores/auth'
import ToastHost from '@/components/ui/ToastHost.vue'
const auth = useAuthStore()
const router = useRouter()
onMounted(() => {
// 初始化时若已有 token 则拉取用户信息
if (auth.token && !auth.user) auth.fetchMe()
void router
})
onMounted(() => auth.bootstrap())
</script>
<template>
<router-view />
<ToastHost />
</template>
web/src/api/client.ts
+30 -46
View File
@@ -1,60 +1,44 @@
// API 客户端：统一 baseURL、token 注入、401 刷新兜底。
import axios from 'axios'
import { useAuthStore } from '@/stores/auth'
// 代理端点（/v1/*，Bearer API Key）与管理 API（/api/v1）baseURL 不同，分开实例
const proxyClient = axios.create({ baseURL: '/v1', timeout: 30000 })
const client = axios.create({
export const http = axios.create({
baseURL: '/api/v1',
timeout: 20000,
withCredentials: true, // refresh cookie
timeout: 15000,
withCredentials: true,
})
export { proxyClient }
client.interceptors.request.use((config) => {
const token = localStorage.getItem('ot_access')
if (token) config.headers.Authorization = `Bearer ${token}`
http.interceptors.request.use((config) => {
const auth = useAuthStore()
if (auth.accessToken) {
config.headers.Authorization = `Bearer ${auth.accessToken}`
}
return config
})
let refreshing: Promise<string | null> | null = null
client.interceptors.response.use(
(res) => res,
async (err) => {
const original = err.config
// 401 且非刷新请求本身：尝试刷新一次
if (err.response?.status === 401 && !original?._retried && !original?.url?.includes('/auth/')) {
original._retried = true
refreshing = refreshing ?? refreshAccess()
const token = await refreshing
refreshing = null
if (token) {
localStorage.setItem('ot_access', token)
original.headers.Authorization = `Bearer ${token}`
return client(original)
http.interceptors.response.use(
(resp) => resp,
async (error) => {
if (error.response?.status === 401) {
const auth = useAuthStore()
// 尝试用 refresh cookie 换新 token 后再试一次
if (auth.accessToken && !error.config?._retried) {
error.config._retried = true
try {
await auth.refresh()
return http.request(error.config)
} catch {
auth.clear()
}
} else {
auth.clear()
}
}
return Promise.reject(err)
return Promise.reject(error)
},
)
async function refreshAccess(): Promise<string | null> {
try {
const { data } = await client.post('/auth/refresh')
return data.data?.access_token ?? null
} catch {
return null
}
// 统一取后端错误信息
export function errMsg(err: unknown): string {
const e = err as { response?: { data?: { error?: { message?: string } } } }
return e?.response?.data?.error?.message ?? '请求失败，请稍后重试'
}
// 响应壳：{ data: {...} } 或 { error: {...} }
export function unwrap<T>(p: Promise<{ data: { data?: T; error?: { message?: string } } }>): Promise<T> {
return p.then((res) => {
if (res.data.error) throw new Error(res.data.error.message || 'request failed')
return res.data.data as T
})
}
export default client
web/src/assets/hero.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 13 KiB

web/src/assets/vite.svg
-1
View File
File diff suppressed because one or more lines are too long
Side by Side

Before

Width:  |  Height:  |  Size: 8.5 KiB

web/src/components/layout/ShellLayout.vue
+97
View File
@@ -0,0 +1,97 @@
<script setup lang="ts">
import { computed, ref } from 'vue'
import { useRouter } from 'vue-router'
import { PhList } from '@phosphor-icons/vue'
import { useAuthStore } from '@/stores/auth'
import { fmtMoney } from '@/lib/format'
interface NavItem {
to: string
label: string
}
defineProps<{ sections: { title: string; items: NavItem[] }[] }>()
const auth = useAuthStore()
const router = useRouter()
const balance = computed(() => fmtMoney(auth.user?.balance ?? 0))
const sidebarOpen = ref(false)
function navTo() {
sidebarOpen.value = false
}
async function logout() {
await auth.logout()
router.push('/')
}
</script>
<template>
<div class="flex min-h-[100dvh] bg-zinc-950">
<!-- 移动端遮罩 -->
<div
v-if="sidebarOpen"
class="fixed inset-0 z-30 bg-black/60 md:hidden"
@click="sidebarOpen = false"
/>
<!-- 侧边栏 -->
<aside
class="fixed inset-y-0 left-0 z-40 flex w-56 transform flex-col border-r border-zinc-800/80 bg-zinc-950 transition-transform duration-200 md:translate-x-0"
:class="sidebarOpen ? 'translate-x-0' : '-translate-x-full'"
>
<div class="flex h-14 items-center gap-2 border-b border-zinc-800/80 px-4">
<img src="/favicon.svg" alt="" class="size-5" />
<span class="text-sm font-semibold tracking-tight">openteam</span>
</div>
<nav class="flex-1 overflow-y-auto px-3 py-4">
<template v-for="sec in sections" :key="sec.title">
<p class="mt-4 mb-1.5 px-2 text-[10px] font-medium tracking-[0.14em] text-zinc-600 uppercase first:mt-0">
{{ sec.title }}
</p>
<router-link
v-for="n in sec.items"
:key="n.to"
:to="n.to"
class="mb-0.5 flex items-center rounded-md px-2 py-1.5 text-sm text-zinc-400 transition hover:bg-zinc-800/50 hover:text-zinc-100"
active-class="bg-zinc-800/70 text-zinc-50"
@click="navTo"
>
{{ n.label }}
</router-link>
</template>
</nav>
</aside>
<div class="flex min-h-[100dvh] flex-1 flex-col md:ml-56">
<header class="flex h-14 items-center justify-between border-b border-zinc-800/80 px-4 md:px-6">
<div class="flex items-center gap-2">
<button
class="rounded-md p-1.5 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100 md:hidden"
aria-label="打开菜单"
@click="sidebarOpen = true"
>
<PhList :size="20" />
</button>
<span class="font-mono text-xs text-zinc-600">{{ auth.user?.username }}</span>
</div>
<div class="flex items-center gap-3">
<span class="mono-num rounded-md border border-zinc-800 bg-zinc-900 px-2.5 py-1 text-xs text-emerald-300">
余额 {{ balance }}
</span>
<button
class="rounded-md px-2 py-1 text-xs text-zinc-500 transition hover:bg-zinc-800 hover:text-zinc-200"
@click="logout"
>
退出
</button>
</div>
</header>
<main class="flex-1 px-4 py-6 md:px-6">
<router-view />
</main>
</div>
</div>
</template>
web/src/components/ui/Badge.vue
+24 -19
View File
@@ -1,25 +1,30 @@
<script setup lang="ts">
// 状态信号灯徽标：healthy/degraded/cooldown/active/revoked/success/error
const props = defineProps<{ tone: string; label?: string }>()
const tones: Record<string, { dot: string; text: string; bg: string }> = {
healthy: { dot: 'bg-mint-400', text: 'text-mint-300', bg: 'bg-mint-400/10' },
success: { dot: 'bg-mint-400', text: 'text-mint-300', bg: 'bg-mint-400/10' },
active: { dot: 'bg-mint-400', text: 'text-mint-300', bg: 'bg-mint-400/10' },
degraded: { dot: 'bg-signal-400', text: 'text-signal-300', bg: 'bg-signal-400/10' },
cooldown: { dot: 'bg-signal-400', text: 'text-signal-300', bg: 'bg-signal-400/10' },
error: { dot: 'bg-ember-400', text: 'text-ember-300', bg: 'bg-ember-400/10' },
revoked: { dot: 'bg-ember-400', text: 'text-ember-300', bg: 'bg-ember-400/10' },
disabled: { dot: 'bg-paper-600', text: 'text-paper-500', bg: 'bg-paper-600/10' },
pending: { dot: 'bg-sky-400', text: 'text-sky-300', bg: 'bg-sky-400/10' },
}
const t = tones[props.tone] ?? tones.disabled
withDefaults(defineProps<{ variant?: 'neutral' | 'ok' | 'warn' | 'err' | 'accent' }>(), {
variant: 'neutral',
})
</script>
<template>
<span class="inline-flex items-center gap-1.5 rounded-md px-2 py-0.5 text-xs font-medium" :class="[t.bg, t.text]">
<span class="h-1.5 w-1.5 rounded-full" :class="t.dot" />
{{ label ?? tone }}
<span
class="inline-flex items-center gap-1.5 rounded-full px-2 py-0.5 font-mono text-[11px] leading-5"
:class="{
neutral: 'bg-zinc-800/80 text-zinc-300',
ok: 'bg-ok/15 text-emerald-300',
warn: 'bg-warn/15 text-amber-300',
err: 'bg-err/15 text-red-300',
accent: 'bg-accent/15 text-emerald-300',
}[variant]"
>
<span
v-if="variant !== 'neutral'"
class="size-1.5 rounded-full"
:class="{
ok: 'bg-ok',
warn: 'bg-warn',
err: 'bg-err',
accent: 'bg-accent',
}[variant]"
/>
<slot />
</span>
</template>
web/src/components/ui/Button.vue
+8 -23
View File
@@ -1,42 +1,27 @@
<script setup lang="ts">
withDefaults(
defineProps<{
variant?: 'primary' | 'ghost' | 'danger' | 'outline'
variant?: 'primary' | 'ghost' | 'danger'
size?: 'sm' | 'md'
type?: 'button' | 'submit'
loading?: boolean
disabled?: boolean
ariaLabel?: string
}>(),
{ variant: 'primary', size: 'md', type: 'button', loading: false, disabled: false },
{ variant: 'primary', size: 'md', loading: false, disabled: false },
)
defineEmits<{ (e: 'click', ev: MouseEvent): void }>()
</script>
<template>
<button
:type="type"
:disabled="disabled || loading"
:aria-label="ariaLabel"
:aria-busy="loading || undefined"
class="inline-flex touch-manipulation items-center justify-center gap-2 font-medium select-none
transition-[background-color,border-color,color,transform,opacity] duration-150
active:scale-[0.98] disabled:opacity-50 disabled:pointer-events-none cursor-pointer"
class="inline-flex items-center justify-center gap-2 rounded-md font-medium transition-[transform,background-color,border-color,color] duration-150 active:scale-[0.98] disabled:pointer-events-none disabled:opacity-50 select-none"
:class="[
size === 'sm' ? 'h-8 px-3 text-[13px] rounded-md' : 'h-10 px-4 text-sm rounded-md',
variant === 'primary' && 'bg-signal-400 text-ink-950 hover:bg-signal-300',
variant === 'outline' && 'border border-ink-600 text-paper-300 hover:border-signal-400 hover:text-signal-300 bg-transparent',
variant === 'ghost' && 'text-paper-500 hover:text-paper-100 hover:bg-ink-800',
variant === 'danger' && 'bg-ember-500/90 text-white hover:bg-ember-400',
size === 'sm' ? 'h-8 px-3 text-xs' : 'h-10 px-4 text-sm',
variant === 'primary' && 'bg-accent text-zinc-950 hover:bg-accent-strong',
variant === 'ghost' && 'border border-zinc-700 text-zinc-200 hover:border-zinc-500 hover:bg-zinc-800/60',
variant === 'danger' && 'border border-err/50 text-red-300 hover:border-err hover:bg-err/10',
]"
@click="$emit('click', $event)"
>
<span
v-if="loading"
class="h-3.5 w-3.5 animate-spin rounded-full border-2 border-current border-t-transparent"
aria-hidden="true"
/>
<span v-if="loading" class="size-3.5 animate-spin rounded-full border-2 border-current border-t-transparent" />
<slot />
</button>
</template>
web/src/components/ui/Input.vue
+18 -63
View File
@@ -1,79 +1,34 @@
<script setup lang="ts">
import { computed, ref, useId } from 'vue'
type InputMode = 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search'
type Props = {
withDefaults(
defineProps<{
label?: string
modelValue?: string | number
type?: string
placeholder?: string
modelValue?: string
error?: string
hint?: string
mono?: boolean
error?: string
autocomplete?: string
name?: string
inputmode?: InputMode
spellcheck?: boolean
required?: boolean
autofocus?: boolean
}
const props = withDefaults(defineProps<Props>(), {
type: 'text',
placeholder: '',
modelValue: '',
spellcheck: false,
})
defineEmits<{ (e: 'update:modelValue', v: string): void }>()
const uid = useId()
const inputId = `input-${uid}`
const descId = computed(() => (props.error || props.hint ? `desc-${uid}` : undefined))
const inputEl = ref<HTMLInputElement | null>(null)
// 暴露 focus 供父组件定位错误
function focus() {
inputEl.value?.focus()
}
defineExpose({ focus })
disabled?: boolean
}>(),
{ type: 'text', modelValue: '', disabled: false },
)
const emit = defineEmits<{ 'update:modelValue': [string | number] }>()
</script>
<template>
<div>
<label v-if="label" :for="inputId" class="mb-1.5 block text-[13px] font-medium text-paper-300">
{{ label }}<span v-if="required" class="ml-0.5 text-ember-400" aria-hidden="true">*</span>
</label>
<label class="block">
<span v-if="label" class="mb-1.5 block text-xs font-medium text-zinc-400">{{ label }}</span>
<input
ref="inputEl"
:id="inputId"
:type="type"
:name="name"
:value="modelValue"
:placeholder="placeholder"
:autocomplete="autocomplete"
:inputmode="inputmode"
:spellcheck="spellcheck"
:required="required"
:autofocus="autofocus"
:aria-invalid="error ? 'true' : undefined"
:aria-describedby="descId"
@input="$emit('update:modelValue', ($event.target as HTMLInputElement).value)"
class="h-10 w-full rounded-md border bg-ink-900 px-3 text-sm text-paper-100 transition-[border-color,box-shadow] placeholder:text-paper-600
focus:outline-none focus-visible:ring-2 focus-visible:ring-signal-400/60"
:class="[
mono ? 'font-mono' : '',
error ? 'border-ember-500' : 'border-ink-600 hover:border-ink-700',
]"
:disabled="disabled"
class="h-10 w-full rounded-md border border-zinc-700 bg-zinc-900 px-3 text-sm text-zinc-100 placeholder-zinc-500 outline-none transition focus:border-accent focus:ring-2 focus:ring-accent/30 disabled:cursor-not-allowed disabled:opacity-50"
:class="error && 'border-err focus:border-err focus:ring-err/30'"
@input="emit('update:modelValue', ($event.target as HTMLInputElement).value as string | number)"
/>
<p v-if="error" :id="descId" class="mt-1 flex items-start gap-1 text-xs text-ember-400" role="alert">
<svg width="13" height="13" viewBox="0 0 16 16" fill="none" class="mt-px shrink-0" aria-hidden="true">
<circle cx="8" cy="8" r="6.5" stroke="currentColor" stroke-width="1.3" />
<path d="M8 5v3.5M8 11h.01" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" />
</svg>
{{ error }}
</p>
<p v-else-if="hint" :id="descId" class="mt-1 text-xs text-paper-600">{{ hint }}</p>
</div>
<span v-if="hint && !error" class="mt-1.5 block text-xs text-zinc-500">{{ hint }}</span>
<span v-if="error" class="mt-1.5 block text-xs text-red-400">{{ error }}</span>
</label>
</template>
web/src/components/ui/Modal.vue
+50 -65
View File
@@ -1,100 +1,85 @@
<script setup lang="ts">
import { ref, watch, onBeforeUnmount } from 'vue'
import { nextTick, onMounted, onUnmounted, ref, watch } from 'vue'
import { PhX } from '@phosphor-icons/vue'
const props = withDefaults(
defineProps<{ title: string; open: boolean; width?: string }>(),
defineProps<{
open: boolean
title?: string
width?: string
}>(),
{ width: 'max-w-md' },
)
const emit = defineEmits<{ (e: 'close'): void }>()
const emit = defineEmits<{ close: [] }>()
const dialogRef = ref<HTMLElement | null>(null)
const lastFocus = ref<HTMLElement | null>(null)
const panel = ref<HTMLElement | null>(null)
function onKeydown(e: KeyboardEvent) {
if (e.key === 'Escape') {
emit('close')
return
}
if (e.key === 'Tab' && dialogRef.value) {
// focus trap：Tab 循环
const focusables = dialogRef.value.querySelectorAll<HTMLElement>(
'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])',
)
if (!focusables.length) return
const first = focusables[0]
const last = focusables[focusables.length - 1]
if (e.shiftKey && document.activeElement === first) {
e.preventDefault()
last.focus()
} else if (!e.shiftKey && document.activeElement === last) {
e.preventDefault()
first.focus()
}
}
function onKey(e: KeyboardEvent) {
if (e.key === 'Escape' && props.open) emit('close')
}
onMounted(() => window.addEventListener('keydown', onKey))
onUnmounted(() => window.removeEventListener('keydown', onKey))
// 打开时锁背景滚动并聚焦面板，关闭时恢复
watch(
() => props.open,
(open) => {
async (open) => {
document.body.style.overflow = open ? 'hidden' : ''
if (open) {
lastFocus.value = document.activeElement as HTMLElement
document.body.style.overflow = 'hidden'
// 等 DOM 渲染后聚焦第一个可聚焦元素
requestAnimationFrame(() => {
const first = dialogRef.value?.querySelector<HTMLElement>('button, [href], input, select, textarea')
first?.focus()
})
} else {
document.body.style.overflow = ''
lastFocus.value?.focus()
lastFocus.value = null
await nextTick()
panel.value?.focus()
}
},
)
onBeforeUnmount(() => {
onUnmounted(() => {
document.body.style.overflow = ''
})
</script>
<template>
<Teleport to="body">
<Transition name="modal">
<Transition
enter-active-class="transition-opacity duration-150"
enter-from-class="opacity-0"
leave-active-class="transition-opacity duration-150"
leave-to-class="opacity-0"
>
<div
v-if="open"
class="fixed inset-0 z-50 flex items-start justify-center overflow-y-auto p-4 pt-[12vh]"
style="overscroll-behavior: contain; touch-action: manipulation"
@keydown="onKeydown"
class="fixed inset-0 z-50 flex items-start justify-center overflow-y-auto bg-black/60 p-4 pt-[12vh] backdrop-blur-sm"
@mousedown.self="emit('close')"
>
<Transition
enter-active-class="transition-transform duration-150"
enter-from-class="scale-[0.97] opacity-0"
leave-active-class="transition-transform duration-150"
leave-to-class="scale-[0.97] opacity-0"
>
<div class="fixed inset-0 bg-black/60 backdrop-blur-[2px]" aria-hidden="true" @click="emit('close')" />
<div
ref="dialogRef"
class="relative w-full rounded-lg border border-ink-700 bg-ink-900 shadow-2xl"
:class="width"
v-if="open"
ref="panel"
role="dialog"
aria-modal="true"
:aria-labelledby="`modal-title-${title}`"
:aria-label="title || '对话框'"
tabindex="-1"
class="card w-full shadow-xl outline-none"
:class="width"
>
<div class="flex items-center justify-between border-b border-ink-700 px-5 py-3.5">
<h3 :id="`modal-title-${title}`" class="text-sm font-semibold text-paper-100">{{ title }}</h3>
<button
class="touch-manipulation rounded-md p-1 text-paper-500 transition-colors hover:bg-ink-800 hover:text-paper-100 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none cursor-pointer"
@click="emit('close')"
aria-label="关闭对话框"
>
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" aria-hidden="true"><path d="M4 4l8 8M12 4l-8 8" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/></svg>
<div class="flex items-center justify-between border-b border-zinc-800 px-5 py-3.5">
<h3 class="text-sm font-semibold text-zinc-100">{{ title }}</h3>
<button class="rounded-md p-1 text-zinc-500 hover:bg-zinc-800 hover:text-zinc-200" aria-label="关闭" @click="emit('close')">
<PhX :size="16" weight="bold" />
</button>
</div>
<div class="px-5 py-4"><slot /></div>
<div class="px-5 py-4">
<slot />
</div>
<div v-if="$slots.footer" class="flex justify-end gap-2 border-t border-zinc-800 px-5 py-3.5">
<slot name="footer" />
</div>
</div>
</Transition>
</div>
</Transition>
</Teleport>
</template>
<style scoped>
.modal-enter-active, .modal-leave-active { transition: opacity 0.15s ease; }
.modal-enter-from, .modal-leave-to { opacity: 0; }
.modal-enter-active .relative, .modal-leave-active .relative { transition: transform 0.15s ease; }
.modal-enter-from .relative, .modal-leave-to .relative { transform: translateY(6px) scale(0.99); }
</style>
web/src/components/ui/Toast.vue
-48
View File
@@ -1,48 +0,0 @@
<script setup lang="ts">
import { useToastStore } from '../../stores/toast'
const toast = useToastStore()
const styles: Record<string, string> = {
success: 'border-mint-500/40 bg-mint-400/10 text-mint-300',
error: 'border-ember-500/40 bg-ember-500/10 text-ember-300',
info: 'border-sky-500/40 bg-sky-400/10 text-sky-300',
}
</script>
<template>
<div
class="pointer-events-none fixed right-4 top-4 z-[60] flex w-80 max-w-[calc(100vw-2rem)] flex-col gap-2"
aria-live="polite"
aria-atomic="false"
>
<TransitionGroup name="toast">
<div
v-for="t in toast.items"
:key="t.id"
class="pointer-events-auto flex items-start gap-2.5 rounded-md border bg-ink-900/95 px-3.5 py-2.5 text-[13px] shadow-lg backdrop-blur"
:class="styles[t.kind]"
role="status"
>
<span class="mt-px shrink-0" aria-hidden="true">
<svg v-if="t.kind === 'success'" width="14" height="14" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6.5" stroke="currentColor" stroke-width="1.3"/><path d="M5 8.2l2 2 4-4.4" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"/></svg>
<svg v-else-if="t.kind === 'error'" width="14" height="14" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6.5" stroke="currentColor" stroke-width="1.3"/><path d="M5.5 5.5l5 5M10.5 5.5l-5 5" stroke="currentColor" stroke-width="1.3" stroke-linecap="round"/></svg>
<svg v-else width="14" height="14" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6.5" stroke="currentColor" stroke-width="1.3"/><path d="M8 5v3.5M8 11h.01" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/></svg>
</span>
<span class="min-w-0 flex-1 break-words">{{ t.message }}</span>
<button
class="shrink-0 text-current opacity-60 transition-opacity hover:opacity-100 focus-visible:ring-2 focus-visible:ring-current focus:outline-none cursor-pointer"
:aria-label="`关闭通知`"
@click="toast.dismiss(t.id)"
>
<svg width="12" height="12" viewBox="0 0 16 16" fill="none" aria-hidden="true"><path d="M4 4l8 8M12 4l-8 8" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/></svg>
</button>
</div>
</TransitionGroup>
</div>
</template>
<style scoped>
.toast-enter-active, .toast-leave-active { transition: opacity 0.2s ease, transform 0.2s ease; }
.toast-enter-from, .toast-leave-to { opacity: 0; transform: translateY(-6px); }
</style>
web/src/components/ui/ToastHost.vue
+28
View File
@@ -0,0 +1,28 @@
<script setup lang="ts">
import { useToastStore } from '@/stores/toast'
const toast = useToastStore()
</script>
<template>
<div class="fixed right-4 bottom-4 z-[80] flex w-80 flex-col gap-2" aria-live="polite">
<TransitionGroup
enter-active-class="transition-all duration-200"
enter-from-class="translate-y-1 opacity-0"
leave-active-class="transition-all duration-200"
leave-to-class="translate-y-1 opacity-0"
>
<div
v-for="t in toast.items"
:key="t.id"
class="card flex items-start gap-2.5 px-4 py-3 shadow-lg"
:class="t.type === 'err' && 'border-err/40'"
>
<span
class="mt-0.5 size-1.5 shrink-0 rounded-full"
:class="t.type === 'err' ? 'bg-err' : t.type === 'ok' ? 'bg-ok' : 'bg-zinc-500'"
/>
<p class="text-sm text-zinc-200">{{ t.msg }}</p>
</div>
</TransitionGroup>
</div>
</template>
web/src/components/ui/TrendChart.vue
+57
View File
@@ -0,0 +1,57 @@
<script setup lang="ts">
import { computed } from 'vue'
const props = withDefaults(
defineProps<{
points: { label: string; value: number }[]
height?: number
format?: (v: number) => string
}>(),
{ height: 160, format: (v: number) => String(v) },
)
const chart = computed(() => {
const max = Math.max(...props.points.map((p) => p.value), 1)
const bw = 100 / props.points.length
const bars = props.points.map((p, i) => ({
x: i * bw,
w: Math.max(bw * 0.5, 2),
h: (p.value / max) * 100,
label: p.label,
value: props.format(p.value),
}))
return { bars, maxLabel: props.format(max) }
})
</script>
<template>
<div class="w-full">
<div class="mb-1 flex items-baseline justify-between">
<span class="mono-num text-xs text-zinc-500">max {{ chart.maxLabel }}</span>
</div>
<svg
:viewBox="`0 0 100 ${height}`"
:height="height"
class="w-full"
preserveAspectRatio="none"
role="img"
:aria-label="`用量趋势，共 ${points.length} 天`"
>
<!-- 基线 -->
<line x1="0" :y1="height - 18" x2="100" :y2="height - 18" stroke="rgb(39 39 42)" stroke-width="0.6" />
<g v-for="b in chart.bars" :key="b.label">
<rect
:x="b.x"
:y="height - 18 - b.h"
:width="b.w"
:height="b.h"
rx="0.8"
class="fill-accent/80 hover:fill-accent"
/>
</g>
</svg>
<div class="mt-1 flex justify-between font-mono text-[10px] text-zinc-600">
<span v-for="b in chart.bars" :key="'l-' + b.label" class="truncate">{{ b.label }}</span>
</div>
</div>
</template>
web/src/lib/format.ts
+20
View File
@@ -0,0 +1,20 @@
export function fmtMoney(v: number): string {
return '$' + v.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 6 })
}
export function fmtNum(v: number): string {
return v.toLocaleString('en-US')
}
export function fmtTime(s?: string | null): string {
if (!s) return '-'
const d = new Date(s)
if (Number.isNaN(d.getTime())) return '-'
return d.toLocaleString('zh-CN', { hour12: false })
}
export function fmtCost(v: number): string {
if (v === 0) return '$0'
if (v < 0.01) return '$' + v.toExponential(2)
return fmtMoney(v)
}
web/src/main.ts
+5 -2
View File
@@ -1,8 +1,11 @@
import { createApp } from 'vue'
import { createPinia } from 'pinia'
import './style.css'
import App from './App.vue'
import router from './router'
import { router } from './router'
import './style.css'
// 深色优先（MVP 固定深色，后续加亮色切换）
document.documentElement.classList.add('dark')
const app = createApp(App)
app.use(createPinia())
web/src/router/index.ts
+24 -12
View File
@@ -1,21 +1,34 @@
import { createRouter, createWebHistory } from 'vue-router'
import { useAuthStore } from '../stores/auth'
import { useAuthStore } from '@/stores/auth'
const router = createRouter({
export const router = createRouter({
history: createWebHistory(),
routes: [
{ path: '/', name: 'landing', component: () => import('../views/LandingView.vue') },
{ path: '/login', name: 'login', component: () => import('../views/LoginView.vue'), meta: { guest: true } },
{ path: '/register', name: 'register', component: () => import('../views/RegisterView.vue'), meta: { guest: true } },
{ path: '/', name: 'landing', component: () => import('@/views/LandingView.vue') },
{ path: '/login', name: 'login', component: () => import('@/views/LoginView.vue'), meta: { guest: true } },
{ path: '/register', name: 'register', component: () => import('@/views/RegisterView.vue'), meta: { guest: true } },
{
path: '/console',
component: () => import('../views/console/ConsoleLayout.vue'),
component: () => import('@/views/console/ConsoleLayout.vue'),
meta: { auth: true },
children: [
{ path: '', redirect: '/console/dashboard' },
{ path: 'dashboard', name: 'dashboard', component: () => import('../views/console/DashboardView.vue') },
{ path: 'keys', name: 'keys', component: () => import('../views/console/KeysView.vue') },
{ path: 'usage', name: 'usage', component: () => import('../views/console/UsageView.vue') },
{ path: 'dashboard', name: 'dashboard', component: () => import('@/views/console/DashboardView.vue') },
{ path: 'keys', name: 'keys', component: () => import('@/views/console/KeysView.vue') },
{ path: 'usage', name: 'usage', component: () => import('@/views/console/UsageView.vue') },
],
},
{
path: '/admin',
component: () => import('@/views/admin/AdminLayout.vue'),
meta: { auth: true, admin: true },
children: [
{ path: '', redirect: '/admin/overview' },
{ path: 'overview', name: 'admin-overview', component: () => import('@/views/admin/OverviewView.vue') },
{ path: 'channels', name: 'admin-channels', component: () => import('@/views/admin/ChannelsView.vue') },
{ path: 'models', name: 'admin-models', component: () => import('@/views/admin/ModelsView.vue') },
{ path: 'users', name: 'admin-users', component: () => import('@/views/admin/UsersView.vue') },
{ path: 'config', name: 'admin-config', component: () => import('@/views/admin/ConfigView.vue') },
],
},
{ path: '/:pathMatch(.*)*', redirect: '/' },
@@ -24,10 +37,9 @@ const router = createRouter({
router.beforeEach(async (to) => {
const auth = useAuthStore()
if (!auth.ready && auth.token) await auth.fetchMe()
if (!auth.ready) await auth.bootstrap()
if (to.meta.auth && !auth.isAuthed) return { name: 'login', query: { redirect: to.fullPath } }
if (to.meta.admin && !auth.isAdmin) return { name: 'dashboard' }
if (to.meta.guest && auth.isAuthed) return { name: 'dashboard' }
return true
})
export default router
web/src/stores/auth.ts
+38 -39
View File
@@ -1,60 +1,59 @@
import { defineStore } from 'pinia'
import client, { unwrap } from '../api/client'
export interface User {
id: number
username: string
email: string
role: 'user' | 'admin'
balance: number
status: string
created_at: string
}
interface LoginResp {
access_token: string
expires_in: number
user: User
}
import { http } from '@/api/client'
import type { User } from '@/types'
export const useAuthStore = defineStore('auth', {
state: () => ({
user: null as User | null,
token: localStorage.getItem('ot_access') ?? '',
accessToken: localStorage.getItem('ot_access') ?? '',
ready: false,
}),
getters: {
isAuthed: (s) => !!s.token,
isAuthed: (s) => !!s.accessToken && !!s.user,
isAdmin: (s) => s.user?.role === 'admin',
},
actions: {
setToken(t: string) {
this.token = t
localStorage.setItem('ot_access', t)
},
async login(username: string, password: string) {
const data = await unwrap<LoginResp>(client.post('/auth/login', { username, password }))
this.setToken(data.access_token)
this.user = data.user
async bootstrap() {
try {
if (!this.accessToken) {
await this.refresh()
}
await this.fetchMe()
} catch {
this.clear()
}
this.ready = true
},
async register(username: string, email: string, password: string) {
await unwrap(client.post('/auth/register', { username, email, password }))
await http.post('/auth/register', { username, email, password })
},
async login(username: string, password: string) {
const { data } = await http.post('/auth/login', { username, password })
const d = data.data as { access_token: string; user: User }
this.accessToken = d.access_token
this.user = d.user
localStorage.setItem('ot_access', d.access_token)
},
async refresh() {
const { data } = await http.post('/auth/refresh')
this.accessToken = data.data.access_token as string
localStorage.setItem('ot_access', this.accessToken)
},
async fetchMe() {
if (!this.token) return
try {
const data = await unwrap<{ user: User }>(client.get('/auth/me'))
this.user = data.user
} catch {
this.logout()
} finally {
this.ready = true
}
const { data } = await http.get('/auth/me')
this.user = data.data.user as User
},
async logout() {
try { await client.post('/auth/logout') } catch { /* ignore */ }
try {
await http.post('/auth/logout')
} catch {
/* ignore */
}
this.clear()
},
clear() {
this.accessToken = ''
this.user = null
this.token = ''
localStorage.removeItem('ot_access')
},
},
web/src/stores/toast.ts
+15 -13
View File
@@ -1,27 +1,29 @@
// Toast 状态：轻量全局消息队列（操作反馈，aria-live 播报）
import { defineStore } from 'pinia'
export interface Toast {
export interface ToastItem {
id: number
kind: 'success' | 'error' | 'info'
message: string
msg: string
type: 'info' | 'ok' | 'err'
}
let seq = 0
export const useToastStore = defineStore('toast', {
state: () => ({ items: [] as Toast[] }),
state: () => ({ items: [] as ToastItem[] }),
actions: {
push(kind: Toast['kind'], message: string) {
push(msg: string, type: ToastItem['type'] = 'info') {
const id = ++seq
this.items.push({ id, kind, message })
setTimeout(() => this.dismiss(id), 4000)
this.items.push({ id, msg, type })
setTimeout(() => this.remove(id), 4000)
},
success(message: string) { this.push('success', message) },
error(message: string) { this.push('error', message) },
info(message: string) { this.push('info', message) },
dismiss(id: number) {
this.items = this.items.filter((t) => t.id !== id)
ok(msg: string) {
this.push(msg, 'ok')
},
err(msg: string) {
this.push(msg, 'err')
},
remove(id: number) {
this.items = this.items.filter((i) => i.id !== id)
},
},
})
web/src/style.css
+43 -99
View File
@@ -1,122 +1,66 @@
@import "tailwindcss";
@import "@fontsource/outfit/400.css";
@import "@fontsource/outfit/500.css";
@import "@fontsource/outfit/600.css";
@import "@fontsource/outfit/700.css";
@import "@fontsource/jetbrains-mono/400.css";
@import "@fontsource/jetbrains-mono/500.css";
@import "@fontsource/jetbrains-mono/600.css";
@import 'tailwindcss';
@import '@fontsource-variable/geist';
@import '@fontsource-variable/geist-mono';
/* ============================================================
openteam 设计 tokens（taste-skill 产出）
方向：深色优先的开发者控制台 / 信号系统语言
色板：石墨墨底 + 暖白文本 + 单一信号铜色强调（信号灯）
数据一律 mono（JetBrains Mono），UI 用 Outfit
============================================================ */
/* ------------------------------------------------------------------ */
/* 设计 tokens（taste-skill 产出） */
/* 深色优先 · 单一强调色 emerald · 圆角体系:卡片 8 / 控件 6 / 徽章 pill */
/* 密度 7:mono 数字、紧凑表格、细线分隔 */
/* ------------------------------------------------------------------ */
@theme {
/* 墨色层（背景阶梯） */
--color-ink-950: #0c0d0f;
--color-ink-900: #121417;
--color-ink-850: #16191d;
--color-ink-800: #1c2025;
--color-ink-700: #282d34;
--color-ink-600: #363c45;
--font-sans: 'Geist Variable', ui-sans-serif, system-ui, -apple-system, 'Segoe UI', sans-serif;
--font-mono: 'Geist Mono Variable', ui-monospace, SFMono-Regular, Menlo, monospace;
/* 纸色层（文本） */
--color-paper-100: #eae8e3;
--color-paper-300: #c8c5bd;
--color-paper-500: #8b909a;
--color-paper-600: #63686f;
/* 强调色（单一一处定义，全局一致） */
--color-accent: oklch(0.72 0.17 152);
--color-accent-strong: oklch(0.64 0.19 152);
--color-accent-soft: oklch(0.95 0.05 152);
/* 信号铜色（唯一强调，信号灯意象） */
--color-signal-200: #f7d9a8;
--color-signal-300: #f0be6d;
--color-signal-400: #e5a13c;
--color-signal-500: #c9842a;
--color-signal-600: #a56a1f;
/* 语义色 */
--color-mint-300: #7fd0ac;
--color-mint-400: #4cb58a;
--color-mint-500: #33946f;
--color-ember-300: #ec8a80;
--color-ember-400: #d9685c;
--color-ember-500: #b34c42;
--color-sky-300: #93bce4;
--color-sky-400: #6e9fd8;
--font-sans: "Outfit", ui-sans-serif, system-ui, sans-serif;
--font-mono: "JetBrains Mono", ui-monospace, "SF Mono", monospace;
/* 圆角：全局统一 6px（工具类，克制） */
--radius-sm: 4px;
--radius-md: 6px;
--radius-lg: 10px;
}
/* 亮色主题（保留：data-theme="light" 时切换，默认深色优先） */
[data-theme="light"] {
--color-ink-950: #f4f3f0;
--color-ink-900: #ffffff;
--color-ink-850: #faf9f6;
--color-ink-800: #f0efeb;
--color-ink-700: #e2e0da;
--color-ink-600: #cfccc4;
--color-paper-100: #1d2024;
--color-paper-300: #3a3f46;
--color-paper-500: #5f6670;
--color-paper-600: #8a9099;
--color-signal-400: #b3741c;
--color-signal-500: #9a6116;
--color-mint-400: #1f8a61;
--color-ember-400: #c24b41;
--color-sky-400: #3f78b8;
/* 状态色（语义，克制使用） */
--color-ok: oklch(0.72 0.17 152);
--color-warn: oklch(0.80 0.15 75);
--color-err: oklch(0.63 0.21 25);
}
html {
color-scheme: dark;
}
[data-theme="light"] {
color-scheme: light;
}
body {
@apply bg-ink-950 text-paper-100 font-sans antialiased;
font-feature-settings: "ss01" on, "cv05" on;
background-color: #09090b;
color: #f4f4f5;
font-family: var(--font-sans);
-webkit-font-smoothing: antialiased;
}
/* 数字统一用 tabular 对齐（数据密集场景） */
.num {
font-family: var(--font-mono);
font-variant-numeric: tabular-nums;
letter-spacing: -0.01em;
}
/* 聚焦可见性：键盘可达性 */
/* 全站统一键盘焦点可见性 */
:focus-visible {
outline: 2px solid var(--color-signal-400);
outline: 2px solid var(--color-accent);
outline-offset: 2px;
}
/* 滚动条克制化 */
::-webkit-scrollbar {
width: 10px;
height: 10px;
}
::-webkit-scrollbar-thumb {
background: var(--color-ink-700);
border-radius: 6px;
border: 2px solid var(--color-ink-950);
}
::-webkit-scrollbar-track {
background: transparent;
border-radius: 4px;
}
@media (prefers-reduced-motion: reduce) {
*, *::before, *::after {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
transition-duration: 0.01ms !important;
}
}
/* 通用组件视觉基元 */
@layer components {
.card {
@apply rounded-lg border border-zinc-800 bg-zinc-900/60;
}
.mono-num {
@apply font-mono tabular-nums;
}
.table-row {
@apply border-b border-zinc-800/70 last:border-0 hover:bg-zinc-800/30;
}
}
web/src/types.ts
+80
View File
@@ -0,0 +1,80 @@
export interface User {
id: number
username: string
email: string
role: 'user' | 'admin'
balance: number
status: string
created_at: string
}
export interface ApiKey {
id: number
name: string
key_prefix: string
quota_tokens_per_day?: number | null
quota_requests_per_day?: number | null
allowed_models?: string[] | null
expires_at?: string | null
status: string
last_used_at?: string | null
created_at: string
}
export interface Channel {
id: number
name: string
provider: 'openai' | 'anthropic' | 'compatible'
base_url: string
api_key_masked: string
weight: number
priority: number
timeout_ms: number
max_concurrency: number
health_status: string
enabled: boolean
created_at: string
}
export interface ModelBinding {
id: number
channel_id: number
channel_name: string
upstream_model: string
weight: number
}
export interface Model {
id: number
name: string
display_name: string
input_price: number
output_price: number
cache_read_price: number
enabled: boolean
sort: number
channels: ModelBinding[]
}
export interface UsageLog {
id: number
request_id: string
model: string
protocol: string
input_tokens: number
output_tokens: number
cache_read_tokens: number
cost: number
latency_ms: number
status: string
error_code: string | null
created_at: string
user?: string
}
export interface Paged<T> {
items: T[]
total: number
page: number
page_size: number
}
web/src/views/LandingView.vue
+138 -69
View File
@@ -1,105 +1,174 @@
<script setup lang="ts">
import { useAuthStore } from '../stores/auth'
import { computed } from 'vue'
import { useAuthStore } from '@/stores/auth'
const auth = useAuthStore()
const primaryAction = computed(() => (auth.isAuthed ? '/console/dashboard' : '/register'))
const protocols = [
{ name: 'POST /v1/chat/completions', desc: 'OpenAI Chat Completions · 流式 + 工具调用' },
{ name: 'POST /v1/responses', desc: 'OpenAI Responses API · 新一代生态' },
{ name: 'POST /v1/messages', desc: 'Anthropic Messages · Claude 原生格式' },
{ name: 'GET /v1/models', desc: 'OpenAI 风格模型列表' },
]
</script>
<template>
<div class="min-h-[100dvh] bg-ink-950 text-paper-100">
<!-- 顶部导航 -->
<header class="sticky top-0 z-40 border-b border-ink-800 bg-ink-950/90 backdrop-blur">
<div class="mx-auto flex h-16 max-w-6xl items-center justify-between px-6">
<router-link to="/" class="flex items-center gap-2.5" aria-label="openteam 首页">
<span class="flex h-7 w-7 items-center justify-center rounded-md bg-signal-400" aria-hidden="true">
<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M2 8h3l2-5 3 10 2-5h2" stroke="#0c0d0f" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>
</span>
<span class="text-[15px] font-semibold tracking-tight" translate="no">openteam</span>
<span class="ml-1 rounded border border-ink-700 px-1.5 py-px font-mono text-[10px] text-paper-500" translate="no">relay</span>
</router-link>
<nav class="flex items-center gap-2" aria-label="站内导航">
<div class="min-h-[100dvh] bg-zinc-950 text-zinc-100">
<!-- 导航 -->
<header class="sticky top-0 z-40 border-b border-zinc-800/60 bg-zinc-950/80 backdrop-blur">
<div class="mx-auto flex h-14 max-w-6xl items-center justify-between px-4">
<div class="flex items-center gap-2">
<img src="/favicon.svg" alt="" class="size-5" />
<span class="text-sm font-semibold tracking-tight">openteam</span>
</div>
<nav class="flex items-center gap-2">
<router-link
v-if="!auth.isAuthed"
to="/login"
class="rounded-md px-3 py-2 text-sm text-paper-500 transition-colors hover:bg-ink-800 hover:text-paper-100 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
>登录</router-link>
class="rounded-md px-3 py-1.5 text-sm text-zinc-400 transition hover:text-zinc-100"
>
登录
</router-link>
<router-link v-else to="/console/dashboard" class="rounded-md px-3 py-1.5 text-sm text-zinc-400 transition hover:text-zinc-100">
控制台
</router-link>
<router-link
:to="primaryAction"
class="inline-flex h-9 touch-manipulation items-center rounded-md bg-signal-400 px-4 text-sm font-medium text-ink-950 transition-colors hover:bg-signal-300 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
>开始使用</router-link>
v-if="!auth.isAuthed"
to="/register"
class="rounded-md bg-accent px-3.5 py-1.5 text-sm font-medium text-zinc-950 transition hover:bg-accent-strong"
>
免费注册
</router-link>
</nav>
</div>
</header>
<main id="landing-main">
<!-- Hero：左对齐，信号路径示意 -->
<section class="mx-auto grid max-w-6xl grid-cols-1 items-center gap-14 px-6 pt-16 pb-20 lg:grid-cols-[1.1fr_0.9fr]">
<div>
<p class="font-mono text-xs uppercase tracking-[0.2em] text-signal-400" translate="no">self-hosted llm relay</p>
<h1 class="mt-4 text-4xl leading-[1.05] font-bold tracking-tight text-balance md:text-5xl">
一个 Key，<br />接入全部模型
<!-- Hero：左文案 + 右真实调用演示 -->
<section class="relative overflow-hidden">
<div class="pointer-events-none absolute inset-x-0 top-0 h-px bg-gradient-to-r from-transparent via-emerald-500/40 to-transparent" />
<div class="mx-auto grid max-w-6xl items-center gap-10 px-4 pt-20 pb-16 lg:grid-cols-2 lg:pt-24">
<div class="max-w-xl">
<p class="mb-3 font-mono text-xs tracking-wide text-emerald-400/80">LLM API 中转网关</p>
<h1 class="text-4xl leading-none font-semibold tracking-tight md:text-5xl">
一个 Key，调用所有主流模型
</h1>
<p class="mt-5 max-w-[52ch] text-base leading-relaxed text-paper-500">
自托管 LLM API 中转网关。统一 OpenAI 与 Anthropic 协议入口，背后对接任意上游渠道，用量计费一目了然。
<p class="mt-5 max-w-md text-base leading-relaxed text-zinc-400">
统一 OpenAI 与 Anthropic 协议入口，三套 API 自动互转，用量、计费与 API Key 管理开箱即用。
</p>
<div class="mt-8 flex items-center gap-3">
<router-link
to="/register"
class="inline-flex h-10 touch-manipulation items-center rounded-md bg-signal-400 px-5 text-sm font-medium text-ink-950 transition-[background-color,transform] hover:bg-signal-300 active:scale-[0.98] focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
>立即开始</router-link>
<a
href="#protocols"
class="inline-flex h-10 touch-manipulation items-center rounded-md border border-ink-600 px-5 text-sm text-paper-300 transition-colors hover:border-signal-400 hover:text-signal-300 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
>查看端点</a>
class="inline-flex h-10 items-center rounded-md bg-accent px-5 text-sm font-medium text-zinc-950 transition hover:bg-accent-strong active:scale-[0.98]"
>
免费注册
</router-link>
<router-link
to="/login"
class="inline-flex h-10 items-center rounded-md border border-zinc-700 px-5 text-sm text-zinc-200 transition hover:border-zinc-500"
>
登录
</router-link>
</div>
<p class="mt-5 font-mono text-xs text-zinc-600">不用换 SDK，改一行 base_url 即可接入</p>
</div>
<!-- 信号路径：client → gateway → upstream -->
<div class="rounded-lg border border-ink-700 bg-ink-900 p-5 font-mono text-[13px]" aria-label="请求链路示意">
<div class="flex items-center gap-3 pb-4">
<span class="h-1.5 w-1.5 animate-pulse rounded-full bg-mint-400" aria-hidden="true" />
<span class="text-xs text-paper-500" translate="no">request path · live</span>
<!-- 调用演示（真实格式，非伪截图） -->
<div class="card overflow-hidden font-mono text-xs">
<div class="flex items-center gap-1.5 border-b border-zinc-800 px-4 py-2.5">
<span class="size-2.5 rounded-full bg-zinc-700" />
<span class="size-2.5 rounded-full bg-zinc-700" />
<span class="ml-2 text-zinc-500">curl api.openteam.dev</span>
</div>
<div class="space-y-3 p-4 leading-relaxed">
<div>
<p class="text-zinc-400"><span class="text-emerald-400">$</span> curl https://api.openteam.dev/v1/chat/completions</p>
<p class="text-zinc-400"> -H <span class="text-emerald-300">"Authorization: Bearer sk-..."</span> \</p>
<p class="text-zinc-400"> -d <span class="text-zinc-300">'{"model": "claude-sonnet-5", "messages": [{"role": "user", "content": "你好"}]}'</span></p>
</div>
<div class="border-t border-zinc-800 pt-3 text-zinc-500">
<p class="text-zinc-600"># OpenAI 格式请求，网关自动转 Anthropic 协议</p>
<p class="text-zinc-300">data: {"id":"resp_1","model":"claude-sonnet-5","choices":[{</p>
<p class="text-zinc-300">&nbsp;&nbsp;"delta":{"content":"你好，这是流式回复"}</p>
<p class="text-zinc-300">}]}</p>
<p class="text-zinc-300">data: [DONE]</p>
</div>
</div>
<div class="space-y-2">
<div class="rounded-md border border-ink-700 bg-ink-850 px-3 py-2 text-paper-300">client <span class="text-signal-400" aria-hidden="true">──▶</span> <span class="text-paper-500" translate="no">/v1/chat/completions</span></div>
<div class="rounded-md border border-ink-700 bg-ink-850 px-3 py-2 text-paper-300">gateway <span class="text-signal-400" aria-hidden="true">──▶</span> <span class="text-paper-500" translate="no">auth · quota · route</span></div>
<div class="rounded-md border border-ink-700 bg-ink-850 px-3 py-2 text-paper-300">upstream <span class="text-mint-400" aria-hidden="true">◀──</span> <span class="text-paper-500" translate="no">openai / anthropic</span></div>
<div class="rounded-md border border-ink-700 bg-ink-850 px-3 py-2 text-paper-300">billing <span class="text-mint-400" aria-hidden="true">──▶</span> <span class="num text-paper-500" translate="no">usage · cost · ledger</span></div>
</div>
</div>
</section>
<!-- 协议端点 -->
<section id="protocols" class="scroll-mt-16 border-t border-ink-800 bg-ink-900/50">
<div class="mx-auto max-w-6xl px-6 py-16">
<h2 class="text-xl font-semibold tracking-tight">三套协议，一个入口</h2>
<p class="mt-2 max-w-[60ch] text-sm leading-relaxed text-paper-500">
OpenAI 与 Anthropic 生态的 SDK 与客户端无需改动，直接指向本网关。协议间自动互转。
<!-- 协议入口 -->
<section class="border-t border-zinc-800/60">
<div class="mx-auto max-w-6xl px-4 py-16">
<h2 class="text-2xl font-semibold tracking-tight">三套协议，一个入口</h2>
<p class="mt-2 max-w-xl text-sm text-zinc-500">
对客户端暴露统一的 OpenAI 兼容入口；客户端协议与上游渠道不匹配时自动转换，无需关心背后接的是哪家。
</p>
<div class="mt-8 grid grid-cols-1 gap-3 md:grid-cols-2">
<div v-for="p in protocols" :key="p.name" class="rounded-lg border border-ink-700 bg-ink-900 p-4">
<code class="font-mono text-[13px] text-signal-300" translate="no">{{ p.name }}</code>
<p class="mt-1.5 text-[13px] text-paper-500">{{ p.desc }}</p>
<div class="card mt-8 divide-y divide-zinc-800/70">
<div v-for="p in [
{ path: 'POST /v1/chat/completions', desc: 'OpenAI Chat，兼容面最广，SDK 与工具链最全', tag: 'OpenAI' },
{ path: 'POST /v1/responses', desc: 'OpenAI Responses，新一代 SDK 与 Agents 首选', tag: 'OpenAI' },
{ path: 'POST /v1/messages', desc: 'Anthropic Messages，Claude 生态原生格式', tag: 'Anthropic' },
{ path: 'GET /v1/models', desc: 'OpenAI 风格模型列表', tag: 'List' },
]" :key="p.path" class="grid gap-1 px-5 py-3.5 sm:grid-cols-3 sm:items-center">
<code class="font-mono text-sm text-emerald-300">{{ p.path }}</code>
<p class="text-sm text-zinc-400 sm:col-span-1">{{ p.desc }}</p>
<span class="hidden justify-self-end font-mono text-[11px] text-zinc-600 sm:block">{{ p.tag }}</span>
</div>
</div>
</div>
</section>
<!-- 页脚 -->
<footer class="border-t border-ink-800">
<div class="mx-auto flex max-w-6xl items-center justify-between px-6 py-6 text-xs text-paper-600">
<span>openteam · 自托管 LLM 中转网关</span>
<span class="font-mono" translate="no">v0.1 · M1</span>
<!-- 网关能力 -->
<section class="border-t border-zinc-800/60">
<div class="mx-auto max-w-6xl px-4 py-16">
<h2 class="text-2xl font-semibold tracking-tight">网关替你处理的事</h2>
<div class="mt-8 grid gap-4 lg:grid-cols-3">
<div class="card p-5 lg:col-span-2">
<p class="font-mono text-xs text-emerald-400/80">responses → claude-sonnet-5</p>
<h3 class="mt-2 text-lg font-semibold">协议自动转换</h3>
<p class="mt-2 text-sm leading-relaxed text-zinc-500">
客户端按 Responses 调用 Claude 模型，网关转成 Anthropic 协议打给上游，再以 Responses 事件流式返回。直通优先，能力无损时零转换。
</p>
</div>
<div class="card p-5">
<p class="font-mono text-xs text-zinc-600">usage · daily</p>
<h3 class="mt-2 text-lg font-semibold">用量与计费</h3>
<p class="mt-2 text-sm leading-relaxed text-zinc-500">
请求级 token 统计，按模型价格自动扣费，日粒度报表与余额流水可追溯。
</p>
</div>
<div class="card p-5">
<p class="font-mono text-xs text-zinc-600">sk-…</p>
<h3 class="mt-2 text-lg font-semibold">API Key 管理</h3>
<p class="mt-2 text-sm leading-relaxed text-zinc-500">
密钥仅存哈希，支持配额、过期与模型白名单，创建时一次性展示。
</p>
</div>
<div class="card p-5 lg:col-span-2">
<p class="font-mono text-xs text-zinc-600">channels · lb · health</p>
<h3 class="mt-2 text-lg font-semibold">多渠道接入</h3>
<p class="mt-2 text-sm leading-relaxed text-zinc-500">
一个模型绑定多个上游渠道，按权重与健康状态选择，故障自动转移。管理员在后台一键接入新渠道、导入模型并定价。
</p>
</div>
</div>
</div>
</section>
<!-- CTA -->
<section class="border-t border-zinc-800/60">
<div class="mx-auto max-w-6xl px-4 py-20 text-center">
<h2 class="text-2xl font-semibold tracking-tight">自托管，密钥在自己手里</h2>
<p class="mx-auto mt-3 max-w-md text-sm text-zinc-500">Docker Compose 一键部署，PostgreSQL 存账，渠道密钥加密存储。</p>
<router-link
to="/register"
class="mt-8 inline-flex h-10 items-center rounded-md bg-accent px-6 text-sm font-medium text-zinc-950 transition hover:bg-accent-strong active:scale-[0.98]"
>
开始使用
</router-link>
</div>
</section>
<footer class="border-t border-zinc-800/60">
<div class="mx-auto flex max-w-6xl items-center justify-between px-4 py-6 text-xs text-zinc-600">
<div class="flex items-center gap-2">
<img src="/favicon.svg" alt="" class="size-4" />
<span>openteam · LLM API 中转站</span>
</div>
<span class="font-mono">© 2026</span>
</div>
</footer>
</main>
</div>
</template>
web/src/views/LoginView.vue
+30 -55
View File
@@ -1,32 +1,33 @@
<script setup lang="ts">
import { ref } from 'vue'
import { useRoute, useRouter } from 'vue-router'
import { useAuthStore } from '../stores/auth'
import Input from '../components/ui/Input.vue'
import Button from '../components/ui/Button.vue'
import { useRouter, useRoute } from 'vue-router'
import { useAuthStore } from '@/stores/auth'
import { useToastStore } from '@/stores/toast'
import { errMsg } from '@/api/client'
import Button from '@/components/ui/Button.vue'
import Input from '@/components/ui/Input.vue'
const auth = useAuthStore()
const router = useRouter()
const route = useRoute()
const auth = useAuthStore()
const toast = useToastStore()
const username = ref('')
const password = ref('')
const error = ref('')
const loading = ref(false)
const error = ref('')
async function submit() {
error.value = ''
if (!username.value.trim() || !password.value) {
error.value = '请输入用户名和密码'
return
}
if (!username.value || !password.value) return
loading.value = true
error.value = ''
try {
await auth.login(username.value.trim(), password.value)
await auth.login(username.value, password.value)
toast.ok('登录成功')
const redirect = (route.query.redirect as string) || '/console/dashboard'
router.push(redirect)
} catch (e: any) {
error.value = e.response?.data?.error?.message || '登录失败，请检查用户名与密码'
} catch (e) {
error.value = errMsg(e)
} finally {
loading.value = false
}
@@ -34,52 +35,26 @@ async function submit() {
</script>
<template>
<div class="flex min-h-[100dvh] items-center justify-center bg-ink-950 px-4">
<div class="flex min-h-[100dvh] items-center justify-center bg-zinc-950 px-4">
<div class="w-full max-w-sm">
<div class="mb-8 flex items-center gap-2.5">
<span class="flex h-7 w-7 items-center justify-center rounded-md bg-signal-400" aria-hidden="true">
<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M2 8h3l2-5 3 10 2-5h2" stroke="#0c0d0f" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>
</span>
<span class="text-[15px] font-semibold tracking-tight" translate="no">openteam</span>
<div class="mb-8 text-center">
<div class="mb-3 inline-flex items-center gap-2">
<img src="/favicon.svg" alt="" class="size-7" />
<span class="text-lg font-semibold tracking-tight">openteam</span>
</div>
<p class="text-sm text-zinc-500">登录到控制台</p>
</div>
<h1 class="text-xl font-semibold tracking-tight">登录控制台</h1>
<p class="mt-1 text-sm text-paper-500">管理密钥、查看用量与余额</p>
<form class="mt-8 space-y-4" @submit.prevent="submit" novalidate>
<Input
v-model="username"
label="用户名或邮箱"
name="username"
placeholder="alice"
autocomplete="username"
:spellcheck="false"
autofocus
/>
<Input
v-model="password"
label="密码"
name="password"
type="password"
placeholder="输入密码…"
autocomplete="current-password"
required
/>
<p
v-if="error"
class="rounded-md border border-ember-500/40 bg-ember-500/10 px-3 py-2 text-[13px] text-ember-300"
role="alert"
aria-live="polite"
>{{ error }}</p>
<Button type="submit" class="w-full" :loading="loading">登录</Button>
<form class="card space-y-4 p-6" @submit.prevent="submit">
<Input v-model="username" label="用户名或邮箱" autocomplete="username" placeholder="alice" />
<Input v-model="password" label="密码" type="password" autocomplete="current-password" />
<p v-if="error" class="text-xs text-red-400">{{ error }}</p>
<Button class="w-full" :loading="loading" type="submit">登录</Button>
</form>
<p class="mt-6 text-center text-[13px] text-paper-500">
还没有账号？
<router-link to="/register" class="text-signal-300 transition-colors hover:text-signal-200">注册</router-link>
</p>
<p class="mt-4 text-center">
<router-link to="/" class="text-xs text-paper-600 transition-colors hover:text-paper-500">← 返回首页</router-link>
<p class="mt-5 text-center text-sm text-zinc-500">
还没有账号?
<router-link to="/register" class="text-accent hover:text-accent-strong">注册</router-link>
</p>
</div>
</div>
web/src/views/RegisterView.vue
+38 -80
View File
@@ -1,44 +1,40 @@
<script setup lang="ts">
import { ref } from 'vue'
import { useRouter } from 'vue-router'
import { useAuthStore } from '../stores/auth'
import Input from '../components/ui/Input.vue'
import Button from '../components/ui/Button.vue'
import { useAuthStore } from '@/stores/auth'
import { useToastStore } from '@/stores/toast'
import { errMsg } from '@/api/client'
import Button from '@/components/ui/Button.vue'
import Input from '@/components/ui/Input.vue'
const auth = useAuthStore()
const router = useRouter()
const auth = useAuthStore()
const toast = useToastStore()
const username = ref('')
const email = ref('')
const password = ref('')
const confirm = ref('')
const formError = ref('')
const errors = ref<Record<string, string>>({})
const loading = ref(false)
function validate() {
const e: Record<string, string> = {}
if (!username.value.trim()) e.username = '请输入用户名'
else if (username.value.length < 3) e.username = '用户名至少 3 个字符'
if (!email.value.trim()) e.email = '请输入邮箱'
else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email.value)) e.email = '邮箱格式不正确'
if (!password.value) e.password = '请输入密码'
else if (password.value.length < 8) e.password = '密码至少 8 位'
if (confirm.value !== password.value) e.confirm = '两次输入的密码不一致'
errors.value = e
return Object.keys(e).length === 0
}
const error = ref('')
async function submit() {
formError.value = ''
if (!validate()) return
if (!username.value || !email.value) {
error.value = '请填写用户名和邮箱'
return
}
if (password.value.length < 8) {
error.value = '密码至少 8 位'
return
}
loading.value = true
error.value = ''
try {
await auth.register(username.value.trim(), email.value.trim(), password.value)
await auth.login(username.value.trim(), password.value)
await auth.register(username.value, email.value, password.value)
await auth.login(username.value, password.value)
toast.ok('注册成功，欢迎使用')
router.push('/console/dashboard')
} catch (e: any) {
formError.value = e.response?.data?.error?.message || '注册失败，请稍后重试'
} catch (e) {
error.value = errMsg(e)
} finally {
loading.value = false
}
@@ -46,71 +42,33 @@ async function submit() {
</script>
<template>
<div class="flex min-h-[100dvh] items-center justify-center bg-ink-950 px-4">
<div class="flex min-h-[100dvh] items-center justify-center bg-zinc-950 px-4">
<div class="w-full max-w-sm">
<div class="mb-8 flex items-center gap-2.5">
<span class="flex h-7 w-7 items-center justify-center rounded-md bg-signal-400" aria-hidden="true">
<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M2 8h3l2-5 3 10 2-5h2" stroke="#0c0d0f" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>
</span>
<span class="text-[15px] font-semibold tracking-tight" translate="no">openteam</span>
<div class="mb-8 text-center">
<div class="mb-3 inline-flex items-center justify-center gap-2">
<img src="/favicon.svg" alt="" class="size-7" />
<span class="text-lg font-semibold tracking-tight">openteam</span>
</div>
<p class="text-sm text-zinc-500">一个 Key 访问多家模型</p>
</div>
<h1 class="text-xl font-semibold tracking-tight">创建账号</h1>
<p class="mt-1 text-sm text-paper-500">注册即赠体验额度，一个 Key 接入全部模型</p>
<form class="mt-8 space-y-4" @submit.prevent="submit" novalidate>
<Input
v-model="username"
label="用户名"
name="username"
placeholder="alice"
autocomplete="username"
:spellcheck="false"
:error="errors.username"
autofocus
/>
<Input
v-model="email"
label="邮箱"
name="email"
type="email"
inputmode="email"
placeholder="alice@example.com"
autocomplete="email"
:spellcheck="false"
:error="errors.email"
/>
<form class="card space-y-4 p-6" @submit.prevent="submit">
<Input v-model="username" label="用户名" autocomplete="username" placeholder="alice" />
<Input v-model="email" label="邮箱" type="email" autocomplete="email" placeholder="alice@example.com" />
<Input
v-model="password"
label="密码"
name="password"
type="password"
placeholder="至少 8 位…"
autocomplete="new-password"
hint="使用 argon2id 加密存储"
:error="errors.password"
hint="至少 8 位"
/>
<Input
v-model="confirm"
label="确认密码"
name="confirm"
type="password"
placeholder="再次输入…"
autocomplete="new-password"
:error="errors.confirm"
/>
<p
v-if="formError"
class="rounded-md border border-ember-500/40 bg-ember-500/10 px-3 py-2 text-[13px] text-ember-300"
role="alert"
aria-live="polite"
>{{ formError }}</p>
<Button type="submit" class="w-full" :loading="loading">注册</Button>
<p v-if="error" class="text-xs text-red-400">{{ error }}</p>
<Button class="w-full" :loading="loading" type="submit">注册</Button>
</form>
<p class="mt-6 text-center text-[13px] text-paper-500">
已有账号？
<router-link to="/login" class="text-signal-300 transition-colors hover:text-signal-200">登录</router-link>
<p class="mt-5 text-center text-sm text-zinc-500">
已有账号?
<router-link to="/login" class="text-accent hover:text-accent-strong">登录</router-link>
</p>
</div>
</div>
web/src/views/admin/AdminLayout.vue
+32
View File
@@ -0,0 +1,32 @@
<script setup lang="ts">
import { computed } from 'vue'
import { useAuthStore } from '@/stores/auth'
import ShellLayout from '@/components/layout/ShellLayout.vue'
const auth = useAuthStore()
const sections = computed(() => {
const s: { title: string; items: { to: string; label: string }[] }[] = [
{ title: '管理', items: [
{ to: '/admin/overview', label: '运营总览' },
{ to: '/admin/channels', label: '渠道' },
{ to: '/admin/models', label: '模型与定价' },
{ to: '/admin/users', label: '用户' },
{ to: '/admin/config', label: '系统配置' },
] },
]
if (auth.user) {
s.push({ title: '控制台', items: [
{ to: '/console/dashboard', label: '仪表盘' },
{ to: '/console/keys', label: 'API Keys' },
{ to: '/console/usage', label: '用量' },
] })
}
return s
})
</script>
<template>
<ShellLayout :sections="sections">
<router-view />
</ShellLayout>
</template>
web/src/views/admin/ChannelsView.vue
+216
View File
@@ -0,0 +1,216 @@
<script setup lang="ts">
import { onMounted, reactive, ref } from 'vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import Button from '@/components/ui/Button.vue'
import Input from '@/components/ui/Input.vue'
import Modal from '@/components/ui/Modal.vue'
import Badge from '@/components/ui/Badge.vue'
import type { Channel } from '@/types'
const toast = useToastStore()
const channels = ref<Channel[]>([])
const editOpen = ref(false)
const editing = ref<Channel | null>(null)
const saving = ref(false)
const busyId = ref<number | null>(null)
const form = reactive({
name: '',
provider: 'openai' as 'openai' | 'anthropic' | 'compatible',
base_url: '',
api_key: '',
weight: 1,
priority: 0,
timeout_ms: 120000,
max_concurrency: 16,
enabled: true,
})
const providerMap: Record<string, string> = {
openai: 'OpenAI',
anthropic: 'Anthropic',
compatible: '兼容',
}
async function load() {
try {
const { data } = await http.get('/admin/channels')
channels.value = data.data.items
} catch (e) {
toast.err(errMsg(e))
}
}
function openCreate() {
editing.value = null
Object.assign(form, {
name: '', provider: 'openai', base_url: '', api_key: '',
weight: 1, priority: 0, timeout_ms: 120000, max_concurrency: 16, enabled: true,
})
editOpen.value = true
}
function openEdit(ch: Channel) {
editing.value = ch
Object.assign(form, {
name: ch.name, provider: ch.provider, base_url: ch.base_url, api_key: '',
weight: ch.weight, priority: ch.priority, timeout_ms: ch.timeout_ms,
max_concurrency: ch.max_concurrency, enabled: ch.enabled,
})
editOpen.value = true
}
async function save() {
saving.value = true
const payload = {
...form,
weight: Number(form.weight),
priority: Number(form.priority),
timeout_ms: Number(form.timeout_ms),
max_concurrency: Number(form.max_concurrency),
}
try {
if (editing.value) {
await http.put(`/admin/channels/${editing.value.id}`, payload)
toast.ok('渠道已更新')
} else {
await http.post('/admin/channels', payload)
toast.ok('渠道已创建')
}
editOpen.value = false
await load()
} catch (e) {
toast.err(errMsg(e))
} finally {
saving.value = false
}
}
async function remove(ch: Channel) {
if (!confirm(`删除渠道 ${ch.name}？关联的模型绑定也会清除。`)) return
try {
await http.delete(`/admin/channels/${ch.id}`)
toast.ok('渠道已删除')
await load()
} catch (e) {
toast.err(errMsg(e))
}
}
async function testChannel(ch: Channel) {
busyId.value = ch.id
try {
await http.post(`/admin/channels/${ch.id}/test`)
toast.ok(`渠道 ${ch.name} 连接正常`)
} catch (e) {
toast.err(`连接失败: ${errMsg(e)}`)
} finally {
busyId.value = null
await load()
}
}
async function importModels(ch: Channel) {
busyId.value = ch.id
try {
const { data } = await http.post(`/admin/channels/${ch.id}/models/import`)
toast.ok(`已导入 ${data.data.imported} 个模型`)
} catch (e) {
toast.err(errMsg(e))
} finally {
busyId.value = null
}
}
onMounted(load)
</script>
<template>
<div class="mx-auto max-w-6xl">
<div class="mb-6 flex items-center justify-between">
<div>
<h1 class="text-lg font-semibold">渠道</h1>
<p class="text-sm text-zinc-500">接入上游服务，API Key 加密存储</p>
</div>
<Button @click="openCreate">添加渠道</Button>
</div>
<div class="card">
<div class="overflow-x-auto">
<table class="w-full text-sm">
<thead>
<tr class="border-b border-zinc-800 text-left text-xs text-zinc-500">
<th scope="col" class="px-4 py-2.5 font-medium">名称</th>
<th scope="col" class="px-4 py-2.5 font-medium">类型</th>
<th scope="col" class="px-4 py-2.5 font-medium">Base URL</th>
<th scope="col" class="px-4 py-2.5 font-medium">Key</th>
<th scope="col" class="px-4 py-2.5 font-medium">健康</th>
<th scope="col" class="px-4 py-2.5 font-medium">启用</th>
<th scope="col" class="px-4 py-2.5" />
</tr>
</thead>
<tbody>
<tr v-for="ch in channels" :key="ch.id" class="table-row">
<td class="px-4 py-2.5 text-zinc-200">{{ ch.name }}</td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-400">{{ providerMap[ch.provider] }}</td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-500">{{ ch.base_url }}</td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-600">{{ ch.api_key_masked || '****' }}</td>
<td class="px-4 py-2.5">
<Badge :variant="ch.health_status === 'healthy' ? 'ok' : ch.health_status === 'cooldown' ? 'err' : 'warn'">
{{ ch.health_status }}
</Badge>
</td>
<td class="px-4 py-2.5 text-xs text-zinc-400">{{ ch.enabled ? '是' : '否' }}</td>
<td class="px-4 py-2.5 text-right">
<div class="flex justify-end gap-2">
<button class="text-xs text-zinc-500 hover:text-accent" :disabled="busyId === ch.id" @click="testChannel(ch)">
{{ busyId === ch.id ? '测试中…' : '测试' }}
</button>
<button class="text-xs text-zinc-500 hover:text-accent" @click="importModels(ch)">导入模型</button>
<button class="text-xs text-zinc-500 hover:text-zinc-200" @click="openEdit(ch)">编辑</button>
<button class="text-xs text-zinc-500 hover:text-red-400" @click="remove(ch)">删除</button>
</div>
</td>
</tr>
<tr v-if="channels.length === 0">
<td colspan="7" class="px-4 py-10 text-center text-sm text-zinc-600">还没有渠道，点击「添加渠道」</td>
</tr>
</tbody>
</table>
</div>
</div>
<Modal :open="editOpen" :title="editing ? '编辑渠道' : '添加渠道'" @close="editOpen = false">
<div class="space-y-4">
<div class="grid grid-cols-2 gap-4">
<Input v-model="form.name" label="名称" placeholder="openai" />
<label class="block">
<span class="mb-1.5 block text-xs font-medium text-zinc-400">API 类型</span>
<select v-model="form.provider" class="h-10 w-full rounded-md border border-zinc-700 bg-zinc-900 px-3 text-sm text-zinc-100 outline-none focus:border-accent">
<option value="openai">OpenAI</option>
<option value="anthropic">Anthropic</option>
<option value="compatible">兼容</option>
</select>
</label>
</div>
<Input v-model="form.base_url" label="Base URL" placeholder="https://api.openai.com" />
<Input
v-model="form.api_key"
label="上游 API Key"
:placeholder="editing ? '留空则不修改' : 'sk-...'"
/>
<div class="grid grid-cols-2 gap-4">
<Input v-model="form.weight" label="权重" type="number" />
<Input v-model="form.priority" label="优先级" type="number" />
<Input v-model="form.timeout_ms" label="超时 (ms)" type="number" />
<Input v-model="form.max_concurrency" label="最大并发" type="number" />
</div>
</div>
<template #footer>
<Button variant="ghost" @click="editOpen = false">取消</Button>
<Button :loading="saving" @click="save">{{ editing ? '保存' : '创建' }}</Button>
</template>
</Modal>
</div>
</template>
web/src/views/admin/ConfigView.vue
+96
View File
@@ -0,0 +1,96 @@
<script setup lang="ts">
import { onMounted, reactive, ref } from 'vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import Button from '@/components/ui/Button.vue'
const toast = useToastStore()
const config = reactive<Record<string, string>>({})
const loading = ref(false)
const saving = ref(false)
async function load() {
loading.value = true
try {
const { data } = await http.get('/admin/config')
Object.keys(config).forEach((k) => delete config[k])
Object.assign(config, data.data.config)
} catch (e) {
toast.err(errMsg(e))
} finally {
loading.value = false
}
}
async function save() {
saving.value = true
try {
await http.put('/admin/config', config)
toast.ok('配置已保存')
} catch (e) {
toast.err(errMsg(e))
} finally {
saving.value = false
}
}
onMounted(load)
</script>
<template>
<div class="mx-auto max-w-2xl">
<div class="mb-6">
<h1 class="text-lg font-semibold">系统配置</h1>
<p class="text-sm text-zinc-500">注册策略等平台级配置</p>
</div>
<div class="card space-y-5 p-6">
<div v-if="loading" class="py-8 text-center text-sm text-zinc-600">加载中…</div>
<template v-else>
<div class="space-y-4">
<div>
<p class="mb-1.5 text-xs font-medium text-zinc-400">注册模式</p>
<div class="flex gap-2">
<button
class="flex-1 rounded-md border px-3 py-2 text-sm transition"
:class="config.registration_mode === 'open' ? 'border-accent bg-accent/10 text-emerald-300' : 'border-zinc-700 text-zinc-400'"
@click="config.registration_mode = 'open'"
>
开放注册
</button>
<button
class="flex-1 rounded-md border px-3 py-2 text-sm transition"
:class="config.registration_mode === 'invite' ? 'border-accent bg-accent/10 text-emerald-300' : 'border-zinc-700 text-zinc-400'"
@click="config.registration_mode = 'invite'"
>
邀请码
</button>
</div>
<p class="mt-1.5 text-xs text-zinc-600">邀请模式下注册需填写有效邀请码（invite_codes 配置）</p>
</div>
<div>
<p class="mb-1.5 text-xs font-medium text-zinc-400">邀请码（逗号分隔）</p>
<input
v-model="config.invite_codes"
placeholder="code1,code2"
class="h-10 w-full rounded-md border border-zinc-700 bg-zinc-900 px-3 font-mono text-xs outline-none focus:border-accent"
/>
</div>
<div class="flex items-center justify-between rounded-md border border-zinc-800 bg-zinc-900/60 px-4 py-3">
<div>
<p class="text-sm text-zinc-300">其他配置项</p>
<p class="text-xs text-zinc-600">汇率、限流阈值、维护开关在后续里程碑开放</p>
</div>
<span class="font-mono text-xs text-zinc-600">M3+</span>
</div>
</div>
<div class="flex justify-end">
<Button :loading="saving" @click="save">保存</Button>
</div>
</template>
</div>
</div>
</template>
web/src/views/admin/ModelsView.vue
+215
View File
@@ -0,0 +1,215 @@
<script setup lang="ts">
import { onMounted, reactive, ref } from 'vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import Button from '@/components/ui/Button.vue'
import Input from '@/components/ui/Input.vue'
import Modal from '@/components/ui/Modal.vue'
import Badge from '@/components/ui/Badge.vue'
import type { Channel, Model } from '@/types'
const toast = useToastStore()
const models = ref<Model[]>([])
const channels = ref<Channel[]>([])
const editOpen = ref(false)
const editing = ref<Model | null>(null)
const saving = ref(false)
const bindOpen = ref(false)
const bindModel = ref<Model | null>(null)
const binding = reactive({ channel_id: 0, upstream_model: '', weight: 1 })
const form = reactive({
name: '',
display_name: '',
input_price: 0,
output_price: 0,
cache_read_price: 0,
enabled: true,
})
async function load() {
try {
const [m, c] = await Promise.all([http.get('/admin/models'), http.get('/admin/channels')])
models.value = m.data.data.items
channels.value = c.data.data.items
} catch (e) {
toast.err(errMsg(e))
}
}
function openCreate() {
editing.value = null
Object.assign(form, { name: '', display_name: '', input_price: 0, output_price: 0, cache_read_price: 0, enabled: true })
editOpen.value = true
}
function openEdit(m: Model) {
editing.value = m
Object.assign(form, {
name: m.name, display_name: m.display_name,
input_price: m.input_price, output_price: m.output_price, cache_read_price: m.cache_read_price,
enabled: m.enabled,
})
editOpen.value = true
}
async function save() {
saving.value = true
const payload = {
display_name: form.display_name || form.name,
input_price: Number(form.input_price),
output_price: Number(form.output_price),
cache_read_price: Number(form.cache_read_price),
enabled: form.enabled,
}
try {
if (editing.value) {
await http.put(`/admin/models/${editing.value.id}`, payload)
toast.ok('模型已更新')
} else {
await http.post('/admin/models', { name: form.name, ...payload })
toast.ok('模型已创建')
}
editOpen.value = false
await load()
} catch (e) {
toast.err(errMsg(e))
} finally {
saving.value = false
}
}
async function removeModel(m: Model) {
if (!confirm(`删除模型 ${m.name}？`)) return
try {
await http.delete(`/admin/models/${m.id}`)
toast.ok('模型已删除')
await load()
} catch (e) {
toast.err(errMsg(e))
}
}
function openBind(m: Model) {
bindModel.value = m
Object.assign(binding, { channel_id: channels.value[0]?.id ?? 0, upstream_model: m.name, weight: 1 })
bindOpen.value = true
}
async function saveBinding() {
if (!bindModel.value) return
try {
await http.post(`/admin/models/${bindModel.value.id}/bindings`, {
...binding,
weight: Number(binding.weight),
})
toast.ok('绑定已添加')
bindOpen.value = false
await load()
} catch (e) {
toast.err(errMsg(e))
}
}
async function removeBinding(m: Model, bid: number) {
try {
await http.delete(`/admin/models/${m.id}/bindings/${bid}`)
toast.ok('绑定已移除')
await load()
} catch (e) {
toast.err(errMsg(e))
}
}
onMounted(load)
</script>
<template>
<div class="mx-auto max-w-6xl">
<div class="mb-6 flex items-center justify-between">
<div>
<h1 class="text-lg font-semibold">模型与定价</h1>
<p class="text-sm text-zinc-500">价格按每百万 token (USD)，历史用量按当时价格入账</p>
</div>
<Button @click="openCreate">添加模型</Button>
</div>
<div class="space-y-3">
<div v-for="m in models" :key="m.id" class="card">
<div class="flex items-center justify-between px-4 py-3">
<div class="flex items-center gap-3">
<span class="font-mono text-sm text-zinc-100">{{ m.name }}</span>
<Badge :variant="m.enabled ? 'ok' : 'neutral'">{{ m.enabled ? '启用' : '停用' }}</Badge>
</div>
<div class="flex items-center gap-3">
<span class="mono-num text-xs text-zinc-400">入 {{ m.input_price }}</span>
<span class="mono-num text-xs text-zinc-400">出 {{ m.output_price }}</span>
<span class="mono-num text-xs text-zinc-500">缓存读 {{ m.cache_read_price }}</span>
</div>
<div class="flex gap-2">
<button class="text-xs text-zinc-500 hover:text-accent" @click="openBind(m)">绑定渠道</button>
<button class="text-xs text-zinc-500 hover:text-zinc-200" @click="openEdit(m)">编辑</button>
<button class="text-xs text-zinc-500 hover:text-red-400" @click="removeModel(m)">删除</button>
</div>
</div>
<div v-if="m.channels.length" class="border-t border-zinc-800/70 px-4 py-2">
<div class="flex flex-wrap gap-2">
<span
v-for="b in m.channels"
:key="b.id"
class="inline-flex items-center gap-1.5 rounded-md border border-zinc-800 bg-zinc-900 px-2 py-0.5 font-mono text-[11px] text-zinc-400"
>
{{ b.channel_name }} → {{ b.upstream_model }}
<button class="text-zinc-400 hover:text-red-400" aria-label="移除绑定" @click="removeBinding(m, b.id)">×</button>
</span>
</div>
</div>
<p v-else class="border-t border-zinc-800/70 px-4 py-2 text-xs text-zinc-600">
未绑定渠道，客户端无法调用该模型
</p>
</div>
<p v-if="models.length === 0" class="card px-4 py-10 text-center text-sm text-zinc-600">
还没有模型，点击「添加模型」或到渠道页「导入模型」
</p>
</div>
<!-- 模型编辑 -->
<Modal :open="editOpen" :title="editing ? '编辑模型' : '添加模型'" @close="editOpen = false">
<div class="space-y-4">
<Input v-model="form.name" label="模型名" placeholder="claude-sonnet-5" :disabled="!!editing" />
<Input v-model="form.display_name" label="展示名" />
<div class="grid grid-cols-2 gap-4">
<Input v-model="form.input_price" label="输入价格 /1M" type="number" />
<Input v-model="form.output_price" label="输出价格 /1M" type="number" />
<Input v-model="form.cache_read_price" label="缓存读价格 /1M" type="number" />
</div>
</div>
<template #footer>
<Button variant="ghost" @click="editOpen = false">取消</Button>
<Button :loading="saving" @click="save">{{ editing ? '保存' : '创建' }}</Button>
</template>
</Modal>
<!-- 绑定渠道 -->
<Modal :open="bindOpen" title="绑定渠道" @close="bindOpen = false">
<div class="space-y-4">
<p class="text-xs text-zinc-500">模型 <span class="font-mono text-emerald-300">{{ bindModel?.name }}</span> 通过以下渠道提供</p>
<label class="block">
<span class="mb-1.5 block text-xs font-medium text-zinc-400">渠道</span>
<select v-model="binding.channel_id" class="h-10 w-full rounded-md border border-zinc-700 bg-zinc-900 px-3 text-sm text-zinc-100 outline-none focus:border-accent">
<option v-for="ch in channels" :key="ch.id" :value="ch.id">{{ ch.name }}</option>
</select>
</label>
<Input v-model="binding.upstream_model" label="上游模型名" placeholder="与渠道侧一致" />
<Input v-model="binding.weight" label="权重" type="number" />
</div>
<template #footer>
<Button variant="ghost" @click="bindOpen = false">取消</Button>
<Button @click="saveBinding">绑定</Button>
</template>
</Modal>
</div>
</template>
web/src/views/admin/OverviewView.vue
+93
View File
@@ -0,0 +1,93 @@
<script setup lang="ts">
import { onMounted, ref } from 'vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import { fmtNum, fmtCost, fmtTime } from '@/lib/format'
import Badge from '@/components/ui/Badge.vue'
import TrendChart from '@/components/ui/TrendChart.vue'
import type { UsageLog } from '@/types'
const toast = useToastStore()
const data = ref({
total_users: 0, total_keys: 0, total_channels: 0, total_models: 0,
today: { requests: 0, cost: 0, tokens: 0 },
month: { requests: 0, cost: 0, tokens: 0 },
trend_14d: [] as { date: string; requests: number; cost: number }[],
})
const logs = ref<UsageLog[]>([])
async function load() {
try {
const [o, u] = await Promise.all([http.get('/admin/stats/overview'), http.get('/admin/usage?page_size=8')])
data.value = o.data.data
logs.value = u.data.data.items
} catch (e) {
toast.err(errMsg(e))
}
}
onMounted(load)
</script>
<template>
<div class="mx-auto max-w-6xl space-y-6">
<div class="mb-2">
<h1 class="text-lg font-semibold">运营总览</h1>
<p class="text-sm text-zinc-500">全局用户、渠道与营收</p>
</div>
<div class="grid grid-cols-2 gap-3 lg:grid-cols-4">
<div class="card p-4">
<p class="text-xs text-zinc-500">用户 / 密钥</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(data.total_users) }} / {{ fmtNum(data.total_keys) }}</p>
</div>
<div class="card p-4">
<p class="text-xs text-zinc-500">渠道 / 模型</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(data.total_channels) }} / {{ fmtNum(data.total_models) }}</p>
</div>
<div class="card p-4">
<p class="text-xs text-zinc-500">今日请求</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(data.today.requests) }}</p>
</div>
<div class="card p-4">
<p class="text-xs text-zinc-500">本月营收</p>
<p class="mono-num mt-1 text-xl text-emerald-300">{{ fmtCost(data.month.cost) }}</p>
</div>
</div>
<div class="grid gap-6 lg:grid-cols-5">
<div class="card p-5 lg:col-span-3">
<div class="mb-4 flex items-baseline justify-between">
<h2 class="text-sm font-semibold">近 14 天全局成本</h2>
<span class="font-mono text-[11px] text-zinc-600">{{ fmtCost(data.month.cost) }} / 本月</span>
</div>
<TrendChart
:points="data.trend_14d.map((t) => ({ label: t.date.slice(5), value: t.cost }))"
:format="(v) => '$' + v.toExponential(2)"
/>
</div>
<div class="card p-5 lg:col-span-2">
<div class="mb-3 flex items-baseline justify-between">
<h2 class="text-sm font-semibold">全局最近请求</h2>
<span class="font-mono text-[11px] text-zinc-600">共 {{ data.month.requests }} / 月</span>
</div>
<ul class="divide-y divide-zinc-800/70">
<li v-for="l in logs" :key="l.id" class="flex items-center justify-between py-2">
<div class="min-w-0">
<p class="truncate text-xs text-zinc-300">
<span class="font-mono text-emerald-400/80">{{ l.user }}</span> · {{ l.model }}
</p>
<p class="font-mono text-[11px] text-zinc-600">{{ fmtTime(l.created_at) }}</p>
</div>
<div class="flex items-center gap-2">
<span class="mono-num text-xs text-zinc-500">{{ fmtCost(l.cost) }}</span>
<Badge :variant="l.status === 'success' ? 'ok' : 'err'">{{ l.status }}</Badge>
</div>
</li>
<li v-if="logs.length === 0" class="py-6 text-center text-xs text-zinc-600">暂无请求</li>
</ul>
</div>
</div>
</div>
</template>
web/src/views/admin/UsersView.vue
+199
View File
@@ -0,0 +1,199 @@
<script setup lang="ts">
import { onMounted, reactive, ref } from 'vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import { useAuthStore } from '@/stores/auth'
import { fmtMoney, fmtTime } from '@/lib/format'
import Button from '@/components/ui/Button.vue'
import Input from '@/components/ui/Input.vue'
import Modal from '@/components/ui/Modal.vue'
import Badge from '@/components/ui/Badge.vue'
import type { User } from '@/types'
const toast = useToastStore()
const auth = useAuthStore()
const users = ref<User[]>([])
const total = ref(0)
const page = ref(1)
const q = ref('')
const pageSize = 15
const editOpen = ref(false)
const editing = ref<User | null>(null)
const editForm = reactive({ role: 'user', status: 'active' })
const balanceOpen = ref(false)
const balanceUser = ref<User | null>(null)
const balanceForm = reactive({ amount: 0, remark: '' })
async function load() {
try {
const { data } = await http.get(`/admin/users?page=${page.value}&page_size=${pageSize}${q.value ? '&q=' + q.value : ''}`)
users.value = data.data.items
total.value = data.data.total
} catch (e) {
toast.err(errMsg(e))
}
}
function search() {
page.value = 1
load()
}
function openEdit(u: User) {
editing.value = u
Object.assign(editForm, { role: u.role, status: u.status })
editOpen.value = true
}
async function saveEdit() {
if (!editing.value) return
try {
await http.patch(`/admin/users/${editing.value.id}`, editForm)
toast.ok('已更新')
editOpen.value = false
await load()
} catch (e) {
toast.err(errMsg(e))
}
}
function openBalance(u: User) {
balanceUser.value = u
Object.assign(balanceForm, { amount: 0, remark: '' })
balanceOpen.value = true
}
async function saveBalance() {
if (!balanceUser.value || !balanceForm.amount) return
try {
await http.post(`/admin/users/${balanceUser.value.id}/balance`, {
amount: Number(balanceForm.amount),
remark: balanceForm.remark,
})
toast.ok('余额已调整')
balanceOpen.value = false
await load()
} catch (e) {
toast.err(errMsg(e))
}
}
function goPage(p: number) {
page.value = p
load()
}
onMounted(load)
</script>
<template>
<div class="mx-auto max-w-6xl">
<div class="mb-6 flex items-center justify-between">
<div>
<h1 class="text-lg font-semibold">用户</h1>
<p class="text-sm text-zinc-500">管理角色、状态与余额</p>
</div>
<div class="flex gap-2">
<input
v-model="q"
placeholder="搜索用户名 / 邮箱"
class="h-10 w-56 rounded-md border border-zinc-700 bg-zinc-900 px-3 text-sm outline-none focus:border-accent"
@keyup.enter="search"
/>
<Button variant="ghost" @click="search">搜索</Button>
</div>
</div>
<div class="card">
<div class="overflow-x-auto">
<table class="w-full text-sm">
<thead>
<tr class="border-b border-zinc-800 text-left text-xs text-zinc-500">
<th scope="col" class="px-4 py-2.5 font-medium">ID</th>
<th scope="col" class="px-4 py-2.5 font-medium">用户名</th>
<th scope="col" class="px-4 py-2.5 font-medium">邮箱</th>
<th scope="col" class="px-4 py-2.5 font-medium">角色</th>
<th scope="col" class="px-4 py-2.5 font-medium">余额</th>
<th scope="col" class="px-4 py-2.5 font-medium">状态</th>
<th scope="col" class="px-4 py-2.5 font-medium">注册时间</th>
<th scope="col" class="px-4 py-2.5" />
</tr>
</thead>
<tbody>
<tr v-for="u in users" :key="u.id" class="table-row">
<td class="px-4 py-2.5 font-mono text-xs text-zinc-500">{{ u.id }}</td>
<td class="px-4 py-2.5 text-zinc-200">
{{ u.username }}
<span v-if="u.id === auth.user?.id" class="text-[11px] text-zinc-600">(我)</span>
</td>
<td class="px-4 py-2.5 text-xs text-zinc-400">{{ u.email }}</td>
<td class="px-4 py-2.5">
<Badge :variant="u.role === 'admin' ? 'accent' : 'neutral'">{{ u.role }}</Badge>
</td>
<td class="px-4 py-2.5 mono-num text-xs text-emerald-300/90">{{ fmtMoney(u.balance) }}</td>
<td class="px-4 py-2.5">
<Badge :variant="u.status === 'active' ? 'ok' : 'warn'">{{ u.status }}</Badge>
</td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-500">{{ fmtTime(u.created_at) }}</td>
<td class="px-4 py-2.5 text-right">
<div class="flex justify-end gap-2">
<button class="text-xs text-zinc-500 hover:text-zinc-200" @click="openEdit(u)">编辑</button>
<button class="text-xs text-zinc-500 hover:text-accent" @click="openBalance(u)">调余额</button>
</div>
</td>
</tr>
<tr v-if="users.length === 0">
<td colspan="8" class="px-4 py-10 text-center text-sm text-zinc-600">无用户</td>
</tr>
</tbody>
</table>
</div>
<div class="flex items-center justify-between border-t border-zinc-800 px-4 py-3">
<span class="font-mono text-xs text-zinc-600">共 {{ total }} 人</span>
<div class="flex gap-2">
<Button size="sm" variant="ghost" :disabled="page <= 1" @click="goPage(page - 1)">上一页</Button>
<Button size="sm" variant="ghost" :disabled="page * pageSize >= total" @click="goPage(page + 1)">下一页</Button>
</div>
</div>
</div>
<!-- 编辑用户 -->
<Modal :open="editOpen" title="编辑用户" @close="editOpen = false">
<div class="space-y-4">
<label class="block">
<span class="mb-1.5 block text-xs font-medium text-zinc-400">角色</span>
<select v-model="editForm.role" class="h-10 w-full rounded-md border border-zinc-700 bg-zinc-900 px-3 text-sm outline-none focus:border-accent">
<option value="user">user</option>
<option value="admin">admin</option>
</select>
</label>
<label class="block">
<span class="mb-1.5 block text-xs font-medium text-zinc-400">状态</span>
<select v-model="editForm.status" class="h-10 w-full rounded-md border border-zinc-700 bg-zinc-900 px-3 text-sm outline-none focus:border-accent">
<option value="active">active</option>
<option value="disabled">disabled</option>
</select>
</label>
</div>
<template #footer>
<Button variant="ghost" @click="editOpen = false">取消</Button>
<Button @click="saveEdit">保存</Button>
</template>
</Modal>
<!-- 调整余额 -->
<Modal :open="balanceOpen" :title="`调整余额 · ${balanceUser?.username}`" @close="balanceOpen = false">
<div class="space-y-4">
<p class="text-xs text-zinc-500">当前余额 {{ fmtMoney(balanceUser?.balance ?? 0) }}</p>
<Input v-model="balanceForm.amount" label="调整金额" type="number" hint="正数增加，负数扣减" />
<Input v-model="balanceForm.remark" label="备注" placeholder="可选" />
</div>
<template #footer>
<Button variant="ghost" @click="balanceOpen = false">取消</Button>
<Button @click="saveBalance">确认</Button>
</template>
</Modal>
</div>
</template>
web/src/views/console/ConsoleLayout.vue
+28 -75
View File
@@ -1,85 +1,38 @@
<script setup lang="ts">
import { useAuthStore } from '../../stores/auth'
import { useRouter } from 'vue-router'
import { computed } from 'vue'
import Toast from '../../components/ui/Toast.vue'
import { useAuthStore } from '@/stores/auth'
import ShellLayout from '@/components/layout/ShellLayout.vue'
const auth = useAuthStore()
const router = useRouter()
const nav = [
{ to: '/console/dashboard', label: '仪表盘', icon: 'M3 12l9-9 9 9M5 10v10h5v-6h4v6h5V10' },
{ to: '/console/keys', label: 'API 密钥', icon: 'M15 7a4 4 0 11-8 0 4 4 0 018 0zM3 21v-1a6 6 0 0112 0v1' },
{ to: '/console/usage', label: '用量明细', icon: 'M4 20V10M10 20V4M16 20v-7M22 20H2' },
]
const balanceFmt = computed(() => {
if (!auth.user) return '—'
return new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', minimumFractionDigits: 2, maximumFractionDigits: 4 }).format(auth.user.balance)
const sections = computed(() => {
const s: { title: string; items: { to: string; label: string }[] }[] = [
{
title: '控制台',
items: [
{ to: '/console/dashboard', label: '仪表盘' },
{ to: '/console/keys', label: 'API Keys' },
{ to: '/console/usage', label: '用量' },
],
},
]
if (auth.isAdmin) {
s.push({
title: '管理',
items: [
{ to: '/admin/overview', label: '运营总览' },
{ to: '/admin/channels', label: '渠道' },
{ to: '/admin/models', label: '模型与定价' },
{ to: '/admin/users', label: '用户' },
{ to: '/admin/config', label: '系统配置' },
],
})
}
return s
})
async function logout() {
await auth.logout()
router.push('/')
}
</script>
<template>
<div class="min-h-[100dvh] bg-ink-950 text-paper-100">
<!-- 无障碍：跳过导航 -->
<a
href="#main-content"
class="sr-only focus:not-sr-only focus:fixed focus:left-4 focus:top-4 focus:z-[70] focus:rounded-md focus:bg-signal-400 focus:px-4 focus:py-2 focus:text-sm focus:font-medium focus:text-ink-950"
>跳到主内容</a>
<!-- 侧边栏 -->
<aside aria-label="主导航" class="fixed inset-y-0 left-0 z-30 flex w-56 flex-col border-r border-ink-800 bg-ink-900/60">
<div class="flex h-16 items-center gap-2.5 border-b border-ink-800 px-5">
<span class="flex h-7 w-7 items-center justify-center rounded-md bg-signal-400" aria-hidden="true">
<svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M2 8h3l2-5 3 10 2-5h2" stroke="#0c0d0f" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg>
</span>
<span class="text-[15px] font-semibold tracking-tight" translate="no">openteam</span>
</div>
<nav class="flex-1 space-y-0.5 px-3 py-4" aria-label="控制台">
<router-link
v-for="item in nav"
:key="item.to"
:to="item.to"
class="flex items-center gap-3 rounded-md px-3 py-2 text-[13.5px] text-paper-500 transition-colors hover:bg-ink-800 hover:text-paper-100 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
active-class="bg-ink-800 text-signal-300! font-medium"
>
<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path :d="item.icon" /></svg>
{{ item.label }}
</router-link>
</nav>
<div class="border-t border-ink-800 px-3 py-4">
<div class="flex items-center justify-between rounded-md bg-ink-850 px-3 py-2.5">
<div class="min-w-0">
<p class="truncate text-[13px] font-medium text-paper-100">{{ auth.user?.username }}</p>
<p class="text-xs text-paper-600">{{ auth.isAdmin ? 'admin' : 'user' }}</p>
</div>
<span class="num text-[13px] font-medium text-mint-400" translate="no">{{ balanceFmt }}</span>
</div>
<button
class="mt-2 flex w-full touch-manipulation items-center justify-center gap-2 rounded-md px-3 py-2 text-[13px] text-paper-500 transition-colors hover:bg-ink-800 hover:text-ember-300 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none cursor-pointer"
@click="logout"
>
<svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M9 21H5a2 2 0 01-2-2V5a2 2 0 012-2h4M16 17l5-5-5-5M21 12H9" /></svg>
退出登录
</button>
</div>
</aside>
<!-- 主区域 -->
<div class="ml-56 flex-1">
<main id="main-content" class="mx-auto max-w-6xl scroll-mt-4 px-8 py-8" tabindex="-1">
<ShellLayout :sections="sections">
<router-view />
</main>
</div>
<!-- 全局通知 -->
<Toast />
</div>
</ShellLayout>
</template>
web/src/views/console/DashboardView.vue
+83 -141
View File
@@ -1,167 +1,109 @@
<script setup lang="ts">
import { ref, onMounted, computed } from 'vue'
import { use } from 'echarts/core'
import { CanvasRenderer } from 'echarts/renderers'
import { BarChart } from 'echarts/charts'
import { GridComponent, TooltipComponent } from 'echarts/components'
import VChart from 'vue-echarts'
import client, { unwrap } from '../../api/client'
import Badge from '../../components/ui/Badge.vue'
import { onMounted, ref } from 'vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import { fmtMoney, fmtNum, fmtCost, fmtTime } from '@/lib/format'
import Badge from '@/components/ui/Badge.vue'
import TrendChart from '@/components/ui/TrendChart.vue'
import type { UsageLog } from '@/types'
use([CanvasRenderer, BarChart, GridComponent, TooltipComponent])
const toast = useToastStore()
interface BalanceInfo { balance: number; spent_last_30d: number; today: { requests: number; tokens: number; cost: number }; models_available: number }
interface UsagePoint { date: string; requests: number; tokens: number; cost: number }
interface LogItem { id: number; model: string; protocol: string; input_tokens: number; output_tokens: number; cost: number; latency_ms: number; status: string; created_at: string }
const balance = ref(0)
const today = ref({ requests: 0, tokens: 0, cost: 0 })
const monthCost = ref(0)
const models = ref(0)
const trend = ref<{ label: string; value: number }[]>([])
const logs = ref<UsageLog[]>([])
const balance = ref<BalanceInfo | null>(null)
const stats = ref<UsagePoint[]>([])
const recentLogs = ref<LogItem[]>([])
const error = ref('')
const loaded = ref(false)
const usd = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' })
const usdPrecise = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', minimumFractionDigits: 6, maximumFractionDigits: 6 })
const balanceText = computed(() => (balance.value ? usd.format(balance.value.balance) : '—'))
const spent30d = computed(() => usd.format(balance.value?.spent_last_30d ?? 0))
const todayCostText = computed(() => usdPrecise.format(balance.value?.today.cost ?? 0))
const modelsCount = computed(() => balance.value?.models_available ?? '—')
const todayRequests = computed(() => balance.value?.today.requests ?? '—')
const todayTokens = computed(() => balance.value?.today.tokens ?? 0)
const chartOption = computed(() => ({
grid: { left: 8, right: 8, top: 24, bottom: 0, containLabel: true },
tooltip: {
trigger: 'axis',
backgroundColor: '#16191d',
borderColor: '#282d34',
textStyle: { color: '#eae8e3', fontSize: 12, fontFamily: 'JetBrains Mono' },
},
xAxis: {
type: 'category',
data: stats.value.map((s) => s.date.slice(5)),
axisLine: { lineStyle: { color: '#282d34' } },
axisLabel: { color: '#63686f', fontFamily: 'JetBrains Mono', fontSize: 11 },
axisTick: { show: false },
},
yAxis: {
type: 'value',
splitLine: { lineStyle: { color: '#1c2025' } },
axisLabel: { color: '#63686f', fontFamily: 'JetBrains Mono', fontSize: 11 },
},
series: [
{
name: '请求数',
type: 'bar',
data: stats.value.map((s) => s.requests),
itemStyle: { color: '#e5a13c', borderRadius: [3, 3, 0, 0] },
barMaxWidth: 22,
},
],
}))
onMounted(async () => {
async function load() {
try {
const [b, s, logs] = await Promise.all([
unwrap<BalanceInfo>(client.get('/user/balance')),
unwrap<{ items: UsagePoint[] }>(client.get('/usage/stats', { params: { group: 'day' } })),
unwrap<{ items: LogItem[] }>(client.get('/usage/logs', { params: { page_size: 8 } })),
const [b, s, l] = await Promise.all([
http.get('/user/balance'),
http.get('/usage/stats?group=day&from=' + daysAgo(13)),
http.get('/usage/logs?page_size=8'),
])
balance.value = b
stats.value = s.items ?? []
recentLogs.value = logs.items ?? []
} catch (e: any) {
error.value = e.message || '加载失败'
} finally {
loaded.value = true
const d = b.data.data
balance.value = d.balance
today.value = d.today
monthCost.value = d.spent_last_30d
models.value = d.models_available
trend.value = s.data.data.items.map((x: { date: string; cost: number }) => ({ label: x.date.slice(5), value: x.cost }))
logs.value = l.data.data.items
} catch (e) {
toast.err(errMsg(e))
}
})
}
const fmtCost = (n: number) => usd.format(n)
function daysAgo(n: number): string {
const d = new Date(Date.now() - n * 864e5)
return d.toISOString().slice(0, 10)
}
onMounted(load)
</script>
<template>
<div>
<div class="flex items-end justify-between">
<div>
<h1 class="text-xl font-semibold tracking-tight">仪表盘</h1>
<p class="mt-1 text-[13px] text-paper-500">今日与近 30 日用量总览</p>
</div>
<router-link
to="/console/keys"
class="inline-flex h-10 touch-manipulation items-center rounded-md bg-signal-400 px-4 text-sm font-medium text-ink-950 transition-colors hover:bg-signal-300 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
>新建密钥</router-link>
<div class="mx-auto max-w-5xl space-y-6">
<div class="mb-2">
<h1 class="text-lg font-semibold">仪表盘</h1>
<p class="text-sm text-zinc-500">余额、用量与最近请求</p>
</div>
<p v-if="error" class="mt-4 rounded-md border border-ember-500/40 bg-ember-500/10 px-3 py-2 text-[13px] text-ember-300" role="alert">{{ error }}</p>
<!-- 指标行 -->
<section aria-label="用量指标" class="mt-6 grid grid-cols-2 gap-3 lg:grid-cols-4">
<template v-if="!loaded">
<div v-for="i in 4" :key="i" class="rounded-lg border border-ink-700 bg-ink-900 p-4" aria-hidden="true">
<div class="h-3 w-14 animate-pulse rounded bg-ink-700" />
<div class="mt-3 h-7 w-24 animate-pulse rounded bg-ink-700" />
<div class="mt-2 h-3 w-20 animate-pulse rounded bg-ink-700" />
<!-- 指标条 -->
<div class="grid grid-cols-2 gap-3 lg:grid-cols-4">
<div class="card p-4">
<p class="text-xs text-zinc-500">余额</p>
<p class="mono-num mt-1 text-xl text-emerald-300">{{ fmtMoney(balance) }}</p>
</div>
</template>
<template v-else>
<div class="rounded-lg border border-ink-700 bg-ink-900 p-4">
<p class="text-xs text-paper-500">余额</p>
<p class="num mt-1.5 text-2xl font-semibold text-mint-400" translate="no">{{ balanceText }}</p>
<p class="num mt-1 text-[11px] text-paper-600">30 日消耗 <span translate="no">{{ spent30d }}</span></p>
<div class="card p-4">
<p class="text-xs text-zinc-500">今日请求</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(today.requests) }}</p>
</div>
<div class="rounded-lg border border-ink-700 bg-ink-900 p-4">
<p class="text-xs text-paper-500">今日请求</p>
<p class="num mt-1.5 text-2xl font-semibold">{{ todayRequests }}</p>
<p class="num mt-1 text-[11px] text-paper-600">{{ todayTokens }} tokens</p>
<div class="card p-4">
<p class="text-xs text-zinc-500">今日 Token</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(today.tokens) }}</p>
</div>
<div class="rounded-lg border border-ink-700 bg-ink-900 p-4">
<p class="text-xs text-paper-500">今日成本</p>
<p class="num mt-1.5 text-2xl font-semibold text-signal-300" translate="no">{{ todayCostText }}</p>
<p class="num mt-1 text-[11px] text-paper-600">按量计费 · USD</p>
<div class="card p-4">
<p class="text-xs text-zinc-500">近 30 日消耗</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtCost(monthCost) }}</p>
</div>
<div class="rounded-lg border border-ink-700 bg-ink-900 p-4">
<p class="text-xs text-paper-500">可用模型</p>
<p class="num mt-1.5 text-2xl font-semibold">{{ modelsCount }}</p>
<p class="mt-1 text-[11px] text-paper-600">GET /v1/models 查看</p>
</div>
</template>
</section>
<!-- 图表 + 最近请求 -->
<div class="mt-6 grid grid-cols-1 gap-3 lg:grid-cols-[1.4fr_1fr]">
<div class="rounded-lg border border-ink-700 bg-ink-900 p-4">
<div class="mb-2 flex items-center justify-between">
<h2 class="text-sm font-medium text-paper-300">近 30 日请求</h2>
<span class="font-mono text-[11px] text-paper-600" translate="no">usage/stats?group=day</span>
</div>
<VChart v-if="stats.length" class="h-56" :option="chartOption" autoresize />
<div v-else-if="loaded" class="flex h-56 items-center justify-center text-[13px] text-paper-600">暂无数据，发起第一次请求后这里会出现图表</div>
<div v-else class="h-56 animate-pulse rounded bg-ink-800" aria-hidden="true" />
</div>
<div class="rounded-lg border border-ink-700 bg-ink-900 p-4">
<div class="mb-2 flex items-center justify-between">
<h2 class="text-sm font-medium text-paper-300">最近请求</h2>
<router-link to="/console/usage" class="text-xs text-signal-300 transition-colors hover:text-signal-200">全部 →</router-link>
<div class="grid gap-6 lg:grid-cols-5">
<!-- 用量趋势 -->
<div class="card p-5 lg:col-span-3">
<div class="mb-4 flex items-baseline justify-between">
<h2 class="text-sm font-semibold">近 14 天成本</h2>
<span class="font-mono text-[11px] text-zinc-600">{{ models }} 个可用模型</span>
</div>
<div v-if="recentLogs.length" class="divide-y divide-ink-800">
<div v-for="l in recentLogs" :key="l.id" class="flex items-center justify-between gap-3 py-2.5">
<TrendChart :points="trend" :format="(v) => '$' + v.toExponential(2)" />
</div>
<!-- 最近请求 -->
<div class="card p-5 lg:col-span-2">
<div class="mb-3 flex items-baseline justify-between">
<h2 class="text-sm font-semibold">最近请求</h2>
<router-link to="/console/usage" class="text-xs text-accent hover:text-accent-strong">查看全部</router-link>
</div>
<ul class="divide-y divide-zinc-800/70">
<li v-for="l in logs" :key="l.id" class="flex items-center justify-between py-2">
<div class="min-w-0">
<p class="truncate font-mono text-[12.5px] text-paper-100" translate="no">{{ l.model }}</p>
<p class="num mt-0.5 text-[11px] text-paper-600" translate="no">{{ l.protocol }} · {{ l.input_tokens }}/{{ l.output_tokens }} tok · {{ l.latency_ms }}ms</p>
<p class="truncate font-mono text-xs text-zinc-300">{{ l.model }}</p>
<p class="text-[11px] text-zinc-600">{{ fmtTime(l.created_at) }}</p>
</div>
<div class="flex shrink-0 items-center gap-2">
<span class="num text-[12.5px] text-paper-300" translate="no">{{ fmtCost(l.cost) }}</span>
<Badge :tone="l.status === 'success' ? 'success' : 'error'" />
</div>
</div>
</div>
<div v-else-if="loaded" class="flex h-48 items-center justify-center text-[13px] text-paper-600">还没有请求记录</div>
<div v-else class="space-y-3 pt-2" aria-hidden="true">
<div v-for="i in 4" :key="i" class="h-8 animate-pulse rounded bg-ink-800" />
<div class="flex items-center gap-2">
<span class="mono-num text-xs text-zinc-400">{{ l.input_tokens }}/{{ l.output_tokens }}</span>
<span class="mono-num w-16 text-right text-xs text-zinc-500">{{ fmtCost(l.cost) }}</span>
<Badge :variant="l.status === 'success' ? 'ok' : 'err'">{{ l.status }}</Badge>
</div>
</li>
<li v-if="logs.length === 0" class="py-6 text-center text-xs text-zinc-600">
还没有请求记录，去
<router-link to="/console/keys" class="text-accent">API Keys</router-link>
创建密钥开始调用
</li>
</ul>
</div>
</div>
</div>
web/src/views/console/KeysView.vue
+95 -146
View File
@@ -1,205 +1,154 @@
<script setup lang="ts">
import { ref, onMounted, nextTick } from 'vue'
import client, { unwrap } from '../../api/client'
import Badge from '../../components/ui/Badge.vue'
import Button from '../../components/ui/Button.vue'
import Modal from '../../components/ui/Modal.vue'
import Input from '../../components/ui/Input.vue'
import { useToastStore } from '../../stores/toast'
interface APIKey {
id: number
name: string
key_prefix: string
quota_tokens_per_day: number | null
quota_requests_per_day: number | null
status: string
last_used_at: string | null
created_at: string
}
import { onMounted, ref } from 'vue'
import { PhCopy, PhCheck } from '@phosphor-icons/vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import { fmtTime } from '@/lib/format'
import Button from '@/components/ui/Button.vue'
import Input from '@/components/ui/Input.vue'
import Modal from '@/components/ui/Modal.vue'
import Badge from '@/components/ui/Badge.vue'
import type { ApiKey } from '@/types'
const toast = useToastStore()
const keys = ref<ApiKey[]>([])
const keys = ref<APIKey[]>([])
const loading = ref(false)
const error = ref('')
// 创建
const showCreate = ref(false)
const newName = ref('')
const createOpen = ref(false)
const keyName = ref('')
const creating = ref(false)
const createdKey = ref('')
const createError = ref('')
const nameInput = ref<{ focus: () => void } | null>(null)
// 吊销
const revokeTarget = ref<APIKey | null>(null)
const revoking = ref(false)
const created = ref<{ name: string; key: string; key_prefix: string } | null>(null)
const copied = ref(false)
async function load() {
loading.value = true
try {
const data = await unwrap<{ items: APIKey[] }>(client.get('/keys'))
keys.value = data.items
} catch (e: any) {
error.value = e.message || '加载失败'
} finally {
loading.value = false
const { data } = await http.get('/keys')
keys.value = data.data.items
} catch (e) {
toast.err(errMsg(e))
}
}
async function create() {
createError.value = ''
if (!newName.value.trim()) {
createError.value = '请填写密钥名称'
await nextTick()
nameInput.value?.focus()
return
}
async function createKey() {
if (!keyName.value) return
creating.value = true
try {
const data = await unwrap<{ key: string }>(client.post('/keys', { name: newName.value.trim() }))
createdKey.value = data.key
newName.value = ''
const { data } = await http.post('/keys', { name: keyName.value })
created.value = data.data
createOpen.value = false
keyName.value = ''
await load()
} catch (e: any) {
createError.value = e.response?.data?.error?.message || '创建失败'
} catch (e) {
toast.err(errMsg(e))
} finally {
creating.value = false
}
}
async function revoke() {
if (!revokeTarget.value) return
revoking.value = true
async function revoke(k: ApiKey) {
if (!confirm(`吊销密钥 ${k.name}？吊销后立即失效。`)) return
try {
await unwrap(client.delete(`/keys/${revokeTarget.value.id}`))
toast.success(`密钥 ${revokeTarget.value.key_prefix}… 已吊销`)
revokeTarget.value = null
await http.delete(`/keys/${k.id}`)
toast.ok('密钥已吊销')
await load()
} catch (e: any) {
toast.error(e.message || '吊销失败')
} finally {
revoking.value = false
} catch (e) {
toast.err(errMsg(e))
}
}
async function copyKey(text: string) {
async function copyKey() {
if (!created.value) return
try {
await navigator.clipboard.writeText(text)
await navigator.clipboard.writeText(created.value.key)
copied.value = true
setTimeout(() => (copied.value = false), 1500)
} catch {
const ta = document.createElement('textarea')
ta.value = text
ta.style.position = 'fixed'
ta.style.opacity = '0'
document.body.appendChild(ta)
ta.select()
document.execCommand('copy')
ta.remove()
toast.err('复制失败，请手动复制')
}
toast.success('密钥已复制')
}
onMounted(load)
const fmtDate = (s: string | null) =>
s ? new Intl.DateTimeFormat('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(s)) : '从未使用'
</script>
<template>
<div class="mx-auto max-w-5xl">
<div class="mb-6 flex items-center justify-between">
<div>
<div class="flex items-end justify-between">
<div>
<h1 class="text-xl font-semibold tracking-tight">API 密钥</h1>
<p class="mt-1 text-[13px] text-paper-500">密钥仅以 SHA-256 哈希存储，明文只在创建时展示一次</p>
<h1 class="text-lg font-semibold">API Keys</h1>
<p class="text-sm text-zinc-500">密钥明文仅在创建时展示一次，请立即保存</p>
</div>
<Button @click="showCreate = true">新建密钥</Button>
<Button @click="createOpen = true">新建密钥</Button>
</div>
<p v-if="error" class="mt-4 rounded-md border border-ember-500/40 bg-ember-500/10 px-3 py-2 text-[13px] text-ember-300" role="alert">{{ error }}</p>
<div class="mt-6 overflow-hidden rounded-lg border border-ink-700">
<table class="w-full text-left text-[13px]">
<caption class="sr-only">API 密钥列表</caption>
<div class="card">
<div class="overflow-x-auto">
<table class="w-full text-sm">
<thead>
<tr class="border-b border-ink-700 bg-ink-900 text-xs text-paper-500">
<th scope="col" class="px-4 py-3 font-medium">名称</th>
<th scope="col" class="px-4 py-3 font-medium">密钥前缀</th>
<th scope="col" class="px-4 py-3 font-medium">每日限额</th>
<th scope="col" class="px-4 py-3 font-medium">最近使用</th>
<th scope="col" class="px-4 py-3 font-medium">状态</th>
<th scope="col" class="px-4 py-3 text-right font-medium">操作</th>
<tr class="border-b border-zinc-800 text-left text-xs text-zinc-500">
<th scope="col" class="px-4 py-2.5 font-medium">名称</th>
<th scope="col" class="px-4 py-2.5 font-medium">前缀</th>
<th scope="col" class="px-4 py-2.5 font-medium">状态</th>
<th scope="col" class="px-4 py-2.5 font-medium">最近使用</th>
<th scope="col" class="px-4 py-2.5 font-medium">创建时间</th>
<th scope="col" class="px-4 py-2.5" />
</tr>
</thead>
<tbody class="divide-y divide-ink-800 bg-ink-900/50">
<tr v-for="k in keys" :key="k.id" class="transition-colors hover:bg-ink-850">
<td class="px-4 py-3 font-medium text-paper-100">{{ k.name }}</td>
<td class="px-4 py-3"><code class="font-mono text-[12.5px] text-signal-300" translate="no">{{ k.key_prefix }}…</code></td>
<td class="num px-4 py-3 text-paper-500" translate="no">
{{ k.quota_tokens_per_day ? `${(k.quota_tokens_per_day / 1000).toFixed(0)}k tok` : '—' }}
/ {{ k.quota_requests_per_day ? `${k.quota_requests_per_day} req` : '—' }}
<tbody>
<tr v-for="k in keys" :key="k.id" class="table-row">
<td class="px-4 py-2.5 text-zinc-200">{{ k.name }}</td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-400">{{ k.key_prefix }}…</td>
<td class="px-4 py-2.5">
<Badge :variant="k.status === 'active' ? 'ok' : 'neutral'">{{ k.status }}</Badge>
</td>
<td class="num px-4 py-3 text-paper-500" translate="no">{{ fmtDate(k.last_used_at) }}</td>
<td class="px-4 py-3"><Badge :tone="k.status" /></td>
<td class="px-4 py-3 text-right">
<td class="px-4 py-2.5 font-mono text-xs text-zinc-500">{{ fmtTime(k.last_used_at) }}</td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-500">{{ fmtTime(k.created_at) }}</td>
<td class="px-4 py-2.5 text-right">
<button
v-if="k.status === 'active'"
class="touch-manipulation text-xs text-ember-400 transition-colors hover:text-ember-300 focus-visible:ring-2 focus-visible:ring-ember-400/60 focus:outline-none cursor-pointer"
@click="revokeTarget = k"
>吊销</button>
<span v-else class="text-xs text-paper-600">已吊销</span>
class="text-xs text-zinc-500 hover:text-red-400"
@click="revoke(k)"
>
吊销
</button>
</td>
</tr>
<tr v-if="!keys.length">
<td colspan="6" class="px-4 py-12 text-center text-[13px] text-paper-600">
{{ loading ? '加载中…' : '还没有密钥 — 点击右上角「新建密钥」创建第一个' }}
<tr v-if="keys.length === 0">
<td colspan="6" class="px-4 py-10 text-center text-sm text-zinc-600">
还没有密钥，点击右上角「新建密钥」
</td>
</tr>
</tbody>
</table>
</div>
</div>
<!-- 创建模态 -->
<Modal :open="showCreate" title="新建 API 密钥" @close="showCreate = false">
<template v-if="!createdKey">
<Input
ref="nameInput"
v-model="newName"
label="密钥名称"
name="key-name"
placeholder="例如：本地开发"
hint="用于在用量明细中区分来源"
:error="createError || undefined"
autocomplete="off"
:spellcheck="false"
@keydown.enter.prevent="create"
/>
<div class="mt-5 flex justify-end gap-2">
<Button variant="ghost" @click="showCreate = false">取消</Button>
<Button :loading="creating" @click="create">创建密钥</Button>
</div>
</template>
<template v-else>
<p class="text-[13px] leading-relaxed text-paper-500">密钥已生成。出于安全考虑，<span class="text-paper-300">明文只会展示这一次</span>，请立即复制保存。</p>
<div class="mt-3 flex items-center gap-2 rounded-md border border-mint-500/40 bg-mint-400/10 px-3 py-2.5">
<code class="min-w-0 flex-1 break-all font-mono text-[12.5px] text-mint-300" translate="no">{{ createdKey }}</code>
<Button variant="outline" size="sm" @click="copyKey(createdKey)">复制</Button>
</div>
<div class="mt-5 flex justify-end">
<Button @click="showCreate = false; createdKey = ''">完成</Button>
</div>
<!-- 新建密钥 -->
<Modal :open="createOpen" title="新建密钥" @close="createOpen = false">
<Input v-model="keyName" label="密钥名称" placeholder="例如 dev / prod" @keyup.enter="createKey" />
<template #footer>
<Button variant="ghost" @click="createOpen = false">取消</Button>
<Button :loading="creating" @click="createKey">创建</Button>
</template>
</Modal>
<!-- 吊销确认 -->
<Modal :open="!!revokeTarget" title="吊销密钥" @close="revokeTarget = null">
<p class="text-[13px] leading-relaxed text-paper-500">
吊销后 <code class="font-mono text-paper-300" translate="no">{{ revokeTarget?.key_prefix }}…</code> 将立即失效，使用它的请求会返回 401。此操作不可撤销。
</p>
<div class="mt-5 flex justify-end gap-2">
<Button variant="ghost" @click="revokeTarget = null">取消</Button>
<Button variant="danger" :loading="revoking" @click="revoke">确认吊销</Button>
<!-- 一次性展示密钥 -->
<Modal :open="!!created" title="密钥已创建" @close="created = null">
<div class="space-y-4">
<p class="text-xs text-zinc-500">请复制并妥善保存，关闭后不再显示。</p>
<div class="flex items-center gap-2">
<code class="mono-num flex-1 truncate rounded-md border border-accent/40 bg-zinc-900 px-3 py-2 text-xs text-emerald-300">
{{ created?.key }}
</code>
<Button size="sm" @click="copyKey">
<PhCheck v-if="copied" :size="14" />
<PhCopy v-else :size="14" />
{{ copied ? '已复制' : '复制' }}
</Button>
</div>
</div>
<template #footer>
<Button @click="created = null">完成</Button>
</template>
</Modal>
</div>
</template>
web/src/views/console/UsageView.vue
+118 -120
View File
@@ -1,149 +1,147 @@
<script setup lang="ts">
import { ref, onMounted, computed, watch } from 'vue'
import { useRoute, useRouter } from 'vue-router'
import client, { unwrap } from '../../api/client'
import Badge from '../../components/ui/Badge.vue'
import { onMounted, ref } from 'vue'
import { http, errMsg } from '@/api/client'
import { useToastStore } from '@/stores/toast'
import { fmtNum, fmtCost, fmtTime } from '@/lib/format'
import Badge from '@/components/ui/Badge.vue'
import TrendChart from '@/components/ui/TrendChart.vue'
import type { UsageLog } from '@/types'
interface LogItem {
id: number
request_id: string
model: string
protocol: string
input_tokens: number
output_tokens: number
cache_read_tokens: number
cost: number
latency_ms: number
status: string
created_at: string
}
const route = useRoute()
const router = useRouter()
const logs = ref<LogItem[]>([])
const toast = useToastStore()
const summary = ref({ today: { requests: 0, tokens: 0, cost: 0 }, month: { requests: 0, tokens: 0, cost: 0 } })
const group = ref<'day' | 'model'>('day')
const chart = ref<{ label: string; value: number }[]>([])
const logs = ref<UsageLog[]>([])
const page = ref(1)
const total = ref(0)
const page = ref(Number(route.query.page) || 1)
const pageSize = 20
const modelFilter = ref((route.query.model as string) || '')
const models = ref<string[]>([])
const loading = ref(false)
const pages = computed(() => Math.max(1, Math.ceil(total.value / pageSize)))
const usd = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' })
const fmtDate = new Intl.DateTimeFormat('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hour12: false })
// 筛选/分页同步到 URL（可深链、可分享）
watch([page, modelFilter], () => {
router.replace({
query: {
...(modelFilter.value ? { model: modelFilter.value } : {}),
...(page.value > 1 ? { page: String(page.value) } : {}),
},
})
})
const modelFilter = ref('')
const pageSize = 15
async function load() {
loading.value = true
try {
const data = await unwrap<{ items: LogItem[]; total: number }>(
client.get('/usage/logs', { params: { page: page.value, page_size: pageSize, model: modelFilter.value || undefined } }),
)
logs.value = data.items ?? []
total.value = data.total
} catch {
// 加载失败静默，空态兜底
} finally {
loading.value = false
const [s, st, l] = await Promise.all([
http.get('/usage/summary'),
http.get(`/usage/stats?group=${group.value}`),
http.get(`/usage/logs?page=${page.value}&page_size=${pageSize}${modelFilter.value ? '&model=' + modelFilter.value : ''}`),
])
summary.value = s.data.data
const items = st.data.data.items as { date?: string; model?: string; cost: number; requests: number }[]
chart.value = items.map((x) => ({ label: (x.date || x.model || '') as string, value: x.cost }))
logs.value = l.data.data.items
total.value = l.data.data.total
} catch (e) {
toast.err(errMsg(e))
}
}
async function loadModels() {
try {
const data = await unwrap<{ items: string[] }>(client.get('/user/models'))
models.value = data.items ?? []
} catch { /* ignore */ }
function switchGroup(g: 'day' | 'model') {
group.value = g
load()
}
onMounted(() => {
function goPage(p: number) {
page.value = p
load()
loadModels()
})
}
const fmtCost = (n: number) => usd.format(n)
const fmtDateStr = (s: string) => fmtDate.format(new Date(s))
onMounted(load)
</script>
<template>
<div>
<div class="flex items-end justify-between">
<div>
<h1 class="text-xl font-semibold tracking-tight">用量明细</h1>
<p class="mt-1 text-[13px] text-paper-500">请求级记录 · 按当时价格入账</p>
</div>
<label class="flex items-center gap-2">
<span class="text-xs text-paper-600">模型</span>
<select
v-model="modelFilter"
class="h-9 touch-manipulation rounded-md border border-ink-600 bg-ink-900 px-3 text-[13px] text-paper-300 transition-colors hover:border-ink-700 focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
@change="page = 1; load()"
>
<option value="">全部模型</option>
<option v-for="m in models" :key="m" :value="m" translate="no">{{ m }}</option>
</select>
</label>
<div class="mx-auto max-w-5xl space-y-6">
<div class="mb-2">
<h1 class="text-lg font-semibold">用量</h1>
<p class="text-sm text-zinc-500">汇总、分布与请求明细</p>
</div>
<div class="mt-6 overflow-hidden rounded-lg border border-ink-700">
<table class="w-full text-left text-[13px]">
<caption class="sr-only">用量明细记录</caption>
<div class="grid grid-cols-2 gap-3 lg:grid-cols-4">
<div class="card p-4">
<p class="text-xs text-zinc-500">今日请求</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(summary.today.requests) }}</p>
</div>
<div class="card p-4">
<p class="text-xs text-zinc-500">今日 Token</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(summary.today.tokens) }}</p>
</div>
<div class="card p-4">
<p class="text-xs text-zinc-500">本月请求</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtNum(summary.month.requests) }}</p>
</div>
<div class="card p-4">
<p class="text-xs text-zinc-500">本月成本</p>
<p class="mono-num mt-1 text-xl text-zinc-100">{{ fmtCost(summary.month.cost) }}</p>
</div>
</div>
<div class="card p-5">
<div class="mb-4 flex items-center justify-between">
<h2 class="text-sm font-semibold">成本分布</h2>
<div class="flex gap-1 rounded-md border border-zinc-800 p-0.5">
<button
class="rounded px-2.5 py-1 text-xs transition"
:class="group === 'day' ? 'bg-zinc-800 text-zinc-100' : 'text-zinc-500'"
@click="switchGroup('day')"
>
按天
</button>
<button
class="rounded px-2.5 py-1 text-xs transition"
:class="group === 'model' ? 'bg-zinc-800 text-zinc-100' : 'text-zinc-500'"
@click="switchGroup('model')"
>
按模型
</button>
</div>
</div>
<TrendChart :points="chart" :format="(v) => '$' + v.toExponential(2)" />
</div>
<div class="card">
<div class="flex items-center justify-between border-b border-zinc-800 px-4 py-3">
<h2 class="text-sm font-semibold">请求明细</h2>
<input
v-model="modelFilter"
placeholder="按模型过滤"
class="h-8 w-48 rounded-md border border-zinc-700 bg-zinc-900 px-2.5 font-mono text-xs outline-none focus:border-accent"
@keyup.enter="page = 1; load()"
/>
</div>
<div class="overflow-x-auto">
<table class="w-full text-sm">
<thead>
<tr class="border-b border-ink-700 bg-ink-900 text-xs text-paper-500">
<th scope="col" class="px-4 py-3 font-medium">时间</th>
<th scope="col" class="px-4 py-3 font-medium">模型</th>
<th scope="col" class="px-4 py-3 font-medium">协议</th>
<th scope="col" class="px-4 py-3 text-right font-medium">输入 tok</th>
<th scope="col" class="px-4 py-3 text-right font-medium">输出 tok</th>
<th scope="col" class="px-4 py-3 text-right font-medium">成本</th>
<th scope="col" class="px-4 py-3 text-right font-medium">耗时</th>
<th scope="col" class="px-4 py-3 font-medium">状态</th>
<tr class="border-b border-zinc-800 text-left text-xs text-zinc-500">
<th scope="col" class="px-4 py-2.5 font-medium">模型</th>
<th scope="col" class="px-4 py-2.5 font-medium">协议</th>
<th scope="col" class="px-4 py-2.5 font-medium">Token 入/出</th>
<th scope="col" class="px-4 py-2.5 font-medium">成本</th>
<th scope="col" class="px-4 py-2.5 font-medium">耗时</th>
<th scope="col" class="px-4 py-2.5 font-medium">状态</th>
<th scope="col" class="px-4 py-2.5 font-medium">时间</th>
</tr>
</thead>
<tbody class="divide-y divide-ink-800 bg-ink-900/50">
<tr v-for="l in logs" :key="l.id" class="transition-colors hover:bg-ink-850">
<td class="num px-4 py-3 text-paper-500" translate="no">{{ fmtDateStr(l.created_at) }}</td>
<td class="px-4 py-3"><code class="font-mono text-[12.5px] text-paper-100" translate="no">{{ l.model }}</code></td>
<td class="px-4 py-3 font-mono text-[12px] text-paper-500" translate="no">{{ l.protocol }}</td>
<td class="num px-4 py-3 text-right text-paper-300" translate="no">{{ l.input_tokens }}</td>
<td class="num px-4 py-3 text-right text-paper-300" translate="no">{{ l.output_tokens }}</td>
<td class="num px-4 py-3 text-right text-signal-300" translate="no">{{ fmtCost(l.cost) }}</td>
<td class="num px-4 py-3 text-right text-paper-500" translate="no">{{ l.latency_ms }}ms</td>
<td class="px-4 py-3"><Badge :tone="l.status === 'success' ? 'success' : 'error'" /></td>
<tbody>
<tr v-for="l in logs" :key="l.id" class="table-row">
<td class="px-4 py-2.5 font-mono text-xs text-zinc-200">{{ l.model }}</td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-500">{{ l.protocol }}</td>
<td class="px-4 py-2.5 mono-num text-xs text-zinc-400">{{ l.input_tokens }}/{{ l.output_tokens }}</td>
<td class="px-4 py-2.5 mono-num text-xs text-zinc-300">{{ fmtCost(l.cost) }}</td>
<td class="px-4 py-2.5 mono-num text-xs text-zinc-500">{{ l.latency_ms }}ms</td>
<td class="px-4 py-2.5"><Badge :variant="l.status === 'success' ? 'ok' : 'err'">{{ l.status }}</Badge></td>
<td class="px-4 py-2.5 font-mono text-xs text-zinc-500">{{ fmtTime(l.created_at) }}</td>
</tr>
<tr v-if="!logs.length">
<td colspan="8" class="px-4 py-12 text-center text-[13px] text-paper-600">{{ loading ? '加载中…' : '暂无用量记录' }}</td>
<tr v-if="logs.length === 0">
<td colspan="7" class="px-4 py-10 text-center text-sm text-zinc-600">暂无请求记录</td>
</tr>
</tbody>
</table>
</div>
<div class="mt-4 flex items-center justify-between">
<p class="num text-xs text-paper-600">共 {{ total }} 条</p>
<nav aria-label="分页" class="flex items-center gap-1.5">
<button
class="touch-manipulation rounded-md border border-ink-600 px-3 py-1.5 text-xs text-paper-300 transition-colors hover:border-signal-400 disabled:opacity-40 cursor-pointer disabled:cursor-default focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
:disabled="page <= 1"
:aria-label="`上一页，当前第 ${page} 页`"
@click="page--; load()"
>上一页</button>
<span class="num px-2 text-xs text-paper-500" aria-current="page">第 {{ page }} / {{ pages }} 页</span>
<button
class="touch-manipulation rounded-md border border-ink-600 px-3 py-1.5 text-xs text-paper-300 transition-colors hover:border-signal-400 disabled:opacity-40 cursor-pointer disabled:cursor-default focus-visible:ring-2 focus-visible:ring-signal-400/60 focus:outline-none"
:disabled="page >= pages"
:aria-label="`下一页，当前第 ${page} 页`"
@click="page++; load()"
>下一页</button>
</nav>
<div class="flex items-center justify-between border-t border-zinc-800 px-4 py-3">
<span class="font-mono text-xs text-zinc-600">共 {{ total }} 条</span>
<div class="flex gap-2">
<Button size="sm" variant="ghost" :disabled="page <= 1" @click="goPage(page - 1)">上一页</Button>
<Button size="sm" variant="ghost" :disabled="page * pageSize >= total" @click="goPage(page + 1)">下一页</Button>
</div>
</div>
</div>
</div>
</template>
web/src/vite-env.d.ts
Vendored
+6
View File
@@ -1 +1,7 @@
/// <reference types="vite/client" />
declare module '*.vue' {
import type { DefineComponent } from 'vue'
const component: DefineComponent<object, object, unknown>
export default component
}
web/tsconfig.app.json
+17 -8
View File
@@ -1,15 +1,24 @@
{
"extends": "@vue/tsconfig/tsconfig.dom.json",
"compilerOptions": {
"target": "ES2022",
"useDefineForClassFields": true,
"module": "ESNext",
"lib": ["ES2022", "DOM", "DOM.Iterable"],
"skipLibCheck": true,
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"composite": true,
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
"types": ["vite/client"],
"allowArbitraryExtensions": true,
/* Linting */
"jsx": "preserve",
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"erasableSyntaxOnly": true,
"noFallthroughCasesInSwitch": true
"noFallthroughCasesInSwitch": true,
"baseUrl": ".",
"paths": { "@/*": ["./src/*"] }
},
"include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"]
"include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.vue"]
}
web/tsconfig.node.json
+8 -17
View File
@@ -1,23 +1,14 @@
{
"compilerOptions": {
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
"target": "es2023",
"lib": ["ES2023"],
"types": ["node"],
"skipLibCheck": true,
/* Bundler mode */
"module": "nodenext",
"allowImportingTsExtensions": true,
"verbatimModuleSyntax": true,
"moduleDetection": "force",
"composite": true,
"noEmit": true,
/* Linting */
"noUnusedLocals": true,
"noUnusedParameters": true,
"erasableSyntaxOnly": true,
"noFallthroughCasesInSwitch": true
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
"skipLibCheck": true,
"module": "ESNext",
"moduleResolution": "bundler",
"allowSyntheticDefaultImports": true,
"strict": true,
"types": ["node"]
},
"include": ["vite.config.ts"]
}
web/vite.config.ts
+8 -4
View File
@@ -1,16 +1,20 @@
import { fileURLToPath, URL } from 'node:url'
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import tailwindcss from '@tailwindcss/vite'
// https://vite.dev/config/
export default defineConfig({
plugins: [vue(), tailwindcss()],
resolve: {
alias: {
'@': fileURLToPath(new URL('./src', import.meta.url)),
},
},
server: {
port: 5173,
proxy: {
// 开发代理到 Go API
'/api': 'http://localhost:8080',
'/v1': 'http://localhost:8080',
'/api': { target: 'http://localhost:8080', changeOrigin: true },
'/v1': { target: 'http://localhost:8080', changeOrigin: true },
},
},
})