commit 84c66ccaa7893d1195b355c9cc400212d2ea9914
Author: Echo <1711788888@qq.com>
Date:   Thu Mar 5 21:28:41 2026 +0800

    :art: 增加并发访问

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..311d8d5
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,54 @@
+# Rust build artifacts
+target/
+Cargo.lock
+
+# Node.js dependencies and build artifacts
+admin-ui/node_modules/
+admin-ui/dist/
+admin-ui/pnpm-lock.yaml
+admin-ui/tsconfig.tsbuildinfo
+admin-ui/.vite/
+
+# Version control
+.git/
+.gitignore
+
+# IDE and editor files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Claude/AI
+.claude/
+CLAUDE.md
+AGENTS.md
+
+# CI/CD
+.github/
+
+# Documentation and examples
+*.md
+README.md
+config.example.json
+credentials.example.*.json
+
+# Development and test files
+src/test.rs
+src/debug.rs
+test.json
+tools/
+
+# OS-specific files
+.DS_Store
+Thumbs.db
+
+# Local configuration (keep templates only)
+config.json
+credentials.json
+
+# Docker files
+Dockerfile
+.dockerignore
+docker-compose*.yml
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..38f37c3
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,34 @@
+/target
+
+/config.json
+/credentials.json
+/.idea
+/test.json
+
+/admin-ui/node_modules/
+/admin-ui/dist/
+/admin-ui/pnpm-lock.yaml
+/admin-ui/package-lock.json
+/admin-ui/tsconfig.tsbuildinfo
+
+.claude/
+!.claude/skills/
+
+/credentials.*
+
+*.json
+logs/
+data/
+
+/kiro_balance_cache.json
+/kiro_stats.json
+
+refs/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+config/
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..41ea9f0
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,779 @@
+# Changelog
+
+## [v1.1.5] - 2026-03-02
+
+### Fixed
+- **防止孤立 tool_result 导致空消息** — `convert_user_message` 新增最终兜底逻辑，当 tool_result 被过滤为孤立块后 content 变空时插入占位符 "."，避免上游返回 400 "Improperly formed request"；新增回归测试覆盖孤立 tool_result 场景 (`src/anthropic/converter.rs`)
+
+## [v1.1.4] - 2026-03-02
+
+### Fixed
+- **WebSearch 历史消息上下文保留** — `convert_assistant_message` 新增对 `server_tool_use`（忽略）和 `web_search_tool_result`（提取 title、url、snippet、page_age 为纯文本）的处理，修复多轮对话中搜索结果被静默丢弃导致 Kiro 丢失上下文的问题；使用纯文本格式彻底规避特殊字符破坏格式的风险；新增 2 个单元测试覆盖上述路径 (`src/anthropic/converter.rs`)
+
+## [v1.1.3] - 2026-02-27
+
+### Changed
+- **合并三个导入对话框为一个** — 删除冗余的 `KamImportDialog` 和 `BatchImportDialog`，统一使用 `ImportTokenJsonDialog`，自动识别 KAM 嵌套格式、扁平凭据格式和 Token JSON 格式 (`admin-ui/src/components/`)
+- **上游网络错误归类为瞬态错误** — `error sending request`/`connection closed`/`connection reset` 纳入 `is_transient_upstream_error`，返回 502 且不输出请求体 (`src/anthropic/handlers.rs`)
+- **上游报错不再输出完整请求体** — `sensitive-logs` 模式下仅输出请求体字节数 (`src/anthropic/handlers.rs`)
+- **瞬态错误匹配大小写归一化** — `is_transient_upstream_error` 统一 `.to_lowercase()` 后匹配，提取 `NETWORK_ERROR_PATTERNS` 常量消除重复 (`src/anthropic/handlers.rs`)
+
+### Removed
+- **移除负载均衡模式切换** — 删除前端按钮/API/hooks 和后端路由/handler/service/types/config 字段/token_manager 方法及测试，该设置实际未被使用 (`admin-ui/`, `src/admin/`, `src/kiro/token_manager.rs`, `src/model/config.rs`)
+
+### Added
+- **Usage 诊断日志** — 流式/缓冲流式/非流式三条路径均增加 `sensitive-logs` 保护的 usage 日志，输出 estimated/context/final input_tokens 及来源、output_tokens (`src/anthropic/stream.rs`, `src/anthropic/handlers.rs`)
+
+## [v1.1.2] - 2026-02-27
+
+### Added
+- **Kiro Account Manager 导入** — 支持导入 KAM 导出的 JSON 凭据文件 (`admin-ui/src/components/kam-import-dialog.tsx`)
+- **批量导入对话框** — 新增独立的批量导入凭据组件 (`admin-ui/src/components/batch-import-dialog.tsx`)
+- **凭证 disabled 字段持久化** — 从配置文件读取 disabled 状态，支持手动禁用凭据跨重启保留 (`src/kiro/model/credentials.rs`, `src/kiro/token_manager.rs`)
+- **凭据级 Region 编辑** — Admin UI 支持对已有凭据在线修改 `region` 和 `apiRegion`，点击凭据卡片内联编辑，保存后持久化 (`src/admin/`, `admin-ui/src/components/credential-card.tsx`)
+- **Admin API `POST /credentials/:id/region`** — 新增 Region 修改接口，支持清除（传 null）或覆盖两个 region 字段 (`src/admin/handlers.rs`, `src/admin/router.rs`)
+
+### Fixed
+- **WebSearch SSE 事件序列修正** — 调整 server_tool_use 位置、content block index、page_age 转换、usage 统计 (`src/anthropic/websearch.rs`)
+- **Token Manager 统计回写** — 立即回写统计数据，清除已删除凭据残留 (`src/kiro/token_manager.rs`)
+- **HTTP 非安全地址批量导入** — 修复 admin-ui 在 HTTP 下的导入错误 (`admin-ui/src/lib/utils.ts`)
+- **Docker 端口绑定优化** — 修正端口绑定和配置目录挂载 (`docker-compose.yml`)
+- **移除重复 Sonnet 4.6 模型项** — 删除 `/v1/models` 中重复的 claude-sonnet-4-6 条目，避免 id 冲突 (`src/anthropic/handlers.rs`)
+- **防止自动禁用状态被持久化** — `persist_credentials()` 仅持久化手动禁用，避免重启后自动禁用变为手动禁用导致无法自愈 (`src/kiro/token_manager.rs`)
+- **sha256Hex digest 异常回退** — 在 `crypto.subtle.digest` 外围加 try/catch，失败时回退到纯 JS 实现 (`admin-ui/src/lib/utils.ts`)
+- **parseKamJson null 输入保护** — 对 JSON null 输入增加类型检查，避免 TypeError (`admin-ui/src/components/kam-import-dialog.tsx`)
+- **额度查询 region 修复** — `get_usage_limits` 改用 `effective_api_region`，凭据指定 region 时不再因走错 endpoint 而 403 (`src/kiro/token_manager.rs`)
+- **批量导入丢失 apiRegion** — `TokenJsonItem` 补充 `api_region` 字段，导入 JSON 中的 `apiRegion` 不再被丢弃 (`src/admin/types.rs`, `src/admin/service.rs`)
+- **API 请求使用凭据级 region** — `provider.rs` 的 `base_url`/`mcp_url`/`base_domain` 改用 `credentials.effective_api_region()`，凭据配置了 region 时不再错误地走全局 config region 导致 403 (`src/kiro/provider.rs`)
+- **Region 编辑 stale state** — 点击编辑 Region 时同步最新 props 到 input，避免后台刷新后提交旧值覆盖服务端数据 (`admin-ui/src/components/credential-card.tsx`)
+- **Region 值未 trim** — `set_region` 保存前对 region/apiRegion 做 trim，防止带空格的值持久化后生成无效 URL (`src/admin/service.rs`)
+- **过滤超长工具名** — `convert_tools` 过滤掉 name 超过 64 字符的工具，避免上游拒绝整个请求 (`src/anthropic/converter.rs`)
+- **429 错误不再输出完整请求体** — 瞬态上游错误（429/5xx）走独立分支返回 429，不触发 sensitive-logs 的请求体诊断日志 (`src/anthropic/handlers.rs`)
+- **兼容旧 authRegion 配置** — `credentials.region` 增加 `#[serde(alias = "authRegion")]`，旧配置文件中的 `authRegion` 字段不再被静默忽略 (`src/kiro/model/credentials.rs`)
+- **导入凭据 region 规范化** — token.json 导入路径对 region/apiRegion 做 trim + 空字符串转 None，与 `set_region` 逻辑一致 (`src/admin/service.rs`)
+
+### Changed
+- **默认 kiro_version 更新至 0.10.0** (`src/model/config.rs`)
+- **Opus 模型映射调整** — opus 默认映射到 claude-opus-4.6，仅 4.5/4-5 显式映射到 claude-opus-4.5 (`src/anthropic/converter.rs`)
+- **Sonnet 4.6 Model 字段补全** — 添加 context_length、max_completion_tokens、thinking 字段 (`src/anthropic/handlers.rs`)
+- **Region 配置精简** — 删除 `credentials.auth_region` 和 `config.auth_region` 冗余字段；凭据的 `region` 同时用于 Token 刷新和 API 请求默认值，`api_region` 可单独覆盖 API 路由 (`src/kiro/model/credentials.rs`, `src/model/config.rs`)
+- **添加凭据 UI Region 字段语义调整** — 前端"Auth Region"改为"Region"（对应 `credentials.region`），"API Region"保持，去除无意义的 `authRegion` 前端字段 (`admin-ui/`)
+
+## [v1.1.1] - 2026-02-18
+
+### Fixed
+- **修复 Sonnet 4.6 thinking 配置变量名错误** (`src/anthropic/handlers.rs`)
+  - 修正 thinking 配置覆写逻辑中的变量名拼写错误
+
+## [v1.1.0] - 2026-02-18
+
+### Added
+- **Sonnet 4.6 模型支持** (`src/anthropic/handlers.rs`, `src/anthropic/converter.rs`, `src/anthropic/types.rs`)
+  - 添加 claude-sonnet-4-6 及其 thinking/agentic 变体到模型列表
+  - 更新模型映射逻辑以正确识别 Sonnet 4.6 版本
+  - 为 Sonnet 4.6 启用 1M 上下文窗口和 64K 最大输出 tokens
+  - 更新 thinking 配置覆写逻辑以支持 Sonnet 4.6 的 adaptive thinking
+
+## [v1.0.21] - 2026-02-17
+
+### Changed
+- **图片处理限制放宽** (`src/model/config.rs`)
+  - 单图总像素限制从 1.15M 放宽至 4M，支持更高分辨率图片直接透传
+  - 图片长边限制从 1568 放宽至 4000，减少不必要的缩放压缩
+
+## [v1.0.20] - 2026-02-17
+
+### Fixed
+- **空消息内容验证与错误分类改进** (`src/anthropic/converter.rs`, `src/anthropic/handlers.rs`)
+  - 新增 `ConversionError::EmptyMessageContent` 错误类型，在请求转换阶段验证消息内容不为空
+  - 在 prefill 处理后验证最后一条消息内容有效性，支持字符串和数组两种 content 格式
+  - 检测空字符串、空白字符、空数组等情况，避免向上游发送无效请求
+  - 修复 `is_input_too_long_error` 错误地将 "Improperly formed request" 归类为上下文过长错误
+  - 新增 `is_improperly_formed_request_error` 函数专门处理格式错误，返回准确的错误信息
+  - 新增 3 个测试用例验证空消息内容检测功能
+- **图片文件大小压缩优化** (`src/image.rs`)
+  - 新增基于文件大小的强制重新编码逻辑：即使图片尺寸符合要求，如果文件大小超过 200KB 也会重新编码降低质量
+  - 修复小尺寸高质量图片（如 483x480 但 631KB）直接透传导致请求体过大的问题
+  - 新增日志输出追踪大文件重新编码过程和压缩率
+
+## [v1.0.19] - 2026-02-17
+
+### Changed
+- **自适应压缩策略优化** (`src/anthropic/handlers.rs`)
+  - 请求体大小校验改为以实际序列化后的总字节数为准，不再扣除图片 base64 字节（上游存在约 5MiB 的硬性请求体大小限制，图片也必须计入）
+  - 压缩层级重排：当单条 user content 已超过阈值时优先截断超长消息（第三层），再移除历史消息（第四层），避免移除历史后仍无法降到阈值内
+  - 新增 `has_any_tool_results_or_tools` / `has_any_tool_uses` 预检，跳过无效的 tool 阈值降低迭代
+  - 历史消息移除改为批量 drain（单轮最多 16 条），提升大上下文场景的压缩效率
+- **请求体大小阈值默认上调至 4.5MiB** (`src/model/config.rs`, `config.example.json`)
+  - `compression.maxRequestBodyBytes` 从 400KB 上调至 4,718,592 字节（4.5MiB），匹配上游实际限制
+
+### Fixed
+- **cargo fmt 格式化** (`src/anthropic/converter.rs`, `src/image.rs`)
+
+## [v1.0.18] - 2026-02-17
+
+### Added
+- **GIF 动图抽帧采样与强制重编码** (`src/image.rs`, `src/anthropic/converter.rs`)
+  - 新增 `process_gif_frames()` 函数，将 GIF 动图抽帧为多张静态 JPEG，避免动图 base64 体积巨大导致 upstream 400 错误
+  - 采样策略：总帧数不超过 20 帧，每秒最多 5 帧，超长 GIF 自动降低采样频率均匀抽取
+  - 新增 `process_image_to_format()` 函数，支持将任意图片强制重编码为指定格式
+  - GIF 抽帧失败时多级回退：JPEG 重编码 → 静态 GIF 处理 → 原始数据透传
+  - `process_image()` 对 GIF 格式强制重编码为静态帧，即使无需缩放也避免透传体积巨大的动图
+  - `ImageProcessResult` 新增 `was_reencoded`、`original_bytes_len`、`final_bytes_len` 字段
+
+### Changed
+- **请求体大小阈值默认上调** (`src/model/config.rs`, `config.example.json`)
+  - 上游存在请求体大小硬限制（实测约 5MiB 左右会触发 400），默认将 `compression.maxRequestBodyBytes` 上调至 4.5MiB 预留安全余量
+- **日志分析脚本同步更新** (`tools/analyze_compression.py`, `tools/diagnose_improper_request.py`)
+  - 修复 ANSI 序列污染解析，并增加“自适应二次压缩/本地超限拒绝”的统计输出
+
+## [v1.0.17] - 2026-02-15
+
+### Added
+- **自适应压缩第四层：超长用户消息内容截断** (`src/anthropic/compressor.rs`, `src/anthropic/handlers.rs`)
+  - 新增 `compress_long_messages_pass()` 函数，截断超长的 User 消息 content（保留头部，尾部附加省略标记）
+  - 在 `adaptive_shrink_request_body` 的三层策略之后增加第四层兜底，解决单条消息过大（如粘贴整个文件）导致自适应压缩空转的问题
+  - 动态计算截断阈值：初始为最大消息字符数的 3/4，每轮递减 3/4，最低 8192 字符
+  - 日志新增 `final_message_content_max_chars` 字段便于排查
+
+## [v1.0.16] - 2026-02-15
+
+### Fixed
+- **请求体日志仅在 upstream 报错时输出完整内容** (`src/anthropic/handlers.rs`)
+  - 移除发送前的完整请求体 DEBUG 日志（`sensitive-logs` 模式下每次请求都输出几十 KB JSON），统一只输出字节大小
+  - upstream 报错时在 `sensitive-logs` 模式下以 ERROR 级别输出完整请求体（截断 base64），用于诊断 400/502 等错误
+
+## [v1.0.15] - 2026-02-15
+
+### Added
+- **Opus 4.6 1M 上下文窗口支持** (`src/anthropic/types.rs`, `src/anthropic/handlers.rs`, `src/anthropic/stream.rs`)
+  - 新增 `get_context_window_size()` 函数，Opus 4.6 返回 1,000,000 tokens，其他模型返回 200,000 tokens
+  - 删除硬编码 `CONTEXT_WINDOW_SIZE` 常量，改用动态计算
+  - `MAX_BUDGET_TOKENS` 从 24,576 提升到 128,000
+  - `Model` 结构体新增 `context_length`、`max_completion_tokens`、`thinking` 字段
+- **Agentic 模型变体** (`src/anthropic/converter.rs`, `src/anthropic/handlers.rs`)
+  - 新增 sonnet-agentic、opus-4.5-agentic、opus-4.6-agentic、haiku-agentic 四个模型变体
+  - `map_model()` 自动剥离 `-agentic` 后缀再映射
+  - Agentic 模型注入专用系统提示，引导自主工作模式
+- **Thinking level 后缀** (`src/anthropic/handlers.rs`)
+  - 支持 `-thinking-minimal`(512)、`-thinking-low`(1024)、`-thinking-medium`(8192)、`-thinking-high`(24576)、`-thinking-xhigh`(32768) 后缀
+- **工具压缩** (`src/anthropic/tool_compression.rs` 新建)
+  - 20KB 阈值两步压缩：简化 input_schema → 按比例截断 description（最短 50 字符）
+- **截断检测** (`src/anthropic/truncation.rs` 新建)
+  - 4 种截断类型的启发式检测（空输入、无效 JSON、缺少字段、未闭合字符串）
+  - 工具 JSON 解析失败时自动检测截断并生成软失败消息
+
+### Changed
+- 工具调用仅含 tool_use 时占位符从 `" "` 改为 `"."`，提升语义清晰度
+
+## [v1.0.14] - 2026-02-15
+
+### Fixed
+- **sensitive-logs 模式下请求体日志截断** (`src/kiro/provider.rs`, `src/anthropic/handlers.rs`)
+  - 400 错误日志中的 `request_body` 字段改用 `truncate_body_for_log()` 截断（保留头尾各 1200 字符），避免输出包含大量 base64 图片数据的完整请求体
+  - 工具输入 JSON 解析失败日志中的 `request_body` 字段改用 `truncate_middle()` 截断
+  - 新增 `KiroProvider::truncate_body_for_log()` 函数，正确处理 UTF-8 多字节字符边界
+
+## [v1.0.13] - 2026-02-14
+
+### Fixed
+- **请求体大小预检输出 image_bytes 归因信息** (`src/anthropic/handlers.rs`)
+  - 新增 `total_image_bytes()` 函数，计算 KiroRequest 中所有图片 base64 数据的总字节数
+  - 错误提示信息增加 image_bytes 和 non-image bytes 字段，便于排查请求体大小归因
+
+## [v1.0.12] - 2026-02-14
+
+### Fixed
+- **WebSearch 仅纯搜索请求走本地处理** (`src/anthropic/websearch.rs`, `src/anthropic/handlers.rs`)
+  - 新增 `should_handle_websearch_request()` 精确判断：仅当 tool_choice 强制选择 web_search、tools 仅含 web_search 单工具、或用户消息包含 `Perform a web search for the query:` 前缀时，才路由到本地 WebSearch 处理
+  - 混合工具场景（web_search + 其他工具）改为剔除 web_search 后转发 upstream，避免普通对话被误当成搜索查询
+  - 新增 `strip_web_search_tools()` 从 tools 列表中移除 web_search 工具
+  - 搜索查询提取增加空白归一化处理
+
+## [v1.0.11] - 2026-02-14
+
+### Added
+- **自适应二次压缩策略** (`src/anthropic/handlers.rs`)
+  - 请求体超过 `max_request_body_bytes` 阈值时，自动迭代压缩：逐步降低 tool_result/tool_use_input 截断阈值，最后按轮移除最老历史消息
+  - 最多迭代 32 轮，避免极端输入导致过长 CPU 消耗
+  - `post_messages` 和 `post_messages_cc` 均支持自适应压缩
+- **压缩后 tool_use/tool_result 配对修复** (`src/anthropic/compressor.rs`)
+  - 新增 `repair_tool_pairing_pass()`：历史截断后自动移除孤立的 tool_use 和 tool_result
+  - 解决截断破坏跨消息 tool_use→tool_result 配对导致 upstream 返回 400 "Improperly formed request" 的问题
+- **stable 版 `floor_char_boundary` 工具函数** (`src/common/utf8.rs`)
+  - 新增 `common::utf8` 模块，提供 stable Rust 下的 `floor_char_boundary()` 实现
+  - 统一替换项目中散落的 `str::floor_char_boundary()` nightly 调用
+
+### Fixed
+- **WebSearch 支持混合工具列表** (`src/anthropic/websearch.rs`)
+  - `has_web_search_tool()` 改为只要 tools 中包含 web_search（按 name 或 type 判断）即走本地处理，不再要求 tools 仅有一个
+  - `extract_search_query()` 改为取最后一条 user 消息，更符合多轮对话场景
+  - 新增非流式（`stream: false`）响应支持，返回完整 JSON 而非 SSE 流
+
+### Changed
+- **迁移 `floor_char_boundary` 调用到 `common::utf8` 模块** (`src/anthropic/compressor.rs`, `src/anthropic/stream.rs`, `src/admin/service.rs`, `src/kiro/token_manager.rs`, `src/kiro/provider.rs`)
+  - 移除各文件中重复的 `floor_char_boundary` 内联实现，统一使用 `crate::common::utf8::floor_char_boundary`
+
+## [v1.0.10] - 2026-02-12
+
+### Fixed
+- **配额耗尽返回 429 而非 502** (`src/anthropic/handlers.rs`, `src/kiro/provider.rs`)
+  - 所有凭据配额耗尽时返回 `429 Too Many Requests`（`rate_limit_error`），而非 `502 Bad Gateway`
+  - 余额刷新时主动禁用低余额凭据（余额 < 1.0），402 分支同步清零余额缓存
+- **亲和性检查不再触发限流** (`src/kiro/token_manager.rs`)
+  - 亲和性检查改用 `check_rate_limit` 只读探测，消除"检查本身消耗速率配额"的恶性循环
+  - 亲和性分流日志提升至 info 级别并脱敏 user_id，便于生产监控热点凭据
+
+### Added
+- **请求体大小预检** (`src/anthropic/handlers.rs`, `src/model/config.rs`)
+  - 新增 `max_request_body_bytes` 配置项，序列化后拦截超大请求避免无效 upstream 往返
+
+### Changed
+- **移除无意义的 max_tokens 调整逻辑** (`src/anthropic/handlers.rs`)
+  - 删除 max_tokens 超限警告日志和调整逻辑，因为该值实际不传递给 Kiro upstream
+
+## [v1.0.9] - 2026-02-12
+
+### Fixed
+- **修复 upstream 合并丢失的功能** (`src/anthropic/stream.rs`)
+  - 恢复 `stop_reason` 优先级逻辑：高优先级原因可覆盖低优先级（model_context_window_exceeded > max_tokens > tool_use > end_turn）
+  - 注释掉重复的 `content_block_start` 日志，避免日志噪音
+  - 修复 `contextUsageEvent` 日志格式（保留4位小数）
+  - 移除冗余的 `find_char_boundary` 函数，改用标准库 `str::floor_char_boundary()`
+
+## [v1.0.8] - 2026-02-12
+
+### Added
+- **批量导入 token.json** (`src/admin/service.rs`, `src/admin/types.rs`)
+  - 新增 `import_token_json` 接口，支持批量导入官方 token.json 格式凭据
+  - 自动映射 provider/authMethod 字段，支持 dry-run 预览模式
+  - 去重检测：通过 refreshToken 前缀匹配避免重复导入
+
+- **缓存余额查询接口** (`src/admin/handlers.rs`, `src/admin/router.rs`)
+  - 新增 `GET /admin/credentials/balances/cached` 端点
+  - 返回所有凭据的缓存余额信息（含 TTL 和缓存时间）
+
+### Changed
+- **用户亲和性支持** (`src/kiro/token_manager.rs`, `src/kiro/provider.rs`)
+  - 新增 `UserAffinityManager`：用户与凭据绑定，保持会话连续性
+  - `acquire_context_for_user` 方法支持按 user_id 获取绑定凭据
+  - 亲和性过期时间可配置，默认 30 分钟
+
+- **余额缓存动态 TTL** (`src/kiro/token_manager.rs`)
+  - 基于使用频率动态调整缓存 TTL（高频用户更短 TTL）
+  - 新增 `update_balance_cache`、`get_all_cached_balances` 方法
+  - 缓存持久化到 `kiro_balance_cache.json`
+
+- **请求压缩管道** (`src/anthropic/converter.rs`, `src/anthropic/middleware.rs`)
+  - `AppState` 新增 `compression_config` 字段
+  - `convert_request` 支持 `CompressionConfig` 参数
+  - 图片压缩、空白压缩、上下文截断等功能集成
+
+- **凭据级代理配置** (`src/kiro/provider.rs`)
+  - KiroProvider 支持按凭据动态选择代理
+  - 新增 `get_client_for_credential` 方法，缓存凭据级 client
+  - API 请求和 MCP 请求均使用凭据的 `effective_proxy()`
+
+- **API Region 分离** (`src/kiro/provider.rs`)
+  - `base_url`、`mcp_url`、`base_domain` 使用 `effective_api_region()`
+  - 支持 Token 刷新和 API 调用使用不同 region
+
+- **handlers 传递 user_id** (`src/anthropic/handlers.rs`)
+  - 从请求 metadata 提取 user_id 并传递给 provider
+  - 支持用户亲和性功能
+
+### Fixed
+- **修复 mask_user_id UTF-8 panic** (`src/anthropic/handlers.rs`)
+  - 使用 `chars()` 按字符而非字节切片，避免多字节字符导致 panic
+
+## [v1.0.7] - 2026-02-10
+
+### Added
+- **图片 Token 估算与压缩模块** (`src/image.rs`)
+  - 新增 `estimate_image_tokens()`: 从 base64 数据解析图片尺寸并估算 token 数
+  - 新增 `process_image()`: 根据配置对大图进行缩放压缩
+  - 实现 Anthropic 官方公式: `tokens = (width × height) / 750`
+  - 支持 JPEG/PNG/GIF/WebP 格式
+
+### Changed
+- **Token 计算支持图片** (`src/token.rs`)
+  - `count_all_tokens_local()` 现在处理 `type: "image"` 的 ContentBlock
+  - 调用 `estimate_image_tokens()` 计算图片 token，解决之前图片 token 被计为 0 的问题
+- **协议转换支持图片压缩** (`src/anthropic/converter.rs`)
+  - `process_message_content()` 新增图片压缩处理，根据配置自动缩放超限图片
+  - 新增 `count_images_in_request()` 统计请求中图片总数，用于判断多图模式
+  - 缩放后记录日志: `图片已缩放: (原始尺寸) -> (缩放后尺寸), tokens: xxx`
+- **压缩配置新增图片参数** (`src/model/config.rs`)
+  - `image_max_long_edge`: 长边最大像素，默认 1568（Anthropic 推荐值）
+  - `image_max_pixels_single`: 单张图片最大总像素，默认 1,150,000（约 1600 tokens）
+  - `image_max_pixels_multi`: 多图模式下单张最大像素，默认 4,000,000（2000×2000）
+  - `image_multi_threshold`: 触发多图限制的图片数量阈值，默认 20
+
+### Dependencies
+- 新增 `image` crate (0.25): 图片处理（支持 JPEG/PNG/GIF/WebP）
+- 新增 `base64` crate (0.22): Base64 编解码
+
+## [v1.0.6] - 2026-02-10
+
+### Changed
+- **压缩统计日志改用字节单位** (`src/anthropic/handlers.rs`)
+  - 移除不准确的 token 估算（`compressed_input_tokens`、`tokens_saved`），改为直接输出字节数
+  - 字段重命名：`whitespace_saved` → `whitespace_bytes_saved` 等，明确单位语义
+  - 注释更新：说明字节统计用于排查 upstream 请求体大小限制
+
+### Added
+- **日志脱敏工具模块** (`src/common/redact.rs`)
+  - `redact_opt_string`: Option<String> 脱敏为存在性表示
+  - `mask_email`: 邮箱脱敏（保留首字符）
+  - `mask_aws_account_id_in_arn`: AWS ARN 中 account id 脱敏
+  - `mask_url_userinfo`: URL userinfo 脱敏
+  - `mask_user_agent_machine_id`: User-Agent 中 machine_id 脱敏
+
+## [v1.0.5] - 2026-02-09
+
+### Changed
+- **请求日志输出压缩前后 token 估算** (`src/anthropic/converter.rs`, `src/anthropic/handlers.rs`)
+  - `ConversionResult` 新增 `compression_stats` 字段，将压缩统计从 converter 内部返回给调用方
+  - `post_messages` / `post_messages_cc` 在 `convert_request()` 之前估算 input tokens，`Received` 日志追加 `estimated_input_tokens`
+  - 压缩完成后输出 token 对比日志：`estimated_input_tokens`、`compressed_input_tokens`、`tokens_saved` 及各项压缩明细
+  - WebSearch 分支复用已有估算值，消除重复的 `count_all_tokens` 调用
+- **`count_all_tokens` 改为接受借用** (`src/token.rs`)
+  - 参数从按值传递改为引用（`&str`、`&[Message]`、`&Option<Vec<T>>`），消除 handlers 中的深拷贝开销
+- **历史截断统计增加字节数** (`src/anthropic/compressor.rs`)
+  - `CompressionStats` 新增 `history_bytes_saved` 字段，`total_saved()` 包含历史截断字节数
+  - `compress_history_pass` 返回 `(turns_removed, bytes_saved)` 元组，token 估算准确计入历史截断
+
+## [v1.0.4] - 2026-02-09
+
+### Changed
+- **Docker 构建优化**: 引入 `cargo-chef` 实现依赖层缓存，大幅加速重复构建
+  - 新增 `planner` 阶段生成依赖 recipe，`builder` 阶段先编译依赖再编译源码
+  - Docker 层缓存使得仅源码变更时无需重新编译所有依赖
+- **GitHub Actions Docker 构建缓存**: 启用 GHA 缓存（`cache-from/cache-to: type=gha`）
+- **Cargo.toml 优化**:
+  - `lto` 从 `true`（fat LTO）改为 `"thin"`，加快编译速度同时保持较好的优化效果
+  - `tokio` features 从 `full` 精简为实际使用的 5 个 feature（`rt-multi-thread`, `macros`, `net`, `time`, `sync`），减小编译体积
+
+## [v1.0.3] - 2026-02-09
+
+### Fixed
+- **opus4-6 上下文超限错误识别** (`src/anthropic/handlers.rs`)
+  - 将 `Improperly formed request` 纳入输入过长错误检测，返回 Claude Code 可识别的 `400 Input is too long` 而非 `502 Bad Gateway`
+- **Opus 4.6 模型 ID 移除时间日期** (`src/anthropic/handlers.rs`)
+  - `claude-opus-4-6-20260206` → `claude-opus-4-6`
+- **post_messages 借用冲突编译错误** (`src/anthropic/handlers.rs`)
+  - 将 `override_thinking_from_model_name` 调用移至 `user_id` 提取之前，修复 E0502 借用冲突
+
+### Added
+- **模型 "thinking" 后缀支持** (`src/anthropic/handlers.rs`, `src/anthropic/converter.rs`)
+  - 模型名含 `-thinking` 后缀时自动覆写 thinking 配置（opus4.6 用 adaptive + high effort，其他用 enabled）
+  - 模型列表新增 sonnet/opus4.5/opus4.6/haiku 的 thinking 变体
+
+### Docs
+- **README.md 补充输入压缩配置文档**
+  - 新增"输入压缩"章节，说明 5 层压缩管道机制和 10 个可配置参数
+
+## [v1.0.2] - 2026-02-09
+
+### Fixed
+- **opus4-6 上下文超限错误识别** (`src/anthropic/handlers.rs`)
+  - 将 `Improperly formed request` 纳入输入过长错误检测，返回 Claude Code 可识别的 `400 Input is too long` 而非 `502 Bad Gateway`
+- **Opus 4.6 模型 ID 移除时间日期** (`src/anthropic/handlers.rs`)
+  - `claude-opus-4-6-20260206` → `claude-opus-4-6`
+- **post_messages 借用冲突编译错误** (`src/anthropic/handlers.rs`)
+  - 将 `override_thinking_from_model_name` 调用移至 `user_id` 提取之前，修复 E0502 借用冲突
+
+### Added
+- **模型 "thinking" 后缀支持** (`src/anthropic/handlers.rs`, `src/anthropic/converter.rs`)
+  - 模型名含 `-thinking` 后缀时自动覆写 thinking 配置（opus4.6 用 adaptive + high effort，其他用 enabled）
+  - 模型列表新增 sonnet/opus4.5/opus4.6/haiku 的 thinking 变体
+
+### Docs
+- **README.md 补充输入压缩配置文档**
+  - 新增"输入压缩"章节，说明 5 层压缩管道机制和 10 个可配置参数
+
+## [v1.0.1] - 2026-02-08
+
+### Fixed
+- **历史截断字符统计口径修正** (`src/anthropic/compressor.rs`)
+  - `max_history_chars` 从按字节 `.len()` 改为按字符 `.chars().count()`，与配置语义一致
+- **remove_thinking_blocks 不再全局 trim** (`src/anthropic/compressor.rs`)
+  - 移除末尾 `.trim()`，避免意外吞掉原始内容的首尾空白
+- **token.json 导入注释/逻辑统一** (`src/admin/service.rs`)
+  - 更新注释：`builder-id → idc`（与实际映射一致）
+  - 删除 `auth_method == "builder-id"` 死分支
+- **Admin UI 验活开关 added=0 卡住修复** (`admin-ui/src/components/import-token-json-dialog.tsx`)
+  - `enableVerify` 开启但无新增凭据时，直接跳转 result 步骤而非卡在 preview
+- **工具描述截断 max_description_chars=0 语义修正** (`src/anthropic/converter.rs`)
+  - `0` 现在表示"不截断"，而非截断为空字符串
+
+### Added
+- **输入压缩管道** (`src/anthropic/compressor.rs`)
+  - 新增 5 层压缩管道，规避 Kiro upstream 请求体大小限制
+  - 空白压缩：连续空行(3+)→2行，行尾空格移除，保留行首缩进
+  - thinking 块处理：支持 discard/truncate/keep 三种策略
+  - tool_result 智能截断：按行截断保留头尾，行数不足时回退字符级截断
+  - tool_use input 截断：递归截断 JSON 值中的大字符串
+  - 历史截断：保留系统消息对，按轮数/字符数从前往后成对移除
+  - 12 个单元测试覆盖所有压缩层和边界条件
+- **CompressionConfig 配置结构体** (`src/model/config.rs`)
+  - 新增 `compression` 配置字段，支持通过 JSON 配置文件调整参数
+  - 10 个可配置参数：总开关、空白压缩、thinking 策略、各截断阈值、历史限制
+  - 工具描述截断阈值从硬编码 10000 改为可配置（默认 4000）
+- **合并 upstream 新功能**: 从 upstream/master 拉取并融合大量新特性
+  - **负载均衡模式** (`src/model/config.rs`, `src/kiro/token_manager.rs`, `src/admin/`)
+    - 新增 `loadBalancingMode` 配置项，支持 `priority`（默认）和 `balanced`（Least-Used）两种模式
+    - Admin API 新增 `GET/PUT /config/load-balancing` 端点
+    - 前端新增负载均衡模式切换开关
+  - **凭据统计与持久化** (`src/kiro/token_manager.rs`)
+    - 新增 `success_count`、`last_used_at` 字段，跟踪每个凭据的调用统计
+    - 新增 `save_stats_debounced` 防抖持久化机制，`Drop` 时自动保存
+    - 新增 `refreshTokenHash` 字段用于前端重复检测
+  - **前端批量操作** (`admin-ui/src/components/dashboard.tsx`)
+    - 批量导入对话框 (`BatchImportDialog`)
+    - 批量验活对话框 (`BatchVerifyDialog`)
+    - 分页控件、批量选择/删除/恢复/验活功能
+    - 凭据卡片新增 Checkbox 选择、email 显示、订阅等级、成功次数、剩余用量等信息
+  - **配置文件路径管理** (`src/model/config.rs`)
+    - `Config` 新增 `config_path` 字段和 `load()`/`save()` 方法，支持配置回写
+  - **前端依赖**: 新增 `@radix-ui/react-checkbox` 组件
+
+### Changed
+- `convert_request()` 签名新增 `&CompressionConfig` 参数 (`src/anthropic/converter.rs`)
+- `convert_tools()` 描述截断阈值参数化 (`src/anthropic/converter.rs`)
+- `AppState` 新增 `compression_config` 字段 (`src/anthropic/middleware.rs`)
+- `create_router_with_provider()` 新增 `CompressionConfig` 参数 (`src/anthropic/router.rs`)
+- 重构 README.md 配置文档，提升新用户上手体验
+  - 明确配置文件默认路径：当前工作目录（或通过 `-c`/`--config` 和 `--credentials` 参数指定）
+  - 添加 JSON 注释警告：移除所有带 `//` 注释的示例，提供可直接复制的配置
+  - 修正字段必填性：仅 `apiKey` 为必填，其他字段均有默认值
+  - 新增命令行参数说明表格（`-c`, `--credentials`, `-h`, `-V`）
+  - 补充遗漏的 `credentialRpm` 字段说明（凭据级 RPM 限流）
+  - 使用表格形式展示配置字段，标注必填/可选和默认值
+- 优化 debug 日志中请求体的输出长度 (`src/anthropic/handlers.rs`)
+  - 新增 `truncate_middle()` 函数：截断字符串中间部分，保留头尾各 1200 字符
+  - 正确处理 UTF-8 多字节字符边界，不会截断中文
+  - 仅在启用 `sensitive-logs` feature 时生效，减少日志噪音
+
+### Fixed
+- **[P0] API Key 日志泄露修复** (`src/main.rs`)
+  - info 级别不再打印 API Key 前半段，仅显示末 4 位和长度
+  - 完整前缀仅在 `sensitive-logs` feature 的 debug 级别输出
+- **[P2] 占位工具大小写变体重复插入** (`src/anthropic/converter.rs`)
+  - `collect_history_tool_names` 改为小写去重，避免 `read`/`Read` 等变体重复
+  - 占位工具 push 后同步更新 `existing_tool_names` 集合
+- **[P1] 统计与缓存写盘非原子操作** (`src/kiro/token_manager.rs`, `src/admin/service.rs`)
+  - 统计数据和余额缓存改为临时文件 + 原子重命名，防止写入中断导致文件损坏
+- **[P1] stop_reason 覆盖策略可能丢失信息** (`src/anthropic/stream.rs`)
+  - `set_stop_reason()` 改为基于优先级覆盖，高优先级原因可覆盖低优先级原因
+- **[P2] snapshot 重复计算 SHA-256** (`src/kiro/token_manager.rs`)
+  - `CredentialEntry` 新增 `refresh_token_hash` 缓存字段
+  - Token 刷新时自动更新哈希，`snapshot()` 优先使用缓存避免重复计算
+- **Clippy 警告修复** (`src/model/config.rs`)
+  - 修复 `field_reassign_with_default` 警告，改用结构体初始化语法
+- **[P2] Assistant Prefill 静默丢弃** (`src/anthropic/converter.rs`, `src/anthropic/handlers.rs`)
+  - 末尾 `assistant` 消息（prefill 场景）不再返回 400 错误，改为静默丢弃并回退到最后一条 `user` 消息
+  - Claude 4.x 已弃用 assistant prefill，Kiro API 也不支持，转换器在入口处截断消息列表
+  - 移除 `InvalidLastMessageRole` 错误变体，`build_history` 接受预处理后的消息切片
+- **[P2] 凭据回写原子性** (`src/kiro/token_manager.rs`)
+  - `persist_credentials` 改为临时文件 + `rename` 原子替换
+  - 新增 `resolve_symlink_target` 辅助函数：优先 `canonicalize`，失败时用 `read_link` 解析 symlink
+  - 保留原文件权限，防止 umask 导致凭据文件权限放宽
+  - Windows 兼容：`rename` 前先删除已存在的目标文件
+  - 避免进程崩溃或并发调用导致凭据文件损坏
+- 限制 `max_tokens` 最大值为 32000（Kiro upstream 限制）
+  - 当用户设置超出限制的值时自动调整为 32000
+  - 记录 WARN 级别日志，包含原始值和调整后的值
+  - 涉及文件：`src/anthropic/handlers.rs`
+- 工具输入 JSON 解析失败时的日志输出改为受 `sensitive-logs` feature 控制
+  - 默认仅输出 `buffer_len` 和 `request_body_bytes`（长度信息）
+  - 启用 `--features sensitive-logs` 时输出完整 `buffer` 和 `request_body`
+  - 涉及文件：`src/anthropic/handlers.rs`
+- 修复 Kiro upstream 请求兼容性问题
+  - 空 content（仅 tool_result/image）时使用占位符避免 400
+  - 规范化工具 JSON Schema、补全空 description
+  - 禁用 reqwest 系统代理探测（仅支持显式 `config.proxy_url`）
+  - 新增离线诊断脚本：`tools/diagnose_improper_request.py`
+  - 涉及文件：`src/anthropic/converter.rs`、`src/http_client.rs`、`tools/diagnose_improper_request.py`、`.gitignore`
+- 优化 400 Bad Request "输入过长" 错误的日志输出 (`src/kiro/provider.rs`)
+  - 对于 `CONTENT_LENGTH_EXCEEDS_THRESHOLD` / `Input is too long` 错误，不再输出完整请求体（太占空间且无调试价值）
+  - 改为记录 `request_body_bytes`（字节数）和 `estimated_input_tokens`（估算 token 数）
+  - 新增 `estimate_tokens()` 函数：基于 CJK/非 CJK 字符比例估算 token 数量
+    - CJK 字符（中/日/韩）: token 数 = 字符数 / 1.5
+    - 其他字符（英文等）: token 数 = 字符数 / 3.5
+  - 新增 `is_input_too_long()` 和 `is_cjk_char()` 辅助函数
+
+- 新增多维度设备指纹系统 (`src/kiro/fingerprint.rs`)
+  - 每个凭据生成独立的确定性指纹，模拟真实 Kiro IDE 客户端
+  - 支持 10+ 维度设备信息：SDK 版本、Kiro 版本、Node.js 版本、操作系统、屏幕分辨率、CPU 核心数、时区等
+  - 提供 `user_agent()` 和 `x_amz_user_agent()` 方法构建请求头
+  - 参考 CLIProxyAPIPlus 实现，降低被检测风险
+
+- 新增精细化速率限制系统 (`src/kiro/rate_limiter.rs`)
+  - 每日请求限制（默认 500 次/天）
+  - 请求间隔控制（1-2 秒 + 30% 抖动）
+  - 指数退避策略（30s → 5min，倍数 1.5）
+  - 暂停检测（关键词匹配：suspended, banned, quota exceeded 等）
+
+- 新增独立冷却管理模块 (`src/kiro/cooldown.rs`)
+  - 分类冷却原因（7 种类型：速率限制、账户暂停、配额耗尽、Token 刷新失败等）
+  - 差异化冷却时长：短冷却（1-5 分钟）vs 长冷却（1-24 小时）
+  - 递增冷却机制（连续触发时延长冷却时间）
+  - 自动清理过期冷却
+
+- 新增后台 Token 刷新模块 (`src/kiro/background_refresh.rs`)
+  - 独立后台任务定期检查即将过期的 Token
+  - 支持批量并发刷新（信号量控制）
+  - 可配置检查间隔、批处理大小、并发数
+  - 优雅关闭机制
+
+- `MultiTokenManager` 新增增强方法
+  - `get_fingerprint()`: 获取凭据的设备指纹
+  - `is_credential_available()`: 综合检查凭据可用性（未禁用、未冷却、未超速率限制）
+  - `set_credential_cooldown()` / `clear_credential_cooldown()`: 冷却管理
+  - `get_expiring_credential_ids()`: 获取即将过期的凭据列表
+  - `start_background_refresh()`: 启动后台 Token 刷新任务
+  - `refresh_token_for_credential()`: 带优雅降级的 Token 刷新
+  - `record_api_success()` / `record_api_failure()`: 更新速率限制器状态
+- `CredentialEntry` 结构体新增 `fingerprint` 字段，每个凭据独立生成设备指纹
+
+- 修复 IDC 凭据 `fetch_profile_arn` 在某些 region 返回 `UnknownOperationException` 的问题
+  - 新增 `ListAvailableCustomizations` API 作为 `ListProfiles` 的回退方案
+  - 支持多 region 尝试：先尝试用户配置的 region，失败则回退到 `us-east-1`
+  - 涉及文件：`src/kiro/token_manager.rs`
+
+- 修复 `start_background_refresh` 后台刷新器生命周期问题（Codex Review P1）
+  - 问题：`refresher` 作为局部变量在函数返回后被 drop，导致后台任务立即停止
+  - 解决：方法现在返回 `Arc<BackgroundRefresher>`，调用方需保持引用以维持任务运行
+  - 涉及文件：`src/kiro/token_manager.rs`
+
+- 修复 `calculate_backoff` 退避时间可能超过配置上限的问题（Codex Review P2）
+  - 问题：添加抖动后未再次进行上限约束，可能导致实际等待时间超过 `backoff_max_ms`
+  - 解决：在添加抖动后再进行 `.min(max)` 约束
+  - 涉及文件：`src/kiro/rate_limiter.rs`
+
+- 改进 `persist_credentials` 并发写入安全性（Codex Review P1）
+  - 问题：在锁外执行文件写入可能导致并发写入时旧快照覆盖新数据
+  - 解决：在持有 entries 锁的情况下完成序列化，确保快照一致性
+  - 涉及文件：`src/kiro/token_manager.rs`
+- 修复 IDC 凭据返回 403 "The bearer token included in the request is invalid" 的问题
+  - 根本原因：`profile_arn` 只从第一个凭据获取并存储在全局 `AppState` 中，当使用 IDC 凭据时，Bearer Token 来自 IDC 凭据，但 `profile_arn` 来自第一个凭据（可能是 Social 类型），导致 Token 和 profile_arn 不匹配
+  - 解决方案 1：在 `call_api_with_retry` 中动态注入当前凭据的 `profile_arn`，确保 Token 和 profile_arn 始终匹配
+  - 解决方案 2：IDC Token 刷新后自动调用 `ListProfiles` API 获取 `profileArn`（IDC 的 OIDC 刷新不返回此字段）
+  - 新增 `inject_profile_arn()` 辅助方法，解析请求体 JSON 并覆盖 `profileArn` 字段
+  - 新增 `fetch_profile_arn()` 方法，通过 CodeWhisperer ListProfiles API 获取 profileArn
+  - 涉及文件：`src/kiro/provider.rs`, `src/kiro/token_manager.rs`
+- 新增批量导入 token.json 功能
+  - 后端：新增 `POST /api/admin/credentials/import-token-json` 端点
+  - 支持解析官方 token.json 格式（含 `provider`、`refreshToken`、`clientId`、`clientSecret` 等字段）
+  - 按 `provider` 字段自动映射 `authMethod`（BuilderId → idc, IdC → idc, Social → social）
+  - 支持 dry-run 预览模式，返回详细的导入结果（成功/跳过/无效）
+  - 通过 refreshToken 前缀匹配自动去重，避免重复导入
+  - 前端：新增"导入 token.json"对话框组件
+  - 支持拖放上传 JSON 文件或直接粘贴 JSON 内容
+  - 三步流程：输入 → 预览 → 结果
+  - 涉及文件：
+    - `src/admin/types.rs`（新增 `TokenJsonItem`、`ImportTokenJsonRequest`、`ImportTokenJsonResponse` 等类型）
+    - `src/admin/service.rs`（新增 `import_token_json()` 方法）
+    - `src/admin/handlers.rs`（新增 `import_token_json` handler）
+    - `src/admin/router.rs`（添加路由）
+    - `src/kiro/token_manager.rs`（新增 `has_refresh_token_prefix()` 方法）
+    - `admin-ui/src/types/api.ts`（新增导入相关类型）
+    - `admin-ui/src/api/credentials.ts`（新增 `importTokenJson()` 函数）
+    - `admin-ui/src/hooks/use-credentials.ts`（新增 `useImportTokenJson()` hook）
+    - `admin-ui/src/components/import-token-json-dialog.tsx`（新建）
+    - `admin-ui/src/components/dashboard.tsx`（添加导入按钮）
+
+- 修复字符串切片在多字节字符中间切割导致 panic 的风险（DoS 漏洞）
+  - `generate_fingerprint()` 和 `has_refresh_token_prefix()` 使用 `floor_char_boundary()` 安全截断
+  - 涉及文件：`src/admin/service.rs`, `src/kiro/token_manager.rs`
+- 修复日志截断在多字节字符中间切割导致 panic 的问题
+  - `truncate_for_log()` 使用 `floor_char_boundary()` 安全截断 UTF-8 字符串
+  - 删除 `stream.rs` 中冗余的 `find_char_boundary()` 函数，直接使用标准库方法
+  - 涉及文件：`src/kiro/provider.rs`, `src/anthropic/stream.rs`
+- 移除历史消息中孤立的 tool_use（无对应 tool_result）
+  - Kiro API 要求 tool_use 必须有配对的 tool_result，否则返回 400 Bad Request
+  - 新增 `remove_orphaned_tool_uses()` 函数清理孤立的 tool_use
+  - 涉及文件：`src/anthropic/converter.rs`
+- 修复 `/cc/v1/messages` 缓冲流 ping 定时器首次立即触发的问题
+  - 将 `interval()` 改为 `interval_at(Instant::now() + ping_period, ping_period)`
+  - 现在首个 ping 会在 25 秒后触发，与 `/v1/messages` 行为一致
+  - 涉及文件：`src/anthropic/handlers.rs`
+- 修复 Clippy `collapsible_if` 警告
+  - 使用 let-chains 语法合并嵌套 if 语句
+  - 涉及文件：`src/anthropic/stream.rs`
+
+- 增强 400 Bad Request 错误日志，记录完整请求信息
+  - 移除请求体截断限制，记录完整的 `request_body`
+  - 新增 `request_url` 和 `request_headers` 字段
+  - 新增 `format_headers_for_log()` 辅助函数，对 Authorization 头进行脱敏处理
+  - 删除不再使用的 `truncate_for_log()` 函数（YAGNI 原则）
+  - 涉及文件：`src/kiro/provider.rs`
+- 改进凭据选择算法：同优先级内实现负载均衡
+  - 第一优先级：使用次数最少
+  - 第二优先级：余额最多（使用次数相同时）
+  - 第三优先级：轮询选择（使用次数和余额完全相同时，避免总选第一个）
+  - 新增 `selection_rr` 原子计数器用于轮询抖动
+  - 新增 `select_best_candidate_id()` 方法实现三级排序逻辑
+  - 涉及文件：`src/kiro/token_manager.rs`
+
+- 修复测试代码使用 `serde_json::json!` 构造 Tool 对象导致的类型不匹配问题
+  - 改用 `Tool` 结构体直接构造，确保类型安全
+  - 涉及文件：`src/anthropic/websearch.rs`
+- 修复 `select_best_candidate_id()` 中 NaN 余额处理问题
+  - 在评分阶段将 NaN/Infinity 余额归一化为 0.0
+  - 避免 NaN 被 `total_cmp` 视为最大值导致错误的凭据选择
+  - 避免 NaN 导致 `scored` 被完全过滤后除零 panic
+  - 涉及文件：`src/kiro/token_manager.rs`
+- 新增 `system` 字段格式兼容性支持（`src/anthropic/types.rs`）
+  - 支持字符串格式：`"system": "You are a helpful assistant"`（new-api 等网关添加的系统提示词）
+  - 支持数组格式：`"system": [{"type": "text", "text": "..."}]`（Claude Code 原生格式）
+  - 自动将字符串格式转换为单元素数组，保持内部处理一致性
+  - 新增 6 个单元测试验证格式兼容性
+- 新增请求体大小限制：50MB（`DefaultBodyLimit::max(50 * 1024 * 1024)`）
+  - 涉及文件：`src/anthropic/router.rs`
+- 调整全局禁用恢复时间：`GLOBAL_DISABLE_RECOVERY_MINUTES` 从 10 分钟降至 5 分钟
+  - 加快模型暂时不可用后的自动恢复速度
+- 调整总重试次数硬上限：`MAX_TOTAL_RETRIES` 从 5 降至 3
+  - 进一步减少无效重试开销，加快故障转移速度
+- 余额初始化改为顺序查询，每次间隔 0.5 秒避免触发限流
+  - 从并发查询改为顺序查询（`initialize_balances()`）
+  - 移除 30 秒整体超时机制
+  - 涉及文件：`src/kiro/token_manager.rs`
+
+- 修复 assistant 消息仅包含 tool_use 时 content 为空导致 Kiro API 报错的问题
+  - 当 text_content 为空且存在 tool_uses 时，使用 "OK" 作为占位符
+  - 涉及文件：`src/anthropic/converter.rs`
+- 修复 `MODEL_TEMPORARILY_UNAVAILABLE` 错误检测逻辑未实际调用的问题
+  - 在 `call_mcp()` 和 `call_api()` 中添加错误检测和熔断触发逻辑
+  - 移除 `report_model_unavailable()` 和 `disable_all_credentials()` 的 `#[allow(dead_code)]` 标记
+  - 现在当检测到该错误时会正确触发全局熔断机制
+
+- 新增 WebSearch 工具支持（`src/anthropic/websearch.rs`）
+  - 实现 Anthropic WebSearch 请求到 Kiro MCP 的转换
+  - 支持 SSE 流式响应，生成完整的搜索结果事件序列
+  - 自动检测纯 WebSearch 请求（tools 仅包含 web_search）并路由到专用处理器
+- 新增 MCP API 调用支持（`src/kiro/provider.rs`）
+  - 新增 `call_mcp()` 方法，支持 WebSearch 等工具调用
+  - 新增 `mcp_url()` 和 `build_mcp_headers()` 方法
+  - 完整的重试和故障转移逻辑
+- 新增凭据级 `region` 字段，用于 OIDC token 刷新时指定 endpoint 区域
+  - 未配置时回退到 config.json 的全局 region
+  - API 调用仍使用 config.json 的 region
+- 新增凭据级 `machineId` 字段，支持每个凭据使用独立的机器码
+  - 支持 64 字符十六进制和 UUID 格式（自动标准化）
+  - 未配置时回退到 config.json 的 machineId，都未配置时由 refreshToken 派生
+  - 启动时自动补全并持久化到配置文件
+- 新增 GitHub Actions Docker 构建工作流（`.github/workflows/docker-build.yaml`）
+  - 支持 linux/amd64 和 linux/arm64 双架构
+  - 推送到 GitHub Container Registry
+- 版本号升级至 2026.1.5
+- TLS 库从 native-tls 切换至 rustls（reqwest 依赖调整）
+- `authMethod` 自动推断：未指定时根据是否有 clientId/clientSecret 自动判断为 idc 或 social
+- 移除 web_search/websearch 工具过滤（`is_unsupported_tool` 现在返回 false）
+
+- 修复 machineId 格式兼容性问题，支持 UUID 格式自动转换为 64 字符十六进制
+### Removed
+- 移除 `current_id` 概念（后端和前端）
+  - 后端：移除 `MultiTokenManager.current_id` 字段和相关方法（`switch_to_next`、`select_highest_priority`、`select_by_balance`、`credentials`）
+  - 后端：移除 `ManagerSnapshot.current_id` 字段
+  - 后端：移除 `CredentialStatusItem.is_current` 字段
+  - 前端：移除 `CredentialsStatusResponse.currentId` 和 `CredentialStatusItem.isCurrent`
+  - 原因：多用户并发访问时，"当前凭据"概念无意义，凭据选择由 `acquire_context_for_user()` 动态决定
+
+- 新增启动时余额初始化功能
+  - `initialize_balances()`: 启动时并发查询所有凭据余额并更新缓存
+  - 整体超时 30 秒，避免阻塞启动流程
+  - 初始化失败或超时时输出警告日志
+- 改进凭据选择算法：从单一"使用次数最少"改为两级排序
+  - 第一优先级：使用次数最少
+  - 第二优先级：余额最多（使用次数相同时）
+  - 未初始化余额的凭据会被降级处理，避免被优先选中
+- 移除前端"当前活跃"凭据展示
+  - 前端：移除凭据卡片的"当前"高亮和 Badge
+  - 前端：移除 Dashboard 中的"当前活跃"统计卡片
+  - 统计卡片布局从 3 列调整为 2 列
+
+- 新增 `sensitive-logs` feature flag，显式启用才允许打印潜在敏感信息（仅用于排障）
+  - 默认关闭：Kiro 请求体只输出长度，凭证只输出摘要信息
+  - 启用方式：`cargo build --features sensitive-logs`
+
+- 修复 SSE 流 ping 保活首次立即触发的问题
+  - 使用 `interval_at(Instant::now() + ping_period, ping_period)` 延迟首次触发
+  - 避免连接建立后立即发送无意义的 ping 事件
+- 改进服务启动错误处理
+  - 绑定监听地址失败时输出错误日志并退出（exit code 1）
+  - HTTP 服务异常退出时输出错误日志并退出（exit code 1）
+
+- 修复合并 upstream 后 `CredentialEntry` 结构体字段缺失导致的编译错误
+  - 添加 `disable_reason: Option<DisableReason>` 字段（公共 API 展示用）
+  - 添加 `auto_heal_reason: Option<AutoHealReason>` 字段（内部自愈逻辑用）
+- 修复禁用原因字段不同步问题
+  - `report_failure()`: 禁用时同步设置两个字段
+  - `set_disabled()`: 启用/禁用时同步设置/清除两个字段
+  - `reset_and_enable()`: 重置时同步清除两个字段
+  - 自愈循环：重新启用凭据时同步清除 `disable_reason`
+  - `mark_insufficient_balance()`: 清除 `auto_heal_reason` 防止被自愈循环错误恢复
+- 重命名内部字段以提高可读性
+  - `DisabledReason` → `AutoHealReason`（自愈原因枚举）
+  - `disabled_reason` → `auto_heal_reason`（自愈原因字段）
+- 日志中的 `user_id` 现在会进行掩码处理，保护用户隐私
+  - 长度 > 25：保留前13后8字符（如 `user_f516339a***897ac7`）
+  - 长度 13-25：保留前4后4字符
+  - 长度 ≤ 12：完全掩码为 `***`
+
+- 新增缓存余额查询 API（`GET /credentials/balances/cached`）
+  - 后端：`CachedBalanceInfo` 结构体、`get_all_cached_balances()` 方法
+  - 前端：凭据卡片直接显示缓存余额和更新时间
+  - 30 秒自动轮询更新，缓存超过 1 分钟时点击强制刷新
+- 新增 Bonus 用量包支持（`src/kiro/model/usage_limits.rs`）
+  - 新增 `Bonus` 结构体，支持 GIFT 类型的额外用量包
+  - 新增 `Bonus::is_active()` 方法，按状态/过期时间判断是否激活
+  - `usage_limit()` 和 `current_usage()` 现在会合并基础额度、免费试用额度和所有激活的 bonuses
+- 新增 Kiro Web Portal API 模块（`src/kiro/web_portal.rs`）
+  - 支持 CBOR 协议与 app.kiro.dev 通信
+  - 实现 `get_user_info()` 和 `get_user_usage_and_limits()` API
+  - 新增 `aggregate_account_info()` 聚合账号信息（套餐/用量/邮箱等）
+- Admin UI 前端增强
+  - 新增数字格式化工具（`admin-ui/src/lib/format.ts`）：K/M/B 显示、Token 对格式化、过期时间格式化
+  - 新增统计相关 API 和 Hooks：`getCredentialStats`, `resetCredentialStats`, `resetAllStats`
+  - 新增账号信息 API：`getCredentialAccountInfo`, `useCredentialAccountInfo`
+  - 扩展 `CredentialStatusItem` 添加统计字段（调用次数、Token 用量、最后调用时间等）
+  - 新增完整的账号信息类型定义（`AccountAggregateInfo`, `CreditsUsageSummary` 等）
+- 新增 `serde_cbor` 依赖用于 CBOR 编解码
+
+- 修复手动查询余额后列表页面不显示缓存余额的问题
+  - `get_balance()` 成功后调用 `update_balance_cache()` 更新缓存
+  - 现在点击"查看余额"后，列表页面会正确显示缓存的余额值
+- 修复关闭余额弹窗后卡片不更新缓存余额的问题
+  - 弹窗关闭时调用 `queryClient.invalidateQueries({ queryKey: ['cached-balances'] })`
+  - 确保卡片和弹窗使用的两个独立数据源保持同步
+- 增强 Token 刷新日志，添加凭证 ID 追踪
+  - 新增 `refresh_token_with_id()` 函数支持传入凭证 ID
+  - 日志现在包含 `credential_id` 字段，便于多凭据环境下的问题排查
+- 调整重试策略：单凭据最大重试次数 3→2，单请求最大重试次数 9→5
+  - `MAX_RETRIES_PER_CREDENTIAL`: 3 → 2
+  - `MAX_TOTAL_RETRIES`: 9 → 5
+  - `MAX_FAILURES_PER_CREDENTIAL`: 3 → 2
+  - 减少无效凭据的重试开销，加快故障转移速度
+
+- 新增用户亲和性绑定功能：连续对话优先使用同一凭据（基于 `metadata.user_id`）
+  - 新增 `src/kiro/affinity.rs` 模块，实现 `UserAffinityManager`
+  - 新增 `acquire_context_for_user()` 方法支持亲和性查询
+  - 亲和性绑定 TTL 为 30 分钟
+- 新增余额感知故障转移：凭据失效时自动切换到余额最高的可用凭据
+- 新增动态余额缓存 TTL 策略：
+  - 高频渠道（10分钟内 ≥20 次调用）：10 分钟刷新
+  - 低频渠道：30 分钟刷新
+  - 低余额渠道（余额 < 1.0）：24 小时刷新
+- 新增 `record_usage()` 方法自动记录凭据使用频率
+- 新增负载均衡：无亲和性绑定时优先分配到使用频率最低的凭据
+- 新增 `DisableReason` 枚举，区分凭据禁用原因（失败次数、余额不足、模型不可用、手动禁用）
+- 成功请求时自动重置 `MODEL_TEMPORARILY_UNAVAILABLE` 计数器，避免跨时间累计触发
+- 新增 `MODEL_TEMPORARILY_UNAVAILABLE` 错误检测和全局禁用机制
+  - 当该 500 错误发生 2 次时，自动禁用所有凭据
+  - 5 分钟后自动恢复（余额不足的凭据除外）
+- `CredentialEntrySnapshot` 新增 `disable_reason` 字段，支持查询禁用原因
+- 新增自动余额刷新：成功请求后自动在后台刷新余额缓存（基于动态 TTL 策略）
+  - 新增 `spawn_balance_refresh()` 方法，使用 `tokio::spawn` 异步刷新
+  - 新增 `should_refresh_balance()` 方法，根据 TTL 判断是否需要刷新
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..27b9b44
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,100 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## 项目概述
+
+kiro-rs 是一个用 Rust 编写的 Anthropic Claude API 兼容代理服务，将 Anthropic API 请求转换为 Kiro API 请求。支持多凭据管理、自动故障转移、流式响应和 Web 管理界面。
+
+**技术栈**: Rust (Axum 0.8 + Tokio) + React 18 + TypeScript + Tailwind CSS
+
+## 常用命令
+
+```bash
+# 构建（必须先构建前端）
+cd admin-ui && pnpm install && pnpm build
+cargo build --release
+
+# 开发运行
+cargo run -- -c config.json --credentials credentials.json
+
+# 测试
+cargo test
+cargo test <test_name>           # 运行单个测试
+
+# 代码检查
+cargo fmt          # 格式化
+cargo clippy       # lint
+
+# 启用敏感日志构建（排障用，输出 token 用量等诊断信息）
+cargo run --features sensitive-logs -- -c config.json --credentials credentials.json
+
+# 前端开发
+cd admin-ui
+pnpm install
+pnpm dev           # 开发服务器
+pnpm build         # 生产构建
+```
+
+## 请求处理流程
+
+```
+POST /v1/messages (Anthropic 格式)
+  → auth_middleware: 验证 x-api-key / Bearer token（subtle 常量时间比较）
+  → post_messages handler:
+      1. 判断 WebSearch 触发条件，决定本地处理或剔除后转发
+      2. converter::convert_request() 转换为 Kiro 请求格式
+      3. provider.call_api() 发送请求（含重试和故障转移）
+      4. stream.rs 解析 AWS Event Stream → 转换为 Anthropic SSE 格式返回
+```
+
+## 核心设计模式
+
+1. **Provider Pattern** - `kiro/provider.rs`: 统一的 API 提供者接口，处理请求转发和重试。支持凭据级代理（每个凭据可配独立 HTTP/SOCKS5 代理，缓存对应 HTTP Client 避免重复创建）
+2. **Multi-Token Manager** - `kiro/token_manager.rs`: 多凭据管理，按优先级故障转移，后台异步刷新 Token（支持 Social 和 IdC 两种认证方式）。余额缓存动态 TTL：高频用户 10 分钟、低频用户 30 分钟、低余额用户 24 小时，过期时异步刷新不阻塞请求
+3. **Protocol Converter** - `anthropic/converter.rs`: Anthropic ↔ Kiro 双向协议转换，包括模型映射（sonnet/opus/haiku → Kiro 模型 ID）、JSON Schema 规范化（修复 MCP 工具的 `required: null` / `properties: null`）、工具占位符生成、图片格式转换
+4. **Event Stream Parser** - `kiro/parser/`: AWS Event Stream 二进制协议解析（header + payload + CRC32C 校验）
+5. **Buffered Stream** - `anthropic/stream.rs`: 两种流模式 — `StreamContext`（直接转发）和 `BufferedStreamContext`（缓冲所有事件，等 `contextUsageEvent` 到达后修正 input_tokens 再一次性发送）
+
+## 共享状态
+
+```rust
+AppState {
+    api_key: String,                          // Anthropic API 认证密钥
+    kiro_provider: Option<Arc<KiroProvider>>,  // 核心 API 提供者（Arc 线程安全共享）
+    profile_arn: Option<String>,               // AWS Profile ARN
+    compression_config: CompressionConfig,     // 输入压缩配置
+}
+```
+
+通过 Axum `State` extractor 注入到所有 handler 中。
+
+## 凭据故障转移与冷却
+
+- 凭据按 `priority` 字段排序，优先使用高优先级凭据
+- 请求失败时 `report_failure()` 触发故障转移到下一个可用凭据
+- 冷却分类管理：`FailureLimit` / `InsufficientBalance` / `ModelUnavailable` / `QuotaExceeded`
+- `MODEL_TEMPORARILY_UNAVAILABLE` 触发全局熔断，禁用所有凭据
+
+## API 端点
+
+**代理端点**:
+- `GET /v1/models` - 获取可用模型列表
+- `POST /v1/messages` - 创建消息（Anthropic 格式）
+- `POST /v1/messages/count_tokens` - Token 计数
+- `/cc/v1/*` - Claude Code 兼容端点（同上，路径别名）
+
+**Admin API** (需配置 `adminApiKey`):
+- 凭据 CRUD、状态监控、余额查询
+
+## 重要注意事项
+
+1. **构建顺序**: 必须先构建前端 `admin-ui`，再编译 Rust 后端（静态文件通过 `rust-embed` 嵌入，derive 宏为 `#[derive(Embed)]`）
+2. **凭据格式**: 支持单凭据（向后兼容）和多凭据（数组格式，支持 priority 字段）
+3. **重试策略**: 单凭据最多重试 2 次，单请求最多重试 3 次
+4. **WebSearch 工具**: 仅当请求明确触发 WebSearch（`tool_choice` 强制 / 仅提供 `web_search` 单工具 / 消息前缀匹配）时走本地 WebSearch；否则从 `tools` 中剔除 `web_search` 后转发上游（避免误路由）
+5. **安全**: 使用 `subtle` 库进行常量时间比较防止时序攻击；Admin API Key 空字符串视为未配置
+6. **Prefill 处理**: Claude 4.x 已弃用 assistant prefill，末尾 assistant 消息被静默丢弃
+7. **sensitive-logs 特性**: 编译时 feature flag，启用后输出 token 用量诊断日志和请求体大小（默认关闭，仅用于排障）
+8. **网络错误分类**: 连接关闭/重置、发送失败等网络错误被归类为瞬态上游错误，返回 502（不记录请求体）
+9. **Rust edition**: 项目使用 Rust 2024 edition
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..a841afc
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,2587 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
+
+[[package]]
+name = "atomic"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89cbf775b137e9b968e67227ef7f775587cde3fd31b0d8599dbd0f598a48340"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "axum"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8"
+dependencies = [
+ "axum-core",
+ "bytes",
+ "form_urlencoded",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde_core",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chrono"
+version = "0.4.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "wasm-bindgen",
+ "windows-link",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63be97961acde393029492ce0be7a1af7e323e6bae9511ebfac33751be5e6806"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f13174bda5dfd69d7e947827e5af4b0f2f94a4a3ee92912fba07a66150f21e2"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831"
+
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "gif"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5df2ba84018d80c213569363bdcd0c64e6933c67fe4c1d60ecf822971a3c35e"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
+[[package]]
+name = "half"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hyper"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "pin-utils",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+dependencies = [
+ "http",
+ "hyper",
+ "hyper-util",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tower-service",
+ "webpki-roots",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "image"
+version = "0.25.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "color_quant",
+ "gif",
+ "image-webp",
+ "moxcms",
+ "num-traits",
+ "png",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "image-webp"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
+dependencies = [
+ "byteorder-lite",
+ "quick-error",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "iri-string"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "js-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kiro-rs"
+version = "1.1.5"
+dependencies = [
+ "anyhow",
+ "axum",
+ "base64",
+ "bytes",
+ "chrono",
+ "clap",
+ "crc",
+ "fastrand",
+ "futures",
+ "hex",
+ "http",
+ "image",
+ "mime_guess",
+ "parking_lot",
+ "reqwest",
+ "rust-embed",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+ "sha2",
+ "subtle",
+ "tokio",
+ "tower-http",
+ "tracing",
+ "tracing-subscriber",
+ "urlencoding",
+ "uuid",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "matchit"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "moxcms"
+version = "0.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "png"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97baced388464909d42d89643fe4361939af9b7ce7a31ee32a168f832a70f2a0"
+dependencies = [
+ "bitflags",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pxfm"
+version = "0.1.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7186d3822593aa4393561d186d1393b3923e9d6163d3fbfd6e825e3e6cf3e6a8"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quinn"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "socket2",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+dependencies = [
+ "bytes",
+ "getrandom 0.3.4",
+ "lru-slab",
+ "rand",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2",
+ "tracing",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
+
+[[package]]
+name = "reqwest"
+version = "0.12.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "webpki-roots",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rust-embed"
+version = "8.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04113cb9355a377d83f06ef1f0a45b8ab8cd7d8b1288160717d66df5c7988d27"
+dependencies = [
+ "rust-embed-impl",
+ "rust-embed-utils",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-impl"
+version = "8.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0902e4c7c8e997159ab384e6d0fc91c221375f6894346ae107f47dd0f3ccaa"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rust-embed-utils",
+ "syn",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-utils"
+version = "8.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bcdef0be6fe7f6fa333b1073c949729274b05f123a0ad7efcb8efd878e5c3b1"
+dependencies = [
+ "sha2",
+ "walkdir",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustls"
+version = "0.23.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
+dependencies = [
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
+dependencies = [
+ "web-time",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
+dependencies = [
+ "itoa",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.115"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e614ed320ac28113fa64972c4262d5dbc89deacdfd00c34a3e4cea073243c12"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.49.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "537dd038a89878be9b64dd4bd1b260315c1bb94f4d784956b81e27a088d9a09e"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uuid"
+version = "1.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+dependencies = [
+ "atomic",
+ "getrandom 0.4.1",
+ "js-sys",
+ "rand",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "410e9ecef634c709e3831c2cfdb8d9c32164fae1c67496d5b68fff728eec37fe"
+dependencies = [
+ "zune-core",
+]
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..d5e630c
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "kiro-rs"
+version = "1.1.5"
+edition = "2024"
+
+[profile.release]
+lto = "thin"
+strip = true
+
+[features]
+default = []
+# 显式启用才允许打印潜在敏感信息（仅用于排障）
+sensitive-logs = []
+
+[dependencies]
+axum = "0.8"
+tokio = { version = "1.0", features = ["rt-multi-thread", "macros", "net", "time", "sync"] }
+reqwest = { version = "0.12", default-features = false, features = ["stream", "json", "socks", "rustls-tls"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+serde_cbor = "0.11"   # CBOR 编解码（Web Portal API）
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+anyhow = "1.0"
+http = "1.0"
+futures = "0.3"
+chrono = { version = "0.4", features = ["serde"] }
+uuid = { version = "1.10", features = ["v1", "v4", "fast-rng"] }
+fastrand = "2"
+sha2 = "0.10"
+hex = "0.4"
+crc = "3"           # CRC32C 计算
+bytes = "1"         # 高效的字节缓冲区
+tower-http = { version = "0.6", features = ["cors"] }
+clap = { version = "4.5", features = ["derive"] }
+urlencoding = "2"
+parking_lot = "0.12"  # 高性能同步原语
+subtle = "2.6"        # 常量时间比较（防止时序攻击）
+rust-embed = "8"      # 嵌入静态文件
+mime_guess = "2"      # MIME 类型推断
+image = { version = "0.25", default-features = false, features = ["jpeg", "png", "gif", "webp"] }  # 图片处理
+base64 = "0.22"       # Base64 编解码
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..6d10c55
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,51 @@
+FROM rust:1.93-alpine AS chef
+RUN apk add --no-cache musl-dev openssl-dev openssl-libs-static
+RUN cargo install cargo-chef
+WORKDIR /app
+
+FROM chef AS planner
+COPY Cargo.toml Cargo.lock* ./
+COPY src ./src
+RUN cargo chef prepare --recipe-path recipe.json
+
+FROM node:24-alpine AS frontend-builder
+WORKDIR /app/admin-ui
+COPY admin-ui/package.json ./
+RUN npm install -g pnpm && pnpm install
+COPY admin-ui ./
+RUN pnpm build
+
+FROM chef AS builder
+
+# 可选：启用敏感日志输出（仅用于排障）
+ARG ENABLE_SENSITIVE_LOGS=false
+
+COPY --from=planner /app/recipe.json recipe.json
+RUN if [ "$ENABLE_SENSITIVE_LOGS" = "true" ]; then \
+        cargo chef cook --release --features sensitive-logs --recipe-path recipe.json; \
+    else \
+        cargo chef cook --release --recipe-path recipe.json; \
+    fi
+
+COPY Cargo.toml Cargo.lock* ./
+COPY src ./src
+COPY --from=frontend-builder /app/admin-ui/dist /app/admin-ui/dist
+
+RUN if [ "$ENABLE_SENSITIVE_LOGS" = "true" ]; then \
+        cargo build --release --features sensitive-logs; \
+    else \
+        cargo build --release; \
+    fi
+
+FROM alpine:3.21
+
+RUN apk add --no-cache ca-certificates
+
+WORKDIR /app
+COPY --from=builder /app/target/release/kiro-rs /app/kiro-rs
+
+VOLUME ["/app/config"]
+
+EXPOSE 8990
+
+CMD ["./kiro-rs", "-c", "/app/config/config.json", "--credentials", "/app/config/credentials.json"]
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..3115809
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,68 @@
+.PHONY: dev build release clean test lint fmt ui ui-dev docker help
+
+# 默认目标
+help:
+	@echo "Usage: make <target>"
+	@echo ""
+	@echo "开发:"
+	@echo "  dev        cargo run（debug 模式，需先 make ui）"
+	@echo "  ui-dev     启动前端 dev server"
+	@echo ""
+	@echo "构建:"
+	@echo "  ui         构建前端"
+	@echo "  build      构建前端 + 后端（debug）"
+	@echo "  release    构建前端 + 后端（release）"
+	@echo "  docker     构建 Docker 镜像"
+	@echo ""
+	@echo "质量:"
+	@echo "  test       运行测试"
+	@echo "  lint       cargo clippy"
+	@echo "  fmt        cargo fmt"
+	@echo "  check      fmt + clippy + test"
+	@echo ""
+	@echo "其他:"
+	@echo "  clean      清理构建产物"
+
+# --- 前端 ---
+
+ui:
+	cd admin-ui && pnpm install && pnpm build
+
+ui-dev:
+	@echo "启动前端 dev server: http://localhost:5173"
+	cd admin-ui && pnpm install && pnpm dev
+
+# --- 后端 ---
+
+dev: ui
+	cargo run --features sensitive-logs -- -c config/config.json --credentials config/credentials.json
+
+build: ui
+	cargo build
+
+release: ui
+	cargo build --release
+
+# --- 质量 ---
+
+test:
+	cargo test
+
+lint:
+	cargo clippy -- -D warnings
+
+fmt:
+	cargo fmt
+
+check: fmt lint test
+
+# --- Docker ---
+
+docker:
+	docker build -t kiro-rs .
+
+# --- 清理 ---
+
+clean:
+	cargo clean
+	rm -rf admin-ui/dist admin-ui/node_modules
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..4ed60d0
--- /dev/null
+++ b/README.md
@@ -0,0 +1,525 @@
+# kiro-rs
+
+一个用 Rust 编写的 Anthropic Claude API 兼容代理服务，将 Anthropic API 请求转换为 Kiro API 请求。
+
+---
+
+## 免责声明
+
+本项目仅供研究使用, Use at your own risk, 使用本项目所导致的任何后果由使用人承担, 与本项目无关。
+本项目与 AWS/KIRO/Anthropic/Claude 等官方无关, 本项目不代表官方立场。
+
+## 注意！
+
+因 TLS 默认从 native-tls 切换至 rustls，你可能需要专门安装证书后才能配置 HTTP 代理。可通过 `config.json` 的 `tlsBackend` 切回 `native-tls`。
+如果遇到请求报错, 尤其是无法刷新 token, 或者是直接返回 error request, 请尝试切换 tls 后端为 `native-tls`, 一般即可解决。
+
+**Write Failed/会话卡死**: 如果遇到持续的 Write File / Write Failed 并导致会话不可用，参考 Issue [#22](https://github.com/hank9999/kiro.rs/issues/22) 和 [#49](https://github.com/hank9999/kiro.rs/issues/49) 的说明与临时解决方案（通常与输出过长被截断有关，可尝试调低输出相关 token 上限）
+
+## 功能特性
+
+- **Anthropic API 兼容**: 完整支持 Anthropic Claude API 格式
+- **流式响应**: 支持 SSE (Server-Sent Events) 流式输出
+- **Token 自动刷新**: 自动管理和刷新 OAuth Token
+- **多凭据支持**: 支持配置多个凭据，按优先级自动故障转移
+- **智能重试**: 单凭据最多重试 2 次，单请求最多重试 3 次
+- **凭据回写**: 多凭据格式下自动回写刷新后的 Token
+- **Thinking 模式**: 支持 Claude 的 extended thinking 功能
+- **工具调用**: 完整支持 function calling / tool use
+- **WebSearch**: 内置 WebSearch 工具转换逻辑
+- **多模型支持**: 支持 Sonnet、Opus、Haiku 系列模型
+- **Admin 管理**: 可选的 Web 管理界面和 API，支持凭据管理、余额查询等
+- **多级 Region 配置**: 支持全局和凭据级别的 Auth Region / API Region 配置
+- **凭据级代理**: 支持为每个凭据单独配置 HTTP/SOCKS5 代理，优先级：凭据代理 > 全局代理 > 无代理
+
+---
+
+- [开始](#开始)
+  - [1. 编译](#1-编译)
+  - [2. 最小配置](#2-最小配置)
+  - [3. 启动](#3-启动)
+  - [4. 验证](#4-验证)
+  - [Docker](#docker)
+- [配置详解](#配置详解)
+  - [config.json](#configjson)
+  - [credentials.json](#credentialsjson)
+  - [Region 配置](#region-配置)
+  - [代理配置](#代理配置)
+  - [认证方式](#认证方式)
+  - [环境变量](#环境变量)
+- [API 端点](#api-端点)
+  - [标准端点 (/v1)](#标准端点-v1)
+  - [Claude Code 兼容端点 (/cc/v1)](#claude-code-兼容端点-ccv1)
+  - [Thinking 模式](#thinking-模式)
+  - [工具调用](#工具调用)
+- [模型映射](#模型映射)
+- [Admin（可选）](#admin可选)
+- [注意事项](#注意事项)
+- [项目结构](#项目结构)
+- [技术栈](#技术栈)
+- [License](#license)
+- [致谢](#致谢)
+
+## 开始
+
+### 1. 编译
+
+> PS: 如果不想编辑可以直接前往 Release 下载二进制文件
+
+> **前置步骤**：编译前需要先构建前端 Admin UI（用于嵌入到二进制中）：
+> ```bash
+> cd admin-ui && pnpm install && pnpm build
+> ```
+
+```bash
+cargo build --release
+```
+
+### 2. 最小配置
+
+创建 `config.json`：
+
+```json
+{
+   "host": "127.0.0.1",
+   "port": 8990,
+   "apiKey": "sk-kiro-rs-qazWSXedcRFV123456",
+   "region": "us-east-1"
+}
+```
+> PS: 如果你需要 Web 管理面板, 请注意配置 `adminApiKey`
+
+创建 `credentials.json`（从 Kiro IDE 等中获取凭证信息）：
+> PS: 可以前往 Web 管理面板配置跳过本步骤
+> 如果你对凭据地域有疑惑, 请查看 [Region 配置](#region-配置)
+
+Social 认证：
+```json
+{
+   "refreshToken": "你的刷新token",
+   "expiresAt": "2025-12-31T02:32:45.144Z",
+   "authMethod": "social"
+}
+```
+
+IdC 认证：
+```json
+{
+   "refreshToken": "你的刷新token",
+   "expiresAt": "2025-12-31T02:32:45.144Z",
+   "authMethod": "idc",
+   "clientId": "你的clientId",
+   "clientSecret": "你的clientSecret"
+}
+```
+
+### 3. 启动
+
+```bash
+./target/release/kiro-rs
+```
+
+或指定配置文件路径：
+
+```bash
+./target/release/kiro-rs -c /path/to/config.json --credentials /path/to/credentials.json
+```
+
+### 4. 验证
+
+```bash
+curl http://127.0.0.1:8990/v1/messages \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: sk-kiro-rs-qazWSXedcRFV123456" \
+  -d '{
+    "model": "claude-sonnet-4-20250514",
+    "max_tokens": 1024,
+    "stream": true,
+    "messages": [
+      {"role": "user", "content": "Hello, Claude!"}
+    ]
+  }'
+```
+
+### Docker
+
+也可以通过 Docker 启动：
+
+```bash
+docker-compose up
+```
+
+需要将 `config.json` 和 `credentials.json` 挂载到容器中，具体参见 `docker-compose.yml`。
+
+## 配置详解
+
+### config.json
+
+| 字段 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| `host` | string | `127.0.0.1` | 服务监听地址 |
+| `port` | number | `8080` | 服务监听端口 |
+| `apiKey` | string | - | 自定义 API Key（用于客户端认证，必配） |
+| `region` | string | `us-east-1` | AWS 区域 |
+| `authRegion` | string | - | Auth Region（用于 Token 刷新），未配置时回退到 region |
+| `apiRegion` | string | - | API Region（用于 API 请求），未配置时回退到 region |
+| `kiroVersion` | string | `0.10.0` | Kiro 版本号 |
+| `machineId` | string | - | 自定义机器码（64位十六进制），不定义则自动生成 |
+| `systemVersion` | string | 随机 | 系统版本标识 |
+| `nodeVersion` | string | `22.21.1` | Node.js 版本标识 |
+| `tlsBackend` | string | `rustls` | TLS 后端：`rustls` 或 `native-tls` |
+| `countTokensApiUrl` | string | - | 外部 count_tokens API 地址 |
+| `countTokensApiKey` | string | - | 外部 count_tokens API 密钥 |
+| `countTokensAuthType` | string | `x-api-key` | 外部 API 认证类型：`x-api-key` 或 `bearer` |
+| `proxyUrl` | string | - | HTTP/SOCKS5 代理地址 |
+| `proxyUsername` | string | - | 代理用户名 |
+| `proxyPassword` | string | - | 代理密码 |
+| `adminApiKey` | string | - | Admin API 密钥，配置后启用凭据管理 API 和 Web 管理界面 |
+
+完整配置示例：
+
+```json
+{
+   "host": "127.0.0.1",
+   "port": 8990,
+   "apiKey": "sk-kiro-rs-qazWSXedcRFV123456",
+   "region": "us-east-1",
+   "tlsBackend": "rustls",
+   "kiroVersion": "0.10.0",
+   "machineId": "64位十六进制机器码",
+   "systemVersion": "darwin#24.6.0",
+   "nodeVersion": "22.21.1",
+   "authRegion": "us-east-1",
+   "apiRegion": "us-east-1",
+   "countTokensApiUrl": "https://api.example.com/v1/messages/count_tokens",
+   "countTokensApiKey": "sk-your-count-tokens-api-key",
+   "countTokensAuthType": "x-api-key",
+   "proxyUrl": "http://127.0.0.1:7890",
+   "proxyUsername": "user",
+   "proxyPassword": "pass",
+   "adminApiKey": "sk-admin-your-secret-key"
+}
+```
+
+### credentials.json
+
+支持单对象格式（向后兼容）或数组格式（多凭据）。
+
+#### 字段说明
+
+| 字段             | 类型     | 描述                                          |
+|----------------|--------|---------------------------------------------|
+| `id`           | number | 凭据唯一 ID（可选，仅用于 Admin API 管理；手写文件可不填）        |
+| `accessToken`  | string | OAuth 访问令牌（可选，可自动刷新）                        |
+| `refreshToken` | string | OAuth 刷新令牌                                  |
+| `profileArn`   | string | AWS Profile ARN（可选，登录时返回）                   |
+| `expiresAt`    | string | Token 过期时间 (RFC3339)                        |
+| `authMethod`   | string | 认证方式：`social` 或 `idc`                       |
+| `clientId`     | string | IdC 登录的客户端 ID（IdC 认证必填）                     |
+| `clientSecret` | string | IdC 登录的客户端密钥（IdC 认证必填）                      |
+| `priority`     | number | 凭据优先级，数字越小越优先，默认为 0                         |
+| `region`       | string | 凭据级 Auth Region, 兼容字段                       |
+| `authRegion`   | string | 凭据级 Auth Region，用于 Token 刷新, 未配置时回退到 region |
+| `apiRegion`    | string | 凭据级 API Region，用于 API 请求                    |
+| `machineId`    | string | 凭据级机器码（64位十六进制）                             |
+| `email`        | string | 用户邮箱（可选，从 API 获取）                           |
+| `proxyUrl`     | string | 凭据级代理 URL（可选，特殊值 `direct` 表示不使用代理）       |
+| `proxyUsername`| string | 凭据级代理用户名（可选）                                |
+| `proxyPassword`| string | 凭据级代理密码（可选）                                 |
+
+说明：
+- IdC / Builder-ID / IAM 在本项目里属于同一种登录方式，配置时统一使用 `authMethod: "idc"`
+- 为兼容旧配置，`builder-id` / `iam` 仍可被识别，但会按 `idc` 处理
+
+#### 单凭据格式（旧格式，向后兼容）
+
+```json
+{
+   "accessToken": "请求token，一般有效期一小时，可选",
+   "refreshToken": "刷新token，一般有效期7-30天不等",
+   "profileArn": "arn:aws:codewhisperer:us-east-1:111112222233:profile/QWER1QAZSDFGH",
+   "expiresAt": "2025-12-31T02:32:45.144Z",
+   "authMethod": "social",
+   "clientId": "IdC 登录需要",
+   "clientSecret": "IdC 登录需要"
+}
+```
+
+#### 多凭据格式（支持故障转移和自动回写）
+
+```json
+[
+   {
+      "refreshToken": "第一个凭据的刷新token",
+      "expiresAt": "2025-12-31T02:32:45.144Z",
+      "authMethod": "social",
+      "priority": 0
+   },
+   {
+      "refreshToken": "第二个凭据的刷新token",
+      "expiresAt": "2025-12-31T02:32:45.144Z",
+      "authMethod": "idc",
+      "clientId": "xxxxxxxxx",
+      "clientSecret": "xxxxxxxxx",
+      "region": "us-east-2",
+      "priority": 1,
+      "proxyUrl": "socks5://proxy.example.com:1080",
+      "proxyUsername": "user",
+      "proxyPassword": "pass"
+   },
+   {
+      "refreshToken": "第三个凭据（显式不走代理）",
+      "expiresAt": "2025-12-31T02:32:45.144Z",
+      "authMethod": "social",
+      "priority": 2,
+      "proxyUrl": "direct"
+   }
+]
+```
+
+多凭据特性：
+- 按 `priority` 字段排序，数字越小优先级越高（默认为 0）
+- 单凭据最多重试 3 次，单请求最多重试 9 次
+- 自动故障转移到下一个可用凭据
+- 多凭据格式下 Token 刷新后自动回写到源文件
+
+### Region 配置
+
+支持多级 Region 配置，分别控制 Token 刷新和 API 请求使用的区域。
+
+**Auth Region**（Token 刷新）优先级：
+`凭据.authRegion` > `凭据.region` > `config.authRegion` > `config.region`
+
+**API Region**（API 请求）优先级：
+`凭据.apiRegion` > `config.apiRegion` > `config.region`
+
+### 代理配置
+
+支持全局代理和凭据级代理，凭据级代理会覆盖该凭据产生的所有出站连接（API 请求、Token 刷新、额度查询）。
+
+**代理优先级**：`凭据.proxyUrl` > `config.proxyUrl` > 无代理
+
+| 凭据 `proxyUrl` 值 | 行为 |
+|---|---|
+| 具体 URL（如 `http://proxy:8080`、`socks5://proxy:1080`） | 使用凭据指定的代理 |
+| `direct` | 显式不使用代理（即使全局配置了代理） |
+| 未配置（留空） | 回退到全局代理配置 |
+
+凭据级代理示例：
+
+```json
+[
+   {
+      "refreshToken": "凭据A：使用自己的代理",
+      "authMethod": "social",
+      "proxyUrl": "socks5://proxy-a.example.com:1080",
+      "proxyUsername": "user_a",
+      "proxyPassword": "pass_a"
+   },
+   {
+      "refreshToken": "凭据B：显式不走代理（直连）",
+      "authMethod": "social",
+      "proxyUrl": "direct"
+   },
+   {
+      "refreshToken": "凭据C：使用全局代理（或直连，取决于 config.json）",
+      "authMethod": "social"
+   }
+]
+```
+
+### 认证方式
+
+客户端请求本服务时，支持两种认证方式：
+
+1. **x-api-key Header**
+   ```
+   x-api-key: sk-your-api-key
+   ```
+
+2. **Authorization Bearer**
+   ```
+   Authorization: Bearer sk-your-api-key
+   ```
+
+### 环境变量
+
+可通过环境变量配置日志级别：
+
+```bash
+RUST_LOG=debug ./target/release/kiro-rs
+```
+
+## API 端点
+
+### 标准端点 (/v1)
+
+| 端点 | 方法 | 描述 |
+|------|------|------|
+| `/v1/models` | GET | 获取可用模型列表 |
+| `/v1/messages` | POST | 创建消息（对话） |
+| `/v1/messages/count_tokens` | POST | 估算 Token 数量 |
+
+### Claude Code 兼容端点 (/cc/v1)
+
+| 端点 | 方法 | 描述 |
+|------|------|------|
+| `/cc/v1/messages` | POST | 创建消息（缓冲模式，确保 `input_tokens` 准确） |
+| `/cc/v1/messages/count_tokens` | POST | 估算 Token 数量（与 `/v1` 相同） |
+
+> **`/cc/v1/messages` 与 `/v1/messages` 的区别**：
+> - `/v1/messages`：实时流式返回，`message_start` 中的 `input_tokens` 是估算值
+> - `/cc/v1/messages`：缓冲模式，等待上游流完成后，用从 `contextUsageEvent` 计算的准确 `input_tokens` 更正 `message_start`，然后一次性返回所有事件
+> - 等待期间会每 25 秒发送 `ping` 事件保活
+
+### Thinking 模式
+
+支持 Claude 的 extended thinking 功能：
+
+```json
+{
+  "model": "claude-sonnet-4-20250514",
+  "max_tokens": 16000,
+  "thinking": {
+    "type": "enabled",
+    "budget_tokens": 10000
+  },
+  "messages": [...]
+}
+```
+
+### 工具调用
+
+完整支持 Anthropic 的 tool use 功能：
+
+```json
+{
+  "model": "claude-sonnet-4-20250514",
+  "max_tokens": 1024,
+  "tools": [
+    {
+      "name": "get_weather",
+      "description": "获取指定城市的天气",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "city": {"type": "string"}
+        },
+        "required": ["city"]
+      }
+    }
+  ],
+  "messages": [...]
+}
+```
+
+## 模型映射
+
+| Anthropic 模型 | Kiro 模型 |
+|----------------|-----------|
+| `*sonnet*`（含 4-6/4.6） | `claude-sonnet-4.6` |
+| `*sonnet*`（其他） | `claude-sonnet-4.5` |
+| `*opus*`（含 4-5/4.5） | `claude-opus-4.5` |
+| `*opus*`（其他） | `claude-opus-4.6` |
+| `*haiku*` | `claude-haiku-4.5` |
+
+## Admin（可选）
+
+当 `config.json` 配置了非空 `adminApiKey` 时，会启用：
+
+- **Admin API（认证同 API Key）**
+  - `GET /api/admin/credentials` - 获取所有凭据状态
+  - `POST /api/admin/credentials` - 添加新凭据
+  - `DELETE /api/admin/credentials/:id` - 删除凭据
+  - `POST /api/admin/credentials/:id/disabled` - 设置凭据禁用状态
+  - `POST /api/admin/credentials/:id/priority` - 设置凭据优先级
+  - `POST /api/admin/credentials/:id/region` - 设置凭据 Region
+  - `POST /api/admin/credentials/:id/reset` - 重置失败计数
+  - `GET /api/admin/credentials/:id/balance` - 获取凭据余额
+
+- **Admin UI**
+  - `GET /admin` - 访问管理页面（需要在编译前构建 `admin-ui/dist`）
+
+## 注意事项
+
+1. **凭证安全**: 请妥善保管 `credentials.json` 文件，不要提交到版本控制
+2. **Token 刷新**: 服务会自动刷新过期的 Token，无需手动干预
+3. **WebSearch 工具**: 只要 `tools` 中包含 `web_search`（按 name 或 type 判断），就走内置 WebSearch 处理逻辑
+
+## 项目结构
+
+```
+kiro-rs/
+├── src/
+│   ├── main.rs                 # 程序入口
+│   ├── http_client.rs          # HTTP 客户端构建
+│   ├── token.rs                # Token 计算模块
+│   ├── debug.rs                # 调试工具
+│   ├── test.rs                 # 测试
+│   ├── model/                  # 配置和参数模型
+│   │   ├── config.rs           # 应用配置
+│   │   └── arg.rs              # 命令行参数
+│   ├── anthropic/              # Anthropic API 兼容层
+│   │   ├── router.rs           # 路由配置
+│   │   ├── handlers.rs         # 请求处理器
+│   │   ├── middleware.rs       # 认证中间件
+│   │   ├── types.rs            # 类型定义
+│   │   ├── converter.rs        # 协议转换器
+│   │   ├── stream.rs           # 流式响应处理
+│   │   └── websearch.rs        # WebSearch 工具处理
+│   ├── kiro/                   # Kiro API 客户端
+│   │   ├── provider.rs         # API 提供者
+│   │   ├── token_manager.rs    # Token 管理
+│   │   ├── machine_id.rs       # 设备指纹生成
+│   │   ├── model/              # 数据模型
+│   │   │   ├── credentials.rs  # OAuth 凭证
+│   │   │   ├── events/         # 响应事件类型
+│   │   │   ├── requests/       # 请求类型
+│   │   │   ├── common/         # 共享类型
+│   │   │   ├── token_refresh.rs # Token 刷新模型
+│   │   │   └── usage_limits.rs # 使用额度模型
+│   │   └── parser/             # AWS Event Stream 解析器
+│   │       ├── decoder.rs      # 流式解码器
+│   │       ├── frame.rs        # 帧解析
+│   │       ├── header.rs       # 头部解析
+│   │       ├── error.rs        # 错误类型
+│   │       └── crc.rs          # CRC 校验
+│   ├── admin/                  # Admin API 模块
+│   │   ├── router.rs           # 路由配置
+│   │   ├── handlers.rs         # 请求处理器
+│   │   ├── service.rs          # 业务逻辑服务
+│   │   ├── types.rs            # 类型定义
+│   │   ├── middleware.rs       # 认证中间件
+│   │   └── error.rs            # 错误处理
+│   ├── admin_ui/               # Admin UI 静态文件嵌入
+│   │   └── router.rs           # 静态文件路由
+│   └── common/                 # 公共模块
+│       └── auth.rs             # 认证工具函数
+├── admin-ui/                   # Admin UI 前端工程（构建产物会嵌入二进制）
+├── tools/                      # 辅助工具
+├── Cargo.toml                  # 项目配置
+├── config.example.json         # 配置示例
+├── docker-compose.yml          # Docker Compose 配置
+└── Dockerfile                  # Docker 构建文件
+```
+
+## 技术栈
+
+- **Web 框架**: [Axum](https://github.com/tokio-rs/axum) 0.8
+- **异步运行时**: [Tokio](https://tokio.rs/)
+- **HTTP 客户端**: [Reqwest](https://github.com/seanmonstar/reqwest)
+- **序列化**: [Serde](https://serde.rs/)
+- **日志**: [tracing](https://github.com/tokio-rs/tracing)
+- **命令行**: [Clap](https://github.com/clap-rs/clap)
+
+## License
+
+MIT
+
+## 致谢
+
+本项目的实现离不开前辈的努力:  
+ - [kiro2api](https://github.com/caidaoli/kiro2api)
+ - [proxycast](https://github.com/aiclientproxy/proxycast)
+
+本项目部分逻辑参考了以上的项目, 再次由衷的感谢!
diff --git a/VERSION b/VERSION
new file mode 100644
index 0000000..261f347
--- /dev/null
+++ b/VERSION
@@ -0,0 +1 @@
+v1.1.5
\ No newline at end of file
diff --git a/admin-ui/bun.lock b/admin-ui/bun.lock
new file mode 100644
index 0000000..4aed436
--- /dev/null
+++ b/admin-ui/bun.lock
@@ -0,0 +1,480 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "kiro-admin-ui",
+      "dependencies": {
+        "@radix-ui/react-dialog": "^1.1.15",
+        "@radix-ui/react-dropdown-menu": "^2.1.16",
+        "@radix-ui/react-slot": "^1.2.4",
+        "@radix-ui/react-switch": "^1.2.6",
+        "@radix-ui/react-toast": "^1.2.15",
+        "@radix-ui/react-tooltip": "^1.2.8",
+        "@tanstack/react-query": "^5.90.20",
+        "axios": "^1.13.4",
+        "class-variance-authority": "^0.7.1",
+        "clsx": "^2.1.1",
+        "lucide-react": "^0.563.0",
+        "react": "^19.2.4",
+        "react-dom": "^19.2.4",
+        "sonner": "^2.0.7",
+        "tailwind-merge": "^3.4.0",
+      },
+      "devDependencies": {
+        "@tailwindcss/postcss": "^4.1.18",
+        "@types/react": "^19.2.10",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react-swc": "^4.2.2",
+        "autoprefixer": "^10.4.24",
+        "postcss": "^8.5.6",
+        "tailwindcss": "^4.1.18",
+        "typescript": "^5.9.3",
+        "vite": "^7.3.1",
+      },
+    },
+  },
+  "packages": {
+    "@alloc/quick-lru": ["@alloc/quick-lru@5.2.0", "https://registry.npmmirror.com/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", {}, "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.2", "https://registry.npmmirror.com/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz", { "os": "aix", "cpu": "ppc64" }, "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.27.2", "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.27.2.tgz", { "os": "android", "cpu": "arm" }, "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz", { "os": "android", "cpu": "arm64" }, "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.27.2.tgz", { "os": "android", "cpu": "x64" }, "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz", { "os": "darwin", "cpu": "arm64" }, "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz", { "os": "darwin", "cpu": "x64" }, "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz", { "os": "freebsd", "cpu": "arm64" }, "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz", { "os": "freebsd", "cpu": "x64" }, "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz", { "os": "linux", "cpu": "arm" }, "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz", { "os": "linux", "cpu": "ia32" }, "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz", { "os": "linux", "cpu": "none" }, "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz", { "os": "linux", "cpu": "none" }, "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz", { "os": "linux", "cpu": "ppc64" }, "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz", { "os": "linux", "cpu": "none" }, "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz", { "os": "linux", "cpu": "s390x" }, "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz", { "os": "linux", "cpu": "x64" }, "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz", { "os": "none", "cpu": "arm64" }, "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz", { "os": "none", "cpu": "x64" }, "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz", { "os": "openbsd", "cpu": "arm64" }, "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz", { "os": "openbsd", "cpu": "x64" }, "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz", { "os": "none", "cpu": "arm64" }, "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz", { "os": "sunos", "cpu": "x64" }, "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.2", "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz", { "os": "win32", "cpu": "arm64" }, "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.2", "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz", { "os": "win32", "cpu": "ia32" }, "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.2", "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz", { "os": "win32", "cpu": "x64" }, "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ=="],
+
+    "@floating-ui/core": ["@floating-ui/core@1.7.4", "https://registry.npmmirror.com/@floating-ui/core/-/core-1.7.4.tgz", { "dependencies": { "@floating-ui/utils": "^0.2.10" } }, "sha512-C3HlIdsBxszvm5McXlB8PeOEWfBhcGBTZGkGlWc2U0KFY5IwG5OQEuQ8rq52DZmcHDlPLd+YFBK+cZcytwIFWg=="],
+
+    "@floating-ui/dom": ["@floating-ui/dom@1.7.5", "https://registry.npmmirror.com/@floating-ui/dom/-/dom-1.7.5.tgz", { "dependencies": { "@floating-ui/core": "^1.7.4", "@floating-ui/utils": "^0.2.10" } }, "sha512-N0bD2kIPInNHUHehXhMke1rBGs1dwqvC9O9KYMyyjK7iXt7GAhnro7UlcuYcGdS/yYOlq0MAVgrow8IbWJwyqg=="],
+
+    "@floating-ui/react-dom": ["@floating-ui/react-dom@2.1.7", "https://registry.npmmirror.com/@floating-ui/react-dom/-/react-dom-2.1.7.tgz", { "dependencies": { "@floating-ui/dom": "^1.7.5" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg=="],
+
+    "@floating-ui/utils": ["@floating-ui/utils@0.2.10", "https://registry.npmmirror.com/@floating-ui/utils/-/utils-0.2.10.tgz", {}, "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "https://registry.npmmirror.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
+
+    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "https://registry.npmmirror.com/@jridgewell/remapping/-/remapping-2.3.5.tgz", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "https://registry.npmmirror.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "https://registry.npmmirror.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "https://registry.npmmirror.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
+
+    "@radix-ui/primitive": ["@radix-ui/primitive@1.1.3", "https://registry.npmmirror.com/@radix-ui/primitive/-/primitive-1.1.3.tgz", {}, "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg=="],
+
+    "@radix-ui/react-arrow": ["@radix-ui/react-arrow@1.1.7", "https://registry.npmmirror.com/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w=="],
+
+    "@radix-ui/react-collection": ["@radix-ui/react-collection@1.1.7", "https://registry.npmmirror.com/@radix-ui/react-collection/-/react-collection-1.1.7.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw=="],
+
+    "@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.2", "https://registry.npmmirror.com/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg=="],
+
+    "@radix-ui/react-context": ["@radix-ui/react-context@1.1.2", "https://registry.npmmirror.com/@radix-ui/react-context/-/react-context-1.1.2.tgz", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA=="],
+
+    "@radix-ui/react-dialog": ["@radix-ui/react-dialog@1.1.15", "https://registry.npmmirror.com/@radix-ui/react-dialog/-/react-dialog-1.1.15.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw=="],
+
+    "@radix-ui/react-direction": ["@radix-ui/react-direction@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-direction/-/react-direction-1.1.1.tgz", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw=="],
+
+    "@radix-ui/react-dismissable-layer": ["@radix-ui/react-dismissable-layer@1.1.11", "https://registry.npmmirror.com/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-escape-keydown": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg=="],
+
+    "@radix-ui/react-dropdown-menu": ["@radix-ui/react-dropdown-menu@2.1.16", "https://registry.npmmirror.com/@radix-ui/react-dropdown-menu/-/react-dropdown-menu-2.1.16.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-menu": "2.1.16", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw=="],
+
+    "@radix-ui/react-focus-guards": ["@radix-ui/react-focus-guards@1.1.3", "https://registry.npmmirror.com/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw=="],
+
+    "@radix-ui/react-focus-scope": ["@radix-ui/react-focus-scope@1.1.7", "https://registry.npmmirror.com/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw=="],
+
+    "@radix-ui/react-id": ["@radix-ui/react-id@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-id/-/react-id-1.1.1.tgz", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg=="],
+
+    "@radix-ui/react-menu": ["@radix-ui/react-menu@2.1.16", "https://registry.npmmirror.com/@radix-ui/react-menu/-/react-menu-2.1.16.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-callback-ref": "1.1.1", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.6.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg=="],
+
+    "@radix-ui/react-popper": ["@radix-ui/react-popper@1.2.8", "https://registry.npmmirror.com/@radix-ui/react-popper/-/react-popper-1.2.8.tgz", { "dependencies": { "@floating-ui/react-dom": "^2.0.0", "@radix-ui/react-arrow": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-rect": "1.1.1", "@radix-ui/react-use-size": "1.1.1", "@radix-ui/rect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw=="],
+
+    "@radix-ui/react-portal": ["@radix-ui/react-portal@1.1.9", "https://registry.npmmirror.com/@radix-ui/react-portal/-/react-portal-1.1.9.tgz", { "dependencies": { "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ=="],
+
+    "@radix-ui/react-presence": ["@radix-ui/react-presence@1.1.5", "https://registry.npmmirror.com/@radix-ui/react-presence/-/react-presence-1.1.5.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ=="],
+
+    "@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.3", "https://registry.npmmirror.com/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz", { "dependencies": { "@radix-ui/react-slot": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ=="],
+
+    "@radix-ui/react-roving-focus": ["@radix-ui/react-roving-focus@1.1.11", "https://registry.npmmirror.com/@radix-ui/react-roving-focus/-/react-roving-focus-1.1.11.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA=="],
+
+    "@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.4", "https://registry.npmmirror.com/@radix-ui/react-slot/-/react-slot-1.2.4.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA=="],
+
+    "@radix-ui/react-switch": ["@radix-ui/react-switch@1.2.6", "https://registry.npmmirror.com/@radix-ui/react-switch/-/react-switch-1.2.6.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-previous": "1.1.1", "@radix-ui/react-use-size": "1.1.1" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ=="],
+
+    "@radix-ui/react-toast": ["@radix-ui/react-toast@1.2.15", "https://registry.npmmirror.com/@radix-ui/react-toast/-/react-toast-1.2.15.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-3OSz3TacUWy4WtOXV38DggwxoqJK4+eDkNMl5Z/MJZaoUPaP4/9lf81xXMe1I2ReTAptverZUpbPY4wWwWyL5g=="],
+
+    "@radix-ui/react-tooltip": ["@radix-ui/react-tooltip@1.2.8", "https://registry.npmmirror.com/@radix-ui/react-tooltip/-/react-tooltip-1.2.8.tgz", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-id": "1.1.1", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg=="],
+
+    "@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg=="],
+
+    "@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.2", "https://registry.npmmirror.com/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz", { "dependencies": { "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg=="],
+
+    "@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.2", "https://registry.npmmirror.com/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA=="],
+
+    "@radix-ui/react-use-escape-keydown": ["@radix-ui/react-use-escape-keydown@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz", { "dependencies": { "@radix-ui/react-use-callback-ref": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g=="],
+
+    "@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ=="],
+
+    "@radix-ui/react-use-previous": ["@radix-ui/react-use-previous@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ=="],
+
+    "@radix-ui/react-use-rect": ["@radix-ui/react-use-rect@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz", { "dependencies": { "@radix-ui/rect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w=="],
+
+    "@radix-ui/react-use-size": ["@radix-ui/react-use-size@1.1.1", "https://registry.npmmirror.com/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.1" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ=="],
+
+    "@radix-ui/react-visually-hidden": ["@radix-ui/react-visually-hidden@1.2.3", "https://registry.npmmirror.com/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug=="],
+
+    "@radix-ui/rect": ["@radix-ui/rect@1.1.1", "https://registry.npmmirror.com/@radix-ui/rect/-/rect-1.1.1.tgz", {}, "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw=="],
+
+    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.47", "https://registry.npmmirror.com/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.47.tgz", {}, "sha512-8QagwMH3kNCuzD8EWL8R2YPW5e4OrHNSAHRFDdmFqEwEaD/KcNKjVoumo+gP2vW5eKB2UPbM6vTYiGZX0ixLnw=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.57.1.tgz", { "os": "android", "cpu": "arm" }, "sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.57.1.tgz", { "os": "android", "cpu": "arm64" }, "sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.57.1.tgz", { "os": "darwin", "cpu": "arm64" }, "sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.57.1.tgz", { "os": "darwin", "cpu": "x64" }, "sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.57.1.tgz", { "os": "freebsd", "cpu": "arm64" }, "sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.57.1.tgz", { "os": "freebsd", "cpu": "x64" }, "sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.57.1.tgz", { "os": "linux", "cpu": "arm" }, "sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.57.1.tgz", { "os": "linux", "cpu": "arm" }, "sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.57.1.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.57.1.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q=="],
+
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.57.1.tgz", { "os": "linux", "cpu": "none" }, "sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA=="],
+
+    "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.57.1.tgz", { "os": "linux", "cpu": "none" }, "sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.57.1.tgz", { "os": "linux", "cpu": "ppc64" }, "sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w=="],
+
+    "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.57.1.tgz", { "os": "linux", "cpu": "ppc64" }, "sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.57.1.tgz", { "os": "linux", "cpu": "none" }, "sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.57.1.tgz", { "os": "linux", "cpu": "none" }, "sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.57.1.tgz", { "os": "linux", "cpu": "s390x" }, "sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.57.1.tgz", { "os": "linux", "cpu": "x64" }, "sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.57.1.tgz", { "os": "linux", "cpu": "x64" }, "sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw=="],
+
+    "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.57.1.tgz", { "os": "openbsd", "cpu": "x64" }, "sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw=="],
+
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.57.1.tgz", { "os": "none", "cpu": "arm64" }, "sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.57.1.tgz", { "os": "win32", "cpu": "arm64" }, "sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.57.1.tgz", { "os": "win32", "cpu": "ia32" }, "sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.57.1.tgz", { "os": "win32", "cpu": "x64" }, "sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.57.1", "https://registry.npmmirror.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.57.1.tgz", { "os": "win32", "cpu": "x64" }, "sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA=="],
+
+    "@swc/core": ["@swc/core@1.15.11", "https://registry.npmmirror.com/@swc/core/-/core-1.15.11.tgz", { "dependencies": { "@swc/counter": "^0.1.3", "@swc/types": "^0.1.25" }, "optionalDependencies": { "@swc/core-darwin-arm64": "1.15.11", "@swc/core-darwin-x64": "1.15.11", "@swc/core-linux-arm-gnueabihf": "1.15.11", "@swc/core-linux-arm64-gnu": "1.15.11", "@swc/core-linux-arm64-musl": "1.15.11", "@swc/core-linux-x64-gnu": "1.15.11", "@swc/core-linux-x64-musl": "1.15.11", "@swc/core-win32-arm64-msvc": "1.15.11", "@swc/core-win32-ia32-msvc": "1.15.11", "@swc/core-win32-x64-msvc": "1.15.11" }, "peerDependencies": { "@swc/helpers": ">=0.5.17" }, "optionalPeers": ["@swc/helpers"] }, "sha512-iLmLTodbYxU39HhMPaMUooPwO/zqJWvsqkrXv1ZI38rMb048p6N7qtAtTp37sw9NzSrvH6oli8EdDygo09IZ/w=="],
+
+    "@swc/core-darwin-arm64": ["@swc/core-darwin-arm64@1.15.11", "https://registry.npmmirror.com/@swc/core-darwin-arm64/-/core-darwin-arm64-1.15.11.tgz", { "os": "darwin", "cpu": "arm64" }, "sha512-QoIupRWVH8AF1TgxYyeA5nS18dtqMuxNwchjBIwJo3RdwLEFiJq6onOx9JAxHtuPwUkIVuU2Xbp+jCJ7Vzmgtg=="],
+
+    "@swc/core-darwin-x64": ["@swc/core-darwin-x64@1.15.11", "https://registry.npmmirror.com/@swc/core-darwin-x64/-/core-darwin-x64-1.15.11.tgz", { "os": "darwin", "cpu": "x64" }, "sha512-S52Gu1QtPSfBYDiejlcfp9GlN+NjTZBRRNsz8PNwBgSE626/FUf2PcllVUix7jqkoMC+t0rS8t+2/aSWlMuQtA=="],
+
+    "@swc/core-linux-arm-gnueabihf": ["@swc/core-linux-arm-gnueabihf@1.15.11", "https://registry.npmmirror.com/@swc/core-linux-arm-gnueabihf/-/core-linux-arm-gnueabihf-1.15.11.tgz", { "os": "linux", "cpu": "arm" }, "sha512-lXJs8oXo6Z4yCpimpQ8vPeCjkgoHu5NoMvmJZ8qxDyU99KVdg6KwU9H79vzrmB+HfH+dCZ7JGMqMF//f8Cfvdg=="],
+
+    "@swc/core-linux-arm64-gnu": ["@swc/core-linux-arm64-gnu@1.15.11", "https://registry.npmmirror.com/@swc/core-linux-arm64-gnu/-/core-linux-arm64-gnu-1.15.11.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-chRsz1K52/vj8Mfq/QOugVphlKPWlMh10V99qfH41hbGvwAU6xSPd681upO4bKiOr9+mRIZZW+EfJqY42ZzRyA=="],
+
+    "@swc/core-linux-arm64-musl": ["@swc/core-linux-arm64-musl@1.15.11", "https://registry.npmmirror.com/@swc/core-linux-arm64-musl/-/core-linux-arm64-musl-1.15.11.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-PYftgsTaGnfDK4m6/dty9ryK1FbLk+LosDJ/RJR2nkXGc8rd+WenXIlvHjWULiBVnS1RsjHHOXmTS4nDhe0v0w=="],
+
+    "@swc/core-linux-x64-gnu": ["@swc/core-linux-x64-gnu@1.15.11", "https://registry.npmmirror.com/@swc/core-linux-x64-gnu/-/core-linux-x64-gnu-1.15.11.tgz", { "os": "linux", "cpu": "x64" }, "sha512-DKtnJKIHiZdARyTKiX7zdRjiDS1KihkQWatQiCHMv+zc2sfwb4Glrodx2VLOX4rsa92NLR0Sw8WLcPEMFY1szQ=="],
+
+    "@swc/core-linux-x64-musl": ["@swc/core-linux-x64-musl@1.15.11", "https://registry.npmmirror.com/@swc/core-linux-x64-musl/-/core-linux-x64-musl-1.15.11.tgz", { "os": "linux", "cpu": "x64" }, "sha512-mUjjntHj4+8WBaiDe5UwRNHuEzLjIWBTSGTw0JT9+C9/Yyuh4KQqlcEQ3ro6GkHmBGXBFpGIj/o5VMyRWfVfWw=="],
+
+    "@swc/core-win32-arm64-msvc": ["@swc/core-win32-arm64-msvc@1.15.11", "https://registry.npmmirror.com/@swc/core-win32-arm64-msvc/-/core-win32-arm64-msvc-1.15.11.tgz", { "os": "win32", "cpu": "arm64" }, "sha512-ZkNNG5zL49YpaFzfl6fskNOSxtcZ5uOYmWBkY4wVAvgbSAQzLRVBp+xArGWh2oXlY/WgL99zQSGTv7RI5E6nzA=="],
+
+    "@swc/core-win32-ia32-msvc": ["@swc/core-win32-ia32-msvc@1.15.11", "https://registry.npmmirror.com/@swc/core-win32-ia32-msvc/-/core-win32-ia32-msvc-1.15.11.tgz", { "os": "win32", "cpu": "ia32" }, "sha512-6XnzORkZCQzvTQ6cPrU7iaT9+i145oLwnin8JrfsLG41wl26+5cNQ2XV3zcbrnFEV6esjOceom9YO1w9mGJByw=="],
+
+    "@swc/core-win32-x64-msvc": ["@swc/core-win32-x64-msvc@1.15.11", "https://registry.npmmirror.com/@swc/core-win32-x64-msvc/-/core-win32-x64-msvc-1.15.11.tgz", { "os": "win32", "cpu": "x64" }, "sha512-IQ2n6af7XKLL6P1gIeZACskSxK8jWtoKpJWLZmdXTDj1MGzktUy4i+FvpdtxFmJWNavRWH1VmTr6kAubRDHeKw=="],
+
+    "@swc/counter": ["@swc/counter@0.1.3", "https://registry.npmmirror.com/@swc/counter/-/counter-0.1.3.tgz", {}, "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ=="],
+
+    "@swc/types": ["@swc/types@0.1.25", "https://registry.npmmirror.com/@swc/types/-/types-0.1.25.tgz", { "dependencies": { "@swc/counter": "^0.1.3" } }, "sha512-iAoY/qRhNH8a/hBvm3zKj9qQ4oc2+3w1unPJa2XvTK3XjeLXtzcCingVPw/9e5mn1+0yPqxcBGp9Jf0pkfMb1g=="],
+
+    "@tailwindcss/node": ["@tailwindcss/node@4.1.18", "https://registry.npmmirror.com/@tailwindcss/node/-/node-4.1.18.tgz", { "dependencies": { "@jridgewell/remapping": "^2.3.4", "enhanced-resolve": "^5.18.3", "jiti": "^2.6.1", "lightningcss": "1.30.2", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", "tailwindcss": "4.1.18" } }, "sha512-DoR7U1P7iYhw16qJ49fgXUlry1t4CpXeErJHnQ44JgTSKMaZUdf17cfn5mHchfJ4KRBZRFA/Coo+MUF5+gOaCQ=="],
+
+    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide/-/oxide-4.1.18.tgz", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.1.18", "@tailwindcss/oxide-darwin-arm64": "4.1.18", "@tailwindcss/oxide-darwin-x64": "4.1.18", "@tailwindcss/oxide-freebsd-x64": "4.1.18", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.18", "@tailwindcss/oxide-linux-arm64-gnu": "4.1.18", "@tailwindcss/oxide-linux-arm64-musl": "4.1.18", "@tailwindcss/oxide-linux-x64-gnu": "4.1.18", "@tailwindcss/oxide-linux-x64-musl": "4.1.18", "@tailwindcss/oxide-wasm32-wasi": "4.1.18", "@tailwindcss/oxide-win32-arm64-msvc": "4.1.18", "@tailwindcss/oxide-win32-x64-msvc": "4.1.18" } }, "sha512-EgCR5tTS5bUSKQgzeMClT6iCY3ToqE1y+ZB0AKldj809QXk1Y+3jB0upOYZrn9aGIzPtUsP7sX4QQ4XtjBB95A=="],
+
+    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.1.18.tgz", { "os": "android", "cpu": "arm64" }, "sha512-dJHz7+Ugr9U/diKJA0W6N/6/cjI+ZTAoxPf9Iz9BFRF2GzEX8IvXxFIi/dZBloVJX/MZGvRuFA9rqwdiIEZQ0Q=="],
+
+    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.1.18.tgz", { "os": "darwin", "cpu": "arm64" }, "sha512-Gc2q4Qhs660bhjyBSKgq6BYvwDz4G+BuyJ5H1xfhmDR3D8HnHCmT/BSkvSL0vQLy/nkMLY20PQ2OoYMO15Jd0A=="],
+
+    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.1.18.tgz", { "os": "darwin", "cpu": "x64" }, "sha512-FL5oxr2xQsFrc3X9o1fjHKBYBMD1QZNyc1Xzw/h5Qu4XnEBi3dZn96HcHm41c/euGV+GRiXFfh2hUCyKi/e+yw=="],
+
+    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.1.18.tgz", { "os": "freebsd", "cpu": "x64" }, "sha512-Fj+RHgu5bDodmV1dM9yAxlfJwkkWvLiRjbhuO2LEtwtlYlBgiAT4x/j5wQr1tC3SANAgD+0YcmWVrj8R9trVMA=="],
+
+    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.1.18.tgz", { "os": "linux", "cpu": "arm" }, "sha512-Fp+Wzk/Ws4dZn+LV2Nqx3IilnhH51YZoRaYHQsVq3RQvEl+71VGKFpkfHrLM/Li+kt5c0DJe/bHXK1eHgDmdiA=="],
+
+    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.1.18.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-S0n3jboLysNbh55Vrt7pk9wgpyTTPD0fdQeh7wQfMqLPM/Hrxi+dVsLsPrycQjGKEQk85Kgbx+6+QnYNiHalnw=="],
+
+    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.1.18.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-1px92582HkPQlaaCkdRcio71p8bc8i/ap5807tPRDK/uw953cauQBT8c5tVGkOwrHMfc2Yh6UuxaH4vtTjGvHg=="],
+
+    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.1.18.tgz", { "os": "linux", "cpu": "x64" }, "sha512-v3gyT0ivkfBLoZGF9LyHmts0Isc8jHZyVcbzio6Wpzifg/+5ZJpDiRiUhDLkcr7f/r38SWNe7ucxmGW3j3Kb/g=="],
+
+    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.1.18.tgz", { "os": "linux", "cpu": "x64" }, "sha512-bhJ2y2OQNlcRwwgOAGMY0xTFStt4/wyU6pvI6LSuZpRgKQwxTec0/3Scu91O8ir7qCR3AuepQKLU/kX99FouqQ=="],
+
+    "@tailwindcss/oxide-wasm32-wasi": ["@tailwindcss/oxide-wasm32-wasi@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.1.18.tgz", { "dependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1", "@emnapi/wasi-threads": "^1.1.0", "@napi-rs/wasm-runtime": "^1.1.0", "@tybys/wasm-util": "^0.10.1", "tslib": "^2.4.0" }, "cpu": "none" }, "sha512-LffYTvPjODiP6PT16oNeUQJzNVyJl1cjIebq/rWWBF+3eDst5JGEFSc5cWxyRCJ0Mxl+KyIkqRxk1XPEs9x8TA=="],
+
+    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.1.18.tgz", { "os": "win32", "cpu": "arm64" }, "sha512-HjSA7mr9HmC8fu6bdsZvZ+dhjyGCLdotjVOgLA2vEqxEBZaQo9YTX4kwgEvPCpRh8o4uWc4J/wEoFzhEmjvPbA=="],
+
+    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.1.18", "https://registry.npmmirror.com/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.1.18.tgz", { "os": "win32", "cpu": "x64" }, "sha512-bJWbyYpUlqamC8dpR7pfjA0I7vdF6t5VpUGMWRkXVE3AXgIZjYUYAK7II1GNaxR8J1SSrSrppRar8G++JekE3Q=="],
+
+    "@tailwindcss/postcss": ["@tailwindcss/postcss@4.1.18", "https://registry.npmmirror.com/@tailwindcss/postcss/-/postcss-4.1.18.tgz", { "dependencies": { "@alloc/quick-lru": "^5.2.0", "@tailwindcss/node": "4.1.18", "@tailwindcss/oxide": "4.1.18", "postcss": "^8.4.41", "tailwindcss": "4.1.18" } }, "sha512-Ce0GFnzAOuPyfV5SxjXGn0CubwGcuDB0zcdaPuCSzAa/2vII24JTkH+I6jcbXLb1ctjZMZZI6OjDaLPJQL1S0g=="],
+
+    "@tanstack/query-core": ["@tanstack/query-core@5.90.20", "https://registry.npmmirror.com/@tanstack/query-core/-/query-core-5.90.20.tgz", {}, "sha512-OMD2HLpNouXEfZJWcKeVKUgQ5n+n3A2JFmBaScpNDUqSrQSjiveC7dKMe53uJUg1nDG16ttFPz2xfilz6i2uVg=="],
+
+    "@tanstack/react-query": ["@tanstack/react-query@5.90.20", "https://registry.npmmirror.com/@tanstack/react-query/-/react-query-5.90.20.tgz", { "dependencies": { "@tanstack/query-core": "5.90.20" }, "peerDependencies": { "react": "^18 || ^19" } }, "sha512-vXBxa+qeyveVO7OA0jX1z+DeyCA4JKnThKv411jd5SORpBKgkcVnYKCiBgECvADvniBX7tobwBmg01qq9JmMJw=="],
+
+    "@types/estree": ["@types/estree@1.0.8", "https://registry.npmmirror.com/@types/estree/-/estree-1.0.8.tgz", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
+
+    "@types/react": ["@types/react@19.2.10", "https://registry.npmmirror.com/@types/react/-/react-19.2.10.tgz", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-WPigyYuGhgZ/cTPRXB2EwUw+XvsRA3GqHlsP4qteqrnnjDrApbS7MxcGr/hke5iUoeB7E/gQtrs9I37zAJ0Vjw=="],
+
+    "@types/react-dom": ["@types/react-dom@19.2.3", "https://registry.npmmirror.com/@types/react-dom/-/react-dom-19.2.3.tgz", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ=="],
+
+    "@vitejs/plugin-react-swc": ["@vitejs/plugin-react-swc@4.2.2", "https://registry.npmmirror.com/@vitejs/plugin-react-swc/-/plugin-react-swc-4.2.2.tgz", { "dependencies": { "@rolldown/pluginutils": "1.0.0-beta.47", "@swc/core": "^1.13.5" }, "peerDependencies": { "vite": "^4 || ^5 || ^6 || ^7" } }, "sha512-x+rE6tsxq/gxrEJN3Nv3dIV60lFflPj94c90b+NNo6n1QV1QQUTLoL0MpaOVasUZ0zqVBn7ead1B5ecx1JAGfA=="],
+
+    "aria-hidden": ["aria-hidden@1.2.6", "https://registry.npmmirror.com/aria-hidden/-/aria-hidden-1.2.6.tgz", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="],
+
+    "asynckit": ["asynckit@0.4.0", "https://registry.npmmirror.com/asynckit/-/asynckit-0.4.0.tgz", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
+
+    "autoprefixer": ["autoprefixer@10.4.24", "https://registry.npmmirror.com/autoprefixer/-/autoprefixer-10.4.24.tgz", { "dependencies": { "browserslist": "^4.28.1", "caniuse-lite": "^1.0.30001766", "fraction.js": "^5.3.4", "picocolors": "^1.1.1", "postcss-value-parser": "^4.2.0" }, "peerDependencies": { "postcss": "^8.1.0" }, "bin": { "autoprefixer": "bin/autoprefixer" } }, "sha512-uHZg7N9ULTVbutaIsDRoUkoS8/h3bdsmVJYZ5l3wv8Cp/6UIIoRDm90hZ+BwxUj/hGBEzLxdHNSKuFpn8WOyZw=="],
+
+    "axios": ["axios@1.13.4", "https://registry.npmmirror.com/axios/-/axios-1.13.4.tgz", { "dependencies": { "follow-redirects": "^1.15.6", "form-data": "^4.0.4", "proxy-from-env": "^1.1.0" } }, "sha512-1wVkUaAO6WyaYtCkcYCOx12ZgpGf9Zif+qXa4n+oYzK558YryKqiL6UWwd5DqiH3VRW0GYhTZQ/vlgJrCoNQlg=="],
+
+    "baseline-browser-mapping": ["baseline-browser-mapping@2.9.19", "https://registry.npmmirror.com/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz", { "bin": { "baseline-browser-mapping": "dist/cli.js" } }, "sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg=="],
+
+    "browserslist": ["browserslist@4.28.1", "https://registry.npmmirror.com/browserslist/-/browserslist-4.28.1.tgz", { "dependencies": { "baseline-browser-mapping": "^2.9.0", "caniuse-lite": "^1.0.30001759", "electron-to-chromium": "^1.5.263", "node-releases": "^2.0.27", "update-browserslist-db": "^1.2.0" }, "bin": { "browserslist": "cli.js" } }, "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA=="],
+
+    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "https://registry.npmmirror.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
+
+    "caniuse-lite": ["caniuse-lite@1.0.30001766", "https://registry.npmmirror.com/caniuse-lite/-/caniuse-lite-1.0.30001766.tgz", {}, "sha512-4C0lfJ0/YPjJQHagaE9x2Elb69CIqEPZeG0anQt9SIvIoOH4a4uaRl73IavyO+0qZh6MDLH//DrXThEYKHkmYA=="],
+
+    "class-variance-authority": ["class-variance-authority@0.7.1", "https://registry.npmmirror.com/class-variance-authority/-/class-variance-authority-0.7.1.tgz", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="],
+
+    "clsx": ["clsx@2.1.1", "https://registry.npmmirror.com/clsx/-/clsx-2.1.1.tgz", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
+
+    "combined-stream": ["combined-stream@1.0.8", "https://registry.npmmirror.com/combined-stream/-/combined-stream-1.0.8.tgz", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="],
+
+    "csstype": ["csstype@3.2.3", "https://registry.npmmirror.com/csstype/-/csstype-3.2.3.tgz", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
+
+    "delayed-stream": ["delayed-stream@1.0.0", "https://registry.npmmirror.com/delayed-stream/-/delayed-stream-1.0.0.tgz", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
+
+    "detect-libc": ["detect-libc@2.1.2", "https://registry.npmmirror.com/detect-libc/-/detect-libc-2.1.2.tgz", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
+
+    "detect-node-es": ["detect-node-es@1.1.0", "https://registry.npmmirror.com/detect-node-es/-/detect-node-es-1.1.0.tgz", {}, "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="],
+
+    "dunder-proto": ["dunder-proto@1.0.1", "https://registry.npmmirror.com/dunder-proto/-/dunder-proto-1.0.1.tgz", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
+
+    "electron-to-chromium": ["electron-to-chromium@1.5.283", "https://registry.npmmirror.com/electron-to-chromium/-/electron-to-chromium-1.5.283.tgz", {}, "sha512-3vifjt1HgrGW/h76UEeny+adYApveS9dH2h3p57JYzBSXJIKUJAvtmIytDKjcSCt9xHfrNCFJ7gts6vkhuq++w=="],
+
+    "enhanced-resolve": ["enhanced-resolve@5.18.4", "https://registry.npmmirror.com/enhanced-resolve/-/enhanced-resolve-5.18.4.tgz", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.2.0" } }, "sha512-LgQMM4WXU3QI+SYgEc2liRgznaD5ojbmY3sb8LxyguVkIg5FxdpTkvk72te2R38/TGKxH634oLxXRGY6d7AP+Q=="],
+
+    "es-define-property": ["es-define-property@1.0.1", "https://registry.npmmirror.com/es-define-property/-/es-define-property-1.0.1.tgz", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
+
+    "es-errors": ["es-errors@1.3.0", "https://registry.npmmirror.com/es-errors/-/es-errors-1.3.0.tgz", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
+
+    "es-object-atoms": ["es-object-atoms@1.1.1", "https://registry.npmmirror.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
+
+    "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "https://registry.npmmirror.com/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="],
+
+    "esbuild": ["esbuild@0.27.2", "https://registry.npmmirror.com/esbuild/-/esbuild-0.27.2.tgz", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.2", "@esbuild/android-arm": "0.27.2", "@esbuild/android-arm64": "0.27.2", "@esbuild/android-x64": "0.27.2", "@esbuild/darwin-arm64": "0.27.2", "@esbuild/darwin-x64": "0.27.2", "@esbuild/freebsd-arm64": "0.27.2", "@esbuild/freebsd-x64": "0.27.2", "@esbuild/linux-arm": "0.27.2", "@esbuild/linux-arm64": "0.27.2", "@esbuild/linux-ia32": "0.27.2", "@esbuild/linux-loong64": "0.27.2", "@esbuild/linux-mips64el": "0.27.2", "@esbuild/linux-ppc64": "0.27.2", "@esbuild/linux-riscv64": "0.27.2", "@esbuild/linux-s390x": "0.27.2", "@esbuild/linux-x64": "0.27.2", "@esbuild/netbsd-arm64": "0.27.2", "@esbuild/netbsd-x64": "0.27.2", "@esbuild/openbsd-arm64": "0.27.2", "@esbuild/openbsd-x64": "0.27.2", "@esbuild/openharmony-arm64": "0.27.2", "@esbuild/sunos-x64": "0.27.2", "@esbuild/win32-arm64": "0.27.2", "@esbuild/win32-ia32": "0.27.2", "@esbuild/win32-x64": "0.27.2" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw=="],
+
+    "escalade": ["escalade@3.2.0", "https://registry.npmmirror.com/escalade/-/escalade-3.2.0.tgz", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
+
+    "fdir": ["fdir@6.5.0", "https://registry.npmmirror.com/fdir/-/fdir-6.5.0.tgz", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "follow-redirects": ["follow-redirects@1.15.11", "https://registry.npmmirror.com/follow-redirects/-/follow-redirects-1.15.11.tgz", {}, "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ=="],
+
+    "form-data": ["form-data@4.0.5", "https://registry.npmmirror.com/form-data/-/form-data-4.0.5.tgz", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w=="],
+
+    "fraction.js": ["fraction.js@5.3.4", "https://registry.npmmirror.com/fraction.js/-/fraction.js-5.3.4.tgz", {}, "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ=="],
+
+    "fsevents": ["fsevents@2.3.3", "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "function-bind": ["function-bind@1.1.2", "https://registry.npmmirror.com/function-bind/-/function-bind-1.1.2.tgz", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
+
+    "get-intrinsic": ["get-intrinsic@1.3.0", "https://registry.npmmirror.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
+
+    "get-nonce": ["get-nonce@1.0.1", "https://registry.npmmirror.com/get-nonce/-/get-nonce-1.0.1.tgz", {}, "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q=="],
+
+    "get-proto": ["get-proto@1.0.1", "https://registry.npmmirror.com/get-proto/-/get-proto-1.0.1.tgz", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
+
+    "gopd": ["gopd@1.2.0", "https://registry.npmmirror.com/gopd/-/gopd-1.2.0.tgz", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
+
+    "graceful-fs": ["graceful-fs@4.2.11", "https://registry.npmmirror.com/graceful-fs/-/graceful-fs-4.2.11.tgz", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
+    "has-symbols": ["has-symbols@1.1.0", "https://registry.npmmirror.com/has-symbols/-/has-symbols-1.1.0.tgz", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
+
+    "has-tostringtag": ["has-tostringtag@1.0.2", "https://registry.npmmirror.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
+
+    "hasown": ["hasown@2.0.2", "https://registry.npmmirror.com/hasown/-/hasown-2.0.2.tgz", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
+
+    "jiti": ["jiti@2.6.1", "https://registry.npmmirror.com/jiti/-/jiti-2.6.1.tgz", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ=="],
+
+    "lightningcss": ["lightningcss@1.30.2", "https://registry.npmmirror.com/lightningcss/-/lightningcss-1.30.2.tgz", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.30.2", "lightningcss-darwin-arm64": "1.30.2", "lightningcss-darwin-x64": "1.30.2", "lightningcss-freebsd-x64": "1.30.2", "lightningcss-linux-arm-gnueabihf": "1.30.2", "lightningcss-linux-arm64-gnu": "1.30.2", "lightningcss-linux-arm64-musl": "1.30.2", "lightningcss-linux-x64-gnu": "1.30.2", "lightningcss-linux-x64-musl": "1.30.2", "lightningcss-win32-arm64-msvc": "1.30.2", "lightningcss-win32-x64-msvc": "1.30.2" } }, "sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ=="],
+
+    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.30.2", "https://registry.npmmirror.com/lightningcss-android-arm64/-/lightningcss-android-arm64-1.30.2.tgz", { "os": "android", "cpu": "arm64" }, "sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A=="],
+
+    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.30.2", "https://registry.npmmirror.com/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.30.2.tgz", { "os": "darwin", "cpu": "arm64" }, "sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA=="],
+
+    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.30.2", "https://registry.npmmirror.com/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.30.2.tgz", { "os": "darwin", "cpu": "x64" }, "sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ=="],
+
+    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.30.2", "https://registry.npmmirror.com/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.30.2.tgz", { "os": "freebsd", "cpu": "x64" }, "sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA=="],
+
+    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.30.2", "https://registry.npmmirror.com/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.30.2.tgz", { "os": "linux", "cpu": "arm" }, "sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA=="],
+
+    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.30.2", "https://registry.npmmirror.com/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.30.2.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A=="],
+
+    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.30.2", "https://registry.npmmirror.com/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.30.2.tgz", { "os": "linux", "cpu": "arm64" }, "sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA=="],
+
+    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.30.2", "https://registry.npmmirror.com/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.30.2.tgz", { "os": "linux", "cpu": "x64" }, "sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w=="],
+
+    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.30.2", "https://registry.npmmirror.com/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.30.2.tgz", { "os": "linux", "cpu": "x64" }, "sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA=="],
+
+    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.30.2", "https://registry.npmmirror.com/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.30.2.tgz", { "os": "win32", "cpu": "arm64" }, "sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ=="],
+
+    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.2", "https://registry.npmmirror.com/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.30.2.tgz", { "os": "win32", "cpu": "x64" }, "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw=="],
+
+    "lucide-react": ["lucide-react@0.563.0", "https://registry.npmmirror.com/lucide-react/-/lucide-react-0.563.0.tgz", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-8dXPB2GI4dI8jV4MgUDGBeLdGk8ekfqVZ0BdLcrRzocGgG75ltNEmWS+gE7uokKF/0oSUuczNDT+g9hFJ23FkA=="],
+
+    "magic-string": ["magic-string@0.30.21", "https://registry.npmmirror.com/magic-string/-/magic-string-0.30.21.tgz", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
+
+    "math-intrinsics": ["math-intrinsics@1.1.0", "https://registry.npmmirror.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
+
+    "mime-db": ["mime-db@1.52.0", "https://registry.npmmirror.com/mime-db/-/mime-db-1.52.0.tgz", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
+
+    "mime-types": ["mime-types@2.1.35", "https://registry.npmmirror.com/mime-types/-/mime-types-2.1.35.tgz", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
+
+    "nanoid": ["nanoid@3.3.11", "https://registry.npmmirror.com/nanoid/-/nanoid-3.3.11.tgz", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "node-releases": ["node-releases@2.0.27", "https://registry.npmmirror.com/node-releases/-/node-releases-2.0.27.tgz", {}, "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA=="],
+
+    "picocolors": ["picocolors@1.1.1", "https://registry.npmmirror.com/picocolors/-/picocolors-1.1.1.tgz", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.3", "https://registry.npmmirror.com/picomatch/-/picomatch-4.0.3.tgz", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+
+    "postcss": ["postcss@8.5.6", "https://registry.npmmirror.com/postcss/-/postcss-8.5.6.tgz", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
+
+    "postcss-value-parser": ["postcss-value-parser@4.2.0", "https://registry.npmmirror.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", {}, "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="],
+
+    "proxy-from-env": ["proxy-from-env@1.1.0", "https://registry.npmmirror.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="],
+
+    "react": ["react@19.2.4", "https://registry.npmmirror.com/react/-/react-19.2.4.tgz", {}, "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ=="],
+
+    "react-dom": ["react-dom@19.2.4", "https://registry.npmmirror.com/react-dom/-/react-dom-19.2.4.tgz", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.4" } }, "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ=="],
+
+    "react-remove-scroll": ["react-remove-scroll@2.7.2", "https://registry.npmmirror.com/react-remove-scroll/-/react-remove-scroll-2.7.2.tgz", { "dependencies": { "react-remove-scroll-bar": "^2.3.7", "react-style-singleton": "^2.2.3", "tslib": "^2.1.0", "use-callback-ref": "^1.3.3", "use-sidecar": "^1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q=="],
+
+    "react-remove-scroll-bar": ["react-remove-scroll-bar@2.3.8", "https://registry.npmmirror.com/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz", { "dependencies": { "react-style-singleton": "^2.2.2", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" }, "optionalPeers": ["@types/react"] }, "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q=="],
+
+    "react-style-singleton": ["react-style-singleton@2.2.3", "https://registry.npmmirror.com/react-style-singleton/-/react-style-singleton-2.2.3.tgz", { "dependencies": { "get-nonce": "^1.0.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ=="],
+
+    "rollup": ["rollup@4.57.1", "https://registry.npmmirror.com/rollup/-/rollup-4.57.1.tgz", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.57.1", "@rollup/rollup-android-arm64": "4.57.1", "@rollup/rollup-darwin-arm64": "4.57.1", "@rollup/rollup-darwin-x64": "4.57.1", "@rollup/rollup-freebsd-arm64": "4.57.1", "@rollup/rollup-freebsd-x64": "4.57.1", "@rollup/rollup-linux-arm-gnueabihf": "4.57.1", "@rollup/rollup-linux-arm-musleabihf": "4.57.1", "@rollup/rollup-linux-arm64-gnu": "4.57.1", "@rollup/rollup-linux-arm64-musl": "4.57.1", "@rollup/rollup-linux-loong64-gnu": "4.57.1", "@rollup/rollup-linux-loong64-musl": "4.57.1", "@rollup/rollup-linux-ppc64-gnu": "4.57.1", "@rollup/rollup-linux-ppc64-musl": "4.57.1", "@rollup/rollup-linux-riscv64-gnu": "4.57.1", "@rollup/rollup-linux-riscv64-musl": "4.57.1", "@rollup/rollup-linux-s390x-gnu": "4.57.1", "@rollup/rollup-linux-x64-gnu": "4.57.1", "@rollup/rollup-linux-x64-musl": "4.57.1", "@rollup/rollup-openbsd-x64": "4.57.1", "@rollup/rollup-openharmony-arm64": "4.57.1", "@rollup/rollup-win32-arm64-msvc": "4.57.1", "@rollup/rollup-win32-ia32-msvc": "4.57.1", "@rollup/rollup-win32-x64-gnu": "4.57.1", "@rollup/rollup-win32-x64-msvc": "4.57.1", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A=="],
+
+    "scheduler": ["scheduler@0.27.0", "https://registry.npmmirror.com/scheduler/-/scheduler-0.27.0.tgz", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
+
+    "sonner": ["sonner@2.0.7", "https://registry.npmmirror.com/sonner/-/sonner-2.0.7.tgz", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "https://registry.npmmirror.com/source-map-js/-/source-map-js-1.2.1.tgz", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "tailwind-merge": ["tailwind-merge@3.4.0", "https://registry.npmmirror.com/tailwind-merge/-/tailwind-merge-3.4.0.tgz", {}, "sha512-uSaO4gnW+b3Y2aWoWfFpX62vn2sR3skfhbjsEnaBI81WD1wBLlHZe5sWf0AqjksNdYTbGBEd0UasQMT3SNV15g=="],
+
+    "tailwindcss": ["tailwindcss@4.1.18", "https://registry.npmmirror.com/tailwindcss/-/tailwindcss-4.1.18.tgz", {}, "sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw=="],
+
+    "tapable": ["tapable@2.3.0", "https://registry.npmmirror.com/tapable/-/tapable-2.3.0.tgz", {}, "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg=="],
+
+    "tinyglobby": ["tinyglobby@0.2.15", "https://registry.npmmirror.com/tinyglobby/-/tinyglobby-0.2.15.tgz", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="],
+
+    "tslib": ["tslib@2.8.1", "https://registry.npmmirror.com/tslib/-/tslib-2.8.1.tgz", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "typescript": ["typescript@5.9.3", "https://registry.npmmirror.com/typescript/-/typescript-5.9.3.tgz", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "update-browserslist-db": ["update-browserslist-db@1.2.3", "https://registry.npmmirror.com/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="],
+
+    "use-callback-ref": ["use-callback-ref@1.3.3", "https://registry.npmmirror.com/use-callback-ref/-/use-callback-ref-1.3.3.tgz", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg=="],
+
+    "use-sidecar": ["use-sidecar@1.1.3", "https://registry.npmmirror.com/use-sidecar/-/use-sidecar-1.1.3.tgz", { "dependencies": { "detect-node-es": "^1.1.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ=="],
+
+    "vite": ["vite@7.3.1", "https://registry.npmmirror.com/vite/-/vite-7.3.1.tgz", { "dependencies": { "esbuild": "^0.27.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA=="],
+
+    "@radix-ui/react-collection/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "https://registry.npmmirror.com/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-dialog/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "https://registry.npmmirror.com/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-menu/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "https://registry.npmmirror.com/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-primitive/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "https://registry.npmmirror.com/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@radix-ui/react-tooltip/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "https://registry.npmmirror.com/@radix-ui/react-slot/-/react-slot-1.2.3.tgz", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/core": ["@emnapi/core@1.8.1", "https://registry.npmmirror.com/@emnapi/core/-/core-1.8.1.tgz", { "dependencies": { "@emnapi/wasi-threads": "1.1.0", "tslib": "^2.4.0" }, "bundled": true }, "sha512-AvT9QFpxK0Zd8J0jopedNm+w/2fIzvtPKPjqyw9jwvBaReTTqPBk9Hixaz7KbjimP+QNz605/XnjFcDAL2pqBg=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.8.1", "https://registry.npmmirror.com/@emnapi/runtime/-/runtime-1.8.1.tgz", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-mehfKSMWjjNol8659Z8KxEMrdSJDDot5SXMq00dM8BN4o+CLNXQ0xH2V7EchNHV4RmbZLmmPdEaXZc5H2FXmDg=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.1.0", "https://registry.npmmirror.com/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.1", "https://registry.npmmirror.com/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.1.tgz", { "dependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1", "@tybys/wasm-util": "^0.10.1" }, "bundled": true }, "sha512-p64ah1M1ld8xjWv3qbvFwHiFVWrq1yFvV4f7w+mzaqiR4IlSgkqhcRdHwsGgomwzBH51sRY4NEowLxnaBjcW/A=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@tybys/wasm-util": ["@tybys/wasm-util@0.10.1", "https://registry.npmmirror.com/@tybys/wasm-util/-/wasm-util-0.10.1.tgz", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "https://registry.npmmirror.com/tslib/-/tslib-2.8.1.tgz", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+  }
+}
diff --git a/admin-ui/index.html b/admin-ui/index.html
new file mode 100644
index 0000000..fa27c3e
--- /dev/null
+++ b/admin-ui/index.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Kiro Admin</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/admin-ui/postcss.config.js b/admin-ui/postcss.config.js
new file mode 100644
index 0000000..1c87846
--- /dev/null
+++ b/admin-ui/postcss.config.js
@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+    autoprefixer: {},
+  },
+}
diff --git a/admin-ui/public/vite.svg b/admin-ui/public/vite.svg
new file mode 100644
index 0000000..6a41099
--- /dev/null
+++ b/admin-ui/public/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFBD4F"></stop><stop offset="100%" stop-color="#FF980E"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
diff --git a/admin-ui/src/App.tsx b/admin-ui/src/App.tsx
new file mode 100644
index 0000000..f2fab45
--- /dev/null
+++ b/admin-ui/src/App.tsx
@@ -0,0 +1,37 @@
+import { useState, useEffect } from 'react'
+import { storage } from '@/lib/storage'
+import { LoginPage } from '@/components/login-page'
+import { Dashboard } from '@/components/dashboard'
+import { Toaster } from '@/components/ui/sonner'
+
+function App() {
+  const [isLoggedIn, setIsLoggedIn] = useState(false)
+
+  useEffect(() => {
+    // 检查是否已经有保存的 API Key
+    if (storage.getApiKey()) {
+      setIsLoggedIn(true)
+    }
+  }, [])
+
+  const handleLogin = () => {
+    setIsLoggedIn(true)
+  }
+
+  const handleLogout = () => {
+    setIsLoggedIn(false)
+  }
+
+  return (
+    <>
+      {isLoggedIn ? (
+        <Dashboard onLogout={handleLogout} />
+      ) : (
+        <LoginPage onLogin={handleLogin} />
+      )}
+      <Toaster position="top-right" />
+    </>
+  )
+}
+
+export default App
diff --git a/admin-ui/src/api/credentials.ts b/admin-ui/src/api/credentials.ts
new file mode 100644
index 0000000..d7aca3a
--- /dev/null
+++ b/admin-ui/src/api/credentials.ts
@@ -0,0 +1,147 @@
+import axios from 'axios'
+import { storage } from '@/lib/storage'
+import type {
+  CredentialsStatusResponse,
+  BalanceResponse,
+  CachedBalancesResponse,
+  SuccessResponse,
+  SetDisabledRequest,
+  SetPriorityRequest,
+  AddCredentialRequest,
+  AddCredentialResponse,
+  CredentialStatsResponse,
+  CredentialAccountInfoResponse,
+  ImportTokenJsonRequest,
+  ImportTokenJsonResponse,
+} from '@/types/api'
+
+// 创建 axios 实例
+const api = axios.create({
+  baseURL: '/api/admin',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+})
+
+// 请求拦截器添加 API Key
+api.interceptors.request.use((config) => {
+  const apiKey = storage.getApiKey()
+  if (apiKey) {
+    config.headers['x-api-key'] = apiKey
+  }
+  return config
+})
+
+// 获取所有凭据状态
+export async function getCredentials(): Promise<CredentialsStatusResponse> {
+  const { data } = await api.get<CredentialsStatusResponse>('/credentials')
+  return data
+}
+
+// 设置凭据禁用状态
+export async function setCredentialDisabled(
+  id: number,
+  disabled: boolean
+): Promise<SuccessResponse> {
+  const { data } = await api.post<SuccessResponse>(
+    `/credentials/${id}/disabled`,
+    { disabled } as SetDisabledRequest
+  )
+  return data
+}
+
+// 设置凭据优先级
+export async function setCredentialPriority(
+  id: number,
+  priority: number
+): Promise<SuccessResponse> {
+  const { data } = await api.post<SuccessResponse>(
+    `/credentials/${id}/priority`,
+    { priority } as SetPriorityRequest
+  )
+  return data
+}
+
+// 重置失败计数
+export async function resetCredentialFailure(
+  id: number
+): Promise<SuccessResponse> {
+  const { data } = await api.post<SuccessResponse>(`/credentials/${id}/reset`)
+  return data
+}
+
+// 设置凭据 Region
+export async function setCredentialRegion(
+  id: number,
+  region: string | null,
+  apiRegion: string | null
+): Promise<SuccessResponse> {
+  const { data } = await api.post<SuccessResponse>(`/credentials/${id}/region`, {
+    region: region || null,
+    apiRegion: apiRegion || null,
+  })
+  return data
+}
+
+// 获取凭据余额
+export async function getCredentialBalance(id: number): Promise<BalanceResponse> {
+  const { data } = await api.get<BalanceResponse>(`/credentials/${id}/balance`)
+  return data
+}
+
+// 获取所有凭据的缓存余额
+export async function getCachedBalances(): Promise<CachedBalancesResponse> {
+  const { data } = await api.get<CachedBalancesResponse>('/credentials/balances/cached')
+  return data
+}
+
+// 获取凭据账号信息（套餐/用量/邮箱等）
+export async function getCredentialAccountInfo(
+  id: number
+): Promise<CredentialAccountInfoResponse> {
+  const { data } = await api.get<CredentialAccountInfoResponse>(`/credentials/${id}/account`)
+  return data
+}
+
+// 添加新凭据
+export async function addCredential(
+  req: AddCredentialRequest
+): Promise<AddCredentialResponse> {
+  const { data } = await api.post<AddCredentialResponse>('/credentials', req)
+  return data
+}
+
+// 删除凭据
+export async function deleteCredential(id: number): Promise<SuccessResponse> {
+  const { data } = await api.delete<SuccessResponse>(`/credentials/${id}`)
+  return data
+}
+
+// 获取指定凭据统计
+export async function getCredentialStats(id: number): Promise<CredentialStatsResponse> {
+  const { data } = await api.get<CredentialStatsResponse>(`/credentials/${id}/stats`)
+  return data
+}
+
+// 清空指定凭据统计
+export async function resetCredentialStats(id: number): Promise<SuccessResponse> {
+  const { data } = await api.post<SuccessResponse>(`/credentials/${id}/stats/reset`)
+  return data
+}
+
+// 清空全部统计
+export async function resetAllStats(): Promise<SuccessResponse> {
+  const { data } = await api.post<SuccessResponse>('/stats/reset')
+  return data
+}
+
+// 批量导入 token.json
+export async function importTokenJson(
+  req: ImportTokenJsonRequest
+): Promise<ImportTokenJsonResponse> {
+  const { data } = await api.post<ImportTokenJsonResponse>(
+    '/credentials/import-token-json',
+    req
+  )
+  return data
+}
diff --git a/admin-ui/src/components/add-credential-dialog.tsx b/admin-ui/src/components/add-credential-dialog.tsx
new file mode 100644
index 0000000..5c09fe4
--- /dev/null
+++ b/admin-ui/src/components/add-credential-dialog.tsx
@@ -0,0 +1,279 @@
+import { useState } from 'react'
+import { toast } from 'sonner'
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { useAddCredential } from '@/hooks/use-credentials'
+import { extractErrorMessage } from '@/lib/utils'
+
+interface AddCredentialDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+}
+
+type AuthMethod = 'social' | 'idc'
+
+export function AddCredentialDialog({ open, onOpenChange }: AddCredentialDialogProps) {
+  const [refreshToken, setRefreshToken] = useState('')
+  const [authMethod, setAuthMethod] = useState<AuthMethod>('social')
+  const [region, setRegion] = useState('')
+  const [apiRegion, setApiRegion] = useState('')
+  const [clientId, setClientId] = useState('')
+  const [clientSecret, setClientSecret] = useState('')
+  const [priority, setPriority] = useState('0')
+  const [machineId, setMachineId] = useState('')
+  const [proxyUrl, setProxyUrl] = useState('')
+  const [proxyUsername, setProxyUsername] = useState('')
+  const [proxyPassword, setProxyPassword] = useState('')
+
+  const { mutate, isPending } = useAddCredential()
+
+  const resetForm = () => {
+    setRefreshToken('')
+    setAuthMethod('social')
+    setRegion('')
+    setApiRegion('')
+    setClientId('')
+    setClientSecret('')
+    setPriority('0')
+    setMachineId('')
+    setProxyUrl('')
+    setProxyUsername('')
+    setProxyPassword('')
+  }
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault()
+
+    // 验证必填字段
+    if (!refreshToken.trim()) {
+      toast.error('请输入 Refresh Token')
+      return
+    }
+
+    // IdC/Builder-ID/IAM 需要额外字段
+    if (authMethod === 'idc' && (!clientId.trim() || !clientSecret.trim())) {
+      toast.error('IdC/Builder-ID/IAM 认证需要填写 Client ID 和 Client Secret')
+      return
+    }
+
+    mutate(
+      {
+        refreshToken: refreshToken.trim(),
+        authMethod,
+        region: region.trim() || undefined,
+        apiRegion: apiRegion.trim() || undefined,
+        clientId: clientId.trim() || undefined,
+        clientSecret: clientSecret.trim() || undefined,
+        priority: parseInt(priority) || 0,
+        machineId: machineId.trim() || undefined,
+        proxyUrl: proxyUrl.trim() || undefined,
+        proxyUsername: proxyUsername.trim() || undefined,
+        proxyPassword: proxyPassword.trim() || undefined,
+      },
+      {
+        onSuccess: (data) => {
+          toast.success(data.message)
+          onOpenChange(false)
+          resetForm()
+        },
+        onError: (error: unknown) => {
+          toast.error(`添加失败: ${extractErrorMessage(error)}`)
+        },
+      }
+    )
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-lg max-h-[85vh] flex flex-col">
+        <DialogHeader>
+          <DialogTitle>添加凭据</DialogTitle>
+        </DialogHeader>
+
+        <form onSubmit={handleSubmit} className="flex flex-col min-h-0 flex-1">
+          <div className="space-y-4 py-4 overflow-y-auto flex-1 pr-1">
+            {/* Refresh Token */}
+            <div className="space-y-2">
+              <label htmlFor="refreshToken" className="text-sm font-medium">
+                Refresh Token <span className="text-red-500">*</span>
+              </label>
+              <Input
+                id="refreshToken"
+                type="password"
+                placeholder="请输入 Refresh Token"
+                value={refreshToken}
+                onChange={(e) => setRefreshToken(e.target.value)}
+                disabled={isPending}
+              />
+            </div>
+
+            {/* 认证方式 */}
+            <div className="space-y-2">
+              <label htmlFor="authMethod" className="text-sm font-medium">
+                认证方式
+              </label>
+              <select
+                id="authMethod"
+                value={authMethod}
+                onChange={(e) => setAuthMethod(e.target.value as AuthMethod)}
+                disabled={isPending}
+                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50"
+              >
+                <option value="social">Social</option>
+                <option value="idc">IdC/Builder-ID/IAM</option>
+              </select>
+            </div>
+
+            {/* Region 配置 */}
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Region 配置</label>
+              <div className="grid grid-cols-2 gap-2">
+                <div>
+                  <Input
+                    id="region"
+                    placeholder="Region"
+                    value={region}
+                    onChange={(e) => setRegion(e.target.value)}
+                    disabled={isPending}
+                  />
+                </div>
+                <div>
+                  <Input
+                    id="apiRegion"
+                    placeholder="API Region（可选覆盖）"
+                    value={apiRegion}
+                    onChange={(e) => setApiRegion(e.target.value)}
+                    disabled={isPending}
+                  />
+                </div>
+              </div>
+              <p className="text-xs text-muted-foreground">
+                Region 用于 Token 刷新，留空使用全局配置。API Region 可单独覆盖 API 请求所用的 Region
+              </p>
+            </div>
+
+            {/* IdC/Builder-ID/IAM 额外字段 */}
+            {authMethod === 'idc' && (
+              <>
+                <div className="space-y-2">
+                  <label htmlFor="clientId" className="text-sm font-medium">
+                    Client ID <span className="text-red-500">*</span>
+                  </label>
+                  <Input
+                    id="clientId"
+                    placeholder="请输入 Client ID"
+                    value={clientId}
+                    onChange={(e) => setClientId(e.target.value)}
+                    disabled={isPending}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <label htmlFor="clientSecret" className="text-sm font-medium">
+                    Client Secret <span className="text-red-500">*</span>
+                  </label>
+                  <Input
+                    id="clientSecret"
+                    type="password"
+                    placeholder="请输入 Client Secret"
+                    value={clientSecret}
+                    onChange={(e) => setClientSecret(e.target.value)}
+                    disabled={isPending}
+                  />
+                </div>
+              </>
+            )}
+
+            {/* 优先级 */}
+            <div className="space-y-2">
+              <label htmlFor="priority" className="text-sm font-medium">
+                优先级
+              </label>
+              <Input
+                id="priority"
+                type="number"
+                min="0"
+                placeholder="数字越小优先级越高"
+                value={priority}
+                onChange={(e) => setPriority(e.target.value)}
+                disabled={isPending}
+              />
+              <p className="text-xs text-muted-foreground">
+                数字越小优先级越高，默认为 0
+              </p>
+            </div>
+
+            {/* Machine ID */}
+            <div className="space-y-2">
+              <label htmlFor="machineId" className="text-sm font-medium">
+                Machine ID
+              </label>
+              <Input
+                id="machineId"
+                placeholder="留空使用配置中字段, 否则由刷新Token自动派生"
+                value={machineId}
+                onChange={(e) => setMachineId(e.target.value)}
+                disabled={isPending}
+              />
+              <p className="text-xs text-muted-foreground">
+                可选，64 位十六进制字符串，留空使用配置中字段, 否则由刷新Token自动派生
+              </p>
+            </div>
+
+            {/* 代理配置 */}
+            <div className="space-y-2">
+              <label className="text-sm font-medium">代理配置</label>
+              <Input
+                id="proxyUrl"
+                placeholder='代理 URL（留空使用全局配置，"direct" 不使用代理）'
+                value={proxyUrl}
+                onChange={(e) => setProxyUrl(e.target.value)}
+                disabled={isPending}
+              />
+              <div className="grid grid-cols-2 gap-2">
+                <Input
+                  id="proxyUsername"
+                  placeholder="代理用户名"
+                  value={proxyUsername}
+                  onChange={(e) => setProxyUsername(e.target.value)}
+                  disabled={isPending}
+                />
+                <Input
+                  id="proxyPassword"
+                  type="password"
+                  placeholder="代理密码"
+                  value={proxyPassword}
+                  onChange={(e) => setProxyPassword(e.target.value)}
+                  disabled={isPending}
+                />
+              </div>
+              <p className="text-xs text-muted-foreground">
+                留空使用全局代理。输入 "direct" 可显式不使用代理
+              </p>
+            </div>
+          </div>
+
+          <DialogFooter>
+            <Button
+              type="button"
+              variant="outline"
+              onClick={() => onOpenChange(false)}
+              disabled={isPending}
+            >
+              取消
+            </Button>
+            <Button type="submit" disabled={isPending}>
+              {isPending ? '添加中...' : '添加'}
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/admin-ui/src/components/balance-dialog.tsx b/admin-ui/src/components/balance-dialog.tsx
new file mode 100644
index 0000000..70c441d
--- /dev/null
+++ b/admin-ui/src/components/balance-dialog.tsx
@@ -0,0 +1,106 @@
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Progress } from '@/components/ui/progress'
+import { useCredentialBalance } from '@/hooks/use-credentials'
+import { parseError } from '@/lib/utils'
+
+interface BalanceDialogProps {
+  credentialId: number | null
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  forceRefresh?: boolean
+}
+
+export function BalanceDialog({ credentialId, open, onOpenChange, forceRefresh }: BalanceDialogProps) {
+  const { data: balance, isLoading, isFetching, error } = useCredentialBalance(credentialId)
+  const showLoading = isLoading || (forceRefresh && isFetching)
+
+  const formatDate = (timestamp: number | null) => {
+    if (!timestamp) return '未知'
+    return new Date(timestamp * 1000).toLocaleString('zh-CN')
+  }
+
+  const formatNumber = (num: number) => {
+    return num.toLocaleString('zh-CN', { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>
+            凭据 #{credentialId} 余额信息
+          </DialogTitle>
+        </DialogHeader>
+
+        {showLoading && (
+          <div className="flex items-center justify-center py-8">
+            <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary"></div>
+          </div>
+        )}
+
+        {error && (() => {
+          const parsed = parseError(error)
+          return (
+            <div className="py-6 space-y-3">
+              <div className="flex items-center justify-center gap-2 text-red-500">
+                <svg className="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
+                  <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
+                </svg>
+                <span className="font-medium">{parsed.title}</span>
+              </div>
+              {parsed.detail && (
+                <div className="text-sm text-muted-foreground text-center px-4">
+                  {parsed.detail}
+                </div>
+              )}
+            </div>
+          )
+        })()}
+
+        {balance && (
+          <div className="space-y-4">
+            {/* 订阅类型 */}
+            <div className="text-center">
+              <span className="text-lg font-semibold">
+                {balance.subscriptionTitle || '未知订阅类型'}
+              </span>
+            </div>
+
+            {/* 使用进度 */}
+            <div className="space-y-2">
+              <div className="flex justify-between text-sm">
+                <span>已使用: ${formatNumber(balance.currentUsage)}</span>
+                <span>限额: ${formatNumber(balance.usageLimit)}</span>
+              </div>
+              <Progress value={balance.usagePercentage} />
+              <div className="text-center text-sm text-muted-foreground">
+                {balance.usagePercentage.toFixed(1)}% 已使用
+              </div>
+            </div>
+
+            {/* 详细信息 */}
+            <div className="grid grid-cols-2 gap-4 pt-4 border-t text-sm">
+              <div>
+                <span className="text-muted-foreground">剩余额度：</span>
+                <span className="font-medium text-green-600">
+                  ${formatNumber(balance.remaining)}
+                </span>
+              </div>
+              <div>
+                <span className="text-muted-foreground">下次重置：</span>
+                <span className="font-medium">
+                  {formatDate(balance.nextResetAt)}
+                </span>
+              </div>
+            </div>
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/admin-ui/src/components/batch-import-dialog.tsx b/admin-ui/src/components/batch-import-dialog.tsx
new file mode 100644
index 0000000..e98cbf2
--- /dev/null
+++ b/admin-ui/src/components/batch-import-dialog.tsx
@@ -0,0 +1,434 @@
+import { useState } from 'react'
+import { toast } from 'sonner'
+import { CheckCircle2, XCircle, AlertCircle, Loader2 } from 'lucide-react'
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { useCredentials, useAddCredential, useDeleteCredential } from '@/hooks/use-credentials'
+import { getCredentialBalance, setCredentialDisabled } from '@/api/credentials'
+import { extractErrorMessage, sha256Hex } from '@/lib/utils'
+
+interface BatchImportDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+}
+
+interface CredentialInput {
+  refreshToken: string
+  clientId?: string
+  clientSecret?: string
+  region?: string
+  authRegion?: string
+  apiRegion?: string
+  priority?: number
+  machineId?: string
+}
+
+interface VerificationResult {
+  index: number
+  status: 'pending' | 'checking' | 'verifying' | 'verified' | 'duplicate' | 'failed'
+  error?: string
+  usage?: string
+  email?: string
+  credentialId?: number
+  rollbackStatus?: 'success' | 'failed' | 'skipped'
+  rollbackError?: string
+}
+
+
+
+export function BatchImportDialog({ open, onOpenChange }: BatchImportDialogProps) {
+  const [jsonInput, setJsonInput] = useState('')
+  const [importing, setImporting] = useState(false)
+  const [progress, setProgress] = useState({ current: 0, total: 0 })
+  const [currentProcessing, setCurrentProcessing] = useState<string>('')
+  const [results, setResults] = useState<VerificationResult[]>([])
+
+  const { data: existingCredentials } = useCredentials()
+  const { mutateAsync: addCredential } = useAddCredential()
+  const { mutateAsync: deleteCredential } = useDeleteCredential()
+
+  const rollbackCredential = async (id: number): Promise<{ success: boolean; error?: string }> => {
+    try {
+      await setCredentialDisabled(id, true)
+    } catch (error) {
+      return {
+        success: false,
+        error: `禁用失败: ${extractErrorMessage(error)}`,
+      }
+    }
+
+    try {
+      await deleteCredential(id)
+      return { success: true }
+    } catch (error) {
+      return {
+        success: false,
+        error: `删除失败: ${extractErrorMessage(error)}`,
+      }
+    }
+  }
+
+  const resetForm = () => {
+    setJsonInput('')
+    setProgress({ current: 0, total: 0 })
+    setCurrentProcessing('')
+    setResults([])
+  }
+
+  const handleBatchImport = async () => {
+    // 先单独解析 JSON，给出精准的错误提示
+    let credentials: CredentialInput[]
+    try {
+      const parsed = JSON.parse(jsonInput)
+      credentials = Array.isArray(parsed) ? parsed : [parsed]
+    } catch (error) {
+      toast.error('JSON 格式错误: ' + extractErrorMessage(error))
+      return
+    }
+
+    if (credentials.length === 0) {
+      toast.error('没有可导入的凭据')
+      return
+    }
+
+    try {
+      setImporting(true)
+      setProgress({ current: 0, total: credentials.length })
+
+      // 2. 初始化结果
+      const initialResults: VerificationResult[] = credentials.map((_, i) => ({
+        index: i + 1,
+        status: 'pending'
+      }))
+      setResults(initialResults)
+
+      // 3. 检测重复
+      const existingTokenHashes = new Set(
+        existingCredentials?.credentials
+          .map(c => c.refreshTokenHash)
+          .filter((hash): hash is string => Boolean(hash)) || []
+      )
+
+      let successCount = 0
+      let duplicateCount = 0
+      let failCount = 0
+      let rollbackSuccessCount = 0
+      let rollbackFailedCount = 0
+      let rollbackSkippedCount = 0
+
+      // 4. 导入并验活
+      for (let i = 0; i < credentials.length; i++) {
+        const cred = credentials[i]
+        const token = cred.refreshToken.trim()
+        const tokenHash = await sha256Hex(token)
+
+        // 更新状态为检查中
+        setCurrentProcessing(`正在处理凭据 ${i + 1}/${credentials.length}`)
+        setResults(prev => {
+          const newResults = [...prev]
+          newResults[i] = { ...newResults[i], status: 'checking' }
+          return newResults
+        })
+
+        // 检查重复
+        if (existingTokenHashes.has(tokenHash)) {
+          duplicateCount++
+          const existingCred = existingCredentials?.credentials.find(c => c.refreshTokenHash === tokenHash)
+          setResults(prev => {
+            const newResults = [...prev]
+            newResults[i] = {
+              ...newResults[i],
+              status: 'duplicate',
+              error: '该凭据已存在',
+              email: existingCred?.email || undefined
+            }
+            return newResults
+          })
+          setProgress({ current: i + 1, total: credentials.length })
+          continue
+        }
+
+        // 更新状态为验活中
+        setResults(prev => {
+          const newResults = [...prev]
+          newResults[i] = { ...newResults[i], status: 'verifying' }
+          return newResults
+        })
+
+        let addedCredId: number | null = null
+
+        try {
+          // 添加凭据
+          const clientId = cred.clientId?.trim() || undefined
+          const clientSecret = cred.clientSecret?.trim() || undefined
+          const authMethod = clientId && clientSecret ? 'idc' : 'social'
+
+          // idc 模式下必须同时提供 clientId 和 clientSecret
+          if (authMethod === 'social' && (clientId || clientSecret)) {
+            throw new Error('idc 模式需要同时提供 clientId 和 clientSecret')
+          }
+
+          const addedCred = await addCredential({
+            refreshToken: token,
+            authMethod,
+            authRegion: cred.authRegion?.trim() || cred.region?.trim() || undefined,
+            apiRegion: cred.apiRegion?.trim() || undefined,
+            clientId,
+            clientSecret,
+            priority: cred.priority || 0,
+            machineId: cred.machineId?.trim() || undefined,
+          })
+
+          addedCredId = addedCred.credentialId
+
+          // 延迟 1 秒
+          await new Promise(resolve => setTimeout(resolve, 1000))
+
+          // 验活
+          const balance = await getCredentialBalance(addedCred.credentialId)
+
+          // 验活成功
+          successCount++
+          existingTokenHashes.add(tokenHash)
+          setCurrentProcessing(addedCred.email ? `验活成功: ${addedCred.email}` : `验活成功: 凭据 ${i + 1}`)
+          setResults(prev => {
+            const newResults = [...prev]
+            newResults[i] = {
+              ...newResults[i],
+              status: 'verified',
+              usage: `${balance.currentUsage}/${balance.usageLimit}`,
+              email: addedCred.email || undefined,
+              credentialId: addedCred.credentialId
+            }
+            return newResults
+          })
+        } catch (error) {
+          // 验活失败，尝试回滚（先禁用再删除）
+          let rollbackStatus: VerificationResult['rollbackStatus'] = 'skipped'
+          let rollbackError: string | undefined
+
+          if (addedCredId) {
+            const rollbackResult = await rollbackCredential(addedCredId)
+            if (rollbackResult.success) {
+              rollbackStatus = 'success'
+              rollbackSuccessCount++
+            } else {
+              rollbackStatus = 'failed'
+              rollbackFailedCount++
+              rollbackError = rollbackResult.error
+            }
+          } else {
+            rollbackSkippedCount++
+          }
+
+          failCount++
+          setResults(prev => {
+            const newResults = [...prev]
+            newResults[i] = {
+              ...newResults[i],
+              status: 'failed',
+              error: extractErrorMessage(error),
+              email: undefined,
+              rollbackStatus,
+              rollbackError,
+            }
+            return newResults
+          })
+        }
+
+        setProgress({ current: i + 1, total: credentials.length })
+      }
+
+      // 显示结果
+      if (failCount === 0 && duplicateCount === 0) {
+        toast.success(`成功导入并验活 ${successCount} 个凭据`)
+      } else {
+        const failureSummary = failCount > 0
+          ? `，失败 ${failCount} 个（已排除 ${rollbackSuccessCount}，未排除 ${rollbackFailedCount}，无需排除 ${rollbackSkippedCount}）`
+          : ''
+        toast.info(`验活完成：成功 ${successCount} 个，重复 ${duplicateCount} 个${failureSummary}`)
+
+        if (rollbackFailedCount > 0) {
+          toast.warning(`有 ${rollbackFailedCount} 个失败凭据回滚未完成，请手动禁用并删除`)
+        }
+      }
+    } catch (error) {
+      toast.error('导入失败: ' + extractErrorMessage(error))
+    } finally {
+      setImporting(false)
+    }
+  }
+
+  const getStatusIcon = (status: VerificationResult['status']) => {
+    switch (status) {
+      case 'pending':
+        return <div className="w-5 h-5 rounded-full border-2 border-gray-300" />
+      case 'checking':
+      case 'verifying':
+        return <Loader2 className="w-5 h-5 animate-spin text-blue-500" />
+      case 'verified':
+        return <CheckCircle2 className="w-5 h-5 text-green-500" />
+      case 'duplicate':
+        return <AlertCircle className="w-5 h-5 text-yellow-500" />
+      case 'failed':
+        return <XCircle className="w-5 h-5 text-red-500" />
+    }
+  }
+
+  const getStatusText = (result: VerificationResult) => {
+    switch (result.status) {
+      case 'pending':
+        return '等待中'
+      case 'checking':
+        return '检查重复...'
+      case 'verifying':
+        return '验活中...'
+      case 'verified':
+        return '验活成功'
+      case 'duplicate':
+        return '重复凭据'
+      case 'failed':
+        if (result.rollbackStatus === 'success') return '验活失败（已排除）'
+        if (result.rollbackStatus === 'failed') return '验活失败（未排除）'
+        return '验活失败（未创建）'
+    }
+  }
+
+  return (
+    <Dialog
+      open={open}
+      onOpenChange={(newOpen) => {
+        // 关闭时清空表单（但不在导入过程中清空）
+        if (!newOpen && !importing) {
+          resetForm()
+        }
+        onOpenChange(newOpen)
+      }}
+    >
+      <DialogContent className="sm:max-w-2xl max-h-[80vh] flex flex-col">
+        <DialogHeader>
+          <DialogTitle>批量导入凭据（自动验活）</DialogTitle>
+        </DialogHeader>
+
+        <div className="flex-1 overflow-y-auto space-y-4 py-4">
+          <div className="space-y-2">
+            <label className="text-sm font-medium">
+              JSON 格式凭据
+            </label>
+            <textarea
+              placeholder={'粘贴 JSON 格式的凭据（支持单个对象或数组）\n例如: [{"refreshToken":"...","clientId":"...","clientSecret":"...","authRegion":"us-east-1","apiRegion":"us-west-2"}]\n支持 region 字段自动映射为 authRegion'}
+              value={jsonInput}
+              onChange={(e) => setJsonInput(e.target.value)}
+              disabled={importing}
+              className="flex min-h-[200px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 font-mono"
+            />
+            <p className="text-xs text-muted-foreground">
+              💡 导入时自动验活，失败的凭据会被排除
+            </p>
+          </div>
+
+          {(importing || results.length > 0) && (
+            <>
+              {/* 进度条 */}
+              <div className="space-y-2">
+                <div className="flex justify-between text-sm">
+                  <span>{importing ? '验活进度' : '验活完成'}</span>
+                  <span>{progress.current} / {progress.total}</span>
+                </div>
+                <div className="w-full bg-secondary rounded-full h-2">
+                  <div
+                    className="bg-primary h-2 rounded-full transition-all"
+                    style={{ width: `${(progress.current / progress.total) * 100}%` }}
+                  />
+                </div>
+                {importing && currentProcessing && (
+                  <div className="text-xs text-muted-foreground">
+                    {currentProcessing}
+                  </div>
+                )}
+              </div>
+
+              {/* 统计 */}
+              <div className="flex gap-4 text-sm">
+                <span className="text-green-600 dark:text-green-400">
+                  ✓ 成功: {results.filter(r => r.status === 'verified').length}
+                </span>
+                <span className="text-yellow-600 dark:text-yellow-400">
+                  ⚠ 重复: {results.filter(r => r.status === 'duplicate').length}
+                </span>
+                <span className="text-red-600 dark:text-red-400">
+                  ✗ 失败: {results.filter(r => r.status === 'failed').length}
+                </span>
+              </div>
+
+              {/* 结果列表 */}
+              <div className="border rounded-md divide-y max-h-[300px] overflow-y-auto">
+                {results.map((result) => (
+                  <div key={result.index} className="p-3">
+                    <div className="flex items-start gap-3">
+                      {getStatusIcon(result.status)}
+                      <div className="flex-1 min-w-0">
+                        <div className="flex items-center gap-2">
+                          <span className="text-sm font-medium">
+                            {result.email || `凭据 #${result.index}`}
+                          </span>
+                          <span className="text-xs text-muted-foreground">
+                            {getStatusText(result)}
+                          </span>
+                        </div>
+                        {result.usage && (
+                          <div className="text-xs text-muted-foreground mt-1">
+                            用量: {result.usage}
+                          </div>
+                        )}
+                        {result.error && (
+                          <div className="text-xs text-red-600 dark:text-red-400 mt-1">
+                            {result.error}
+                          </div>
+                        )}
+                        {result.rollbackError && (
+                          <div className="text-xs text-red-600 dark:text-red-400 mt-1">
+                            回滚失败: {result.rollbackError}
+                          </div>
+                        )}
+                      </div>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </>
+          )}
+        </div>
+
+        <DialogFooter>
+          <Button
+            type="button"
+            variant="outline"
+            onClick={() => {
+              onOpenChange(false)
+              resetForm()
+            }}
+            disabled={importing}
+          >
+            {importing ? '验活中...' : results.length > 0 ? '关闭' : '取消'}
+          </Button>
+          {results.length === 0 && (
+            <Button
+              type="button"
+              onClick={handleBatchImport}
+              disabled={importing || !jsonInput.trim()}
+            >
+              开始导入并验活
+            </Button>
+          )}
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/admin-ui/src/components/batch-verify-dialog.tsx b/admin-ui/src/components/batch-verify-dialog.tsx
new file mode 100644
index 0000000..1d169c5
--- /dev/null
+++ b/admin-ui/src/components/batch-verify-dialog.tsx
@@ -0,0 +1,152 @@
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { Badge } from '@/components/ui/badge'
+
+export interface VerifyResult {
+  id: number
+  status: 'pending' | 'verifying' | 'success' | 'failed'
+  usage?: string
+  error?: string
+}
+
+interface BatchVerifyDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  verifying: boolean
+  progress: { current: number; total: number }
+  results: Map<number, VerifyResult>
+  onCancel: () => void
+}
+
+export function BatchVerifyDialog({
+  open,
+  onOpenChange,
+  verifying,
+  progress,
+  results,
+  onCancel,
+}: BatchVerifyDialogProps) {
+  const resultsArray = Array.from(results.values())
+  const successCount = resultsArray.filter(r => r.status === 'success').length
+  const failedCount = resultsArray.filter(r => r.status === 'failed').length
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-lg">
+        <DialogHeader>
+          <DialogTitle>批量验活</DialogTitle>
+        </DialogHeader>
+
+        <div className="space-y-4 py-4">
+          {/* 进度显示 */}
+          {verifying && (
+            <div className="space-y-2">
+              <div className="flex justify-between text-sm">
+                <span>验活进度</span>
+                <span>{progress.current} / {progress.total}</span>
+              </div>
+              <div className="w-full bg-secondary rounded-full h-2">
+                <div
+                  className="bg-primary h-2 rounded-full transition-all"
+                  style={{ width: `${(progress.current / progress.total) * 100}%` }}
+                />
+              </div>
+            </div>
+          )}
+
+          {/* 统计信息 */}
+          {results.size > 0 && (
+            <div className="flex justify-between text-sm font-medium">
+              <span>验活结果</span>
+              <span>
+                成功: {successCount} / 失败: {failedCount}
+              </span>
+            </div>
+          )}
+
+          {/* 结果列表 */}
+          {results.size > 0 && (
+            <div className="max-h-[400px] overflow-y-auto border rounded-md p-2 space-y-1">
+              {resultsArray.map((result) => (
+                <div
+                  key={result.id}
+                  className={`text-sm p-2 rounded ${
+                    result.status === 'success'
+                      ? 'bg-green-50 text-green-700 dark:bg-green-950 dark:text-green-300'
+                      : result.status === 'failed'
+                      ? 'bg-red-50 text-red-700 dark:bg-red-950 dark:text-red-300'
+                      : result.status === 'verifying'
+                      ? 'bg-blue-50 text-blue-700 dark:bg-blue-950 dark:text-blue-300'
+                      : 'bg-gray-50 text-gray-700 dark:bg-gray-950 dark:text-gray-300'
+                  }`}
+                >
+                  <div className="flex items-start justify-between gap-2">
+                    <div className="flex items-center gap-2">
+                      <span className="font-medium">凭据 #{result.id}</span>
+                      {result.status === 'success' && result.usage && (
+                        <Badge variant="secondary" className="text-xs">
+                          {result.usage}
+                        </Badge>
+                      )}
+                    </div>
+                    <span>
+                      {result.status === 'success' && '✓'}
+                      {result.status === 'failed' && '✗'}
+                      {result.status === 'verifying' && '⏳'}
+                      {result.status === 'pending' && '⋯'}
+                    </span>
+                  </div>
+                  {result.error && (
+                    <div className="text-xs mt-1 opacity-90">
+                      错误: {result.error}
+                    </div>
+                  )}
+                </div>
+              ))}
+            </div>
+          )}
+
+          {/* 提示信息 */}
+          {verifying && (
+            <p className="text-xs text-muted-foreground">
+              💡 验活过程中每次请求间隔 2 秒，防止被封号。你可以关闭此窗口，验活会在后台继续进行。
+            </p>
+          )}
+        </div>
+
+        <div className="flex justify-end gap-2">
+          {verifying ? (
+            <>
+              <Button
+                type="button"
+                variant="outline"
+                onClick={() => onOpenChange(false)}
+              >
+                后台运行
+              </Button>
+              <Button
+                type="button"
+                variant="destructive"
+                onClick={onCancel}
+              >
+                取消验活
+              </Button>
+            </>
+          ) : (
+            <Button
+              type="button"
+              onClick={() => onOpenChange(false)}
+            >
+              关闭
+            </Button>
+          )}
+        </div>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/admin-ui/src/components/credential-card.tsx b/admin-ui/src/components/credential-card.tsx
new file mode 100644
index 0000000..1955f15
--- /dev/null
+++ b/admin-ui/src/components/credential-card.tsx
@@ -0,0 +1,476 @@
+import { useState } from 'react'
+import { toast } from 'sonner'
+import { RefreshCw, ChevronUp, ChevronDown, Wallet, Trash2, Loader2 } from 'lucide-react'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import { Badge } from '@/components/ui/badge'
+import { Switch } from '@/components/ui/switch'
+import { Input } from '@/components/ui/input'
+import { Checkbox } from '@/components/ui/checkbox'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import type { CredentialStatusItem, CachedBalanceInfo, BalanceResponse } from '@/types/api'
+import {
+  useSetDisabled,
+  useSetPriority,
+  useSetRegion,
+  useResetFailure,
+  useDeleteCredential,
+} from '@/hooks/use-credentials'
+
+interface CredentialCardProps {
+  credential: CredentialStatusItem
+  cachedBalance?: CachedBalanceInfo
+  onViewBalance: (id: number, forceRefresh: boolean) => void
+  selected: boolean
+  onToggleSelect: () => void
+  balance: BalanceResponse | null
+  loadingBalance: boolean
+}
+
+function formatLastUsed(lastUsedAt: string | null): string {
+  if (!lastUsedAt) return '从未使用'
+  const date = new Date(lastUsedAt)
+  const now = new Date()
+  const diff = now.getTime() - date.getTime()
+  if (diff < 0) return '刚刚'
+  const seconds = Math.floor(diff / 1000)
+  if (seconds < 60) return `${seconds} 秒前`
+  const minutes = Math.floor(seconds / 60)
+  if (minutes < 60) return `${minutes} 分钟前`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours} 小时前`
+  const days = Math.floor(hours / 24)
+  return `${days} 天前`
+}
+
+export function CredentialCard({
+  credential,
+  cachedBalance,
+  onViewBalance,
+  selected,
+  onToggleSelect,
+  balance,
+  loadingBalance,
+}: CredentialCardProps) {
+  const [editingPriority, setEditingPriority] = useState(false)
+  const [priorityValue, setPriorityValue] = useState(String(credential.priority))
+  const [editingRegion, setEditingRegion] = useState(false)
+  const [regionValue, setRegionValue] = useState(credential.region ?? '')
+  const [apiRegionValue, setApiRegionValue] = useState(credential.apiRegion ?? '')
+  const [showDeleteDialog, setShowDeleteDialog] = useState(false)
+
+  const setDisabled = useSetDisabled()
+  const setPriority = useSetPriority()
+  const setRegion = useSetRegion()
+  const resetFailure = useResetFailure()
+  const deleteCredential = useDeleteCredential()
+
+  const handleToggleDisabled = () => {
+    setDisabled.mutate(
+      { id: credential.id, disabled: !credential.disabled },
+      {
+        onSuccess: (res) => {
+          toast.success(res.message)
+        },
+        onError: (err) => {
+          toast.error('操作失败: ' + (err as Error).message)
+        },
+      }
+    )
+  }
+
+  const handlePriorityChange = () => {
+    const newPriority = parseInt(priorityValue, 10)
+    if (isNaN(newPriority) || newPriority < 0) {
+      toast.error('优先级必须是非负整数')
+      return
+    }
+    setPriority.mutate(
+      { id: credential.id, priority: newPriority },
+      {
+        onSuccess: (res) => {
+          toast.success(res.message)
+          setEditingPriority(false)
+        },
+        onError: (err) => {
+          toast.error('操作失败: ' + (err as Error).message)
+        },
+      }
+    )
+  }
+
+  const handleRegionChange = () => {
+    setRegion.mutate(
+      {
+        id: credential.id,
+        region: regionValue.trim() || null,
+        apiRegion: apiRegionValue.trim() || null,
+      },
+      {
+        onSuccess: (res) => {
+          toast.success(res.message)
+          setEditingRegion(false)
+        },
+        onError: (err) => {
+          toast.error('操作失败: ' + (err as Error).message)
+        },
+      }
+    )
+  }
+
+  const handleReset = () => {
+    resetFailure.mutate(credential.id, {
+      onSuccess: (res) => {
+        toast.success(res.message)
+      },
+      onError: (err) => {
+        toast.error('操作失败: ' + (err as Error).message)
+      },
+    })
+  }
+
+  const handleDelete = () => {
+    if (!credential.disabled) {
+      toast.error('请先禁用凭据再删除')
+      setShowDeleteDialog(false)
+      return
+    }
+
+    deleteCredential.mutate(credential.id, {
+      onSuccess: (res) => {
+        toast.success(res.message)
+        setShowDeleteDialog(false)
+      },
+      onError: (err) => {
+        toast.error('删除失败: ' + (err as Error).message)
+      },
+    })
+  }
+
+  // 格式化缓存时间（相对时间）
+  const formatCacheAge = (cachedAt: number) => {
+    const now = Date.now()
+    const diff = now - cachedAt
+    const seconds = Math.floor(diff / 1000)
+    if (seconds < 60) return `${seconds}秒前`
+    const minutes = Math.floor(seconds / 60)
+    if (minutes < 60) return `${minutes}分钟前`
+    return `${Math.floor(minutes / 60)}小时前`
+  }
+
+  // 检查缓存是否过期（使用后端返回的 TTL）
+  const isCacheStale = () => {
+    if (!cachedBalance) return true
+    const ageMs = Date.now() - cachedBalance.cachedAt
+    const ttlMs = (cachedBalance.ttlSecs ?? 60) * 1000
+    return ageMs > ttlMs
+  }
+
+  const handleViewBalance = () => {
+    onViewBalance(credential.id, isCacheStale())
+  }
+
+
+  return (
+    <>
+      <Card>
+        <CardHeader className="pb-2">
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-2">
+              <Checkbox
+                checked={selected}
+                onCheckedChange={onToggleSelect}
+              />
+              <CardTitle className="text-lg flex items-center gap-2">
+                {credential.email || `凭据 #${credential.id}`}
+                {credential.disabled && (
+                  <Badge variant="destructive">已禁用</Badge>
+                )}
+              </CardTitle>
+            </div>
+            <div className="flex items-center gap-2">
+              <span className="text-sm text-muted-foreground">启用</span>
+              <Switch
+                checked={!credential.disabled}
+                onCheckedChange={handleToggleDisabled}
+                disabled={setDisabled.isPending}
+              />
+            </div>
+          </div>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          {/* 信息网格 */}
+          <div className="grid grid-cols-2 gap-4 text-sm">
+            <div>
+              <span className="text-muted-foreground">优先级：</span>
+              {editingPriority ? (
+                <div className="inline-flex items-center gap-1 ml-1">
+                  <Input
+                    type="number"
+                    value={priorityValue}
+                    onChange={(e) => setPriorityValue(e.target.value)}
+                    className="w-16 h-7 text-sm"
+                    min="0"
+                  />
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    className="h-7 w-7 p-0"
+                    onClick={handlePriorityChange}
+                    disabled={setPriority.isPending}
+                  >
+                    ✓
+                  </Button>
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    className="h-7 w-7 p-0"
+                    onClick={() => {
+                      setEditingPriority(false)
+                      setPriorityValue(String(credential.priority))
+                    }}
+                  >
+                    ✕
+                  </Button>
+                </div>
+              ) : (
+                <span
+                  className="font-medium cursor-pointer hover:underline ml-1"
+                  onClick={() => setEditingPriority(true)}
+                >
+                  {credential.priority}
+                  <span className="text-xs text-muted-foreground ml-1">(点击编辑)</span>
+                </span>
+              )}
+            </div>
+            <div>
+              <span className="text-muted-foreground">失败次数：</span>
+              <span className={credential.failureCount > 0 ? 'text-red-500 font-medium' : ''}>
+                {credential.failureCount}
+              </span>
+            </div>
+            <div>
+              <span className="text-muted-foreground">订阅等级：</span>
+              <span className="font-medium">
+                {loadingBalance ? (
+                  <Loader2 className="inline w-3 h-3 animate-spin" />
+                ) : balance?.subscriptionTitle || '未知'}
+              </span>
+            </div>
+            <div>
+              <span className="text-muted-foreground">成功次数：</span>
+              <span className="font-medium">{credential.successCount}</span>
+            </div>
+            <div className="col-span-2">
+              <span className="text-muted-foreground">最后调用：</span>
+              <span className="font-medium">{formatLastUsed(credential.lastUsedAt)}</span>
+            </div>
+            <div className="col-span-2">
+              <span className="text-muted-foreground">剩余用量：</span>
+              {loadingBalance ? (
+                <span className="text-sm ml-1">
+                  <Loader2 className="inline w-3 h-3 animate-spin" /> 加载中...
+                </span>
+              ) : balance ? (
+                <span className="font-medium ml-1">
+                  {balance.remaining.toFixed(2)} / {balance.usageLimit.toFixed(2)}
+                  <span className="text-xs text-muted-foreground ml-1">
+                    ({(100 - balance.usagePercentage).toFixed(1)}% 剩余)
+                  </span>
+                </span>
+              ) : (
+                <span className="text-sm text-muted-foreground ml-1">未知</span>
+              )}
+            </div>
+            <div>
+              <span className="text-muted-foreground">余额：</span>
+              {cachedBalance && cachedBalance.ttlSecs > 0 ? (
+                <>
+                  <span className={`font-medium ${cachedBalance.remaining > 0 ? 'text-green-600' : 'text-red-500'}`}>
+                    ${cachedBalance.remaining.toFixed(2)}
+                  </span>
+                  <span className="text-xs text-muted-foreground ml-1">
+                    ({formatCacheAge(cachedBalance.cachedAt)})
+                  </span>
+                </>
+              ) : (
+                <span className="text-muted-foreground">—</span>
+              )}
+            </div>
+            {credential.hasProxy && (
+              <div className="col-span-2">
+                <span className="text-muted-foreground">代理：</span>
+                <span className="font-medium">{credential.proxyUrl}</span>
+              </div>
+            )}
+            {/* Region 配置 */}
+            <div className="col-span-2">
+              <span className="text-muted-foreground">Region：</span>
+              {editingRegion ? (
+                <div className="inline-flex items-center gap-1 ml-1 flex-wrap">
+                  <Input
+                    placeholder="Region（留空清除）"
+                    value={regionValue}
+                    onChange={(e) => setRegionValue(e.target.value)}
+                    className="w-32 h-7 text-sm"
+                  />
+                  <Input
+                    placeholder="API Region（可选）"
+                    value={apiRegionValue}
+                    onChange={(e) => setApiRegionValue(e.target.value)}
+                    className="w-36 h-7 text-sm"
+                  />
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    className="h-7 w-7 p-0"
+                    onClick={handleRegionChange}
+                    disabled={setRegion.isPending}
+                  >
+                    ✓
+                  </Button>
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    className="h-7 w-7 p-0"
+                    onClick={() => {
+                      setEditingRegion(false)
+                      setRegionValue(credential.region ?? '')
+                      setApiRegionValue(credential.apiRegion ?? '')
+                    }}
+                  >
+                    ✕
+                  </Button>
+                </div>
+              ) : (
+                <span
+                  className="font-medium cursor-pointer hover:underline ml-1"
+                  onClick={() => {
+                    setRegionValue(credential.region ?? '')
+                    setApiRegionValue(credential.apiRegion ?? '')
+                    setEditingRegion(true)
+                  }}
+                >
+                  {credential.region || '全局默认'}
+                  {credential.apiRegion && (
+                    <span className="text-muted-foreground ml-1">
+                      / API: {credential.apiRegion}
+                    </span>
+                  )}
+                  <span className="text-xs text-muted-foreground ml-1">(点击编辑)</span>
+                </span>
+              )}
+            </div>
+            {credential.hasProfileArn && (
+              <div className="col-span-2">
+                <Badge variant="secondary">有 Profile ARN</Badge>
+              </div>
+            )}
+          </div>
+
+          {/* 操作按钮 */}
+          <div className="flex flex-wrap gap-2 pt-2 border-t">
+            <Button
+              size="sm"
+              variant="outline"
+              onClick={handleReset}
+              disabled={resetFailure.isPending || credential.failureCount === 0}
+            >
+              <RefreshCw className="h-4 w-4 mr-1" />
+              重置失败
+            </Button>
+            <Button
+              size="sm"
+              variant="outline"
+              onClick={() => {
+                const newPriority = Math.max(0, credential.priority - 1)
+                setPriority.mutate(
+                  { id: credential.id, priority: newPriority },
+                  {
+                    onSuccess: (res) => toast.success(res.message),
+                    onError: (err) => toast.error('操作失败: ' + (err as Error).message),
+                  }
+                )
+              }}
+              disabled={setPriority.isPending || credential.priority === 0}
+            >
+              <ChevronUp className="h-4 w-4 mr-1" />
+              提高优先级
+            </Button>
+            <Button
+              size="sm"
+              variant="outline"
+              onClick={() => {
+                const newPriority = credential.priority + 1
+                setPriority.mutate(
+                  { id: credential.id, priority: newPriority },
+                  {
+                    onSuccess: (res) => toast.success(res.message),
+                    onError: (err) => toast.error('操作失败: ' + (err as Error).message),
+                  }
+                )
+              }}
+              disabled={setPriority.isPending}
+            >
+              <ChevronDown className="h-4 w-4 mr-1" />
+              降低优先级
+            </Button>
+            <Button
+              size="sm"
+              variant="default"
+              onClick={handleViewBalance}
+            >
+              <Wallet className="h-4 w-4 mr-1" />
+              查看余额
+            </Button>
+            <Button
+              size="sm"
+              variant="destructive"
+              onClick={() => setShowDeleteDialog(true)}
+              disabled={!credential.disabled}
+              title={!credential.disabled ? '需要先禁用凭据才能删除' : undefined}
+            >
+              <Trash2 className="h-4 w-4 mr-1" />
+              删除
+            </Button>
+          </div>
+        </CardContent>
+      </Card>
+
+      {/* 删除确认对话框 */}
+      <Dialog open={showDeleteDialog} onOpenChange={setShowDeleteDialog}>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>确认删除凭据</DialogTitle>
+            <DialogDescription>
+              您确定要删除凭据 #{credential.id} 吗？此操作无法撤销。
+            </DialogDescription>
+          </DialogHeader>
+          <DialogFooter>
+            <Button
+              variant="outline"
+              onClick={() => setShowDeleteDialog(false)}
+              disabled={deleteCredential.isPending}
+            >
+              取消
+            </Button>
+            <Button
+              variant="destructive"
+              onClick={handleDelete}
+              disabled={deleteCredential.isPending || !credential.disabled}
+            >
+              确认删除
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </>
+  )
+}
diff --git a/admin-ui/src/components/dashboard.tsx b/admin-ui/src/components/dashboard.tsx
new file mode 100644
index 0000000..d44dcf4
--- /dev/null
+++ b/admin-ui/src/components/dashboard.tsx
@@ -0,0 +1,700 @@
+import { useState, useEffect, useRef } from 'react'
+import { RefreshCw, LogOut, Moon, Sun, Server, Plus, Upload, Trash2, RotateCcw, CheckCircle2 } from 'lucide-react'
+import { useQueryClient } from '@tanstack/react-query'
+import { toast } from 'sonner'
+import { storage } from '@/lib/storage'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import { CredentialCard } from '@/components/credential-card'
+import { BalanceDialog } from '@/components/balance-dialog'
+import { AddCredentialDialog } from '@/components/add-credential-dialog'
+import { ImportTokenJsonDialog } from '@/components/import-token-json-dialog'
+import { BatchVerifyDialog, type VerifyResult } from '@/components/batch-verify-dialog'
+import { useCredentials, useCachedBalances, useDeleteCredential, useResetFailure } from '@/hooks/use-credentials'
+import { getCredentialBalance } from '@/api/credentials'
+import { extractErrorMessage } from '@/lib/utils'
+import { Badge } from '@/components/ui/badge'
+import type { BalanceResponse } from '@/types/api'
+
+interface DashboardProps {
+  onLogout: () => void
+}
+
+export function Dashboard({ onLogout }: DashboardProps) {
+  const [selectedCredentialId, setSelectedCredentialId] = useState<number | null>(null)
+  const [balanceDialogOpen, setBalanceDialogOpen] = useState(false)
+  const [forceRefreshBalance, setForceRefreshBalance] = useState(false)
+  const [addDialogOpen, setAddDialogOpen] = useState(false)
+  const [importDialogOpen, setImportDialogOpen] = useState(false)
+  const [selectedIds, setSelectedIds] = useState<Set<number>>(new Set())
+  const [verifyDialogOpen, setVerifyDialogOpen] = useState(false)
+  const [verifying, setVerifying] = useState(false)
+  const [verifyProgress, setVerifyProgress] = useState({ current: 0, total: 0 })
+  const [verifyResults, setVerifyResults] = useState<Map<number, VerifyResult>>(new Map())
+  const [balanceMap, setBalanceMap] = useState<Map<number, BalanceResponse>>(new Map())
+  const [loadingBalanceIds, setLoadingBalanceIds] = useState<Set<number>>(new Set())
+  const [queryingInfo, setQueryingInfo] = useState(false)
+  const [queryInfoProgress, setQueryInfoProgress] = useState({ current: 0, total: 0 })
+  const cancelVerifyRef = useRef(false)
+  const [currentPage, setCurrentPage] = useState(1)
+  const itemsPerPage = 12
+  const [darkMode, setDarkMode] = useState(() => {
+    if (typeof window !== 'undefined') {
+      return document.documentElement.classList.contains('dark')
+    }
+    return false
+  })
+
+  const queryClient = useQueryClient()
+  const { data, isLoading, error, refetch } = useCredentials()
+  const { data: cachedBalancesData } = useCachedBalances()
+  const { mutate: deleteCredential } = useDeleteCredential()
+  const { mutate: resetFailure } = useResetFailure()
+
+  // 构建 id -> cachedBalance 的映射
+  const cachedBalanceMap = new Map(
+    cachedBalancesData?.balances.map((b) => [b.id, b]) ?? []
+  )
+
+  // 计算分页
+  const totalPages = Math.ceil((data?.credentials.length || 0) / itemsPerPage)
+  const startIndex = (currentPage - 1) * itemsPerPage
+  const endIndex = startIndex + itemsPerPage
+  const currentCredentials = data?.credentials.slice(startIndex, endIndex) || []
+  const disabledCredentialCount = data?.credentials.filter(credential => credential.disabled).length || 0
+  const selectedDisabledCount = Array.from(selectedIds).filter(id => {
+    const credential = data?.credentials.find(c => c.id === id)
+    return Boolean(credential?.disabled)
+  }).length
+
+  // 当凭据列表变化时重置到第一页
+  useEffect(() => {
+    setCurrentPage(1)
+  }, [data?.credentials.length])
+
+  // 只保留当前仍存在的凭据缓存，避免删除后残留旧数据
+  useEffect(() => {
+    if (!data?.credentials) {
+      setBalanceMap(new Map())
+      setLoadingBalanceIds(new Set())
+      return
+    }
+
+    const validIds = new Set(data.credentials.map(credential => credential.id))
+
+    setBalanceMap(prev => {
+      const next = new Map<number, BalanceResponse>()
+      prev.forEach((value, id) => {
+        if (validIds.has(id)) {
+          next.set(id, value)
+        }
+      })
+      return next.size === prev.size ? prev : next
+    })
+
+    setLoadingBalanceIds(prev => {
+      if (prev.size === 0) {
+        return prev
+      }
+      const next = new Set<number>()
+      prev.forEach(id => {
+        if (validIds.has(id)) {
+          next.add(id)
+        }
+      })
+      return next.size === prev.size ? prev : next
+    })
+  }, [data?.credentials])
+
+  const toggleDarkMode = () => {
+    setDarkMode(!darkMode)
+    document.documentElement.classList.toggle('dark')
+  }
+
+  const handleViewBalance = (id: number, forceRefresh: boolean) => {
+    setSelectedCredentialId(id)
+    setForceRefreshBalance(forceRefresh)
+    if (forceRefresh) {
+      // 清除该凭据的余额缓存，强制重新获取
+      queryClient.invalidateQueries({ queryKey: ['credential-balance', id] })
+    }
+    setBalanceDialogOpen(true)
+  }
+
+  const handleRefresh = () => {
+    refetch()
+    toast.success('已刷新凭据列表')
+  }
+
+  const handleLogout = () => {
+    storage.removeApiKey()
+    queryClient.clear()
+    onLogout()
+  }
+
+  // 选择管理
+  const toggleSelect = (id: number) => {
+    const newSelected = new Set(selectedIds)
+    if (newSelected.has(id)) {
+      newSelected.delete(id)
+    } else {
+      newSelected.add(id)
+    }
+    setSelectedIds(newSelected)
+  }
+
+  const deselectAll = () => {
+    setSelectedIds(new Set())
+  }
+
+  // 批量删除（仅删除已禁用项）
+  const handleBatchDelete = async () => {
+    if (selectedIds.size === 0) {
+      toast.error('请先选择要删除的凭据')
+      return
+    }
+
+    const disabledIds = Array.from(selectedIds).filter(id => {
+      const credential = data?.credentials.find(c => c.id === id)
+      return Boolean(credential?.disabled)
+    })
+
+    if (disabledIds.length === 0) {
+      toast.error('选中的凭据中没有已禁用项')
+      return
+    }
+
+    const skippedCount = selectedIds.size - disabledIds.length
+    const skippedText = skippedCount > 0 ? `（将跳过 ${skippedCount} 个未禁用凭据）` : ''
+
+    if (!confirm(`确定要删除 ${disabledIds.length} 个已禁用凭据吗？此操作无法撤销。${skippedText}`)) {
+      return
+    }
+
+    let successCount = 0
+    let failCount = 0
+
+    for (const id of disabledIds) {
+      try {
+        await new Promise<void>((resolve, reject) => {
+          deleteCredential(id, {
+            onSuccess: () => {
+              successCount++
+              resolve()
+            },
+            onError: (err) => {
+              failCount++
+              reject(err)
+            }
+          })
+        })
+      } catch (error) {
+        // 错误已在 onError 中处理
+      }
+    }
+
+    const skippedResultText = skippedCount > 0 ? `，已跳过 ${skippedCount} 个未禁用凭据` : ''
+
+    if (failCount === 0) {
+      toast.success(`成功删除 ${successCount} 个已禁用凭据${skippedResultText}`)
+    } else {
+      toast.warning(`删除已禁用凭据：成功 ${successCount} 个，失败 ${failCount} 个${skippedResultText}`)
+    }
+
+    deselectAll()
+  }
+
+  // 批量恢复异常
+  const handleBatchResetFailure = async () => {
+    if (selectedIds.size === 0) {
+      toast.error('请先选择要恢复的凭据')
+      return
+    }
+
+    const failedIds = Array.from(selectedIds).filter(id => {
+      const cred = data?.credentials.find(c => c.id === id)
+      return cred && cred.failureCount > 0
+    })
+
+    if (failedIds.length === 0) {
+      toast.error('选中的凭据中没有失败的凭据')
+      return
+    }
+
+    let successCount = 0
+    let failCount = 0
+
+    for (const id of failedIds) {
+      try {
+        await new Promise<void>((resolve, reject) => {
+          resetFailure(id, {
+            onSuccess: () => {
+              successCount++
+              resolve()
+            },
+            onError: (err) => {
+              failCount++
+              reject(err)
+            }
+          })
+        })
+      } catch (error) {
+        // 错误已在 onError 中处理
+      }
+    }
+
+    if (failCount === 0) {
+      toast.success(`成功恢复 ${successCount} 个凭据`)
+    } else {
+      toast.warning(`成功 ${successCount} 个，失败 ${failCount} 个`)
+    }
+
+    deselectAll()
+  }
+
+  // 一键清除所有已禁用凭据
+  const handleClearAll = async () => {
+    if (!data?.credentials || data.credentials.length === 0) {
+      toast.error('没有可清除的凭据')
+      return
+    }
+
+    const disabledCredentials = data.credentials.filter(credential => credential.disabled)
+
+    if (disabledCredentials.length === 0) {
+      toast.error('没有可清除的已禁用凭据')
+      return
+    }
+
+    if (!confirm(`确定要清除所有 ${disabledCredentials.length} 个已禁用凭据吗？此操作无法撤销。`)) {
+      return
+    }
+
+    let successCount = 0
+    let failCount = 0
+
+    for (const credential of disabledCredentials) {
+      try {
+        await new Promise<void>((resolve, reject) => {
+          deleteCredential(credential.id, {
+            onSuccess: () => {
+              successCount++
+              resolve()
+            },
+            onError: (err) => {
+              failCount++
+              reject(err)
+            }
+          })
+        })
+      } catch (error) {
+        // 错误已在 onError 中处理
+      }
+    }
+
+    if (failCount === 0) {
+      toast.success(`成功清除所有 ${successCount} 个已禁用凭据`)
+    } else {
+      toast.warning(`清除已禁用凭据：成功 ${successCount} 个，失败 ${failCount} 个`)
+    }
+
+    deselectAll()
+  }
+
+  // 查询当前页凭据信息（逐个查询，避免瞬时并发）
+  const handleQueryCurrentPageInfo = async () => {
+    if (currentCredentials.length === 0) {
+      toast.error('当前页没有可查询的凭据')
+      return
+    }
+
+    const ids = currentCredentials
+      .filter(credential => !credential.disabled)
+      .map(credential => credential.id)
+
+    if (ids.length === 0) {
+      toast.error('当前页没有可查询的启用凭据')
+      return
+    }
+
+    setQueryingInfo(true)
+    setQueryInfoProgress({ current: 0, total: ids.length })
+
+    let successCount = 0
+    let failCount = 0
+
+    for (let i = 0; i < ids.length; i++) {
+      const id = ids[i]
+
+      setLoadingBalanceIds(prev => {
+        const next = new Set(prev)
+        next.add(id)
+        return next
+      })
+
+      try {
+        const balance = await getCredentialBalance(id)
+        successCount++
+
+        setBalanceMap(prev => {
+          const next = new Map(prev)
+          next.set(id, balance)
+          return next
+        })
+      } catch (error) {
+        failCount++
+      } finally {
+        setLoadingBalanceIds(prev => {
+          const next = new Set(prev)
+          next.delete(id)
+          return next
+        })
+      }
+
+      setQueryInfoProgress({ current: i + 1, total: ids.length })
+    }
+
+    setQueryingInfo(false)
+
+    if (failCount === 0) {
+      toast.success(`查询完成：成功 ${successCount}/${ids.length}`)
+    } else {
+      toast.warning(`查询完成：成功 ${successCount} 个，失败 ${failCount} 个`)
+    }
+  }
+
+  // 批量验活
+  const handleBatchVerify = async () => {
+    if (selectedIds.size === 0) {
+      toast.error('请先选择要验活的凭据')
+      return
+    }
+
+    // 初始化状态
+    setVerifying(true)
+    cancelVerifyRef.current = false
+    const ids = Array.from(selectedIds)
+    setVerifyProgress({ current: 0, total: ids.length })
+
+    let successCount = 0
+
+    // 初始化结果，所有凭据状态为 pending
+    const initialResults = new Map<number, VerifyResult>()
+    ids.forEach(id => {
+      initialResults.set(id, { id, status: 'pending' })
+    })
+    setVerifyResults(initialResults)
+    setVerifyDialogOpen(true)
+
+    // 开始验活
+    for (let i = 0; i < ids.length; i++) {
+      // 检查是否取消
+      if (cancelVerifyRef.current) {
+        toast.info('已取消验活')
+        break
+      }
+
+      const id = ids[i]
+
+      // 更新当前凭据状态为 verifying
+      setVerifyResults(prev => {
+        const newResults = new Map(prev)
+        newResults.set(id, { id, status: 'verifying' })
+        return newResults
+      })
+
+      try {
+        const balance = await getCredentialBalance(id)
+        successCount++
+
+        // 更新为成功状态
+        setVerifyResults(prev => {
+          const newResults = new Map(prev)
+          newResults.set(id, {
+            id,
+            status: 'success',
+            usage: `${balance.currentUsage}/${balance.usageLimit}`
+          })
+          return newResults
+        })
+      } catch (error) {
+        // 更新为失败状态
+        setVerifyResults(prev => {
+          const newResults = new Map(prev)
+          newResults.set(id, {
+            id,
+            status: 'failed',
+            error: extractErrorMessage(error)
+          })
+          return newResults
+        })
+      }
+
+      // 更新进度
+      setVerifyProgress({ current: i + 1, total: ids.length })
+
+      // 添加延迟防止封号（最后一个不需要延迟）
+      if (i < ids.length - 1 && !cancelVerifyRef.current) {
+        await new Promise(resolve => setTimeout(resolve, 2000))
+      }
+    }
+
+    setVerifying(false)
+
+    if (!cancelVerifyRef.current) {
+      toast.success(`验活完成：成功 ${successCount}/${ids.length}`)
+    }
+  }
+
+  // 取消验活
+  const handleCancelVerify = () => {
+    cancelVerifyRef.current = true
+    setVerifying(false)
+  }
+
+  if (isLoading) {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-background">
+        <div className="text-center">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-primary mx-auto mb-4"></div>
+          <p className="text-muted-foreground">加载中...</p>
+        </div>
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-background p-4">
+        <Card className="w-full max-w-md">
+          <CardContent className="pt-6 text-center">
+            <div className="text-red-500 mb-4">加载失败</div>
+            <p className="text-muted-foreground mb-4">{(error as Error).message}</p>
+            <div className="space-x-2">
+              <Button onClick={() => refetch()}>重试</Button>
+              <Button variant="outline" onClick={handleLogout}>重新登录</Button>
+            </div>
+          </CardContent>
+        </Card>
+      </div>
+    )
+  }
+
+  return (
+    <div className="min-h-screen bg-background">
+      {/* 顶部导航 */}
+      <header className="sticky top-0 z-50 w-full border-b bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/60">
+        <div className="container flex h-14 items-center justify-between px-4 md:px-8">
+          <div className="flex items-center gap-2">
+            <Server className="h-5 w-5" />
+            <span className="font-semibold">Kiro Admin</span>
+          </div>
+          <div className="flex items-center gap-2">
+            <Button variant="ghost" size="icon" onClick={toggleDarkMode}>
+              {darkMode ? <Sun className="h-5 w-5" /> : <Moon className="h-5 w-5" />}
+            </Button>
+            <Button variant="ghost" size="icon" onClick={handleRefresh}>
+              <RefreshCw className="h-5 w-5" />
+            </Button>
+            <Button variant="ghost" size="icon" onClick={handleLogout}>
+              <LogOut className="h-5 w-5" />
+            </Button>
+          </div>
+        </div>
+      </header>
+
+      {/* 主内容 */}
+      <main className="container mx-auto px-4 md:px-8 py-6">
+        {/* 统计卡片 */}
+        <div className="grid gap-4 md:grid-cols-2 mb-6">
+          <Card>
+            <CardHeader className="pb-2">
+              <CardTitle className="text-sm font-medium text-muted-foreground">
+                凭据总数
+              </CardTitle>
+            </CardHeader>
+            <CardContent>
+              <div className="text-2xl font-bold">{data?.total || 0}</div>
+            </CardContent>
+          </Card>
+          <Card>
+            <CardHeader className="pb-2">
+              <CardTitle className="text-sm font-medium text-muted-foreground">
+                可用凭据
+              </CardTitle>
+            </CardHeader>
+            <CardContent>
+              <div className="text-2xl font-bold text-green-600">{data?.available || 0}</div>
+            </CardContent>
+          </Card>
+        </div>
+
+        {/* 凭据列表 */}
+        <div className="space-y-4">
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-4">
+              <h2 className="text-xl font-semibold">凭据管理</h2>
+              {selectedIds.size > 0 && (
+                <div className="flex items-center gap-2">
+                  <Badge variant="secondary">已选择 {selectedIds.size} 个</Badge>
+                  <Button onClick={deselectAll} size="sm" variant="ghost">
+                    取消选择
+                  </Button>
+                </div>
+              )}
+            </div>
+            <div className="flex gap-2">
+              {selectedIds.size > 0 && (
+                <>
+                  <Button onClick={handleBatchVerify} size="sm" variant="outline">
+                    <CheckCircle2 className="h-4 w-4 mr-2" />
+                    批量验活
+                  </Button>
+                  <Button onClick={handleBatchResetFailure} size="sm" variant="outline">
+                    <RotateCcw className="h-4 w-4 mr-2" />
+                    恢复异常
+                  </Button>
+                  <Button
+                    onClick={handleBatchDelete}
+                    size="sm"
+                    variant="destructive"
+                    disabled={selectedDisabledCount === 0}
+                    title={selectedDisabledCount === 0 ? '只能删除已禁用凭据' : undefined}
+                  >
+                    <Trash2 className="h-4 w-4 mr-2" />
+                    批量删除
+                  </Button>
+                </>
+              )}
+              {verifying && !verifyDialogOpen && (
+                <Button onClick={() => setVerifyDialogOpen(true)} size="sm" variant="secondary">
+                  <CheckCircle2 className="h-4 w-4 mr-2 animate-spin" />
+                  验活中... {verifyProgress.current}/{verifyProgress.total}
+                </Button>
+              )}
+              {data?.credentials && data.credentials.length > 0 && (
+                <Button
+                  onClick={handleQueryCurrentPageInfo}
+                  size="sm"
+                  variant="outline"
+                  disabled={queryingInfo}
+                >
+                  <RefreshCw className={`h-4 w-4 mr-2 ${queryingInfo ? 'animate-spin' : ''}`} />
+                  {queryingInfo ? `查询中... ${queryInfoProgress.current}/${queryInfoProgress.total}` : '查询信息'}
+                </Button>
+              )}
+              {data?.credentials && data.credentials.length > 0 && (
+                <Button
+                  onClick={handleClearAll}
+                  size="sm"
+                  variant="outline"
+                  className="text-destructive hover:text-destructive"
+                  disabled={disabledCredentialCount === 0}
+                  title={disabledCredentialCount === 0 ? '没有可清除的已禁用凭据' : undefined}
+                >
+                  <Trash2 className="h-4 w-4 mr-2" />
+                  清除已禁用
+                </Button>
+              )}
+              <Button variant="outline" onClick={() => setImportDialogOpen(true)} size="sm">
+                <Upload className="h-4 w-4 mr-2" />
+                导入凭据
+              </Button>
+              <Button onClick={() => setAddDialogOpen(true)} size="sm">
+                <Plus className="h-4 w-4 mr-2" />
+                添加凭据
+              </Button>
+            </div>
+          </div>
+          {data?.credentials.length === 0 ? (
+            <Card>
+              <CardContent className="py-8 text-center text-muted-foreground">
+                暂无凭据
+              </CardContent>
+            </Card>
+          ) : (
+            <>
+              <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
+                {currentCredentials.map((credential) => (
+                  <CredentialCard
+                    key={credential.id}
+                    credential={credential}
+                    cachedBalance={cachedBalanceMap.get(credential.id)}
+                    onViewBalance={handleViewBalance}
+                    selected={selectedIds.has(credential.id)}
+                    onToggleSelect={() => toggleSelect(credential.id)}
+                    balance={balanceMap.get(credential.id) || null}
+                    loadingBalance={loadingBalanceIds.has(credential.id)}
+                  />
+                ))}
+              </div>
+
+              {/* 分页控件 */}
+              {totalPages > 1 && (
+                <div className="flex justify-center items-center gap-4 mt-6">
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() => setCurrentPage(p => Math.max(1, p - 1))}
+                    disabled={currentPage === 1}
+                  >
+                    上一页
+                  </Button>
+                  <span className="text-sm text-muted-foreground">
+                    第 {currentPage} / {totalPages} 页（共 {data?.credentials.length} 个凭据）
+                  </span>
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() => setCurrentPage(p => Math.min(totalPages, p + 1))}
+                    disabled={currentPage === totalPages}
+                  >
+                    下一页
+                  </Button>
+                </div>
+              )}
+            </>
+          )}
+        </div>
+      </main>
+
+      {/* 余额对话框 */}
+      <BalanceDialog
+        credentialId={selectedCredentialId}
+        open={balanceDialogOpen}
+        onOpenChange={(open) => {
+          setBalanceDialogOpen(open)
+          if (!open) {
+            setForceRefreshBalance(false)
+            // 关闭弹窗时刷新缓存余额，让卡片显示最新数据
+            queryClient.invalidateQueries({ queryKey: ['cached-balances'] })
+          }
+        }}
+        forceRefresh={forceRefreshBalance}
+      />
+
+      {/* 添加凭据对话框 */}
+      <AddCredentialDialog
+        open={addDialogOpen}
+        onOpenChange={setAddDialogOpen}
+      />
+
+      {/* 导入凭据对话框 */}
+      <ImportTokenJsonDialog
+        open={importDialogOpen}
+        onOpenChange={setImportDialogOpen}
+      />
+
+
+      {/* 批量验活对话框 */}
+      <BatchVerifyDialog
+        open={verifyDialogOpen}
+        onOpenChange={setVerifyDialogOpen}
+        verifying={verifying}
+        progress={verifyProgress}
+        results={verifyResults}
+        onCancel={handleCancelVerify}
+      />
+    </div>
+  )
+}
diff --git a/admin-ui/src/components/import-token-json-dialog.tsx b/admin-ui/src/components/import-token-json-dialog.tsx
new file mode 100644
index 0000000..124d6a0
--- /dev/null
+++ b/admin-ui/src/components/import-token-json-dialog.tsx
@@ -0,0 +1,671 @@
+import { useState, useCallback, useRef } from 'react'
+import { toast } from 'sonner'
+import { Upload, FileJson, CheckCircle2, XCircle, AlertCircle, Loader2 } from 'lucide-react'
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+  DialogDescription,
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { Switch } from '@/components/ui/switch'
+import { useImportTokenJson, useDeleteCredential } from '@/hooks/use-credentials'
+import { getCredentialBalance, setCredentialDisabled } from '@/api/credentials'
+import { extractErrorMessage } from '@/lib/utils'
+import type { TokenJsonItem, ImportItemResult, ImportSummary } from '@/types/api'
+
+interface ImportTokenJsonDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+}
+
+type Step = 'input' | 'preview' | 'result' | 'verifying'
+
+// 验活结果
+interface VerifyItemResult {
+  index: number
+  credentialId?: number
+  status: 'pending' | 'verifying' | 'verified' | 'failed' | 'skipped' | 'rolled_back' | 'rollback_failed'
+  usage?: string
+  error?: string
+  rollbackError?: string
+}
+
+export function ImportTokenJsonDialog({ open, onOpenChange }: ImportTokenJsonDialogProps) {
+  const [step, setStep] = useState<Step>('input')
+  const [jsonText, setJsonText] = useState('')
+  const [parsedItems, setParsedItems] = useState<TokenJsonItem[]>([])
+  const [previewResults, setPreviewResults] = useState<ImportItemResult[]>([])
+  const [previewSummary, setPreviewSummary] = useState<ImportSummary | null>(null)
+  const [finalResults, setFinalResults] = useState<ImportItemResult[]>([])
+  const [finalSummary, setFinalSummary] = useState<ImportSummary | null>(null)
+  const [isDragging, setIsDragging] = useState(false)
+  const [enableVerify, setEnableVerify] = useState(false)
+  const [verifyResults, setVerifyResults] = useState<VerifyItemResult[]>([])
+  const [verifyProgress, setVerifyProgress] = useState({ current: 0, total: 0 })
+  const [isVerifying, setIsVerifying] = useState(false)
+  const fileInputRef = useRef<HTMLInputElement>(null)
+
+  const { mutate: importMutate, isPending } = useImportTokenJson()
+  const { mutateAsync: deleteCredential } = useDeleteCredential()
+
+  const resetState = useCallback(() => {
+    setStep('input')
+    setJsonText('')
+    setParsedItems([])
+    setPreviewResults([])
+    setPreviewSummary(null)
+    setFinalResults([])
+    setFinalSummary(null)
+    setEnableVerify(false)
+    setVerifyResults([])
+    setVerifyProgress({ current: 0, total: 0 })
+    setIsVerifying(false)
+  }, [])
+
+  const handleClose = useCallback(() => {
+    if (isVerifying) return // 验活中不允许关闭
+    onOpenChange(false)
+    setTimeout(resetState, 200)
+  }, [onOpenChange, resetState, isVerifying])
+
+  // 将 KAM 账号结构展平为 TokenJsonItem
+  const flattenKamAccount = useCallback((account: Record<string, unknown>): TokenJsonItem | null => {
+    const cred = account.credentials as Record<string, unknown> | undefined
+    if (!cred || typeof cred !== 'object') return null
+    // refreshToken 必须是非空字符串
+    if (typeof cred.refreshToken !== 'string' || !cred.refreshToken.trim()) return null
+    // 跳过 error 状态的账号
+    if (account.status === 'error') return null
+    const authMethod = cred.authMethod as string | undefined
+    return {
+      refreshToken: cred.refreshToken.trim(),
+      clientId: cred.clientId as string | undefined,
+      clientSecret: cred.clientSecret as string | undefined,
+      authMethod: (!authMethod && cred.clientId && cred.clientSecret) ? 'idc' : authMethod,
+      region: cred.region as string | undefined,
+      machineId: account.machineId as string | undefined,
+    }
+  }, [])
+
+  // 解析 JSON（兼容 Token JSON / KAM 导出 / 批量导入格式）
+  const parseJson = useCallback((text: string): TokenJsonItem[] | null => {
+    try {
+      const parsed = JSON.parse(text)
+
+      let rawItems: unknown[]
+
+      // KAM 标准导出格式：{ version, accounts: [...] }
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && Array.isArray(parsed.accounts)) {
+        rawItems = parsed.accounts
+      } else if (Array.isArray(parsed)) {
+        rawItems = parsed
+      } else if (parsed && typeof parsed === 'object') {
+        rawItems = [parsed]
+      } else {
+        toast.error('JSON 格式无效')
+        return null
+      }
+
+      const validItems: TokenJsonItem[] = []
+      for (const item of rawItems) {
+        if (!item || typeof item !== 'object') continue
+        const obj = item as Record<string, unknown>
+
+        // KAM 嵌套格式：{ credentials: { refreshToken, ... } }
+        if (obj.credentials && typeof obj.credentials === 'object') {
+          const flat = flattenKamAccount(obj)
+          if (flat) validItems.push(flat)
+          continue
+        }
+
+        // 扁平格式：{ refreshToken, ... }
+        if (typeof obj.refreshToken === 'string' && obj.refreshToken.trim()) {
+          const tokenItem = { ...obj, refreshToken: obj.refreshToken.trim() } as TokenJsonItem
+          // 兼容旧批量导入的 authRegion 字段
+          if (!tokenItem.region && obj.authRegion) {
+            tokenItem.region = obj.authRegion as string
+          }
+          if (!tokenItem.authMethod && tokenItem.clientId && tokenItem.clientSecret) {
+            tokenItem.authMethod = 'idc'
+          }
+          validItems.push(tokenItem)
+        }
+      }
+
+      if (validItems.length === 0) {
+        toast.error('JSON 中没有找到有效的凭据（需要包含 refreshToken 字段）')
+        return null
+      }
+      return validItems
+    } catch {
+      toast.error('JSON 格式无效')
+      return null
+    }
+  }, [flattenKamAccount])
+
+  // 文件拖放
+  const handleDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    setIsDragging(false)
+    const file = e.dataTransfer.files[0]
+    if (!file) return
+    if (!file.name.endsWith('.json')) {
+      toast.error('请上传 JSON 文件')
+      return
+    }
+    const reader = new FileReader()
+    reader.onload = (event) => setJsonText(event.target?.result as string)
+    reader.readAsText(file)
+  }, [])
+
+  // 文件选择
+  const handleFileSelect = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (!file) return
+    const reader = new FileReader()
+    reader.onload = (event) => setJsonText(event.target?.result as string)
+    reader.readAsText(file)
+  }, [])
+
+  // 预览（dry-run）
+  const handlePreview = useCallback(() => {
+    const items = parseJson(jsonText)
+    if (!items) return
+    setParsedItems(items)
+    importMutate(
+      { dryRun: true, items },
+      {
+        onSuccess: (response) => {
+          setPreviewResults(response.items)
+          setPreviewSummary(response.summary)
+          setStep('preview')
+        },
+        onError: (error) => {
+          toast.error(`预览失败: ${extractErrorMessage(error)}`)
+        },
+      }
+    )
+  }, [jsonText, parseJson, importMutate])
+
+  // 回滚凭据（禁用 + 删除）
+  const rollbackCredential = async (id: number): Promise<{ success: boolean; error?: string }> => {
+    try {
+      await setCredentialDisabled(id, true)
+    } catch (error) {
+      return { success: false, error: `禁用失败: ${extractErrorMessage(error)}` }
+    }
+    try {
+      await deleteCredential(id)
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: `删除失败: ${extractErrorMessage(error)}` }
+    }
+  }
+
+  // 验活流程
+  const runVerification = useCallback(async (results: ImportItemResult[]) => {
+    const addedItems = results.filter(r => r.action === 'added' && r.credentialId)
+    if (addedItems.length === 0) {
+      toast.info('没有新增凭据需要验活')
+      return
+    }
+
+    setIsVerifying(true)
+    setStep('verifying')
+    setVerifyProgress({ current: 0, total: addedItems.length })
+
+    const initialVerifyResults: VerifyItemResult[] = addedItems.map(item => ({
+      index: item.index,
+      credentialId: item.credentialId,
+      status: 'pending',
+    }))
+    setVerifyResults(initialVerifyResults)
+
+    let successCount = 0
+    let failCount = 0
+
+    for (let i = 0; i < addedItems.length; i++) {
+      const item = addedItems[i]
+      const credId = item.credentialId!
+
+      // 更新为验活中
+      setVerifyResults(prev => prev.map((r, idx) =>
+        idx === i ? { ...r, status: 'verifying' } : r
+      ))
+
+      try {
+        await new Promise(resolve => setTimeout(resolve, 1000))
+        const balance = await getCredentialBalance(credId)
+        successCount++
+        setVerifyResults(prev => prev.map((r, idx) =>
+          idx === i ? { ...r, status: 'verified', usage: `${balance.currentUsage}/${balance.usageLimit}` } : r
+        ))
+      } catch (error) {
+        failCount++
+        // 验活失败，回滚
+        const rollback = await rollbackCredential(credId)
+        setVerifyResults(prev => prev.map((r, idx) =>
+          idx === i ? {
+            ...r,
+            status: rollback.success ? 'rolled_back' : 'rollback_failed',
+            error: extractErrorMessage(error),
+            rollbackError: rollback.error,
+          } : r
+        ))
+      }
+
+      setVerifyProgress({ current: i + 1, total: addedItems.length })
+    }
+
+    setIsVerifying(false)
+
+    if (failCount === 0) {
+      toast.success(`全部 ${successCount} 个凭据验活成功`)
+    } else {
+      toast.info(`验活完成：成功 ${successCount}，失败 ${failCount}`)
+    }
+  }, [deleteCredential])
+
+  // 确认导入
+  const handleConfirmImport = useCallback(() => {
+    importMutate(
+      { dryRun: false, items: parsedItems },
+      {
+        onSuccess: (response) => {
+          setFinalResults(response.items)
+          setFinalSummary(response.summary)
+
+          if (enableVerify) {
+            // 开启验活模式：导入后自动验活
+            if (response.summary.added > 0) {
+              toast.success(`成功导入 ${response.summary.added} 个凭据，开始验活...`)
+              runVerification(response.items)
+            } else {
+              // 没有新增凭据，直接显示结果
+              setStep('result')
+              toast.info('没有新增凭据需要验活')
+            }
+          } else {
+            // 普通模式：直接显示结果
+            setStep('result')
+            if (response.summary.added > 0) {
+              toast.success(`成功导入 ${response.summary.added} 个凭据`)
+            }
+          }
+        },
+        onError: (error) => {
+          toast.error(`导入失败: ${extractErrorMessage(error)}`)
+        },
+      }
+    )
+  }, [parsedItems, importMutate, enableVerify, runVerification])
+
+  // 渲染图标
+  const renderActionIcon = (action: string) => {
+    switch (action) {
+      case 'added': return <CheckCircle2 className="h-4 w-4 text-green-500" />
+      case 'skipped': return <AlertCircle className="h-4 w-4 text-yellow-500" />
+      case 'invalid': return <XCircle className="h-4 w-4 text-red-500" />
+      default: return null
+    }
+  }
+
+  const renderActionText = (action: string) => {
+    switch (action) {
+      case 'added': return <span className="text-green-600">添加</span>
+      case 'skipped': return <span className="text-yellow-600">跳过</span>
+      case 'invalid': return <span className="text-red-600">无效</span>
+      default: return action
+    }
+  }
+
+  const getVerifyStatusIcon = (status: VerifyItemResult['status']) => {
+    switch (status) {
+      case 'pending': return <div className="w-5 h-5 rounded-full border-2 border-gray-300" />
+      case 'verifying': return <Loader2 className="w-5 h-5 animate-spin text-blue-500" />
+      case 'verified': return <CheckCircle2 className="w-5 h-5 text-green-500" />
+      case 'failed':
+      case 'rollback_failed': return <XCircle className="w-5 h-5 text-red-500" />
+      case 'rolled_back': return <AlertCircle className="w-5 h-5 text-yellow-500" />
+      case 'skipped': return <AlertCircle className="w-5 h-5 text-gray-400" />
+    }
+  }
+
+  const getVerifyStatusText = (result: VerifyItemResult) => {
+    switch (result.status) {
+      case 'pending': return '等待中'
+      case 'verifying': return '验活中...'
+      case 'verified': return '验活成功'
+      case 'failed': return '验活失败'
+      case 'rolled_back': return '验活失败（已排除）'
+      case 'rollback_failed': return '验活失败（未排除）'
+      case 'skipped': return '跳过'
+    }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={handleClose}>
+      <DialogContent className="sm:max-w-2xl max-h-[80vh] overflow-hidden flex flex-col">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <FileJson className="h-5 w-5" />
+            导入凭据
+          </DialogTitle>
+          <DialogDescription>
+            {step === 'input' && '粘贴或上传 JSON 文件以批量导入凭据'}
+            {step === 'preview' && '预览导入结果，确认后执行导入'}
+            {step === 'result' && '导入完成'}
+            {step === 'verifying' && '正在验活导入的凭据...'}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="flex-1 overflow-auto py-4">
+          {/* Step 1: Input */}
+          {step === 'input' && (
+            <div className="space-y-4">
+              {/* 拖放区域 */}
+              <div
+                className={`border-2 border-dashed rounded-lg p-8 text-center transition-colors ${
+                  isDragging
+                    ? 'border-primary bg-primary/5'
+                    : 'border-muted-foreground/25 hover:border-muted-foreground/50'
+                }`}
+                onDragOver={(e) => { e.preventDefault(); setIsDragging(true) }}
+                onDragLeave={() => setIsDragging(false)}
+                onDrop={handleDrop}
+                onClick={() => fileInputRef.current?.click()}
+              >
+                <Upload className="h-10 w-10 mx-auto mb-4 text-muted-foreground" />
+                <p className="text-sm text-muted-foreground mb-2">
+                  拖放 JSON 文件到此处，或点击选择文件
+                </p>
+                <p className="text-xs text-muted-foreground">
+                  支持单个凭据或凭据数组格式
+                </p>
+                <input
+                  ref={fileInputRef}
+                  type="file"
+                  accept=".json"
+                  className="hidden"
+                  onChange={handleFileSelect}
+                />
+              </div>
+
+              {/* 分隔线 */}
+              <div className="relative">
+                <div className="absolute inset-0 flex items-center">
+                  <span className="w-full border-t" />
+                </div>
+                <div className="relative flex justify-center text-xs uppercase">
+                  <span className="bg-background px-2 text-muted-foreground">或</span>
+                </div>
+              </div>
+
+              {/* 文本输入 */}
+              <div className="space-y-2">
+                <label className="text-sm font-medium">直接粘贴 JSON</label>
+                <textarea
+                  className="w-full h-48 p-3 text-sm font-mono border rounded-md bg-background resize-none focus:outline-none focus:ring-2 focus:ring-ring"
+                  placeholder='{"refreshToken": "...", "provider": "BuilderId", ...}'
+                  value={jsonText}
+                  onChange={(e) => setJsonText(e.target.value)}
+                />
+              </div>
+            </div>
+          )}
+
+          {/* Step 2: Preview */}
+          {step === 'preview' && previewSummary && (
+            <div className="space-y-4">
+              {/* 统计 */}
+              <div className="grid grid-cols-4 gap-4">
+                <div className="text-center p-3 bg-muted rounded-lg">
+                  <div className="text-2xl font-bold">{previewSummary.parsed}</div>
+                  <div className="text-xs text-muted-foreground">解析</div>
+                </div>
+                <div className="text-center p-3 bg-green-50 dark:bg-green-950 rounded-lg">
+                  <div className="text-2xl font-bold text-green-600">{previewSummary.added}</div>
+                  <div className="text-xs text-muted-foreground">将添加</div>
+                </div>
+                <div className="text-center p-3 bg-yellow-50 dark:bg-yellow-950 rounded-lg">
+                  <div className="text-2xl font-bold text-yellow-600">{previewSummary.skipped}</div>
+                  <div className="text-xs text-muted-foreground">跳过</div>
+                </div>
+                <div className="text-center p-3 bg-red-50 dark:bg-red-950 rounded-lg">
+                  <div className="text-2xl font-bold text-red-600">{previewSummary.invalid}</div>
+                  <div className="text-xs text-muted-foreground">无效</div>
+                </div>
+              </div>
+
+              {/* 预览列表 */}
+              <div className="border rounded-lg overflow-hidden">
+                <div className="max-h-48 overflow-auto">
+                  <table className="w-full text-sm">
+                    <thead className="bg-muted sticky top-0">
+                      <tr>
+                        <th className="text-left p-2 font-medium">#</th>
+                        <th className="text-left p-2 font-medium">指纹</th>
+                        <th className="text-left p-2 font-medium">状态</th>
+                        <th className="text-left p-2 font-medium">原因</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {previewResults.map((item) => (
+                        <tr key={item.index} className="border-t">
+                          <td className="p-2">{item.index + 1}</td>
+                          <td className="p-2 font-mono text-xs">{item.fingerprint}</td>
+                          <td className="p-2">
+                            <div className="flex items-center gap-1">
+                              {renderActionIcon(item.action)}
+                              {renderActionText(item.action)}
+                            </div>
+                          </td>
+                          <td className="p-2 text-muted-foreground text-xs">
+                            {item.reason || '-'}
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </div>
+              </div>
+
+              {/* 验活开关 */}
+              {previewSummary.added > 0 && (
+                <div className="flex items-center justify-between p-3 border rounded-lg bg-muted/50">
+                  <div>
+                    <div className="text-sm font-medium">导入后自动验活</div>
+                    <div className="text-xs text-muted-foreground">
+                      逐个检查凭据有效性，失败的自动排除
+                    </div>
+                  </div>
+                  <Switch checked={enableVerify} onCheckedChange={setEnableVerify} />
+                </div>
+              )}
+            </div>
+          )}
+
+          {/* Step 3: Result (普通模式) */}
+          {step === 'result' && finalSummary && (
+            <div className="space-y-4">
+              <div className="grid grid-cols-4 gap-4">
+                <div className="text-center p-3 bg-muted rounded-lg">
+                  <div className="text-2xl font-bold">{finalSummary.parsed}</div>
+                  <div className="text-xs text-muted-foreground">解析</div>
+                </div>
+                <div className="text-center p-3 bg-green-50 dark:bg-green-950 rounded-lg">
+                  <div className="text-2xl font-bold text-green-600">{finalSummary.added}</div>
+                  <div className="text-xs text-muted-foreground">已添加</div>
+                </div>
+                <div className="text-center p-3 bg-yellow-50 dark:bg-yellow-950 rounded-lg">
+                  <div className="text-2xl font-bold text-yellow-600">{finalSummary.skipped}</div>
+                  <div className="text-xs text-muted-foreground">跳过</div>
+                </div>
+                <div className="text-center p-3 bg-red-50 dark:bg-red-950 rounded-lg">
+                  <div className="text-2xl font-bold text-red-600">{finalSummary.invalid}</div>
+                  <div className="text-xs text-muted-foreground">无效</div>
+                </div>
+              </div>
+
+              <div className="border rounded-lg overflow-hidden">
+                <div className="max-h-64 overflow-auto">
+                  <table className="w-full text-sm">
+                    <thead className="bg-muted sticky top-0">
+                      <tr>
+                        <th className="text-left p-2 font-medium">#</th>
+                        <th className="text-left p-2 font-medium">指纹</th>
+                        <th className="text-left p-2 font-medium">状态</th>
+                        <th className="text-left p-2 font-medium">凭据 ID</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {finalResults.map((item) => (
+                        <tr key={item.index} className="border-t">
+                          <td className="p-2">{item.index + 1}</td>
+                          <td className="p-2 font-mono text-xs">{item.fingerprint}</td>
+                          <td className="p-2">
+                            <div className="flex items-center gap-1">
+                              {renderActionIcon(item.action)}
+                              {renderActionText(item.action)}
+                            </div>
+                          </td>
+                          <td className="p-2">
+                            {item.credentialId ? `#${item.credentialId}` : item.reason || '-'}
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Step: Verifying (验活模式) */}
+          {step === 'verifying' && (
+            <div className="space-y-4">
+              {/* 进度条 */}
+              <div className="space-y-2">
+                <div className="flex justify-between text-sm">
+                  <span>{isVerifying ? '验活进度' : '验活完成'}</span>
+                  <span>{verifyProgress.current} / {verifyProgress.total}</span>
+                </div>
+                <div className="w-full bg-secondary rounded-full h-2">
+                  <div
+                    className="bg-primary h-2 rounded-full transition-all"
+                    style={{ width: verifyProgress.total > 0 ? `${(verifyProgress.current / verifyProgress.total) * 100}%` : '0%' }}
+                  />
+                </div>
+              </div>
+
+              {/* 统计 */}
+              <div className="flex gap-4 text-sm">
+                <span className="text-green-600 dark:text-green-400">
+                  ✓ 成功: {verifyResults.filter(r => r.status === 'verified').length}
+                </span>
+                <span className="text-yellow-600 dark:text-yellow-400">
+                  ⚠ 已排除: {verifyResults.filter(r => r.status === 'rolled_back').length}
+                </span>
+                <span className="text-red-600 dark:text-red-400">
+                  ✗ 失败: {verifyResults.filter(r => r.status === 'rollback_failed').length}
+                </span>
+              </div>
+
+              {/* 结果列表 */}
+              <div className="border rounded-md divide-y max-h-[300px] overflow-y-auto">
+                {verifyResults.map((result) => (
+                  <div key={result.index} className="p-3">
+                    <div className="flex items-start gap-3">
+                      {getVerifyStatusIcon(result.status)}
+                      <div className="flex-1 min-w-0">
+                        <div className="flex items-center gap-2">
+                          <span className="text-sm font-medium">
+                            凭据 #{result.credentialId || result.index + 1}
+                          </span>
+                          <span className="text-xs text-muted-foreground">
+                            {getVerifyStatusText(result)}
+                          </span>
+                        </div>
+                        {result.usage && (
+                          <div className="text-xs text-muted-foreground mt-1">
+                            用量: {result.usage}
+                          </div>
+                        )}
+                        {result.error && (
+                          <div className="text-xs text-red-600 dark:text-red-400 mt-1">
+                            {result.error}
+                          </div>
+                        )}
+                        {result.rollbackError && (
+                          <div className="text-xs text-red-600 dark:text-red-400 mt-1">
+                            回滚失败: {result.rollbackError}
+                          </div>
+                        )}
+                      </div>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+        </div>
+
+        <DialogFooter>
+          {step === 'input' && (
+            <>
+              <Button variant="outline" onClick={handleClose}>
+                取消
+              </Button>
+              <Button onClick={handlePreview} disabled={!jsonText.trim() || isPending}>
+                {isPending ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    解析中...
+                  </>
+                ) : (
+                  '预览'
+                )}
+              </Button>
+            </>
+          )}
+
+          {step === 'preview' && (
+            <>
+              <Button variant="outline" onClick={() => setStep('input')}>
+                返回
+              </Button>
+              <Button
+                onClick={handleConfirmImport}
+                disabled={isPending || (previewSummary?.added ?? 0) === 0}
+              >
+                {isPending ? (
+                  <>
+                    <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                    导入中...
+                  </>
+                ) : enableVerify ? (
+                  `导入并验活 (${previewSummary?.added ?? 0})`
+                ) : (
+                  `确认导入 (${previewSummary?.added ?? 0})`
+                )}
+              </Button>
+            </>
+          )}
+
+          {step === 'result' && (
+            <Button onClick={handleClose}>完成</Button>
+          )}
+
+          {step === 'verifying' && (
+            <Button onClick={handleClose} disabled={isVerifying}>
+              {isVerifying ? '验活中...' : '完成'}
+            </Button>
+          )}
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/admin-ui/src/components/kam-import-dialog.tsx b/admin-ui/src/components/kam-import-dialog.tsx
new file mode 100644
index 0000000..9938a41
--- /dev/null
+++ b/admin-ui/src/components/kam-import-dialog.tsx
@@ -0,0 +1,491 @@
+import { useState, useMemo } from 'react'
+import { toast } from 'sonner'
+import { CheckCircle2, XCircle, AlertCircle, Loader2 } from 'lucide-react'
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { useCredentials, useAddCredential, useDeleteCredential } from '@/hooks/use-credentials'
+import { getCredentialBalance, setCredentialDisabled } from '@/api/credentials'
+import { extractErrorMessage, sha256Hex } from '@/lib/utils'
+
+interface KamImportDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+}
+
+// KAM 导出 JSON 中的账号结构
+interface KamAccount {
+  email?: string
+  userId?: string | null
+  nickname?: string
+  credentials: {
+    refreshToken: string
+    clientId?: string
+    clientSecret?: string
+    region?: string
+    authMethod?: string
+    startUrl?: string
+  }
+  machineId?: string
+  status?: string
+}
+
+interface VerificationResult {
+  index: number
+  status: 'pending' | 'checking' | 'verifying' | 'verified' | 'duplicate' | 'failed' | 'skipped'
+  error?: string
+  usage?: string
+  email?: string
+  credentialId?: number
+  rollbackStatus?: 'success' | 'failed' | 'skipped'
+  rollbackError?: string
+}
+
+
+
+// 校验元素是否为有效的 KAM 账号结构
+function isValidKamAccount(item: unknown): item is KamAccount {
+  if (typeof item !== 'object' || item === null) return false
+  const obj = item as Record<string, unknown>
+  if (typeof obj.credentials !== 'object' || obj.credentials === null) return false
+  const cred = obj.credentials as Record<string, unknown>
+  return typeof cred.refreshToken === 'string' && cred.refreshToken.trim().length > 0
+}
+
+// 解析 KAM 导出 JSON，支持单账号和多账号格式
+function parseKamJson(raw: string): KamAccount[] {
+  const parsed = JSON.parse(raw)
+
+  let rawItems: unknown[]
+
+  // 标准 KAM 导出格式：{ version, accounts: [...] }
+  if (parsed.accounts && Array.isArray(parsed.accounts)) {
+    rawItems = parsed.accounts
+  }
+  // 兜底：如果直接是账号数组
+  else if (Array.isArray(parsed)) {
+    rawItems = parsed
+  }
+  // 单个账号对象（有 credentials 字段）
+  else if (parsed.credentials && typeof parsed.credentials === 'object') {
+    rawItems = [parsed]
+  }
+  else {
+    throw new Error('无法识别的 KAM JSON 格式')
+  }
+
+  const validAccounts = rawItems.filter(isValidKamAccount)
+
+  if (rawItems.length > 0 && validAccounts.length === 0) {
+    throw new Error(`共 ${rawItems.length} 条记录，但均缺少有效的 credentials.refreshToken`)
+  }
+
+  if (validAccounts.length < rawItems.length) {
+    const skipped = rawItems.length - validAccounts.length
+    console.warn(`KAM 导入：跳过 ${skipped} 条缺少有效 credentials.refreshToken 的记录`)
+  }
+
+  return validAccounts
+}
+
+export function KamImportDialog({ open, onOpenChange }: KamImportDialogProps) {
+  const [jsonInput, setJsonInput] = useState('')
+  const [importing, setImporting] = useState(false)
+  const [skipErrorAccounts, setSkipErrorAccounts] = useState(true)
+  const [progress, setProgress] = useState({ current: 0, total: 0 })
+  const [currentProcessing, setCurrentProcessing] = useState<string>('')
+  const [results, setResults] = useState<VerificationResult[]>([])
+
+  const { data: existingCredentials } = useCredentials()
+  const { mutateAsync: addCredential } = useAddCredential()
+  const { mutateAsync: deleteCredential } = useDeleteCredential()
+
+  const rollbackCredential = async (id: number): Promise<{ success: boolean; error?: string }> => {
+    try {
+      await setCredentialDisabled(id, true)
+    } catch (error) {
+      return { success: false, error: `禁用失败: ${extractErrorMessage(error)}` }
+    }
+    try {
+      await deleteCredential(id)
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: `删除失败: ${extractErrorMessage(error)}` }
+    }
+  }
+
+  const resetForm = () => {
+    setJsonInput('')
+    setProgress({ current: 0, total: 0 })
+    setCurrentProcessing('')
+    setResults([])
+  }
+
+  const handleImport = async () => {
+    // 先单独解析 JSON，给出精准的错误提示
+    let validAccounts: KamAccount[]
+    try {
+      const accounts = parseKamJson(jsonInput)
+
+      if (accounts.length === 0) {
+        toast.error('没有可导入的账号')
+        return
+      }
+
+      validAccounts = accounts.filter(a => a.credentials?.refreshToken)
+      if (validAccounts.length === 0) {
+        toast.error('没有包含有效 refreshToken 的账号')
+        return
+      }
+    } catch (error) {
+      toast.error('JSON 格式错误: ' + extractErrorMessage(error))
+      return
+    }
+
+    try {
+
+      setImporting(true)
+      setProgress({ current: 0, total: validAccounts.length })
+
+      // 初始化结果，标记 error 状态的账号
+      const initialResults: VerificationResult[] = validAccounts.map((account, i) => {
+        if (skipErrorAccounts && account.status === 'error') {
+          return { index: i + 1, status: 'skipped' as const, email: account.email || account.nickname }
+        }
+        return { index: i + 1, status: 'pending' as const, email: account.email || account.nickname }
+      })
+      setResults(initialResults)
+
+      // 重复检测
+      const existingTokenHashes = new Set(
+        existingCredentials?.credentials
+          .map(c => c.refreshTokenHash)
+          .filter((hash): hash is string => Boolean(hash)) || []
+      )
+
+      let successCount = 0
+      let duplicateCount = 0
+      let failCount = 0
+      let skippedCount = 0
+
+      for (let i = 0; i < validAccounts.length; i++) {
+        const account = validAccounts[i]
+
+        // 跳过 error 状态的账号
+        if (skipErrorAccounts && account.status === 'error') {
+          skippedCount++
+          setProgress({ current: i + 1, total: validAccounts.length })
+          continue
+        }
+
+        const cred = account.credentials
+        const token = cred.refreshToken.trim()
+        const tokenHash = await sha256Hex(token)
+
+        setCurrentProcessing(`正在处理 ${account.email || account.nickname || `账号 ${i + 1}`}`)
+        setResults(prev => {
+          const next = [...prev]
+          next[i] = { ...next[i], status: 'checking' }
+          return next
+        })
+
+        // 检查重复
+        if (existingTokenHashes.has(tokenHash)) {
+          duplicateCount++
+          const existingCred = existingCredentials?.credentials.find(c => c.refreshTokenHash === tokenHash)
+          setResults(prev => {
+            const next = [...prev]
+            next[i] = { ...next[i], status: 'duplicate', error: '该凭据已存在', email: existingCred?.email || account.email }
+            return next
+          })
+          setProgress({ current: i + 1, total: validAccounts.length })
+          continue
+        }
+
+        // 验活中
+        setResults(prev => {
+          const next = [...prev]
+          next[i] = { ...next[i], status: 'verifying' }
+          return next
+        })
+
+        let addedCredId: number | null = null
+
+        try {
+          const clientId = cred.clientId?.trim() || undefined
+          const clientSecret = cred.clientSecret?.trim() || undefined
+          const authMethod = clientId && clientSecret ? 'idc' : 'social'
+
+          // idc 模式下必须同时提供 clientId 和 clientSecret
+          if (authMethod === 'social' && (clientId || clientSecret)) {
+            throw new Error('idc 模式需要同时提供 clientId 和 clientSecret')
+          }
+
+          const addedCred = await addCredential({
+            refreshToken: token,
+            authMethod,
+            authRegion: cred.region?.trim() || undefined,
+            clientId,
+            clientSecret,
+            machineId: account.machineId?.trim() || undefined,
+          })
+
+          addedCredId = addedCred.credentialId
+
+          await new Promise(resolve => setTimeout(resolve, 1000))
+
+          const balance = await getCredentialBalance(addedCred.credentialId)
+
+          successCount++
+          existingTokenHashes.add(tokenHash)
+          setCurrentProcessing(`验活成功: ${addedCred.email || account.email || `账号 ${i + 1}`}`)
+          setResults(prev => {
+            const next = [...prev]
+            next[i] = {
+              ...next[i],
+              status: 'verified',
+              usage: `${balance.currentUsage}/${balance.usageLimit}`,
+              email: addedCred.email || account.email,
+              credentialId: addedCred.credentialId,
+            }
+            return next
+          })
+        } catch (error) {
+          let rollbackStatus: VerificationResult['rollbackStatus'] = 'skipped'
+          let rollbackError: string | undefined
+
+          if (addedCredId) {
+            const result = await rollbackCredential(addedCredId)
+            if (result.success) {
+              rollbackStatus = 'success'
+            } else {
+              rollbackStatus = 'failed'
+              rollbackError = result.error
+            }
+          }
+
+          failCount++
+          setResults(prev => {
+            const next = [...prev]
+            next[i] = {
+              ...next[i],
+              status: 'failed',
+              error: extractErrorMessage(error),
+              rollbackStatus,
+              rollbackError,
+            }
+            return next
+          })
+        }
+
+        setProgress({ current: i + 1, total: validAccounts.length })
+      }
+
+      // 汇总
+      const parts: string[] = []
+      if (successCount > 0) parts.push(`成功 ${successCount}`)
+      if (duplicateCount > 0) parts.push(`重复 ${duplicateCount}`)
+      if (failCount > 0) parts.push(`失败 ${failCount}`)
+      if (skippedCount > 0) parts.push(`跳过 ${skippedCount}`)
+
+      if (failCount === 0 && duplicateCount === 0 && skippedCount === 0) {
+        toast.success(`成功导入并验活 ${successCount} 个凭据`)
+      } else {
+        toast.info(`导入完成：${parts.join('，')}`)
+      }
+    } catch (error) {
+      toast.error('导入失败: ' + extractErrorMessage(error))
+    } finally {
+      setImporting(false)
+    }
+  }
+
+  const getStatusIcon = (status: VerificationResult['status']) => {
+    switch (status) {
+      case 'pending':
+        return <div className="w-5 h-5 rounded-full border-2 border-gray-300" />
+      case 'checking':
+      case 'verifying':
+        return <Loader2 className="w-5 h-5 animate-spin text-blue-500" />
+      case 'verified':
+        return <CheckCircle2 className="w-5 h-5 text-green-500" />
+      case 'duplicate':
+        return <AlertCircle className="w-5 h-5 text-yellow-500" />
+      case 'skipped':
+        return <AlertCircle className="w-5 h-5 text-gray-400" />
+      case 'failed':
+        return <XCircle className="w-5 h-5 text-red-500" />
+    }
+  }
+
+  const getStatusText = (result: VerificationResult) => {
+    switch (result.status) {
+      case 'pending': return '等待中'
+      case 'checking': return '检查重复...'
+      case 'verifying': return '验活中...'
+      case 'verified': return '验活成功'
+      case 'duplicate': return '重复凭据'
+      case 'skipped': return '已跳过（error 状态）'
+      case 'failed':
+        if (result.rollbackStatus === 'success') return '验活失败（已排除）'
+        if (result.rollbackStatus === 'failed') return '验活失败（未排除）'
+        return '验活失败（未创建）'
+    }
+  }
+
+  // 预览解析结果
+  const { previewAccounts, parseError } = useMemo(() => {
+    if (!jsonInput.trim()) return { previewAccounts: [] as KamAccount[], parseError: '' }
+    try {
+      return { previewAccounts: parseKamJson(jsonInput), parseError: '' }
+    } catch (e) {
+      return { previewAccounts: [] as KamAccount[], parseError: extractErrorMessage(e) }
+    }
+  }, [jsonInput])
+
+  const errorAccountCount = previewAccounts.filter(a => a.status === 'error').length
+
+  return (
+    <Dialog
+      open={open}
+      onOpenChange={(newOpen) => {
+        if (!newOpen && importing) return
+        if (!newOpen) resetForm()
+        onOpenChange(newOpen)
+      }}
+    >
+      <DialogContent className="sm:max-w-2xl max-h-[80vh] flex flex-col">
+        <DialogHeader>
+          <DialogTitle>KAM 账号导入（自动验活）</DialogTitle>
+        </DialogHeader>
+
+        <div className="flex-1 overflow-y-auto space-y-4 py-4">
+          <div className="space-y-2">
+            <label className="text-sm font-medium">KAM 导出 JSON</label>
+            <textarea
+              placeholder={'粘贴 Kiro Account Manager 导出的 JSON，格式如下：\n{\n  "version": "1.5.0",\n  "accounts": [\n    {\n      "email": "...",\n      "credentials": {\n        "refreshToken": "...",\n        "clientId": "...",\n        "clientSecret": "...",\n        "region": "us-east-1"\n      }\n    }\n  ]\n}'}
+              value={jsonInput}
+              onChange={(e) => setJsonInput(e.target.value)}
+              disabled={importing}
+              className="flex min-h-[200px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 font-mono"
+            />
+          </div>
+
+          {/* 解析预览 */}
+          {parseError && (
+            <div className="text-sm text-red-600 dark:text-red-400">解析失败: {parseError}</div>
+          )}
+          {previewAccounts.length > 0 && !importing && results.length === 0 && (
+            <div className="space-y-2">
+              <div className="text-sm text-muted-foreground">
+                识别到 {previewAccounts.length} 个账号
+                {errorAccountCount > 0 && `（其中 ${errorAccountCount} 个为 error 状态）`}
+              </div>
+              {errorAccountCount > 0 && (
+                <label className="flex items-center gap-2 text-sm">
+                  <input
+                    type="checkbox"
+                    checked={skipErrorAccounts}
+                    onChange={(e) => setSkipErrorAccounts(e.target.checked)}
+                    className="rounded border-gray-300"
+                  />
+                  跳过 error 状态的账号
+                </label>
+              )}
+            </div>
+          )}
+
+          {/* 导入进度和结果 */}
+          {(importing || results.length > 0) && (
+            <>
+              <div className="space-y-2">
+                <div className="flex justify-between text-sm">
+                  <span>{importing ? '导入进度' : '导入完成'}</span>
+                  <span>{progress.current} / {progress.total}</span>
+                </div>
+                <div className="w-full bg-secondary rounded-full h-2">
+                  <div
+                    className="bg-primary h-2 rounded-full transition-all"
+                    style={{ width: `${progress.total > 0 ? (progress.current / progress.total) * 100 : 0}%` }}
+                  />
+                </div>
+                {importing && currentProcessing && (
+                  <div className="text-xs text-muted-foreground">{currentProcessing}</div>
+                )}
+              </div>
+
+              <div className="flex gap-4 text-sm">
+                <span className="text-green-600 dark:text-green-400">
+                  ✓ 成功: {results.filter(r => r.status === 'verified').length}
+                </span>
+                <span className="text-yellow-600 dark:text-yellow-400">
+                  ⚠ 重复: {results.filter(r => r.status === 'duplicate').length}
+                </span>
+                <span className="text-red-600 dark:text-red-400">
+                  ✗ 失败: {results.filter(r => r.status === 'failed').length}
+                </span>
+                <span className="text-gray-500">
+                  ○ 跳过: {results.filter(r => r.status === 'skipped').length}
+                </span>
+              </div>
+
+              <div className="border rounded-md divide-y max-h-[300px] overflow-y-auto">
+                {results.map((result) => (
+                  <div key={result.index} className="p-3">
+                    <div className="flex items-start gap-3">
+                      {getStatusIcon(result.status)}
+                      <div className="flex-1 min-w-0">
+                        <div className="flex items-center gap-2">
+                          <span className="text-sm font-medium">
+                            {result.email || `账号 #${result.index}`}
+                          </span>
+                          <span className="text-xs text-muted-foreground">
+                            {getStatusText(result)}
+                          </span>
+                        </div>
+                        {result.usage && (
+                          <div className="text-xs text-muted-foreground mt-1">用量: {result.usage}</div>
+                        )}
+                        {result.error && (
+                          <div className="text-xs text-red-600 dark:text-red-400 mt-1">{result.error}</div>
+                        )}
+                        {result.rollbackError && (
+                          <div className="text-xs text-red-600 dark:text-red-400 mt-1">回滚失败: {result.rollbackError}</div>
+                        )}
+                      </div>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </>
+          )}
+        </div>
+
+        <DialogFooter>
+          <Button
+            type="button"
+            variant="outline"
+            onClick={() => { onOpenChange(false); resetForm() }}
+            disabled={importing}
+          >
+            {importing ? '导入中...' : results.length > 0 ? '关闭' : '取消'}
+          </Button>
+          {results.length === 0 && (
+            <Button
+              type="button"
+              onClick={handleImport}
+              disabled={importing || !jsonInput.trim() || previewAccounts.length === 0 || !!parseError}
+            >
+              开始导入并验活
+            </Button>
+          )}
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/admin-ui/src/components/login-page.tsx b/admin-ui/src/components/login-page.tsx
new file mode 100644
index 0000000..c89f65c
--- /dev/null
+++ b/admin-ui/src/components/login-page.tsx
@@ -0,0 +1,62 @@
+import { useState, useEffect } from 'react'
+import { KeyRound } from 'lucide-react'
+import { storage } from '@/lib/storage'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Input } from '@/components/ui/input'
+import { Button } from '@/components/ui/button'
+
+interface LoginPageProps {
+  onLogin: (apiKey: string) => void
+}
+
+export function LoginPage({ onLogin }: LoginPageProps) {
+  const [apiKey, setApiKey] = useState('')
+
+  useEffect(() => {
+    // 从 storage 读取保存的 API Key
+    const savedKey = storage.getApiKey()
+    if (savedKey) {
+      setApiKey(savedKey)
+    }
+  }, [])
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault()
+    if (apiKey.trim()) {
+      storage.setApiKey(apiKey.trim())
+      onLogin(apiKey.trim())
+    }
+  }
+
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-background p-4">
+      <Card className="w-full max-w-md">
+        <CardHeader className="text-center">
+          <div className="mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-full bg-primary/10">
+            <KeyRound className="h-6 w-6 text-primary" />
+          </div>
+          <CardTitle className="text-2xl">Kiro Admin</CardTitle>
+          <CardDescription>
+            请输入 Admin API Key 以访问管理面板
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <form onSubmit={handleSubmit} className="space-y-4">
+            <div className="space-y-2">
+              <Input
+                type="password"
+                placeholder="Admin API Key"
+                value={apiKey}
+                onChange={(e) => setApiKey(e.target.value)}
+                className="text-center"
+              />
+            </div>
+            <Button type="submit" className="w-full" disabled={!apiKey.trim()}>
+              登录
+            </Button>
+          </form>
+        </CardContent>
+      </Card>
+    </div>
+  )
+}
diff --git a/admin-ui/src/components/ui/badge.tsx b/admin-ui/src/components/ui/badge.tsx
new file mode 100644
index 0000000..baa444c
--- /dev/null
+++ b/admin-ui/src/components/ui/badge.tsx
@@ -0,0 +1,39 @@
+import * as React from 'react'
+import { cva, type VariantProps } from 'class-variance-authority'
+import { cn } from '@/lib/utils'
+
+const badgeVariants = cva(
+  'inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2',
+  {
+    variants: {
+      variant: {
+        default:
+          'border-transparent bg-primary text-primary-foreground hover:bg-primary/80',
+        secondary:
+          'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',
+        destructive:
+          'border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80',
+        outline: 'text-foreground',
+        success:
+          'border-transparent bg-green-500 text-white hover:bg-green-500/80',
+        warning:
+          'border-transparent bg-yellow-500 text-white hover:bg-yellow-500/80',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  }
+)
+
+export interface BadgeProps
+  extends React.HTMLAttributes<HTMLDivElement>,
+    VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, ...props }: BadgeProps) {
+  return (
+    <div className={cn(badgeVariants({ variant }), className)} {...props} />
+  )
+}
+
+export { Badge, badgeVariants }
diff --git a/admin-ui/src/components/ui/button.tsx b/admin-ui/src/components/ui/button.tsx
new file mode 100644
index 0000000..640e0f6
--- /dev/null
+++ b/admin-ui/src/components/ui/button.tsx
@@ -0,0 +1,55 @@
+import * as React from 'react'
+import { Slot } from '@radix-ui/react-slot'
+import { cva, type VariantProps } from 'class-variance-authority'
+import { cn } from '@/lib/utils'
+
+const buttonVariants = cva(
+  'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0',
+  {
+    variants: {
+      variant: {
+        default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+        destructive:
+          'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+        outline:
+          'border border-input bg-background hover:bg-accent hover:text-accent-foreground',
+        secondary:
+          'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+        ghost: 'hover:bg-accent hover:text-accent-foreground',
+        link: 'text-primary underline-offset-4 hover:underline',
+      },
+      size: {
+        default: 'h-10 px-4 py-2',
+        sm: 'h-9 rounded-md px-3',
+        lg: 'h-11 rounded-md px-8',
+        icon: 'h-10 w-10',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default',
+    },
+  }
+)
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : 'button'
+    return (
+      <Comp
+        className={cn(buttonVariants({ variant, size, className }))}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+Button.displayName = 'Button'
+
+export { Button, buttonVariants }
diff --git a/admin-ui/src/components/ui/card.tsx b/admin-ui/src/components/ui/card.tsx
new file mode 100644
index 0000000..18e786a
--- /dev/null
+++ b/admin-ui/src/components/ui/card.tsx
@@ -0,0 +1,78 @@
+import * as React from 'react'
+import { cn } from '@/lib/utils'
+
+const Card = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn(
+      'rounded-lg border bg-card text-card-foreground shadow-sm',
+      className
+    )}
+    {...props}
+  />
+))
+Card.displayName = 'Card'
+
+const CardHeader = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn('flex flex-col space-y-1.5 p-6', className)}
+    {...props}
+  />
+))
+CardHeader.displayName = 'CardHeader'
+
+const CardTitle = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
+>(({ className, ...props }, ref) => (
+  <h3
+    ref={ref}
+    className={cn(
+      'text-2xl font-semibold leading-none tracking-tight',
+      className
+    )}
+    {...props}
+  />
+))
+CardTitle.displayName = 'CardTitle'
+
+const CardDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => (
+  <p
+    ref={ref}
+    className={cn('text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+CardDescription.displayName = 'CardDescription'
+
+const CardContent = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div ref={ref} className={cn('p-6 pt-0', className)} {...props} />
+))
+CardContent.displayName = 'CardContent'
+
+const CardFooter = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn('flex items-center p-6 pt-0', className)}
+    {...props}
+  />
+))
+CardFooter.displayName = 'CardFooter'
+
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }
diff --git a/admin-ui/src/components/ui/checkbox.tsx b/admin-ui/src/components/ui/checkbox.tsx
new file mode 100644
index 0000000..ddbdd01
--- /dev/null
+++ b/admin-ui/src/components/ui/checkbox.tsx
@@ -0,0 +1,28 @@
+import * as React from "react"
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox"
+import { Check } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+const Checkbox = React.forwardRef<
+  React.ElementRef<typeof CheckboxPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>
+>(({ className, ...props }, ref) => (
+  <CheckboxPrimitive.Root
+    ref={ref}
+    className={cn(
+      "peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
+      className
+    )}
+    {...props}
+  >
+    <CheckboxPrimitive.Indicator
+      className={cn("flex items-center justify-center text-current")}
+    >
+      <Check className="h-4 w-4" />
+    </CheckboxPrimitive.Indicator>
+  </CheckboxPrimitive.Root>
+))
+Checkbox.displayName = CheckboxPrimitive.Root.displayName
+
+export { Checkbox }
diff --git a/admin-ui/src/components/ui/dialog.tsx b/admin-ui/src/components/ui/dialog.tsx
new file mode 100644
index 0000000..ba67aa8
--- /dev/null
+++ b/admin-ui/src/components/ui/dialog.tsx
@@ -0,0 +1,119 @@
+import * as React from 'react'
+import * as DialogPrimitive from '@radix-ui/react-dialog'
+import { X } from 'lucide-react'
+import { cn } from '@/lib/utils'
+
+const Dialog = DialogPrimitive.Root
+
+const DialogTrigger = DialogPrimitive.Trigger
+
+const DialogPortal = DialogPrimitive.Portal
+
+const DialogClose = DialogPrimitive.Close
+
+const DialogOverlay = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Overlay>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Overlay
+    ref={ref}
+    className={cn(
+      'fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+      className
+    )}
+    {...props}
+  />
+))
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName
+
+const DialogContent = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>
+>(({ className, children, ...props }, ref) => (
+  <DialogPortal>
+    <DialogOverlay />
+    <DialogPrimitive.Content
+      ref={ref}
+      className={cn(
+        'fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg',
+        className
+      )}
+      {...props}
+    >
+      {children}
+      <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
+        <X className="h-4 w-4" />
+        <span className="sr-only">关闭</span>
+      </DialogPrimitive.Close>
+    </DialogPrimitive.Content>
+  </DialogPortal>
+))
+DialogContent.displayName = DialogPrimitive.Content.displayName
+
+const DialogHeader = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col space-y-1.5 text-center sm:text-left',
+      className
+    )}
+    {...props}
+  />
+)
+DialogHeader.displayName = 'DialogHeader'
+
+const DialogFooter = ({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      'flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2',
+      className
+    )}
+    {...props}
+  />
+)
+DialogFooter.displayName = 'DialogFooter'
+
+const DialogTitle = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Title>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Title
+    ref={ref}
+    className={cn(
+      'text-lg font-semibold leading-none tracking-tight',
+      className
+    )}
+    {...props}
+  />
+))
+DialogTitle.displayName = DialogPrimitive.Title.displayName
+
+const DialogDescription = React.forwardRef<
+  React.ElementRef<typeof DialogPrimitive.Description>,
+  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
+>(({ className, ...props }, ref) => (
+  <DialogPrimitive.Description
+    ref={ref}
+    className={cn('text-sm text-muted-foreground', className)}
+    {...props}
+  />
+))
+DialogDescription.displayName = DialogPrimitive.Description.displayName
+
+export {
+  Dialog,
+  DialogPortal,
+  DialogOverlay,
+  DialogClose,
+  DialogTrigger,
+  DialogContent,
+  DialogHeader,
+  DialogFooter,
+  DialogTitle,
+  DialogDescription,
+}
diff --git a/admin-ui/src/components/ui/input.tsx b/admin-ui/src/components/ui/input.tsx
new file mode 100644
index 0000000..d32ad81
--- /dev/null
+++ b/admin-ui/src/components/ui/input.tsx
@@ -0,0 +1,24 @@
+import * as React from 'react'
+import { cn } from '@/lib/utils'
+
+export interface InputProps
+  extends React.InputHTMLAttributes<HTMLInputElement> {}
+
+const Input = React.forwardRef<HTMLInputElement, InputProps>(
+  ({ className, type, ...props }, ref) => {
+    return (
+      <input
+        type={type}
+        className={cn(
+          'flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50',
+          className
+        )}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+Input.displayName = 'Input'
+
+export { Input }
diff --git a/admin-ui/src/components/ui/progress.tsx b/admin-ui/src/components/ui/progress.tsx
new file mode 100644
index 0000000..b400823
--- /dev/null
+++ b/admin-ui/src/components/ui/progress.tsx
@@ -0,0 +1,35 @@
+import * as React from 'react'
+import { cn } from '@/lib/utils'
+
+interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+  value?: number
+  max?: number
+}
+
+const Progress = React.forwardRef<HTMLDivElement, ProgressProps>(
+  ({ className, value = 0, max = 100, ...props }, ref) => {
+    const percentage = Math.min(Math.max((value / max) * 100, 0), 100)
+
+    return (
+      <div
+        ref={ref}
+        className={cn(
+          'relative h-4 w-full overflow-hidden rounded-full bg-secondary',
+          className
+        )}
+        {...props}
+      >
+        <div
+          className={cn(
+            'h-full transition-all',
+            percentage > 80 ? 'bg-red-500' : percentage > 60 ? 'bg-yellow-500' : 'bg-green-500'
+          )}
+          style={{ width: `${percentage}%` }}
+        />
+      </div>
+    )
+  }
+)
+Progress.displayName = 'Progress'
+
+export { Progress }
diff --git a/admin-ui/src/components/ui/sonner.tsx b/admin-ui/src/components/ui/sonner.tsx
new file mode 100644
index 0000000..f5d591c
--- /dev/null
+++ b/admin-ui/src/components/ui/sonner.tsx
@@ -0,0 +1,25 @@
+import { Toaster as Sonner } from 'sonner'
+
+type ToasterProps = React.ComponentProps<typeof Sonner>
+
+const Toaster = ({ ...props }: ToasterProps) => {
+  return (
+    <Sonner
+      className="toaster group"
+      toastOptions={{
+        classNames: {
+          toast:
+            'group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg',
+          description: 'group-[.toast]:text-muted-foreground',
+          actionButton:
+            'group-[.toast]:bg-primary group-[.toast]:text-primary-foreground',
+          cancelButton:
+            'group-[.toast]:bg-muted group-[.toast]:text-muted-foreground',
+        },
+      }}
+      {...props}
+    />
+  )
+}
+
+export { Toaster }
diff --git a/admin-ui/src/components/ui/switch.tsx b/admin-ui/src/components/ui/switch.tsx
new file mode 100644
index 0000000..f2d6513
--- /dev/null
+++ b/admin-ui/src/components/ui/switch.tsx
@@ -0,0 +1,26 @@
+import * as React from 'react'
+import * as SwitchPrimitives from '@radix-ui/react-switch'
+import { cn } from '@/lib/utils'
+
+const Switch = React.forwardRef<
+  React.ElementRef<typeof SwitchPrimitives.Root>,
+  React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>
+>(({ className, ...props }, ref) => (
+  <SwitchPrimitives.Root
+    className={cn(
+      'peer inline-flex h-6 w-11 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input',
+      className
+    )}
+    {...props}
+    ref={ref}
+  >
+    <SwitchPrimitives.Thumb
+      className={cn(
+        'pointer-events-none block h-5 w-5 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-5 data-[state=unchecked]:translate-x-0'
+      )}
+    />
+  </SwitchPrimitives.Root>
+))
+Switch.displayName = SwitchPrimitives.Root.displayName
+
+export { Switch }
diff --git a/admin-ui/src/hooks/use-credentials.ts b/admin-ui/src/hooks/use-credentials.ts
new file mode 100644
index 0000000..974a824
--- /dev/null
+++ b/admin-ui/src/hooks/use-credentials.ts
@@ -0,0 +1,175 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import {
+  getCredentials,
+  deleteCredential,
+  setCredentialDisabled,
+  setCredentialPriority,
+  setCredentialRegion,
+  resetCredentialFailure,
+  getCredentialBalance,
+  getCachedBalances,
+  getCredentialAccountInfo,
+  addCredential,
+  getCredentialStats,
+  resetCredentialStats,
+  resetAllStats,
+  importTokenJson,
+} from '@/api/credentials'
+import type { AddCredentialRequest, ImportTokenJsonRequest } from '@/types/api'
+
+// 查询凭据列表
+export function useCredentials() {
+  return useQuery({
+    queryKey: ['credentials'],
+    queryFn: getCredentials,
+    refetchInterval: 30000, // 每 30 秒刷新一次
+  })
+}
+
+// 查询凭据余额
+export function useCredentialBalance(id: number | null) {
+  return useQuery({
+    queryKey: ['credential-balance', id],
+    queryFn: () => getCredentialBalance(id!),
+    enabled: id !== null,
+    retry: false, // 余额查询失败时不重试（避免重复请求被封禁的账号）
+  })
+}
+
+// 查询所有凭据的缓存余额（定时轮询，带退避策略）
+export function useCachedBalances() {
+  return useQuery({
+    queryKey: ['cached-balances'],
+    queryFn: getCachedBalances,
+    refetchInterval: (query) => (query.state.error ? 60000 : 30000),
+    refetchIntervalInBackground: false, // 页面不可见时暂停轮询
+  })
+}
+
+// 查询凭据账号信息（套餐/用量/邮箱等）
+export function useCredentialAccountInfo(id: number | null, enabled: boolean) {
+  return useQuery({
+    queryKey: ['credential-account', id],
+    queryFn: () => getCredentialAccountInfo(id!),
+    enabled: enabled && id !== null,
+    retry: false,
+  })
+}
+
+// 删除指定凭据
+export function useDeleteCredential() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: number) => deleteCredential(id),
+    onSuccess: (_res, id) => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+      queryClient.invalidateQueries({ queryKey: ['credential-balance', id] })
+      queryClient.invalidateQueries({ queryKey: ['credential-account', id] })
+      queryClient.invalidateQueries({ queryKey: ['credential-stats', id] })
+    },
+  })
+}
+
+// 设置禁用状态
+export function useSetDisabled() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, disabled }: { id: number; disabled: boolean }) =>
+      setCredentialDisabled(id, disabled),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+    },
+  })
+}
+
+// 设置优先级
+export function useSetPriority() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, priority }: { id: number; priority: number }) =>
+      setCredentialPriority(id, priority),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+    },
+  })
+}
+
+// 设置 Region
+export function useSetRegion() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, region, apiRegion }: { id: number; region: string | null; apiRegion: string | null }) =>
+      setCredentialRegion(id, region, apiRegion),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+    },
+  })
+}
+
+// 重置失败计数
+export function useResetFailure() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: number) => resetCredentialFailure(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+    },
+  })
+}
+
+// 添加新凭据
+export function useAddCredential() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (req: AddCredentialRequest) => addCredential(req),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+    },
+  })
+}
+
+// 查询指定凭据统计
+export function useCredentialStats(id: number | null, enabled: boolean) {
+  return useQuery({
+    queryKey: ['credential-stats', id],
+    queryFn: () => getCredentialStats(id!),
+    enabled: enabled && id !== null,
+    retry: false,
+  })
+}
+
+// 清空指定凭据统计
+export function useResetCredentialStats() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: number) => resetCredentialStats(id),
+    onSuccess: (_res, id) => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+      queryClient.invalidateQueries({ queryKey: ['credential-stats', id] })
+    },
+  })
+}
+
+// 清空全部统计
+export function useResetAllStats() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: () => resetAllStats(),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+      queryClient.invalidateQueries({ queryKey: ['credential-stats'] })
+    },
+  })
+}
+
+// 批量导入 token.json
+export function useImportTokenJson() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (req: ImportTokenJsonRequest) => importTokenJson(req),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] })
+      queryClient.invalidateQueries({ queryKey: ['cached-balances'] })
+    },
+  })
+}
diff --git a/admin-ui/src/index.css b/admin-ui/src/index.css
new file mode 100644
index 0000000..ed406e2
--- /dev/null
+++ b/admin-ui/src/index.css
@@ -0,0 +1,90 @@
+@import "tailwindcss";
+
+/* 自定义主题配置 */
+@theme {
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-ring: hsl(var(--ring));
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+
+  --color-accent: hsl(var(--accent));
+  --color-accent-foreground: hsl(var(--accent-foreground));
+
+  --color-popover: hsl(var(--popover));
+  --color-popover-foreground: hsl(var(--popover-foreground));
+
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+
+  --radius-lg: var(--radius);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-sm: calc(var(--radius) - 4px);
+}
+
+:root {
+  --background: 0 0% 100%;
+  --foreground: 222.2 84% 4.9%;
+  --card: 0 0% 100%;
+  --card-foreground: 222.2 84% 4.9%;
+  --popover: 0 0% 100%;
+  --popover-foreground: 222.2 84% 4.9%;
+  --primary: 222.2 47.4% 11.2%;
+  --primary-foreground: 210 40% 98%;
+  --secondary: 210 40% 96.1%;
+  --secondary-foreground: 222.2 47.4% 11.2%;
+  --muted: 210 40% 96.1%;
+  --muted-foreground: 215.4 16.3% 46.9%;
+  --accent: 210 40% 96.1%;
+  --accent-foreground: 222.2 47.4% 11.2%;
+  --destructive: 0 84.2% 60.2%;
+  --destructive-foreground: 210 40% 98%;
+  --border: 214.3 31.8% 91.4%;
+  --input: 214.3 31.8% 91.4%;
+  --ring: 222.2 84% 4.9%;
+  --radius: 0.5rem;
+}
+
+.dark {
+  --background: 222.2 84% 4.9%;
+  --foreground: 210 40% 98%;
+  --card: 222.2 84% 4.9%;
+  --card-foreground: 210 40% 98%;
+  --popover: 222.2 84% 4.9%;
+  --popover-foreground: 210 40% 98%;
+  --primary: 210 40% 98%;
+  --primary-foreground: 222.2 47.4% 11.2%;
+  --secondary: 217.2 32.6% 17.5%;
+  --secondary-foreground: 210 40% 98%;
+  --muted: 217.2 32.6% 17.5%;
+  --muted-foreground: 215 20.2% 65.1%;
+  --accent: 217.2 32.6% 17.5%;
+  --accent-foreground: 210 40% 98%;
+  --destructive: 0 62.8% 30.6%;
+  --destructive-foreground: 210 40% 98%;
+  --border: 217.2 32.6% 17.5%;
+  --input: 217.2 32.6% 17.5%;
+  --ring: 212.7 26.8% 83.9%;
+}
+
+* {
+  border-color: hsl(var(--border));
+}
+
+body {
+  background-color: hsl(var(--background));
+  color: hsl(var(--foreground));
+  font-feature-settings: "rlig" 1, "calt" 1;
+}
diff --git a/admin-ui/src/lib/format.ts b/admin-ui/src/lib/format.ts
new file mode 100644
index 0000000..5333eb2
--- /dev/null
+++ b/admin-ui/src/lib/format.ts
@@ -0,0 +1,44 @@
+export function formatCompactNumber(value: number | null | undefined): string {
+  if (value === null || value === undefined) return '-'
+  if (!Number.isFinite(value)) return String(value)
+
+  const abs = Math.abs(value)
+  const sign = value < 0 ? '-' : ''
+
+  const formatScaled = (scale: number, suffix: string) => {
+    const scaled = abs / scale
+    const decimals = scaled < 10 ? 1 : 0
+    const fixed = scaled.toFixed(decimals)
+    const trimmed = fixed.endsWith('.0') ? fixed.slice(0, -2) : fixed
+    return `${sign}${trimmed}${suffix}`
+  }
+
+  if (abs >= 1_000_000_000) return formatScaled(1_000_000_000, 'B')
+  if (abs >= 1_000_000) return formatScaled(1_000_000, 'M')
+  if (abs >= 1_000) return formatScaled(1_000, 'K')
+
+  // 小于 1000：按整数显示
+  return `${sign}${Math.round(abs)}`
+}
+
+export function formatTokensPair(inputTokens: number, outputTokens: number): string {
+  return `${formatCompactNumber(inputTokens)} in / ${formatCompactNumber(outputTokens)} out`
+}
+
+export function formatExpiry(expiresAt: string | null): string {
+  if (!expiresAt) return '未知'
+  const date = new Date(expiresAt)
+  if (isNaN(date.getTime())) return expiresAt
+
+  const now = new Date()
+  const diff = date.getTime() - now.getTime()
+  if (diff < 0) return '已过期'
+
+  const minutes = Math.floor(diff / 60000)
+  if (minutes < 60) return `${minutes} 分钟`
+
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours} 小时`
+
+  return `${Math.floor(hours / 24)} 天`
+}
diff --git a/admin-ui/src/lib/storage.ts b/admin-ui/src/lib/storage.ts
new file mode 100644
index 0000000..b61b741
--- /dev/null
+++ b/admin-ui/src/lib/storage.ts
@@ -0,0 +1,7 @@
+const API_KEY_STORAGE_KEY = 'adminApiKey'
+
+export const storage = {
+  getApiKey: () => localStorage.getItem(API_KEY_STORAGE_KEY),
+  setApiKey: (key: string) => localStorage.setItem(API_KEY_STORAGE_KEY, key),
+  removeApiKey: () => localStorage.removeItem(API_KEY_STORAGE_KEY),
+}
diff --git a/admin-ui/src/lib/utils.ts b/admin-ui/src/lib/utils.ts
new file mode 100644
index 0000000..ae9af50
--- /dev/null
+++ b/admin-ui/src/lib/utils.ts
@@ -0,0 +1,202 @@
+import { clsx, type ClassValue } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+/**
+ * 解析后端错误响应，提取用户友好的错误信息
+ */
+export interface ParsedError {
+  /** 简短的错误标题 */
+  title: string
+  /** 详细的错误描述 */
+  detail?: string
+  /** 错误类型 */
+  type?: string
+}
+
+/**
+ * 从错误对象中提取错误消息
+ * 支持 Axios 错误和普通 Error 对象
+ */
+export function extractErrorMessage(error: unknown): string {
+  const parsed = parseError(error)
+  return parsed.title
+}
+
+/**
+ * 解析错误，返回结构化的错误信息
+ */
+export function parseError(error: unknown): ParsedError {
+  if (!error || typeof error !== 'object') {
+    return { title: '未知错误' }
+  }
+
+  const axiosError = error as Record<string, unknown>
+  const response = axiosError.response as Record<string, unknown> | undefined
+  const data = response?.data as Record<string, unknown> | undefined
+  const errorObj = data?.error as Record<string, unknown> | undefined
+
+  // 尝试从后端错误响应中提取信息
+  if (errorObj && typeof errorObj.message === 'string') {
+    const message = errorObj.message
+    const type = typeof errorObj.type === 'string' ? errorObj.type : undefined
+
+    // 解析嵌套的错误信息（如：上游服务错误: 权限不足: 403 {...}）
+    const parsed = parseNestedErrorMessage(message)
+
+    return {
+      title: parsed.title,
+      detail: parsed.detail,
+      type,
+    }
+  }
+
+  // 回退到 Error.message
+  if ('message' in axiosError && typeof axiosError.message === 'string') {
+    return { title: axiosError.message }
+  }
+
+  return { title: '未知错误' }
+}
+
+/**
+ * 解析嵌套的错误消息
+ * 例如："上游服务错误: 权限不足，无法获取使用额度: 403 Forbidden {...}"
+ */
+function parseNestedErrorMessage(message: string): { title: string; detail?: string } {
+  // 尝试提取 HTTP 状态码（如 403、502 等）
+  const statusMatch = message.match(/(\d{3})\s+\w+/)
+  const statusCode = statusMatch ? statusMatch[1] : null
+
+  // 尝试提取 JSON 中的 message 字段
+  const jsonMatch = message.match(/\{[^{}]*"message"\s*:\s*"([^"]+)"[^{}]*\}/)
+  if (jsonMatch) {
+    const innerMessage = jsonMatch[1]
+    // 提取主要错误原因（去掉前缀）
+    const parts = message.split(':').map(s => s.trim())
+    const mainReason = parts.length > 1 ? parts[1].split(':')[0] : parts[0]
+
+    // 在 title 中包含状态码
+    const title = statusCode
+      ? `${mainReason || '服务错误'} (${statusCode})`
+      : (mainReason || '服务错误')
+
+    return {
+      title,
+      detail: innerMessage,
+    }
+  }
+
+  // 尝试按冒号分割，提取主要信息
+  const colonParts = message.split(':')
+  if (colonParts.length >= 2) {
+    const mainPart = colonParts[1].trim().split(':')[0].trim()
+    const title = statusCode ? `${mainPart} (${statusCode})` : mainPart
+
+    return {
+      title,
+      detail: colonParts.slice(2).join(':').trim() || undefined,
+    }
+  }
+
+  return { title: message }
+}
+
+
+
+
+/**
+ * 计算字符串的 SHA-256 哈希（十六进制）
+ *
+ * 优先使用 Web Crypto API（crypto.subtle），在非安全上下文（HTTP + 非 localhost）中
+ * 自动回退到纯 JS 实现，解决 Docker 部署时 crypto.subtle 不可用的问题。
+ */
+export async function sha256Hex(value: string): Promise<string> {
+  const encoded = new TextEncoder().encode(value)
+
+  // 安全上下文中使用原生 Web Crypto API（性能更好）
+  if (typeof crypto !== 'undefined' && crypto.subtle) {
+    try {
+      const digest = await crypto.subtle.digest('SHA-256', encoded)
+      const bytes = new Uint8Array(digest)
+      return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('')
+    } catch {
+      // digest 可能在某些策略/上下文下抛错，回退到纯 JS 实现
+    }
+  }
+
+  // 非安全上下文 fallback：纯 JS SHA-256 实现
+  return sha256Pure(encoded)
+}
+
+/**
+ * 纯 JS SHA-256 实现（无外部依赖）
+ * 仅在 crypto.subtle 不可用时使用
+ */
+function sha256Pure(data: Uint8Array): string {
+  // SHA-256 常量：前 64 个素数的立方根的小数部分
+  const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+  ])
+
+  const rotr = (x: number, n: number) => (x >>> n) | (x << (32 - n))
+
+  // 预处理：填充消息
+  const bitLen = data.length * 8
+  // 消息 + 1 字节 0x80 + 填充 + 8 字节长度，总长度对齐到 64 字节
+  const padLen = (((data.length + 9 + 63) >>> 6) << 6)
+  const buf = new Uint8Array(padLen)
+  buf.set(data)
+  buf[data.length] = 0x80
+  // 写入 64 位大端长度（仅低 32 位，高 32 位在 JS 中始终为 0）
+  const view = new DataView(buf.buffer)
+  view.setUint32(padLen - 4, bitLen, false)
+
+  // 初始哈希值
+  let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a
+  let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19
+
+  const w = new Uint32Array(64)
+
+  for (let offset = 0; offset < padLen; offset += 64) {
+    for (let i = 0; i < 16; i++) {
+      w[i] = view.getUint32(offset + i * 4, false)
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3)
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10)
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0
+    }
+
+    let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7
+
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)
+      const ch = (e & f) ^ (~e & g)
+      const temp1 = (h + S1 + ch + K[i] + w[i]) | 0
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)
+      const maj = (a & b) ^ (a & c) ^ (b & c)
+      const temp2 = (S0 + maj) | 0
+
+      h = g; g = f; f = e; e = (d + temp1) | 0
+      d = c; c = b; b = a; a = (temp1 + temp2) | 0
+    }
+
+    h0 = (h0 + a) | 0; h1 = (h1 + b) | 0; h2 = (h2 + c) | 0; h3 = (h3 + d) | 0
+    h4 = (h4 + e) | 0; h5 = (h5 + f) | 0; h6 = (h6 + g) | 0; h7 = (h7 + h) | 0
+  }
+
+  return [h0, h1, h2, h3, h4, h5, h6, h7]
+    .map(v => (v >>> 0).toString(16).padStart(8, '0'))
+    .join('')
+}
diff --git a/admin-ui/src/main.tsx b/admin-ui/src/main.tsx
new file mode 100644
index 0000000..17ef62a
--- /dev/null
+++ b/admin-ui/src/main.tsx
@@ -0,0 +1,22 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import App from './App'
+import './index.css'
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 5000,
+      refetchOnWindowFocus: false,
+    },
+  },
+})
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <QueryClientProvider client={queryClient}>
+      <App />
+    </QueryClientProvider>
+  </React.StrictMode>,
+)
diff --git a/admin-ui/src/types/api.ts b/admin-ui/src/types/api.ts
new file mode 100644
index 0000000..97ece7d
--- /dev/null
+++ b/admin-ui/src/types/api.ts
@@ -0,0 +1,311 @@
+// 凭据状态响应
+export interface CredentialsStatusResponse {
+  total: number
+  available: number
+  credentials: CredentialStatusItem[]
+}
+
+// 单个凭据状态
+export interface CredentialStatusItem {
+  id: number
+  priority: number
+  disabled: boolean
+  failureCount: number
+  expiresAt: string | null
+  authMethod: string | null
+  hasProfileArn: boolean
+  accountEmail: string | null
+  email?: string
+  refreshTokenHash?: string
+
+  // ===== 统计（可持久化） =====
+  callsTotal: number
+  callsOk: number
+  callsErr: number
+  inputTokensTotal: number
+  outputTokensTotal: number
+  lastCallAt: string | null
+  lastSuccessAt: string | null
+  lastErrorAt: string | null
+  lastError: string | null
+
+  // ===== upstream 字段 =====
+  successCount: number
+  lastUsedAt: string | null
+  hasProxy: boolean
+  proxyUrl?: string
+  /** 凭据级 Region（用于 Token 刷新） */
+  region: string | null
+  /** 凭据级 API Region（单独覆盖 API 请求） */
+  apiRegion: string | null
+}
+
+// 余额响应
+export interface BalanceResponse {
+  id: number
+  subscriptionTitle: string | null
+  currentUsage: number
+  usageLimit: number
+  remaining: number
+  usagePercentage: number
+  nextResetAt: number | null
+}
+
+// 缓存余额信息
+export interface CachedBalanceInfo {
+  id: number
+  remaining: number
+  cachedAt: number // Unix 毫秒时间戳
+  ttlSecs: number
+}
+
+// 缓存余额响应
+export interface CachedBalancesResponse {
+  balances: CachedBalanceInfo[]
+}
+
+// 成功响应
+export interface SuccessResponse {
+  success: boolean
+  message: string
+}
+
+// ===== 统计（可持久化） =====
+
+export interface StatsBucket {
+  // 按日：YYYY-MM-DD；按模型：model id
+  key: string
+  callsTotal: number
+  callsOk: number
+  callsErr: number
+  inputTokensTotal: number
+  outputTokensTotal: number
+  lastCallAt: string | null
+  lastSuccessAt: string | null
+  lastErrorAt: string | null
+  lastError: string | null
+}
+
+export interface CredentialStatsResponse {
+  id: number
+  callsTotal: number
+  callsOk: number
+  callsErr: number
+  inputTokensTotal: number
+  outputTokensTotal: number
+  lastCallAt: string | null
+  lastSuccessAt: string | null
+  lastErrorAt: string | null
+  lastError: string | null
+  byDay: StatsBucket[]
+  byModel: StatsBucket[]
+}
+
+// 错误响应
+export interface AdminErrorResponse {
+  error: {
+    type: string
+    message: string
+  }
+}
+
+// 请求类型
+export interface SetDisabledRequest {
+  disabled: boolean
+}
+
+export interface SetPriorityRequest {
+  priority: number
+}
+
+// 添加凭据请求
+export interface AddCredentialRequest {
+  refreshToken: string
+  authMethod?: 'social' | 'idc'
+  clientId?: string
+  clientSecret?: string
+  priority?: number
+  /** Region（用于 Token 刷新及默认 API 请求），可被 apiRegion 单独覆盖 */
+  region?: string
+  /** 单独覆盖 API 请求使用的 region */
+  apiRegion?: string
+  machineId?: string
+  proxyUrl?: string
+  proxyUsername?: string
+  proxyPassword?: string
+}
+
+// 添加凭据响应
+export interface AddCredentialResponse {
+  success: boolean
+  message: string
+  credentialId: number
+  email?: string
+}
+
+// ===== 账号信息（套餐/用量/邮箱等） =====
+
+export interface CreditBonus {
+  code: string
+  name: string
+  current: number
+  limit: number
+  expiresAt: string | null
+}
+
+export interface CreditsResourceDetail {
+  displayName: string | null
+  displayNamePlural: string | null
+  resourceType: string | null
+  currency: string | null
+  unit: string | null
+  overageRate: number | null
+  overageCap: number | null
+}
+
+export interface CreditsUsageSummary {
+  current: number
+  limit: number
+  baseCurrent: number
+  baseLimit: number
+  freeTrialCurrent: number
+  freeTrialLimit: number
+  freeTrialExpiry: string | null
+  bonuses: CreditBonus[]
+  nextResetDate: string | null
+  overageEnabled: boolean | null
+  resourceDetail: CreditsResourceDetail | null
+}
+
+export interface AccountSubscriptionDetails {
+  rawType: string | null
+  managementTarget: string | null
+  upgradeCapability: string | null
+  overageCapability: string | null
+}
+
+export interface ResourceUsageSummary {
+  resourceType: string | null
+  displayName: string | null
+  unit: string | null
+  currency: string | null
+  current: number
+  limit: number
+}
+
+export interface UsageAndLimitsResponse {
+  userInfo: { email: string | null; userId: string | null } | null
+  subscriptionInfo:
+    | {
+        type: string | null
+        subscriptionTitle: string | null
+        upgradeCapability: string | null
+        overageCapability: string | null
+        subscriptionManagementTarget: string | null
+      }
+    | null
+  usageBreakdownList:
+    | Array<{
+        resourceType: string | null
+        currentUsage: number | null
+        currentUsageWithPrecision: number | null
+        usageLimit: number | null
+        usageLimitWithPrecision: number | null
+        displayName: string | null
+        displayNamePlural: string | null
+        currency: string | null
+        unit: string | null
+        overageRate: number | null
+        overageCap: number | null
+        freeTrialInfo:
+          | {
+              usageLimit: number | null
+              usageLimitWithPrecision: number | null
+              currentUsage: number | null
+              currentUsageWithPrecision: number | null
+              freeTrialExpiry: string | null
+              freeTrialStatus: string | null
+            }
+          | null
+        bonuses:
+          | Array<{
+              bonusCode: string | null
+              displayName: string | null
+              usageLimit: number | null
+              usageLimitWithPrecision: number | null
+              currentUsage: number | null
+              currentUsageWithPrecision: number | null
+              status: string | null
+              expiresAt: string | null
+            }>
+          | null
+      }>
+    | null
+  nextDateReset: string | null
+  overageConfiguration: { overageEnabled: boolean | null } | null
+}
+
+export interface AccountAggregateInfo {
+  email: string | null
+  userId: string | null
+  idp: string | null
+  status: string | null
+  featureFlags: string[] | null
+  subscriptionTitle: string | null
+  subscriptionType: string
+  subscription: AccountSubscriptionDetails
+  usage: CreditsUsageSummary
+  resources: ResourceUsageSummary[]
+  rawUsage: UsageAndLimitsResponse
+}
+
+export interface CredentialAccountInfoResponse {
+  id: number
+  account: AccountAggregateInfo
+}
+
+// ============ 批量导入 token.json ============
+
+// 官方 token.json 格式（用于解析导入）
+export interface TokenJsonItem {
+  provider?: string
+  refreshToken?: string
+  clientId?: string
+  clientSecret?: string
+  authMethod?: string
+  priority?: number
+  region?: string
+  machineId?: string
+}
+
+// 批量导入请求
+export interface ImportTokenJsonRequest {
+  dryRun?: boolean
+  items: TokenJsonItem | TokenJsonItem[]
+}
+
+// 导入动作
+export type ImportAction = 'added' | 'skipped' | 'invalid'
+
+// 单项导入结果
+export interface ImportItemResult {
+  index: number
+  fingerprint: string
+  action: ImportAction
+  reason?: string
+  credentialId?: number
+}
+
+// 导入汇总
+export interface ImportSummary {
+  parsed: number
+  added: number
+  skipped: number
+  invalid: number
+}
+
+// 批量导入响应
+export interface ImportTokenJsonResponse {
+  summary: ImportSummary
+  items: ImportItemResult[]
+}
diff --git a/admin-ui/tailwind.config.js b/admin-ui/tailwind.config.js
new file mode 100644
index 0000000..2e36b3b
--- /dev/null
+++ b/admin-ui/tailwind.config.js
@@ -0,0 +1,53 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  darkMode: 'class',
+  content: [
+    './index.html',
+    './src/**/*.{js,ts,jsx,tsx}',
+  ],
+  theme: {
+    extend: {
+      colors: {
+        border: 'hsl(var(--border))',
+        input: 'hsl(var(--input))',
+        ring: 'hsl(var(--ring))',
+        background: 'hsl(var(--background))',
+        foreground: 'hsl(var(--foreground))',
+        primary: {
+          DEFAULT: 'hsl(var(--primary))',
+          foreground: 'hsl(var(--primary-foreground))',
+        },
+        secondary: {
+          DEFAULT: 'hsl(var(--secondary))',
+          foreground: 'hsl(var(--secondary-foreground))',
+        },
+        destructive: {
+          DEFAULT: 'hsl(var(--destructive))',
+          foreground: 'hsl(var(--destructive-foreground))',
+        },
+        muted: {
+          DEFAULT: 'hsl(var(--muted))',
+          foreground: 'hsl(var(--muted-foreground))',
+        },
+        accent: {
+          DEFAULT: 'hsl(var(--accent))',
+          foreground: 'hsl(var(--accent-foreground))',
+        },
+        popover: {
+          DEFAULT: 'hsl(var(--popover))',
+          foreground: 'hsl(var(--popover-foreground))',
+        },
+        card: {
+          DEFAULT: 'hsl(var(--card))',
+          foreground: 'hsl(var(--card-foreground))',
+        },
+      },
+      borderRadius: {
+        lg: 'var(--radius)',
+        md: 'calc(var(--radius) - 2px)',
+        sm: 'calc(var(--radius) - 4px)',
+      },
+    },
+  },
+  plugins: [],
+}
diff --git a/admin-ui/vite.config.ts b/admin-ui/vite.config.ts
new file mode 100644
index 0000000..f02668b
--- /dev/null
+++ b/admin-ui/vite.config.ts
@@ -0,0 +1,28 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react-swc'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+export default defineConfig({
+  plugins: [react()],
+  base: '/admin/',
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+  server: {
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8080',
+        changeOrigin: true,
+      },
+    },
+  },
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+  },
+})
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..d44c86d
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,13 @@
+services:
+  kiro-rs:
+    # 使用国内镜像
+    # image: ghcr.nju.edu.cn/${IMAGE_OWNER:-hank9999}/kiro-rs:${IMAGE_TAG:-latest}
+    image: ghcr.io/${IMAGE_OWNER:-hank9999}/kiro-rs:${IMAGE_TAG:-latest}
+    container_name: kiro-rs
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    ports:
+      - "8990:8990"
+    volumes:
+      - ./config/:/app/config/
+    restart: unless-stopped
diff --git a/docs/media.md b/docs/media.md
new file mode 100644
index 0000000..1f503e6
--- /dev/null
+++ b/docs/media.md
@@ -0,0 +1,75 @@
+# 多媒体输入（图片 / GIF / 视频）
+
+本项目在 Anthropic → Kiro 的协议转换过程中，会把 `messages[].content` 里的 `image` 内容块转换为上游 Kiro API 的 `images[]` 字段。
+
+为避免上游对“大请求体/异常输入”返回 `400 Improperly formed request`，对 GIF 做了专门处理（抽帧→静态图）。
+
+## 图片（静态）
+
+当前支持的静态图片 `source.media_type`：
+
+- `image/jpeg`
+- `image/png`
+- `image/webp`
+
+处理策略：
+
+- 读取尺寸后按配置做等比缩放（长边/像素上限）
+- 保持原格式重编码（仅在需要缩放时）
+
+## GIF（动图）
+
+### 为什么不能直接透传 GIF
+
+GIF 常见特征是「分辨率不大但字节体积巨大」（多帧 + 调色板 + 压缩特性），如果把整段 GIF base64 原样塞进上游请求体，极易触发上游的请求体大小/校验限制（表现为 `400 Improperly formed request` 这类兜底错误）。
+
+### 当前实现：抽帧输出多张静态图
+
+当检测到 `source.media_type=image/gif` 时，会：
+
+1. 解码 GIF，计算总时长与源帧数
+2. 按时间轴采样（见下方采样策略）
+3. 对被选中的帧按同样的缩放规则处理，并重编码为静态 `jpeg`
+4. 将这些帧按时间顺序写入上游请求的 `images[]`
+
+### 采样策略（固定上限，按时长自适应）
+
+约束：
+
+- 总输出帧数 `<= 20`
+- 采样频率 `<= 5 fps`
+
+规则（等价描述）：
+
+- `fps = min(5, floor(20 / ceil(duration_seconds)))`
+- `interval_ms = 1000 / fps`
+- 若 `duration_seconds` 很大导致 `fps=0`，则按 `interval_ms = ceil(duration_ms / 20)` 做均匀采样
+
+例子：
+
+- 8 秒 GIF：`floor(20/8)=2` → `2 fps` → `interval=500ms` → 最多约 `16` 张
+- 4 秒 GIF：`floor(20/4)=5` → `5 fps` → `interval=200ms` → 最多 `20` 张
+
+## 视频（mp4 / mov 等）
+
+当前状态：**未实现**。
+
+说明：
+
+- Anthropic 的 `image` 内容块规范里通常不会发送 `video/*`，因此本项目当前也不会把 `video/mp4`、`video/quicktime` 等媒体类型转换成上游 `images[]`（等价于不支持/忽略）。
+
+### 规划方案（记录，暂不实现）
+
+如果未来需要支持“视频 → 多张静态图”的输入，推荐方案是引入视频解码能力（通常依赖 `ffmpeg/ffprobe`）：
+
+1. `ffprobe` 读取视频时长（毫秒）
+2. 复用 GIF 的采样策略计算 `interval_ms`，并限制 `<=20` 帧、`<=5fps`
+3. `ffmpeg` 按时间点抽帧（导出 `jpeg/webp`）
+4. 每帧按现有缩放规则处理后 base64 化，写入 `images[]`
+
+建议配套的安全/稳定性约束（避免 DoS 与请求体爆炸）：
+
+- 限制输入视频最大字节数与最大时长（超限直接 400）
+- 限制抽帧后总输出图片字节数（超限则降低 fps/分辨率/质量，或回退更少帧）
+- 使用临时目录并确保清理；并发下避免落盘文件名冲突
+
diff --git a/docs/qrcode_1769645166806.png b/docs/qrcode_1769645166806.png
new file mode 100644
index 0000000..5aee50e
Binary files /dev/null and b/docs/qrcode_1769645166806.png differ
diff --git a/examples/test_compression.rs b/examples/test_compression.rs
new file mode 100644
index 0000000..a773f22
--- /dev/null
+++ b/examples/test_compression.rs
@@ -0,0 +1,146 @@
+use serde_json::Value;
+use std::fs;
+
+fn main() -> anyhow::Result<()> {
+    let path = std::env::args().nth(1).ok_or_else(|| {
+        anyhow::anyhow!("Usage: cargo run --example test_compression -- <path-to-json>")
+    })?;
+
+    let content = fs::read_to_string(&path)?;
+    let data: Value = serde_json::from_str(&content)?;
+
+    let (req, raw_body_len) = if let Some(body_str) = data["request_body"].as_str() {
+        (
+            serde_json::from_str::<Value>(body_str)?,
+            Some(body_str.len()),
+        )
+    } else {
+        (data, None)
+    };
+
+    let body_len = match raw_body_len {
+        Some(n) => n,
+        None => serde_json::to_string(&req).unwrap_or_default().len(),
+    };
+    println!(
+        "原始请求体大小: {} bytes ({:.1} KB)",
+        body_len,
+        body_len as f64 / 1024.0
+    );
+
+    if let Some(messages) = req["messages"].as_array() {
+        println!("消息数量: {}", messages.len());
+
+        let mut user_count = 0;
+        let mut assistant_count = 0;
+        let mut total_chars = 0;
+        let mut tool_result_chars = 0;
+        let mut tool_use_chars = 0;
+
+        for msg in messages {
+            match msg["role"].as_str() {
+                Some("user") => user_count += 1,
+                Some("assistant") => assistant_count += 1,
+                _ => {}
+            }
+
+            if let Some(content) = msg["content"].as_array() {
+                for item in content {
+                    if let Some(text) = item["text"].as_str() {
+                        total_chars += text.len();
+                    }
+                    // 统计 tool_result
+                    if item["type"].as_str() == Some("tool_result")
+                        && let Some(result_content) = item["content"].as_array()
+                    {
+                        for result_item in result_content {
+                            if let Some(text) = result_item["text"].as_str() {
+                                tool_result_chars += text.len();
+                            }
+                        }
+                    }
+                    // 统计 tool_use
+                    if item["type"].as_str() == Some("tool_use") {
+                        let input_str =
+                            serde_json::to_string(&item["input"]).unwrap_or_else(|_| "null".into());
+                        tool_use_chars += input_str.len();
+                    }
+                }
+            }
+        }
+
+        println!("  - user: {}", user_count);
+        println!("  - assistant: {}", assistant_count);
+        println!(
+            "  - 文本字符数: {} ({:.1} KB)",
+            total_chars,
+            total_chars as f64 / 1024.0
+        );
+        println!(
+            "  - tool_result 字符数: {} ({:.1} KB)",
+            tool_result_chars,
+            tool_result_chars as f64 / 1024.0
+        );
+        println!(
+            "  - tool_use input 字符数: {} ({:.1} KB)",
+            tool_use_chars,
+            tool_use_chars as f64 / 1024.0
+        );
+
+        // 模拟历史截断
+        let max_history_turns = 80;
+        let max_history_chars = 400_000;
+
+        let turns = messages.len() / 2;
+        println!("\n压缩模拟（默认配置）:");
+        println!("  - 当前轮数: {} (阈值: {})", turns, max_history_turns);
+
+        if turns > max_history_turns {
+            let to_remove = turns - max_history_turns;
+            println!("  - 需要移除: {} 轮 ({} 条消息)", to_remove, to_remove * 2);
+        } else {
+            println!("  - 轮数未超限");
+        }
+
+        let total_content_chars = total_chars + tool_result_chars + tool_use_chars;
+        println!(
+            "  - 总内容字符数: {} ({:.1} KB)",
+            total_content_chars,
+            total_content_chars as f64 / 1024.0
+        );
+
+        if total_content_chars > max_history_chars {
+            println!(
+                "  - 字符数超限: {} > {}",
+                total_content_chars, max_history_chars
+            );
+        } else {
+            println!("  - 字符数未超限");
+        }
+    }
+
+    if let Some(tools) = req["tools"].as_array() {
+        let tools_str = serde_json::to_string(tools).unwrap_or_default();
+        println!("\n工具数量: {}", tools.len());
+        println!(
+            "工具定义总大小: {} bytes ({:.1} KB)",
+            tools_str.len(),
+            tools_str.len() as f64 / 1024.0
+        );
+
+        // 统计每个工具描述的大小
+        let mut total_desc_chars = 0;
+        for tool in tools {
+            if let Some(desc) = tool["description"].as_str() {
+                total_desc_chars += desc.len();
+            }
+        }
+        println!(
+            "工具描述总字符数: {} ({:.1} KB)",
+            total_desc_chars,
+            total_desc_chars as f64 / 1024.0
+        );
+    }
+
+    Ok(())
+}
diff --git a/src/admin/error.rs b/src/admin/error.rs
new file mode 100644
index 0000000..e1f9219
--- /dev/null
+++ b/src/admin/error.rs
@@ -0,0 +1,64 @@
+//! Admin API 错误类型定义
+
+use std::fmt;
+
+use axum::http::StatusCode;
+
+use super::types::AdminErrorResponse;
+
+/// Admin 服务错误类型
+#[derive(Debug)]
+pub enum AdminServiceError {
+    /// 凭据不存在
+    NotFound { id: u64 },
+
+    /// 上游服务调用失败（网络、API 错误等）
+    UpstreamError(String),
+
+    /// 内部状态错误
+    InternalError(String),
+
+    /// 凭据无效（验证失败）
+    InvalidCredential(String),
+}
+
+impl fmt::Display for AdminServiceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AdminServiceError::NotFound { id } => {
+                write!(f, "凭据不存在: {}", id)
+            }
+            AdminServiceError::UpstreamError(msg) => write!(f, "上游服务错误: {}", msg),
+            AdminServiceError::InternalError(msg) => write!(f, "内部错误: {}", msg),
+            AdminServiceError::InvalidCredential(msg) => write!(f, "凭据无效: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for AdminServiceError {}
+
+impl AdminServiceError {
+    /// 获取对应的 HTTP 状态码
+    pub fn status_code(&self) -> StatusCode {
+        match self {
+            AdminServiceError::NotFound { .. } => StatusCode::NOT_FOUND,
+            AdminServiceError::UpstreamError(_) => StatusCode::BAD_GATEWAY,
+            AdminServiceError::InternalError(_) => StatusCode::INTERNAL_SERVER_ERROR,
+            AdminServiceError::InvalidCredential(_) => StatusCode::BAD_REQUEST,
+        }
+    }
+
+    /// 转换为 API 错误响应
+    pub fn into_response(self) -> AdminErrorResponse {
+        match &self {
+            AdminServiceError::NotFound { .. } => AdminErrorResponse::not_found(self.to_string()),
+            AdminServiceError::UpstreamError(_) => AdminErrorResponse::api_error(self.to_string()),
+            AdminServiceError::InternalError(_) => {
+                AdminErrorResponse::internal_error(self.to_string())
+            }
+            AdminServiceError::InvalidCredential(_) => {
+                AdminErrorResponse::invalid_request(self.to_string())
+            }
+        }
+    }
+}
diff --git a/src/admin/handlers.rs b/src/admin/handlers.rs
new file mode 100644
index 0000000..e410f86
--- /dev/null
+++ b/src/admin/handlers.rs
@@ -0,0 +1,139 @@
+//! Admin API HTTP 处理器
+
+use axum::{
+    Json,
+    extract::{Path, State},
+    response::IntoResponse,
+};
+
+use super::{
+    middleware::AdminState,
+    types::{
+        AddCredentialRequest, ImportTokenJsonRequest, SetDisabledRequest, SetPriorityRequest,
+        SetRegionRequest, SuccessResponse,
+    },
+};
+
+/// GET /api/admin/credentials
+/// 获取所有凭据状态
+pub async fn get_all_credentials(State(state): State<AdminState>) -> impl IntoResponse {
+    let response = state.service.get_all_credentials();
+    Json(response)
+}
+
+/// POST /api/admin/credentials/:id/disabled
+/// 设置凭据禁用状态
+pub async fn set_credential_disabled(
+    State(state): State<AdminState>,
+    Path(id): Path<u64>,
+    Json(payload): Json<SetDisabledRequest>,
+) -> impl IntoResponse {
+    match state.service.set_disabled(id, payload.disabled) {
+        Ok(_) => {
+            let action = if payload.disabled { "禁用" } else { "启用" };
+            Json(SuccessResponse::new(format!("凭据 #{} 已{}", id, action))).into_response()
+        }
+        Err(e) => (e.status_code(), Json(e.into_response())).into_response(),
+    }
+}
+
+/// POST /api/admin/credentials/:id/priority
+/// 设置凭据优先级
+pub async fn set_credential_priority(
+    State(state): State<AdminState>,
+    Path(id): Path<u64>,
+    Json(payload): Json<SetPriorityRequest>,
+) -> impl IntoResponse {
+    match state.service.set_priority(id, payload.priority) {
+        Ok(_) => Json(SuccessResponse::new(format!(
+            "凭据 #{} 优先级已设置为 {}",
+            id, payload.priority
+        )))
+        .into_response(),
+        Err(e) => (e.status_code(), Json(e.into_response())).into_response(),
+    }
+}
+
+/// POST /api/admin/credentials/:id/region
+/// 设置凭据 Region
+pub async fn set_credential_region(
+    State(state): State<AdminState>,
+    Path(id): Path<u64>,
+    Json(payload): Json<SetRegionRequest>,
+) -> impl IntoResponse {
+    match state
+        .service
+        .set_region(id, payload.region, payload.api_region)
+    {
+        Ok(_) => Json(SuccessResponse::new(format!("凭据 #{} Region 已更新", id))).into_response(),
+        Err(e) => (e.status_code(), Json(e.into_response())).into_response(),
+    }
+}
+
+/// POST /api/admin/credentials/:id/reset
+/// 重置失败计数并重新启用
+pub async fn reset_failure_count(
+    State(state): State<AdminState>,
+    Path(id): Path<u64>,
+) -> impl IntoResponse {
+    match state.service.reset_and_enable(id) {
+        Ok(_) => Json(SuccessResponse::new(format!(
+            "凭据 #{} 失败计数已重置并重新启用",
+            id
+        )))
+        .into_response(),
+        Err(e) => (e.status_code(), Json(e.into_response())).into_response(),
+    }
+}
+
+/// GET /api/admin/credentials/:id/balance
+/// 获取指定凭据的余额
+pub async fn get_credential_balance(
+    State(state): State<AdminState>,
+    Path(id): Path<u64>,
+) -> impl IntoResponse {
+    match state.service.get_balance(id).await {
+        Ok(response) => Json(response).into_response(),
+        Err(e) => (e.status_code(), Json(e.into_response())).into_response(),
+    }
+}
+
+/// GET /api/admin/credentials/balances/cached
+/// 获取所有凭据的缓存余额
+pub async fn get_cached_balances(State(state): State<AdminState>) -> impl IntoResponse {
+    Json(state.service.get_cached_balances())
+}
+
+/// POST /api/admin/credentials
+/// 添加新凭据
+pub async fn add_credential(
+    State(state): State<AdminState>,
+    Json(payload): Json<AddCredentialRequest>,
+) -> impl IntoResponse {
+    match state.service.add_credential(payload).await {
+        Ok(response) => Json(response).into_response(),
+        Err(e) => (e.status_code(), Json(e.into_response())).into_response(),
+    }
+}
+
+/// DELETE /api/admin/credentials/:id
+/// 删除凭据
+pub async fn delete_credential(
+    State(state): State<AdminState>,
+    Path(id): Path<u64>,
+) -> impl IntoResponse {
+    match state.service.delete_credential(id) {
+        Ok(_) => Json(SuccessResponse::new(format!("凭据 #{} 已删除", id))).into_response(),
+        Err(e) => (e.status_code(), Json(e.into_response())).into_response(),
+    }
+}
+
+/// POST /api/admin/credentials/import-token-json
+/// 批量导入 token.json
+pub async fn import_token_json(
+    State(state): State<AdminState>,
+    Json(payload): Json<ImportTokenJsonRequest>,
+) -> impl IntoResponse {
+    let response = state.service.import_token_json(payload).await;
+    Json(response)
+}
diff --git a/src/admin/middleware.rs b/src/admin/middleware.rs
new file mode 100644
index 0000000..af11af9
--- /dev/null
+++ b/src/admin/middleware.rs
@@ -0,0 +1,50 @@
+//! Admin API 中间件
+
+use std::sync::Arc;
+
+use axum::{
+    body::Body,
+    extract::State,
+    http::{Request, StatusCode},
+    middleware::Next,
+    response::{IntoResponse, Json, Response},
+};
+
+use super::service::AdminService;
+use super::types::AdminErrorResponse;
+use crate::common::auth;
+
+/// Admin API 共享状态
+#[derive(Clone)]
+pub struct AdminState {
+    /// Admin API 密钥
+    pub admin_api_key: String,
+    /// Admin 服务
+    pub service: Arc<AdminService>,
+}
+
+impl AdminState {
+    pub fn new(admin_api_key: impl Into<String>, service: AdminService) -> Self {
+        Self {
+            admin_api_key: admin_api_key.into(),
+            service: Arc::new(service),
+        }
+    }
+}
+
+/// Admin API 认证中间件
+pub async fn admin_auth_middleware(
+    State(state): State<AdminState>,
+    request: Request<Body>,
+    next: Next,
+) -> Response {
+    let api_key = auth::extract_api_key(&request);
+
+    match api_key {
+        Some(key) if auth::constant_time_eq(&key, &state.admin_api_key) => next.run(request).await,
+        _ => {
+            let error = AdminErrorResponse::authentication_error();
+            (StatusCode::UNAUTHORIZED, Json(error)).into_response()
+        }
+    }
+}
diff --git a/src/admin/mod.rs b/src/admin/mod.rs
new file mode 100644
index 0000000..21321f8
--- /dev/null
+++ b/src/admin/mod.rs
@@ -0,0 +1,28 @@
+//! Admin API 模块
+//!
+//! 提供凭据管理和监控功能的 HTTP API
+//!
+//! # 功能
+//! - 查询所有凭据状态
+//! - 启用/禁用凭据
+//! - 修改凭据优先级
+//! - 重置失败计数
+//! - 查询凭据余额
+//!
+//! # 使用
+//! ```ignore
+//! let admin_service = AdminService::new(token_manager.clone());
+//! let admin_state = AdminState::new(admin_api_key, admin_service);
+//! let admin_router = create_admin_router(admin_state);
+//! ```
+
+mod error;
+mod handlers;
+mod middleware;
+mod router;
+mod service;
+pub mod types;
+
+pub use middleware::AdminState;
+pub use router::create_admin_router;
+pub use service::AdminService;
diff --git a/src/admin/router.rs b/src/admin/router.rs
new file mode 100644
index 0000000..f119b0f
--- /dev/null
+++ b/src/admin/router.rs
@@ -0,0 +1,53 @@
+//! Admin API 路由配置
+
+use axum::{
+    Router, middleware,
+    routing::{delete, get, post},
+};
+
+use super::{
+    handlers::{
+        add_credential, delete_credential, get_all_credentials, get_cached_balances,
+        get_credential_balance, import_token_json, reset_failure_count, set_credential_disabled,
+        set_credential_priority, set_credential_region,
+    },
+    middleware::{AdminState, admin_auth_middleware},
+};
+
+/// 创建 Admin API 路由
+///
+/// # 端点
+/// - `GET /credentials` - 获取所有凭据状态
+/// - `POST /credentials` - 添加新凭据
+/// - `POST /credentials/import-token-json` - 批量导入 token.json
+/// - `DELETE /credentials/:id` - 删除凭据
+/// - `POST /credentials/:id/disabled` - 设置凭据禁用状态
+/// - `POST /credentials/:id/priority` - 设置凭据优先级
+/// - `POST /credentials/:id/reset` - 重置失败计数
+/// - `GET /credentials/:id/balance` - 获取凭据余额
+/// - `GET /credentials/balances/cached` - 获取所有凭据的缓存余额
+///
+/// # 认证
+/// 需要 Admin API Key 认证，支持：
+/// - `x-api-key` header
+/// - `Authorization: Bearer <token>` header
+pub fn create_admin_router(state: AdminState) -> Router {
+    Router::new()
+        .route(
+            "/credentials",
+            get(get_all_credentials).post(add_credential),
+        )
+        .route("/credentials/balances/cached", get(get_cached_balances))
+        .route("/credentials/import-token-json", post(import_token_json))
+        .route("/credentials/{id}", delete(delete_credential))
+        .route("/credentials/{id}/disabled", post(set_credential_disabled))
+        .route("/credentials/{id}/priority", post(set_credential_priority))
+        .route("/credentials/{id}/region", post(set_credential_region))
+        .route("/credentials/{id}/reset", post(reset_failure_count))
+        .route("/credentials/{id}/balance", get(get_credential_balance))
+        .layer(middleware::from_fn_with_state(
+            state.clone(),
+            admin_auth_middleware,
+        ))
+        .with_state(state)
+}
diff --git a/src/admin/service.rs b/src/admin/service.rs
new file mode 100644
index 0000000..aa2bd35
--- /dev/null
+++ b/src/admin/service.rs
@@ -0,0 +1,612 @@
+//! Admin API 业务逻辑服务
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use chrono::Utc;
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+
+use crate::common::utf8::floor_char_boundary;
+use crate::kiro::model::credentials::KiroCredentials;
+use crate::kiro::token_manager::MultiTokenManager;
+
+use super::error::AdminServiceError;
+use super::types::{
+    AddCredentialRequest, AddCredentialResponse, BalanceResponse, CachedBalanceItem,
+    CachedBalancesResponse, CredentialStatusItem, CredentialsStatusResponse, ImportAction,
+    ImportItemResult, ImportSummary, ImportTokenJsonRequest, ImportTokenJsonResponse,
+    TokenJsonItem,
+};
+
+/// 余额缓存过期时间（秒），5 分钟
+const BALANCE_CACHE_TTL_SECS: i64 = 300;
+
+/// 缓存的余额条目（含时间戳）
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct CachedBalance {
+    /// 缓存时间（Unix 秒）
+    cached_at: f64,
+    /// 缓存的余额数据
+    data: BalanceResponse,
+}
+
+/// Admin 服务
+///
+/// 封装所有 Admin API 的业务逻辑
+pub struct AdminService {
+    token_manager: Arc<MultiTokenManager>,
+    balance_cache: Mutex<HashMap<u64, CachedBalance>>,
+    cache_path: Option<PathBuf>,
+}
+
+impl AdminService {
+    pub fn new(token_manager: Arc<MultiTokenManager>) -> Self {
+        let cache_path = token_manager
+            .cache_dir()
+            .map(|d| d.join("kiro_balance_cache.json"));
+
+        let balance_cache = Self::load_balance_cache_from(&cache_path);
+
+        Self {
+            token_manager,
+            balance_cache: Mutex::new(balance_cache),
+            cache_path,
+        }
+    }
+
+    /// 获取所有凭据状态
+    pub fn get_all_credentials(&self) -> CredentialsStatusResponse {
+        let snapshot = self.token_manager.snapshot();
+
+        let mut credentials: Vec<CredentialStatusItem> = snapshot
+            .entries
+            .into_iter()
+            .map(|entry| CredentialStatusItem {
+                id: entry.id,
+                priority: entry.priority,
+                disabled: entry.disabled,
+                failure_count: entry.failure_count,
+                expires_at: entry.expires_at,
+                auth_method: entry.auth_method,
+                has_profile_arn: entry.has_profile_arn,
+                refresh_token_hash: entry.refresh_token_hash,
+                email: entry.email,
+                success_count: entry.success_count,
+                last_used_at: entry.last_used_at.clone(),
+                region: entry.region,
+                api_region: entry.api_region,
+            })
+            .collect();
+
+        // 按优先级排序（数字越小优先级越高）
+        credentials.sort_by_key(|c| c.priority);
+
+        CredentialsStatusResponse {
+            total: snapshot.total,
+            available: snapshot.available,
+            credentials,
+        }
+    }
+
+    /// 设置凭据禁用状态
+    pub fn set_disabled(&self, id: u64, disabled: bool) -> Result<(), AdminServiceError> {
+        self.token_manager
+            .set_disabled(id, disabled)
+            .map_err(|e| self.classify_error(e, id))
+    }
+
+    /// 设置凭据优先级
+    pub fn set_priority(&self, id: u64, priority: u32) -> Result<(), AdminServiceError> {
+        self.token_manager
+            .set_priority(id, priority)
+            .map_err(|e| self.classify_error(e, id))
+    }
+
+    /// 设置凭据 Region
+    pub fn set_region(
+        &self,
+        id: u64,
+        region: Option<String>,
+        api_region: Option<String>,
+    ) -> Result<(), AdminServiceError> {
+        // trim 后空字符串转 None
+        let region = region
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty());
+        let api_region = api_region
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty());
+        self.token_manager
+            .set_region(id, region, api_region)
+            .map_err(|e| self.classify_error(e, id))
+    }
+
+    /// 重置失败计数并重新启用
+    pub fn reset_and_enable(&self, id: u64) -> Result<(), AdminServiceError> {
+        self.token_manager
+            .reset_and_enable(id)
+            .map_err(|e| self.classify_error(e, id))
+    }
+
+    /// 获取凭据余额（带缓存）
+    pub async fn get_balance(&self, id: u64) -> Result<BalanceResponse, AdminServiceError> {
+        // 先查缓存
+        {
+            let cache = self.balance_cache.lock();
+            if let Some(cached) = cache.get(&id) {
+                let now = Utc::now().timestamp() as f64;
+                if (now - cached.cached_at) < BALANCE_CACHE_TTL_SECS as f64 {
+                    tracing::debug!("凭据 #{} 余额命中缓存", id);
+                    return Ok(cached.data.clone());
+                }
+            }
+        }
+
+        // 缓存未命中或已过期，从上游获取
+        let balance = self.fetch_balance(id).await?;
+
+        // 更新缓存
+        {
+            let mut cache = self.balance_cache.lock();
+            cache.insert(
+                id,
+                CachedBalance {
+                    cached_at: Utc::now().timestamp() as f64,
+                    data: balance.clone(),
+                },
+            );
+        }
+        self.save_balance_cache();
+
+        Ok(balance)
+    }
+
+    /// 从上游获取余额（无缓存）
+    async fn fetch_balance(&self, id: u64) -> Result<BalanceResponse, AdminServiceError> {
+        let usage = self
+            .token_manager
+            .get_usage_limits_for(id)
+            .await
+            .map_err(|e| self.classify_balance_error(e, id))?;
+
+        let current_usage = usage.current_usage();
+        let usage_limit = usage.usage_limit();
+        let remaining = (usage_limit - current_usage).max(0.0);
+        let usage_percentage = if usage_limit > 0.0 {
+            (current_usage / usage_limit * 100.0).min(100.0)
+        } else {
+            0.0
+        };
+
+        // 更新缓存，使列表页面能显示最新余额
+        self.token_manager.update_balance_cache(id, remaining);
+
+        Ok(BalanceResponse {
+            id,
+            subscription_title: usage.subscription_title().map(|s| s.to_string()),
+            current_usage,
+            usage_limit,
+            remaining,
+            usage_percentage,
+            next_reset_at: usage.next_date_reset,
+        })
+    }
+
+    /// 获取所有凭据的缓存余额
+    pub fn get_cached_balances(&self) -> CachedBalancesResponse {
+        let balances = self
+            .token_manager
+            .get_all_cached_balances()
+            .into_iter()
+            .map(|info| CachedBalanceItem {
+                id: info.id,
+                remaining: info.remaining,
+                cached_at: info.cached_at,
+                ttl_secs: info.ttl_secs,
+            })
+            .collect();
+
+        CachedBalancesResponse { balances }
+    }
+
+    /// 添加新凭据
+    pub async fn add_credential(
+        &self,
+        req: AddCredentialRequest,
+    ) -> Result<AddCredentialResponse, AdminServiceError> {
+        // 构建凭据对象
+        let email = req.email.clone();
+        let new_cred = KiroCredentials {
+            id: None,
+            access_token: None,
+            refresh_token: Some(req.refresh_token),
+            profile_arn: None,
+            expires_at: None,
+            auth_method: Some(req.auth_method),
+            client_id: req.client_id,
+            client_secret: req.client_secret,
+            priority: req.priority,
+            region: req.region,
+            api_region: req.api_region,
+            machine_id: req.machine_id,
+            email: req.email,
+            subscription_title: None,
+            proxy_url: req.proxy_url,
+            proxy_username: req.proxy_username,
+            proxy_password: req.proxy_password,
+            disabled: false, // 新添加的凭据默认启用
+        };
+
+        // 调用 token_manager 添加凭据
+        let credential_id = self
+            .token_manager
+            .add_credential(new_cred)
+            .await
+            .map_err(|e| self.classify_add_error(e))?;
+
+        Ok(AddCredentialResponse {
+            success: true,
+            message: format!("凭据添加成功，ID: {}", credential_id),
+            credential_id,
+            email,
+        })
+    }
+
+    /// 删除凭据
+    pub fn delete_credential(&self, id: u64) -> Result<(), AdminServiceError> {
+        self.token_manager
+            .delete_credential(id)
+            .map_err(|e| self.classify_delete_error(e, id))?;
+
+        // 清理已删除凭据的余额缓存
+        {
+            let mut cache = self.balance_cache.lock();
+            cache.remove(&id);
+        }
+        self.save_balance_cache();
+
+        Ok(())
+    }
+
+    // ============ 余额缓存持久化 ============
+
+    fn load_balance_cache_from(cache_path: &Option<PathBuf>) -> HashMap<u64, CachedBalance> {
+        let path = match cache_path {
+            Some(p) => p,
+            None => return HashMap::new(),
+        };
+
+        let content = match std::fs::read_to_string(path) {
+            Ok(c) => c,
+            Err(_) => return HashMap::new(),
+        };
+
+        // 文件中使用字符串 key 以兼容 JSON 格式
+        let map: HashMap<String, CachedBalance> = match serde_json::from_str(&content) {
+            Ok(m) => m,
+            Err(e) => {
+                tracing::warn!("解析余额缓存失败，将忽略: {}", e);
+                return HashMap::new();
+            }
+        };
+
+        let now = Utc::now().timestamp() as f64;
+        map.into_iter()
+            .filter_map(|(k, v)| {
+                let id = k.parse::<u64>().ok()?;
+                // 丢弃超过 TTL 的条目
+                if (now - v.cached_at) < BALANCE_CACHE_TTL_SECS as f64 {
+                    Some((id, v))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    fn save_balance_cache(&self) {
+        let path = match &self.cache_path {
+            Some(p) => p,
+            None => return,
+        };
+
+        // 快速 clone 数据后释放锁，减少锁持有时间
+        let map: HashMap<String, CachedBalance> = {
+            let cache = self.balance_cache.lock();
+            cache
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.clone()))
+                .collect()
+        };
+
+        // 锁外执行序列化和文件 IO
+        match serde_json::to_string_pretty(&map) {
+            Ok(json) => {
+                // 原子写入：先写临时文件，再重命名
+                let tmp_path = path.with_extension("json.tmp");
+                match std::fs::write(&tmp_path, json) {
+                    Ok(_) => {
+                        if let Err(e) = std::fs::rename(&tmp_path, path) {
+                            tracing::warn!("原子重命名余额缓存失败: {}", e);
+                            let _ = std::fs::remove_file(&tmp_path);
+                        }
+                    }
+                    Err(e) => tracing::warn!("写入临时余额文件失败: {}", e),
+                }
+            }
+            Err(e) => tracing::warn!("序列化余额缓存失败: {}", e),
+        }
+    }
+
+    // ============ 错误分类 ============
+
+    /// 分类简单操作错误（set_disabled, set_priority, reset_and_enable）
+    fn classify_error(&self, e: anyhow::Error, id: u64) -> AdminServiceError {
+        let msg = e.to_string();
+        if msg.contains("不存在") {
+            AdminServiceError::NotFound { id }
+        } else {
+            AdminServiceError::InternalError(msg)
+        }
+    }
+
+    /// 分类余额查询错误（可能涉及上游 API 调用）
+    fn classify_balance_error(&self, e: anyhow::Error, id: u64) -> AdminServiceError {
+        let msg = e.to_string();
+
+        // 1. 凭据不存在
+        if msg.contains("不存在") {
+            return AdminServiceError::NotFound { id };
+        }
+
+        // 2. 上游服务错误特征：HTTP 响应错误或网络错误
+        let is_upstream_error =
+            // HTTP 响应错误（来自 refresh_*_token 的错误消息）
+            msg.contains("凭证已过期或无效") ||
+            msg.contains("权限不足") ||
+            msg.contains("已被限流") ||
+            msg.contains("服务器错误") ||
+            msg.contains("Token 刷新失败") ||
+            msg.contains("暂时不可用") ||
+            // 网络错误（reqwest 错误）
+            msg.contains("error trying to connect") ||
+            msg.contains("connection") ||
+            msg.contains("timeout") ||
+            msg.contains("timed out");
+
+        if is_upstream_error {
+            AdminServiceError::UpstreamError(msg)
+        } else {
+            // 3. 默认归类为内部错误（本地验证失败、配置错误等）
+            // 包括：缺少 refreshToken、refreshToken 已被截断、无法生成 machineId 等
+            AdminServiceError::InternalError(msg)
+        }
+    }
+
+    /// 分类添加凭据错误
+    fn classify_add_error(&self, e: anyhow::Error) -> AdminServiceError {
+        let msg = e.to_string();
+
+        // 凭据验证失败（refreshToken 无效、格式错误等）
+        let is_invalid_credential = msg.contains("缺少 refreshToken")
+            || msg.contains("refreshToken 为空")
+            || msg.contains("refreshToken 已被截断")
+            || msg.contains("凭据已存在")
+            || msg.contains("refreshToken 重复")
+            || msg.contains("凭证已过期或无效")
+            || msg.contains("权限不足")
+            || msg.contains("已被限流");
+
+        if is_invalid_credential {
+            AdminServiceError::InvalidCredential(msg)
+        } else if msg.contains("error trying to connect")
+            || msg.contains("connection")
+            || msg.contains("timeout")
+        {
+            AdminServiceError::UpstreamError(msg)
+        } else {
+            AdminServiceError::InternalError(msg)
+        }
+    }
+
+    /// 分类删除凭据错误
+    fn classify_delete_error(&self, e: anyhow::Error, id: u64) -> AdminServiceError {
+        let msg = e.to_string();
+        if msg.contains("不存在") {
+            AdminServiceError::NotFound { id }
+        } else if msg.contains("只能删除已禁用的凭据") || msg.contains("请先禁用凭据")
+        {
+            AdminServiceError::InvalidCredential(msg)
+        } else {
+            AdminServiceError::InternalError(msg)
+        }
+    }
+
+    /// 批量导入 token.json
+    ///
+    /// 解析官方 token.json 格式，按 provider 字段自动映射 authMethod：
+    /// - BuilderId/builder-id/idc → idc
+    /// - Social/social → social
+    pub async fn import_token_json(&self, req: ImportTokenJsonRequest) -> ImportTokenJsonResponse {
+        let items = req.items.into_vec();
+        let dry_run = req.dry_run;
+
+        let mut results = Vec::with_capacity(items.len());
+        let mut added = 0usize;
+        let mut skipped = 0usize;
+        let mut invalid = 0usize;
+
+        for (index, item) in items.into_iter().enumerate() {
+            let result = self.process_token_json_item(index, item, dry_run).await;
+            match result.action {
+                ImportAction::Added => added += 1,
+                ImportAction::Skipped => skipped += 1,
+                ImportAction::Invalid => invalid += 1,
+            }
+            results.push(result);
+        }
+
+        ImportTokenJsonResponse {
+            summary: ImportSummary {
+                parsed: results.len(),
+                added,
+                skipped,
+                invalid,
+            },
+            items: results,
+        }
+    }
+
+    /// 处理单个 token.json 项
+    async fn process_token_json_item(
+        &self,
+        index: usize,
+        item: TokenJsonItem,
+        dry_run: bool,
+    ) -> ImportItemResult {
+        // 生成指纹（用于识别和去重）
+        let fingerprint = Self::generate_fingerprint(&item);
+
+        // 验证必填字段
+        let refresh_token = match &item.refresh_token {
+            Some(rt) if !rt.is_empty() => rt.clone(),
+            _ => {
+                return ImportItemResult {
+                    index,
+                    fingerprint,
+                    action: ImportAction::Invalid,
+                    reason: Some("缺少 refreshToken".to_string()),
+                    credential_id: None,
+                };
+            }
+        };
+
+        // 映射 authMethod
+        let auth_method = Self::map_auth_method(&item);
+
+        // IdC 需要 clientId 和 clientSecret
+        if auth_method == "idc" && (item.client_id.is_none() || item.client_secret.is_none()) {
+            return ImportItemResult {
+                index,
+                fingerprint,
+                action: ImportAction::Invalid,
+                reason: Some(format!("{} 认证需要 clientId 和 clientSecret", auth_method)),
+                credential_id: None,
+            };
+        }
+
+        // 检查是否已存在（通过 refreshToken 前缀匹配）
+        if self.token_manager.has_refresh_token_prefix(&refresh_token) {
+            return ImportItemResult {
+                index,
+                fingerprint,
+                action: ImportAction::Skipped,
+                reason: Some("凭据已存在".to_string()),
+                credential_id: None,
+            };
+        }
+
+        // dry-run 模式只返回预览
+        if dry_run {
+            return ImportItemResult {
+                index,
+                fingerprint,
+                action: ImportAction::Added,
+                reason: Some("预览模式".to_string()),
+                credential_id: None,
+            };
+        }
+
+        // 实际添加凭据（trim + 空字符串转 None，与 set_region 逻辑一致）
+        let region = item
+            .region
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty());
+        let api_region = item
+            .api_region
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty());
+        let new_cred = KiroCredentials {
+            id: None,
+            access_token: None,
+            refresh_token: Some(refresh_token),
+            profile_arn: None,
+            expires_at: None,
+            auth_method: Some(auth_method),
+            client_id: item.client_id,
+            client_secret: item.client_secret,
+            priority: item.priority,
+            region,
+            api_region,
+            machine_id: item.machine_id,
+            email: None,
+            subscription_title: None,
+            proxy_url: None,
+            proxy_username: None,
+            proxy_password: None,
+            disabled: false,
+        };
+
+        match self.token_manager.add_credential(new_cred).await {
+            Ok(credential_id) => ImportItemResult {
+                index,
+                fingerprint,
+                action: ImportAction::Added,
+                reason: None,
+                credential_id: Some(credential_id),
+            },
+            Err(e) => ImportItemResult {
+                index,
+                fingerprint,
+                action: ImportAction::Invalid,
+                reason: Some(e.to_string()),
+                credential_id: None,
+            },
+        }
+    }
+
+    /// 生成凭据指纹（用于识别）
+    fn generate_fingerprint(item: &TokenJsonItem) -> String {
+        // 使用 refreshToken 前 16 字符作为指纹
+        // 使用 floor_char_boundary 安全截断，避免在多字节字符中间切割导致 panic
+        item.refresh_token
+            .as_ref()
+            .map(|rt| {
+                if rt.len() >= 16 {
+                    let end = floor_char_boundary(rt, 16);
+                    format!("{}...", &rt[..end])
+                } else {
+                    rt.clone()
+                }
+            })
+            .unwrap_or_else(|| "(empty)".to_string())
+    }
+
+    /// 映射 provider/authMethod 到标准 authMethod
+    fn map_auth_method(item: &TokenJsonItem) -> String {
+        // 优先使用 authMethod 字段
+        if let Some(auth) = &item.auth_method {
+            let auth_lower = auth.to_lowercase();
+            return match auth_lower.as_str() {
+                "idc" | "builder-id" | "builderid" => "idc".to_string(),
+                "social" => "social".to_string(),
+                _ => auth_lower,
+            };
+        }
+
+        // 回退到 provider 字段
+        if let Some(provider) = &item.provider {
+            let provider_lower = provider.to_lowercase();
+            return match provider_lower.as_str() {
+                "builderid" | "builder-id" | "idc" => "idc".to_string(),
+                "social" => "social".to_string(),
+                _ => "social".to_string(), // 默认 social
+            };
+        }
+
+        // 默认 social
+        "social".to_string()
+    }
+}
diff --git a/src/admin/types.rs b/src/admin/types.rs
new file mode 100644
index 0000000..ceb88fa
--- /dev/null
+++ b/src/admin/types.rs
@@ -0,0 +1,335 @@
+//! Admin API 类型定义
+
+use serde::{Deserialize, Serialize};
+
+// ============ 凭据状态 ============
+
+/// 所有凭据状态响应
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CredentialsStatusResponse {
+    /// 凭据总数
+    pub total: usize,
+    /// 可用凭据数量（未禁用）
+    pub available: usize,
+    /// 各凭据状态列表
+    pub credentials: Vec<CredentialStatusItem>,
+}
+
+/// 单个凭据的状态信息
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CredentialStatusItem {
+    /// 凭据唯一 ID
+    pub id: u64,
+    /// 优先级（数字越小优先级越高）
+    pub priority: u32,
+    /// 是否被禁用
+    pub disabled: bool,
+    /// 连续失败次数
+    pub failure_count: u32,
+    /// Token 过期时间（RFC3339 格式）
+    pub expires_at: Option<String>,
+    /// 认证方式
+    pub auth_method: Option<String>,
+    /// 是否有 Profile ARN
+    pub has_profile_arn: bool,
+    /// refreshToken 的 SHA-256 哈希（用于前端重复检测）
+    pub refresh_token_hash: Option<String>,
+    /// 用户邮箱（用于前端显示）
+    pub email: Option<String>,
+    /// API 调用成功次数
+    pub success_count: u64,
+    /// 最后一次 API 调用时间（RFC3339 格式）
+    pub last_used_at: Option<String>,
+    /// 凭据级 Region（用于 Token 刷新）
+    pub region: Option<String>,
+    /// 凭据级 API Region（单独覆盖 API 请求）
+    pub api_region: Option<String>,
+}
+
+// ============ 操作请求 ============
+
+/// 启用/禁用凭据请求
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SetDisabledRequest {
+    /// 是否禁用
+    pub disabled: bool,
+}
+
+/// 修改优先级请求
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SetPriorityRequest {
+    /// 新优先级值
+    pub priority: u32,
+}
+
+/// 修改 Region 请求
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SetRegionRequest {
+    /// 凭据级 Region（用于 Token 刷新），空字符串表示清除
+    pub region: Option<String>,
+    /// 凭据级 API Region（单独覆盖 API 请求），空字符串表示清除
+    pub api_region: Option<String>,
+}
+
+/// 添加凭据请求
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AddCredentialRequest {
+    /// 刷新令牌（必填）
+    pub refresh_token: String,
+
+    /// 认证方式（可选，默认 social）
+    #[serde(default = "default_auth_method")]
+    pub auth_method: String,
+
+    /// OIDC Client ID（IdC 认证需要）
+    pub client_id: Option<String>,
+
+    /// OIDC Client Secret（IdC 认证需要）
+    pub client_secret: Option<String>,
+
+    /// 优先级（可选，默认 0）
+    #[serde(default)]
+    pub priority: u32,
+
+    /// 凭据级 Region 配置（用于 Token 刷新）
+    /// 未配置时回退到 config.json 的全局 region
+    pub region: Option<String>,
+
+    /// 凭据级 API Region（用于 API 调用）
+    pub api_region: Option<String>,
+
+    /// 凭据级 Machine ID（可选，64 位字符串）
+    /// 未配置时回退到 config.json 的 machineId
+    pub machine_id: Option<String>,
+
+    /// 用户邮箱（可选，用于前端显示）
+    pub email: Option<String>,
+
+    /// 凭据级代理 URL
+    pub proxy_url: Option<String>,
+
+    /// 凭据级代理用户名
+    pub proxy_username: Option<String>,
+
+    /// 凭据级代理密码
+    pub proxy_password: Option<String>,
+}
+
+fn default_auth_method() -> String {
+    "social".to_string()
+}
+
+/// 添加凭据成功响应
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AddCredentialResponse {
+    pub success: bool,
+    pub message: String,
+    /// 新添加的凭据 ID
+    pub credential_id: u64,
+    /// 用户邮箱（如果获取成功）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub email: Option<String>,
+}
+
+// ============ 余额查询 ============
+
+/// 余额查询响应
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BalanceResponse {
+    /// 凭据 ID
+    pub id: u64,
+    /// 订阅类型
+    pub subscription_title: Option<String>,
+    /// 当前使用量
+    pub current_usage: f64,
+    /// 使用限额
+    pub usage_limit: f64,
+    /// 剩余额度
+    pub remaining: f64,
+    /// 使用百分比
+    pub usage_percentage: f64,
+    /// 下次重置时间（Unix 时间戳）
+    pub next_reset_at: Option<f64>,
+}
+
+/// 缓存余额信息
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CachedBalanceItem {
+    /// 凭据 ID
+    pub id: u64,
+    /// 缓存的剩余额度
+    pub remaining: f64,
+    /// 缓存时间（Unix 毫秒时间戳）
+    pub cached_at: u64,
+    /// 缓存存活时间（秒），缓存过期时间 = cached_at + ttl_secs * 1000
+    pub ttl_secs: u64,
+}
+
+/// 所有凭据的缓存余额响应
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CachedBalancesResponse {
+    /// 各凭据的缓存余额列表
+    pub balances: Vec<CachedBalanceItem>,
+}
+
+// ============ 负载均衡配置 ============
+
+// ============ 通用响应 ============
+
+/// 操作成功响应
+#[derive(Debug, Serialize)]
+pub struct SuccessResponse {
+    pub success: bool,
+    pub message: String,
+}
+
+impl SuccessResponse {
+    pub fn new(message: impl Into<String>) -> Self {
+        Self {
+            success: true,
+            message: message.into(),
+        }
+    }
+}
+
+// ============ 批量导入 token.json ============
+
+/// 官方 token.json 格式（用于解析导入）
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TokenJsonItem {
+    pub provider: Option<String>,
+    pub refresh_token: Option<String>,
+    pub client_id: Option<String>,
+    pub client_secret: Option<String>,
+    pub auth_method: Option<String>,
+    #[serde(default)]
+    pub priority: u32,
+    pub region: Option<String>,
+    pub api_region: Option<String>,
+    pub machine_id: Option<String>,
+}
+
+/// 批量导入请求
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportTokenJsonRequest {
+    #[serde(default = "default_dry_run")]
+    pub dry_run: bool,
+    pub items: ImportItems,
+}
+
+fn default_dry_run() -> bool {
+    true
+}
+
+/// 导入项（支持单个或数组）
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+pub enum ImportItems {
+    Single(TokenJsonItem),
+    Multiple(Vec<TokenJsonItem>),
+}
+
+impl ImportItems {
+    pub fn into_vec(self) -> Vec<TokenJsonItem> {
+        match self {
+            ImportItems::Single(item) => vec![item],
+            ImportItems::Multiple(items) => items,
+        }
+    }
+}
+
+/// 批量导入响应
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportTokenJsonResponse {
+    pub summary: ImportSummary,
+    pub items: Vec<ImportItemResult>,
+}
+
+/// 导入汇总
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportSummary {
+    pub parsed: usize,
+    pub added: usize,
+    pub skipped: usize,
+    pub invalid: usize,
+}
+
+/// 单项导入结果
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportItemResult {
+    pub index: usize,
+    pub fingerprint: String,
+    pub action: ImportAction,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reason: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub credential_id: Option<u64>,
+}
+
+/// 导入动作
+#[derive(Debug, Serialize, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ImportAction {
+    Added,
+    Skipped,
+    Invalid,
+}
+
+/// 错误响应
+#[derive(Debug, Serialize)]
+pub struct AdminErrorResponse {
+    pub error: AdminError,
+}
+
+#[derive(Debug, Serialize)]
+pub struct AdminError {
+    #[serde(rename = "type")]
+    pub error_type: String,
+    pub message: String,
+}
+
+impl AdminErrorResponse {
+    pub fn new(error_type: impl Into<String>, message: impl Into<String>) -> Self {
+        Self {
+            error: AdminError {
+                error_type: error_type.into(),
+                message: message.into(),
+            },
+        }
+    }
+
+    pub fn invalid_request(message: impl Into<String>) -> Self {
+        Self::new("invalid_request", message)
+    }
+
+    pub fn authentication_error() -> Self {
+        Self::new("authentication_error", "Invalid or missing admin API key")
+    }
+
+    pub fn not_found(message: impl Into<String>) -> Self {
+        Self::new("not_found", message)
+    }
+
+    pub fn api_error(message: impl Into<String>) -> Self {
+        Self::new("api_error", message)
+    }
+
+    pub fn internal_error(message: impl Into<String>) -> Self {
+        Self::new("internal_error", message)
+    }
+}
diff --git a/src/admin_ui/mod.rs b/src/admin_ui/mod.rs
new file mode 100644
index 0000000..9537d28
--- /dev/null
+++ b/src/admin_ui/mod.rs
@@ -0,0 +1,7 @@
+//! Admin UI 静态文件服务模块
+//!
+//! 使用 rust-embed 嵌入前端构建产物
+
+mod router;
+
+pub use router::create_admin_ui_router;
diff --git a/src/admin_ui/router.rs b/src/admin_ui/router.rs
new file mode 100644
index 0000000..36d8bc7
--- /dev/null
+++ b/src/admin_ui/router.rs
@@ -0,0 +1,109 @@
+//! Admin UI 路由配置
+
+use axum::{
+    Router,
+    body::Body,
+    http::{Response, StatusCode, Uri, header},
+    response::IntoResponse,
+    routing::get,
+};
+use rust_embed::Embed;
+
+/// 嵌入前端构建产物
+#[derive(Embed)]
+#[folder = "admin-ui/dist"]
+struct Asset;
+
+/// 创建 Admin UI 路由
+pub fn create_admin_ui_router() -> Router {
+    Router::new()
+        .route("/", get(index_handler))
+        .route("/{*file}", get(static_handler))
+}
+
+/// 处理首页请求
+async fn index_handler() -> impl IntoResponse {
+    serve_index()
+}
+
+/// 处理静态文件请求
+async fn static_handler(uri: Uri) -> impl IntoResponse {
+    let path = uri.path().trim_start_matches('/');
+
+    // 安全检查：拒绝包含 .. 的路径
+    if path.contains("..") {
+        return Response::builder()
+            .status(StatusCode::BAD_REQUEST)
+            .body(Body::from("Invalid path"))
+            .expect("Failed to build response");
+    }
+
+    // 尝试获取请求的文件
+    if let Some(content) = Asset::get(path) {
+        let mime = mime_guess::from_path(path)
+            .first_or_octet_stream()
+            .to_string();
+
+        // 根据文件类型设置不同的缓存策略
+        let cache_control = get_cache_control(path);
+
+        return Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, mime)
+            .header(header::CACHE_CONTROL, cache_control)
+            .body(Body::from(content.data.into_owned()))
+            .expect("Failed to build response");
+    }
+
+    // SPA fallback: 如果文件不存在且不是资源文件，返回 index.html
+    if !is_asset_path(path) {
+        return serve_index();
+    }
+
+    // 404
+    Response::builder()
+        .status(StatusCode::NOT_FOUND)
+        .body(Body::from("Not found"))
+        .expect("Failed to build response")
+}
+
+/// 提供 index.html
+fn serve_index() -> Response<Body> {
+    match Asset::get("index.html") {
+        Some(content) => Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
+            .header(header::CACHE_CONTROL, "no-cache")
+            .body(Body::from(content.data.into_owned()))
+            .expect("Failed to build response"),
+        None => Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body(Body::from(
+                "Admin UI not built. Run 'pnpm build' in admin-ui directory.",
+            ))
+            .expect("Failed to build response"),
+    }
+}
+
+/// 根据文件类型返回合适的缓存策略
+fn get_cache_control(path: &str) -> &'static str {
+    if path.ends_with(".html") {
+        // HTML 文件不缓存，确保用户获取最新版本
+        "no-cache"
+    } else if path.starts_with("assets/") {
+        // assets/ 目录下的文件带有内容哈希，可以长期缓存
+        "public, max-age=31536000, immutable"
+    } else {
+        // 其他文件（如 favicon）使用较短的缓存
+        "public, max-age=3600"
+    }
+}
+
+/// 判断是否为资源文件路径（有扩展名的文件）
+fn is_asset_path(path: &str) -> bool {
+    // 检查最后一个路径段是否包含扩展名
+    path.rsplit('/')
+        .next()
+        .map(|filename| filename.contains('.'))
+        .unwrap_or(false)
+}
diff --git a/src/anthropic/compressor.rs b/src/anthropic/compressor.rs
new file mode 100644
index 0000000..c8b0869
--- /dev/null
+++ b/src/anthropic/compressor.rs
@@ -0,0 +1,1063 @@
+//! 输入压缩管道
+//!
+//! 在协议转换完成后、发送到上游前，对 `ConversationState` 执行多层压缩，
+//! 以规避 Kiro 上游请求体大小限制（实测约 5MiB 左右会触发 400）。
+//!
+//! 压缩顺序（低风险 → 高风险）：
+//! 1. 空白压缩
+//! 2. thinking 块丢弃/截断
+//! 3. tool_result 智能截断
+//! 4. tool_use input 截断
+//! 5. 历史截断
+
+use crate::kiro::model::requests::conversation::{ConversationState, Message};
+use crate::model::config::CompressionConfig;
+
+/// 压缩统计信息
+#[derive(Debug, Default)]
+pub struct CompressionStats {
+    pub whitespace_saved: usize,
+    pub thinking_saved: usize,
+    pub tool_result_saved: usize,
+    pub tool_use_input_saved: usize,
+    pub history_turns_removed: usize,
+    pub history_bytes_saved: usize,
+}
+
+impl CompressionStats {
+    /// 总节省字节数
+    pub fn total_saved(&self) -> usize {
+        self.whitespace_saved
+            + self.thinking_saved
+            + self.tool_result_saved
+            + self.tool_use_input_saved
+            + self.history_bytes_saved
+    }
+}
+
+/// 压缩管道入口
+///
+/// 按顺序执行各层压缩，返回统计信息。
+pub fn compress(state: &mut ConversationState, config: &CompressionConfig) -> CompressionStats {
+    let mut stats = CompressionStats::default();
+
+    if !config.enabled {
+        return stats;
+    }
+
+    // 1. 空白压缩
+    if config.whitespace_compression {
+        stats.whitespace_saved = compress_whitespace_pass(state);
+    }
+
+    // 2. thinking 丢弃/截断
+    if config.thinking_strategy != "keep" {
+        stats.thinking_saved = compress_thinking_pass(state, &config.thinking_strategy);
+    }
+
+    // 3. tool_result 智能截断
+    if config.tool_result_max_chars > 0 {
+        stats.tool_result_saved = compress_tool_results_pass(
+            state,
+            config.tool_result_max_chars,
+            config.tool_result_head_lines,
+            config.tool_result_tail_lines,
+        );
+    }
+
+    // 4. tool_use input 截断
+    if config.tool_use_input_max_chars > 0 {
+        stats.tool_use_input_saved =
+            compress_tool_use_inputs_pass(state, config.tool_use_input_max_chars);
+    }
+
+    // 5. 历史截断（最后手段）
+    if config.max_history_turns > 0 || config.max_history_chars > 0 {
+        let (turns, bytes) =
+            compress_history_pass(state, config.max_history_turns, config.max_history_chars);
+        stats.history_turns_removed = turns;
+        stats.history_bytes_saved = bytes;
+    }
+
+    // 历史截断会破坏 tool_use(tool_uses) 与 tool_result(tool_results) 的跨消息配对：
+    // assistant(tool_use) → user(tool_result)。
+    // 若留下孤立 tool_use/tool_result，上游会返回 400 "Improperly formed request"。
+    let (removed_tool_uses, removed_tool_results) = repair_tool_pairing_pass(state);
+    if removed_tool_uses > 0 || removed_tool_results > 0 {
+        tracing::debug!(
+            removed_tool_uses,
+            removed_tool_results,
+            "压缩后已修复 tool_use/tool_result 配对"
+        );
+    }
+
+    stats
+}
+
+// ============ 空白压缩 ============
+
+/// 空白压缩：连续空行(3+)→单空行，行尾空格移除，保留行首缩进
+fn compress_whitespace(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let mut consecutive_empty = 0u32;
+
+    for line in text.split('\n') {
+        let trimmed_end = line.trim_end();
+
+        if trimmed_end.is_empty() {
+            consecutive_empty += 1;
+            if consecutive_empty <= 2 && !result.is_empty() {
+                result.push('\n');
+            }
+        } else {
+            consecutive_empty = 0;
+            if !result.is_empty() {
+                result.push('\n');
+            }
+            result.push_str(trimmed_end);
+        }
+    }
+
+    result
+}
+
+/// 对 ConversationState 中所有文本字段执行空白压缩
+fn compress_whitespace_pass(state: &mut ConversationState) -> usize {
+    let mut saved = 0usize;
+
+    for msg in &mut state.history {
+        match msg {
+            Message::User(user_msg) => {
+                saved += compress_string_field(&mut user_msg.user_input_message.content);
+            }
+            Message::Assistant(assistant_msg) => {
+                saved +=
+                    compress_string_field(&mut assistant_msg.assistant_response_message.content);
+            }
+        }
+    }
+
+    saved += compress_string_field(&mut state.current_message.user_input_message.content);
+    saved
+}
+
+/// 压缩单个字符串字段，返回节省的字节数
+///
+/// 跳过仅为空格占位符 " " 的字段（Kiro API 要求 content 不能为空，
+/// converter 使用 " " 作为占位符）
+fn compress_string_field(field: &mut String) -> usize {
+    if field == " " {
+        return 0;
+    }
+    let original_len = field.len();
+    let compressed = compress_whitespace(field);
+    if compressed.len() < original_len {
+        let saved = original_len - compressed.len();
+        *field = compressed;
+        saved
+    } else {
+        0
+    }
+}
+
+// ============ thinking 压缩 ============
+
+/// 处理 history 中 assistant 消息的 `<thinking>...</thinking>` 块
+fn compress_thinking_pass(state: &mut ConversationState, strategy: &str) -> usize {
+    let mut saved = 0usize;
+
+    for msg in &mut state.history {
+        if let Message::Assistant(assistant_msg) = msg {
+            let content = &mut assistant_msg.assistant_response_message.content;
+            let original_len = content.len();
+
+            match strategy {
+                "discard" => *content = remove_thinking_blocks(content),
+                "truncate" => *content = truncate_thinking_blocks(content, 500),
+                _ => {}
+            }
+
+            if content.len() < original_len {
+                saved += original_len - content.len();
+            }
+        }
+    }
+
+    saved
+}
+
+/// 移除所有 `<thinking>...</thinking>` 块
+fn remove_thinking_blocks(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let mut remaining = text;
+
+    while let Some(start) = remaining.find("<thinking>") {
+        result.push_str(&remaining[..start]);
+        if let Some(end) = remaining[start..].find("</thinking>") {
+            remaining = &remaining[start + end + "</thinking>".len()..];
+        } else {
+            remaining = "";
+        }
+    }
+    result.push_str(remaining);
+    result
+}
+
+/// 截断 `<thinking>...</thinking>` 块内容，保留前 N 个字符
+fn truncate_thinking_blocks(text: &str, max_chars: usize) -> String {
+    let mut result = String::with_capacity(text.len());
+    let mut remaining = text;
+
+    while let Some(start) = remaining.find("<thinking>") {
+        result.push_str(&remaining[..start]);
+        let after_tag = &remaining[start + "<thinking>".len()..];
+
+        if let Some(end) = after_tag.find("</thinking>") {
+            let thinking_content = &after_tag[..end];
+            let truncated = safe_char_truncate(thinking_content, max_chars);
+            result.push_str("<thinking>");
+            result.push_str(truncated);
+            if truncated.len() < thinking_content.len() {
+                result.push_str("...[truncated]");
+            }
+            result.push_str("</thinking>");
+            remaining = &after_tag[end + "</thinking>".len()..];
+        } else {
+            let truncated = safe_char_truncate(after_tag, max_chars);
+            result.push_str("<thinking>");
+            result.push_str(truncated);
+            result.push_str("...[truncated]</thinking>");
+            remaining = "";
+        }
+    }
+    result.push_str(remaining);
+    result
+}
+
+// ============ tool_result 智能截断 ============
+
+/// 按行智能截断，保留头尾行
+fn smart_truncate_by_lines(
+    text: &str,
+    max_chars: usize,
+    head_lines: usize,
+    tail_lines: usize,
+) -> (String, usize) {
+    let char_count = text.chars().count();
+    if char_count <= max_chars {
+        return (text.to_string(), 0);
+    }
+
+    let lines: Vec<&str> = text.lines().collect();
+    let total_lines = lines.len();
+
+    if total_lines <= head_lines + tail_lines {
+        let half = max_chars / 2;
+        let head = safe_char_truncate(text, half);
+        let tail_chars = max_chars.saturating_sub(head.chars().count());
+        let tail_start = text
+            .char_indices()
+            .rev()
+            .nth(tail_chars.saturating_sub(1))
+            .map(|(i, _)| i)
+            .unwrap_or(0);
+        let tail = &text[tail_start..];
+        let omitted = char_count.saturating_sub(head.chars().count() + tail.chars().count());
+        let result = format!("{}\n... [{} chars omitted] ...\n{}", head, omitted, tail);
+        let saved = text.len().saturating_sub(result.len());
+        return (result, saved);
+    }
+
+    let head_part: String = lines[..head_lines].join("\n");
+    let tail_part: String = lines[total_lines - tail_lines..].join("\n");
+    let omitted_lines = total_lines - head_lines - tail_lines;
+    let omitted_chars =
+        char_count.saturating_sub(head_part.chars().count() + tail_part.chars().count());
+
+    let mut result = format!(
+        "{}\n... [{} lines omitted ({} chars)] ...\n{}",
+        head_part, omitted_lines, omitted_chars, tail_part
+    );
+
+    // 硬截断兜底：确保结果不超过 max_chars
+    if result.chars().count() > max_chars {
+        let truncated = safe_char_truncate(&result, max_chars);
+        result = truncated.to_string();
+    }
+
+    let saved = text.len().saturating_sub(result.len());
+    (result, saved)
+}
+
+/// 遍历所有 tool_result 的 text 字段，执行智能截断
+fn compress_tool_results_pass(
+    state: &mut ConversationState,
+    max_chars: usize,
+    head_lines: usize,
+    tail_lines: usize,
+) -> usize {
+    let mut saved = 0usize;
+
+    for msg in &mut state.history {
+        if let Message::User(user_msg) = msg {
+            for result in &mut user_msg
+                .user_input_message
+                .user_input_message_context
+                .tool_results
+            {
+                saved += truncate_tool_result_content(
+                    &mut result.content,
+                    max_chars,
+                    head_lines,
+                    tail_lines,
+                );
+            }
+        }
+    }
+
+    for result in &mut state
+        .current_message
+        .user_input_message
+        .user_input_message_context
+        .tool_results
+    {
+        saved +=
+            truncate_tool_result_content(&mut result.content, max_chars, head_lines, tail_lines);
+    }
+
+    saved
+}
+
+/// 截断单个 tool_result 的 content 数组中的 text 字段
+fn truncate_tool_result_content(
+    content: &mut [serde_json::Map<String, serde_json::Value>],
+    max_chars: usize,
+    head_lines: usize,
+    tail_lines: usize,
+) -> usize {
+    let mut saved = 0usize;
+
+    for map in content.iter_mut() {
+        if let Some(serde_json::Value::String(text)) = map.get_mut("text")
+            && text.chars().count() > max_chars
+        {
+            let (truncated, s) = smart_truncate_by_lines(text, max_chars, head_lines, tail_lines);
+            saved += s;
+            *text = truncated;
+        }
+    }
+
+    saved
+}
+
+// ============ tool_use input 截断 ============
+
+/// 遍历 history 中 assistant 消息的 tool_use input，截断大字符串字段
+fn compress_tool_use_inputs_pass(state: &mut ConversationState, max_chars: usize) -> usize {
+    let mut saved = 0usize;
+
+    for msg in &mut state.history {
+        if let Message::Assistant(assistant_msg) = msg
+            && let Some(ref mut tool_uses) = assistant_msg.assistant_response_message.tool_uses
+        {
+            for tool_use in tool_uses.iter_mut() {
+                let serialized = serde_json::to_string(&tool_use.input).unwrap_or_default();
+                if serialized.chars().count() > max_chars {
+                    saved += truncate_json_value_strings(&mut tool_use.input, max_chars);
+                }
+            }
+        }
+    }
+
+    saved
+}
+
+/// 递归截断 JSON 值中的大字符串
+fn truncate_json_value_strings(value: &mut serde_json::Value, max_chars: usize) -> usize {
+    let mut saved = 0usize;
+
+    match value {
+        serde_json::Value::String(s) => {
+            let original_char_count = s.chars().count();
+            if original_char_count > max_chars {
+                let original_len = s.len();
+                let truncated = safe_char_truncate(s, max_chars).to_string();
+                let omitted_chars = original_char_count.saturating_sub(max_chars);
+
+                // 仅当“带标记版本”确实更短时才附加标记，避免在边界场景（仅略超阈值）
+                // 反而把字符串变长，导致压缩失效。
+                let with_marker = format!(
+                    "{}...[truncated {} chars]",
+                    truncated.as_str(),
+                    omitted_chars
+                );
+                let new_value = if with_marker.len() < original_len {
+                    with_marker
+                } else {
+                    truncated
+                };
+
+                saved += original_len.saturating_sub(new_value.len());
+                *s = new_value;
+            }
+        }
+        serde_json::Value::Object(map) => {
+            for (_, v) in map.iter_mut() {
+                saved += truncate_json_value_strings(v, max_chars);
+            }
+        }
+        serde_json::Value::Array(arr) => {
+            for v in arr.iter_mut() {
+                saved += truncate_json_value_strings(v, max_chars);
+            }
+        }
+        _ => {}
+    }
+
+    saved
+}
+
+// ============ 历史截断 ============
+
+/// 历史截断：保留前 2 条（系统消息对），从前往后成对移除
+///
+/// 返回 (移除的轮数, 移除的字节数)
+fn compress_history_pass(
+    state: &mut ConversationState,
+    max_turns: usize,
+    max_chars: usize,
+) -> (usize, usize) {
+    let mut removed = 0usize;
+    let mut bytes_saved = 0usize;
+    let preserve_count = 2;
+
+    /// 计算一条消息的字节数
+    fn msg_bytes(msg: &Message) -> usize {
+        match msg {
+            Message::User(u) => u.user_input_message.content.len(),
+            Message::Assistant(a) => a.assistant_response_message.content.len(),
+        }
+    }
+
+    // 按轮数截断
+    if max_turns > 0 {
+        let max_messages = preserve_count + max_turns * 2;
+        while state.history.len() > max_messages && state.history.len() > preserve_count + 2 {
+            bytes_saved += msg_bytes(&state.history[preserve_count]);
+            state.history.remove(preserve_count);
+            bytes_saved += msg_bytes(&state.history[preserve_count]);
+            state.history.remove(preserve_count);
+            removed += 1;
+        }
+    }
+
+    // 按字符数截断
+    if max_chars > 0 {
+        loop {
+            let total_chars: usize = state
+                .history
+                .iter()
+                .map(|msg| match msg {
+                    Message::User(u) => u.user_input_message.content.chars().count(),
+                    Message::Assistant(a) => a.assistant_response_message.content.chars().count(),
+                })
+                .sum();
+
+            if total_chars <= max_chars || state.history.len() <= preserve_count + 2 {
+                break;
+            }
+
+            bytes_saved += msg_bytes(&state.history[preserve_count]);
+            state.history.remove(preserve_count);
+            bytes_saved += msg_bytes(&state.history[preserve_count]);
+            state.history.remove(preserve_count);
+            removed += 1;
+        }
+    }
+
+    (removed, bytes_saved)
+}
+
+/// 修复 tool_use/tool_result 配对（压缩后）。
+///
+/// 目标：
+/// - 移除 history/current 中孤立的 tool_result（其 tool_use_id 在 history 的 tool_use 中不存在）
+/// - 移除 history 中孤立的 tool_use（其 tool_use_id 在 history/current 的 tool_result 中不存在）
+///
+/// 返回 (移除的 tool_use 数, 移除的 tool_result 数)。
+fn repair_tool_pairing_pass(state: &mut ConversationState) -> (usize, usize) {
+    use std::collections::HashSet;
+
+    // 1) 收集 history 内所有 tool_use_id（上游通常要求 tool_result 必须能在历史 tool_use 中找到）
+    let mut tool_use_ids: HashSet<String> = HashSet::new();
+    for msg in &state.history {
+        if let Message::Assistant(a) = msg
+            && let Some(ref tool_uses) = a.assistant_response_message.tool_uses
+        {
+            for tu in tool_uses {
+                tool_use_ids.insert(tu.tool_use_id.clone());
+            }
+        }
+    }
+
+    // 2) 移除 history/current 中孤立 tool_result（没有对应 tool_use）
+    let mut removed_tool_results = 0usize;
+
+    for msg in &mut state.history {
+        if let Message::User(u) = msg {
+            let results = &mut u.user_input_message.user_input_message_context.tool_results;
+            let before = results.len();
+            results.retain(|tr| tool_use_ids.contains(&tr.tool_use_id));
+            removed_tool_results += before - results.len();
+        }
+    }
+
+    {
+        let results = &mut state
+            .current_message
+            .user_input_message
+            .user_input_message_context
+            .tool_results;
+        let before = results.len();
+        results.retain(|tr| tool_use_ids.contains(&tr.tool_use_id));
+        removed_tool_results += before - results.len();
+    }
+
+    // 3) 收集 history/current 内所有 tool_result 的 tool_use_id
+    let mut tool_result_ids: HashSet<String> = HashSet::new();
+    for msg in &state.history {
+        if let Message::User(u) = msg {
+            for tr in &u.user_input_message.user_input_message_context.tool_results {
+                tool_result_ids.insert(tr.tool_use_id.clone());
+            }
+        }
+    }
+    for tr in &state
+        .current_message
+        .user_input_message
+        .user_input_message_context
+        .tool_results
+    {
+        tool_result_ids.insert(tr.tool_use_id.clone());
+    }
+
+    // 4) 移除 history 内孤立 tool_use（没有对应 tool_result）
+    let mut removed_tool_uses = 0usize;
+    for msg in &mut state.history {
+        if let Message::Assistant(a) = msg
+            && let Some(ref mut tool_uses) = a.assistant_response_message.tool_uses
+        {
+            let before = tool_uses.len();
+            tool_uses.retain(|tu| tool_result_ids.contains(&tu.tool_use_id));
+            removed_tool_uses += before - tool_uses.len();
+
+            if tool_uses.is_empty() {
+                a.assistant_response_message.tool_uses = None;
+            }
+        }
+    }
+
+    (removed_tool_uses, removed_tool_results)
+}
+
+// ============ 超长消息内容截断 ============
+
+/// 截断超长的用户消息内容（history user messages 和 current_message）
+///
+/// 这是最后手段的压缩层，仅在自适应二次压缩中使用。
+/// 截断策略：保留头部内容，尾部截断并附加省略标记。
+///
+/// 返回节省的字节数。
+pub fn compress_long_messages_pass(state: &mut ConversationState, max_chars: usize) -> usize {
+    if max_chars == 0 {
+        return 0;
+    }
+
+    let mut saved = 0usize;
+
+    // 遍历 history 中所有 User 消息
+    for msg in &mut state.history {
+        if let Message::User(user_msg) = msg {
+            saved += truncate_long_content(&mut user_msg.user_input_message.content, max_chars);
+        }
+    }
+
+    // 处理 current_message
+    saved += truncate_long_content(
+        &mut state.current_message.user_input_message.content,
+        max_chars,
+    );
+
+    saved
+}
+
+/// 截断单个 content 字段，返回节省的字节数
+///
+/// 跳过仅为空格占位符 " " 的字段（与 compress_string_field 一致）
+fn truncate_long_content(field: &mut String, max_chars: usize) -> usize {
+    if field == " " {
+        return 0;
+    }
+    let char_count = field.chars().count();
+    if char_count <= max_chars {
+        return 0;
+    }
+
+    let original_len = field.len();
+    let truncated = safe_char_truncate(field, max_chars);
+    let omitted = char_count - max_chars;
+    *field = format!(
+        "{}\n...[content truncated, {} chars omitted]",
+        truncated, omitted
+    );
+    original_len.saturating_sub(field.len())
+}
+
+// ============ 工具函数 ============
+
+/// 安全 UTF-8 字符截断
+fn safe_char_truncate(text: &str, max_chars: usize) -> &str {
+    match text.char_indices().nth(max_chars) {
+        Some((idx, _)) => &text[..idx],
+        None => text,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kiro::model::requests::conversation::*;
+    use crate::kiro::model::requests::tool::{ToolResult, ToolUseEntry};
+    use crate::model::config::CompressionConfig;
+
+    fn make_simple_state(history_content: Vec<(&str, &str)>, current: &str) -> ConversationState {
+        let mut history = Vec::new();
+        for (user, assistant) in history_content {
+            history.push(Message::User(HistoryUserMessage::new(
+                user,
+                "claude-sonnet-4.5",
+            )));
+            history.push(Message::Assistant(HistoryAssistantMessage::new(assistant)));
+        }
+        ConversationState::new("test-conv")
+            .with_current_message(CurrentMessage::new(UserInputMessage::new(
+                current,
+                "claude-sonnet-4.5",
+            )))
+            .with_history(history)
+    }
+
+    #[test]
+    fn test_compress_whitespace_consecutive_empty_lines() {
+        let input = "line1\n\n\n\n\nline2";
+        let result = compress_whitespace(input);
+        // 5 个空行 → 保留最多 2 个（即 line1 + 2 个 \n + line2）
+        assert_eq!(result, "line1\n\n\nline2");
+    }
+
+    #[test]
+    fn test_compress_whitespace_trailing_spaces() {
+        let input = "hello   \nworld  ";
+        let result = compress_whitespace(input);
+        assert_eq!(result, "hello\nworld");
+    }
+
+    #[test]
+    fn test_compress_whitespace_preserves_indentation() {
+        let input = "    indented\n        more indented";
+        let result = compress_whitespace(input);
+        assert_eq!(result, "    indented\n        more indented");
+    }
+
+    #[test]
+    fn test_smart_truncate_short_content_unchanged() {
+        let input = "short text";
+        let (result, saved) = smart_truncate_by_lines(input, 100, 5, 3);
+        assert_eq!(result, input);
+        assert_eq!(saved, 0);
+    }
+
+    #[test]
+    fn test_smart_truncate_preserves_head_tail() {
+        let lines: Vec<String> = (0..200).map(|i| format!("line {}", i)).collect();
+        let input = lines.join("\n");
+        let (result, _saved) = smart_truncate_by_lines(&input, 100, 3, 2);
+        assert!(result.starts_with("line 0\nline 1\nline 2\n"));
+        assert!(result.ends_with("line 198\nline 199"));
+        assert!(result.contains("lines omitted"));
+    }
+
+    #[test]
+    fn test_safe_char_truncate_utf8() {
+        let input = "你好世界abcd";
+        let result = safe_char_truncate(input, 4);
+        assert_eq!(result, "你好世界");
+    }
+
+    #[test]
+    fn test_thinking_discard() {
+        let mut state = make_simple_state(
+            vec![(
+                "hi",
+                "<thinking>long thinking content here</thinking>\n\nactual response",
+            )],
+            "next",
+        );
+        let config = CompressionConfig {
+            thinking_strategy: "discard".to_string(),
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert!(stats.thinking_saved > 0);
+        // assistant content 不应包含 thinking 标签
+        if let Message::Assistant(a) = &state.history[1] {
+            assert!(!a.assistant_response_message.content.contains("<thinking>"));
+            assert!(
+                a.assistant_response_message
+                    .content
+                    .contains("actual response")
+            );
+        }
+    }
+
+    #[test]
+    fn test_thinking_truncate() {
+        let long_thinking = "a".repeat(1000);
+        let content = format!("<thinking>{}</thinking>\n\nresponse", long_thinking);
+        let mut state = make_simple_state(vec![("hi", &content)], "next");
+        let config = CompressionConfig {
+            thinking_strategy: "truncate".to_string(),
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert!(stats.thinking_saved > 0);
+        if let Message::Assistant(a) = &state.history[1] {
+            assert!(a.assistant_response_message.content.contains("<thinking>"));
+            assert!(a.assistant_response_message.content.contains("[truncated]"));
+        }
+    }
+
+    #[test]
+    fn test_thinking_keep() {
+        let content = "<thinking>keep me</thinking>\n\nresponse";
+        let mut state = make_simple_state(vec![("hi", content)], "next");
+        let config = CompressionConfig {
+            thinking_strategy: "keep".to_string(),
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert_eq!(stats.thinking_saved, 0);
+        if let Message::Assistant(a) = &state.history[1] {
+            assert!(
+                a.assistant_response_message
+                    .content
+                    .contains("<thinking>keep me</thinking>")
+            );
+        }
+    }
+
+    #[test]
+    fn test_tool_result_truncation() {
+        let long_text = "x\n".repeat(500);
+        let mut state = ConversationState::new("test")
+            .with_current_message(CurrentMessage::new(
+                UserInputMessage::new("msg", "claude-sonnet-4.5").with_context(
+                    UserInputMessageContext::new()
+                        .with_tool_results(vec![ToolResult::success("t1", &long_text)]),
+                ),
+            ))
+            .with_history(Vec::new());
+
+        let config = CompressionConfig {
+            tool_result_max_chars: 100,
+            tool_result_head_lines: 3,
+            tool_result_tail_lines: 2,
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert!(stats.tool_result_saved > 0);
+    }
+
+    #[test]
+    fn test_tool_use_input_truncation() {
+        let long_input = serde_json::json!({
+            "content": "a".repeat(10000)
+        });
+        let mut assistant_msg = AssistantMessage::new("using tool");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("t1", "write").with_input(long_input),
+        ]);
+
+        // tool_use 必须有对应的 tool_result（Kiro 要求严格配对），否则会被压缩后的修复逻辑移除。
+        let current = UserInputMessage::new(" ", "claude-sonnet-4.5").with_context(
+            UserInputMessageContext::new().with_tool_results(vec![ToolResult::success("t1", "ok")]),
+        );
+        let mut state = ConversationState::new("test")
+            .with_current_message(CurrentMessage::new(current))
+            .with_history(vec![
+                Message::User(HistoryUserMessage::new("do it", "claude-sonnet-4.5")),
+                Message::Assistant(HistoryAssistantMessage {
+                    assistant_response_message: assistant_msg,
+                }),
+            ]);
+
+        let config = CompressionConfig {
+            tool_use_input_max_chars: 100,
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert!(stats.tool_use_input_saved > 0);
+    }
+
+    #[test]
+    fn test_tool_use_input_truncation_does_not_expand_near_threshold() {
+        let long_input = serde_json::json!({
+            "content": "a".repeat(101)
+        });
+        let mut assistant_msg = AssistantMessage::new("using tool");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("t1", "write").with_input(long_input),
+        ]);
+
+        let current = UserInputMessage::new(" ", "claude-sonnet-4.5").with_context(
+            UserInputMessageContext::new().with_tool_results(vec![ToolResult::success("t1", "ok")]),
+        );
+        let mut state = ConversationState::new("test")
+            .with_current_message(CurrentMessage::new(current))
+            .with_history(vec![
+                Message::User(HistoryUserMessage::new("do it", "claude-sonnet-4.5")),
+                Message::Assistant(HistoryAssistantMessage {
+                    assistant_response_message: assistant_msg,
+                }),
+            ]);
+
+        let config = CompressionConfig {
+            tool_use_input_max_chars: 100,
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert!(stats.tool_use_input_saved > 0);
+
+        if let Message::Assistant(a) = &state.history[1]
+            && let Some(tool_uses) = &a.assistant_response_message.tool_uses
+            && let Some(content) = tool_uses[0].input["content"].as_str()
+        {
+            // 101 字符略超阈值时，不应追加标记导致更长；应退化为纯截断
+            let expected = "a".repeat(100);
+            assert_eq!(content, expected.as_str());
+        } else {
+            panic!("tool_use input content should exist");
+        }
+    }
+
+    #[test]
+    fn test_tool_use_input_truncation_unicode_under_limit_is_unchanged() {
+        let original = "你".repeat(60); // 60 chars, but 180 bytes
+        let long_input = serde_json::json!({
+            "content": original.clone()
+        });
+        let mut assistant_msg = AssistantMessage::new("using tool");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("t1", "write").with_input(long_input),
+        ]);
+
+        let current = UserInputMessage::new(" ", "claude-sonnet-4.5").with_context(
+            UserInputMessageContext::new().with_tool_results(vec![ToolResult::success("t1", "ok")]),
+        );
+        let mut state = ConversationState::new("test")
+            .with_current_message(CurrentMessage::new(current))
+            .with_history(vec![
+                Message::User(HistoryUserMessage::new("do it", "claude-sonnet-4.5")),
+                Message::Assistant(HistoryAssistantMessage {
+                    assistant_response_message: assistant_msg,
+                }),
+            ]);
+
+        let config = CompressionConfig {
+            tool_use_input_max_chars: 100,
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert_eq!(stats.tool_use_input_saved, 0);
+
+        if let Message::Assistant(a) = &state.history[1]
+            && let Some(tool_uses) = &a.assistant_response_message.tool_uses
+            && let Some(content) = tool_uses[0].input["content"].as_str()
+        {
+            assert_eq!(content, original.as_str());
+        } else {
+            panic!("tool_use input content should exist");
+        }
+    }
+
+    #[test]
+    fn test_history_truncation_preserves_system_pair() {
+        // 创建 system pair (2) + 5 轮对话 (10) = 12 条消息
+        let mut history_content = vec![("system prompt", "I will follow these instructions.")];
+        for _i in 0..5 {
+            history_content.push(("user msg", "assistant msg"));
+        }
+        let mut state = make_simple_state(history_content, "current");
+
+        let config = CompressionConfig {
+            max_history_turns: 2,
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert!(stats.history_turns_removed > 0);
+        // 应保留 system pair (2) + 2 轮 (4) = 6 条
+        assert_eq!(state.history.len(), 6);
+        // 第一对应该是 system pair
+        if let Message::User(u) = &state.history[0] {
+            assert!(u.user_input_message.content.contains("system prompt"));
+        }
+    }
+
+    #[test]
+    fn test_history_truncation_repairs_tool_pairing() {
+        // 构造典型 tool_use → tool_result 跨消息链路：
+        // assistant(tool_use) 紧跟 user(tool_result)。
+        // 当按 user+assistant 成对从前往后截断时，容易删掉 tool_use 而保留 tool_result。
+        let tool_use_id = "tooluse_1";
+
+        let system_user = Message::User(HistoryUserMessage::new("system", "claude-sonnet-4.5"));
+        let system_assistant = Message::Assistant(HistoryAssistantMessage::new(
+            "I will follow these instructions.",
+        ));
+
+        let user1 = Message::User(HistoryUserMessage::new("do something", "claude-sonnet-4.5"));
+
+        let tool_use =
+            ToolUseEntry::new(tool_use_id, "Read").with_input(serde_json::json!({"path": "a.txt"}));
+        let assistant1 = Message::Assistant(HistoryAssistantMessage {
+            assistant_response_message: AssistantMessage::new(" ").with_tool_uses(vec![tool_use]),
+        });
+
+        let tool_result_ctx = UserInputMessageContext::new()
+            .with_tool_results(vec![ToolResult::success(tool_use_id, "ok")]);
+        let user2 = Message::User(HistoryUserMessage {
+            user_input_message: UserMessage::new(" ", "claude-sonnet-4.5")
+                .with_context(tool_result_ctx),
+        });
+
+        let assistant2 = Message::Assistant(HistoryAssistantMessage::new("done"));
+
+        let mut state = ConversationState::new("test")
+            .with_current_message(CurrentMessage::new(UserInputMessage::new(
+                "next",
+                "claude-sonnet-4.5",
+            )))
+            .with_history(vec![
+                system_user,
+                system_assistant,
+                user1,
+                assistant1,
+                user2,
+                assistant2,
+            ]);
+
+        // 将历史限制到 1 轮（2+2=4 条），触发截断：会移除 user1+assistant1。
+        // 若不修复，user2 中的 tool_result 会变成 orphan，导致上游 400。
+        let config = CompressionConfig {
+            max_history_turns: 1,
+            max_history_chars: 0,
+            ..Default::default()
+        };
+
+        let _stats = compress(&mut state, &config);
+
+        // history 中不应存在 tool_result（因为对应 tool_use 已被截断移除）
+        for msg in &state.history {
+            if let Message::User(u) = msg {
+                assert!(
+                    u.user_input_message
+                        .user_input_message_context
+                        .tool_results
+                        .is_empty(),
+                    "history 中不应残留孤立 tool_result"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_compress_disabled_no_change() {
+        let content = "line1\n\n\n\n\nline2   ";
+        let mut state = make_simple_state(vec![("hi", content)], "next");
+        let original_content = content.to_string();
+
+        let config = CompressionConfig {
+            enabled: false,
+            ..Default::default()
+        };
+        let stats = compress(&mut state, &config);
+        assert_eq!(stats.total_saved(), 0);
+        assert_eq!(stats.history_turns_removed, 0);
+        // content 应保持不变
+        if let Message::Assistant(a) = &state.history[1] {
+            assert_eq!(a.assistant_response_message.content, original_content);
+        }
+    }
+
+    #[test]
+    fn test_compress_long_messages_truncates_current_message() {
+        let long_content = "a".repeat(20000);
+        let mut state = make_simple_state(vec![], &long_content);
+        let saved = compress_long_messages_pass(&mut state, 8192);
+        assert!(saved > 0);
+        let content = &state.current_message.user_input_message.content;
+        assert!(content.len() < long_content.len());
+        assert!(content.contains("[content truncated,"));
+        assert!(content.contains("chars omitted]"));
+        // 头部应保留
+        assert!(content.starts_with("aaaa"));
+    }
+
+    #[test]
+    fn test_compress_long_messages_truncates_history_user() {
+        let long_content = "b".repeat(20000);
+        let mut state = make_simple_state(vec![(&long_content, "short reply")], "current");
+        let saved = compress_long_messages_pass(&mut state, 8192);
+        assert!(saved > 0);
+        if let Message::User(u) = &state.history[0] {
+            assert!(u.user_input_message.content.len() < long_content.len());
+            assert!(u.user_input_message.content.contains("[content truncated,"));
+        } else {
+            panic!("expected User message");
+        }
+    }
+
+    #[test]
+    fn test_compress_long_messages_short_unchanged() {
+        let mut state = make_simple_state(vec![("short user", "short assistant")], "short current");
+        let saved = compress_long_messages_pass(&mut state, 8192);
+        assert_eq!(saved, 0);
+        assert_eq!(
+            state.current_message.user_input_message.content,
+            "short current"
+        );
+        if let Message::User(u) = &state.history[0] {
+            assert_eq!(u.user_input_message.content, "short user");
+        }
+    }
+
+    #[test]
+    fn test_compress_long_messages_skips_placeholder() {
+        let mut state = make_simple_state(vec![], " ");
+        let saved = compress_long_messages_pass(&mut state, 1);
+        assert_eq!(saved, 0);
+        assert_eq!(state.current_message.user_input_message.content, " ");
+    }
+
+    #[test]
+    fn test_compress_long_messages_zero_max_chars_noop() {
+        let long_content = "x".repeat(20000);
+        let mut state = make_simple_state(vec![], &long_content);
+        let saved = compress_long_messages_pass(&mut state, 0);
+        assert_eq!(saved, 0);
+        assert_eq!(
+            state.current_message.user_input_message.content,
+            long_content
+        );
+    }
+}
diff --git a/src/anthropic/converter.rs b/src/anthropic/converter.rs
new file mode 100644
index 0000000..b77f669
--- /dev/null
+++ b/src/anthropic/converter.rs
@@ -0,0 +1,2852 @@
+//! Anthropic → Kiro 协议转换器
+//!
+//! 负责将 Anthropic API 请求格式转换为 Kiro API 请求格式
+
+use uuid::Uuid;
+
+use crate::image::{process_gif_frames, process_image, process_image_to_format};
+use crate::kiro::model::requests::conversation::{
+    AssistantMessage, ConversationState, CurrentMessage, HistoryAssistantMessage,
+    HistoryUserMessage, KiroImage, Message, UserInputMessage, UserInputMessageContext, UserMessage,
+};
+use crate::kiro::model::requests::tool::{
+    InputSchema, Tool as KiroTool, ToolResult, ToolSpecification, ToolUseEntry,
+};
+
+use super::types::{ContentBlock, MessagesRequest, Tool as AnthropicTool};
+use crate::anthropic::compressor::CompressionStats;
+use crate::model::config::CompressionConfig;
+
+/// 规范化 JSON Schema，修复 MCP 工具定义中常见的类型问题
+///
+/// Claude Code / MCP 工具定义偶尔会出现 `required: null`、`properties: null` 等，
+/// 导致上游返回 400 "Improperly formed request"。
+fn normalize_json_schema(schema: serde_json::Value) -> serde_json::Value {
+    let serde_json::Value::Object(mut obj) = schema else {
+        return serde_json::json!({
+            "type": "object",
+            "properties": {},
+            "required": [],
+            "additionalProperties": true
+        });
+    };
+
+    // $schema（必须是非空字符串）
+    if obj
+        .get("$schema")
+        .and_then(|v| v.as_str())
+        .is_none_or(|s| s.is_empty())
+    {
+        obj.insert(
+            "$schema".to_string(),
+            serde_json::Value::String("http://json-schema.org/draft-07/schema#".to_string()),
+        );
+    }
+
+    // type（必须是字符串）
+    if obj
+        .get("type")
+        .and_then(|v| v.as_str())
+        .is_none_or(|s| s.is_empty())
+    {
+        obj.insert(
+            "type".to_string(),
+            serde_json::Value::String("object".to_string()),
+        );
+    }
+
+    // properties（必须是 object）
+    match obj.get("properties") {
+        Some(serde_json::Value::Object(_)) => {}
+        _ => {
+            obj.insert(
+                "properties".to_string(),
+                serde_json::Value::Object(serde_json::Map::new()),
+            );
+        }
+    }
+
+    // required（必须是 string 数组）
+    let required = match obj.remove("required") {
+        Some(serde_json::Value::Array(arr)) => serde_json::Value::Array(
+            arr.into_iter()
+                .filter_map(|v| v.as_str().map(|s| serde_json::Value::String(s.to_string())))
+                .collect(),
+        ),
+        _ => serde_json::Value::Array(Vec::new()),
+    };
+    obj.insert("required".to_string(), required);
+
+    // additionalProperties（允许 bool 或 object，其他按 true 处理）
+    match obj.get("additionalProperties") {
+        Some(serde_json::Value::Bool(_)) | Some(serde_json::Value::Object(_)) => {}
+        _ => {
+            obj.insert(
+                "additionalProperties".to_string(),
+                serde_json::Value::Bool(true),
+            );
+        }
+    }
+
+    serde_json::Value::Object(obj)
+}
+
+/// 追加到 Write 工具 description 末尾的内容
+const WRITE_TOOL_DESCRIPTION_SUFFIX: &str = "- IMPORTANT: If the content to write exceeds 150 lines, you MUST only write the first 50 lines using this tool, then use `Edit` tool to append the remaining content in chunks of no more than 50 lines each. If needed, leave a unique placeholder to help append content. Do NOT attempt to write all content at once.";
+
+/// 追加到 Edit 工具 description 末尾的内容
+const EDIT_TOOL_DESCRIPTION_SUFFIX: &str = "- IMPORTANT: If the `new_string` content exceeds 50 lines, you MUST split it into multiple Edit calls, each replacing no more than 50 lines at a time. If used to append content, leave a unique placeholder to help append content. On the final chunk, do NOT include the placeholder.";
+
+/// 追加到系统提示词的分块写入策略
+const SYSTEM_CHUNKED_POLICY: &str = "\
+When the Write or Edit tool has content size limits, always comply silently. \
+Never suggest bypassing these limits via alternative tools. \
+Never ask the user whether to switch approaches. \
+Complete all chunked operations without commentary.";
+
+/// Agentic 模型专用系统提示
+///
+/// 指导模型在 agentic 模式下的行为：持续工作、自主决策、减少确认
+const KIRO_AGENTIC_SYSTEM_PROMPT: &str = "\
+You are an autonomous coding agent. Follow these principles:\n\
+1. Work continuously until the task is fully complete.\n\
+2. Use tools proactively without asking for permission.\n\
+3. When encountering errors, debug and fix them autonomously.\n\
+4. Break complex tasks into steps and execute them sequentially.\n\
+5. Verify your work by reading files after writing them.\n\
+6. Never ask the user for confirmation mid-task — just proceed.\n\
+7. If a tool call fails, try alternative approaches before giving up.\n\
+8. Prefer making changes directly over explaining what you would do.";
+
+fn non_empty_content_or_space(content: String, has_non_text_payload: bool) -> String {
+    // Kiro 上游在部分场景下会拒绝空 content（例如仅 tool_result / 仅 image 的消息）。
+    // 使用最小占位符可保持语义，同时规避 400 Improperly formed request。
+    if has_non_text_payload && content.trim().is_empty() {
+        return ".".to_string();
+    }
+    content
+}
+
+/// 统计单个消息内容中的图片数量
+fn count_images_in_content(content: &serde_json::Value) -> usize {
+    match content {
+        serde_json::Value::Array(arr) => arr
+            .iter()
+            .filter(|item| item.get("type").and_then(|v| v.as_str()) == Some("image"))
+            .count(),
+        _ => 0,
+    }
+}
+
+/// 模型映射：将 Anthropic 模型名映射到 Kiro 模型 ID
+///
+/// 映射规则：
+/// - sonnet 且包含 4.6/4-6 → claude-sonnet-4.6，否则 → claude-sonnet-4.5
+/// - opus 且包含 4.5/4-5 → claude-opus-4.5，否则 → claude-opus-4.6
+/// - 所有 haiku → claude-haiku-4.5
+/// - `-agentic` 后缀会被剥离后再映射
+pub fn map_model(model: &str) -> Option<String> {
+    let model_lower = model.to_lowercase();
+    // 剥离 -agentic 后缀再做模型映射
+    let model_lower = model_lower.strip_suffix("-agentic").unwrap_or(&model_lower);
+
+    if model_lower.contains("sonnet") {
+        if model_lower.contains("4-6") || model_lower.contains("4.6") {
+            Some("claude-sonnet-4.6".to_string())
+        } else {
+            Some("claude-sonnet-4.5".to_string())
+        }
+    } else if model_lower.contains("opus") {
+        if model_lower.contains("4-5") || model_lower.contains("4.5") {
+            Some("claude-opus-4.5".to_string())
+        } else {
+            Some("claude-opus-4.6".to_string())
+        }
+    } else if model_lower.contains("haiku") {
+        Some("claude-haiku-4.5".to_string())
+    } else {
+        None
+    }
+}
+
+/// 判断模型名是否为 agentic 变体
+pub fn is_agentic_model(model: &str) -> bool {
+    model.to_lowercase().ends_with("-agentic")
+}
+
+/// 转换结果
+#[derive(Debug)]
+pub struct ConversionResult {
+    /// 转换后的 Kiro 请求
+    pub conversation_state: ConversationState,
+    /// 压缩统计信息（仅在启用压缩时有值）
+    pub compression_stats: Option<CompressionStats>,
+}
+
+/// 转换错误
+#[derive(Debug)]
+pub enum ConversionError {
+    UnsupportedModel(String),
+    EmptyMessages,
+    EmptyMessageContent,
+}
+
+impl std::fmt::Display for ConversionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ConversionError::UnsupportedModel(model) => write!(f, "模型不支持: {}", model),
+            ConversionError::EmptyMessages => write!(f, "消息列表为空"),
+            ConversionError::EmptyMessageContent => write!(f, "消息内容为空"),
+        }
+    }
+}
+
+impl std::error::Error for ConversionError {}
+
+/// 从 metadata.user_id 中提取 session UUID
+///
+/// user_id 格式: user_xxx_account__session_0b4445e1-f5be-49e1-87ce-62bbc28ad705
+/// 提取 session_ 后面的 UUID 作为 conversationId
+fn extract_session_id(user_id: &str) -> Option<String> {
+    // 查找 "session_" 后面的内容
+    if let Some(pos) = user_id.find("session_") {
+        let session_part = &user_id[pos + 8..]; // "session_" 长度为 8
+        // session_part 应该是 UUID 格式: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        // 验证是否是有效的 UUID 格式（36 字符，包含 4 个连字符）
+        if session_part.len() >= 36 {
+            let uuid_str = &session_part[..36];
+            // 简单验证 UUID 格式
+            if uuid_str.chars().filter(|c| *c == '-').count() == 4 {
+                return Some(uuid_str.to_string());
+            }
+        }
+    }
+    None
+}
+
+/// 收集历史消息中使用的所有工具名称（小写去重）
+///
+/// 返回去重后的工具名称列表，保留原始大小写（首次出现的形式），
+/// 但通过小写比较避免 `read` / `Read` 这类变体重复。
+fn collect_history_tool_names(history: &[Message]) -> Vec<String> {
+    let mut seen_lowercase = std::collections::HashSet::new();
+    let mut tool_names = Vec::new();
+
+    for msg in history {
+        if let Message::Assistant(assistant_msg) = msg
+            && let Some(ref tool_uses) = assistant_msg.assistant_response_message.tool_uses
+        {
+            for tool_use in tool_uses {
+                if seen_lowercase.insert(tool_use.name.to_lowercase()) {
+                    tool_names.push(tool_use.name.clone());
+                }
+            }
+        }
+    }
+
+    tool_names
+}
+
+/// 为历史中使用但不在 tools 列表中的工具创建占位符定义
+/// Kiro API 要求：历史消息中引用的工具必须在 currentMessage.tools 中有定义
+fn create_placeholder_tool(name: &str) -> KiroTool {
+    KiroTool {
+        tool_specification: ToolSpecification {
+            name: name.to_string(),
+            description: "Tool used in conversation history".to_string(),
+            input_schema: InputSchema::from_json(serde_json::json!({
+                "$schema": "http://json-schema.org/draft-07/schema#",
+                "type": "object",
+                "properties": {},
+                "required": [],
+                "additionalProperties": true
+            })),
+        },
+    }
+}
+
+/// 将 Anthropic 请求转换为 Kiro 请求
+pub fn convert_request(
+    req: &MessagesRequest,
+    compression_config: &CompressionConfig,
+) -> Result<ConversionResult, ConversionError> {
+    // 1. 映射模型
+    let model_id = map_model(&req.model)
+        .ok_or_else(|| ConversionError::UnsupportedModel(req.model.clone()))?;
+
+    // 2. 检查消息列表
+    if req.messages.is_empty() {
+        return Err(ConversionError::EmptyMessages);
+    }
+
+    // 2.5. 预处理 prefill：如果末尾是 assistant，静默丢弃并截断到最后一条 user
+    // 原因：Claude 4.x 已弃用 assistant prefill，Kiro API 也不支持
+    let messages: &[_] = if req
+        .messages
+        .last()
+        .map(|m| m.role != "user")
+        .unwrap_or(false)
+    {
+        tracing::info!("检测到末尾 assistant 消息（prefill），静默丢弃，回退到最后一条 user 消息");
+        let last_user_idx = req
+            .messages
+            .iter()
+            .rposition(|m| m.role == "user")
+            .ok_or(ConversionError::EmptyMessages)?;
+        &req.messages[..=last_user_idx]
+    } else {
+        &req.messages
+    };
+
+    // 2.6. 验证最后一条消息内容不为空
+    // 检查最后一条消息（经过 prefill 处理后）是否有有效内容
+    let last_message = messages.last().unwrap();
+    let has_valid_content = match &last_message.content {
+        serde_json::Value::String(s) => !s.trim().is_empty(),
+        serde_json::Value::Array(arr) => arr.iter().any(|item| {
+            if let Ok(block) = serde_json::from_value::<ContentBlock>(item.clone()) {
+                match block.block_type.as_str() {
+                    "text" => block.text.as_ref().is_some_and(|t| !t.trim().is_empty()),
+                    "image" | "tool_use" | "tool_result" => true,
+                    _ => false,
+                }
+            } else {
+                false
+            }
+        }),
+        _ => false,
+    };
+    if !has_valid_content {
+        tracing::warn!("最后一条消息内容为空（仅包含空白文本或无内容）");
+        return Err(ConversionError::EmptyMessageContent);
+    }
+
+    // 3. 生成会话 ID 和代理 ID
+    // 优先从 metadata.user_id 中提取 session UUID 作为 conversationId
+    let conversation_id = req
+        .metadata
+        .as_ref()
+        .and_then(|m| m.user_id.as_ref())
+        .and_then(|user_id| extract_session_id(user_id))
+        .unwrap_or_else(|| Uuid::new_v4().to_string());
+    let agent_continuation_id = Uuid::new_v4().to_string();
+
+    // 4. 确定触发类型
+    let chat_trigger_type = determine_chat_trigger_type(req);
+
+    // 4.5. 统计图片总数（用于决定压缩策略，基于截断后的 messages）
+    let total_image_count: usize = messages
+        .iter()
+        .map(|msg| count_images_in_content(&msg.content))
+        .sum();
+
+    // 5. 处理最后一条消息作为 current_message（经过 prefill 预处理，末尾必为 user）
+    let last_message = messages.last().unwrap();
+    let (text_content, images, tool_results) =
+        process_message_content(&last_message.content, compression_config, total_image_count)?;
+
+    // 6. 转换工具定义
+    let mut tools = convert_tools(&req.tools, compression_config.tool_description_max_chars);
+
+    // 7. 构建历史消息（需要先构建，以便收集历史中使用的工具）
+    let mut history = build_history(
+        req,
+        messages,
+        &model_id,
+        compression_config,
+        total_image_count,
+        is_agentic_model(&req.model),
+    )?;
+
+    // 8. 验证并过滤 tool_use/tool_result 配对
+    // 移除孤立的 tool_result（没有对应的 tool_use）
+    // 同时返回孤立的 tool_use_id 集合，用于后续清理
+    let (validated_tool_results, orphaned_tool_use_ids) =
+        validate_tool_pairing(&history, &tool_results);
+
+    // 9. 从历史中移除孤立的 tool_use（Kiro API 要求 tool_use 必须有对应的 tool_result）
+    remove_orphaned_tool_uses(&mut history, &orphaned_tool_use_ids);
+
+    // 10. 收集历史中使用的工具名称，为缺失的工具生成占位符定义
+    // Kiro API 要求：历史消息中引用的工具必须在 tools 列表中有定义
+    // 注意：Kiro 匹配工具名称时忽略大小写，所以这里也需要忽略大小写比较
+    let history_tool_names = collect_history_tool_names(&history);
+    let mut existing_tool_names: std::collections::HashSet<_> = tools
+        .iter()
+        .map(|t| t.tool_specification.name.to_lowercase())
+        .collect();
+
+    for tool_name in history_tool_names {
+        let lower = tool_name.to_lowercase();
+        if !existing_tool_names.contains(&lower) {
+            tools.push(create_placeholder_tool(&tool_name));
+            existing_tool_names.insert(lower);
+        }
+    }
+
+    // 10.5. 工具压缩：在所有工具（含 placeholder）就绪后执行
+    tools = super::tool_compression::compress_tools_if_needed(&tools);
+
+    // 11. 构建 UserInputMessageContext
+    let mut context = UserInputMessageContext::new();
+    if !tools.is_empty() {
+        context = context.with_tools(tools);
+    }
+    let has_tool_results = !validated_tool_results.is_empty();
+    if has_tool_results {
+        context = context.with_tool_results(validated_tool_results);
+    }
+
+    // 12. 构建当前消息
+    // 保留文本内容，即使有工具结果也不丢弃用户文本
+    let mut content =
+        non_empty_content_or_space(text_content, !images.is_empty() || has_tool_results);
+    // tool_result 可能在配对校验阶段被过滤，导致当前消息最终变成空字符串。
+    // 上游会拒绝空 content（400 Improperly formed request），因此这里做最终兜底。
+    if content.trim().is_empty() {
+        tracing::warn!("currentMessage content 为空，已使用占位符修复");
+        content = ".".to_string();
+    }
+
+    let mut user_input = UserInputMessage::new(content, &model_id)
+        .with_context(context)
+        .with_origin("AI_EDITOR");
+
+    if !images.is_empty() {
+        user_input = user_input.with_images(images);
+    }
+
+    let current_message = CurrentMessage::new(user_input);
+
+    // 13. 构建 ConversationState
+    let mut conversation_state = ConversationState::new(conversation_id)
+        .with_agent_continuation_id(agent_continuation_id)
+        .with_agent_task_type("vibe")
+        .with_chat_trigger_type(chat_trigger_type)
+        .with_current_message(current_message)
+        .with_history(history);
+
+    // 14. 执行输入压缩
+    let compression_stats = if compression_config.enabled {
+        let stats = super::compressor::compress(&mut conversation_state, compression_config);
+        if stats.total_saved() > 0 || stats.history_turns_removed > 0 {
+            Some(stats)
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    Ok(ConversionResult {
+        conversation_state,
+        compression_stats,
+    })
+}
+
+/// 确定聊天触发类型
+/// "AUTO" 模式可能会导致 400 Bad Request 错误
+fn determine_chat_trigger_type(_req: &MessagesRequest) -> String {
+    "MANUAL".to_string()
+}
+
+/// 处理消息内容，提取文本、图片和工具结果
+fn process_message_content(
+    content: &serde_json::Value,
+    compression_config: &CompressionConfig,
+    total_image_count: usize,
+) -> Result<(String, Vec<KiroImage>, Vec<ToolResult>), ConversionError> {
+    let mut text_parts = Vec::new();
+    let mut images = Vec::new();
+    let mut tool_results = Vec::new();
+
+    match content {
+        serde_json::Value::String(s) => {
+            text_parts.push(s.clone());
+        }
+        serde_json::Value::Array(arr) => {
+            for item in arr {
+                if let Ok(block) = serde_json::from_value::<ContentBlock>(item.clone()) {
+                    match block.block_type.as_str() {
+                        "text" => {
+                            if let Some(text) = block.text {
+                                text_parts.push(text);
+                            }
+                        }
+                        "image" => {
+                            if let Some(source) = block.source
+                                && let Some(format) = get_image_format(&source.media_type)
+                            {
+                                // GIF：抽帧为多张静态图，避免动图 base64 体积巨大导致上游 400
+                                if format.eq_ignore_ascii_case("gif") {
+                                    match process_gif_frames(
+                                        &source.data,
+                                        compression_config,
+                                        total_image_count,
+                                    ) {
+                                        Ok(gif) => {
+                                            let total_final_bytes: usize =
+                                                gif.frames.iter().map(|f| f.final_bytes_len).sum();
+                                            tracing::info!(
+                                                duration_ms = gif.duration_ms,
+                                                source_frames = gif.source_frames,
+                                                sampled_frames = gif.frames.len(),
+                                                sampling_interval_ms = gif.sampling_interval_ms,
+                                                output_format = gif.output_format,
+                                                original_bytes_len =
+                                                    gif.frames[0].original_bytes_len,
+                                                total_final_bytes = total_final_bytes,
+                                                "GIF 已抽帧并重编码"
+                                            );
+
+                                            for f in gif.frames {
+                                                images.push(KiroImage::from_base64(
+                                                    gif.output_format,
+                                                    f.data,
+                                                ));
+                                            }
+                                        }
+                                        Err(e) => {
+                                            tracing::warn!(
+                                                "GIF 抽帧失败，回退为静态图（可能丢失动图信息）: {}",
+                                                e
+                                            );
+                                            match process_image_to_format(
+                                                &source.data,
+                                                "jpeg",
+                                                compression_config,
+                                                total_image_count,
+                                            ) {
+                                                Ok(result) => {
+                                                    images.push(KiroImage::from_base64(
+                                                        "jpeg",
+                                                        result.data,
+                                                    ));
+                                                }
+                                                Err(e2) => {
+                                                    tracing::warn!(
+                                                        "GIF 回退重编码失败，尝试静态 GIF: {}",
+                                                        e2
+                                                    );
+                                                    match process_image(
+                                                        &source.data,
+                                                        &format,
+                                                        compression_config,
+                                                        total_image_count,
+                                                    ) {
+                                                        Ok(result) => {
+                                                            images.push(KiroImage::from_base64(
+                                                                format,
+                                                                result.data,
+                                                            ));
+                                                        }
+                                                        Err(e3) => {
+                                                            tracing::warn!(
+                                                                "图片处理失败，使用原始数据: {}",
+                                                                e3
+                                                            );
+                                                            images.push(KiroImage::from_base64(
+                                                                format,
+                                                                source.data,
+                                                            ));
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    // 处理静态图片（可能缩放）
+                                    match process_image(
+                                        &source.data,
+                                        &format,
+                                        compression_config,
+                                        total_image_count,
+                                    ) {
+                                        Ok(result) => {
+                                            if result.was_resized {
+                                                tracing::info!(
+                                                    "图片已缩放: {:?} -> {:?}, tokens: {}",
+                                                    result.original_size,
+                                                    result.final_size,
+                                                    result.tokens
+                                                );
+                                            }
+                                            images
+                                                .push(KiroImage::from_base64(format, result.data));
+                                        }
+                                        Err(e) => {
+                                            tracing::warn!("图片处理失败，使用原始数据: {}", e);
+                                            images
+                                                .push(KiroImage::from_base64(format, source.data));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        "tool_result" => {
+                            if let Some(tool_use_id) = block.tool_use_id {
+                                let result_content = extract_tool_result_content(&block.content);
+                                let is_error = block.is_error.unwrap_or(false);
+
+                                let mut result = if is_error {
+                                    ToolResult::error(&tool_use_id, result_content)
+                                } else {
+                                    ToolResult::success(&tool_use_id, result_content)
+                                };
+                                result.status =
+                                    Some(if is_error { "error" } else { "success" }.to_string());
+
+                                tool_results.push(result);
+                            }
+                        }
+                        "tool_use" => {
+                            // tool_use 在 assistant 消息中处理，这里忽略
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+
+    Ok((text_parts.join("\n"), images, tool_results))
+}
+
+/// 从 media_type 获取图片格式
+fn get_image_format(media_type: &str) -> Option<String> {
+    match media_type {
+        "image/jpeg" => Some("jpeg".to_string()),
+        "image/png" => Some("png".to_string()),
+        "image/gif" => Some("gif".to_string()),
+        "image/webp" => Some("webp".to_string()),
+        _ => None,
+    }
+}
+
+/// 提取工具结果内容
+fn extract_tool_result_content(content: &Option<serde_json::Value>) -> String {
+    match content {
+        Some(serde_json::Value::String(s)) => s.clone(),
+        Some(serde_json::Value::Array(arr)) => {
+            let mut parts = Vec::new();
+            for item in arr {
+                if let Some(text) = item.get("text").and_then(|v| v.as_str()) {
+                    parts.push(text.to_string());
+                }
+            }
+            parts.join("\n")
+        }
+        Some(v) => v.to_string(),
+        None => String::new(),
+    }
+}
+
+/// 验证并过滤 tool_use/tool_result 配对
+///
+/// 收集所有 tool_use_id，验证 tool_result 是否匹配
+/// 静默跳过孤立的 tool_use 和 tool_result，输出警告日志
+///
+/// # Arguments
+/// * `history` - 历史消息引用
+/// * `tool_results` - 当前消息中的 tool_result 列表
+///
+/// # Returns
+/// 元组：(经过验证和过滤后的 tool_result 列表, 孤立的 tool_use_id 集合)
+fn validate_tool_pairing(
+    history: &[Message],
+    tool_results: &[ToolResult],
+) -> (Vec<ToolResult>, std::collections::HashSet<String>) {
+    use std::collections::HashSet;
+
+    // 1. 收集所有历史中的 tool_use_id
+    let mut all_tool_use_ids: HashSet<String> = HashSet::new();
+    // 2. 收集历史中已经有 tool_result 的 tool_use_id
+    let mut history_tool_result_ids: HashSet<String> = HashSet::new();
+
+    for msg in history {
+        match msg {
+            Message::Assistant(assistant_msg) => {
+                if let Some(ref tool_uses) = assistant_msg.assistant_response_message.tool_uses {
+                    for tool_use in tool_uses {
+                        all_tool_use_ids.insert(tool_use.tool_use_id.clone());
+                    }
+                }
+            }
+            Message::User(user_msg) => {
+                // 收集历史 user 消息中的 tool_results
+                for result in &user_msg
+                    .user_input_message
+                    .user_input_message_context
+                    .tool_results
+                {
+                    history_tool_result_ids.insert(result.tool_use_id.clone());
+                }
+            }
+        }
+    }
+
+    // 3. 计算真正未配对的 tool_use_ids（排除历史中已配对的）
+    let mut unpaired_tool_use_ids: HashSet<String> = all_tool_use_ids
+        .difference(&history_tool_result_ids)
+        .cloned()
+        .collect();
+
+    // 4. 过滤并验证当前消息的 tool_results
+    let mut filtered_results = Vec::new();
+
+    for result in tool_results {
+        if unpaired_tool_use_ids.contains(&result.tool_use_id) {
+            // 配对成功
+            filtered_results.push(result.clone());
+            unpaired_tool_use_ids.remove(&result.tool_use_id);
+        } else if all_tool_use_ids.contains(&result.tool_use_id) {
+            // tool_use 存在但已经在历史中配对过了，这是重复的 tool_result
+            tracing::warn!(
+                "跳过重复的 tool_result：该 tool_use 已在历史中配对，tool_use_id={}",
+                result.tool_use_id
+            );
+        } else {
+            // 孤立 tool_result - 找不到对应的 tool_use
+            tracing::warn!(
+                "跳过孤立的 tool_result：找不到对应的 tool_use，tool_use_id={}",
+                result.tool_use_id
+            );
+        }
+    }
+
+    // 5. 检测真正孤立的 tool_use（有 tool_use 但在历史和当前消息中都没有 tool_result）
+    for orphaned_id in &unpaired_tool_use_ids {
+        tracing::warn!(
+            "检测到孤立的 tool_use：找不到对应的 tool_result，将从历史中移除，tool_use_id={}",
+            orphaned_id
+        );
+    }
+
+    (filtered_results, unpaired_tool_use_ids)
+}
+
+/// 从历史消息中移除孤立的 tool_use
+///
+/// Kiro API 要求每个 tool_use 必须有对应的 tool_result，否则返回 400 Bad Request。
+/// 此函数遍历历史中的 assistant 消息，移除没有对应 tool_result 的 tool_use。
+///
+/// # Arguments
+/// * `history` - 可变的历史消息列表
+/// * `orphaned_ids` - 需要移除的孤立 tool_use_id 集合
+fn remove_orphaned_tool_uses(
+    history: &mut [Message],
+    orphaned_ids: &std::collections::HashSet<String>,
+) {
+    if orphaned_ids.is_empty() {
+        return;
+    }
+
+    for msg in history.iter_mut() {
+        if let Message::Assistant(assistant_msg) = msg
+            && let Some(ref mut tool_uses) = assistant_msg.assistant_response_message.tool_uses
+        {
+            let original_len = tool_uses.len();
+            tool_uses.retain(|tu| !orphaned_ids.contains(&tu.tool_use_id));
+
+            // 如果移除后为空，设置为 None
+            if tool_uses.is_empty() {
+                assistant_msg.assistant_response_message.tool_uses = None;
+            } else if tool_uses.len() != original_len {
+                tracing::debug!(
+                    "从 assistant 消息中移除了 {} 个孤立的 tool_use",
+                    original_len - tool_uses.len()
+                );
+            }
+        }
+    }
+}
+
+/// 转换工具定义
+///
+/// # 不支持的工具类型
+///
+/// 以下工具类型会被自动过滤（Kiro API 当前不支持）：
+/// - `web_search_*`: Anthropic 的 Web 搜索工具（如 `web_search_20250305`）
+///
+/// **TODO**: 如果 Kiro API 未来支持 web_search，需要：
+/// 1. 移除下方的 `filter` 过滤逻辑
+/// 2. 添加 web_search 工具的转换逻辑（可能需要特殊处理 `max_uses` 等字段）
+/// 3. 更新相关测试用例
+fn convert_tools(
+    tools: &Option<Vec<AnthropicTool>>,
+    max_description_chars: usize,
+) -> Vec<KiroTool> {
+    let Some(tools) = tools else {
+        return Vec::new();
+    };
+
+    tools
+        .iter()
+        .filter(|t| {
+            // 过滤掉 web_search 类型的工具（Kiro API 当前不支持）
+            // 工具类型格式: "web_search_20250305"
+            let dominated = t
+                .tool_type
+                .as_ref()
+                .is_some_and(|ty| ty.starts_with("web_search"));
+            if dominated {
+                tracing::debug!("过滤不支持的工具: name={}, type={:?}", t.name, t.tool_type);
+            }
+
+            // 过滤掉 name 超过 64 字符的工具（上游硬限制）
+            if t.name.len() > 64 {
+                tracing::warn!(
+                    "过滤工具名过长的工具: name={} ({}字符，上限64)",
+                    t.name,
+                    t.name.len()
+                );
+                return false;
+            }
+
+            !dominated
+        })
+        .map(|t| {
+            let mut description = if t.description.trim().is_empty() {
+                format!("Tool: {}", t.name)
+            } else {
+                t.description.clone()
+            };
+
+            // 对 Write/Edit 工具追加自定义描述后缀
+            let suffix = match t.name.as_str() {
+                "Write" => WRITE_TOOL_DESCRIPTION_SUFFIX,
+                "Edit" => EDIT_TOOL_DESCRIPTION_SUFFIX,
+                _ => "",
+            };
+            if !suffix.is_empty() {
+                description.push('\n');
+                description.push_str(suffix);
+            }
+
+            // 限制描述长度（0=不截断；安全截断 UTF-8，单次遍历）
+            let description = if max_description_chars > 0 {
+                match description.char_indices().nth(max_description_chars) {
+                    Some((idx, _)) => description[..idx].to_string(),
+                    None => description,
+                }
+            } else {
+                description
+            };
+
+            let schema = normalize_json_schema(serde_json::json!(t.input_schema));
+
+            KiroTool {
+                tool_specification: ToolSpecification {
+                    name: t.name.clone(),
+                    description,
+                    input_schema: InputSchema::from_json(schema),
+                },
+            }
+        })
+        .collect()
+}
+
+/// 生成thinking标签前缀
+fn generate_thinking_prefix(req: &MessagesRequest) -> Option<String> {
+    if let Some(t) = &req.thinking {
+        if t.thinking_type == "enabled" {
+            return Some(format!(
+                "<thinking_mode>enabled</thinking_mode><max_thinking_length>{}</max_thinking_length>",
+                t.budget_tokens
+            ));
+        } else if t.thinking_type == "adaptive" {
+            let raw_effort = req
+                .output_config
+                .as_ref()
+                .map(|c| c.effort.as_str())
+                .unwrap_or("high");
+            // 白名单归一化：仅接受 low/medium/high，非法值回退 high
+            let effort = match raw_effort {
+                "low" | "medium" | "high" => raw_effort,
+                _ => {
+                    tracing::warn!("未知的 thinking effort 值 '{}', 回退为 'high'", raw_effort);
+                    "high"
+                }
+            };
+            return Some(format!(
+                "<thinking_mode>adaptive</thinking_mode><thinking_effort>{}</thinking_effort>",
+                effort
+            ));
+        }
+    }
+    None
+}
+
+/// 检查内容是否已包含thinking标签
+fn has_thinking_tags(content: &str) -> bool {
+    content.contains("<thinking_mode>") || content.contains("<max_thinking_length>")
+}
+
+/// 检查请求的工具列表中是否包含 Write 或 Edit 工具
+fn has_write_or_edit_tool(req: &MessagesRequest) -> bool {
+    req.tools
+        .as_ref()
+        .is_some_and(|tools| tools.iter().any(|t| t.name == "Write" || t.name == "Edit"))
+}
+
+/// 构建历史消息
+/// `messages` 参数是经过 prefill 预处理后的消息切片（末尾必为 user）
+fn build_history(
+    req: &MessagesRequest,
+    messages: &[super::types::Message],
+    model_id: &str,
+    compression_config: &CompressionConfig,
+    total_image_count: usize,
+    is_agentic: bool,
+) -> Result<Vec<Message>, ConversionError> {
+    let mut history = Vec::new();
+
+    // 生成thinking前缀（如果需要）
+    let thinking_prefix = generate_thinking_prefix(req);
+
+    // 仅在请求包含 Write/Edit 工具时注入分块写入策略
+    let should_inject_chunked_policy = has_write_or_edit_tool(req);
+
+    // 1. 处理系统消息
+    if let Some(ref system) = req.system {
+        let system_content: String = system
+            .iter()
+            .map(|s| s.text.clone())
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        if !system_content.is_empty() {
+            // 仅在存在 Write/Edit 工具时追加分块写入策略到系统消息
+            let system_content = if should_inject_chunked_policy {
+                format!("{}\n{}", system_content, SYSTEM_CHUNKED_POLICY)
+            } else {
+                system_content
+            };
+
+            // 注入thinking标签到系统消息最前面（如果需要且不存在）
+            let final_content = if let Some(ref prefix) = thinking_prefix {
+                if !has_thinking_tags(&system_content) {
+                    format!("{}\n{}", prefix, system_content)
+                } else {
+                    system_content
+                }
+            } else {
+                system_content
+            };
+
+            // 系统消息作为 user + assistant 配对
+            let user_msg = HistoryUserMessage::new(final_content, model_id);
+            history.push(Message::User(user_msg));
+
+            let assistant_msg = HistoryAssistantMessage::new("I will follow these instructions.");
+            history.push(Message::Assistant(assistant_msg));
+        }
+    } else if thinking_prefix.is_some() || should_inject_chunked_policy {
+        // 没有系统消息但需要注入 thinking 配置或分块写入策略
+        let mut parts = Vec::new();
+        if let Some(ref prefix) = thinking_prefix {
+            parts.push(prefix.clone());
+        }
+        if should_inject_chunked_policy {
+            parts.push(SYSTEM_CHUNKED_POLICY.to_string());
+        }
+        let content = parts.join("\n");
+
+        let user_msg = HistoryUserMessage::new(content, model_id);
+        history.push(Message::User(user_msg));
+
+        let assistant_msg = HistoryAssistantMessage::new("I will follow these instructions.");
+        history.push(Message::Assistant(assistant_msg));
+    }
+
+    // Agentic 模型：追加专用系统提示
+    if is_agentic {
+        let user_msg = HistoryUserMessage::new(KIRO_AGENTIC_SYSTEM_PROMPT, model_id);
+        history.push(Message::User(user_msg));
+
+        let assistant_msg =
+            HistoryAssistantMessage::new("I will work autonomously following these principles.");
+        history.push(Message::Assistant(assistant_msg));
+    }
+
+    // 2. 处理常规消息历史
+    // 最后一条消息作为 currentMessage，不加入历史
+    let history_end_index = messages.len().saturating_sub(1);
+
+    // 收集并配对消息
+    let mut user_buffer: Vec<&super::types::Message> = Vec::new();
+    let mut assistant_buffer: Vec<&super::types::Message> = Vec::new();
+
+    for msg in messages.iter().take(history_end_index) {
+        if msg.role == "user" {
+            // 先处理累积的 assistant 消息
+            if !assistant_buffer.is_empty() {
+                let merged = merge_assistant_messages(&assistant_buffer)?;
+                history.push(Message::Assistant(merged));
+                assistant_buffer.clear();
+            }
+            user_buffer.push(msg);
+        } else if msg.role == "assistant" {
+            // 先处理累积的 user 消息
+            if !user_buffer.is_empty() {
+                let merged_user = merge_user_messages(
+                    &user_buffer,
+                    model_id,
+                    compression_config,
+                    total_image_count,
+                )?;
+                history.push(Message::User(merged_user));
+                user_buffer.clear();
+            }
+            // 累积 assistant 消息（支持连续多条）
+            assistant_buffer.push(msg);
+        }
+    }
+
+    // 处理末尾累积的 assistant 消息
+    if !assistant_buffer.is_empty() {
+        let merged = merge_assistant_messages(&assistant_buffer)?;
+        history.push(Message::Assistant(merged));
+    }
+
+    // 处理结尾的孤立 user 消息
+    if !user_buffer.is_empty() {
+        let merged_user = merge_user_messages(
+            &user_buffer,
+            model_id,
+            compression_config,
+            total_image_count,
+        )?;
+        history.push(Message::User(merged_user));
+
+        // 自动配对一个 "OK" 的 assistant 响应
+        let auto_assistant = HistoryAssistantMessage::new("OK");
+        history.push(Message::Assistant(auto_assistant));
+    }
+
+    Ok(history)
+}
+
+/// 合并多个 user 消息
+fn merge_user_messages(
+    messages: &[&super::types::Message],
+    model_id: &str,
+    compression_config: &CompressionConfig,
+    total_image_count: usize,
+) -> Result<HistoryUserMessage, ConversionError> {
+    let mut content_parts = Vec::new();
+    let mut all_images = Vec::new();
+    let mut all_tool_results = Vec::new();
+
+    for msg in messages {
+        let (text, images, tool_results) =
+            process_message_content(&msg.content, compression_config, total_image_count)?;
+        if !text.is_empty() {
+            content_parts.push(text);
+        }
+        all_images.extend(images);
+        all_tool_results.extend(tool_results);
+    }
+
+    let content = non_empty_content_or_space(
+        content_parts.join("\n"),
+        !all_images.is_empty() || !all_tool_results.is_empty(),
+    );
+    // 保留文本内容，即使有工具结果也不丢弃用户文本
+    let mut user_msg = UserMessage::new(&content, model_id);
+
+    if !all_images.is_empty() {
+        user_msg = user_msg.with_images(all_images);
+    }
+
+    if !all_tool_results.is_empty() {
+        let mut ctx = UserInputMessageContext::new();
+        ctx = ctx.with_tool_results(all_tool_results);
+        user_msg = user_msg.with_context(ctx);
+    }
+
+    Ok(HistoryUserMessage {
+        user_input_message: user_msg,
+    })
+}
+
+/// 转换 assistant 消息
+fn convert_assistant_message(
+    msg: &super::types::Message,
+) -> Result<HistoryAssistantMessage, ConversionError> {
+    let mut thinking_content = String::new();
+    let mut text_content = String::new();
+    let mut tool_uses = Vec::new();
+
+    match &msg.content {
+        serde_json::Value::String(s) => {
+            text_content = s.clone();
+        }
+        serde_json::Value::Array(arr) => {
+            for item in arr {
+                if let Ok(block) = serde_json::from_value::<ContentBlock>(item.clone()) {
+                    match block.block_type.as_str() {
+                        "thinking" => {
+                            if let Some(thinking) = block.thinking {
+                                thinking_content.push_str(&thinking);
+                            }
+                        }
+                        "text" => {
+                            if let Some(text) = block.text {
+                                text_content.push_str(&text);
+                            }
+                        }
+                        "tool_use" => {
+                            if let (Some(id), Some(name)) = (block.id, block.name) {
+                                let input = block.input.unwrap_or(serde_json::json!({}));
+                                tool_uses.push(ToolUseEntry::new(id, name).with_input(input));
+                            }
+                        }
+                        // WebSearch 相关块：server_tool_use 忽略，
+                        // web_search_tool_result 提取 title/url/snippet/page_age 保留到对话历史
+                        "server_tool_use" => {}
+                        "web_search_tool_result" => {
+                            // 注意：历史文本长度由 compressor.rs 的压缩流程统一管理，
+                            // 此处无需额外截断。实际效果需运行时验证。
+                            //
+                            // encrypted_content 字段：本项目中由 websearch.rs 写入，
+                            // 存储的是可读 snippet；若上游改为原生 Anthropic WebSearch 响应，
+                            // 该字段语义可能不同，届时需重新评估是否保留。
+                            if let Some(serde_json::Value::Array(results)) = block.content {
+                                for result in &results {
+                                    if result.get("type").and_then(|t| t.as_str())
+                                        == Some("web_search_result")
+                                    {
+                                        let title = result
+                                            .get("title")
+                                            .and_then(|t| t.as_str())
+                                            .unwrap_or("");
+                                        let url = result
+                                            .get("url")
+                                            .and_then(|u| u.as_str())
+                                            .unwrap_or("");
+                                        if !url.is_empty() {
+                                            // 历史上下文仅供 Kiro 模型理解，使用纯文本格式
+                                            // 避免 title/url 含特殊字符时 Markdown 语法被破坏
+                                            let snippet = result
+                                                .get("encrypted_content")
+                                                .and_then(|s| s.as_str())
+                                                .unwrap_or("");
+                                            let page_age = result
+                                                .get("page_age")
+                                                .and_then(|s| s.as_str())
+                                                .unwrap_or("");
+                                            // 剥除控制字符（换行等），保持单行
+                                            let clean_title: String =
+                                                title.chars().filter(|c| !c.is_control()).collect();
+                                            let clean_snippet: String = snippet
+                                                .chars()
+                                                .filter(|c| !c.is_control())
+                                                .collect();
+                                            if clean_title.is_empty() {
+                                                text_content.push_str(&format!("{}\n", url));
+                                            } else {
+                                                text_content.push_str(&format!(
+                                                    "{}: {}\n",
+                                                    clean_title, url
+                                                ));
+                                            }
+                                            if !page_age.is_empty() {
+                                                text_content
+                                                    .push_str(&format!("Date: {}\n", page_age));
+                                            }
+                                            if !clean_snippet.is_empty() {
+                                                text_content
+                                                    .push_str(&format!("{}\n", clean_snippet));
+                                            }
+                                            text_content.push('\n');
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+
+    // 组合 thinking 和 text 内容
+    // 格式: <thinking>思考内容</thinking>\n\ntext内容
+    // 注意: Kiro API 要求 content 字段不能为空，当只有 tool_use 时需要占位符
+    let final_content = if !thinking_content.is_empty() {
+        if !text_content.is_empty() {
+            format!(
+                "<thinking>{}</thinking>\n\n{}",
+                thinking_content, text_content
+            )
+        } else {
+            format!("<thinking>{}</thinking>", thinking_content)
+        }
+    } else if text_content.is_empty() && !tool_uses.is_empty() {
+        ".".to_string()
+    } else {
+        text_content
+    };
+
+    let mut assistant = AssistantMessage::new(final_content);
+    if !tool_uses.is_empty() {
+        assistant = assistant.with_tool_uses(tool_uses);
+    }
+
+    Ok(HistoryAssistantMessage {
+        assistant_response_message: assistant,
+    })
+}
+
+/// 合并多个连续的 assistant 消息为一条
+/// 用于处理网络不稳定时产生的连续 assistant 消息（Issue #79）
+fn merge_assistant_messages(
+    messages: &[&super::types::Message],
+) -> Result<HistoryAssistantMessage, ConversionError> {
+    assert!(!messages.is_empty());
+    if messages.len() == 1 {
+        return convert_assistant_message(messages[0]);
+    }
+
+    let mut all_tool_uses: Vec<ToolUseEntry> = Vec::new();
+    let mut content_parts: Vec<String> = Vec::new();
+
+    for msg in messages {
+        let converted = convert_assistant_message(msg)?;
+        let am = converted.assistant_response_message;
+        if !am.content.trim().is_empty() {
+            content_parts.push(am.content);
+        }
+        if let Some(tus) = am.tool_uses {
+            all_tool_uses.extend(tus);
+        }
+    }
+
+    let content = if content_parts.is_empty() && !all_tool_uses.is_empty() {
+        ".".to_string()
+    } else {
+        content_parts.join("\n\n")
+    };
+
+    let mut assistant = AssistantMessage::new(content);
+    if !all_tool_uses.is_empty() {
+        assistant = assistant.with_tool_uses(all_tool_uses);
+    }
+    Ok(HistoryAssistantMessage {
+        assistant_response_message: assistant,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::config::CompressionConfig;
+
+    #[test]
+    fn test_map_model_sonnet() {
+        assert!(
+            map_model("claude-sonnet-4-20250514")
+                .unwrap()
+                .contains("sonnet")
+        );
+        assert!(
+            map_model("claude-3-5-sonnet-20241022")
+                .unwrap()
+                .contains("sonnet")
+        );
+    }
+
+    #[test]
+    fn test_map_model_opus() {
+        // 不含 4.5/4-5 的 opus → 默认映射到最新版 4.6
+        assert_eq!(
+            map_model("claude-opus-4-20250514").unwrap(),
+            "claude-opus-4.6"
+        );
+        assert_eq!(
+            map_model("claude-opus-4-20260206").unwrap(),
+            "claude-opus-4.6"
+        );
+        // 显式 4.5 → 保留 4.5
+        assert_eq!(
+            map_model("claude-opus-4-5-20250514").unwrap(),
+            "claude-opus-4.5"
+        );
+        assert_eq!(map_model("claude-opus-4.5").unwrap(), "claude-opus-4.5");
+    }
+
+    #[test]
+    fn test_map_model_haiku() {
+        assert!(
+            map_model("claude-haiku-4-20250514")
+                .unwrap()
+                .contains("haiku")
+        );
+    }
+
+    #[test]
+    fn test_map_model_unsupported() {
+        assert!(map_model("gpt-4").is_none());
+    }
+
+    #[test]
+    fn test_map_model_thinking_suffix_sonnet() {
+        // thinking 后缀不应影响 sonnet 模型映射
+        let result = map_model("claude-sonnet-4-5-20250929-thinking");
+        assert_eq!(result, Some("claude-sonnet-4.5".to_string()));
+    }
+
+    #[test]
+    fn test_map_model_thinking_suffix_opus_4_5() {
+        // thinking 后缀不应影响 opus 4.5 模型映射
+        let result = map_model("claude-opus-4-5-20251101-thinking");
+        assert_eq!(result, Some("claude-opus-4.5".to_string()));
+    }
+
+    #[test]
+    fn test_map_model_thinking_suffix_opus_4_6() {
+        // thinking 后缀不应影响 opus 4.6 模型映射
+        let result = map_model("claude-opus-4-6-thinking");
+        assert_eq!(result, Some("claude-opus-4.6".to_string()));
+    }
+
+    #[test]
+    fn test_map_model_thinking_suffix_haiku() {
+        // thinking 后缀不应影响 haiku 模型映射
+        let result = map_model("claude-haiku-4-5-20251001-thinking");
+        assert_eq!(result, Some("claude-haiku-4.5".to_string()));
+    }
+
+    #[test]
+    fn test_determine_chat_trigger_type() {
+        // 无工具时返回 MANUAL
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+        assert_eq!(determine_chat_trigger_type(&req), "MANUAL");
+    }
+
+    #[test]
+    fn test_collect_history_tool_names() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 创建包含工具使用的历史消息
+        let mut assistant_msg = AssistantMessage::new("I'll read the file.");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("tool-1", "read")
+                .with_input(serde_json::json!({"path": "/test.txt"})),
+            ToolUseEntry::new("tool-2", "write")
+                .with_input(serde_json::json!({"path": "/out.txt"})),
+        ]);
+
+        let history = vec![
+            Message::User(HistoryUserMessage::new(
+                "Read the file",
+                "claude-sonnet-4.5",
+            )),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg,
+            }),
+        ];
+
+        let tool_names = collect_history_tool_names(&history);
+        assert_eq!(tool_names.len(), 2);
+        assert!(tool_names.contains(&"read".to_string()));
+        assert!(tool_names.contains(&"write".to_string()));
+    }
+
+    #[test]
+    fn test_create_placeholder_tool() {
+        let tool = create_placeholder_tool("my_custom_tool");
+
+        assert_eq!(tool.tool_specification.name, "my_custom_tool");
+        assert!(!tool.tool_specification.description.is_empty());
+
+        // 验证 JSON 序列化正确
+        let json = serde_json::to_string(&tool).unwrap();
+        assert!(json.contains("\"name\":\"my_custom_tool\""));
+    }
+
+    #[test]
+    fn test_history_tools_added_to_tools_list() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 创建一个请求，历史中有工具使用，但 tools 列表为空
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!("Read the file"),
+                },
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!([
+                        {"type": "text", "text": "I'll read the file."},
+                        {"type": "tool_use", "id": "tool-1", "name": "read", "input": {"path": "/test.txt"}}
+                    ]),
+                },
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_result", "tool_use_id": "tool-1", "content": "file content"}
+                    ]),
+                },
+            ],
+            stream: false,
+            system: None,
+            tools: None, // 没有提供工具定义
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default()).unwrap();
+
+        // 验证 tools 列表中包含了历史中使用的工具的占位符定义
+        let tools = &result
+            .conversation_state
+            .current_message
+            .user_input_message
+            .user_input_message_context
+            .tools;
+
+        assert!(!tools.is_empty(), "tools 列表不应为空");
+        assert!(
+            tools.iter().any(|t| t.tool_specification.name == "read"),
+            "tools 列表应包含 'read' 工具的占位符定义"
+        );
+    }
+
+    #[test]
+    fn test_extract_session_id_valid() {
+        // 测试有效的 user_id 格式
+        let user_id = "user_0dede55c6dcc4a11a30bbb5e7f22e6fdf86cdeba3820019cc27612af4e1243cd_account__session_8bb5523b-ec7c-4540-a9ca-beb6d79f1552";
+        let session_id = extract_session_id(user_id);
+        assert_eq!(
+            session_id,
+            Some("8bb5523b-ec7c-4540-a9ca-beb6d79f1552".to_string())
+        );
+    }
+
+    #[test]
+    fn test_extract_session_id_no_session() {
+        // 测试没有 session 的 user_id
+        let user_id = "user_0dede55c6dcc4a11a30bbb5e7f22e6fdf86cdeba3820019cc27612af4e1243cd";
+        let session_id = extract_session_id(user_id);
+        assert_eq!(session_id, None);
+    }
+
+    #[test]
+    fn test_extract_session_id_invalid_uuid() {
+        // 测试无效的 UUID 格式
+        let user_id = "user_xxx_session_invalid-uuid";
+        let session_id = extract_session_id(user_id);
+        assert_eq!(session_id, None);
+    }
+
+    #[test]
+    fn test_convert_request_with_session_metadata() {
+        use super::super::types::{Message as AnthropicMessage, Metadata};
+
+        // 测试带有 metadata 的请求，应该使用 session UUID 作为 conversationId
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("Hello"),
+            }],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: Some(Metadata {
+                user_id: Some(
+                    "user_0dede55c6dcc4a11a30bbb5e7f22e6fdf86cdeba3820019cc27612af4e1243cd_account__session_a0662283-7fd3-4399-a7eb-52b9a717ae88".to_string(),
+                ),
+            }),
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default()).unwrap();
+        assert_eq!(
+            result.conversation_state.conversation_id,
+            "a0662283-7fd3-4399-a7eb-52b9a717ae88"
+        );
+    }
+
+    #[test]
+    fn test_convert_request_without_metadata() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 测试没有 metadata 的请求，应该生成新的 UUID
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("Hello"),
+            }],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default()).unwrap();
+        // 验证生成的是有效的 UUID 格式
+        assert_eq!(result.conversation_state.conversation_id.len(), 36);
+        assert_eq!(
+            result
+                .conversation_state
+                .conversation_id
+                .chars()
+                .filter(|c| *c == '-')
+                .count(),
+            4
+        );
+    }
+
+    #[test]
+    fn test_validate_tool_pairing_orphaned_result() {
+        // 测试孤立的 tool_result 被过滤
+        // 历史中没有 tool_use，但 tool_results 中有 tool_result
+        let history = vec![
+            Message::User(HistoryUserMessage::new("Hello", "claude-sonnet-4.5")),
+            Message::Assistant(HistoryAssistantMessage::new("Hi there!")),
+        ];
+
+        let tool_results = vec![ToolResult::success("orphan-123", "some result")];
+
+        let (filtered, _) = validate_tool_pairing(&history, &tool_results);
+
+        // 孤立的 tool_result 应该被过滤掉
+        assert!(filtered.is_empty(), "孤立的 tool_result 应该被过滤");
+    }
+
+    #[test]
+    fn test_validate_tool_pairing_orphaned_use() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 测试孤立的 tool_use（有 tool_use 但没有对应的 tool_result）
+        let mut assistant_msg = AssistantMessage::new("I'll read the file.");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("tool-orphan", "read")
+                .with_input(serde_json::json!({"path": "/test.txt"})),
+        ]);
+
+        let history = vec![
+            Message::User(HistoryUserMessage::new(
+                "Read the file",
+                "claude-sonnet-4.5",
+            )),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg,
+            }),
+        ];
+
+        // 没有 tool_result
+        let tool_results: Vec<ToolResult> = vec![];
+
+        let (filtered, orphaned) = validate_tool_pairing(&history, &tool_results);
+
+        // 结果应该为空（因为没有 tool_result）
+        // 同时应该返回孤立的 tool_use_id
+        assert!(filtered.is_empty());
+        assert!(orphaned.contains("tool-orphan"));
+    }
+
+    #[test]
+    fn test_validate_tool_pairing_valid() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 测试正常配对的情况
+        let mut assistant_msg = AssistantMessage::new("I'll read the file.");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("tool-1", "read")
+                .with_input(serde_json::json!({"path": "/test.txt"})),
+        ]);
+
+        let history = vec![
+            Message::User(HistoryUserMessage::new(
+                "Read the file",
+                "claude-sonnet-4.5",
+            )),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg,
+            }),
+        ];
+
+        let tool_results = vec![ToolResult::success("tool-1", "file content")];
+
+        let (filtered, orphaned) = validate_tool_pairing(&history, &tool_results);
+
+        // 配对成功，应该保留，无孤立
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].tool_use_id, "tool-1");
+        assert!(orphaned.is_empty());
+    }
+
+    #[test]
+    fn test_validate_tool_pairing_mixed() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 测试混合情况：部分配对成功，部分孤立
+        let mut assistant_msg = AssistantMessage::new("I'll use two tools.");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("tool-1", "read").with_input(serde_json::json!({})),
+            ToolUseEntry::new("tool-2", "write").with_input(serde_json::json!({})),
+        ]);
+
+        let history = vec![
+            Message::User(HistoryUserMessage::new("Do something", "claude-sonnet-4.5")),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg,
+            }),
+        ];
+
+        // tool_results: tool-1 配对，tool-3 孤立
+        let tool_results = vec![
+            ToolResult::success("tool-1", "result 1"),
+            ToolResult::success("tool-3", "orphan result"), // 孤立
+        ];
+
+        let (filtered, orphaned) = validate_tool_pairing(&history, &tool_results);
+
+        // 只有 tool-1 应该保留
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].tool_use_id, "tool-1");
+        // tool-2 是孤立的 tool_use（无 result），tool-3 是孤立的 tool_result
+        assert!(orphaned.contains("tool-2"));
+    }
+
+    #[test]
+    fn test_validate_tool_pairing_history_already_paired() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 测试历史中已配对的 tool_use 不应该被报告为孤立
+        // 场景：多轮对话中，之前的 tool_use 已经在历史中有对应的 tool_result
+        let mut assistant_msg1 = AssistantMessage::new("I'll read the file.");
+        assistant_msg1 = assistant_msg1.with_tool_uses(vec![
+            ToolUseEntry::new("tool-1", "read")
+                .with_input(serde_json::json!({"path": "/test.txt"})),
+        ]);
+
+        // 构建历史中的 user 消息，包含 tool_result
+        let mut user_msg_with_result = UserMessage::new("", "claude-sonnet-4.5");
+        let mut ctx = UserInputMessageContext::new();
+        ctx = ctx.with_tool_results(vec![ToolResult::success("tool-1", "file content")]);
+        user_msg_with_result = user_msg_with_result.with_context(ctx);
+
+        let history = vec![
+            // 第一轮：用户请求
+            Message::User(HistoryUserMessage::new(
+                "Read the file",
+                "claude-sonnet-4.5",
+            )),
+            // 第一轮：assistant 使用工具
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg1,
+            }),
+            // 第二轮：用户返回工具结果（历史中已配对）
+            Message::User(HistoryUserMessage {
+                user_input_message: user_msg_with_result,
+            }),
+            // 第二轮：assistant 响应
+            Message::Assistant(HistoryAssistantMessage::new("The file contains...")),
+        ];
+
+        // 当前消息没有 tool_results（用户只是继续对话）
+        let tool_results: Vec<ToolResult> = vec![];
+
+        let (filtered, orphaned) = validate_tool_pairing(&history, &tool_results);
+
+        // 结果应该为空，且不应该有孤立 tool_use
+        // 因为 tool-1 已经在历史中配对了
+        assert!(filtered.is_empty());
+        assert!(orphaned.is_empty());
+    }
+
+    #[test]
+    fn test_validate_tool_pairing_duplicate_result() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 测试重复的 tool_result（历史中已配对，当前消息又发送了相同的 tool_result）
+        let mut assistant_msg = AssistantMessage::new("I'll read the file.");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("tool-1", "read")
+                .with_input(serde_json::json!({"path": "/test.txt"})),
+        ]);
+
+        // 历史中已有 tool_result
+        let mut user_msg_with_result = UserMessage::new("", "claude-sonnet-4.5");
+        let mut ctx = UserInputMessageContext::new();
+        ctx = ctx.with_tool_results(vec![ToolResult::success("tool-1", "file content")]);
+        user_msg_with_result = user_msg_with_result.with_context(ctx);
+
+        let history = vec![
+            Message::User(HistoryUserMessage::new(
+                "Read the file",
+                "claude-sonnet-4.5",
+            )),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg,
+            }),
+            Message::User(HistoryUserMessage {
+                user_input_message: user_msg_with_result,
+            }),
+            Message::Assistant(HistoryAssistantMessage::new("Done")),
+        ];
+
+        // 当前消息又发送了相同的 tool_result（重复）
+        let tool_results = vec![ToolResult::success("tool-1", "file content again")];
+
+        let (filtered, _) = validate_tool_pairing(&history, &tool_results);
+
+        // 重复的 tool_result 应该被过滤掉
+        assert!(filtered.is_empty(), "重复的 tool_result 应该被过滤");
+    }
+
+    #[test]
+    fn test_convert_assistant_message_tool_use_only() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 测试仅包含 tool_use 的 assistant 消息（无 text 块）
+        // Kiro API 要求 content 字段不能为空
+        let msg = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "tool_use", "id": "toolu_01ABC", "name": "read_file", "input": {"path": "/test.txt"}}
+            ]),
+        };
+
+        let result = convert_assistant_message(&msg).expect("应该成功转换");
+
+        // 验证 content 不为空（使用占位符）
+        assert!(
+            !result.assistant_response_message.content.is_empty(),
+            "content 不应为空"
+        );
+        assert_eq!(
+            result.assistant_response_message.content, ".",
+            "仅 tool_use 时应使用 '.' 占位符"
+        );
+
+        // 验证 tool_uses 被正确保留
+        let tool_uses = result
+            .assistant_response_message
+            .tool_uses
+            .expect("应该有 tool_uses");
+        assert_eq!(tool_uses.len(), 1);
+        assert_eq!(tool_uses[0].tool_use_id, "toolu_01ABC");
+        assert_eq!(tool_uses[0].name, "read_file");
+    }
+
+    #[test]
+    fn test_convert_assistant_message_with_text_and_tool_use() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 测试同时包含 text 和 tool_use 的 assistant 消息
+        let msg = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "text", "text": "Let me read that file for you."},
+                {"type": "tool_use", "id": "toolu_02XYZ", "name": "read_file", "input": {"path": "/data.json"}}
+            ]),
+        };
+
+        let result = convert_assistant_message(&msg).expect("应该成功转换");
+
+        // 验证 content 使用原始文本（不是占位符）
+        assert_eq!(
+            result.assistant_response_message.content,
+            "Let me read that file for you."
+        );
+
+        // 验证 tool_uses 被正确保留
+        let tool_uses = result
+            .assistant_response_message
+            .tool_uses
+            .expect("应该有 tool_uses");
+        assert_eq!(tool_uses.len(), 1);
+        assert_eq!(tool_uses[0].tool_use_id, "toolu_02XYZ");
+    }
+
+    #[test]
+    fn test_convert_assistant_message_web_search_tool_result() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 测试 web_search_tool_result 块被提取为纯文本（title、url、snippet、page_age）保留到历史
+        let msg = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "server_tool_use", "id": "srvtoolu_01ABC", "name": "web_search", "input": {"query": "rust async"}},
+                {
+                    "type": "web_search_tool_result",
+                    "content": [
+                        {
+                            "type": "web_search_result",
+                            "title": "Async in Rust",
+                            "url": "https://rust-lang.org/async",
+                            "encrypted_content": "Rust async/await guide.",
+                            "page_age": "January 1, 2025"
+                        },
+                        {"type": "web_search_result", "title": "", "url": "https://example.com/no-title",
+                         "encrypted_content": "", "page_age": null}
+                    ]
+                }
+            ]),
+        };
+
+        let result = convert_assistant_message(&msg).expect("应该成功转换");
+        let content = &result.assistant_response_message.content;
+
+        assert!(
+            content.contains("Async in Rust: https://rust-lang.org/async"),
+            "有 title 时应输出 'title: url'"
+        );
+        assert!(content.contains("Date: January 1, 2025"), "page_age 应保留");
+        assert!(
+            content.contains("Rust async/await guide."),
+            "snippet 应保留"
+        );
+        assert!(
+            content.contains("https://example.com/no-title"),
+            "title 为空时应输出纯 URL"
+        );
+        assert!(
+            !content.contains("srvtoolu_01ABC"),
+            "server_tool_use 应被忽略"
+        );
+    }
+
+    #[test]
+    fn test_convert_assistant_message_web_search_result_control_chars() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 测试 title 含控制字符时被过滤
+        let msg = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {
+                    "type": "web_search_tool_result",
+                    "content": [
+                        {"type": "web_search_result", "title": "Title\nWith\tControl", "url": "https://example.com"}
+                    ]
+                }
+            ]),
+        };
+
+        let result = convert_assistant_message(&msg).expect("应该成功转换");
+        let content = &result.assistant_response_message.content;
+
+        // 控制字符被过滤，不应出现换行和 tab
+        assert!(!content.contains('\t'), "tab 字符应被过滤");
+        // 内容应包含 URL
+        assert!(content.contains("https://example.com"), "URL 应保留");
+    }
+
+    #[test]
+    fn test_convert_tools_filters_web_search() {
+        use super::super::types::Tool as AnthropicTool;
+        use std::collections::HashMap;
+
+        // 测试 web_search 工具被过滤
+        // Kiro API 当前不支持 web_search，需要自动过滤
+        let tools = vec![
+            // web_search 工具（应被过滤）
+            AnthropicTool {
+                tool_type: Some("web_search_20250305".to_string()),
+                name: "web_search".to_string(),
+                description: String::new(),
+                input_schema: HashMap::new(),
+                max_uses: Some(8),
+            },
+            // 普通工具（应保留）
+            AnthropicTool {
+                tool_type: None,
+                name: "read_file".to_string(),
+                description: "Read a file from disk".to_string(),
+                input_schema: {
+                    let mut schema = HashMap::new();
+                    schema.insert("type".to_string(), serde_json::json!("object"));
+                    schema
+                },
+                max_uses: None,
+            },
+        ];
+
+        let converted = convert_tools(&Some(tools), 4000);
+
+        // 应该只有 1 个工具（web_search 被过滤）
+        assert_eq!(converted.len(), 1, "web_search 应该被过滤");
+        assert_eq!(
+            converted[0].tool_specification.name, "read_file",
+            "只应保留 read_file 工具"
+        );
+    }
+
+    #[test]
+    fn test_convert_tools_filters_all_web_search_variants() {
+        use super::super::types::Tool as AnthropicTool;
+        use std::collections::HashMap;
+
+        // 测试所有 web_search 变体都被过滤
+        let tools = vec![
+            AnthropicTool {
+                tool_type: Some("web_search_20250305".to_string()),
+                name: "web_search".to_string(),
+                description: String::new(),
+                input_schema: HashMap::new(),
+                max_uses: Some(8),
+            },
+            AnthropicTool {
+                tool_type: Some("web_search_20260101".to_string()), // 假设的未来版本
+                name: "web_search".to_string(),
+                description: String::new(),
+                input_schema: HashMap::new(),
+                max_uses: Some(10),
+            },
+        ];
+
+        let converted = convert_tools(&Some(tools), 4000);
+
+        // 所有 web_search 工具都应被过滤
+        assert!(converted.is_empty(), "所有 web_search 变体都应被过滤");
+    }
+
+    #[test]
+    fn test_convert_tools_fills_empty_description_and_normalizes_schema() {
+        use super::super::types::{Message as AnthropicMessage, Tool as AnthropicTool};
+        use std::collections::HashMap;
+
+        let mut input_schema = HashMap::new();
+        input_schema.insert("type".to_string(), serde_json::json!("object"));
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 128,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("hi"),
+            }],
+            stream: false,
+            system: None,
+            tools: Some(vec![AnthropicTool {
+                tool_type: None,
+                name: "mcp__ida-pro-mcp__patch_address_assembles".to_string(),
+                description: "".to_string(), // 上游可能拒绝空 description
+                input_schema,                // 故意不带 $schema 等字段
+                max_uses: None,
+            }]),
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default()).unwrap();
+        let tools = &result
+            .conversation_state
+            .current_message
+            .user_input_message
+            .user_input_message_context
+            .tools;
+
+        let tool = tools
+            .iter()
+            .find(|t| t.tool_specification.name == "mcp__ida-pro-mcp__patch_address_assembles")
+            .expect("转换后应包含该工具");
+
+        assert!(
+            !tool.tool_specification.description.trim().is_empty(),
+            "转换后的工具描述不应为空"
+        );
+        assert_eq!(
+            tool.tool_specification.input_schema.json["$schema"],
+            "http://json-schema.org/draft-07/schema#"
+        );
+        assert_eq!(tool.tool_specification.input_schema.json["type"], "object");
+    }
+
+    #[test]
+    fn test_current_message_content_is_non_empty_when_only_tool_result() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 构造典型 tool_use -> tool_result 链路，最后一条为 tool_result user 消息
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 128,
+            messages: vec![
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!("do it"),
+                },
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_use", "id": "tool-1", "name": "read", "input": {"path": "/tmp/a"}}
+                    ]),
+                },
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_result", "tool_use_id": "tool-1", "content": "ok"}
+                    ]),
+                },
+            ],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default()).unwrap();
+        let content = &result
+            .conversation_state
+            .current_message
+            .user_input_message
+            .content;
+
+        assert!(
+            !content.is_empty(),
+            "仅 tool_result 的 user 消息应使用占位符避免空 content"
+        );
+        assert_eq!(content, ".");
+    }
+
+    #[test]
+    fn test_history_user_message_content_is_non_empty_when_only_tool_result() {
+        use super::super::types::Message as AnthropicMessage;
+
+        // 让 tool_result 进入 history：tool_result 后紧跟 assistant，然后用户继续提问
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 128,
+            messages: vec![
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!("do it"),
+                },
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_use", "id": "tool-1", "name": "read", "input": {"path": "/tmp/a"}}
+                    ]),
+                },
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_result", "tool_use_id": "tool-1", "content": "ok"}
+                    ]),
+                },
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!("done"),
+                },
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!("next"),
+                },
+            ],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default()).unwrap();
+
+        let mut found = false;
+        for msg in &result.conversation_state.history {
+            let Message::User(user_msg) = msg else {
+                continue;
+            };
+            let ctx = &user_msg.user_input_message.user_input_message_context;
+            if ctx.tool_results.is_empty() {
+                continue;
+            }
+            found = true;
+            assert!(
+                !user_msg.user_input_message.content.is_empty(),
+                "history 中的 tool_result user 消息也需要占位符"
+            );
+            assert_eq!(user_msg.user_input_message.content, ".");
+        }
+        assert!(found, "测试数据应在 history 中包含 tool_results");
+    }
+
+    #[test]
+    fn test_current_message_content_is_non_empty_when_tool_result_filtered_as_orphan() {
+        use super::super::types::{Message as AnthropicMessage, Tool as AnthropicTool};
+        use std::collections::HashMap;
+
+        // 场景：当前消息仅有 tool_result，但 tool_use_id 与历史不匹配（会被过滤为孤立结果）
+        // 过滤后当前消息无文本/无 tool_result，必须仍保留非空 content 占位符，避免上游 400。
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 128,
+            messages: vec![
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!("请读取配置"),
+                },
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_use", "id": "tooluse_valid_1", "name": "read_file", "input": {"path": "/tmp/a"}}
+                    ]),
+                },
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_result", "tool_use_id": "toolu_orphan_1", "content": "ok"}
+                    ]),
+                },
+            ],
+            stream: false,
+            system: None,
+            tools: Some(vec![AnthropicTool {
+                tool_type: None,
+                name: "read_file".to_string(),
+                description: "read".to_string(),
+                input_schema: HashMap::new(),
+                max_uses: None,
+            }]),
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default()).unwrap();
+
+        // 孤立 tool_result 会被过滤
+        assert!(
+            result
+                .conversation_state
+                .current_message
+                .user_input_message
+                .user_input_message_context
+                .tool_results
+                .is_empty(),
+            "孤立 tool_result 应被过滤"
+        );
+
+        // 过滤后 content 仍应为非空占位符，避免上游拒绝请求
+        assert_eq!(
+            result
+                .conversation_state
+                .current_message
+                .user_input_message
+                .content,
+            "."
+        );
+    }
+
+    #[test]
+    fn test_remove_orphaned_tool_uses() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 测试从历史中移除孤立的 tool_use
+        let mut assistant_msg = AssistantMessage::new("I'll use multiple tools.");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("tool-1", "read").with_input(serde_json::json!({})),
+            ToolUseEntry::new("tool-2", "write").with_input(serde_json::json!({})),
+            ToolUseEntry::new("tool-3", "delete").with_input(serde_json::json!({})),
+        ]);
+
+        let mut history = vec![
+            Message::User(HistoryUserMessage::new("Do something", "claude-sonnet-4.5")),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg,
+            }),
+        ];
+
+        // 移除 tool-1 和 tool-3
+        let mut orphaned = std::collections::HashSet::new();
+        orphaned.insert("tool-1".to_string());
+        orphaned.insert("tool-3".to_string());
+
+        remove_orphaned_tool_uses(&mut history, &orphaned);
+
+        // 验证只剩下 tool-2
+        if let Message::Assistant(ref assistant_msg) = history[1] {
+            let tool_uses = assistant_msg
+                .assistant_response_message
+                .tool_uses
+                .as_ref()
+                .expect("应该还有 tool_uses");
+            assert_eq!(tool_uses.len(), 1);
+            assert_eq!(tool_uses[0].tool_use_id, "tool-2");
+        } else {
+            panic!("应该是 Assistant 消息");
+        }
+    }
+
+    #[test]
+    fn test_remove_orphaned_tool_uses_all_removed() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 测试移除所有 tool_use 后，tool_uses 变为 None
+        let mut assistant_msg = AssistantMessage::new("I'll use a tool.");
+        assistant_msg = assistant_msg.with_tool_uses(vec![
+            ToolUseEntry::new("tool-1", "read").with_input(serde_json::json!({})),
+        ]);
+
+        let mut history = vec![
+            Message::User(HistoryUserMessage::new("Do something", "claude-sonnet-4.5")),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: assistant_msg,
+            }),
+        ];
+
+        let mut orphaned = std::collections::HashSet::new();
+        orphaned.insert("tool-1".to_string());
+
+        remove_orphaned_tool_uses(&mut history, &orphaned);
+
+        // 验证 tool_uses 变为 None
+        if let Message::Assistant(ref assistant_msg) = history[1] {
+            assert!(
+                assistant_msg.assistant_response_message.tool_uses.is_none(),
+                "移除所有 tool_use 后应为 None"
+            );
+        } else {
+            panic!("应该是 Assistant 消息");
+        }
+    }
+
+    #[test]
+    fn test_normalize_json_schema_coerces_field_types() {
+        let input = serde_json::json!({
+            "$schema": null,
+            "type": null,
+            "properties": null,
+            "required": null,
+            "additionalProperties": null,
+        });
+
+        let normalized = normalize_json_schema(input);
+
+        assert_eq!(
+            normalized.get("$schema").and_then(|v| v.as_str()),
+            Some("http://json-schema.org/draft-07/schema#")
+        );
+        assert_eq!(
+            normalized.get("type").and_then(|v| v.as_str()),
+            Some("object")
+        );
+        assert!(normalized.get("properties").is_some_and(|v| v.is_object()));
+        assert!(normalized.get("required").is_some_and(|v| v.is_array()));
+        assert!(
+            normalized
+                .get("additionalProperties")
+                .is_some_and(|v| v.is_boolean())
+        );
+    }
+
+    #[test]
+    fn test_normalize_json_schema_filters_required_non_strings() {
+        let input = serde_json::json!({
+            "type": "object",
+            "properties": {},
+            "required": ["a", 1, null, {"x": 1}],
+        });
+
+        let normalized = normalize_json_schema(input);
+        let required = normalized
+            .get("required")
+            .and_then(|v| v.as_array())
+            .expect("required 应该是数组");
+
+        assert_eq!(required, &vec![serde_json::Value::String("a".to_string())]);
+    }
+
+    #[test]
+    fn test_chunked_policy_injected_only_with_write_edit_tools() {
+        use super::super::types::{
+            Message as AnthropicMessage, SystemMessage, Tool as AnthropicTool,
+        };
+        use std::collections::HashMap;
+
+        let system = vec![SystemMessage {
+            text: "You are a helpful assistant.".to_string(),
+        }];
+
+        // 无工具 → 不注入 chunked policy
+        let req_no_tools = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("hello"),
+            }],
+            stream: false,
+            system: Some(system.clone()),
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req_no_tools, &CompressionConfig::default()).unwrap();
+        let first_user = &result.conversation_state.history[0];
+        match first_user {
+            Message::User(u) => {
+                assert!(
+                    !u.user_input_message.content.contains("chunked operations"),
+                    "无工具时不应注入 chunked policy"
+                );
+            }
+            _ => panic!("history[0] 应该是 User 消息"),
+        }
+
+        // 有 Write 工具 → 注入 chunked policy
+        let req_with_write = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("hello"),
+            }],
+            stream: false,
+            system: Some(system.clone()),
+            tools: Some(vec![AnthropicTool {
+                tool_type: None,
+                name: "Write".to_string(),
+                description: "Write a file".to_string(),
+                input_schema: HashMap::new(),
+                max_uses: None,
+            }]),
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req_with_write, &CompressionConfig::default()).unwrap();
+        let first_user = &result.conversation_state.history[0];
+        match first_user {
+            Message::User(u) => {
+                assert!(
+                    u.user_input_message.content.contains("chunked operations"),
+                    "有 Write 工具时应注入 chunked policy"
+                );
+            }
+            _ => panic!("history[0] 应该是 User 消息"),
+        }
+
+        // system: None + 有 Edit 工具 → 也应注入 chunked policy
+        let req_no_system_with_edit = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("hello"),
+            }],
+            stream: false,
+            system: None,
+            tools: Some(vec![AnthropicTool {
+                tool_type: None,
+                name: "Edit".to_string(),
+                description: "Edit a file".to_string(),
+                input_schema: HashMap::new(),
+                max_uses: None,
+            }]),
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result =
+            convert_request(&req_no_system_with_edit, &CompressionConfig::default()).unwrap();
+        let first_user = &result.conversation_state.history[0];
+        match first_user {
+            Message::User(u) => {
+                assert!(
+                    u.user_input_message.content.contains("chunked operations"),
+                    "system: None + 有 Edit 工具时也应注入 chunked policy"
+                );
+            }
+            _ => panic!("history[0] 应该是 User 消息"),
+        }
+    }
+
+    #[test]
+    fn test_effort_whitelist_fallback() {
+        use super::super::types::{Message as AnthropicMessage, OutputConfig, Thinking};
+
+        // 合法值 "low"
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("hello"),
+            }],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: Some(Thinking {
+                thinking_type: "adaptive".to_string(),
+                budget_tokens: 0,
+            }),
+            output_config: Some(OutputConfig {
+                effort: "low".to_string(),
+            }),
+            metadata: None,
+        };
+
+        let prefix = generate_thinking_prefix(&req).unwrap();
+        assert!(prefix.contains("<thinking_effort>low</thinking_effort>"));
+
+        // 非法值 → 回退 "high"
+        let req_invalid = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!("hello"),
+            }],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: Some(Thinking {
+                thinking_type: "adaptive".to_string(),
+                budget_tokens: 0,
+            }),
+            output_config: Some(OutputConfig {
+                effort: "ultra".to_string(),
+            }),
+            metadata: None,
+        };
+
+        let prefix = generate_thinking_prefix(&req_invalid).unwrap();
+        assert!(
+            prefix.contains("<thinking_effort>high</thinking_effort>"),
+            "非法 effort 值应回退为 high，实际: {}",
+            prefix
+        );
+    }
+
+    #[test]
+    fn test_collect_history_tool_names_deduplicates_case_variants() {
+        use crate::kiro::model::requests::tool::ToolUseEntry;
+
+        // 历史中同时出现 "read" 和 "Read"（大小写变体），应只保留首次出现的形式
+        let mut msg1 = AssistantMessage::new("reading...");
+        msg1 = msg1.with_tool_uses(vec![
+            ToolUseEntry::new("t-1", "read").with_input(serde_json::json!({"path": "/a.txt"})),
+        ]);
+
+        let mut msg2 = AssistantMessage::new("reading again...");
+        msg2 = msg2.with_tool_uses(vec![
+            ToolUseEntry::new("t-2", "Read").with_input(serde_json::json!({"path": "/b.txt"})),
+        ]);
+
+        let history = vec![
+            Message::User(HistoryUserMessage::new("go", "claude-sonnet-4.5")),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: msg1,
+            }),
+            Message::User(HistoryUserMessage::new("ok", "claude-sonnet-4.5")),
+            Message::Assistant(HistoryAssistantMessage {
+                assistant_response_message: msg2,
+            }),
+        ];
+
+        let tool_names = collect_history_tool_names(&history);
+        // 只应有 1 个条目（首次出现的 "read"）
+        assert_eq!(
+            tool_names.len(),
+            1,
+            "大小写变体应被去重，实际: {:?}",
+            tool_names
+        );
+        assert_eq!(tool_names[0], "read");
+    }
+
+    #[test]
+    fn test_convert_request_handles_assistant_prefill() {
+        // 末尾 assistant 消息（prefill）应被静默丢弃，使用最后一条 user 消息作为 current_message
+        use super::super::types::Message as AnthropicMessage;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!("Hello"),
+                },
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!("Hi there"),
+                },
+            ],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let result = convert_request(&req, &CompressionConfig::default());
+        assert!(result.is_ok(), "prefill 场景不应报错: {:?}", result.err());
+        let state = result.unwrap().conversation_state;
+        assert_eq!(
+            state.current_message.user_input_message.content, "Hello",
+            "current_message 应为最后一条 user 消息的内容"
+        );
+    }
+
+    #[test]
+    fn test_convert_request_prefill_no_user_message() {
+        // 只有 assistant 消息、没有 user 消息时应返回 EmptyMessages 错误
+        use super::super::types::Message as AnthropicMessage;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "assistant".to_string(),
+                content: serde_json::json!("Hi there"),
+            }],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let err = convert_request(&req, &CompressionConfig::default()).unwrap_err();
+        assert!(
+            matches!(err, ConversionError::EmptyMessages),
+            "只有 assistant 消息时应返回 EmptyMessages，实际: {:?}",
+            err
+        );
+    }
+
+    #[test]
+    fn test_convert_request_empty_message_content() {
+        // 测试空消息内容应返回 EmptyMessageContent 错误
+        use super::super::types::Message as AnthropicMessage;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!(""),
+            }],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let err = convert_request(&req, &CompressionConfig::default()).unwrap_err();
+        assert!(
+            matches!(err, ConversionError::EmptyMessageContent),
+            "空消息内容应返回 EmptyMessageContent，实际: {:?}",
+            err
+        );
+    }
+
+    #[test]
+    fn test_convert_request_empty_text_block() {
+        // 测试仅包含空白文本块的消息应返回 EmptyMessageContent 错误
+        use super::super::types::Message as AnthropicMessage;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: serde_json::json!([
+                    {"type": "text", "text": "   "},
+                    {"type": "text", "text": "\n\t"}
+                ]),
+            }],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let err = convert_request(&req, &CompressionConfig::default()).unwrap_err();
+        assert!(
+            matches!(err, ConversionError::EmptyMessageContent),
+            "仅包含空白文本的消息应返回 EmptyMessageContent，实际: {:?}",
+            err
+        );
+    }
+
+    #[test]
+    fn test_convert_request_prefill_with_empty_user_message() {
+        // 测试 prefill 场景下，如果回退后的 user 消息为空，应返回 EmptyMessageContent 错误
+        use super::super::types::Message as AnthropicMessage;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!(""),
+                },
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!("Hi there"),
+                },
+            ],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let err = convert_request(&req, &CompressionConfig::default()).unwrap_err();
+        assert!(
+            matches!(err, ConversionError::EmptyMessageContent),
+            "prefill 回退后的空 user 消息应返回 EmptyMessageContent，实际: {:?}",
+            err
+        );
+    }
+
+    #[test]
+    fn test_merge_consecutive_assistant_messages() {
+        // 测试连续 assistant 消息被正确合并（Issue #79）
+        use super::super::types::Message as AnthropicMessage;
+
+        // 第一条 assistant 消息：只有 thinking 和空 text
+        let msg1 = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "thinking", "thinking": "Let me think about this..."},
+                {"type": "text", "text": " "}
+            ]),
+        };
+
+        // 第二条 assistant 消息：有 thinking、text 和 tool_use
+        let msg2 = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "thinking", "thinking": "I should read the file."},
+                {"type": "text", "text": "Let me read that file."},
+                {"type": "tool_use", "id": "toolu_01ABC", "name": "read_file", "input": {"path": "/test.txt"}}
+            ]),
+        };
+
+        let messages: Vec<&AnthropicMessage> = vec![&msg1, &msg2];
+        let result = merge_assistant_messages(&messages).expect("合并应成功");
+
+        // 验证 thinking 和 text 内容被合并
+        let content = &result.assistant_response_message.content;
+        assert!(content.contains("<thinking>"), "应包含 thinking 标签");
+        assert!(
+            content.contains("Let me read that file"),
+            "应包含第二条消息的 text 内容"
+        );
+
+        // 验证 tool_use 被保留
+        let tool_uses = result
+            .assistant_response_message
+            .tool_uses
+            .expect("应有 tool_uses");
+        assert_eq!(tool_uses.len(), 1);
+        assert_eq!(tool_uses[0].tool_use_id, "toolu_01ABC");
+        assert_eq!(tool_uses[0].name, "read_file");
+    }
+
+    #[test]
+    fn test_consecutive_assistant_with_tool_use_result_pairing() {
+        // 测试 Issue #79 的完整场景：连续 assistant 消息后跟 tool_result
+        use super::super::types::Message as AnthropicMessage;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![
+                // 用户请求
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!("Read the config file"),
+                },
+                // 第一条 assistant 消息（部分响应，网络中断）
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!([
+                        {"type": "thinking", "thinking": "I need to read the file..."},
+                        {"type": "text", "text": " "}
+                    ]),
+                },
+                // 第二条 assistant 消息（重新生成，包含 tool_use）
+                AnthropicMessage {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!([
+                        {"type": "thinking", "thinking": "Let me read the config."},
+                        {"type": "text", "text": "I'll read the config file for you."},
+                        {"type": "tool_use", "id": "toolu_01XYZ", "name": "read_file", "input": {"path": "/config.json"}}
+                    ]),
+                },
+                // 用户返回 tool_result
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: serde_json::json!([
+                        {"type": "tool_result", "tool_use_id": "toolu_01XYZ", "content": "{\"key\": \"value\"}"}
+                    ]),
+                },
+            ],
+            stream: false,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        // 转换应成功，不应因 tool_use/tool_result 配对失败而报错
+        let result = convert_request(&req, &CompressionConfig::default());
+        assert!(
+            result.is_ok(),
+            "连续 assistant 消息场景不应报错: {:?}",
+            result.err()
+        );
+
+        let state = result.unwrap().conversation_state;
+
+        // 验证历史中的 assistant 消息包含 tool_use
+        let mut found_tool_use = false;
+        for msg in &state.history {
+            if let Message::Assistant(assistant_msg) = msg
+                && let Some(ref tool_uses) = assistant_msg.assistant_response_message.tool_uses
+                && tool_uses.iter().any(|t| t.tool_use_id == "toolu_01XYZ")
+            {
+                found_tool_use = true;
+                break;
+            }
+        }
+        assert!(found_tool_use, "合并后的 assistant 消息应包含 tool_use");
+
+        // 验证 current_message 包含 tool_result
+        let tool_results = &state
+            .current_message
+            .user_input_message
+            .user_input_message_context
+            .tool_results;
+        assert!(
+            tool_results.iter().any(|t| t.tool_use_id == "toolu_01XYZ"),
+            "current_message 应包含对应的 tool_result"
+        );
+    }
+
+    #[test]
+    fn test_merge_assistant_messages_multiple_tool_uses() {
+        // 测试合并多条 assistant 消息时，所有 tool_use 都被保留
+        use super::super::types::Message as AnthropicMessage;
+
+        let msg1 = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "text", "text": "First action"},
+                {"type": "tool_use", "id": "tool-1", "name": "read", "input": {"path": "/a.txt"}}
+            ]),
+        };
+
+        let msg2 = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "text", "text": "Second action"},
+                {"type": "tool_use", "id": "tool-2", "name": "write", "input": {"path": "/b.txt"}}
+            ]),
+        };
+
+        let messages: Vec<&AnthropicMessage> = vec![&msg1, &msg2];
+        let result = merge_assistant_messages(&messages).expect("合并应成功");
+
+        let tool_uses = result
+            .assistant_response_message
+            .tool_uses
+            .expect("应有 tool_uses");
+
+        assert_eq!(tool_uses.len(), 2, "应保留所有 tool_use");
+        assert!(tool_uses.iter().any(|t| t.tool_use_id == "tool-1"));
+        assert!(tool_uses.iter().any(|t| t.tool_use_id == "tool-2"));
+    }
+
+    #[test]
+    fn test_merge_assistant_messages_only_tool_use() {
+        // 测试合并后只有 tool_use 时，content 使用占位符
+        use super::super::types::Message as AnthropicMessage;
+
+        let msg1 = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "text", "text": " "}  // 空白 text
+            ]),
+        };
+
+        let msg2 = AnthropicMessage {
+            role: "assistant".to_string(),
+            content: serde_json::json!([
+                {"type": "tool_use", "id": "tool-1", "name": "read", "input": {}}
+            ]),
+        };
+
+        let messages: Vec<&AnthropicMessage> = vec![&msg1, &msg2];
+        let result = merge_assistant_messages(&messages).expect("合并应成功");
+
+        // content 应为占位符（因为所有 text 都是空白）
+        assert_eq!(
+            result.assistant_response_message.content, ".",
+            "仅 tool_use 时应使用占位符"
+        );
+    }
+}
diff --git a/src/anthropic/handlers.rs b/src/anthropic/handlers.rs
new file mode 100644
index 0000000..b5cf373
--- /dev/null
+++ b/src/anthropic/handlers.rs
@@ -0,0 +1,1731 @@
+//! Anthropic API Handler 函数
+
+use std::convert::Infallible;
+
+use crate::kiro::model::events::Event;
+use crate::kiro::model::requests::kiro::KiroRequest;
+use crate::kiro::parser::decoder::EventStreamDecoder;
+use crate::token;
+use anyhow::Error;
+use axum::{
+    Json as JsonExtractor,
+    body::Body,
+    extract::State,
+    http::{StatusCode, header},
+    response::{IntoResponse, Json, Response},
+};
+use bytes::Bytes;
+use futures::{Stream, StreamExt, stream};
+use serde_json::json;
+use std::time::Duration;
+use tokio::time::{Instant, interval_at};
+use uuid::Uuid;
+
+/// 自适应压缩：最大迭代次数（避免极端输入导致过长 CPU 消耗）
+const ADAPTIVE_COMPRESSION_MAX_ITERS: usize = 32;
+/// tool_result 二次压缩的最低阈值（字符数）
+const ADAPTIVE_MIN_TOOL_RESULT_MAX_CHARS: usize = 512;
+/// tool_use input 二次压缩的最低阈值（字符数）
+const ADAPTIVE_MIN_TOOL_USE_INPUT_MAX_CHARS: usize = 256;
+/// 历史截断默认保留消息数（与 compressor.rs 的 preserve_count 保持一致）
+const ADAPTIVE_HISTORY_PRESERVE_MESSAGES: usize = 2;
+/// 消息内容二次压缩的最低阈值（字符数）
+const ADAPTIVE_MIN_MESSAGE_CONTENT_MAX_CHARS: usize = 8192;
+
+use super::converter::{ConversionError, convert_request};
+use super::middleware::AppState;
+use super::stream::{BufferedStreamContext, SseEvent, StreamContext};
+use super::types::{
+    CountTokensRequest, CountTokensResponse, ErrorResponse, MessagesRequest, Model, ModelsResponse,
+    OutputConfig, Thinking,
+};
+use super::websearch;
+
+fn is_input_too_long_error(err: &Error) -> bool {
+    // provider.rs 在遇到上游返回的 input-too-long 场景时，会在错误中保留以下关键字：
+    // - CONTENT_LENGTH_EXCEEDS_THRESHOLD
+    // - Input is too long
+    //
+    // 这类错误是确定性的请求问题（缩短输入才可恢复），不应返回 5xx（会诱发客户端重试）。
+    // 注意：不包含 "Improperly formed request"，该错误可能由空消息内容等格式问题引起
+    let s = err.to_string();
+    s.contains("CONTENT_LENGTH_EXCEEDS_THRESHOLD") || s.contains("Input is too long")
+}
+
+fn is_quota_exhausted_error(err: &Error) -> bool {
+    let s = err.to_string();
+    s.contains("所有凭据已用尽")
+}
+
+/// 网络错误关键字（is_transient_upstream_error 和 is_network_error 共用）
+const NETWORK_ERROR_PATTERNS: &[&str] = &[
+    "error sending request",
+    "connection closed",
+    "connection reset",
+];
+
+fn is_network_error(s: &str) -> bool {
+    NETWORK_ERROR_PATTERNS.iter().any(|p| s.contains(p))
+}
+
+fn is_transient_upstream_error(err: &Error) -> bool {
+    let s = err.to_string().to_lowercase();
+    s.contains("429 too many requests")
+        || s.contains("insufficient_model_capacity")
+        || s.contains("high traffic")
+        || s.contains("408 request timeout")
+        || s.contains("502 bad gateway")
+        || s.contains("503 service unavailable")
+        || s.contains("504 gateway timeout")
+        || is_network_error(&s)
+}
+
+fn is_improperly_formed_request_error(err: &Error) -> bool {
+    let s = err.to_string();
+    s.contains("Improperly formed request")
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+struct AdaptiveCompressionOutcome {
+    initial_bytes: usize,
+    final_bytes: usize,
+    iters: usize,
+    additional_history_turns_removed: usize,
+    final_tool_result_max_chars: usize,
+    final_tool_use_input_max_chars: usize,
+    final_message_content_max_chars: usize,
+}
+
+/// 计算 KiroRequest 中所有图片 base64 数据的总字节数。
+///
+/// 该统计用于归因请求体大小（图片 base64 往往占用大量 bytes）。
+/// 注意：上游存在请求体大小硬限制（约 5MiB），因此图片也必须控制体积；
+/// `max_request_body_bytes` 的校验以实际序列化后的总字节数为准。
+fn total_image_bytes(kiro_request: &KiroRequest) -> usize {
+    let state = &kiro_request.conversation_state;
+    let mut total = 0usize;
+
+    // currentMessage 中的图片
+    for img in &state.current_message.user_input_message.images {
+        total += img.source.bytes.len();
+    }
+
+    // 历史消息中的图片
+    for msg in &state.history {
+        if let crate::kiro::model::requests::conversation::Message::User(user_msg) = msg {
+            for img in &user_msg.user_input_message.images {
+                total += img.source.bytes.len();
+            }
+        }
+    }
+
+    total
+}
+
+fn adaptive_shrink_request_body(
+    kiro_request: &mut KiroRequest,
+    base_config: &crate::model::config::CompressionConfig,
+    max_body: usize,
+    request_body: &mut String,
+) -> Result<Option<AdaptiveCompressionOutcome>, serde_json::Error> {
+    if max_body == 0 || request_body.len() <= max_body || !base_config.enabled {
+        return Ok(None);
+    }
+
+    let mut outcome = AdaptiveCompressionOutcome {
+        initial_bytes: request_body.len(),
+        final_bytes: request_body.len(),
+        iters: 0,
+        additional_history_turns_removed: 0,
+        final_tool_result_max_chars: base_config.tool_result_max_chars,
+        final_tool_use_input_max_chars: base_config.tool_use_input_max_chars,
+        final_message_content_max_chars: 0,
+    };
+
+    // 二次压缩策略：
+    // 1) 逐步降低 tool_result_max_chars（仅当存在 tool_result/tools）
+    // 2) 逐步降低 tool_use_input_max_chars（仅当存在 tool_use）
+    // 3) 截断超长用户消息内容（当单条消息已超过阈值时优先）
+    // 4) 按 request_body_bytes 成对移除最老的 user+assistant 两条消息（保留前 2 条）
+    //
+    // 每轮都会重新跑一次压缩管道（包含 tool 配对修复），再重新序列化计算字节数。
+    let mut adaptive_config = base_config.clone();
+
+    // 是否存在任何 tool_result / tools（否则降低阈值只会浪费迭代次数）
+    let has_any_tool_results_or_tools = {
+        let state = &kiro_request.conversation_state;
+        if !state
+            .current_message
+            .user_input_message
+            .user_input_message_context
+            .tool_results
+            .is_empty()
+            || !state
+                .current_message
+                .user_input_message
+                .user_input_message_context
+                .tools
+                .is_empty()
+        {
+            true
+        } else {
+            state.history.iter().any(|msg| match msg {
+                crate::kiro::model::requests::conversation::Message::User(u) => {
+                    !u.user_input_message
+                        .user_input_message_context
+                        .tool_results
+                        .is_empty()
+                        || !u
+                            .user_input_message
+                            .user_input_message_context
+                            .tools
+                            .is_empty()
+                }
+                _ => false,
+            })
+        }
+    };
+
+    // 是否存在任何 tool_use（否则降低阈值只会浪费迭代次数）
+    let has_any_tool_uses = kiro_request
+        .conversation_state
+        .history
+        .iter()
+        .any(|msg| match msg {
+            crate::kiro::model::requests::conversation::Message::Assistant(a) => a
+                .assistant_response_message
+                .tool_uses
+                .as_ref()
+                .is_some_and(|t| !t.is_empty()),
+            _ => false,
+        });
+
+    // 扫描所有用户消息，找到最大 content 字符数作为初始 message_content_max_chars
+    let max_content_chars = {
+        let mut max_chars = kiro_request
+            .conversation_state
+            .current_message
+            .user_input_message
+            .content
+            .chars()
+            .count();
+        for msg in &kiro_request.conversation_state.history {
+            if let crate::kiro::model::requests::conversation::Message::User(u) = msg {
+                max_chars = max_chars.max(u.user_input_message.content.chars().count());
+            }
+        }
+        max_chars
+    };
+    // 初始值设为最大消息字符数的 3/4
+    let mut message_content_max_chars =
+        (max_content_chars * 3 / 4).max(ADAPTIVE_MIN_MESSAGE_CONTENT_MAX_CHARS);
+
+    for _ in 0..ADAPTIVE_COMPRESSION_MAX_ITERS {
+        if request_body.len() <= max_body {
+            break;
+        }
+
+        let mut changed = false;
+
+        if has_any_tool_results_or_tools
+            && adaptive_config.tool_result_max_chars > ADAPTIVE_MIN_TOOL_RESULT_MAX_CHARS
+        {
+            let next = (adaptive_config.tool_result_max_chars * 3 / 4)
+                .max(ADAPTIVE_MIN_TOOL_RESULT_MAX_CHARS);
+            if next < adaptive_config.tool_result_max_chars {
+                adaptive_config.tool_result_max_chars = next;
+                changed = true;
+            }
+        } else if has_any_tool_uses
+            && adaptive_config.tool_use_input_max_chars > ADAPTIVE_MIN_TOOL_USE_INPUT_MAX_CHARS
+        {
+            let next = (adaptive_config.tool_use_input_max_chars * 3 / 4)
+                .max(ADAPTIVE_MIN_TOOL_USE_INPUT_MAX_CHARS);
+            if next < adaptive_config.tool_use_input_max_chars {
+                adaptive_config.tool_use_input_max_chars = next;
+                changed = true;
+            }
+        } else {
+            // 如果任意单条 user content 已经超过 max_body，则移除历史并不能让请求落到阈值内，
+            // 必须优先截断超长消息内容。
+            let max_single_user_content_bytes = {
+                let state = &kiro_request.conversation_state;
+                let mut max_bytes = state.current_message.user_input_message.content.len();
+                for msg in &state.history {
+                    if let crate::kiro::model::requests::conversation::Message::User(u) = msg {
+                        max_bytes = max_bytes.max(u.user_input_message.content.len());
+                    }
+                }
+                max_bytes
+            };
+
+            let history = &mut kiro_request.conversation_state.history;
+            if (max_single_user_content_bytes > max_body
+                || history.len() <= ADAPTIVE_HISTORY_PRESERVE_MESSAGES + 2)
+                && message_content_max_chars >= ADAPTIVE_MIN_MESSAGE_CONTENT_MAX_CHARS
+            {
+                // 第三层：截断超长消息内容
+                let saved = super::compressor::compress_long_messages_pass(
+                    &mut kiro_request.conversation_state,
+                    message_content_max_chars,
+                );
+                if saved > 0 {
+                    changed = true;
+                }
+                // 记录本轮实际生效的阈值（递减前）
+                outcome.final_message_content_max_chars = message_content_max_chars;
+                // 每轮递减 3/4
+                message_content_max_chars =
+                    (message_content_max_chars * 3 / 4).max(ADAPTIVE_MIN_MESSAGE_CONTENT_MAX_CHARS);
+            } else if history.len() > ADAPTIVE_HISTORY_PRESERVE_MESSAGES + 2 {
+                // 第四层：移除最老历史消息（成对移除 user+assistant）
+                let preserve = ADAPTIVE_HISTORY_PRESERVE_MESSAGES;
+                let min_len = preserve + 2;
+                let removable = history.len().saturating_sub(min_len);
+                // 单轮最多移除 16 条消息（8 轮），避免一次性丢弃过多上下文
+                let mut remove_msgs = removable.min(16);
+                remove_msgs -= remove_msgs % 2; // 保持成对移除
+                if remove_msgs > 0 {
+                    history.drain(preserve..preserve + remove_msgs);
+                    outcome.additional_history_turns_removed += remove_msgs / 2;
+                    changed = true;
+                }
+            }
+        }
+
+        if !changed {
+            break;
+        }
+
+        super::compressor::compress(&mut kiro_request.conversation_state, &adaptive_config);
+        *request_body = serde_json::to_string(kiro_request)?;
+        outcome.iters += 1;
+        outcome.final_bytes = request_body.len();
+    }
+
+    outcome.final_tool_result_max_chars = adaptive_config.tool_result_max_chars;
+    outcome.final_tool_use_input_max_chars = adaptive_config.tool_use_input_max_chars;
+    // final_message_content_max_chars 在循环内截断时已记录实际生效值；
+    // 若第四层从未执行，保持默认 0 表示未触发
+
+    Ok(Some(outcome))
+}
+
+fn map_kiro_provider_error_to_response(request_body: &str, err: Error) -> Response {
+    if is_input_too_long_error(&err) {
+        tracing::warn!(
+            kiro_request_body_bytes = request_body.len(),
+            error = %err,
+            "上游拒绝请求：输入上下文过长（不应重试）"
+        );
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(ErrorResponse::new(
+                "invalid_request_error",
+                "Input is too long (CONTENT_LENGTH_EXCEEDS_THRESHOLD). Reduce conversation history/system/tools; retrying the same request will not help.",
+            )),
+        )
+            .into_response();
+    }
+
+    if is_improperly_formed_request_error(&err) {
+        tracing::warn!(
+            error = %err,
+            "上游拒绝请求：请求格式错误（可能是空消息内容或其他格式问题）"
+        );
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(ErrorResponse::new(
+                "invalid_request_error",
+                "Improperly formed request. Check message content is not empty and request format is valid.",
+            )),
+        )
+            .into_response();
+    }
+
+    if is_quota_exhausted_error(&err) {
+        tracing::warn!(error = %err, "所有凭据配额已耗尽");
+        return (
+            StatusCode::TOO_MANY_REQUESTS,
+            Json(ErrorResponse::new(
+                "rate_limit_error",
+                "All credentials quota exhausted. Please wait for quota reset or add new credentials.",
+            )),
+        )
+            .into_response();
+    }
+
+    if is_transient_upstream_error(&err) {
+        let err_str = err.to_string().to_lowercase();
+        if is_network_error(&err_str) {
+            tracing::warn!(error = %err, "上游网络错误，不输出请求体");
+            return (
+                StatusCode::BAD_GATEWAY,
+                Json(ErrorResponse::new(
+                    "api_error",
+                    format!("上游网络错误: {}", err),
+                )),
+            )
+                .into_response();
+        }
+        tracing::warn!(error = %err, "上游瞬态错误（429/5xx），不输出请求体");
+        return (
+            StatusCode::TOO_MANY_REQUESTS,
+            Json(ErrorResponse::new("rate_limit_error", err.to_string())),
+        )
+            .into_response();
+    }
+
+    tracing::error!("Kiro API 调用失败: {}", err);
+    #[cfg(feature = "sensitive-logs")]
+    tracing::error!(
+        request_body_bytes = request_body.len(),
+        "上游报错，请求体大小: {} bytes",
+        request_body.len()
+    );
+    (
+        StatusCode::BAD_GATEWAY,
+        Json(ErrorResponse::new(
+            "api_error",
+            format!("上游 API 调用失败: {}", err),
+        )),
+    )
+        .into_response()
+}
+
+/// 对 user_id 进行掩码处理，保护隐私
+fn mask_user_id(user_id: Option<&str>) -> String {
+    match user_id {
+        Some(id) => {
+            let chars: Vec<char> = id.chars().collect();
+            let len = chars.len();
+            if len > 25 {
+                format!(
+                    "{}***{}",
+                    chars[..13].iter().collect::<String>(),
+                    chars[len - 8..].iter().collect::<String>()
+                )
+            } else if len > 12 {
+                format!(
+                    "{}***{}",
+                    chars[..4].iter().collect::<String>(),
+                    chars[len - 4..].iter().collect::<String>()
+                )
+            } else {
+                "***".to_string()
+            }
+        }
+        None => "None".to_string(),
+    }
+}
+
+/// GET /v1/models
+///
+/// 返回可用的模型列表
+pub async fn get_models() -> impl IntoResponse {
+    tracing::info!("Received GET /v1/models request");
+
+    let models = vec![
+        Model {
+            id: "claude-sonnet-4-6".to_string(),
+            object: "model".to_string(),
+            created: 1770314400,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Sonnet 4.6".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(1_000_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-sonnet-4-6-thinking".to_string(),
+            object: "model".to_string(),
+            created: 1770314400,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Sonnet 4.6 (Thinking)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(1_000_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-sonnet-4-6-agentic".to_string(),
+            object: "model".to_string(),
+            created: 1770314400,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Sonnet 4.6 (Agentic)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(1_000_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-sonnet-4-5-20250929".to_string(),
+            object: "model".to_string(),
+            created: 1727568000,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Sonnet 4.5".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-sonnet-4-5-20250929-thinking".to_string(),
+            object: "model".to_string(),
+            created: 1727568000,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Sonnet 4.5 (Thinking)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-sonnet-4-5-20250929-agentic".to_string(),
+            object: "model".to_string(),
+            created: 1727568000,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Sonnet 4.5 (Agentic)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-opus-4-5-20251101".to_string(),
+            object: "model".to_string(),
+            created: 1730419200,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Opus 4.5".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-opus-4-5-20251101-thinking".to_string(),
+            object: "model".to_string(),
+            created: 1730419200,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Opus 4.5 (Thinking)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-opus-4-5-20251101-agentic".to_string(),
+            object: "model".to_string(),
+            created: 1730419200,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Opus 4.5 (Agentic)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-opus-4-6".to_string(),
+            object: "model".to_string(),
+            created: 1770314400,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Opus 4.6".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(1_000_000),
+            max_completion_tokens: Some(128_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-opus-4-6-thinking".to_string(),
+            object: "model".to_string(),
+            created: 1770314400,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Opus 4.6 (Thinking)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(1_000_000),
+            max_completion_tokens: Some(128_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-opus-4-6-agentic".to_string(),
+            object: "model".to_string(),
+            created: 1770314400,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Opus 4.6 (Agentic)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(1_000_000),
+            max_completion_tokens: Some(128_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-haiku-4-5-20251001".to_string(),
+            object: "model".to_string(),
+            created: 1727740800,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Haiku 4.5".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-haiku-4-5-20251001-thinking".to_string(),
+            object: "model".to_string(),
+            created: 1727740800,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Haiku 4.5 (Thinking)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+        Model {
+            id: "claude-haiku-4-5-20251001-agentic".to_string(),
+            object: "model".to_string(),
+            created: 1727740800,
+            owned_by: "anthropic".to_string(),
+            display_name: "Claude Haiku 4.5 (Agentic)".to_string(),
+            model_type: "chat".to_string(),
+            max_tokens: 32000,
+            context_length: Some(200_000),
+            max_completion_tokens: Some(64_000),
+            thinking: Some(true),
+        },
+    ];
+
+    Json(ModelsResponse {
+        object: "list".to_string(),
+        data: models,
+    })
+}
+
+/// POST /v1/messages
+///
+/// 创建消息（对话）
+pub async fn post_messages(
+    State(state): State<AppState>,
+    JsonExtractor(mut payload): JsonExtractor<MessagesRequest>,
+) -> Response {
+    // 检测模型名是否包含 "thinking" 后缀，若包含则覆写 thinking 配置
+    override_thinking_from_model_name(&mut payload);
+
+    // 提取 user_id 用于凭据亲和性
+    let user_id = payload.metadata.as_ref().and_then(|m| m.user_id.clone());
+
+    // 估算压缩前 input tokens（需在 convert_request 之前，因为后者会消费压缩）
+    let estimated_input_tokens = token::count_all_tokens(
+        payload.model.clone(),
+        payload.system.clone(),
+        payload.messages.clone(),
+        payload.tools.clone(),
+    ) as i32;
+
+    tracing::info!(
+        model = %payload.model,
+        max_tokens = %payload.max_tokens,
+        stream = %payload.stream,
+        message_count = %payload.messages.len(),
+        user_id = %mask_user_id(user_id.as_deref()),
+        estimated_input_tokens,
+        "Received POST /v1/messages request"
+    );
+    // 检查 KiroProvider 是否可用
+    let provider = match &state.kiro_provider {
+        Some(p) => p.clone(),
+        None => {
+            tracing::error!("KiroProvider 未配置");
+            return (
+                StatusCode::SERVICE_UNAVAILABLE,
+                Json(ErrorResponse::new(
+                    "service_unavailable",
+                    "Kiro API provider not configured",
+                )),
+            )
+                .into_response();
+        }
+    };
+
+    // 检查是否为纯 WebSearch 请求（仅 web_search 单工具 / tool_choice 强制 / 前缀匹配）
+    if websearch::should_handle_websearch_request(&payload) {
+        tracing::info!("检测到纯 WebSearch 请求，路由到本地 WebSearch 处理");
+        return websearch::handle_websearch_request(provider, &payload, estimated_input_tokens)
+            .await;
+    }
+
+    // 混合工具场景：剔除 web_search 后转发上游
+    if websearch::has_web_search_tool(&payload) {
+        tracing::info!("检测到混合工具列表中的 web_search，剔除后转发上游");
+        websearch::strip_web_search_tools(&mut payload);
+    }
+
+    // 转换请求
+    let conversion_result = match convert_request(&payload, &state.compression_config) {
+        Ok(result) => result,
+        Err(e) => {
+            let (error_type, message) = match &e {
+                ConversionError::UnsupportedModel(model) => {
+                    ("invalid_request_error", format!("模型不支持: {}", model))
+                }
+                ConversionError::EmptyMessages => {
+                    ("invalid_request_error", "消息列表为空".to_string())
+                }
+                ConversionError::EmptyMessageContent => {
+                    ("invalid_request_error", "消息内容为空".to_string())
+                }
+            };
+            tracing::warn!("请求转换失败: {}", e);
+            return (
+                StatusCode::BAD_REQUEST,
+                Json(ErrorResponse::new(error_type, message)),
+            )
+                .into_response();
+        }
+    };
+
+    // 输出压缩统计（以字节为单位；用于排查上游请求体大小限制，实测约 5MiB 左右会触发 400）
+    if let Some(ref stats) = conversion_result.compression_stats {
+        tracing::info!(
+            estimated_input_tokens,
+            bytes_saved_total = stats.total_saved(),
+            whitespace_bytes_saved = stats.whitespace_saved,
+            thinking_bytes_saved = stats.thinking_saved,
+            tool_result_bytes_saved = stats.tool_result_saved,
+            tool_use_input_bytes_saved = stats.tool_use_input_saved,
+            history_turns_removed = stats.history_turns_removed,
+            history_bytes_saved = stats.history_bytes_saved,
+            "输入压缩完成"
+        );
+    }
+
+    // 构建 Kiro 请求
+    let mut kiro_request = KiroRequest {
+        conversation_state: conversion_result.conversation_state,
+        profile_arn: state.profile_arn.clone(),
+    };
+
+    let mut request_body = match serde_json::to_string(&kiro_request) {
+        Ok(body) => body,
+        Err(e) => {
+            tracing::error!("序列化请求失败: {}", e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ErrorResponse::new(
+                    "internal_error",
+                    format!("序列化请求失败: {}", e),
+                )),
+            )
+                .into_response();
+        }
+    };
+
+    // 请求体大小预检（上游存在硬性请求体大小限制；按实际序列化后的总字节数判断）
+    let max_body = state.compression_config.max_request_body_bytes;
+    if max_body > 0 && request_body.len() > max_body && state.compression_config.enabled {
+        // 自适应二次压缩：按 request_body_bytes 迭代截断，尽量把请求缩到阈值内
+        match adaptive_shrink_request_body(
+            &mut kiro_request,
+            &state.compression_config,
+            max_body,
+            &mut request_body,
+        ) {
+            Ok(Some(outcome)) => {
+                tracing::warn!(
+                    conversation_id = kiro_request.conversation_state.conversation_id.as_str(),
+                    initial_bytes = outcome.initial_bytes,
+                    final_bytes = outcome.final_bytes,
+                    threshold = max_body,
+                    iters = outcome.iters,
+                    additional_history_turns_removed = outcome.additional_history_turns_removed,
+                    final_tool_result_max_chars = outcome.final_tool_result_max_chars,
+                    final_tool_use_input_max_chars = outcome.final_tool_use_input_max_chars,
+                    final_message_content_max_chars = outcome.final_message_content_max_chars,
+                    "请求体超过阈值，已执行自适应二次压缩"
+                );
+            }
+            Ok(None) => {}
+            Err(e) => {
+                tracing::error!("自适应二次压缩序列化失败: {}", e);
+                return (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(ErrorResponse::new(
+                        "internal_error",
+                        format!("序列化请求失败: {}", e),
+                    )),
+                )
+                    .into_response();
+            }
+        }
+    }
+
+    // 压缩后再次检查（输出 image_bytes/non-image bytes 便于排查）
+    let final_img_bytes = total_image_bytes(&kiro_request);
+    let final_effective_len = request_body.len().saturating_sub(final_img_bytes);
+    if max_body > 0 && request_body.len() > max_body {
+        tracing::warn!(
+            conversation_id = kiro_request.conversation_state.conversation_id.as_str(),
+            request_body_bytes = request_body.len(),
+            image_bytes = final_img_bytes,
+            effective_bytes = final_effective_len,
+            threshold = max_body,
+            "请求体超过安全阈值，拒绝发送"
+        );
+        #[cfg(feature = "sensitive-logs")]
+        tracing::error!(
+            "自适应压缩仍超限，完整请求体（用于诊断）: {}",
+            truncate_base64_in_request_body(&request_body)
+        );
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(ErrorResponse::new(
+                "invalid_request_error",
+                format!(
+                    "Request too large ({} bytes total; images {} bytes; non-image {} bytes; limit {}). Reduce conversation history/tool output or number/size of images.",
+                    request_body.len(),
+                    final_img_bytes,
+                    final_effective_len,
+                    max_body
+                ),
+            )),
+        )
+            .into_response();
+    }
+
+    tracing::debug!(
+        kiro_request_body_bytes = request_body.len(),
+        "已构建 Kiro 请求体"
+    );
+
+    // 检查是否启用了thinking
+    let thinking_enabled = payload
+        .thinking
+        .as_ref()
+        .map(|t| t.is_enabled())
+        .unwrap_or(false);
+
+    if payload.stream {
+        // 流式响应
+        handle_stream_request(
+            provider,
+            &request_body,
+            &payload.model,
+            estimated_input_tokens,
+            thinking_enabled,
+            user_id.as_deref(),
+        )
+        .await
+    } else {
+        // 非流式响应
+        handle_non_stream_request(
+            provider,
+            &request_body,
+            &payload.model,
+            estimated_input_tokens,
+            user_id.as_deref(),
+        )
+        .await
+    }
+}
+async fn handle_stream_request(
+    provider: std::sync::Arc<crate::kiro::provider::KiroProvider>,
+    request_body: &str,
+    model: &str,
+    input_tokens: i32,
+    thinking_enabled: bool,
+    user_id: Option<&str>,
+) -> Response {
+    // 调用 Kiro API（支持多凭据故障转移）
+    let response = match provider.call_api_stream(request_body, user_id).await {
+        Ok(resp) => resp,
+        Err(e) => return map_kiro_provider_error_to_response(request_body, e),
+    };
+
+    // 创建流处理上下文
+    let mut ctx = StreamContext::new_with_thinking(model, input_tokens, thinking_enabled);
+
+    // 生成初始事件
+    let initial_events = ctx.generate_initial_events();
+
+    // 创建 SSE 流
+    let stream = create_sse_stream(response, ctx, initial_events);
+
+    // 返回 SSE 响应
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, "text/event-stream")
+        .header(header::CACHE_CONTROL, "no-cache")
+        .header(header::CONNECTION, "keep-alive")
+        .body(Body::from_stream(stream))
+        .unwrap()
+}
+
+/// Ping 事件间隔（25秒）
+const PING_INTERVAL_SECS: u64 = 25;
+
+/// 创建 ping 事件的 SSE 字符串
+fn create_ping_sse() -> Bytes {
+    Bytes::from("event: ping\ndata: {\"type\": \"ping\"}\n\n")
+}
+
+/// 创建 SSE 事件流
+fn create_sse_stream(
+    response: reqwest::Response,
+    ctx: StreamContext,
+    initial_events: Vec<SseEvent>,
+) -> impl Stream<Item = Result<Bytes, Infallible>> {
+    // 先发送初始事件
+    let initial_stream = stream::iter(
+        initial_events
+            .into_iter()
+            .map(|e| Ok(Bytes::from(e.to_sse_string()))),
+    );
+
+    // 然后处理 Kiro 响应流，同时每25秒发送 ping 保活
+    let body_stream = response.bytes_stream();
+    let ping_period = Duration::from_secs(PING_INTERVAL_SECS);
+    let ping_interval = interval_at(Instant::now() + ping_period, ping_period);
+
+    let processing_stream = stream::unfold(
+        (body_stream, ctx, EventStreamDecoder::new(), false, ping_interval),
+        |(mut body_stream, mut ctx, mut decoder, finished, mut ping_interval)| async move {
+            if finished {
+                return None;
+            }
+
+            // 使用 select! 同时等待数据和 ping 定时器
+            tokio::select! {
+                // 处理数据流
+                chunk_result = body_stream.next() => {
+                    match chunk_result {
+                        Some(Ok(chunk)) => {
+                            // 解码事件
+                            if let Err(e) = decoder.feed(&chunk) {
+                                tracing::warn!("缓冲区溢出: {}", e);
+                            }
+
+                            let mut events = Vec::new();
+                            for result in decoder.decode_iter() {
+                                match result {
+                                    Ok(frame) => {
+                                        if let Ok(event) = Event::from_frame(frame) {
+                                            let sse_events = ctx.process_kiro_event(&event);
+                                            events.extend(sse_events);
+                                        }
+                                    }
+                                    Err(e) => {
+                                        tracing::warn!("解码事件失败: {}", e);
+                                    }
+                                }
+                            }
+
+                            // 转换为 SSE 字节流
+                            let bytes: Vec<Result<Bytes, Infallible>> = events
+                                .into_iter()
+                                .map(|e| Ok(Bytes::from(e.to_sse_string())))
+                                .collect();
+
+                            Some((stream::iter(bytes), (body_stream, ctx, decoder, false, ping_interval)))
+                        }
+                        Some(Err(e)) => {
+                            tracing::error!("读取响应流失败: {}", e);
+                            // 发送最终事件并结束
+                            let final_events = ctx.generate_final_events();
+                            let bytes: Vec<Result<Bytes, Infallible>> = final_events
+                                .into_iter()
+                                .map(|e| Ok(Bytes::from(e.to_sse_string())))
+                                .collect();
+                            Some((stream::iter(bytes), (body_stream, ctx, decoder, true, ping_interval)))
+                        }
+                        None => {
+                            // 流结束，发送最终事件
+                            let final_events = ctx.generate_final_events();
+                            let bytes: Vec<Result<Bytes, Infallible>> = final_events
+                                .into_iter()
+                                .map(|e| Ok(Bytes::from(e.to_sse_string())))
+                                .collect();
+                            Some((stream::iter(bytes), (body_stream, ctx, decoder, true, ping_interval)))
+                        }
+                    }
+                }
+                // 发送 ping 保活
+                _ = ping_interval.tick() => {
+                    tracing::trace!("发送 ping 保活事件");
+                    let bytes: Vec<Result<Bytes, Infallible>> = vec![Ok(create_ping_sse())];
+                    Some((stream::iter(bytes), (body_stream, ctx, decoder, false, ping_interval)))
+                }
+            }
+        },
+    )
+    .flatten();
+
+    initial_stream.chain(processing_stream)
+}
+
+/// 处理非流式请求
+async fn handle_non_stream_request(
+    provider: std::sync::Arc<crate::kiro::provider::KiroProvider>,
+    request_body: &str,
+    model: &str,
+    input_tokens: i32,
+    user_id: Option<&str>,
+) -> Response {
+    // 调用 Kiro API（支持多凭据故障转移）
+    let response = match provider.call_api(request_body, user_id).await {
+        Ok(resp) => resp,
+        Err(e) => return map_kiro_provider_error_to_response(request_body, e),
+    };
+
+    // 读取响应体
+    let body_bytes = match response.bytes().await {
+        Ok(bytes) => bytes,
+        Err(e) => {
+            tracing::error!("读取响应体失败: {}", e);
+            return (
+                StatusCode::BAD_GATEWAY,
+                Json(ErrorResponse::new(
+                    "api_error",
+                    format!("读取响应失败: {}", e),
+                )),
+            )
+                .into_response();
+        }
+    };
+
+    // 解析事件流
+    let mut decoder = EventStreamDecoder::new();
+    if let Err(e) = decoder.feed(&body_bytes) {
+        tracing::warn!("缓冲区溢出: {}", e);
+    }
+
+    let mut text_content = String::new();
+    let mut tool_uses: Vec<serde_json::Value> = Vec::new();
+    let mut has_tool_use = false;
+    let mut stop_reason = "end_turn".to_string();
+    // 从 contextUsageEvent 计算的实际输入 tokens
+    let mut context_input_tokens: Option<i32> = None;
+
+    // 收集工具调用的增量 JSON
+    let mut tool_json_buffers: std::collections::HashMap<String, String> =
+        std::collections::HashMap::new();
+
+    for result in decoder.decode_iter() {
+        match result {
+            Ok(frame) => {
+                if let Ok(event) = Event::from_frame(frame) {
+                    match event {
+                        Event::AssistantResponse(resp) => {
+                            text_content.push_str(&resp.content);
+                        }
+                        Event::ToolUse(tool_use) => {
+                            has_tool_use = true;
+
+                            // 累积工具的 JSON 输入
+                            let buffer = tool_json_buffers
+                                .entry(tool_use.tool_use_id.clone())
+                                .or_default();
+                            buffer.push_str(&tool_use.input);
+
+                            // 如果是完整的工具调用，添加到列表
+                            if tool_use.stop {
+                                let input: serde_json::Value = if buffer.trim().is_empty() {
+                                    // 上游可能省略无参工具的 input 字段（或传空字符串）。
+                                    // 这里将其视为合法的空对象，避免 EOF 解析错误导致日志噪音。
+                                    serde_json::json!({})
+                                } else {
+                                    serde_json::from_str(buffer).unwrap_or_else(|e| {
+                                        // 检测是否为截断导致的解析失败
+                                        if let Some(truncation_info) =
+                                            super::truncation::detect_truncation(
+                                                &tool_use.name,
+                                                &tool_use.tool_use_id,
+                                                buffer,
+                                            )
+                                        {
+                                            let soft_msg =
+                                                super::truncation::build_soft_failure_result(
+                                                    &truncation_info,
+                                                );
+                                            tracing::warn!(
+                                                tool_use_id = %tool_use.tool_use_id,
+                                                truncation_type = %truncation_info.truncation_type,
+                                                "检测到工具调用截断: {}", soft_msg
+                                            );
+                                        }
+
+                                        // 仅在显式开启敏感日志时输出完整内容
+                                        #[cfg(feature = "sensitive-logs")]
+                                        tracing::warn!(
+                                            tool_use_id = %tool_use.tool_use_id,
+                                            buffer = %buffer,
+                                            request_body = %truncate_middle(request_body, 1200),
+                                            "工具输入 JSON 解析失败: {e}"
+                                        );
+                                        #[cfg(not(feature = "sensitive-logs"))]
+                                        tracing::warn!(
+                                            tool_use_id = %tool_use.tool_use_id,
+                                            buffer_bytes = buffer.len(),
+                                            request_body_bytes = request_body.len(),
+                                            "工具输入 JSON 解析失败: {e}"
+                                        );
+                                        serde_json::json!({})
+                                    })
+                                };
+
+                                // 释放已完成的 buffer，避免请求处理期间内存重复占用
+                                tool_json_buffers.remove(&tool_use.tool_use_id);
+
+                                tool_uses.push(json!({
+                                    "type": "tool_use",
+                                    "id": tool_use.tool_use_id,
+                                    "name": tool_use.name,
+                                    "input": input
+                                }));
+                            }
+                        }
+                        Event::ContextUsage(context_usage) => {
+                            // 从上下文使用百分比计算实际的 input_tokens
+                            let context_window =
+                                super::types::get_context_window_size(model) as f64;
+                            let actual_input_tokens =
+                                (context_usage.context_usage_percentage * context_window / 100.0)
+                                    as i32;
+                            context_input_tokens = Some(actual_input_tokens);
+                            // 上下文使用量达到 100% 时，设置 stop_reason 为 model_context_window_exceeded
+                            if context_usage.context_usage_percentage >= 100.0 {
+                                stop_reason = "model_context_window_exceeded".to_string();
+                            }
+                            tracing::debug!(
+                                "收到 contextUsageEvent: {}%, 计算 input_tokens: {} (context_window: {})",
+                                context_usage.context_usage_percentage,
+                                actual_input_tokens,
+                                context_window as i32
+                            );
+                        }
+                        Event::Exception { exception_type, .. } => {
+                            if exception_type == "ContentLengthExceededException" {
+                                stop_reason = "max_tokens".to_string();
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            Err(e) => {
+                tracing::warn!("解码事件失败: {}", e);
+            }
+        }
+    }
+
+    // 确定 stop_reason
+    if has_tool_use && stop_reason == "end_turn" {
+        stop_reason = "tool_use".to_string();
+    }
+
+    // 构建响应内容
+    let mut content: Vec<serde_json::Value> = Vec::new();
+
+    if !text_content.is_empty() {
+        content.push(json!({
+            "type": "text",
+            "text": text_content
+        }));
+    }
+
+    content.extend(tool_uses);
+
+    // 估算输出 tokens
+    let output_tokens = token::estimate_output_tokens(&content);
+
+    // 使用从 contextUsageEvent 计算的 input_tokens，如果没有则使用估算值
+    let final_input_tokens = context_input_tokens.unwrap_or(input_tokens);
+
+    #[cfg(feature = "sensitive-logs")]
+    tracing::info!(
+        estimated_input_tokens = input_tokens,
+        context_input_tokens = ?context_input_tokens,
+        final_input_tokens,
+        output_tokens,
+        "Non-stream usage: final_input_tokens={} (来源={}), output_tokens={}",
+        final_input_tokens,
+        if context_input_tokens.is_some() { "contextUsageEvent" } else { "估算" },
+        output_tokens
+    );
+
+    // 构建 Anthropic 响应
+    let response_body = json!({
+        "id": format!("msg_{}", Uuid::new_v4().to_string().replace('-', "")),
+        "type": "message",
+        "role": "assistant",
+        "content": content,
+        "model": model,
+        "stop_reason": stop_reason,
+        "stop_sequence": null,
+        "usage": {
+            "input_tokens": final_input_tokens,
+            "output_tokens": output_tokens
+        }
+    });
+
+    (StatusCode::OK, Json(response_body)).into_response()
+}
+
+/// 检测模型名是否包含 "thinking" 后缀，若包含则覆写 thinking 配置
+///
+/// 支持的后缀格式：
+/// - `-thinking-minimal` → budget 512
+/// - `-thinking-low` → budget 1024
+/// - `-thinking-medium` → budget 8192
+/// - `-thinking-high` → budget 24576
+/// - `-thinking-xhigh` → budget 32768
+/// - `-thinking` → budget 20000（默认）
+///
+/// - Opus 4.6：覆写为 adaptive 类型
+/// - 其他模型：覆写为 enabled 类型
+fn override_thinking_from_model_name(payload: &mut MessagesRequest) {
+    let model_lower = payload.model.to_lowercase();
+    if !model_lower.contains("thinking") {
+        return;
+    }
+
+    // 具体后缀必须在通用 "thinking" 之前匹配
+    let budget_tokens = if model_lower.ends_with("-thinking-minimal") {
+        512
+    } else if model_lower.ends_with("-thinking-low") {
+        1024
+    } else if model_lower.ends_with("-thinking-medium") {
+        8192
+    } else if model_lower.ends_with("-thinking-high") {
+        24576
+    } else if model_lower.ends_with("-thinking-xhigh") {
+        32768
+    } else if model_lower.ends_with("-thinking") {
+        20000
+    } else {
+        // "thinking" 出现在模型名中但不是后缀（如 "thinking-model-v2"），不覆写
+        return;
+    };
+
+    let is_opus_or_sonnet_4_6 = (model_lower.contains("opus") || model_lower.contains("sonnet"))
+        && (model_lower.contains("4-6") || model_lower.contains("4.6"));
+
+    let thinking_type = if is_opus_or_sonnet_4_6 {
+        "adaptive"
+    } else {
+        "enabled"
+    };
+
+    tracing::info!(
+        model = %payload.model,
+        thinking_type = thinking_type,
+        budget_tokens = budget_tokens,
+        "模型名包含 thinking 后缀，覆写 thinking 配置"
+    );
+
+    payload.thinking = Some(Thinking {
+        thinking_type: thinking_type.to_string(),
+        budget_tokens,
+    });
+
+    if is_opus_or_sonnet_4_6 {
+        payload.output_config = Some(OutputConfig {
+            effort: "high".to_string(),
+        });
+    }
+}
+
+/// POST /v1/messages/count_tokens
+///
+/// 计算消息的 token 数量
+pub async fn count_tokens(
+    JsonExtractor(payload): JsonExtractor<CountTokensRequest>,
+) -> impl IntoResponse {
+    tracing::info!(
+        model = %payload.model,
+        message_count = %payload.messages.len(),
+        "Received POST /v1/messages/count_tokens request"
+    );
+
+    let total_tokens = token::count_all_tokens(
+        payload.model.clone(),
+        payload.system.clone(),
+        payload.messages.clone(),
+        payload.tools.clone(),
+    ) as i32;
+
+    Json(CountTokensResponse {
+        input_tokens: total_tokens.max(1) as i32,
+    })
+}
+
+/// POST /cc/v1/messages
+///
+/// Claude Code 兼容端点，与 /v1/messages 的区别在于：
+/// - 流式响应会等待 kiro 端返回 contextUsageEvent 后再发送 message_start
+/// - message_start 中的 input_tokens 是从 contextUsageEvent 计算的准确值
+pub async fn post_messages_cc(
+    State(state): State<AppState>,
+    JsonExtractor(mut payload): JsonExtractor<MessagesRequest>,
+) -> Response {
+    // 检查 KiroProvider 是否可用
+    let provider = match &state.kiro_provider {
+        Some(p) => p.clone(),
+        None => {
+            tracing::error!("KiroProvider 未配置");
+            return (
+                StatusCode::SERVICE_UNAVAILABLE,
+                Json(ErrorResponse::new(
+                    "service_unavailable",
+                    "Kiro API provider not configured",
+                )),
+            )
+                .into_response();
+        }
+    };
+
+    // 检测模型名是否包含 "thinking" 后缀，若包含则覆写 thinking 配置
+    override_thinking_from_model_name(&mut payload);
+
+    // 估算压缩前 input tokens（需在 convert_request 之前）
+    let estimated_input_tokens = token::count_all_tokens(
+        payload.model.clone(),
+        payload.system.clone(),
+        payload.messages.clone(),
+        payload.tools.clone(),
+    ) as i32;
+
+    tracing::info!(
+        model = %payload.model,
+        max_tokens = %payload.max_tokens,
+        stream = %payload.stream,
+        message_count = %payload.messages.len(),
+        estimated_input_tokens,
+        "Received POST /cc/v1/messages request"
+    );
+
+    // 检查是否为纯 WebSearch 请求（仅 web_search 单工具 / tool_choice 强制 / 前缀匹配）
+    if websearch::should_handle_websearch_request(&payload) {
+        tracing::info!("检测到纯 WebSearch 请求，路由到本地 WebSearch 处理");
+        return websearch::handle_websearch_request(provider, &payload, estimated_input_tokens)
+            .await;
+    }
+
+    // 混合工具场景：剔除 web_search 后转发上游
+    if websearch::has_web_search_tool(&payload) {
+        tracing::info!("检测到混合工具列表中的 web_search，剔除后转发上游");
+        websearch::strip_web_search_tools(&mut payload);
+    }
+
+    // 转换请求
+    let conversion_result = match convert_request(&payload, &state.compression_config) {
+        Ok(result) => result,
+        Err(e) => {
+            let (error_type, message) = match &e {
+                ConversionError::UnsupportedModel(model) => {
+                    ("invalid_request_error", format!("模型不支持: {}", model))
+                }
+                ConversionError::EmptyMessages => {
+                    ("invalid_request_error", "消息列表为空".to_string())
+                }
+                ConversionError::EmptyMessageContent => {
+                    ("invalid_request_error", "消息内容为空".to_string())
+                }
+            };
+            tracing::warn!("请求转换失败: {}", e);
+            return (
+                StatusCode::BAD_REQUEST,
+                Json(ErrorResponse::new(error_type, message)),
+            )
+                .into_response();
+        }
+    };
+
+    // 输出压缩统计（以字节为单位；用于排查上游请求体大小限制，实测约 5MiB 左右会触发 400）
+    if let Some(ref stats) = conversion_result.compression_stats {
+        tracing::info!(
+            estimated_input_tokens,
+            bytes_saved_total = stats.total_saved(),
+            whitespace_bytes_saved = stats.whitespace_saved,
+            thinking_bytes_saved = stats.thinking_saved,
+            tool_result_bytes_saved = stats.tool_result_saved,
+            tool_use_input_bytes_saved = stats.tool_use_input_saved,
+            history_turns_removed = stats.history_turns_removed,
+            history_bytes_saved = stats.history_bytes_saved,
+            "输入压缩完成"
+        );
+    }
+
+    // 构建 Kiro 请求
+    let mut kiro_request = KiroRequest {
+        conversation_state: conversion_result.conversation_state,
+        profile_arn: state.profile_arn.clone(),
+    };
+
+    let mut request_body = match serde_json::to_string(&kiro_request) {
+        Ok(body) => body,
+        Err(e) => {
+            tracing::error!("序列化请求失败: {}", e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ErrorResponse::new(
+                    "internal_error",
+                    format!("序列化请求失败: {}", e),
+                )),
+            )
+                .into_response();
+        }
+    };
+
+    // 请求体大小预检（上游存在硬性请求体大小限制；按实际序列化后的总字节数判断）
+    let max_body = state.compression_config.max_request_body_bytes;
+    if max_body > 0 && request_body.len() > max_body && state.compression_config.enabled {
+        // 自适应二次压缩：按 request_body_bytes 迭代截断，尽量把请求缩到阈值内
+        match adaptive_shrink_request_body(
+            &mut kiro_request,
+            &state.compression_config,
+            max_body,
+            &mut request_body,
+        ) {
+            Ok(Some(outcome)) => {
+                tracing::warn!(
+                    conversation_id = kiro_request.conversation_state.conversation_id.as_str(),
+                    initial_bytes = outcome.initial_bytes,
+                    final_bytes = outcome.final_bytes,
+                    threshold = max_body,
+                    iters = outcome.iters,
+                    additional_history_turns_removed = outcome.additional_history_turns_removed,
+                    final_tool_result_max_chars = outcome.final_tool_result_max_chars,
+                    final_tool_use_input_max_chars = outcome.final_tool_use_input_max_chars,
+                    final_message_content_max_chars = outcome.final_message_content_max_chars,
+                    "请求体超过阈值，已执行自适应二次压缩"
+                );
+            }
+            Ok(None) => {}
+            Err(e) => {
+                tracing::error!("自适应二次压缩序列化失败: {}", e);
+                return (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(ErrorResponse::new(
+                        "internal_error",
+                        format!("序列化请求失败: {}", e),
+                    )),
+                )
+                    .into_response();
+            }
+        }
+    }
+
+    // 压缩后再次检查（输出 image_bytes/non-image bytes 便于排查）
+    let final_img_bytes = total_image_bytes(&kiro_request);
+    let final_effective_len = request_body.len().saturating_sub(final_img_bytes);
+    if max_body > 0 && request_body.len() > max_body {
+        tracing::warn!(
+            conversation_id = kiro_request.conversation_state.conversation_id.as_str(),
+            request_body_bytes = request_body.len(),
+            image_bytes = final_img_bytes,
+            effective_bytes = final_effective_len,
+            threshold = max_body,
+            "请求体超过安全阈值，拒绝发送"
+        );
+        #[cfg(feature = "sensitive-logs")]
+        tracing::error!(
+            "自适应压缩仍超限，完整请求体（用于诊断）: {}",
+            truncate_base64_in_request_body(&request_body)
+        );
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(ErrorResponse::new(
+                "invalid_request_error",
+                format!(
+                    "Request too large ({} bytes total; images {} bytes; non-image {} bytes; limit {}). Reduce conversation history/tool output or number/size of images.",
+                    request_body.len(),
+                    final_img_bytes,
+                    final_effective_len,
+                    max_body
+                ),
+            )),
+        )
+            .into_response();
+    }
+
+    tracing::debug!(
+        kiro_request_body_bytes = request_body.len(),
+        "已构建 Kiro 请求体"
+    );
+
+    // 检查是否启用了thinking
+    let thinking_enabled = payload
+        .thinking
+        .as_ref()
+        .map(|t| t.is_enabled())
+        .unwrap_or(false);
+
+    if payload.stream {
+        // 流式响应（缓冲模式）
+        let user_id = payload.metadata.as_ref().and_then(|m| m.user_id.as_deref());
+        handle_stream_request_buffered(
+            provider,
+            &request_body,
+            &payload.model,
+            estimated_input_tokens,
+            thinking_enabled,
+            user_id,
+        )
+        .await
+    } else {
+        // 非流式响应（复用现有逻辑，已经使用正确的 input_tokens）
+        let user_id = payload.metadata.as_ref().and_then(|m| m.user_id.as_deref());
+        handle_non_stream_request(
+            provider,
+            &request_body,
+            &payload.model,
+            estimated_input_tokens,
+            user_id,
+        )
+        .await
+    }
+}
+
+/// 处理流式请求（缓冲版本）
+///
+/// 与 `handle_stream_request` 不同，此函数会缓冲所有事件直到流结束，
+/// 然后用从 contextUsageEvent 计算的正确 input_tokens 生成 message_start 事件。
+async fn handle_stream_request_buffered(
+    provider: std::sync::Arc<crate::kiro::provider::KiroProvider>,
+    request_body: &str,
+    model: &str,
+    estimated_input_tokens: i32,
+    thinking_enabled: bool,
+    user_id: Option<&str>,
+) -> Response {
+    // 调用 Kiro API（支持多凭据故障转移）
+    let response = match provider.call_api_stream(request_body, user_id).await {
+        Ok(resp) => resp,
+        Err(e) => return map_kiro_provider_error_to_response(request_body, e),
+    };
+
+    // 创建缓冲流处理上下文
+    let ctx = BufferedStreamContext::new(model, estimated_input_tokens, thinking_enabled);
+
+    // 创建缓冲 SSE 流
+    let stream = create_buffered_sse_stream(response, ctx);
+
+    // 返回 SSE 响应
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, "text/event-stream")
+        .header(header::CACHE_CONTROL, "no-cache")
+        .header(header::CONNECTION, "keep-alive")
+        .body(Body::from_stream(stream))
+        .unwrap()
+}
+
+/// 创建缓冲 SSE 事件流
+///
+/// 工作流程：
+/// 1. 等待上游流完成，期间只发送 ping 保活信号
+/// 2. 使用 StreamContext 的事件处理逻辑处理所有 Kiro 事件，结果缓存
+/// 3. 流结束后，用正确的 input_tokens 更正 message_start 事件
+/// 4. 一次性发送所有事件
+fn create_buffered_sse_stream(
+    response: reqwest::Response,
+    ctx: BufferedStreamContext,
+) -> impl Stream<Item = Result<Bytes, Infallible>> {
+    let body_stream = response.bytes_stream();
+    let ping_period = Duration::from_secs(PING_INTERVAL_SECS);
+    let ping_interval = interval_at(Instant::now() + ping_period, ping_period);
+
+    stream::unfold(
+        (
+            body_stream,
+            ctx,
+            EventStreamDecoder::new(),
+            false,
+            ping_interval,
+        ),
+        |(mut body_stream, mut ctx, mut decoder, finished, mut ping_interval)| async move {
+            if finished {
+                return None;
+            }
+
+            loop {
+                tokio::select! {
+                    // 使用 biased 模式，优先检查 ping 定时器
+                    // 避免在上游 chunk 密集时 ping 被"饿死"
+                    biased;
+
+                    // 优先检查 ping 保活（等待期间唯一发送的数据）
+                    _ = ping_interval.tick() => {
+                        tracing::trace!("发送 ping 保活事件（缓冲模式）");
+                        let bytes: Vec<Result<Bytes, Infallible>> = vec![Ok(create_ping_sse())];
+                        return Some((stream::iter(bytes), (body_stream, ctx, decoder, false, ping_interval)));
+                    }
+
+                    // 然后处理数据流
+                    chunk_result = body_stream.next() => {
+                        match chunk_result {
+                            Some(Ok(chunk)) => {
+                                // 解码事件
+                                if let Err(e) = decoder.feed(&chunk) {
+                                    tracing::warn!("缓冲区溢出: {}", e);
+                                }
+
+                                for result in decoder.decode_iter() {
+                                    match result {
+                                        Ok(frame) => {
+                                            if let Ok(event) = Event::from_frame(frame) {
+                                                // 缓冲事件（复用 StreamContext 的处理逻辑）
+                                                ctx.process_and_buffer(&event);
+                                            }
+                                        }
+                                        Err(e) => {
+                                            tracing::warn!("解码事件失败: {}", e);
+                                        }
+                                    }
+                                }
+                                // 继续读取下一个 chunk，不发送任何数据
+                            }
+                            Some(Err(e)) => {
+                                tracing::error!("读取响应流失败: {}", e);
+                                // 发生错误，完成处理并返回所有事件
+                                let all_events = ctx.finish_and_get_all_events();
+                                let bytes: Vec<Result<Bytes, Infallible>> = all_events
+                                    .into_iter()
+                                    .map(|e| Ok(Bytes::from(e.to_sse_string())))
+                                    .collect();
+                                return Some((stream::iter(bytes), (body_stream, ctx, decoder, true, ping_interval)));
+                            }
+                            None => {
+                                // 流结束，完成处理并返回所有事件（已更正 input_tokens）
+                                let all_events = ctx.finish_and_get_all_events();
+                                let bytes: Vec<Result<Bytes, Infallible>> = all_events
+                                    .into_iter()
+                                    .map(|e| Ok(Bytes::from(e.to_sse_string())))
+                                    .collect();
+                                return Some((stream::iter(bytes), (body_stream, ctx, decoder, true, ping_interval)));
+                            }
+                        }
+                    }
+                }
+            }
+        },
+    )
+    .flatten()
+}
+
+/// 截断字符串中间部分，保留头尾各 `keep` 个字符
+///
+/// 用于 debug 日志：避免输出过长的请求体，同时保留足够上下文便于排查。
+/// 正确处理 UTF-8 多字节字符边界，不会截断中文。
+#[cfg(feature = "sensitive-logs")]
+fn truncate_middle(s: &str, keep: usize) -> std::borrow::Cow<'_, str> {
+    // 按字符数计算，避免截断后反而更长
+    let char_count = s.chars().count();
+    let min_omit = 30; // 省略号 + 数字的最小开销，确保截断有意义
+    if char_count <= keep * 2 + min_omit {
+        return std::borrow::Cow::Borrowed(s);
+    }
+
+    // 找到第 keep 个字符的字节边界
+    let head_end = s
+        .char_indices()
+        .nth(keep)
+        .map(|(i, _)| i)
+        .unwrap_or(s.len());
+
+    // 找到倒数第 keep 个字符的字节边界
+    let tail_start = s
+        .char_indices()
+        .nth_back(keep - 1)
+        .map(|(i, _)| i)
+        .unwrap_or(0);
+
+    let omitted = s.len() - head_end - (s.len() - tail_start);
+    std::borrow::Cow::Owned(format!(
+        "{}...({} bytes omitted)...{}",
+        &s[..head_end],
+        omitted,
+        &s[tail_start..]
+    ))
+}
+
+/// sensitive-logs 模式下输出完整请求体，但截断 base64 图片数据
+///
+/// 图片 base64 数据对诊断 400 错误没有价值，但可能占几十 KB。
+/// 扫描 `"bytes":"<base64...>"` 模式，将长 base64 替换为占位符。
+#[cfg(feature = "sensitive-logs")]
+fn truncate_base64_in_request_body(s: &str) -> std::borrow::Cow<'_, str> {
+    const MARKER: &str = r#""bytes":""#;
+    const MIN_BASE64_LEN: usize = 200;
+
+    // 快速路径：没有 "bytes":" 就直接返回
+    if !s.contains(MARKER) {
+        return std::borrow::Cow::Borrowed(s);
+    }
+
+    let mut result = String::with_capacity(s.len());
+    let mut pos = 0;
+    let bytes = s.as_bytes();
+
+    while pos < bytes.len() {
+        if let Some(offset) = s[pos..].find(MARKER) {
+            let marker_start = pos + offset;
+            let value_start = marker_start + MARKER.len();
+
+            // 找到闭合引号（处理转义）
+            let mut end = value_start;
+            let mut escaped = false;
+            while end < bytes.len() {
+                if escaped {
+                    escaped = false;
+                    end += 1;
+                    continue;
+                }
+                match bytes[end] {
+                    b'\\' => {
+                        escaped = true;
+                        end += 1;
+                    }
+                    b'"' => break,
+                    _ => end += 1,
+                }
+            }
+
+            let value_len = end - value_start;
+            if value_len >= MIN_BASE64_LEN && is_likely_base64(&s[value_start..end]) {
+                result.push_str(&s[pos..value_start]);
+                result.push_str(&format!("<BASE64_TRUNCATED:{}>", value_len));
+                pos = end; // 跳到闭合引号，下一轮会输出它
+            } else {
+                // 不是 base64 或太短，原样保留
+                result.push_str(&s[pos..value_start]);
+                pos = value_start;
+            }
+        } else {
+            result.push_str(&s[pos..]);
+            break;
+        }
+    }
+
+    std::borrow::Cow::Owned(result)
+}
+
+#[cfg(feature = "sensitive-logs")]
+fn is_likely_base64(s: &str) -> bool {
+    s.bytes()
+        .take(100)
+        .all(|b| b.is_ascii_alphanumeric() || b == b'+' || b == b'/' || b == b'=')
+}
diff --git a/src/anthropic/middleware.rs b/src/anthropic/middleware.rs
new file mode 100644
index 0000000..5cabddc
--- /dev/null
+++ b/src/anthropic/middleware.rs
@@ -0,0 +1,94 @@
+//! Anthropic API 中间件
+
+use std::sync::Arc;
+
+use axum::{
+    body::Body,
+    extract::State,
+    http::{Request, StatusCode},
+    middleware::Next,
+    response::{IntoResponse, Json, Response},
+};
+
+use crate::common::auth;
+use crate::kiro::provider::KiroProvider;
+use crate::model::config::CompressionConfig;
+
+use super::types::ErrorResponse;
+
+/// 应用共享状态
+#[derive(Clone)]
+pub struct AppState {
+    /// API 密钥
+    pub api_key: String,
+    /// Kiro Provider（可选，用于实际 API 调用）
+    /// 内部使用 MultiTokenManager，已支持线程安全的多凭据管理
+    pub kiro_provider: Option<Arc<KiroProvider>>,
+    /// Profile ARN（可选，用于请求）
+    pub profile_arn: Option<String>,
+    /// 输入压缩配置
+    pub compression_config: CompressionConfig,
+}
+
+impl AppState {
+    /// 创建新的应用状态
+    pub fn new(api_key: impl Into<String>) -> Self {
+        Self {
+            api_key: api_key.into(),
+            kiro_provider: None,
+            profile_arn: None,
+            compression_config: CompressionConfig::default(),
+        }
+    }
+
+    /// 设置 KiroProvider
+    pub fn with_kiro_provider(mut self, provider: KiroProvider) -> Self {
+        self.kiro_provider = Some(Arc::new(provider));
+        self
+    }
+
+    /// 设置 Profile ARN
+    pub fn with_profile_arn(mut self, arn: impl Into<String>) -> Self {
+        self.profile_arn = Some(arn.into());
+        self
+    }
+
+    /// 设置压缩配置
+    pub fn with_compression_config(mut self, config: CompressionConfig) -> Self {
+        self.compression_config = config;
+        self
+    }
+}
+
+/// API Key 认证中间件
+pub async fn auth_middleware(
+    State(state): State<AppState>,
+    request: Request<Body>,
+    next: Next,
+) -> Response {
+    match auth::extract_api_key(&request) {
+        Some(key) if auth::constant_time_eq(&key, &state.api_key) => next.run(request).await,
+        _ => {
+            let error = ErrorResponse::authentication_error();
+            (StatusCode::UNAUTHORIZED, Json(error)).into_response()
+        }
+    }
+}
+
+/// CORS 中间件层
+///
+/// **安全说明**：当前配置允许所有来源（Any），这是为了支持公开 API 服务。
+/// 如果需要更严格的安全控制，请根据实际需求配置具体的允许来源、方法和头信息。
+///
+/// # 配置说明
+/// - `allow_origin(Any)`: 允许任何来源的请求
+/// - `allow_methods(Any)`: 允许任何 HTTP 方法
+/// - `allow_headers(Any)`: 允许任何请求头
+pub fn cors_layer() -> tower_http::cors::CorsLayer {
+    use tower_http::cors::{Any, CorsLayer};
+
+    CorsLayer::new()
+        .allow_origin(Any)
+        .allow_methods(Any)
+        .allow_headers(Any)
+}
diff --git a/src/anthropic/mod.rs b/src/anthropic/mod.rs
new file mode 100644
index 0000000..91bb710
--- /dev/null
+++ b/src/anthropic/mod.rs
@@ -0,0 +1,36 @@
+//! Anthropic API 兼容服务模块
+//!
+//! 提供与 Anthropic Claude API 兼容的 HTTP 服务端点。
+//!
+//! # 支持的端点
+//!
+//! ## 标准端点 (/v1)
+//! - `GET /v1/models` - 获取可用模型列表
+//! - `POST /v1/messages` - 创建消息（对话）
+//! - `POST /v1/messages/count_tokens` - 计算 token 数量
+//!
+//! ## Claude Code 兼容端点 (/cc/v1)
+//! - `POST /cc/v1/messages` - 创建消息（流式响应会等待 contextUsageEvent 后再发送 message_start，确保 input_tokens 准确）
+//! - `POST /cc/v1/messages/count_tokens` - 计算 token 数量（与 /v1 相同）
+//!
+//! # 使用示例
+//! ```rust,ignore
+//! use kiro_rs::anthropic;
+//!
+//! let app = anthropic::create_router("your-api-key");
+//! let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;
+//! axum::serve(listener, app).await?;
+//! ```
+
+mod compressor;
+mod converter;
+mod handlers;
+mod middleware;
+mod router;
+mod stream;
+mod tool_compression;
+mod truncation;
+pub mod types;
+mod websearch;
+
+pub use router::create_router_with_provider;
diff --git a/src/anthropic/router.rs b/src/anthropic/router.rs
new file mode 100644
index 0000000..628fa36
--- /dev/null
+++ b/src/anthropic/router.rs
@@ -0,0 +1,79 @@
+//! Anthropic API 路由配置
+
+use axum::{
+    Router,
+    extract::DefaultBodyLimit,
+    middleware,
+    routing::{get, post},
+};
+
+use crate::kiro::provider::KiroProvider;
+use crate::model::config::CompressionConfig;
+
+use super::{
+    handlers::{count_tokens, get_models, post_messages, post_messages_cc},
+    middleware::{AppState, auth_middleware, cors_layer},
+};
+
+/// 请求体最大大小限制 (50MB)
+const MAX_BODY_SIZE: usize = 50 * 1024 * 1024;
+
+/// 创建 Anthropic API 路由
+///
+/// # 端点
+/// - `GET /v1/models` - 获取可用模型列表
+/// - `POST /v1/messages` - 创建消息（对话）
+/// - `POST /v1/messages/count_tokens` - 计算 token 数量
+///
+/// # 认证
+/// 所有 `/v1` 路径需要 API Key 认证，支持：
+/// - `x-api-key` header
+/// - `Authorization: Bearer <token>` header
+///
+/// # 参数
+/// - `api_key`: API 密钥，用于验证客户端请求
+/// - `kiro_provider`: 可选的 KiroProvider，用于调用上游 API
+///
+/// 创建带有 KiroProvider 的 Anthropic API 路由
+pub fn create_router_with_provider(
+    api_key: impl Into<String>,
+    kiro_provider: Option<KiroProvider>,
+    profile_arn: Option<String>,
+    compression_config: CompressionConfig,
+) -> Router {
+    let mut state = AppState::new(api_key);
+    if let Some(provider) = kiro_provider {
+        state = state.with_kiro_provider(provider);
+    }
+    if let Some(arn) = profile_arn {
+        state = state.with_profile_arn(arn);
+    }
+    state = state.with_compression_config(compression_config);
+
+    // 需要认证的 /v1 路由
+    let v1_routes = Router::new()
+        .route("/models", get(get_models))
+        .route("/messages", post(post_messages))
+        .route("/messages/count_tokens", post(count_tokens))
+        .layer(middleware::from_fn_with_state(
+            state.clone(),
+            auth_middleware,
+        ));
+
+    // 需要认证的 /cc/v1 路由（Claude Code 兼容端点）
+    // 与 /v1 的区别：流式响应会等待 contextUsageEvent 后再发送 message_start
+    let cc_v1_routes = Router::new()
+        .route("/messages", post(post_messages_cc))
+        .route("/messages/count_tokens", post(count_tokens))
+        .layer(middleware::from_fn_with_state(
+            state.clone(),
+            auth_middleware,
+        ));
+
+    Router::new()
+        .nest("/v1", v1_routes)
+        .nest("/cc/v1", cc_v1_routes)
+        .layer(cors_layer())
+        .layer(DefaultBodyLimit::max(MAX_BODY_SIZE))
+        .with_state(state)
+}
diff --git a/src/anthropic/stream.rs b/src/anthropic/stream.rs
new file mode 100644
index 0000000..3e338ba
--- /dev/null
+++ b/src/anthropic/stream.rs
@@ -0,0 +1,1937 @@
+//! 流式响应处理模块
+//!
+//! 实现 Kiro → Anthropic 流式响应转换和 SSE 状态管理
+
+use std::collections::HashMap;
+
+use serde_json::json;
+use uuid::Uuid;
+
+use crate::common::utf8::floor_char_boundary;
+use crate::kiro::model::events::Event;
+
+/// 需要跳过的包裹字符
+///
+/// 当 thinking 标签被这些字符包裹时，认为是在引用标签而非真正的标签：
+/// - 反引号 (`)：行内代码
+/// - 双引号 (")：字符串
+/// - 单引号 (')：字符串
+const QUOTE_CHARS: &[u8] = b"`\"'\\#!@$%^&*()-_=+[]{};:<>,.?/";
+
+/// 检查指定位置的字符是否是引用字符
+fn is_quote_char(buffer: &str, pos: usize) -> bool {
+    buffer
+        .as_bytes()
+        .get(pos)
+        .map(|c| QUOTE_CHARS.contains(c))
+        .unwrap_or(false)
+}
+
+/// 查找真正的 thinking 结束标签（不被引用字符包裹，且后面有双换行符）
+///
+/// 当模型在思考过程中提到 `</thinking>` 时，通常会用反引号、引号等包裹，
+/// 或者在同一行有其他内容（如"关于 </thinking> 标签"）。
+/// 这个函数会跳过这些情况，只返回真正的结束标签位置。
+///
+/// 跳过的情况：
+/// - 被引用字符包裹（反引号、引号等）
+/// - 后面没有双换行符（真正的结束标签后面会有 `\n\n`）
+/// - 标签在缓冲区末尾（流式处理时需要等待更多内容）
+///
+/// # 参数
+/// - `buffer`: 要搜索的字符串
+///
+/// # 返回值
+/// - `Some(pos)`: 真正的结束标签的起始位置
+/// - `None`: 没有找到真正的结束标签
+fn find_real_thinking_end_tag(buffer: &str) -> Option<usize> {
+    const TAG: &str = "</thinking>";
+    let mut search_start = 0;
+
+    while let Some(pos) = buffer[search_start..].find(TAG) {
+        let absolute_pos = search_start + pos;
+
+        // 检查前面是否有引用字符
+        let has_quote_before = absolute_pos > 0 && is_quote_char(buffer, absolute_pos - 1);
+
+        // 检查后面是否有引用字符
+        let after_pos = absolute_pos + TAG.len();
+        let has_quote_after = is_quote_char(buffer, after_pos);
+
+        // 如果被引用字符包裹，跳过
+        if has_quote_before || has_quote_after {
+            search_start = absolute_pos + 1;
+            continue;
+        }
+
+        // 检查后面的内容
+        let after_content = &buffer[after_pos..];
+
+        // 如果标签后面内容不足以判断是否有双换行符，等待更多内容
+        if after_content.len() < 2 {
+            return None;
+        }
+
+        // 真正的 thinking 结束标签后面会有双换行符 `\n\n`
+        if after_content.starts_with("\n\n") {
+            return Some(absolute_pos);
+        }
+
+        // 不是双换行符，跳过继续搜索
+        search_start = absolute_pos + 1;
+    }
+
+    None
+}
+
+/// 查找缓冲区末尾的 thinking 结束标签（允许末尾只有空白字符）
+///
+/// 用于“边界事件”场景：例如 thinking 结束后立刻进入 tool_use，或流结束，
+/// 此时 `</thinking>` 后面可能没有 `\n\n`，但结束标签依然应被识别并过滤。
+///
+/// 约束：只有当 `</thinking>` 之后全部都是空白字符时才认为是结束标签，
+/// 以避免在 thinking 内容中提到 `</thinking>`（非结束标签）时误判。
+fn find_real_thinking_end_tag_at_buffer_end(buffer: &str) -> Option<usize> {
+    const TAG: &str = "</thinking>";
+    let mut search_start = 0;
+
+    while let Some(pos) = buffer[search_start..].find(TAG) {
+        let absolute_pos = search_start + pos;
+
+        // 检查前面是否有引用字符
+        let has_quote_before = absolute_pos > 0 && is_quote_char(buffer, absolute_pos - 1);
+
+        // 检查后面是否有引用字符
+        let after_pos = absolute_pos + TAG.len();
+        let has_quote_after = is_quote_char(buffer, after_pos);
+
+        if has_quote_before || has_quote_after {
+            search_start = absolute_pos + 1;
+            continue;
+        }
+
+        // 只有当标签后面全部是空白字符时才认定为结束标签
+        if buffer[after_pos..].trim().is_empty() {
+            return Some(absolute_pos);
+        }
+
+        search_start = absolute_pos + 1;
+    }
+
+    None
+}
+
+/// 查找真正的 thinking 开始标签（不被引用字符包裹）
+///
+/// 与 `find_real_thinking_end_tag` 类似，跳过被引用字符包裹的开始标签。
+fn find_real_thinking_start_tag(buffer: &str) -> Option<usize> {
+    const TAG: &str = "<thinking>";
+    let mut search_start = 0;
+
+    while let Some(pos) = buffer[search_start..].find(TAG) {
+        let absolute_pos = search_start + pos;
+
+        // 检查前面是否有引用字符
+        let has_quote_before = absolute_pos > 0 && is_quote_char(buffer, absolute_pos - 1);
+
+        // 检查后面是否有引用字符
+        let after_pos = absolute_pos + TAG.len();
+        let has_quote_after = is_quote_char(buffer, after_pos);
+
+        // 如果不被引用字符包裹，则是真正的开始标签
+        if !has_quote_before && !has_quote_after {
+            return Some(absolute_pos);
+        }
+
+        // 继续搜索下一个匹配
+        search_start = absolute_pos + 1;
+    }
+
+    None
+}
+
+/// SSE 事件
+#[derive(Debug, Clone)]
+pub struct SseEvent {
+    pub event: String,
+    pub data: serde_json::Value,
+}
+
+impl SseEvent {
+    pub fn new(event: impl Into<String>, data: serde_json::Value) -> Self {
+        Self {
+            event: event.into(),
+            data,
+        }
+    }
+
+    /// 格式化为 SSE 字符串
+    pub fn to_sse_string(&self) -> String {
+        format!(
+            "event: {}\ndata: {}\n\n",
+            self.event,
+            serde_json::to_string(&self.data).unwrap_or_default()
+        )
+    }
+}
+
+/// 内容块状态
+#[derive(Debug, Clone)]
+struct BlockState {
+    block_type: String,
+    started: bool,
+    stopped: bool,
+}
+
+impl BlockState {
+    fn new(block_type: impl Into<String>) -> Self {
+        Self {
+            block_type: block_type.into(),
+            started: false,
+            stopped: false,
+        }
+    }
+}
+
+/// SSE 状态管理器
+///
+/// 确保 SSE 事件序列符合 Claude API 规范：
+/// 1. message_start 只能出现一次
+/// 2. content_block 必须先 start 再 delta 再 stop
+/// 3. message_delta 只能出现一次，且在所有 content_block_stop 之后
+/// 4. message_stop 在最后
+#[derive(Debug)]
+pub struct SseStateManager {
+    /// message_start 是否已发送
+    message_started: bool,
+    /// message_delta 是否已发送
+    message_delta_sent: bool,
+    /// 活跃的内容块状态
+    active_blocks: HashMap<i32, BlockState>,
+    /// 消息是否已结束
+    message_ended: bool,
+    /// 下一个块索引
+    next_block_index: i32,
+    /// 当前 stop_reason
+    stop_reason: Option<String>,
+    /// 是否有工具调用
+    has_tool_use: bool,
+}
+
+impl Default for SseStateManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SseStateManager {
+    pub fn new() -> Self {
+        Self {
+            message_started: false,
+            message_delta_sent: false,
+            active_blocks: HashMap::new(),
+            message_ended: false,
+            next_block_index: 0,
+            stop_reason: None,
+            has_tool_use: false,
+        }
+    }
+
+    /// 判断指定块是否处于可接收 delta 的打开状态
+    fn is_block_open_of_type(&self, index: i32, expected_type: &str) -> bool {
+        self.active_blocks
+            .get(&index)
+            .is_some_and(|b| b.started && !b.stopped && b.block_type == expected_type)
+    }
+
+    /// 获取下一个块索引
+    pub fn next_block_index(&mut self) -> i32 {
+        let index = self.next_block_index;
+        self.next_block_index += 1;
+        index
+    }
+
+    /// 记录工具调用
+    pub fn set_has_tool_use(&mut self, has: bool) {
+        self.has_tool_use = has;
+    }
+
+    /// stop_reason 优先级（索引越小优先级越高）
+    const STOP_REASON_PRIORITY: &'static [&'static str] = &[
+        "model_context_window_exceeded",
+        "max_tokens",
+        "tool_use",
+        "end_turn",
+    ];
+
+    /// 获取 stop_reason 的优先级（越小越高，未知原因返回 usize::MAX）
+    fn stop_reason_priority(reason: &str) -> usize {
+        Self::STOP_REASON_PRIORITY
+            .iter()
+            .position(|&r| r == reason)
+            .unwrap_or(usize::MAX)
+    }
+
+    /// 设置 stop_reason（高优先级原因可覆盖低优先级原因）
+    ///
+    /// 优先级从高到低：model_context_window_exceeded > max_tokens > tool_use > end_turn
+    pub fn set_stop_reason(&mut self, reason: impl Into<String>) {
+        let reason = reason.into();
+        let new_priority = Self::stop_reason_priority(&reason);
+        let should_set = match &self.stop_reason {
+            None => true,
+            Some(current) => new_priority < Self::stop_reason_priority(current),
+        };
+        if should_set {
+            self.stop_reason = Some(reason);
+        }
+    }
+
+    /// 检查是否存在非 thinking 类型的内容块（如 text 或 tool_use）
+    fn has_non_thinking_blocks(&self) -> bool {
+        self.active_blocks
+            .values()
+            .any(|b| b.block_type != "thinking")
+    }
+
+    /// 获取最终的 stop_reason
+    pub fn get_stop_reason(&self) -> String {
+        if let Some(ref reason) = self.stop_reason {
+            reason.clone()
+        } else if self.has_tool_use {
+            "tool_use".to_string()
+        } else {
+            "end_turn".to_string()
+        }
+    }
+
+    /// 处理 message_start 事件
+    pub fn handle_message_start(&mut self, event: serde_json::Value) -> Option<SseEvent> {
+        if self.message_started {
+            tracing::debug!("跳过重复的 message_start 事件");
+            return None;
+        }
+        self.message_started = true;
+        Some(SseEvent::new("message_start", event))
+    }
+
+    /// 处理 content_block_start 事件
+    pub fn handle_content_block_start(
+        &mut self,
+        index: i32,
+        block_type: &str,
+        data: serde_json::Value,
+    ) -> Vec<SseEvent> {
+        let mut events = Vec::new();
+
+        // 如果是 tool_use 块，先关闭之前的文本块
+        if block_type == "tool_use" {
+            self.has_tool_use = true;
+            for (block_index, block) in self.active_blocks.iter_mut() {
+                if block.block_type == "text" && block.started && !block.stopped {
+                    // 自动发送 content_block_stop 关闭文本块
+                    events.push(SseEvent::new(
+                        "content_block_stop",
+                        json!({
+                            "type": "content_block_stop",
+                            "index": block_index
+                        }),
+                    ));
+                    block.stopped = true;
+                }
+            }
+        }
+
+        // 检查块是否已存在
+        if let Some(block) = self.active_blocks.get_mut(&index) {
+            if block.started {
+                tracing::trace!("块 {} 已启动，跳过重复的 content_block_start", index);
+                return events;
+            }
+            block.started = true;
+        } else {
+            let mut block = BlockState::new(block_type);
+            block.started = true;
+            self.active_blocks.insert(index, block);
+        }
+
+        events.push(SseEvent::new("content_block_start", data));
+        events
+    }
+
+    /// 处理 content_block_delta 事件
+    pub fn handle_content_block_delta(
+        &mut self,
+        index: i32,
+        data: serde_json::Value,
+    ) -> Option<SseEvent> {
+        // 确保块已启动
+        if let Some(block) = self.active_blocks.get(&index) {
+            if !block.started || block.stopped {
+                tracing::warn!(
+                    "块 {} 状态异常: started={}, stopped={}",
+                    index,
+                    block.started,
+                    block.stopped
+                );
+                return None;
+            }
+        } else {
+            // 块不存在，可能需要先创建
+            tracing::warn!("收到未知块 {} 的 delta 事件", index);
+            return None;
+        }
+
+        Some(SseEvent::new("content_block_delta", data))
+    }
+
+    /// 处理 content_block_stop 事件
+    pub fn handle_content_block_stop(&mut self, index: i32) -> Option<SseEvent> {
+        if let Some(block) = self.active_blocks.get_mut(&index) {
+            if block.stopped {
+                tracing::debug!("块 {} 已停止，跳过重复的 content_block_stop", index);
+                return None;
+            }
+            block.stopped = true;
+            return Some(SseEvent::new(
+                "content_block_stop",
+                json!({
+                    "type": "content_block_stop",
+                    "index": index
+                }),
+            ));
+        }
+        None
+    }
+
+    /// 生成最终事件序列
+    pub fn generate_final_events(
+        &mut self,
+        input_tokens: i32,
+        output_tokens: i32,
+    ) -> Vec<SseEvent> {
+        let mut events = Vec::new();
+
+        // 关闭所有未关闭的块
+        for (index, block) in self.active_blocks.iter_mut() {
+            if block.started && !block.stopped {
+                events.push(SseEvent::new(
+                    "content_block_stop",
+                    json!({
+                        "type": "content_block_stop",
+                        "index": index
+                    }),
+                ));
+                block.stopped = true;
+            }
+        }
+
+        // 发送 message_delta
+        if !self.message_delta_sent {
+            self.message_delta_sent = true;
+            events.push(SseEvent::new(
+                "message_delta",
+                json!({
+                    "type": "message_delta",
+                    "delta": {
+                        "stop_reason": self.get_stop_reason(),
+                        "stop_sequence": null
+                    },
+                    "usage": {
+                        "input_tokens": input_tokens,
+                        "output_tokens": output_tokens
+                    }
+                }),
+            ));
+        }
+
+        // 发送 message_stop
+        if !self.message_ended {
+            self.message_ended = true;
+            events.push(SseEvent::new(
+                "message_stop",
+                json!({ "type": "message_stop" }),
+            ));
+        }
+
+        events
+    }
+}
+
+/// 流处理上下文
+pub struct StreamContext {
+    /// SSE 状态管理器
+    pub state_manager: SseStateManager,
+    /// 请求的模型名称
+    pub model: String,
+    /// 消息 ID
+    pub message_id: String,
+    /// 输入 tokens（估算值）
+    pub input_tokens: i32,
+    /// 从 contextUsageEvent 计算的实际输入 tokens
+    pub context_input_tokens: Option<i32>,
+    /// 输出 tokens 累计
+    pub output_tokens: i32,
+    /// 工具块索引映射 (tool_id -> block_index)
+    pub tool_block_indices: HashMap<String, i32>,
+    /// thinking 是否启用
+    pub thinking_enabled: bool,
+    /// thinking 内容缓冲区
+    pub thinking_buffer: String,
+    /// 是否在 thinking 块内
+    pub in_thinking_block: bool,
+    /// thinking 块是否已提取完成
+    pub thinking_extracted: bool,
+    /// thinking 块索引
+    pub thinking_block_index: Option<i32>,
+    /// 文本块索引（thinking 启用时动态分配）
+    pub text_block_index: Option<i32>,
+    /// 是否需要剥离 thinking 内容开头的换行符
+    /// 模型输出 `<thinking>\n` 时，`\n` 可能与标签在同一 chunk 或下一 chunk
+    strip_thinking_leading_newline: bool,
+}
+
+impl StreamContext {
+    /// 创建启用thinking的StreamContext
+    pub fn new_with_thinking(
+        model: impl Into<String>,
+        input_tokens: i32,
+        thinking_enabled: bool,
+    ) -> Self {
+        Self {
+            state_manager: SseStateManager::new(),
+            model: model.into(),
+            message_id: format!("msg_{}", Uuid::new_v4().to_string().replace('-', "")),
+            input_tokens,
+            context_input_tokens: None,
+            output_tokens: 0,
+            tool_block_indices: HashMap::new(),
+            thinking_enabled,
+            thinking_buffer: String::new(),
+            in_thinking_block: false,
+            thinking_extracted: false,
+            thinking_block_index: None,
+            text_block_index: None,
+            strip_thinking_leading_newline: false,
+        }
+    }
+
+    /// 生成 message_start 事件
+    pub fn create_message_start_event(&self) -> serde_json::Value {
+        json!({
+            "type": "message_start",
+            "message": {
+                "id": self.message_id,
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "model": self.model,
+                "stop_reason": null,
+                "stop_sequence": null,
+                "usage": {
+                    "input_tokens": self.input_tokens,
+                    "output_tokens": 1
+                }
+            }
+        })
+    }
+
+    /// 生成初始事件序列 (message_start + 文本块 start)
+    ///
+    /// 当 thinking 启用时，不在初始化时创建文本块，而是等到实际收到内容时再创建。
+    /// 这样可以确保 thinking 块（索引 0）在文本块（索引 1）之前。
+    pub fn generate_initial_events(&mut self) -> Vec<SseEvent> {
+        let mut events = Vec::new();
+
+        // message_start
+        let msg_start = self.create_message_start_event();
+        if let Some(event) = self.state_manager.handle_message_start(msg_start) {
+            events.push(event);
+        }
+
+        // 如果启用了 thinking，不在这里创建文本块
+        // thinking 块和文本块会在 process_content_with_thinking 中按正确顺序创建
+        if self.thinking_enabled {
+            return events;
+        }
+
+        // 创建初始文本块（仅在未启用 thinking 时）
+        let text_block_index = self.state_manager.next_block_index();
+        self.text_block_index = Some(text_block_index);
+        let text_block_events = self.state_manager.handle_content_block_start(
+            text_block_index,
+            "text",
+            json!({
+                "type": "content_block_start",
+                "index": text_block_index,
+                "content_block": {
+                    "type": "text",
+                    "text": ""
+                }
+            }),
+        );
+        events.extend(text_block_events);
+
+        events
+    }
+
+    /// 处理 Kiro 事件并转换为 Anthropic SSE 事件
+    pub fn process_kiro_event(&mut self, event: &Event) -> Vec<SseEvent> {
+        match event {
+            Event::AssistantResponse(resp) => self.process_assistant_response(&resp.content),
+            Event::ToolUse(tool_use) => self.process_tool_use(tool_use),
+            Event::ContextUsage(context_usage) => {
+                // 从上下文使用百分比计算实际的 input_tokens
+                let context_window = super::types::get_context_window_size(&self.model) as f64;
+                let actual_input_tokens =
+                    (context_usage.context_usage_percentage * context_window / 100.0) as i32;
+                self.context_input_tokens = Some(actual_input_tokens);
+                // 上下文使用量达到 100% 时，设置 stop_reason 为 model_context_window_exceeded
+                if context_usage.context_usage_percentage >= 100.0 {
+                    self.state_manager
+                        .set_stop_reason("model_context_window_exceeded");
+                }
+                tracing::debug!(
+                    "收到 contextUsageEvent: {:.4}%, 计算 input_tokens: {} (context_window: {})",
+                    context_usage.context_usage_percentage,
+                    actual_input_tokens,
+                    context_window as i32
+                );
+                Vec::new()
+            }
+            Event::Error {
+                error_code,
+                error_message,
+            } => {
+                tracing::error!("收到错误事件: {} - {}", error_code, error_message);
+                Vec::new()
+            }
+            Event::Exception {
+                exception_type,
+                message,
+            } => {
+                // 处理 ContentLengthExceededException
+                if exception_type == "ContentLengthExceededException" {
+                    self.state_manager.set_stop_reason("max_tokens");
+                }
+                tracing::warn!("收到异常事件: {} - {}", exception_type, message);
+                Vec::new()
+            }
+            _ => Vec::new(),
+        }
+    }
+
+    /// 处理助手响应事件
+    fn process_assistant_response(&mut self, content: &str) -> Vec<SseEvent> {
+        if content.is_empty() {
+            return Vec::new();
+        }
+
+        // 估算 tokens
+        self.output_tokens += estimate_tokens(content);
+
+        // 如果启用了thinking，需要处理thinking块
+        if self.thinking_enabled {
+            return self.process_content_with_thinking(content);
+        }
+
+        // 非 thinking 模式同样复用统一的 text_delta 发送逻辑，
+        // 以便在 tool_use 自动关闭文本块后能够自愈重建新的文本块，避免“吞字”。
+        self.create_text_delta_events(content)
+    }
+
+    /// 处理包含thinking块的内容
+    fn process_content_with_thinking(&mut self, content: &str) -> Vec<SseEvent> {
+        let mut events = Vec::new();
+
+        // 将内容添加到缓冲区进行处理
+        self.thinking_buffer.push_str(content);
+
+        loop {
+            if !self.in_thinking_block && !self.thinking_extracted {
+                // 查找 <thinking> 开始标签（跳过被反引号包裹的）
+                if let Some(start_pos) = find_real_thinking_start_tag(&self.thinking_buffer) {
+                    // 发送 <thinking> 之前的内容作为 text_delta
+                    // 注意：如果前面只是空白字符（如 adaptive 模式返回的 \n\n），则跳过，
+                    // 避免在 thinking 块之前产生无意义的 text 块导致客户端解析失败
+                    let before_thinking = self.thinking_buffer[..start_pos].to_string();
+                    if !before_thinking.is_empty() && !before_thinking.trim().is_empty() {
+                        events.extend(self.create_text_delta_events(&before_thinking));
+                    }
+
+                    // 进入 thinking 块
+                    self.in_thinking_block = true;
+                    self.strip_thinking_leading_newline = true;
+                    self.thinking_buffer =
+                        self.thinking_buffer[start_pos + "<thinking>".len()..].to_string();
+
+                    // 创建 thinking 块的 content_block_start 事件
+                    let thinking_index = self.state_manager.next_block_index();
+                    self.thinking_block_index = Some(thinking_index);
+                    let start_events = self.state_manager.handle_content_block_start(
+                        thinking_index,
+                        "thinking",
+                        json!({
+                            "type": "content_block_start",
+                            "index": thinking_index,
+                            "content_block": {
+                                "type": "thinking",
+                                "thinking": ""
+                            }
+                        }),
+                    );
+                    events.extend(start_events);
+                } else {
+                    // 没有找到 <thinking>，检查是否可能是部分标签
+                    // 保留可能是部分标签的内容
+                    let target_len = self
+                        .thinking_buffer
+                        .len()
+                        .saturating_sub("<thinking>".len());
+                    let safe_len = floor_char_boundary(&self.thinking_buffer, target_len);
+                    if safe_len > 0 {
+                        let safe_content = self.thinking_buffer[..safe_len].to_string();
+                        // 如果 thinking 尚未提取，且安全内容只是空白字符，
+                        // 则不发送为 text_delta，继续保留在缓冲区等待更多内容。
+                        // 这避免了 4.6 模型中 <thinking> 标签跨事件分割时，
+                        // 前导空白（如 "\n\n"）被错误地创建为 text 块，
+                        // 导致 text 块先于 thinking 块出现的问题。
+                        if !safe_content.is_empty() && !safe_content.trim().is_empty() {
+                            events.extend(self.create_text_delta_events(&safe_content));
+                            self.thinking_buffer = self.thinking_buffer[safe_len..].to_string();
+                        }
+                    }
+                    break;
+                }
+            } else if self.in_thinking_block {
+                // 剥离 <thinking> 标签后紧跟的换行符（可能跨 chunk）
+                if self.strip_thinking_leading_newline {
+                    if self.thinking_buffer.starts_with('\n') {
+                        self.thinking_buffer = self.thinking_buffer[1..].to_string();
+                        self.strip_thinking_leading_newline = false;
+                    } else if !self.thinking_buffer.is_empty() {
+                        // buffer 非空但不以 \n 开头，不再需要剥离
+                        self.strip_thinking_leading_newline = false;
+                    }
+                    // buffer 为空时保留标志，等待下一个 chunk
+                }
+
+                // 在 thinking 块内，查找 </thinking> 结束标签（跳过被反引号包裹的）
+                if let Some(end_pos) = find_real_thinking_end_tag(&self.thinking_buffer) {
+                    // 提取 thinking 内容
+                    let thinking_content = self.thinking_buffer[..end_pos].to_string();
+                    if let Some(thinking_index) = self.thinking_block_index
+                        && !thinking_content.is_empty()
+                    {
+                        events.push(
+                            self.create_thinking_delta_event(thinking_index, &thinking_content),
+                        );
+                    }
+
+                    // 结束 thinking 块
+                    self.in_thinking_block = false;
+                    self.thinking_extracted = true;
+
+                    // 发送空的 thinking_delta 事件，然后发送 content_block_stop 事件
+                    if let Some(thinking_index) = self.thinking_block_index {
+                        // 先发送空的 thinking_delta
+                        events.push(self.create_thinking_delta_event(thinking_index, ""));
+                        // 再发送 content_block_stop
+                        if let Some(stop_event) =
+                            self.state_manager.handle_content_block_stop(thinking_index)
+                        {
+                            events.push(stop_event);
+                        }
+                    }
+
+                    // 剥离 `</thinking>\n\n`（find_real_thinking_end_tag 已确认 \n\n 存在）
+                    self.thinking_buffer =
+                        self.thinking_buffer[end_pos + "</thinking>\n\n".len()..].to_string();
+                } else {
+                    // 没有找到结束标签，发送当前缓冲区内容作为 thinking_delta。
+                    // 保留末尾可能是部分 `</thinking>\n\n` 的内容：
+                    // find_real_thinking_end_tag 要求标签后有 `\n\n` 才返回 Some，
+                    // 因此保留区必须覆盖 `</thinking>\n\n` 的完整长度（13 字节），
+                    // 否则当 `</thinking>` 已在 buffer 但 `\n\n` 尚未到达时，
+                    // 标签的前几个字符会被错误地作为 thinking_delta 发出。
+                    let target_len = self
+                        .thinking_buffer
+                        .len()
+                        .saturating_sub("</thinking>\n\n".len());
+                    let safe_len = floor_char_boundary(&self.thinking_buffer, target_len);
+                    if safe_len > 0 {
+                        let safe_content = self.thinking_buffer[..safe_len].to_string();
+                        if let Some(thinking_index) = self.thinking_block_index
+                            && !safe_content.is_empty()
+                        {
+                            events.push(
+                                self.create_thinking_delta_event(thinking_index, &safe_content),
+                            );
+                        }
+                        self.thinking_buffer = self.thinking_buffer[safe_len..].to_string();
+                    }
+                    break;
+                }
+            } else {
+                // thinking 已提取完成，剩余内容作为 text_delta
+                if !self.thinking_buffer.is_empty() {
+                    let remaining = self.thinking_buffer.clone();
+                    self.thinking_buffer.clear();
+                    events.extend(self.create_text_delta_events(&remaining));
+                }
+                break;
+            }
+        }
+
+        events
+    }
+
+    /// 创建 text_delta 事件
+    ///
+    /// 如果文本块尚未创建，会先创建文本块。
+    /// 当发生 tool_use 时，状态机会自动关闭当前文本块；后续文本会自动创建新的文本块继续输出。
+    ///
+    /// 返回值包含可能的 content_block_start 事件和 content_block_delta 事件。
+    fn create_text_delta_events(&mut self, text: &str) -> Vec<SseEvent> {
+        let mut events = Vec::new();
+
+        // 如果当前 text_block_index 指向的块已经被关闭（例如 tool_use 开始时自动 stop），
+        // 则丢弃该索引并创建新的文本块继续输出，避免 delta 被状态机拒绝导致"吞字"。
+        if let Some(idx) = self.text_block_index
+            && !self.state_manager.is_block_open_of_type(idx, "text")
+        {
+            self.text_block_index = None;
+        }
+
+        // 获取或创建文本块索引
+        let text_index = if let Some(idx) = self.text_block_index {
+            idx
+        } else {
+            // 文本块尚未创建，需要先创建
+            let idx = self.state_manager.next_block_index();
+            self.text_block_index = Some(idx);
+
+            // 发送 content_block_start 事件
+            let start_events = self.state_manager.handle_content_block_start(
+                idx,
+                "text",
+                json!({
+                    "type": "content_block_start",
+                    "index": idx,
+                    "content_block": {
+                        "type": "text",
+                        "text": ""
+                    }
+                }),
+            );
+            events.extend(start_events);
+            idx
+        };
+
+        // 发送 content_block_delta 事件
+        if let Some(delta_event) = self.state_manager.handle_content_block_delta(
+            text_index,
+            json!({
+                "type": "content_block_delta",
+                "index": text_index,
+                "delta": {
+                    "type": "text_delta",
+                    "text": text
+                }
+            }),
+        ) {
+            events.push(delta_event);
+        }
+
+        events
+    }
+
+    /// 创建 thinking_delta 事件
+    fn create_thinking_delta_event(&self, index: i32, thinking: &str) -> SseEvent {
+        SseEvent::new(
+            "content_block_delta",
+            json!({
+                "type": "content_block_delta",
+                "index": index,
+                "delta": {
+                    "type": "thinking_delta",
+                    "thinking": thinking
+                }
+            }),
+        )
+    }
+
+    /// 处理工具使用事件
+    fn process_tool_use(
+        &mut self,
+        tool_use: &crate::kiro::model::events::ToolUseEvent,
+    ) -> Vec<SseEvent> {
+        let mut events = Vec::new();
+
+        self.state_manager.set_has_tool_use(true);
+
+        // tool_use 必须发生在 thinking 结束之后。
+        // 但当 `</thinking>` 后面没有 `\n\n`（例如紧跟 tool_use 或流结束）时，
+        // thinking 结束标签会滞留在 thinking_buffer，导致后续 flush 时把 `</thinking>` 当作内容输出。
+        // 这里在开始 tool_use block 前做一次"边界场景"的结束标签识别与过滤。
+        if self.thinking_enabled
+            && self.in_thinking_block
+            && let Some(end_pos) = find_real_thinking_end_tag_at_buffer_end(&self.thinking_buffer)
+        {
+            let thinking_content = self.thinking_buffer[..end_pos].to_string();
+            if let Some(thinking_index) = self.thinking_block_index
+                && !thinking_content.is_empty()
+            {
+                events.push(self.create_thinking_delta_event(thinking_index, &thinking_content));
+            }
+
+            // 结束 thinking 块
+            self.in_thinking_block = false;
+            self.thinking_extracted = true;
+
+            if let Some(thinking_index) = self.thinking_block_index {
+                // 先发送空的 thinking_delta
+                events.push(self.create_thinking_delta_event(thinking_index, ""));
+                // 再发送 content_block_stop
+                if let Some(stop_event) =
+                    self.state_manager.handle_content_block_stop(thinking_index)
+                {
+                    events.push(stop_event);
+                }
+            }
+
+            // 把结束标签后的内容当作普通文本（通常为空或空白）
+            let after_pos = end_pos + "</thinking>".len();
+            let remaining = self.thinking_buffer[after_pos..].trim_start().to_string();
+            self.thinking_buffer.clear();
+            if !remaining.is_empty() {
+                events.extend(self.create_text_delta_events(&remaining));
+            }
+        }
+
+        // thinking 模式下，process_content_with_thinking 可能会为了探测 `<thinking>` 而暂存一小段尾部文本。
+        // 如果此时直接开始 tool_use，状态机会自动关闭 text block，导致这段"待输出文本"看起来被 tool_use 吞掉。
+        // 约束：只在尚未进入 thinking block、且 thinking 尚未被提取时，将缓冲区当作普通文本 flush。
+        if self.thinking_enabled
+            && !self.in_thinking_block
+            && !self.thinking_extracted
+            && !self.thinking_buffer.is_empty()
+        {
+            let buffered = std::mem::take(&mut self.thinking_buffer);
+            events.extend(self.create_text_delta_events(&buffered));
+        }
+
+        // 获取或分配块索引
+        let block_index = if let Some(&idx) = self.tool_block_indices.get(&tool_use.tool_use_id) {
+            idx
+        } else {
+            let idx = self.state_manager.next_block_index();
+            self.tool_block_indices
+                .insert(tool_use.tool_use_id.clone(), idx);
+            idx
+        };
+
+        // 发送 content_block_start
+        let start_events = self.state_manager.handle_content_block_start(
+            block_index,
+            "tool_use",
+            json!({
+                "type": "content_block_start",
+                "index": block_index,
+                "content_block": {
+                    "type": "tool_use",
+                    "id": tool_use.tool_use_id,
+                    "name": tool_use.name,
+                    "input": {}
+                }
+            }),
+        );
+        events.extend(start_events);
+
+        // 发送参数增量 (ToolUseEvent.input 是 String 类型)
+        if !tool_use.input.is_empty() {
+            self.output_tokens += (tool_use.input.len() as i32 + 3) / 4; // 估算 token
+
+            if let Some(delta_event) = self.state_manager.handle_content_block_delta(
+                block_index,
+                json!({
+                    "type": "content_block_delta",
+                    "index": block_index,
+                    "delta": {
+                        "type": "input_json_delta",
+                        "partial_json": tool_use.input
+                    }
+                }),
+            ) {
+                events.push(delta_event);
+            }
+        }
+
+        // 如果是完整的工具调用（stop=true），发送 content_block_stop
+        if tool_use.stop
+            && let Some(stop_event) = self.state_manager.handle_content_block_stop(block_index)
+        {
+            events.push(stop_event);
+        }
+
+        events
+    }
+
+    /// 生成最终事件序列
+    pub fn generate_final_events(&mut self) -> Vec<SseEvent> {
+        let mut events = Vec::new();
+
+        // Flush thinking_buffer 中的剩余内容
+        if self.thinking_enabled && !self.thinking_buffer.is_empty() {
+            if self.in_thinking_block {
+                // 末尾可能残留 `</thinking>`（例如紧跟 tool_use 或流结束），需要在 flush 时过滤掉结束标签。
+                if let Some(end_pos) =
+                    find_real_thinking_end_tag_at_buffer_end(&self.thinking_buffer)
+                {
+                    let thinking_content = self.thinking_buffer[..end_pos].to_string();
+                    if let Some(thinking_index) = self.thinking_block_index
+                        && !thinking_content.is_empty()
+                    {
+                        events.push(
+                            self.create_thinking_delta_event(thinking_index, &thinking_content),
+                        );
+                    }
+
+                    // 关闭 thinking 块：先发送空的 thinking_delta，再发送 content_block_stop
+                    if let Some(thinking_index) = self.thinking_block_index {
+                        events.push(self.create_thinking_delta_event(thinking_index, ""));
+                        if let Some(stop_event) =
+                            self.state_manager.handle_content_block_stop(thinking_index)
+                        {
+                            events.push(stop_event);
+                        }
+                    }
+
+                    // 把结束标签后的内容当作普通文本（通常为空或空白）
+                    let after_pos = end_pos + "</thinking>".len();
+                    let remaining = self.thinking_buffer[after_pos..].trim_start().to_string();
+                    self.thinking_buffer.clear();
+                    self.in_thinking_block = false;
+                    self.thinking_extracted = true;
+                    if !remaining.is_empty() {
+                        events.extend(self.create_text_delta_events(&remaining));
+                    }
+                } else {
+                    // 如果还在 thinking 块内，发送剩余内容作为 thinking_delta
+                    if let Some(thinking_index) = self.thinking_block_index {
+                        events.push(
+                            self.create_thinking_delta_event(thinking_index, &self.thinking_buffer),
+                        );
+                    }
+                    // 关闭 thinking 块：先发送空的 thinking_delta，再发送 content_block_stop
+                    if let Some(thinking_index) = self.thinking_block_index {
+                        // 先发送空的 thinking_delta
+                        events.push(self.create_thinking_delta_event(thinking_index, ""));
+                        // 再发送 content_block_stop
+                        if let Some(stop_event) =
+                            self.state_manager.handle_content_block_stop(thinking_index)
+                        {
+                            events.push(stop_event);
+                        }
+                    }
+                }
+            } else {
+                // 否则发送剩余内容作为 text_delta
+                let buffer_content = self.thinking_buffer.clone();
+                events.extend(self.create_text_delta_events(&buffer_content));
+            }
+            self.thinking_buffer.clear();
+        }
+
+        // 如果整个流中只产生了 thinking 块，没有 text 也没有 tool_use，
+        // 则设置 stop_reason 为 max_tokens（表示模型耗尽了 token 预算在思考上），
+        // 并补发一套完整的 text 事件（内容为一个空格），确保 content 数组中有 text 块
+        if self.thinking_enabled
+            && self.thinking_block_index.is_some()
+            && !self.state_manager.has_non_thinking_blocks()
+        {
+            self.state_manager.set_stop_reason("max_tokens");
+            events.extend(self.create_text_delta_events(" "));
+        }
+
+        // 使用从 contextUsageEvent 计算的 input_tokens，如果没有则使用估算值
+        let final_input_tokens = self.context_input_tokens.unwrap_or(self.input_tokens);
+
+        #[cfg(feature = "sensitive-logs")]
+        tracing::info!(
+            estimated_input_tokens = self.input_tokens,
+            context_input_tokens = ?self.context_input_tokens,
+            final_input_tokens,
+            output_tokens = self.output_tokens,
+            "StreamContext usage: final_input_tokens={} (来源={}), output_tokens={}",
+            final_input_tokens,
+            if self.context_input_tokens.is_some() { "contextUsageEvent" } else { "估算" },
+            self.output_tokens
+        );
+
+        // 生成最终事件
+        events.extend(
+            self.state_manager
+                .generate_final_events(final_input_tokens, self.output_tokens),
+        );
+        events
+    }
+}
+
+/// 缓冲流处理上下文 - 用于 /cc/v1/messages 流式请求
+///
+/// 与 `StreamContext` 不同，此上下文会缓冲所有事件直到流结束，
+/// 然后用从 `contextUsageEvent` 计算的正确 `input_tokens` 更正 `message_start` 事件。
+///
+/// 工作流程：
+/// 1. 使用 `StreamContext` 正常处理所有 Kiro 事件
+/// 2. 把生成的 SSE 事件缓存起来（而不是立即发送）
+/// 3. 流结束时，找到 `message_start` 事件并更新其 `input_tokens`
+/// 4. 一次性返回所有事件
+pub struct BufferedStreamContext {
+    /// 内部流处理上下文（复用现有的事件处理逻辑）
+    inner: StreamContext,
+    /// 缓冲的所有事件（包括 message_start、content_block_start 等）
+    event_buffer: Vec<SseEvent>,
+    /// 估算的 input_tokens（用于回退）
+    estimated_input_tokens: i32,
+    /// 是否已经生成了初始事件
+    initial_events_generated: bool,
+}
+
+impl BufferedStreamContext {
+    /// 创建缓冲流上下文
+    pub fn new(
+        model: impl Into<String>,
+        estimated_input_tokens: i32,
+        thinking_enabled: bool,
+    ) -> Self {
+        let inner =
+            StreamContext::new_with_thinking(model, estimated_input_tokens, thinking_enabled);
+        Self {
+            inner,
+            event_buffer: Vec::new(),
+            estimated_input_tokens,
+            initial_events_generated: false,
+        }
+    }
+
+    /// 处理 Kiro 事件并缓冲结果
+    ///
+    /// 复用 StreamContext 的事件处理逻辑，但把结果缓存而不是立即发送。
+    pub fn process_and_buffer(&mut self, event: &crate::kiro::model::events::Event) {
+        // 首次处理事件时，先生成初始事件（message_start 等）
+        if !self.initial_events_generated {
+            let initial_events = self.inner.generate_initial_events();
+            self.event_buffer.extend(initial_events);
+            self.initial_events_generated = true;
+        }
+
+        // 处理事件并缓冲结果
+        let events = self.inner.process_kiro_event(event);
+        self.event_buffer.extend(events);
+    }
+
+    /// 完成流处理并返回所有事件
+    ///
+    /// 此方法会：
+    /// 1. 生成最终事件（message_delta, message_stop）
+    /// 2. 用正确的 input_tokens 更正 message_start 事件
+    /// 3. 返回所有缓冲的事件
+    pub fn finish_and_get_all_events(&mut self) -> Vec<SseEvent> {
+        // 如果从未处理过事件，也要生成初始事件
+        if !self.initial_events_generated {
+            let initial_events = self.inner.generate_initial_events();
+            self.event_buffer.extend(initial_events);
+            self.initial_events_generated = true;
+        }
+
+        // 生成最终事件
+        let final_events = self.inner.generate_final_events();
+        self.event_buffer.extend(final_events);
+
+        // 获取正确的 input_tokens
+        let final_input_tokens = self
+            .inner
+            .context_input_tokens
+            .unwrap_or(self.estimated_input_tokens);
+
+        #[cfg(feature = "sensitive-logs")]
+        tracing::info!(
+            estimated_input_tokens = self.estimated_input_tokens,
+            context_input_tokens = ?self.inner.context_input_tokens,
+            final_input_tokens,
+            output_tokens = self.inner.output_tokens,
+            "BufferedStreamContext usage: final_input_tokens={} (来源={}), output_tokens={}",
+            final_input_tokens,
+            if self.inner.context_input_tokens.is_some() { "contextUsageEvent" } else { "估算" },
+            self.inner.output_tokens
+        );
+
+        // 更正 message_start 事件中的 input_tokens
+        for event in &mut self.event_buffer {
+            if event.event == "message_start"
+                && let Some(message) = event.data.get_mut("message")
+                && let Some(usage) = message.get_mut("usage")
+            {
+                usage["input_tokens"] = serde_json::json!(final_input_tokens);
+            }
+        }
+
+        std::mem::take(&mut self.event_buffer)
+    }
+}
+
+/// 简单的 token 估算
+fn estimate_tokens(text: &str) -> i32 {
+    let chars: Vec<char> = text.chars().collect();
+    let mut chinese_count = 0;
+    let mut other_count = 0;
+
+    for c in &chars {
+        if *c >= '\u{4E00}' && *c <= '\u{9FFF}' {
+            chinese_count += 1;
+        } else {
+            other_count += 1;
+        }
+    }
+
+    // 中文约 1.5 字符/token，英文约 4 字符/token
+    let chinese_tokens = (chinese_count * 2 + 2) / 3;
+    let other_tokens = (other_count + 3) / 4;
+
+    (chinese_tokens + other_tokens).max(1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sse_event_format() {
+        let event = SseEvent::new("message_start", json!({"type": "message_start"}));
+        let sse_str = event.to_sse_string();
+
+        assert!(sse_str.starts_with("event: message_start\n"));
+        assert!(sse_str.contains("data: "));
+        assert!(sse_str.ends_with("\n\n"));
+    }
+
+    #[test]
+    fn test_sse_state_manager_message_start() {
+        let mut manager = SseStateManager::new();
+
+        // 第一次应该成功
+        let event = manager.handle_message_start(json!({"type": "message_start"}));
+        assert!(event.is_some());
+
+        // 第二次应该被跳过
+        let event = manager.handle_message_start(json!({"type": "message_start"}));
+        assert!(event.is_none());
+    }
+
+    #[test]
+    fn test_sse_state_manager_block_lifecycle() {
+        let mut manager = SseStateManager::new();
+
+        // 创建块
+        let events = manager.handle_content_block_start(0, "text", json!({}));
+        assert_eq!(events.len(), 1);
+
+        // delta
+        let event = manager.handle_content_block_delta(0, json!({}));
+        assert!(event.is_some());
+
+        // stop
+        let event = manager.handle_content_block_stop(0);
+        assert!(event.is_some());
+
+        // 重复 stop 应该被跳过
+        let event = manager.handle_content_block_stop(0);
+        assert!(event.is_none());
+    }
+
+    #[test]
+    fn test_text_delta_after_tool_use_restarts_text_block() {
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, false);
+
+        let initial_events = ctx.generate_initial_events();
+        assert!(
+            initial_events
+                .iter()
+                .any(|e| e.event == "content_block_start"
+                    && e.data["content_block"]["type"] == "text")
+        );
+
+        let initial_text_index = ctx
+            .text_block_index
+            .expect("initial text block index should exist");
+
+        // tool_use 开始会自动关闭现有 text block
+        let tool_events = ctx.process_tool_use(&crate::kiro::model::events::ToolUseEvent {
+            name: "test_tool".to_string(),
+            tool_use_id: "tool_1".to_string(),
+            input: "{}".to_string(),
+            stop: false,
+        });
+        assert!(
+            tool_events.iter().any(|e| {
+                e.event == "content_block_stop"
+                    && e.data["index"].as_i64() == Some(initial_text_index as i64)
+            }),
+            "tool_use should stop the previous text block"
+        );
+
+        // 之后再来文本增量，应自动创建新的 text block 而不是往已 stop 的块里写 delta
+        let text_events = ctx.process_assistant_response("hello");
+        let new_text_start_index = text_events.iter().find_map(|e| {
+            if e.event == "content_block_start" && e.data["content_block"]["type"] == "text" {
+                e.data["index"].as_i64()
+            } else {
+                None
+            }
+        });
+        assert!(
+            new_text_start_index.is_some(),
+            "should start a new text block"
+        );
+        assert_ne!(
+            new_text_start_index.unwrap(),
+            initial_text_index as i64,
+            "new text block index should differ from the stopped one"
+        );
+        assert!(
+            text_events.iter().any(|e| {
+                e.event == "content_block_delta"
+                    && e.data["delta"]["type"] == "text_delta"
+                    && e.data["delta"]["text"] == "hello"
+            }),
+            "should emit text_delta after restarting text block"
+        );
+    }
+
+    #[test]
+    fn test_tool_use_flushes_pending_thinking_buffer_text_before_tool_block() {
+        // thinking 模式下，短文本可能被暂存在 thinking_buffer 以等待 `<thinking>` 的跨 chunk 匹配。
+        // 当紧接着出现 tool_use 时，应先 flush 这段文本，再开始 tool_use block。
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        // 两段短文本（各 2 个中文字符），总长度仍可能不足以满足 safe_len>0 的输出条件，
+        // 因而会留在 thinking_buffer 中等待后续 chunk。
+        let ev1 = ctx.process_assistant_response("有修");
+        assert!(
+            ev1.iter().all(|e| e.event != "content_block_delta"),
+            "short prefix should be buffered under thinking mode"
+        );
+        let ev2 = ctx.process_assistant_response("改：");
+        assert!(
+            ev2.iter().all(|e| e.event != "content_block_delta"),
+            "short prefix should still be buffered under thinking mode"
+        );
+
+        let events = ctx.process_tool_use(&crate::kiro::model::events::ToolUseEvent {
+            name: "Write".to_string(),
+            tool_use_id: "tool_1".to_string(),
+            input: "{}".to_string(),
+            stop: false,
+        });
+
+        let text_start_index = events.iter().find_map(|e| {
+            if e.event == "content_block_start" && e.data["content_block"]["type"] == "text" {
+                e.data["index"].as_i64()
+            } else {
+                None
+            }
+        });
+        let pos_text_delta = events.iter().position(|e| {
+            e.event == "content_block_delta" && e.data["delta"]["type"] == "text_delta"
+        });
+        let pos_text_stop = text_start_index.and_then(|idx| {
+            events.iter().position(|e| {
+                e.event == "content_block_stop" && e.data["index"].as_i64() == Some(idx)
+            })
+        });
+        let pos_tool_start = events.iter().position(|e| {
+            e.event == "content_block_start" && e.data["content_block"]["type"] == "tool_use"
+        });
+
+        assert!(
+            text_start_index.is_some(),
+            "should start a text block to flush buffered text"
+        );
+        assert!(
+            pos_text_delta.is_some(),
+            "should flush buffered text as text_delta"
+        );
+        assert!(
+            pos_text_stop.is_some(),
+            "should stop text block before tool_use block starts"
+        );
+        assert!(pos_tool_start.is_some(), "should start tool_use block");
+
+        let pos_text_delta = pos_text_delta.unwrap();
+        let pos_text_stop = pos_text_stop.unwrap();
+        let pos_tool_start = pos_tool_start.unwrap();
+
+        assert!(
+            pos_text_delta < pos_text_stop && pos_text_stop < pos_tool_start,
+            "ordering should be: text_delta -> text_stop -> tool_use_start"
+        );
+
+        assert!(
+            events.iter().any(|e| {
+                e.event == "content_block_delta"
+                    && e.data["delta"]["type"] == "text_delta"
+                    && e.data["delta"]["text"] == "有修改："
+            }),
+            "flushed text should equal the buffered prefix"
+        );
+    }
+
+    #[test]
+    fn test_estimate_tokens() {
+        assert!(estimate_tokens("Hello") > 0);
+        assert!(estimate_tokens("你好") > 0);
+        assert!(estimate_tokens("Hello 你好") > 0);
+    }
+
+    #[test]
+    fn test_find_real_thinking_start_tag_basic() {
+        // 基本情况：正常的开始标签
+        assert_eq!(find_real_thinking_start_tag("<thinking>"), Some(0));
+        assert_eq!(find_real_thinking_start_tag("prefix<thinking>"), Some(6));
+    }
+
+    #[test]
+    fn test_find_real_thinking_start_tag_with_backticks() {
+        // 被反引号包裹的应该被跳过
+        assert_eq!(find_real_thinking_start_tag("`<thinking>`"), None);
+        assert_eq!(find_real_thinking_start_tag("use `<thinking>` tag"), None);
+
+        // 先有被包裹的，后有真正的开始标签
+        assert_eq!(
+            find_real_thinking_start_tag("about `<thinking>` tag<thinking>content"),
+            Some(22)
+        );
+    }
+
+    #[test]
+    fn test_find_real_thinking_start_tag_with_quotes() {
+        // 被双引号包裹的应该被跳过
+        assert_eq!(find_real_thinking_start_tag("\"<thinking>\""), None);
+        assert_eq!(find_real_thinking_start_tag("the \"<thinking>\" tag"), None);
+
+        // 被单引号包裹的应该被跳过
+        assert_eq!(find_real_thinking_start_tag("'<thinking>'"), None);
+
+        // 混合情况
+        assert_eq!(
+            find_real_thinking_start_tag("about \"<thinking>\" and '<thinking>' then<thinking>"),
+            Some(40)
+        );
+    }
+
+    #[test]
+    fn test_find_real_thinking_end_tag_basic() {
+        // 基本情况：正常的结束标签后面有双换行符
+        assert_eq!(find_real_thinking_end_tag("</thinking>\n\n"), Some(0));
+        assert_eq!(
+            find_real_thinking_end_tag("content</thinking>\n\n"),
+            Some(7)
+        );
+        assert_eq!(
+            find_real_thinking_end_tag("some text</thinking>\n\nmore text"),
+            Some(9)
+        );
+
+        // 没有双换行符的情况
+        assert_eq!(find_real_thinking_end_tag("</thinking>"), None);
+        assert_eq!(find_real_thinking_end_tag("</thinking>\n"), None);
+        assert_eq!(find_real_thinking_end_tag("</thinking> more"), None);
+    }
+
+    #[test]
+    fn test_find_real_thinking_end_tag_with_backticks() {
+        // 被反引号包裹的应该被跳过
+        assert_eq!(find_real_thinking_end_tag("`</thinking>`\n\n"), None);
+        assert_eq!(
+            find_real_thinking_end_tag("mention `</thinking>` in code\n\n"),
+            None
+        );
+
+        // 只有前面有反引号
+        assert_eq!(find_real_thinking_end_tag("`</thinking>\n\n"), None);
+
+        // 只有后面有反引号
+        assert_eq!(find_real_thinking_end_tag("</thinking>`\n\n"), None);
+    }
+
+    #[test]
+    fn test_find_real_thinking_end_tag_with_quotes() {
+        // 被双引号包裹的应该被跳过
+        assert_eq!(find_real_thinking_end_tag("\"</thinking>\"\n\n"), None);
+        assert_eq!(
+            find_real_thinking_end_tag("the string \"</thinking>\" is a tag\n\n"),
+            None
+        );
+
+        // 被单引号包裹的应该被跳过
+        assert_eq!(find_real_thinking_end_tag("'</thinking>'\n\n"), None);
+        assert_eq!(
+            find_real_thinking_end_tag("use '</thinking>' as marker\n\n"),
+            None
+        );
+
+        // 混合情况：双引号包裹后有真正的标签
+        assert_eq!(
+            find_real_thinking_end_tag("about \"</thinking>\" tag</thinking>\n\n"),
+            Some(23)
+        );
+
+        // 混合情况：单引号包裹后有真正的标签
+        assert_eq!(
+            find_real_thinking_end_tag("about '</thinking>' tag</thinking>\n\n"),
+            Some(23)
+        );
+    }
+
+    #[test]
+    fn test_find_real_thinking_end_tag_mixed() {
+        // 先有被包裹的，后有真正的结束标签
+        assert_eq!(
+            find_real_thinking_end_tag("discussing `</thinking>` tag</thinking>\n\n"),
+            Some(28)
+        );
+
+        // 多个被包裹的，最后一个是真正的
+        assert_eq!(
+            find_real_thinking_end_tag("`</thinking>` and `</thinking>` done</thinking>\n\n"),
+            Some(36)
+        );
+
+        // 多种引用字符混合
+        assert_eq!(
+            find_real_thinking_end_tag(
+                "`</thinking>` and \"</thinking>\" and '</thinking>' done</thinking>\n\n"
+            ),
+            Some(54)
+        );
+    }
+
+    #[test]
+    fn test_tool_use_immediately_after_thinking_filters_end_tag_and_closes_thinking_block() {
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all_events = Vec::new();
+
+        // thinking 内容以 `</thinking>` 结尾，但后面没有 `\n\n`（模拟紧跟 tool_use 的场景）
+        all_events.extend(ctx.process_assistant_response("<thinking>abc</thinking>"));
+
+        let tool_events = ctx.process_tool_use(&crate::kiro::model::events::ToolUseEvent {
+            name: "Write".to_string(),
+            tool_use_id: "tool_1".to_string(),
+            input: "{}".to_string(),
+            stop: false,
+        });
+        all_events.extend(tool_events);
+
+        all_events.extend(ctx.generate_final_events());
+
+        // 不应把 `</thinking>` 当作 thinking 内容输出
+        assert!(
+            all_events.iter().all(|e| {
+                !(e.event == "content_block_delta"
+                    && e.data["delta"]["type"] == "thinking_delta"
+                    && e.data["delta"]["thinking"] == "</thinking>")
+            }),
+            "`</thinking>` should be filtered from output"
+        );
+
+        // thinking block 必须在 tool_use block 之前关闭
+        let thinking_index = ctx
+            .thinking_block_index
+            .expect("thinking block index should exist");
+        let pos_thinking_stop = all_events.iter().position(|e| {
+            e.event == "content_block_stop"
+                && e.data["index"].as_i64() == Some(thinking_index as i64)
+        });
+        let pos_tool_start = all_events.iter().position(|e| {
+            e.event == "content_block_start" && e.data["content_block"]["type"] == "tool_use"
+        });
+        assert!(
+            pos_thinking_stop.is_some(),
+            "thinking block should be stopped"
+        );
+        assert!(pos_tool_start.is_some(), "tool_use block should be started");
+        assert!(
+            pos_thinking_stop.unwrap() < pos_tool_start.unwrap(),
+            "thinking block should stop before tool_use block starts"
+        );
+    }
+
+    #[test]
+    fn test_final_flush_filters_standalone_thinking_end_tag() {
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all_events = Vec::new();
+        all_events.extend(ctx.process_assistant_response("<thinking>abc</thinking>"));
+        all_events.extend(ctx.generate_final_events());
+
+        assert!(
+            all_events.iter().all(|e| {
+                !(e.event == "content_block_delta"
+                    && e.data["delta"]["type"] == "thinking_delta"
+                    && e.data["delta"]["thinking"] == "</thinking>")
+            }),
+            "`</thinking>` should be filtered during final flush"
+        );
+    }
+
+    #[test]
+    fn test_thinking_strips_leading_newline_same_chunk() {
+        // <thinking>\n 在同一个 chunk 中，\n 应被剥离
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let events = ctx.process_assistant_response("<thinking>\nHello world");
+
+        // 找到所有 thinking_delta 事件
+        let thinking_deltas: Vec<_> = events
+            .iter()
+            .filter(|e| {
+                e.event == "content_block_delta" && e.data["delta"]["type"] == "thinking_delta"
+            })
+            .collect();
+
+        // 拼接所有 thinking 内容
+        let full_thinking: String = thinking_deltas
+            .iter()
+            .map(|e| e.data["delta"]["thinking"].as_str().unwrap_or(""))
+            .collect();
+
+        assert!(
+            !full_thinking.starts_with('\n'),
+            "thinking content should not start with \\n, got: {:?}",
+            full_thinking
+        );
+    }
+
+    #[test]
+    fn test_thinking_strips_leading_newline_cross_chunk() {
+        // <thinking> 在第一个 chunk 末尾，\n 在第二个 chunk 开头
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let events1 = ctx.process_assistant_response("<thinking>");
+        let events2 = ctx.process_assistant_response("\nHello world");
+
+        let mut all_events = Vec::new();
+        all_events.extend(events1);
+        all_events.extend(events2);
+
+        let thinking_deltas: Vec<_> = all_events
+            .iter()
+            .filter(|e| {
+                e.event == "content_block_delta" && e.data["delta"]["type"] == "thinking_delta"
+            })
+            .collect();
+
+        let full_thinking: String = thinking_deltas
+            .iter()
+            .map(|e| e.data["delta"]["thinking"].as_str().unwrap_or(""))
+            .collect();
+
+        assert!(
+            !full_thinking.starts_with('\n'),
+            "thinking content should not start with \\n across chunks, got: {:?}",
+            full_thinking
+        );
+    }
+
+    #[test]
+    fn test_thinking_no_strip_when_no_leading_newline() {
+        // <thinking> 后直接跟内容（无 \n），内容应完整保留
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let events = ctx.process_assistant_response("<thinking>abc</thinking>\n\ntext");
+
+        let thinking_deltas: Vec<_> = events
+            .iter()
+            .filter(|e| {
+                e.event == "content_block_delta" && e.data["delta"]["type"] == "thinking_delta"
+            })
+            .collect();
+
+        let full_thinking: String = thinking_deltas
+            .iter()
+            .filter(|e| {
+                !e.data["delta"]["thinking"]
+                    .as_str()
+                    .unwrap_or("")
+                    .is_empty()
+            })
+            .map(|e| e.data["delta"]["thinking"].as_str().unwrap_or(""))
+            .collect();
+
+        assert_eq!(full_thinking, "abc", "thinking content should be 'abc'");
+    }
+
+    #[test]
+    fn test_text_after_thinking_strips_leading_newlines() {
+        // `</thinking>\n\n` 后的文本不应以 \n\n 开头
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let events = ctx.process_assistant_response("<thinking>\nabc</thinking>\n\n你好");
+
+        let text_deltas: Vec<_> = events
+            .iter()
+            .filter(|e| e.event == "content_block_delta" && e.data["delta"]["type"] == "text_delta")
+            .collect();
+
+        let full_text: String = text_deltas
+            .iter()
+            .map(|e| e.data["delta"]["text"].as_str().unwrap_or(""))
+            .collect();
+
+        assert!(
+            !full_text.starts_with('\n'),
+            "text after thinking should not start with \\n, got: {:?}",
+            full_text
+        );
+        assert_eq!(full_text, "你好");
+    }
+
+    /// 辅助函数：从事件列表中提取所有 thinking_delta 的拼接内容
+    fn collect_thinking_content(events: &[SseEvent]) -> String {
+        events
+            .iter()
+            .filter(|e| {
+                e.event == "content_block_delta" && e.data["delta"]["type"] == "thinking_delta"
+            })
+            .map(|e| e.data["delta"]["thinking"].as_str().unwrap_or(""))
+            .filter(|s| !s.is_empty())
+            .collect()
+    }
+
+    /// 辅助函数：从事件列表中提取所有 text_delta 的拼接内容
+    fn collect_text_content(events: &[SseEvent]) -> String {
+        events
+            .iter()
+            .filter(|e| e.event == "content_block_delta" && e.data["delta"]["type"] == "text_delta")
+            .map(|e| e.data["delta"]["text"].as_str().unwrap_or(""))
+            .collect()
+    }
+
+    #[test]
+    fn test_end_tag_newlines_split_across_events() {
+        // `</thinking>\n` 在 chunk 1，`\n` 在 chunk 2，`text` 在 chunk 3
+        // 确保 `</thinking>` 不会被部分当作 thinking 内容发出
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all = Vec::new();
+        all.extend(ctx.process_assistant_response("<thinking>\nabc</thinking>\n"));
+        all.extend(ctx.process_assistant_response("\n"));
+        all.extend(ctx.process_assistant_response("你好"));
+        all.extend(ctx.generate_final_events());
+
+        let thinking = collect_thinking_content(&all);
+        assert_eq!(
+            thinking, "abc",
+            "thinking should be 'abc', got: {:?}",
+            thinking
+        );
+
+        let text = collect_text_content(&all);
+        assert_eq!(text, "你好", "text should be '你好', got: {:?}", text);
+    }
+
+    #[test]
+    fn test_end_tag_alone_in_chunk_then_newlines_in_next() {
+        // `</thinking>` 单独在一个 chunk，`\n\ntext` 在下一个 chunk
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all = Vec::new();
+        all.extend(ctx.process_assistant_response("<thinking>\nabc</thinking>"));
+        all.extend(ctx.process_assistant_response("\n\n你好"));
+        all.extend(ctx.generate_final_events());
+
+        let thinking = collect_thinking_content(&all);
+        assert_eq!(
+            thinking, "abc",
+            "thinking should be 'abc', got: {:?}",
+            thinking
+        );
+
+        let text = collect_text_content(&all);
+        assert_eq!(text, "你好", "text should be '你好', got: {:?}", text);
+    }
+
+    #[test]
+    fn test_start_tag_newline_split_across_events() {
+        // `\n\n` 在 chunk 1，`<thinking>` 在 chunk 2，`\n` 在 chunk 3
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all = Vec::new();
+        all.extend(ctx.process_assistant_response("\n\n"));
+        all.extend(ctx.process_assistant_response("<thinking>"));
+        all.extend(ctx.process_assistant_response("\n"));
+        all.extend(ctx.process_assistant_response("abc</thinking>\n\ntext"));
+        all.extend(ctx.generate_final_events());
+
+        let thinking = collect_thinking_content(&all);
+        assert_eq!(
+            thinking, "abc",
+            "thinking should be 'abc', got: {:?}",
+            thinking
+        );
+
+        let text = collect_text_content(&all);
+        assert_eq!(text, "text", "text should be 'text', got: {:?}", text);
+    }
+
+    #[test]
+    fn test_full_flow_maximally_split() {
+        // 极端拆分：每个关键边界都在不同 chunk
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all = Vec::new();
+        // \n\n<thinking>\n 拆成多段
+        all.extend(ctx.process_assistant_response("\n"));
+        all.extend(ctx.process_assistant_response("\n"));
+        all.extend(ctx.process_assistant_response("<thin"));
+        all.extend(ctx.process_assistant_response("king>"));
+        all.extend(ctx.process_assistant_response("\n"));
+        all.extend(ctx.process_assistant_response("hello"));
+        // </thinking>\n\n 拆成多段
+        all.extend(ctx.process_assistant_response("</thi"));
+        all.extend(ctx.process_assistant_response("nking>"));
+        all.extend(ctx.process_assistant_response("\n"));
+        all.extend(ctx.process_assistant_response("\n"));
+        all.extend(ctx.process_assistant_response("world"));
+        all.extend(ctx.generate_final_events());
+
+        let thinking = collect_thinking_content(&all);
+        assert_eq!(
+            thinking, "hello",
+            "thinking should be 'hello', got: {:?}",
+            thinking
+        );
+
+        let text = collect_text_content(&all);
+        assert_eq!(text, "world", "text should be 'world', got: {:?}", text);
+    }
+
+    #[test]
+    fn test_thinking_only_sets_max_tokens_stop_reason() {
+        // 整个流只有 thinking 块，没有 text 也没有 tool_use，stop_reason 应为 max_tokens
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all_events = Vec::new();
+        all_events.extend(ctx.process_assistant_response("<thinking>\nabc</thinking>"));
+        all_events.extend(ctx.generate_final_events());
+
+        let message_delta = all_events
+            .iter()
+            .find(|e| e.event == "message_delta")
+            .expect("should have message_delta event");
+
+        assert_eq!(
+            message_delta.data["delta"]["stop_reason"], "max_tokens",
+            "stop_reason should be max_tokens when only thinking is produced"
+        );
+
+        // 应补发一套完整的 text 事件（content_block_start + delta 空格 + content_block_stop）
+        assert!(
+            all_events.iter().any(|e| {
+                e.event == "content_block_start" && e.data["content_block"]["type"] == "text"
+            }),
+            "should emit text content_block_start"
+        );
+        assert!(
+            all_events.iter().any(|e| {
+                e.event == "content_block_delta"
+                    && e.data["delta"]["type"] == "text_delta"
+                    && e.data["delta"]["text"] == " "
+            }),
+            "should emit text_delta with a single space"
+        );
+        // text block 应被 generate_final_events 自动关闭
+        let text_block_index = all_events
+            .iter()
+            .find_map(|e| {
+                if e.event == "content_block_start" && e.data["content_block"]["type"] == "text" {
+                    e.data["index"].as_i64()
+                } else {
+                    None
+                }
+            })
+            .expect("text block should exist");
+        assert!(
+            all_events.iter().any(|e| {
+                e.event == "content_block_stop"
+                    && e.data["index"].as_i64() == Some(text_block_index)
+            }),
+            "text block should be stopped"
+        );
+    }
+
+    #[test]
+    fn test_thinking_with_text_keeps_end_turn_stop_reason() {
+        // thinking + text 的情况，stop_reason 应为 end_turn
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all_events = Vec::new();
+        all_events.extend(ctx.process_assistant_response("<thinking>\nabc</thinking>\n\nHello"));
+        all_events.extend(ctx.generate_final_events());
+
+        let message_delta = all_events
+            .iter()
+            .find(|e| e.event == "message_delta")
+            .expect("should have message_delta event");
+
+        assert_eq!(
+            message_delta.data["delta"]["stop_reason"], "end_turn",
+            "stop_reason should be end_turn when text is also produced"
+        );
+    }
+
+    #[test]
+    fn test_thinking_with_tool_use_keeps_tool_use_stop_reason() {
+        // thinking + tool_use 的情况，stop_reason 应为 tool_use
+        let mut ctx = StreamContext::new_with_thinking("test-model", 1, true);
+        let _initial_events = ctx.generate_initial_events();
+
+        let mut all_events = Vec::new();
+        all_events.extend(ctx.process_assistant_response("<thinking>\nabc</thinking>"));
+        all_events.extend(
+            ctx.process_tool_use(&crate::kiro::model::events::ToolUseEvent {
+                name: "test_tool".to_string(),
+                tool_use_id: "tool_1".to_string(),
+                input: "{}".to_string(),
+                stop: true,
+            }),
+        );
+        all_events.extend(ctx.generate_final_events());
+
+        let message_delta = all_events
+            .iter()
+            .find(|e| e.event == "message_delta")
+            .expect("should have message_delta event");
+
+        assert_eq!(
+            message_delta.data["delta"]["stop_reason"], "tool_use",
+            "stop_reason should be tool_use when tool_use is present"
+        );
+    }
+}
diff --git a/src/anthropic/tool_compression.rs b/src/anthropic/tool_compression.rs
new file mode 100644
index 0000000..1fd31be
--- /dev/null
+++ b/src/anthropic/tool_compression.rs
@@ -0,0 +1,276 @@
+//! 工具定义压缩模块
+//!
+//! 当工具定义的总序列化大小超过阈值时，通过两步压缩减小体积：
+//! 1. 简化 `input_schema`：移除非必要字段（description 等），仅保留结构骨架
+//! 2. 按比例截断 `description`：根据超出比例缩短描述，最短保留 50 字符
+
+use crate::kiro::model::requests::tool::{InputSchema, Tool as KiroTool, ToolSpecification};
+
+/// 工具定义总大小阈值（20KB）
+const TOOL_SIZE_THRESHOLD: usize = 20 * 1024;
+
+/// description 最短保留字符数
+const MIN_DESCRIPTION_CHARS: usize = 50;
+
+/// 如果工具定义总大小超过阈值，执行压缩
+///
+/// 返回压缩后的工具列表（如果未超阈值则原样返回）
+pub fn compress_tools_if_needed(tools: &[KiroTool]) -> Vec<KiroTool> {
+    let total_size = estimate_tools_size(tools);
+    if total_size <= TOOL_SIZE_THRESHOLD {
+        return tools.to_vec();
+    }
+
+    tracing::info!(
+        total_size,
+        threshold = TOOL_SIZE_THRESHOLD,
+        tool_count = tools.len(),
+        "工具定义超过阈值，开始压缩"
+    );
+
+    // 第一步：简化 input_schema
+    let mut compressed: Vec<KiroTool> = tools.iter().map(simplify_schema).collect();
+
+    let size_after_schema = estimate_tools_size(&compressed);
+    if size_after_schema <= TOOL_SIZE_THRESHOLD {
+        tracing::info!(
+            original_size = total_size,
+            compressed_size = size_after_schema,
+            "schema 简化后已低于阈值"
+        );
+        return compressed;
+    }
+    // 第二步：按比例截断 description（基于字节大小）
+    let ratio = TOOL_SIZE_THRESHOLD as f64 / size_after_schema as f64;
+    for tool in &mut compressed {
+        let desc = &tool.tool_specification.description;
+        let target_bytes = (desc.len() as f64 * ratio) as usize;
+        // 最短保留 MIN_DESCRIPTION_CHARS 个字符对应的字节数（至少 50 字符）
+        let min_bytes = desc
+            .char_indices()
+            .nth(MIN_DESCRIPTION_CHARS)
+            .map(|(idx, _)| idx)
+            .unwrap_or(desc.len());
+        let target_bytes = target_bytes.max(min_bytes);
+        if desc.len() > target_bytes {
+            // UTF-8 安全截断：找到不超过 target_bytes 的最大字符边界
+            let truncate_at = desc
+                .char_indices()
+                .take_while(|(idx, _)| *idx <= target_bytes)
+                .last()
+                .map(|(idx, ch)| idx + ch.len_utf8())
+                .unwrap_or(0);
+            tool.tool_specification.description = desc[..truncate_at].to_string();
+        }
+    }
+
+    let final_size = estimate_tools_size(&compressed);
+    tracing::info!(
+        original_size = total_size,
+        after_schema = size_after_schema,
+        final_size,
+        "工具压缩完成"
+    );
+
+    compressed
+}
+
+/// 估算工具列表的总序列化大小（字节）
+fn estimate_tools_size(tools: &[KiroTool]) -> usize {
+    tools
+        .iter()
+        .map(|t| {
+            let spec = &t.tool_specification;
+            spec.name.len()
+                + spec.description.len()
+                + serde_json::to_string(&spec.input_schema.json)
+                    .map(|s| s.len())
+                    .unwrap_or(0)
+        })
+        .sum()
+}
+
+/// 简化工具的 input_schema
+///
+/// 保留结构骨架（type, properties 的 key 和 type, required），
+/// 移除 properties 内部的 description、examples 等非必要字段
+fn simplify_schema(tool: &KiroTool) -> KiroTool {
+    let schema = &tool.tool_specification.input_schema.json;
+    let simplified = simplify_json_schema(schema);
+
+    KiroTool {
+        tool_specification: ToolSpecification {
+            name: tool.tool_specification.name.clone(),
+            description: tool.tool_specification.description.clone(),
+            input_schema: InputSchema::from_json(simplified),
+        },
+    }
+}
+
+/// 递归简化 JSON Schema
+fn simplify_json_schema(schema: &serde_json::Value) -> serde_json::Value {
+    let Some(obj) = schema.as_object() else {
+        return schema.clone();
+    };
+
+    let mut result = serde_json::Map::new();
+
+    // 保留顶层结构字段
+    for key in &["$schema", "type", "required", "additionalProperties"] {
+        if let Some(v) = obj.get(*key) {
+            result.insert(key.to_string(), v.clone());
+        }
+    }
+
+    // 简化 properties：仅保留每个属性的 type
+    if let Some(serde_json::Value::Object(props)) = obj.get("properties") {
+        let mut simplified_props = serde_json::Map::new();
+        for (name, prop_schema) in props {
+            if let Some(prop_obj) = prop_schema.as_object() {
+                let mut simplified_prop = serde_json::Map::new();
+                // 保留 type
+                if let Some(ty) = prop_obj.get("type") {
+                    simplified_prop.insert("type".to_string(), ty.clone());
+                }
+                // 递归简化嵌套 properties（如 object 类型）
+                if let Some(nested_props) = prop_obj.get("properties") {
+                    // 构造完整的子 schema，保留 required 和 additionalProperties
+                    let mut nested_schema = serde_json::Map::new();
+                    nested_schema.insert(
+                        "type".to_string(),
+                        serde_json::Value::String("object".to_string()),
+                    );
+                    nested_schema.insert("properties".to_string(), nested_props.clone());
+                    if let Some(req) = prop_obj.get("required") {
+                        nested_schema.insert("required".to_string(), req.clone());
+                    }
+                    if let Some(ap) = prop_obj.get("additionalProperties") {
+                        nested_schema.insert("additionalProperties".to_string(), ap.clone());
+                    }
+                    let nested = simplify_json_schema(&serde_json::Value::Object(nested_schema));
+                    if let Some(np) = nested.get("properties") {
+                        simplified_prop.insert("properties".to_string(), np.clone());
+                    }
+                    if let Some(req) = nested.get("required") {
+                        simplified_prop.insert("required".to_string(), req.clone());
+                    }
+                    if let Some(ap) = nested.get("additionalProperties") {
+                        simplified_prop.insert("additionalProperties".to_string(), ap.clone());
+                    }
+                }
+                // 保留 items（数组类型）
+                if let Some(items) = prop_obj.get("items") {
+                    simplified_prop.insert("items".to_string(), simplify_json_schema(items));
+                }
+                // 保留 enum
+                if let Some(e) = prop_obj.get("enum") {
+                    simplified_prop.insert("enum".to_string(), e.clone());
+                }
+                simplified_props.insert(name.clone(), serde_json::Value::Object(simplified_prop));
+            } else {
+                simplified_props.insert(name.clone(), prop_schema.clone());
+            }
+        }
+        result.insert(
+            "properties".to_string(),
+            serde_json::Value::Object(simplified_props),
+        );
+    }
+
+    serde_json::Value::Object(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_tool(name: &str, desc: &str, schema: serde_json::Value) -> KiroTool {
+        KiroTool {
+            tool_specification: ToolSpecification {
+                name: name.to_string(),
+                description: desc.to_string(),
+                input_schema: InputSchema::from_json(schema),
+            },
+        }
+    }
+
+    #[test]
+    fn test_no_compression_under_threshold() {
+        let tools = vec![make_tool(
+            "test",
+            "A short description",
+            serde_json::json!({"type": "object", "properties": {}}),
+        )];
+        let result = compress_tools_if_needed(&tools);
+        assert_eq!(result.len(), 1);
+        assert_eq!(
+            result[0].tool_specification.description,
+            "A short description"
+        );
+    }
+
+    #[test]
+    fn test_compression_triggers_over_threshold() {
+        // 创建大量工具使总大小超过 20KB
+        let long_desc = "x".repeat(2000);
+        let tools: Vec<KiroTool> = (0..15)
+            .map(|i| {
+                make_tool(
+                    &format!("tool_{}", i),
+                    &long_desc,
+                    serde_json::json!({
+                        "type": "object",
+                        "properties": {
+                            "param1": {"type": "string", "description": "A very long parameter description that adds to the size"},
+                            "param2": {"type": "number", "description": "Another long description for testing purposes"}
+                        }
+                    }),
+                )
+            })
+            .collect();
+
+        let original_size = estimate_tools_size(&tools);
+        assert!(original_size > TOOL_SIZE_THRESHOLD, "测试数据应超过阈值");
+
+        let result = compress_tools_if_needed(&tools);
+        let compressed_size = estimate_tools_size(&result);
+        assert!(
+            compressed_size < original_size,
+            "压缩后应更小: {} < {}",
+            compressed_size,
+            original_size
+        );
+    }
+
+    #[test]
+    fn test_simplify_schema_removes_descriptions() {
+        let tool = make_tool(
+            "test",
+            "desc",
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "The file path to read"
+                    }
+                },
+                "required": ["path"]
+            }),
+        );
+
+        let simplified = simplify_schema(&tool);
+        let props = simplified
+            .tool_specification
+            .input_schema
+            .json
+            .get("properties")
+            .unwrap();
+        let path_prop = props.get("path").unwrap();
+
+        // description 应被移除
+        assert!(path_prop.get("description").is_none());
+        // type 应保留
+        assert_eq!(path_prop.get("type").unwrap(), "string");
+    }
+}
diff --git a/src/anthropic/truncation.rs b/src/anthropic/truncation.rs
new file mode 100644
index 0000000..4320a7f
--- /dev/null
+++ b/src/anthropic/truncation.rs
@@ -0,0 +1,282 @@
+//! 工具调用截断检测模块
+//!
+//! 当上游返回的工具调用 JSON 被截断时（例如因为 max_tokens 限制），
+//! 提供启发式检测和软失败恢复机制，引导模型分块重试。
+
+/// 截断类型
+#[derive(Debug, Clone, PartialEq)]
+pub enum TruncationType {
+    /// 工具输入为空（上游可能完全截断了 input）
+    EmptyInput,
+    /// JSON 解析失败（不完整的 JSON）
+    InvalidJson,
+    /// 缺少必要字段（JSON 有效但结构不完整）
+    #[allow(dead_code)]
+    MissingFields,
+    /// 未闭合的字符串（JSON 字符串被截断）
+    IncompleteString,
+}
+
+impl std::fmt::Display for TruncationType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TruncationType::EmptyInput => write!(f, "empty_input"),
+            TruncationType::InvalidJson => write!(f, "invalid_json"),
+            TruncationType::MissingFields => write!(f, "missing_fields"),
+            TruncationType::IncompleteString => write!(f, "incomplete_string"),
+        }
+    }
+}
+
+/// 截断检测结果
+#[derive(Debug, Clone)]
+pub struct TruncationInfo {
+    /// 截断类型
+    pub truncation_type: TruncationType,
+    /// 工具名称
+    pub tool_name: String,
+    /// 工具调用 ID
+    pub tool_use_id: String,
+    /// 原始输入（可能不完整）
+    #[allow(dead_code)]
+    pub raw_input: String,
+}
+
+/// 检测工具调用输入是否被截断
+///
+/// 启发式判断规则：
+/// 1. 空输入 → EmptyInput
+/// 2. 未闭合的引号 → IncompleteString
+/// 3. 括号不平衡 → InvalidJson
+/// 4. 末尾字符异常（非 `}` / `]` / `"` / 数字 / `true` / `false` / `null`）→ InvalidJson
+pub fn detect_truncation(
+    tool_name: &str,
+    tool_use_id: &str,
+    raw_input: &str,
+) -> Option<TruncationInfo> {
+    let trimmed = raw_input.trim();
+
+    // 空输入
+    if trimmed.is_empty() {
+        return Some(TruncationInfo {
+            truncation_type: TruncationType::EmptyInput,
+            tool_name: tool_name.to_string(),
+            tool_use_id: tool_use_id.to_string(),
+            raw_input: raw_input.to_string(),
+        });
+    }
+
+    // 检查未闭合的字符串引号
+    if has_unclosed_string(trimmed) {
+        return Some(TruncationInfo {
+            truncation_type: TruncationType::IncompleteString,
+            tool_name: tool_name.to_string(),
+            tool_use_id: tool_use_id.to_string(),
+            raw_input: raw_input.to_string(),
+        });
+    }
+
+    // 检查括号平衡
+    if !are_brackets_balanced(trimmed) {
+        return Some(TruncationInfo {
+            truncation_type: TruncationType::InvalidJson,
+            tool_name: tool_name.to_string(),
+            tool_use_id: tool_use_id.to_string(),
+            raw_input: raw_input.to_string(),
+        });
+    }
+
+    None
+}
+
+/// 构建软失败的工具结果消息
+///
+/// 当检测到截断时，生成一条引导模型分块重试的错误消息，
+/// 而不是直接返回解析错误。
+pub fn build_soft_failure_result(info: &TruncationInfo) -> String {
+    match info.truncation_type {
+        TruncationType::EmptyInput => {
+            format!(
+                "Tool call '{}' (id: {}) was truncated: the input was empty. \
+                 This usually means the response was cut off due to token limits. \
+                 Please retry with a shorter input or break the operation into smaller steps.",
+                info.tool_name, info.tool_use_id
+            )
+        }
+        TruncationType::IncompleteString => {
+            format!(
+                "Tool call '{}' (id: {}) was truncated: a string value was not properly closed. \
+                 The input appears to have been cut off mid-string. \
+                 Please retry with shorter content or split the operation into multiple calls.",
+                info.tool_name, info.tool_use_id
+            )
+        }
+        TruncationType::InvalidJson => {
+            format!(
+                "Tool call '{}' (id: {}) was truncated: the JSON input is incomplete \
+                 (unbalanced brackets). Please retry with a shorter input or break the \
+                 operation into smaller steps.",
+                info.tool_name, info.tool_use_id
+            )
+        }
+        TruncationType::MissingFields => {
+            format!(
+                "Tool call '{}' (id: {}) was truncated: required fields are missing. \
+                 Please retry with all required fields included.",
+                info.tool_name, info.tool_use_id
+            )
+        }
+    }
+}
+
+/// 检查字符串中是否有未闭合的引号
+fn has_unclosed_string(s: &str) -> bool {
+    let mut in_string = false;
+    let mut escape_next = false;
+
+    for ch in s.chars() {
+        if escape_next {
+            escape_next = false;
+            continue;
+        }
+        match ch {
+            '\\' if in_string => {
+                escape_next = true;
+            }
+            '"' => {
+                in_string = !in_string;
+            }
+            _ => {}
+        }
+    }
+
+    in_string
+}
+
+/// 检查括号是否平衡
+fn are_brackets_balanced(s: &str) -> bool {
+    let mut stack: Vec<char> = Vec::new();
+    let mut in_string = false;
+    let mut escape_next = false;
+
+    for ch in s.chars() {
+        if escape_next {
+            escape_next = false;
+            continue;
+        }
+        if in_string {
+            match ch {
+                '\\' => escape_next = true,
+                '"' => in_string = false,
+                _ => {}
+            }
+            continue;
+        }
+        match ch {
+            '"' => in_string = true,
+            '{' | '[' => stack.push(ch),
+            '}' => {
+                if stack.last() != Some(&'{') {
+                    return false;
+                }
+                stack.pop();
+            }
+            ']' => {
+                if stack.last() != Some(&'[') {
+                    return false;
+                }
+                stack.pop();
+            }
+            _ => {}
+        }
+    }
+
+    stack.is_empty()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_detect_empty_input() {
+        let result = detect_truncation("Write", "tool-1", "");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().truncation_type, TruncationType::EmptyInput);
+    }
+
+    #[test]
+    fn test_detect_whitespace_only_input() {
+        let result = detect_truncation("Write", "tool-1", "   \n  ");
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().truncation_type, TruncationType::EmptyInput);
+    }
+
+    #[test]
+    fn test_detect_incomplete_string() {
+        let result = detect_truncation("Write", "tool-1", r#"{"content": "hello world"#);
+        assert!(result.is_some());
+        assert_eq!(
+            result.unwrap().truncation_type,
+            TruncationType::IncompleteString
+        );
+    }
+
+    #[test]
+    fn test_detect_unbalanced_brackets() {
+        // 字符串已闭合但括号不平衡
+        let result = detect_truncation("Write", "tool-1", r#"{"content": "hello","more": 123"#);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().truncation_type, TruncationType::InvalidJson);
+    }
+
+    #[test]
+    fn test_valid_json_no_truncation() {
+        let result = detect_truncation("Write", "tool-1", r#"{"content": "hello"}"#);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_valid_empty_object() {
+        let result = detect_truncation("Write", "tool-1", "{}");
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_nested_brackets() {
+        let result = detect_truncation("Write", "tool-1", r#"{"a": {"b": [1, 2, {"c": 3}]}}"#);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_escaped_quotes_in_string() {
+        let result = detect_truncation("Write", "tool-1", r#"{"content": "say \"hello\""}"#);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_build_soft_failure_empty() {
+        let info = TruncationInfo {
+            truncation_type: TruncationType::EmptyInput,
+            tool_name: "Write".to_string(),
+            tool_use_id: "tool-1".to_string(),
+            raw_input: String::new(),
+        };
+        let msg = build_soft_failure_result(&info);
+        assert!(msg.contains("truncated"));
+        assert!(msg.contains("Write"));
+        assert!(msg.contains("tool-1"));
+    }
+
+    #[test]
+    fn test_build_soft_failure_incomplete_string() {
+        let info = TruncationInfo {
+            truncation_type: TruncationType::IncompleteString,
+            tool_name: "Edit".to_string(),
+            tool_use_id: "tool-2".to_string(),
+            raw_input: r#"{"old_string": "hello"#.to_string(),
+        };
+        let msg = build_soft_failure_result(&info);
+        assert!(msg.contains("string value was not properly closed"));
+    }
+}
diff --git a/src/anthropic/types.rs b/src/anthropic/types.rs
new file mode 100644
index 0000000..74202fa
--- /dev/null
+++ b/src/anthropic/types.rs
@@ -0,0 +1,315 @@
+//! Anthropic API 类型定义
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+// === 错误响应 ===
+
+/// API 错误响应
+#[derive(Debug, Serialize)]
+pub struct ErrorResponse {
+    pub error: ErrorDetail,
+}
+
+/// 错误详情
+#[derive(Debug, Serialize)]
+pub struct ErrorDetail {
+    #[serde(rename = "type")]
+    pub error_type: String,
+    pub message: String,
+}
+
+impl ErrorResponse {
+    /// 创建新的错误响应
+    pub fn new(error_type: impl Into<String>, message: impl Into<String>) -> Self {
+        Self {
+            error: ErrorDetail {
+                error_type: error_type.into(),
+                message: message.into(),
+            },
+        }
+    }
+
+    /// 创建认证错误响应
+    pub fn authentication_error() -> Self {
+        Self::new("authentication_error", "Invalid API key")
+    }
+}
+
+// === Models 端点类型 ===
+
+/// 模型信息
+#[derive(Debug, Serialize)]
+pub struct Model {
+    pub id: String,
+    pub object: String,
+    pub created: i64,
+    pub owned_by: String,
+    pub display_name: String,
+    #[serde(rename = "type")]
+    pub model_type: String,
+    pub max_tokens: i32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub context_length: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_completion_tokens: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<bool>,
+}
+
+/// 模型列表响应
+#[derive(Debug, Serialize)]
+pub struct ModelsResponse {
+    pub object: String,
+    pub data: Vec<Model>,
+}
+
+// === Messages 端点类型 ===
+
+/// 最大思考预算 tokens
+const MAX_BUDGET_TOKENS: i32 = 128_000;
+
+/// Thinking 配置
+#[derive(Debug, Deserialize, Clone)]
+pub struct Thinking {
+    #[serde(rename = "type")]
+    pub thinking_type: String,
+    #[serde(
+        default = "default_budget_tokens",
+        deserialize_with = "deserialize_budget_tokens"
+    )]
+    pub budget_tokens: i32,
+}
+
+impl Thinking {
+    /// 是否启用了 thinking（enabled 或 adaptive）
+    pub fn is_enabled(&self) -> bool {
+        self.thinking_type == "enabled" || self.thinking_type == "adaptive"
+    }
+}
+
+fn default_budget_tokens() -> i32 {
+    20000
+}
+fn deserialize_budget_tokens<'de, D>(deserializer: D) -> Result<i32, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let value = i32::deserialize(deserializer)?;
+    Ok(value.min(MAX_BUDGET_TOKENS))
+}
+
+/// OutputConfig 配置
+#[derive(Debug, Deserialize, Clone)]
+pub struct OutputConfig {
+    #[serde(default = "default_effort")]
+    pub effort: String,
+}
+
+fn default_effort() -> String {
+    "high".to_string()
+}
+
+/// Claude Code 请求中的 metadata
+#[derive(Debug, Clone, Deserialize)]
+pub struct Metadata {
+    /// 用户 ID，格式如: user_xxx_account__session_0b4445e1-f5be-49e1-87ce-62bbc28ad705
+    pub user_id: Option<String>,
+}
+
+/// Messages 请求体
+#[derive(Debug, Deserialize)]
+pub struct MessagesRequest {
+    pub model: String,
+    /// 为 Anthropic API 兼容保留，实际不透传给 Kiro 上游
+    pub max_tokens: i32,
+    pub messages: Vec<Message>,
+    #[serde(default)]
+    pub stream: bool,
+    #[serde(default, deserialize_with = "deserialize_system")]
+    pub system: Option<Vec<SystemMessage>>,
+    pub tools: Option<Vec<Tool>>,
+    #[allow(dead_code)]
+    pub tool_choice: Option<serde_json::Value>,
+    pub thinking: Option<Thinking>,
+    pub output_config: Option<OutputConfig>,
+    /// Claude Code 请求中的 metadata，包含 session 信息
+    pub metadata: Option<Metadata>,
+}
+
+/// 反序列化 system 字段，支持字符串或数组格式
+fn deserialize_system<'de, D>(deserializer: D) -> Result<Option<Vec<SystemMessage>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    // 创建一个 visitor 来处理 string 或 array
+    struct SystemVisitor;
+
+    impl<'de> serde::de::Visitor<'de> for SystemVisitor {
+        type Value = Option<Vec<SystemMessage>>;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("a string or an array of system messages")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(Some(vec![SystemMessage {
+                text: value.to_string(),
+            }]))
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: serde::de::SeqAccess<'de>,
+        {
+            let mut messages = Vec::new();
+            while let Some(msg) = seq.next_element()? {
+                messages.push(msg);
+            }
+            Ok(if messages.is_empty() {
+                None
+            } else {
+                Some(messages)
+            })
+        }
+
+        fn visit_none<E>(self) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(None)
+        }
+
+        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+        where
+            D: serde::Deserializer<'de>,
+        {
+            serde::de::Deserialize::deserialize(deserializer)
+        }
+    }
+
+    deserializer.deserialize_any(SystemVisitor)
+}
+
+/// 消息
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Message {
+    pub role: String,
+    /// 可以是 string 或 ContentBlock 数组
+    pub content: serde_json::Value,
+}
+
+/// 系统消息
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct SystemMessage {
+    pub text: String,
+}
+
+/// 工具定义
+///
+/// 支持两种格式：
+/// 1. 普通工具：{ name, description, input_schema }
+/// 2. WebSearch 工具：{ type: "web_search_20250305", name: "web_search", max_uses: 8 }
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Tool {
+    /// 工具类型，如 "web_search_20250305"（可选，仅 WebSearch 工具）
+    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
+    pub tool_type: Option<String>,
+    /// 工具名称
+    #[serde(default)]
+    pub name: String,
+    /// 工具描述（普通工具必需，WebSearch 工具可选）
+    #[serde(default)]
+    pub description: String,
+    /// 输入参数 schema（普通工具必需，WebSearch 工具无此字段）
+    #[serde(default)]
+    pub input_schema: HashMap<String, serde_json::Value>,
+    /// 最大使用次数（仅 WebSearch 工具）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_uses: Option<i32>,
+}
+
+impl Tool {
+    /// 检查是否为 WebSearch 工具
+    #[allow(dead_code)]
+    pub fn is_web_search(&self) -> bool {
+        self.tool_type
+            .as_ref()
+            .is_some_and(|t| t.starts_with("web_search"))
+    }
+}
+
+/// 内容块
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ContentBlock {
+    #[serde(rename = "type")]
+    pub block_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_use_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub input: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub is_error: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<ImageSource>,
+}
+
+/// 图片数据源
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ImageSource {
+    #[serde(rename = "type")]
+    pub source_type: String,
+    pub media_type: String,
+    pub data: String,
+}
+
+// === Count Tokens 端点类型 ===
+
+/// Token 计数请求
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CountTokensRequest {
+    pub model: String,
+    pub messages: Vec<Message>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        deserialize_with = "deserialize_system"
+    )]
+    pub system: Option<Vec<SystemMessage>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<Tool>>,
+}
+
+/// Token 计数响应
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CountTokensResponse {
+    pub input_tokens: i32,
+}
+
+/// 根据模型名称获取上下文窗口大小
+///
+/// - Opus 4.6 和 Sonnet 4.6 系列: 1,000,000 tokens
+/// - 其他模型: 200,000 tokens
+pub fn get_context_window_size(model: &str) -> i32 {
+    let model_lower = model.to_lowercase();
+    if (model_lower.contains("opus") || model_lower.contains("sonnet"))
+        && (model_lower.contains("4-6") || model_lower.contains("4.6"))
+    {
+        1_000_000
+    } else {
+        200_000
+    }
+}
diff --git a/src/anthropic/websearch.rs b/src/anthropic/websearch.rs
new file mode 100644
index 0000000..4e90f6f
--- /dev/null
+++ b/src/anthropic/websearch.rs
@@ -0,0 +1,987 @@
+//! WebSearch 工具处理模块
+//!
+//! 实现 Anthropic WebSearch 请求到 Kiro MCP 的转换和响应生成
+
+use std::convert::Infallible;
+
+use axum::{
+    body::Body,
+    http::{StatusCode, header},
+    response::{IntoResponse, Json, Response},
+};
+use bytes::Bytes;
+use futures::{Stream, stream};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use uuid::Uuid;
+
+use super::stream::SseEvent;
+use super::types::{ErrorResponse, MessagesRequest};
+
+const WEB_SEARCH_PREFIX: &str = "Perform a web search for the query: ";
+
+/// MCP 请求
+#[derive(Debug, Serialize)]
+pub struct McpRequest {
+    pub id: String,
+    pub jsonrpc: String,
+    pub method: String,
+    pub params: McpParams,
+}
+
+/// MCP 请求参数
+#[derive(Debug, Serialize)]
+pub struct McpParams {
+    pub name: String,
+    pub arguments: McpArguments,
+}
+
+/// MCP 参数
+#[derive(Debug, Serialize)]
+pub struct McpArguments {
+    pub query: String,
+}
+
+/// MCP 响应
+#[derive(Debug, Deserialize)]
+pub struct McpResponse {
+    pub error: Option<McpError>,
+    #[allow(dead_code)]
+    pub id: String,
+    #[allow(dead_code)]
+    pub jsonrpc: String,
+    pub result: Option<McpResult>,
+}
+
+/// MCP 错误
+#[derive(Debug, Deserialize)]
+pub struct McpError {
+    pub code: Option<i32>,
+    pub message: Option<String>,
+}
+
+/// MCP 结果
+#[derive(Debug, Deserialize)]
+pub struct McpResult {
+    pub content: Vec<McpContent>,
+    #[serde(rename = "isError")]
+    #[allow(dead_code)]
+    pub is_error: bool,
+}
+
+/// MCP 内容
+#[derive(Debug, Deserialize)]
+pub struct McpContent {
+    #[serde(rename = "type")]
+    pub content_type: String,
+    pub text: String,
+}
+
+/// WebSearch 搜索结果
+#[derive(Debug, Deserialize)]
+#[allow(dead_code)]
+pub struct WebSearchResults {
+    pub results: Vec<WebSearchResult>,
+    #[serde(rename = "totalResults")]
+    pub total_results: Option<i32>,
+    pub query: Option<String>,
+    pub error: Option<String>,
+}
+
+/// 单个搜索结果
+#[derive(Debug, Deserialize, Clone)]
+#[allow(dead_code)]
+pub struct WebSearchResult {
+    pub title: String,
+    pub url: String,
+    pub snippet: Option<String>,
+    #[serde(rename = "publishedDate")]
+    pub published_date: Option<i64>,
+    pub id: Option<String>,
+    pub domain: Option<String>,
+    #[serde(rename = "maxVerbatimWordLimit")]
+    pub max_verbatim_word_limit: Option<i32>,
+    #[serde(rename = "publicDomain")]
+    pub public_domain: Option<bool>,
+}
+
+/// 检查请求是否包含 WebSearch 工具
+///
+/// 只要 tools 中出现 web_search（按 name 或 type 判断），就认为应走本地 WebSearch 处理。
+pub fn has_web_search_tool(req: &MessagesRequest) -> bool {
+    req.tools.as_ref().is_some_and(|tools| {
+        tools
+            .iter()
+            .any(|t| t.name == "web_search" || t.is_web_search())
+    })
+}
+
+fn tool_choice_requests_web_search(req: &MessagesRequest) -> bool {
+    let Some(choice) = req.tool_choice.as_ref() else {
+        return false;
+    };
+
+    let Some(obj) = choice.as_object() else {
+        return false;
+    };
+
+    // Anthropic 常见形态：{"type":"tool","name":"web_search"}
+    let name = obj
+        .get("name")
+        .and_then(|v| v.as_str())
+        .or_else(|| obj.get("tool_name").and_then(|v| v.as_str()));
+
+    if name != Some("web_search") {
+        return false;
+    }
+
+    // 若包含 type 字段，仅当 type=tool 才视为“强制调用”
+    match obj.get("type").and_then(|v| v.as_str()) {
+        Some("tool") => true,
+        Some(_) => false,
+        None => true,
+    }
+}
+
+fn is_only_web_search_tool(req: &MessagesRequest) -> bool {
+    req.tools.as_ref().is_some_and(|tools| {
+        tools.len() == 1
+            && tools
+                .first()
+                .is_some_and(|t| t.name == "web_search" || t.is_web_search())
+    })
+}
+
+fn extract_last_user_text(req: &MessagesRequest) -> Option<String> {
+    let msg = req
+        .messages
+        .iter()
+        .rev()
+        .find(|m| m.role == "user")
+        .or_else(|| req.messages.last())?;
+
+    match &msg.content {
+        serde_json::Value::String(s) => Some(s.clone()),
+        serde_json::Value::Array(arr) => {
+            let first_block = arr.first()?;
+            if first_block.get("type")?.as_str()? == "text" {
+                Some(first_block.get("text")?.as_str()?.to_string())
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+fn request_explicit_web_search_prefix(req: &MessagesRequest) -> bool {
+    extract_last_user_text(req)
+        .map(|t| t.trim_start().starts_with(WEB_SEARCH_PREFIX))
+        .unwrap_or(false)
+}
+
+/// 判断当前请求是否应走“本地 WebSearch”处理。
+///
+/// 注意：`tools` 里包含 `web_search` 仅代表“可用工具”，并不代表这次一定要执行搜索。
+/// 若不加额外条件，容易把普通对话/任务指令误当成搜索查询，导致 MCP 侧返回 -32602。
+pub fn should_handle_websearch_request(req: &MessagesRequest) -> bool {
+    if !has_web_search_tool(req) {
+        return false;
+    }
+
+    // 1) tool_choice 强制选择 web_search
+    if tool_choice_requests_web_search(req) {
+        return true;
+    }
+
+    // 2) 兼容旧客户端：仅提供 web_search 单工具时，视为“纯 WebSearch 请求”
+    if is_only_web_search_tool(req) {
+        return true;
+    }
+
+    // 3) 兼容 Claude Code 风格前缀
+    request_explicit_web_search_prefix(req)
+}
+
+/// 从请求的 tools 列表中移除 web_search 工具。
+///
+/// 当请求包含混合工具（web_search + 其他工具）时，剔除 web_search 后转发上游。
+/// 若剔除后 tools 为空，则设为 None。
+pub fn strip_web_search_tools(req: &mut MessagesRequest) {
+    if let Some(tools) = req.tools.as_mut() {
+        tools.retain(|t| t.name != "web_search" && !t.is_web_search());
+        if tools.is_empty() {
+            req.tools = None;
+        }
+    }
+}
+
+/// 从消息中提取搜索查询
+///
+/// 读取 messages 中最后一条 user 消息的第一个内容块（更符合多轮对话场景）
+/// 并去除 "Perform a web search for the query: " 前缀
+pub fn extract_search_query(req: &MessagesRequest) -> Option<String> {
+    // 优先取最后一条 user 消息，否则回退到最后一条消息
+    let msg = req
+        .messages
+        .iter()
+        .rev()
+        .find(|m| m.role == "user")
+        .or_else(|| req.messages.last())?;
+
+    // 提取文本内容
+    let text = match &msg.content {
+        serde_json::Value::String(s) => s.clone(),
+        serde_json::Value::Array(arr) => {
+            // 获取第一个内容块
+            let first_block = arr.first()?;
+            if first_block.get("type")?.as_str()? == "text" {
+                first_block.get("text")?.as_str()?.to_string()
+            } else {
+                return None;
+            }
+        }
+        _ => return None,
+    };
+
+    // 去除前缀 "Perform a web search for the query: "
+    let query = text
+        .strip_prefix(WEB_SEARCH_PREFIX)
+        .map(|s| s.to_string())
+        .unwrap_or(text);
+
+    let query = query.split_whitespace().collect::<Vec<_>>().join(" ");
+    if query.is_empty() { None } else { Some(query) }
+}
+
+/// 生成22位大小写字母和数字的随机字符串
+fn generate_random_id_22() -> String {
+    const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    (0..22)
+        .map(|_| {
+            let idx = fastrand::usize(..CHARSET.len());
+            CHARSET[idx] as char
+        })
+        .collect()
+}
+
+/// 生成8位小写字母和数字的随机字符串
+fn generate_random_id_8() -> String {
+    const CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyz0123456789";
+    (0..8)
+        .map(|_| {
+            let idx = fastrand::usize(..CHARSET.len());
+            CHARSET[idx] as char
+        })
+        .collect()
+}
+
+/// 创建 MCP 请求
+///
+/// ID 格式: web_search_tooluse_{22位随机}_{毫秒时间戳}_{8位随机}
+pub fn create_mcp_request(query: &str) -> (String, McpRequest) {
+    let random_22 = generate_random_id_22();
+    let timestamp = chrono::Utc::now().timestamp_millis();
+    let random_8 = generate_random_id_8();
+
+    let request_id = format!(
+        "web_search_tooluse_{}_{}_{}",
+        random_22, timestamp, random_8
+    );
+
+    // tool_use_id 使用相同格式
+    let tool_use_id = format!(
+        "srvtoolu_{}",
+        &Uuid::new_v4().to_string().replace('-', "")[..32]
+    );
+
+    let request = McpRequest {
+        id: request_id,
+        jsonrpc: "2.0".to_string(),
+        method: "tools/call".to_string(),
+        params: McpParams {
+            name: "web_search".to_string(),
+            arguments: McpArguments {
+                query: query.to_string(),
+            },
+        },
+    };
+
+    (tool_use_id, request)
+}
+
+/// 解析 MCP 响应中的搜索结果
+pub fn parse_search_results(mcp_response: &McpResponse) -> Option<WebSearchResults> {
+    let result = mcp_response.result.as_ref()?;
+    let content = result.content.first()?;
+
+    if content.content_type != "text" {
+        return None;
+    }
+
+    serde_json::from_str(&content.text).ok()
+}
+
+/// 生成 WebSearch SSE 响应流
+pub fn create_websearch_sse_stream(
+    model: String,
+    query: String,
+    tool_use_id: String,
+    search_results: Option<WebSearchResults>,
+    input_tokens: i32,
+) -> impl Stream<Item = Result<Bytes, Infallible>> {
+    let events =
+        generate_websearch_events(&model, &query, &tool_use_id, search_results, input_tokens);
+
+    stream::iter(
+        events
+            .into_iter()
+            .map(|e| Ok(Bytes::from(e.to_sse_string()))),
+    )
+}
+
+/// 生成 WebSearch SSE 事件序列
+fn generate_websearch_events(
+    model: &str,
+    query: &str,
+    tool_use_id: &str,
+    search_results: Option<WebSearchResults>,
+    input_tokens: i32,
+) -> Vec<SseEvent> {
+    let mut events = Vec::new();
+    let message_id = format!("msg_{}", &Uuid::new_v4().to_string().replace('-', "")[..24]);
+
+    // 1. message_start
+    events.push(SseEvent::new(
+        "message_start",
+        json!({
+            "type": "message_start",
+            "message": {
+                "id": message_id,
+                "type": "message",
+                "role": "assistant",
+                "model": model,
+                "content": [],
+                "stop_reason": null,
+                "usage": {
+                    "input_tokens": input_tokens,
+                    "output_tokens": 0,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0
+                }
+            }
+        }),
+    ));
+
+    // 2. content_block_start (text - 搜索决策说明, index 0)
+    let decision_text = format!("I'll search for \"{}\".", query);
+    events.push(SseEvent::new(
+        "content_block_start",
+        json!({
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "text",
+                "text": ""
+            }
+        }),
+    ));
+
+    events.push(SseEvent::new(
+        "content_block_delta",
+        json!({
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {
+                "type": "text_delta",
+                "text": decision_text
+            }
+        }),
+    ));
+
+    events.push(SseEvent::new(
+        "content_block_stop",
+        json!({
+            "type": "content_block_stop",
+            "index": 0
+        }),
+    ));
+
+    // 3. content_block_start (server_tool_use, index 1)
+    // server_tool_use 是服务端工具，input 在 content_block_start 中一次性完整发送，
+    // 不像客户端 tool_use 需要通过 input_json_delta 增量传输。
+    events.push(SseEvent::new(
+        "content_block_start",
+        json!({
+            "type": "content_block_start",
+            "index": 1,
+            "content_block": {
+                "id": tool_use_id,
+                "type": "server_tool_use",
+                "name": "web_search",
+                "input": {"query": query}
+            }
+        }),
+    ));
+
+    // 4. content_block_stop (server_tool_use)
+    events.push(SseEvent::new(
+        "content_block_stop",
+        json!({
+            "type": "content_block_stop",
+            "index": 1
+        }),
+    ));
+
+    // 5. content_block_start (web_search_tool_result, index 2)
+    // 官方 API 的 web_search_tool_result 没有 tool_use_id 字段
+    let search_content = if let Some(ref results) = search_results {
+        results
+            .results
+            .iter()
+            .map(|r| {
+                let page_age = r.published_date.and_then(|ms| {
+                    chrono::DateTime::from_timestamp_millis(ms)
+                        .map(|dt| dt.format("%B %-d, %Y").to_string())
+                });
+                json!({
+                    "type": "web_search_result",
+                    "title": r.title,
+                    "url": r.url,
+                    "encrypted_content": r.snippet.clone().unwrap_or_default(),
+                    "page_age": page_age
+                })
+            })
+            .collect::<Vec<_>>()
+    } else {
+        vec![]
+    };
+
+    events.push(SseEvent::new(
+        "content_block_start",
+        json!({
+            "type": "content_block_start",
+            "index": 2,
+            "content_block": {
+                "type": "web_search_tool_result",
+                "content": search_content
+            }
+        }),
+    ));
+
+    // 6. content_block_stop (web_search_tool_result)
+    events.push(SseEvent::new(
+        "content_block_stop",
+        json!({
+            "type": "content_block_stop",
+            "index": 2
+        }),
+    ));
+
+    // 7. content_block_start (text, index 3)
+    events.push(SseEvent::new(
+        "content_block_start",
+        json!({
+            "type": "content_block_start",
+            "index": 3,
+            "content_block": {
+                "type": "text",
+                "text": ""
+            }
+        }),
+    ));
+
+    // 8. content_block_delta (text_delta) - 生成搜索结果摘要
+    let summary = generate_search_summary(query, &search_results);
+
+    // 分块发送文本
+    let chunk_size = 100;
+    for chunk in summary.chars().collect::<Vec<_>>().chunks(chunk_size) {
+        let text: String = chunk.iter().collect();
+        events.push(SseEvent::new(
+            "content_block_delta",
+            json!({
+                "type": "content_block_delta",
+                "index": 3,
+                "delta": {
+                    "type": "text_delta",
+                    "text": text
+                }
+            }),
+        ));
+    }
+
+    // 9. content_block_stop (text)
+    events.push(SseEvent::new(
+        "content_block_stop",
+        json!({
+            "type": "content_block_stop",
+            "index": 3
+        }),
+    ));
+
+    // 10. message_delta
+    // 官方 API 的 message_delta.delta 中没有 stop_sequence 字段
+    let output_tokens = (summary.len() as i32 + 3) / 4; // 简单估算
+    events.push(SseEvent::new(
+        "message_delta",
+        json!({
+            "type": "message_delta",
+            "delta": {
+                "stop_reason": "end_turn"
+            },
+            "usage": {
+                "output_tokens": output_tokens,
+                "server_tool_use": {
+                    "web_search_requests": 1
+                }
+            }
+        }),
+    ));
+
+    // 11. message_stop
+    events.push(SseEvent::new(
+        "message_stop",
+        json!({
+            "type": "message_stop"
+        }),
+    ));
+
+    events
+}
+
+/// 生成搜索结果摘要
+fn generate_search_summary(query: &str, results: &Option<WebSearchResults>) -> String {
+    let mut summary = format!("Here are the search results for \"{}\":\n\n", query);
+
+    if let Some(results) = results {
+        for (i, result) in results.results.iter().enumerate() {
+            summary.push_str(&format!("{}. **{}**\n", i + 1, result.title));
+            if let Some(ref snippet) = result.snippet {
+                // 截断过长的摘要（安全处理 UTF-8 多字节字符）
+                let truncated = match snippet.char_indices().nth(200) {
+                    Some((idx, _)) => format!("{}...", &snippet[..idx]),
+                    None => snippet.clone(),
+                };
+                summary.push_str(&format!("   {}\n", truncated));
+            }
+            summary.push_str(&format!("   Source: {}\n\n", result.url));
+        }
+    } else {
+        summary.push_str("No results found.\n");
+    }
+
+    summary.push_str("\nPlease note that these are web search results and may not be fully accurate or up-to-date.");
+
+    summary
+}
+
+/// 处理 WebSearch 请求
+pub async fn handle_websearch_request(
+    provider: std::sync::Arc<crate::kiro::provider::KiroProvider>,
+    payload: &MessagesRequest,
+    input_tokens: i32,
+) -> Response {
+    // 1. 提取搜索查询
+    let query = match extract_search_query(payload) {
+        Some(q) => q,
+        None => {
+            return (
+                StatusCode::BAD_REQUEST,
+                Json(ErrorResponse::new(
+                    "invalid_request_error",
+                    "无法从消息中提取搜索查询",
+                )),
+            )
+                .into_response();
+        }
+    };
+
+    tracing::info!(query = %query, "处理 WebSearch 请求");
+
+    // 2. 创建 MCP 请求
+    let (tool_use_id, mcp_request) = create_mcp_request(&query);
+
+    // 3. 调用 Kiro MCP API
+    let search_results = match call_mcp_api(&provider, &mcp_request).await {
+        Ok(response) => parse_search_results(&response),
+        Err(e) => {
+            tracing::warn!("MCP API 调用失败: {}", e);
+            None
+        }
+    };
+
+    // 4. 生成 SSE 响应
+    let model = payload.model.clone();
+    if payload.stream {
+        let stream =
+            create_websearch_sse_stream(model, query, tool_use_id, search_results, input_tokens);
+
+        return Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "text/event-stream")
+            .header(header::CACHE_CONTROL, "no-cache")
+            .header(header::CONNECTION, "keep-alive")
+            .body(Body::from_stream(stream))
+            .unwrap();
+    }
+
+    let summary = generate_search_summary(&query, &search_results);
+    let search_content = if let Some(ref results) = search_results {
+        results
+            .results
+            .iter()
+            .map(|r| {
+                json!({
+                    "type": "web_search_result",
+                    "title": r.title,
+                    "url": r.url,
+                    "encrypted_content": r.snippet.clone().unwrap_or_default(),
+                    "page_age": null
+                })
+            })
+            .collect::<Vec<_>>()
+    } else {
+        vec![]
+    };
+
+    let output_tokens = (summary.len() as i32 + 3) / 4; // 简单估算
+
+    let response_body = json!({
+        "id": format!("msg_{}", &Uuid::new_v4().to_string().replace('-', "")[..24]),
+        "type": "message",
+        "role": "assistant",
+        "model": model,
+        "content": [
+            {
+                "type": "server_tool_use",
+                "id": tool_use_id,
+                "name": "web_search",
+                "input": { "query": query }
+            },
+            {
+                "type": "web_search_tool_result",
+                "tool_use_id": tool_use_id,
+                "content": search_content
+            },
+            {
+                "type": "text",
+                "text": summary
+            }
+        ],
+        "stop_reason": "end_turn",
+        "stop_sequence": null,
+        "usage": {
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens
+        }
+    });
+
+    (StatusCode::OK, Json(response_body)).into_response()
+}
+
+/// 调用 Kiro MCP API
+async fn call_mcp_api(
+    provider: &crate::kiro::provider::KiroProvider,
+    request: &McpRequest,
+) -> anyhow::Result<McpResponse> {
+    let request_body = serde_json::to_string(request)?;
+
+    tracing::debug!("MCP request: {}", request_body);
+
+    let response = provider.call_mcp(&request_body).await?;
+
+    let body = response.text().await?;
+    tracing::debug!("MCP response: {}", body);
+
+    let mcp_response: McpResponse = serde_json::from_str(&body)?;
+
+    if let Some(ref error) = mcp_response.error {
+        anyhow::bail!(
+            "MCP error: {} - {}",
+            error.code.unwrap_or(-1),
+            error.message.as_deref().unwrap_or("Unknown error")
+        );
+    }
+
+    Ok(mcp_response)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_has_web_search_tool_only_one() {
+        use crate::anthropic::types::{Message, Tool};
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: serde_json::json!("test"),
+            }],
+            stream: true,
+            system: None,
+            tools: Some(vec![Tool {
+                tool_type: Some("web_search_20250305".to_string()),
+                name: "web_search".to_string(),
+                description: String::new(),
+                input_schema: Default::default(),
+                max_uses: Some(8),
+            }]),
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        assert!(has_web_search_tool(&req));
+    }
+
+    #[test]
+    fn test_has_web_search_tool_when_multiple_tools() {
+        use crate::anthropic::types::{Message, Tool};
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: serde_json::json!("test"),
+            }],
+            stream: true,
+            system: None,
+            tools: Some(vec![
+                Tool {
+                    tool_type: Some("web_search_20250305".to_string()),
+                    name: "web_search".to_string(),
+                    description: String::new(),
+                    input_schema: Default::default(),
+                    max_uses: Some(8),
+                },
+                Tool {
+                    tool_type: None,
+                    name: "other_tool".to_string(),
+                    description: "Other tool".to_string(),
+                    input_schema: Default::default(),
+                    max_uses: None,
+                },
+            ]),
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        assert!(has_web_search_tool(&req));
+    }
+
+    #[test]
+    fn test_has_web_search_tool_when_name_missing_but_type_matches() {
+        use crate::anthropic::types::{Message, Tool};
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: serde_json::json!("test"),
+            }],
+            stream: true,
+            system: None,
+            tools: Some(vec![Tool {
+                tool_type: Some("web_search_20250305".to_string()),
+                name: "".to_string(), // 模拟客户端只传 type 的情况
+                description: String::new(),
+                input_schema: Default::default(),
+                max_uses: Some(8),
+            }]),
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        assert!(has_web_search_tool(&req));
+    }
+
+    #[test]
+    fn test_extract_search_query_with_prefix() {
+        use crate::anthropic::types::Message;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: serde_json::json!([{
+                    "type": "text",
+                    "text": "Perform a web search for the query: rust latest version 2026"
+                }]),
+            }],
+            stream: true,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let query = extract_search_query(&req);
+        // 前缀应该被去除
+        assert_eq!(query, Some("rust latest version 2026".to_string()));
+    }
+
+    #[test]
+    fn test_extract_search_query_plain_text() {
+        use crate::anthropic::types::Message;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: serde_json::json!("What is the weather today?"),
+            }],
+            stream: true,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let query = extract_search_query(&req);
+        assert_eq!(query, Some("What is the weather today?".to_string()));
+    }
+
+    #[test]
+    fn test_extract_search_query_uses_last_user_message() {
+        use crate::anthropic::types::Message;
+
+        let req = MessagesRequest {
+            model: "claude-sonnet-4".to_string(),
+            max_tokens: 1024,
+            messages: vec![
+                Message {
+                    role: "user".to_string(),
+                    content: serde_json::json!("not a query"),
+                },
+                Message {
+                    role: "assistant".to_string(),
+                    content: serde_json::json!("ok"),
+                },
+                Message {
+                    role: "user".to_string(),
+                    content: serde_json::json!([{
+                        "type": "text",
+                        "text": "Perform a web search for the query: rust"
+                    }]),
+                },
+            ],
+            stream: true,
+            system: None,
+            tools: None,
+            tool_choice: None,
+            thinking: None,
+            output_config: None,
+            metadata: None,
+        };
+
+        let query = extract_search_query(&req);
+        assert_eq!(query, Some("rust".to_string()));
+    }
+
+    #[test]
+    fn test_create_mcp_request() {
+        let (tool_use_id, request) = create_mcp_request("test query");
+
+        assert!(tool_use_id.starts_with("srvtoolu_"));
+        assert_eq!(request.jsonrpc, "2.0");
+        assert_eq!(request.method, "tools/call");
+        assert_eq!(request.params.name, "web_search");
+        assert_eq!(request.params.arguments.query, "test query");
+
+        // 验证 ID 格式: web_search_tooluse_{22位}_{时间戳}_{8位}
+        assert!(request.id.starts_with("web_search_tooluse_"));
+    }
+
+    #[test]
+    fn test_mcp_request_id_format() {
+        let (_, request) = create_mcp_request("test");
+
+        // 格式: web_search_tooluse_{22位}_{毫秒时间戳}_{8位}
+        let id = &request.id;
+        assert!(id.starts_with("web_search_tooluse_"));
+
+        let suffix = &id["web_search_tooluse_".len()..];
+        let parts: Vec<&str> = suffix.split('_').collect();
+        assert_eq!(parts.len(), 3, "应该有3个部分: 22位随机_时间戳_8位随机");
+
+        // 第一部分: 22位大小写字母和数字
+        assert_eq!(parts[0].len(), 22);
+        assert!(parts[0].chars().all(|c| c.is_ascii_alphanumeric()));
+
+        // 第二部分: 毫秒时间戳
+        assert!(parts[1].parse::<i64>().is_ok());
+
+        // 第三部分: 8位小写字母和数字
+        assert_eq!(parts[2].len(), 8);
+        assert!(
+            parts[2]
+                .chars()
+                .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit())
+        );
+    }
+
+    #[test]
+    fn test_parse_search_results() {
+        let response = McpResponse {
+            error: None,
+            id: "test_id".to_string(),
+            jsonrpc: "2.0".to_string(),
+            result: Some(McpResult {
+                content: vec![McpContent {
+                    content_type: "text".to_string(),
+                    text: r#"{"results":[{"title":"Test","url":"https://example.com","snippet":"Test snippet"}],"totalResults":1}"#.to_string(),
+                }],
+                is_error: false,
+            }),
+        };
+
+        let results = parse_search_results(&response);
+        assert!(results.is_some());
+        let results = results.unwrap();
+        assert_eq!(results.results.len(), 1);
+        assert_eq!(results.results[0].title, "Test");
+    }
+
+    #[test]
+    fn test_generate_search_summary() {
+        let results = WebSearchResults {
+            results: vec![WebSearchResult {
+                title: "Test Result".to_string(),
+                url: "https://example.com".to_string(),
+                snippet: Some("This is a test snippet".to_string()),
+                published_date: None,
+                id: None,
+                domain: None,
+                max_verbatim_word_limit: None,
+                public_domain: None,
+            }],
+            total_results: Some(1),
+            query: Some("test".to_string()),
+            error: None,
+        };
+
+        let summary = generate_search_summary("test", &Some(results));
+
+        assert!(summary.contains("Test Result"));
+        assert!(summary.contains("https://example.com"));
+        assert!(summary.contains("This is a test snippet"));
+    }
+}
diff --git a/src/common/auth.rs b/src/common/auth.rs
new file mode 100644
index 0000000..74f4b17
--- /dev/null
+++ b/src/common/auth.rs
@@ -0,0 +1,41 @@
+//! 公共认证工具函数
+
+use axum::{
+    body::Body,
+    http::{Request, header},
+};
+use subtle::ConstantTimeEq;
+
+/// 从请求中提取 API Key
+///
+/// 支持两种认证方式：
+/// - `x-api-key` header
+/// - `Authorization: Bearer <token>` header
+pub fn extract_api_key(request: &Request<Body>) -> Option<String> {
+    // 优先检查 x-api-key
+    if let Some(key) = request
+        .headers()
+        .get("x-api-key")
+        .and_then(|v| v.to_str().ok())
+    {
+        return Some(key.to_string());
+    }
+
+    // 其次检查 Authorization: Bearer
+    request
+        .headers()
+        .get(header::AUTHORIZATION)
+        .and_then(|v| v.to_str().ok())
+        .and_then(|v| v.strip_prefix("Bearer "))
+        .map(|s| s.to_string())
+}
+
+/// 常量时间字符串比较，防止时序攻击
+///
+/// 无论字符串内容如何，比较所需的时间都是恒定的，
+/// 这可以防止攻击者通过测量响应时间来猜测 API Key。
+///
+/// 使用经过安全审计的 `subtle` crate 实现
+pub fn constant_time_eq(a: &str, b: &str) -> bool {
+    a.as_bytes().ct_eq(b.as_bytes()).into()
+}
diff --git a/src/common/mod.rs b/src/common/mod.rs
new file mode 100644
index 0000000..22204fe
--- /dev/null
+++ b/src/common/mod.rs
@@ -0,0 +1,5 @@
+//! 公共工具模块
+
+pub mod auth;
+pub mod redact;
+pub mod utf8;
diff --git a/src/common/redact.rs b/src/common/redact.rs
new file mode 100644
index 0000000..0e88e19
--- /dev/null
+++ b/src/common/redact.rs
@@ -0,0 +1,97 @@
+//! 日志脱敏工具
+//!
+//! 目标：避免在日志中输出敏感信息（Token、密钥、密码等）。
+
+#![allow(dead_code)] // 工具模块，函数将在后续被调用
+
+/// 统一的脱敏占位符
+pub const REDACTED: &str = "<redacted>";
+
+/// 将 `Option<String>` 映射为“是否存在”的脱敏表示：
+/// - `Some(_)` -> `Some("<redacted>")`
+/// - `None` -> `None`
+#[inline]
+pub fn redact_opt_string(value: &Option<String>) -> Option<&'static str> {
+    value.as_ref().map(|_| REDACTED)
+}
+
+/// 脱敏邮箱：
+/// - `abc@example.com` -> `a***@example.com`
+/// - 无法解析时返回 `<redacted>`
+pub fn mask_email(email: &str) -> String {
+    let (local, domain) = match email.split_once('@') {
+        Some((l, d)) if !l.is_empty() && !d.is_empty() => (l, d),
+        _ => return REDACTED.to_string(),
+    };
+
+    // 保留首个完整字符（支持多字节 UTF-8）
+    let first_char_end = local
+        .char_indices()
+        .nth(1)
+        .map(|(i, _)| i)
+        .unwrap_or(local.len());
+    format!("{}***@{}", &local[..first_char_end], domain)
+}
+
+/// 脱敏 AWS ARN 中的 account id（第 5 段）：
+/// `arn:aws:service:region:123456789012:resource` -> `arn:aws:service:region:***:resource`
+pub fn mask_aws_account_id_in_arn(arn: &str) -> String {
+    let mut parts = arn.splitn(6, ':').collect::<Vec<_>>();
+    if parts.len() != 6 || parts[0] != "arn" {
+        return arn.to_string();
+    }
+
+    if !parts[4].is_empty() {
+        parts[4] = "***";
+    }
+
+    parts.join(":")
+}
+
+/// 脱敏 URL 中的 userinfo（仅当包含 `scheme://...@`）：
+/// - `http://user:pass@host:port` -> `http://user:***@host:port`
+/// - `http://user@host` -> `http://***@host`
+pub fn mask_url_userinfo(url: &str) -> String {
+    let Some(scheme_end) = url.find("://").map(|i| i + 3) else {
+        return url.to_string();
+    };
+
+    // authority 结束于首个 '/'、'?'、'#' 或字符串末尾
+    let authority_end = url[scheme_end..]
+        .find(['/', '?', '#'])
+        .map(|i| scheme_end + i)
+        .unwrap_or(url.len());
+
+    // '@' 必须在 authority 内才是 userinfo 分隔符
+    let Some(at_pos) = url[scheme_end..authority_end]
+        .find('@')
+        .map(|i| scheme_end + i)
+    else {
+        return url.to_string();
+    };
+
+    let userinfo = &url[scheme_end..at_pos];
+    if userinfo.is_empty() {
+        return url.to_string();
+    }
+
+    let masked_userinfo = match userinfo.split_once(':') {
+        Some((user, _pass)) if !user.is_empty() => format!("{}:***", user),
+        _ => "***".to_string(),
+    };
+
+    format!(
+        "{}{}{}",
+        &url[..scheme_end],
+        masked_userinfo,
+        &url[at_pos..]
+    )
+}
+
+/// 脱敏 User-Agent 中的 machine_id（常见形态为以 `-<machine_id>` 结尾）。
+pub fn mask_user_agent_machine_id(value: &str) -> String {
+    let Some(pos) = value.rfind('-') else {
+        return value.to_string();
+    };
+    format!("{}{}", &value[..(pos + 1)], REDACTED)
+}
diff --git a/src/common/utf8.rs b/src/common/utf8.rs
new file mode 100644
index 0000000..4ab6e30
--- /dev/null
+++ b/src/common/utf8.rs
@@ -0,0 +1,46 @@
+//! UTF-8 字符边界工具
+//!
+//! 目前标准库的 `str::floor_char_boundary()` 仍是 nightly-only。
+//! 为了在 stable 上安全按字节索引截断 UTF-8 字符串，这里提供等价实现。
+
+/// 返回不大于 `idx` 的最大 UTF-8 字符边界（byte index）。
+///
+/// - 若 `idx >= s.len()`，返回 `s.len()`
+/// - 否则向左回退到最近的 `is_char_boundary()` 位置
+#[inline]
+pub fn floor_char_boundary(s: &str, idx: usize) -> usize {
+    if idx >= s.len() {
+        return s.len();
+    }
+
+    let mut i = idx;
+    while i > 0 && !s.is_char_boundary(i) {
+        i -= 1;
+    }
+    i
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_floor_char_boundary_ascii() {
+        let s = "abcdef";
+        assert_eq!(floor_char_boundary(s, 3), 3);
+        assert_eq!(floor_char_boundary(s, 999), s.len());
+    }
+
+    #[test]
+    fn test_floor_char_boundary_utf8() {
+        let s = "你好ab";
+        // "你" 占 3 字节；idx=1/2 应回退到 0
+        assert_eq!(floor_char_boundary(s, 1), 0);
+        assert_eq!(floor_char_boundary(s, 2), 0);
+        assert_eq!(floor_char_boundary(s, 3), 3);
+        // idx 落在第二个汉字中间（3..6）
+        assert_eq!(floor_char_boundary(s, 4), 3);
+        assert_eq!(floor_char_boundary(s, 5), 3);
+        assert_eq!(floor_char_boundary(s, 6), 6);
+    }
+}
diff --git a/src/debug.rs b/src/debug.rs
new file mode 100644
index 0000000..206ea9c
--- /dev/null
+++ b/src/debug.rs
@@ -0,0 +1,210 @@
+//! 调试工具模块
+//!
+//! 提供 hex 打印和 CRC 调试等功能
+
+use crate::kiro::model::events::Event;
+use std::io::Write;
+
+/// 打印 hex 数据 (类似 xxd 格式)
+pub fn print_hex(data: &[u8]) {
+    for (i, chunk) in data.chunks(16).enumerate() {
+        // 打印偏移
+        print!("{:08x}: ", i * 16);
+
+        // 打印 hex
+        for (j, byte) in chunk.iter().enumerate() {
+            if j == 8 {
+                print!(" ");
+            }
+            print!("{:02x} ", byte);
+        }
+
+        // 补齐空格
+        let padding = 16 - chunk.len();
+        for j in 0..padding {
+            if chunk.len() + j == 8 {
+                print!(" ");
+            }
+            print!("   ");
+        }
+
+        // 打印 ASCII
+        print!(" |");
+        for byte in chunk {
+            if *byte >= 0x20 && *byte < 0x7f {
+                print!("{}", *byte as char);
+            } else {
+                print!(".");
+            }
+        }
+        println!("|");
+    }
+    std::io::stdout().flush().ok();
+}
+
+/// 调试 CRC 计算 - 分析 AWS Event Stream 帧的 CRC
+pub fn debug_crc(data: &[u8]) {
+    if data.len() < 12 {
+        println!("[CRC 调试] 数据不足 12 字节");
+        return;
+    }
+
+    use crc::{Crc, CRC_32_BZIP2, CRC_32_ISO_HDLC, CRC_32_ISCSI, CRC_32_JAMCRC};
+
+    let total_length = u32::from_be_bytes([data[0], data[1], data[2], data[3]]);
+    let header_length = u32::from_be_bytes([data[4], data[5], data[6], data[7]]);
+    let prelude_crc = u32::from_be_bytes([data[8], data[9], data[10], data[11]]);
+
+    println!("\n[CRC 调试]");
+    println!("  total_length: {} (0x{:08x})", total_length, total_length);
+    println!(
+        "  header_length: {} (0x{:08x})",
+        header_length, header_length
+    );
+    println!("  prelude_crc (from data): 0x{:08x}", prelude_crc);
+
+    // 测试各种 CRC32 变种
+    let crc32c: Crc<u32> = Crc::<u32>::new(&CRC_32_ISCSI);
+    let crc32_iso: Crc<u32> = Crc::<u32>::new(&CRC_32_ISO_HDLC);
+    let crc32_bzip2: Crc<u32> = Crc::<u32>::new(&CRC_32_BZIP2);
+    let crc32_jamcrc: Crc<u32> = Crc::<u32>::new(&CRC_32_JAMCRC);
+
+    let prelude = &data[..8];
+
+    println!("  CRC32C (ISCSI):   0x{:08x}", crc32c.checksum(prelude));
+    println!(
+        "  CRC32 ISO-HDLC:   0x{:08x} {}",
+        crc32_iso.checksum(prelude),
+        if crc32_iso.checksum(prelude) == prelude_crc {
+            "<-- MATCH"
+        } else {
+            ""
+        }
+    );
+    println!("  CRC32 BZIP2:      0x{:08x}", crc32_bzip2.checksum(prelude));
+    println!(
+        "  CRC32 JAMCRC:     0x{:08x}",
+        crc32_jamcrc.checksum(prelude)
+    );
+
+    // 打印前 8 字节
+    print!("  前 8 字节: ");
+    for byte in prelude {
+        print!("{:02x} ", byte);
+    }
+    println!();
+}
+
+/// 打印帧摘要信息
+pub fn print_frame_summary(data: &[u8]) {
+    if data.len() < 12 {
+        println!("[帧摘要] 数据不足");
+        return;
+    }
+
+    let total_length = u32::from_be_bytes([data[0], data[1], data[2], data[3]]) as usize;
+    let header_length = u32::from_be_bytes([data[4], data[5], data[6], data[7]]) as usize;
+
+    println!("\n[帧摘要]");
+    println!("  总长度: {} 字节", total_length);
+    println!("  头部长度: {} 字节", header_length);
+    println!("  Payload 长度: {} 字节", total_length.saturating_sub(12 + header_length + 4));
+    println!("  数据可用: {} 字节", data.len());
+
+    if data.len() >= total_length {
+        println!("  状态: 完整帧");
+    } else {
+        println!(
+            "  状态: 不完整 (缺少 {} 字节)",
+            total_length - data.len()
+        );
+    }
+}
+
+/// 详细打印事件 (调试格式，包含事件类型和完整数据)
+pub fn print_event_verbose(event: &Event) {
+    match event {
+        Event::AssistantResponse(e) => {
+            println!("\n[事件] AssistantResponse");
+            println!("  content: {:?}", e.content());
+        }
+        Event::ToolUse(e) => {
+            println!("\n[事件] ToolUse");
+            println!("  name: {:?}", e.name());
+            println!("  tool_use_id: {:?}", e.tool_use_id());
+            println!("  input: {:?}", e.input());
+            println!("  stop: {}", e.is_complete());
+        }
+        Event::Metering(e) => {
+            println!("\n[事件] Metering");
+            println!("  unit: {:?}", e.unit);
+            println!("  unit_plural: {:?}", e.unit_plural);
+            println!("  usage: {}", e.usage);
+        }
+        Event::ContextUsage(e) => {
+            println!("\n[事件] ContextUsage");
+            println!("  context_usage_percentage: {}", e.context_usage_percentage);
+        }
+        Event::Unknown { event_type, payload } => {
+            println!("\n[事件] Unknown");
+            println!("  event_type: {:?}", event_type);
+            println!("  payload ({} bytes):", payload.len());
+            print_hex(payload);
+        }
+        Event::Error {
+            error_code,
+            error_message,
+        } => {
+            println!("\n[事件] Error");
+            println!("  error_code: {:?}", error_code);
+            println!("  error_message: {:?}", error_message);
+        }
+        Event::Exception {
+            exception_type,
+            message,
+        } => {
+            println!("\n[事件] Exception");
+            println!("  exception_type: {:?}", exception_type);
+            println!("  message: {:?}", message);
+        }
+    }
+}
+
+/// 简洁打印事件 (用于正常输出)
+pub fn print_event(event: &Event) {
+    match event {
+        Event::AssistantResponse(e) => {
+            // 实时打印助手响应，不换行
+            print!("{}", e.content());
+            std::io::stdout().flush().ok();
+        }
+        Event::ToolUse(e) => {
+            println!("\n[工具调用] {} (id: {})", e.name(), e.tool_use_id());
+            println!("  输入: {}", e.input());
+            if e.is_complete() {
+                println!("  [调用结束]");
+            }
+        }
+        Event::Metering(e) => {
+            println!("\n[计费] {}", e);
+        }
+        Event::ContextUsage(e) => {
+            println!("\n[上下文使用率] {}", e);
+        }
+        Event::Unknown { event_type, .. } => {
+            println!("\n[未知事件] {}", event_type);
+        }
+        Event::Error {
+            error_code,
+            error_message,
+        } => {
+            println!("\n[错误] {}: {}", error_code, error_message);
+        }
+        Event::Exception {
+            exception_type,
+            message,
+        } => {
+            println!("\n[异常] {}: {}", exception_type, message);
+        }
+    }
+}
diff --git a/src/http_client.rs b/src/http_client.rs
new file mode 100644
index 0000000..d31ff81
--- /dev/null
+++ b/src/http_client.rs
@@ -0,0 +1,105 @@
+//! HTTP Client 构建模块
+//!
+//! 提供统一的 HTTP Client 构建功能，支持代理配置
+
+use reqwest::{Client, Proxy};
+use std::time::Duration;
+
+use crate::model::config::TlsBackend;
+
+/// 代理配置
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
+pub struct ProxyConfig {
+    /// 代理地址，支持 http/https/socks5
+    pub url: String,
+    /// 代理认证用户名
+    pub username: Option<String>,
+    /// 代理认证密码
+    pub password: Option<String>,
+}
+
+impl ProxyConfig {
+    /// 从 url 创建代理配置
+    pub fn new(url: impl Into<String>) -> Self {
+        Self {
+            url: url.into(),
+            username: None,
+            password: None,
+        }
+    }
+
+    /// 设置认证信息
+    pub fn with_auth(mut self, username: impl Into<String>, password: impl Into<String>) -> Self {
+        self.username = Some(username.into());
+        self.password = Some(password.into());
+        self
+    }
+}
+
+/// 构建 HTTP Client
+///
+/// # Arguments
+/// * `proxy` - 可选的代理配置
+/// * `timeout_secs` - 超时时间（秒）
+///
+/// # Returns
+/// 配置好的 reqwest::Client
+pub fn build_client(
+    proxy: Option<&ProxyConfig>,
+    timeout_secs: u64,
+    tls_backend: TlsBackend,
+) -> anyhow::Result<Client> {
+    let mut builder = Client::builder().timeout(Duration::from_secs(timeout_secs));
+
+    if tls_backend == TlsBackend::Rustls {
+        builder = builder.use_rustls_tls();
+    }
+
+    if let Some(proxy_config) = proxy {
+        let mut proxy = Proxy::all(&proxy_config.url)?;
+
+        // 设置代理认证
+        if let (Some(username), Some(password)) = (&proxy_config.username, &proxy_config.password) {
+            proxy = proxy.basic_auth(username, password);
+        }
+
+        builder = builder.proxy(proxy);
+        tracing::debug!("HTTP Client 使用代理: {}", proxy_config.url);
+    }
+
+    Ok(builder.build()?)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_proxy_config_new() {
+        let config = ProxyConfig::new("http://127.0.0.1:7890");
+        assert_eq!(config.url, "http://127.0.0.1:7890");
+        assert!(config.username.is_none());
+        assert!(config.password.is_none());
+    }
+
+    #[test]
+    fn test_proxy_config_with_auth() {
+        let config = ProxyConfig::new("socks5://127.0.0.1:1080").with_auth("user", "pass");
+        assert_eq!(config.url, "socks5://127.0.0.1:1080");
+        assert_eq!(config.username, Some("user".to_string()));
+        assert_eq!(config.password, Some("pass".to_string()));
+    }
+
+    #[test]
+    fn test_build_client_without_proxy() {
+        let client = build_client(None, 30, TlsBackend::Rustls);
+        assert!(client.is_ok());
+    }
+
+    #[test]
+    fn test_build_client_with_proxy() {
+        let config = ProxyConfig::new("http://127.0.0.1:7890");
+        let client = build_client(Some(&config), 30, TlsBackend::Rustls);
+        assert!(client.is_ok());
+    }
+}
diff --git a/src/image.rs b/src/image.rs
new file mode 100644
index 0000000..51bed32
--- /dev/null
+++ b/src/image.rs
@@ -0,0 +1,559 @@
+//! 图片处理模块
+//!
+//! 提供图片 token 计算和缩放功能。
+//!
+//! # Token 计算公式（Anthropic 官方）
+//! ```text
+//! tokens = (width × height) / 750
+//! ```
+//!
+//! # 缩放规则
+//! 1. 长边超过 max_long_edge 时，等比缩放
+//! 2. 总像素超过 max_pixels 时，等比缩放
+//! 3. 多图模式（图片数 >= threshold）使用独立的像素限制配置
+
+use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
+use image::AnimationDecoder;
+use image::codecs::gif::GifDecoder;
+use image::{DynamicImage, ImageFormat, ImageReader};
+use std::io::{BufReader, Cursor};
+use std::time::Duration;
+
+use crate::model::config::CompressionConfig;
+
+const GIF_MAX_OUTPUT_FRAMES: usize = 20;
+const GIF_MAX_FPS: usize = 5;
+const GIF_MIN_FRAME_DELAY: Duration = Duration::from_millis(10);
+const GIF_FRAME_OUTPUT_FORMAT: &str = "jpeg";
+
+#[derive(Debug)]
+pub struct GifSamplingResult {
+    pub frames: Vec<ImageProcessResult>,
+    pub duration_ms: u64,
+    pub source_frames: usize,
+    pub sampling_interval_ms: u64,
+    pub output_format: &'static str,
+}
+
+/// 图片处理结果
+#[derive(Debug)]
+pub struct ImageProcessResult {
+    /// 处理后的 base64 数据
+    pub data: String,
+    /// 原始尺寸 (width, height)
+    pub original_size: (u32, u32),
+    /// 处理后尺寸 (width, height)
+    pub final_size: (u32, u32),
+    /// 估算的 token 数
+    pub tokens: u64,
+    /// 是否进行了缩放
+    pub was_resized: bool,
+    /// 是否进行了重新编码（即使无需缩放）
+    ///
+    /// 主要用于 GIF：即便尺寸已符合限制，也会重新编码为静态帧，
+    /// 避免把“体积巨大但分辨率很小的动图”原样发送到上游导致请求体过大。
+    pub was_reencoded: bool,
+    /// 原始图片字节数（base64 解码后）
+    pub original_bytes_len: usize,
+    /// 处理后图片字节数（编码后、base64 前）
+    pub final_bytes_len: usize,
+}
+
+/// 将 GIF 抽帧并重编码为多张静态图（用于降低请求体、提升“动图内容”识别效果）
+///
+/// 采样策略（符合你给的约束）：
+/// - 总帧数不超过 `GIF_MAX_OUTPUT_FRAMES`
+/// - 采样频率不超过 `GIF_MAX_FPS`（每秒最多 5 张）
+/// - 当 GIF 过长导致超出总帧数时，按“秒级上限”下调采样频率（例如 8 秒 GIF → 每秒最多 2 张）
+pub fn process_gif_frames(
+    base64_data: &str,
+    config: &CompressionConfig,
+    image_count: usize,
+) -> Result<GifSamplingResult, String> {
+    let gif_bytes = BASE64
+        .decode(base64_data)
+        .map_err(|e| format!("base64 解码失败: {}", e))?;
+    let original_bytes_len = gif_bytes.len();
+
+    // Pass 1：计算时长（ms）与源帧数，用于确定采样间隔
+    let (duration_ms, source_frames) = {
+        let decoder = GifDecoder::new(BufReader::new(Cursor::new(&gif_bytes)))
+            .map_err(|e| format!("GIF 解码失败: {}", e))?;
+        let mut total = 0u64;
+        let mut n = 0usize;
+        for frame in decoder.into_frames() {
+            let frame = frame.map_err(|e| format!("GIF 帧解码失败: {}", e))?;
+            let delay = Duration::from(frame.delay()).max(GIF_MIN_FRAME_DELAY);
+            total = total.saturating_add(delay.as_millis().min(u128::from(u64::MAX)) as u64);
+            n += 1;
+        }
+        if n == 0 {
+            return Err("GIF 不包含任何帧".to_string());
+        }
+        (total.max(1), n)
+    };
+
+    // 计算采样间隔：
+    // - 优先按“每秒最多 N 张（N<=5）”控制（用户期望的直觉规则）
+    // - 当 GIF 超长（duration_secs > max_frames）时，转为按 max_frames 均匀采样
+    let duration_secs_ceil = duration_ms.div_ceil(1000).max(1) as usize;
+    let fps_by_total = GIF_MAX_OUTPUT_FRAMES / duration_secs_ceil; // integer fps-per-second cap
+    let fps = fps_by_total.min(GIF_MAX_FPS);
+    let sampling_interval_ms = if fps > 0 {
+        (1000 / fps as u64).max(1000 / GIF_MAX_FPS as u64)
+    } else {
+        // duration_secs_ceil > GIF_MAX_OUTPUT_FRAMES：平均 < 1 fps，改为均匀抽取 max_frames 张
+        duration_ms.div_ceil(GIF_MAX_OUTPUT_FRAMES as u64).max(1)
+    };
+
+    // 根据图片数量选择像素限制（复用现有策略）
+    let max_pixels = if image_count >= config.image_multi_threshold {
+        config.image_max_pixels_multi
+    } else {
+        config.image_max_pixels_single
+    };
+
+    // Pass 2：按采样间隔选择帧并重编码
+    let decoder = GifDecoder::new(BufReader::new(Cursor::new(&gif_bytes)))
+        .map_err(|e| format!("GIF 解码失败: {}", e))?;
+
+    let mut frames_out = Vec::new();
+    let mut elapsed_ms = 0u64; // 当前帧起始时间
+    let mut next_sample_ms = 0u64;
+
+    for frame in decoder.into_frames() {
+        if frames_out.len() >= GIF_MAX_OUTPUT_FRAMES {
+            break;
+        }
+
+        let frame = frame.map_err(|e| format!("GIF 帧解码失败: {}", e))?;
+        let delay = Duration::from(frame.delay()).max(GIF_MIN_FRAME_DELAY);
+        let frame_start_ms = elapsed_ms;
+
+        // 用帧起始时间做采样（避免同一帧被重复选中）
+        if frame_start_ms >= next_sample_ms {
+            let buffer = frame.into_buffer();
+            let original_size = (buffer.width(), buffer.height());
+
+            let (target_w, target_h) = apply_scaling_rules(
+                original_size.0,
+                original_size.1,
+                config.image_max_long_edge,
+                max_pixels,
+            );
+            let needs_resize = target_w != original_size.0 || target_h != original_size.1;
+
+            let img = DynamicImage::ImageRgba8(buffer);
+            let processed = if needs_resize {
+                img.resize(target_w, target_h, image::imageops::FilterType::Lanczos3)
+            } else {
+                img
+            };
+
+            let final_size = (processed.width(), processed.height());
+            let (data, final_bytes_len) = encode_image(&processed, GIF_FRAME_OUTPUT_FORMAT)?;
+
+            frames_out.push(ImageProcessResult {
+                data,
+                original_size,
+                final_size,
+                tokens: calculate_tokens(final_size.0, final_size.1),
+                was_resized: needs_resize,
+                was_reencoded: true,
+                original_bytes_len,
+                final_bytes_len,
+            });
+
+            next_sample_ms = frame_start_ms.saturating_add(sampling_interval_ms);
+        }
+
+        elapsed_ms = elapsed_ms.saturating_add(delay.as_millis().min(u128::from(u64::MAX)) as u64);
+    }
+
+    if frames_out.is_empty() {
+        return Err("GIF 抽帧结果为空".to_string());
+    }
+
+    Ok(GifSamplingResult {
+        frames: frames_out,
+        duration_ms,
+        source_frames,
+        sampling_interval_ms,
+        output_format: GIF_FRAME_OUTPUT_FORMAT,
+    })
+}
+
+/// 强制将任意图片重编码为指定格式（可选缩放）
+///
+/// 用于需要把输入格式（如 GIF）转换为上游更稳定支持的静态格式（如 JPEG）时。
+pub fn process_image_to_format(
+    base64_data: &str,
+    output_format: &str,
+    config: &CompressionConfig,
+    image_count: usize,
+) -> Result<ImageProcessResult, String> {
+    let bytes = BASE64
+        .decode(base64_data)
+        .map_err(|e| format!("base64 解码失败: {}", e))?;
+    let original_bytes_len = bytes.len();
+
+    let reader = ImageReader::new(Cursor::new(&bytes))
+        .with_guessed_format()
+        .map_err(|e| format!("图片格式识别失败: {}", e))?;
+    let original_size = reader
+        .into_dimensions()
+        .map_err(|e| format!("读取图片尺寸失败: {}", e))?;
+
+    let max_pixels = if image_count >= config.image_multi_threshold {
+        config.image_max_pixels_multi
+    } else {
+        config.image_max_pixels_single
+    };
+
+    let (target_w, target_h) = apply_scaling_rules(
+        original_size.0,
+        original_size.1,
+        config.image_max_long_edge,
+        max_pixels,
+    );
+    let needs_resize = target_w != original_size.0 || target_h != original_size.1;
+
+    let img = image::load_from_memory(&bytes).map_err(|e| format!("图片加载失败: {}", e))?;
+    let processed = if needs_resize {
+        img.resize(target_w, target_h, image::imageops::FilterType::Lanczos3)
+    } else {
+        img
+    };
+
+    let final_size = (processed.width(), processed.height());
+    let (data, final_bytes_len) = encode_image(&processed, output_format)?;
+
+    Ok(ImageProcessResult {
+        data,
+        original_size,
+        final_size,
+        tokens: calculate_tokens(final_size.0, final_size.1),
+        was_resized: needs_resize,
+        was_reencoded: true,
+        original_bytes_len,
+        final_bytes_len,
+    })
+}
+
+/// 从 base64 数据计算图片 token（不缩放）
+///
+/// 返回 (tokens, width, height)，解析失败返回 None
+pub fn estimate_image_tokens(base64_data: &str) -> Option<(u64, u32, u32)> {
+    let bytes = BASE64.decode(base64_data).ok()?;
+    let reader = ImageReader::new(Cursor::new(&bytes))
+        .with_guessed_format()
+        .ok()?;
+    let (width, height) = reader.into_dimensions().ok()?;
+
+    // 应用 Anthropic 缩放规则计算 token
+    let (scaled_w, scaled_h) = apply_scaling_rules(width, height, 1568, 1_150_000);
+    let tokens = calculate_tokens(scaled_w, scaled_h);
+
+    Some((tokens, width, height))
+}
+
+/// 处理图片：根据配置缩放并返回处理结果
+///
+/// # 参数
+/// - `base64_data`: 原始 base64 编码的图片数据
+/// - `format`: 图片格式（"jpeg", "png", "gif", "webp"）
+/// - `config`: 压缩配置
+/// - `image_count`: 当前请求中的图片总数（用于判断是否启用多图模式）
+pub fn process_image(
+    base64_data: &str,
+    format: &str,
+    config: &CompressionConfig,
+    image_count: usize,
+) -> Result<ImageProcessResult, String> {
+    // 解码 base64
+    let bytes = BASE64
+        .decode(base64_data)
+        .map_err(|e| format!("base64 解码失败: {}", e))?;
+    let original_bytes_len = bytes.len();
+
+    // 先只读取图片头获取尺寸（避免不必要的全量解码）
+    let reader = ImageReader::new(Cursor::new(&bytes))
+        .with_guessed_format()
+        .map_err(|e| format!("图片格式识别失败: {}", e))?;
+    let original_size = reader
+        .into_dimensions()
+        .map_err(|e| format!("读取图片尺寸失败: {}", e))?;
+
+    // 根据图片数量选择像素限制
+    let max_pixels = if image_count >= config.image_multi_threshold {
+        config.image_max_pixels_multi
+    } else {
+        config.image_max_pixels_single
+    };
+
+    // 计算目标尺寸
+    let (target_w, target_h) = apply_scaling_rules(
+        original_size.0,
+        original_size.1,
+        config.image_max_long_edge,
+        max_pixels,
+    );
+
+    let needs_resize = target_w != original_size.0 || target_h != original_size.1;
+
+    // 判断是否需要重新编码：
+    // 1. GIF 特殊处理：即使不需要缩放，也强制重新编码为静态帧
+    //    原因：动图通常"像素不大但字节巨大"，直接透传 base64 会显著放大请求体
+    // 2. 文件过大：即使尺寸符合要求，如果文件大小超过阈值也需要重新编码降低质量
+    //    阈值：200KB（经验值，避免小图片被过度压缩，同时拦截高质量大图）
+    const MAX_IMAGE_BYTES: usize = 200_000; // 200KB
+    let force_reencode_gif = format.eq_ignore_ascii_case("gif");
+    let force_reencode_large = original_bytes_len > MAX_IMAGE_BYTES;
+
+    if force_reencode_large {
+        tracing::info!(
+            original_bytes = original_bytes_len,
+            threshold_bytes = MAX_IMAGE_BYTES,
+            width = original_size.0,
+            height = original_size.1,
+            format = format,
+            "图片文件过大，强制重新编码以降低质量"
+        );
+    }
+
+    let should_decode_and_encode = needs_resize || force_reencode_gif || force_reencode_large;
+
+    // 仅在需要缩放或强制重编码时才全量解码图片
+    let (output_data, final_size, final_bytes_len, was_reencoded) = if should_decode_and_encode {
+        let img = image::load_from_memory(&bytes).map_err(|e| format!("图片加载失败: {}", e))?;
+        let processed = if needs_resize {
+            img.resize(target_w, target_h, image::imageops::FilterType::Lanczos3)
+        } else {
+            img
+        };
+        let size = (processed.width(), processed.height());
+        let (data, bytes_len) = encode_image(&processed, format)?;
+        let was_reencoded = (force_reencode_gif || force_reencode_large) && !needs_resize;
+
+        if force_reencode_large && !needs_resize {
+            tracing::info!(
+                original_bytes = original_bytes_len,
+                final_bytes = bytes_len,
+                compression_ratio = format!(
+                    "{:.1}%",
+                    (1.0 - bytes_len as f64 / original_bytes_len as f64) * 100.0
+                ),
+                "大文件重新编码完成"
+            );
+        }
+
+        (data, size, bytes_len, was_reencoded)
+    } else {
+        (
+            base64_data.to_string(),
+            original_size,
+            original_bytes_len,
+            false,
+        )
+    };
+
+    let tokens = calculate_tokens(final_size.0, final_size.1);
+
+    Ok(ImageProcessResult {
+        data: output_data,
+        original_size,
+        final_size,
+        tokens,
+        was_resized: needs_resize,
+        was_reencoded,
+        original_bytes_len,
+        final_bytes_len,
+    })
+}
+
+/// 应用 Anthropic 缩放规则
+///
+/// 1. 长边不超过 max_long_edge
+/// 2. 总像素不超过 max_pixels
+fn apply_scaling_rules(width: u32, height: u32, max_long_edge: u32, max_pixels: u32) -> (u32, u32) {
+    let mut w = width as f64;
+    let mut h = height as f64;
+
+    // 规则 1: 长边限制
+    let long_edge = w.max(h);
+    if long_edge > max_long_edge as f64 {
+        let scale = max_long_edge as f64 / long_edge;
+        w *= scale;
+        h *= scale;
+    }
+
+    // 规则 2: 总像素限制
+    let pixels = w * h;
+    if pixels > max_pixels as f64 {
+        let scale = (max_pixels as f64 / pixels).sqrt();
+        w *= scale;
+        h *= scale;
+    }
+
+    (w.floor().max(1.0) as u32, h.floor().max(1.0) as u32)
+}
+
+/// 计算 token 数
+#[inline]
+fn calculate_tokens(width: u32, height: u32) -> u64 {
+    ((width as u64 * height as u64) + 375) / 750 // 四舍五入
+}
+
+/// 将图片编码为 base64
+fn encode_image(img: &DynamicImage, format: &str) -> Result<(String, usize), String> {
+    let mut buffer = Cursor::new(Vec::new());
+
+    let image_format = match format {
+        "jpeg" | "jpg" => ImageFormat::Jpeg,
+        "png" => ImageFormat::Png,
+        "gif" => ImageFormat::Gif,
+        "webp" => ImageFormat::WebP,
+        _ => return Err(format!("不支持的图片格式: {}", format)),
+    };
+
+    img.write_to(&mut buffer, image_format)
+        .map_err(|e| format!("图片编码失败: {}", e))?;
+
+    let encoded = buffer.into_inner();
+    let bytes_len = encoded.len();
+    Ok((BASE64.encode(encoded), bytes_len))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_scaling_rules() {
+        // 测试长边限制
+        assert_eq!(
+            apply_scaling_rules(2000, 1000, 1568, 10_000_000),
+            (1568, 784)
+        );
+
+        // 测试像素限制
+        assert_eq!(
+            apply_scaling_rules(1200, 1200, 1568, 1_000_000),
+            (1000, 1000)
+        );
+
+        // 测试无需缩放
+        assert_eq!(apply_scaling_rules(800, 600, 1568, 1_150_000), (800, 600));
+    }
+
+    #[test]
+    fn test_calculate_tokens() {
+        assert_eq!(calculate_tokens(1092, 1092), 1590); // 1:1 标准
+        assert_eq!(calculate_tokens(200, 200), 53); // 小图
+    }
+
+    #[test]
+    fn test_gif_is_reencoded_even_without_resize() {
+        use image::codecs::gif::{GifEncoder, Repeat};
+        use image::{Delay, Frame, Rgba, RgbaImage};
+
+        // 构造一个多帧 GIF（像素小但包含多帧），用于验证“强制重编码为静态帧”的行为。
+        let mut frames = Vec::new();
+        for i in 0..10u8 {
+            let mut img = RgbaImage::new(32, 32);
+            for p in img.pixels_mut() {
+                *p = Rgba([i, 255u8.saturating_sub(i), 0, 255]);
+            }
+            frames.push(Frame::from_parts(
+                img,
+                0,
+                0,
+                Delay::from_numer_denom_ms(10, 1),
+            ));
+        }
+
+        let mut buf = Vec::new();
+        {
+            let mut encoder = GifEncoder::new(&mut buf);
+            encoder.set_repeat(Repeat::Infinite).unwrap();
+            encoder.encode_frames(frames).unwrap();
+        }
+
+        let base64_data = BASE64.encode(&buf);
+        let config = CompressionConfig::default();
+        let result = process_image(&base64_data, "gif", &config, 1).unwrap();
+
+        assert!(!result.was_resized);
+        assert!(result.was_reencoded);
+        assert_eq!(result.original_size, result.final_size);
+        assert!(result.final_bytes_len < result.original_bytes_len);
+    }
+
+    #[test]
+    fn test_process_gif_frames_sampling_8s_caps_to_2fps() {
+        use image::codecs::gif::{GifEncoder, Repeat};
+        use image::{Delay, Frame, Rgba, RgbaImage};
+
+        // 8 秒 GIF：按 max 20 帧限制，每秒最多 2 帧（20/8=2）
+        let frame_delay = Delay::from_numer_denom_ms(100, 1); // 0.1s
+        let mut frames = Vec::new();
+        for i in 0..80u8 {
+            let mut img = RgbaImage::new(64, 64);
+            for p in img.pixels_mut() {
+                *p = Rgba([i, 0, 0, 255]);
+            }
+            frames.push(Frame::from_parts(img, 0, 0, frame_delay));
+        }
+
+        let mut buf = Vec::new();
+        {
+            let mut encoder = GifEncoder::new(&mut buf);
+            encoder.set_repeat(Repeat::Infinite).unwrap();
+            encoder.encode_frames(frames).unwrap();
+        }
+
+        let base64_data = BASE64.encode(&buf);
+        let config = CompressionConfig::default();
+        let res = process_gif_frames(&base64_data, &config, 1).unwrap();
+
+        assert_eq!(res.duration_ms, 8000);
+        assert_eq!(res.sampling_interval_ms, 500);
+        assert_eq!(res.frames.len(), 16);
+        assert!(res.frames.len() <= GIF_MAX_OUTPUT_FRAMES);
+        assert_eq!(res.output_format, GIF_FRAME_OUTPUT_FORMAT);
+    }
+
+    #[test]
+    fn test_process_gif_frames_sampling_4s_hits_5fps_and_20_frames() {
+        use image::codecs::gif::{GifEncoder, Repeat};
+        use image::{Delay, Frame, Rgba, RgbaImage};
+
+        // 4 秒 GIF：每秒最多 5 帧（20/4=5），应能采满 20 帧
+        let frame_delay = Delay::from_numer_denom_ms(100, 1); // 0.1s
+        let mut frames = Vec::new();
+        for i in 0..40u8 {
+            let mut img = RgbaImage::new(64, 64);
+            for p in img.pixels_mut() {
+                *p = Rgba([0, i, 0, 255]);
+            }
+            frames.push(Frame::from_parts(img, 0, 0, frame_delay));
+        }
+
+        let mut buf = Vec::new();
+        {
+            let mut encoder = GifEncoder::new(&mut buf);
+            encoder.set_repeat(Repeat::Infinite).unwrap();
+            encoder.encode_frames(frames).unwrap();
+        }
+
+        let base64_data = BASE64.encode(&buf);
+        let config = CompressionConfig::default();
+        let res = process_gif_frames(&base64_data, &config, 1).unwrap();
+
+        assert_eq!(res.duration_ms, 4000);
+        assert_eq!(res.sampling_interval_ms, 200);
+        assert_eq!(res.frames.len(), 20);
+        assert!(res.frames.len() <= GIF_MAX_OUTPUT_FRAMES);
+        assert_eq!(res.output_format, GIF_FRAME_OUTPUT_FORMAT);
+    }
+}
diff --git a/src/kiro/affinity.rs b/src/kiro/affinity.rs
new file mode 100644
index 0000000..af76e04
--- /dev/null
+++ b/src/kiro/affinity.rs
@@ -0,0 +1,86 @@
+//! 用户亲和性管理模块
+//!
+//! 记录 user_id 与 credential_id 的绑定关系，
+//! 使连续对话尽量使用同一凭据
+
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+/// 亲和性条目
+struct AffinityEntry {
+    credential_id: u64,
+    last_used: Instant,
+}
+
+/// 用户亲和性管理器
+pub struct UserAffinityManager {
+    affinity: Mutex<HashMap<String, AffinityEntry>>,
+    ttl: Duration,
+}
+
+impl Default for UserAffinityManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl UserAffinityManager {
+    /// 创建新的亲和性管理器（默认 TTL 30 分钟）
+    pub fn new() -> Self {
+        Self {
+            affinity: Mutex::new(HashMap::new()),
+            ttl: Duration::from_secs(30 * 60),
+        }
+    }
+
+    /// 获取用户绑定的凭据 ID（惰性清理过期条目）
+    pub fn get(&self, user_id: &str) -> Option<u64> {
+        let mut map = self.affinity.lock();
+        if let Some(entry) = map.get(user_id) {
+            if entry.last_used.elapsed() < self.ttl {
+                tracing::debug!(user_id = %user_id, credential_id = %entry.credential_id, "亲和性命中");
+                return Some(entry.credential_id);
+            }
+            // 过期则删除
+            tracing::debug!(user_id = %user_id, credential_id = %entry.credential_id, "亲和性过期，已清除");
+            map.remove(user_id);
+        }
+        None
+    }
+
+    /// 设置用户与凭据的绑定
+    pub fn set(&self, user_id: &str, credential_id: u64) {
+        tracing::debug!(user_id = %user_id, credential_id = %credential_id, "建立亲和性绑定");
+        let mut map = self.affinity.lock();
+        map.insert(
+            user_id.to_string(),
+            AffinityEntry {
+                credential_id,
+                last_used: Instant::now(),
+            },
+        );
+    }
+
+    /// 更新最后使用时间（续期）
+    pub fn touch(&self, user_id: &str) {
+        let mut map = self.affinity.lock();
+        if let Some(entry) = map.get_mut(user_id) {
+            entry.last_used = Instant::now();
+        }
+    }
+
+    /// 移除指定凭据的所有绑定（凭据被禁用时调用）
+    pub fn remove_by_credential(&self, credential_id: u64) {
+        let mut map = self.affinity.lock();
+        map.retain(|_, entry| entry.credential_id != credential_id);
+    }
+
+    /// 清理过期条目
+    #[allow(dead_code)]
+    pub fn cleanup(&self) {
+        let mut map = self.affinity.lock();
+        let ttl = self.ttl;
+        map.retain(|_, entry| entry.last_used.elapsed() < ttl);
+    }
+}
diff --git a/src/kiro/background_refresh.rs b/src/kiro/background_refresh.rs
new file mode 100644
index 0000000..15038e2
--- /dev/null
+++ b/src/kiro/background_refresh.rs
@@ -0,0 +1,346 @@
+//! 后台 Token 刷新模块
+#![allow(dead_code)]
+//!
+//! 独立后台任务定期检查并刷新即将过期的 Token，
+//! 避免请求时的刷新延迟。
+//! 参考 CLIProxyAPIPlus 的实现。
+
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+use tokio::sync::Notify;
+use tokio::time::interval;
+
+/// 默认检查间隔（秒）
+const DEFAULT_CHECK_INTERVAL_SECS: u64 = 60;
+
+/// 默认批处理大小
+const DEFAULT_BATCH_SIZE: usize = 50;
+
+/// 默认并发数
+const DEFAULT_CONCURRENCY: usize = 10;
+
+/// 默认提前刷新时间（分钟）
+/// Token 在过期前多少分钟开始刷新
+const DEFAULT_REFRESH_BEFORE_EXPIRY_MINS: i64 = 15;
+
+/// 后台刷新配置
+#[derive(Debug, Clone)]
+pub struct BackgroundRefreshConfig {
+    /// 检查间隔（秒），必须 > 0
+    pub check_interval_secs: u64,
+
+    /// 批处理大小，必须 > 0
+    pub batch_size: usize,
+
+    /// 并发数，必须 > 0
+    pub concurrency: usize,
+
+    /// 提前刷新时间（分钟）
+    pub refresh_before_expiry_mins: i64,
+}
+
+impl BackgroundRefreshConfig {
+    /// 校验配置有效性
+    ///
+    /// # Returns
+    /// - `Ok(())` - 配置有效
+    /// - `Err(String)` - 配置无效，返回错误描述
+    pub fn validate(&self) -> Result<(), String> {
+        if self.check_interval_secs == 0 {
+            return Err("check_interval_secs 必须大于 0".to_string());
+        }
+        if self.batch_size == 0 {
+            return Err("batch_size 必须大于 0".to_string());
+        }
+        if self.concurrency == 0 {
+            return Err("concurrency 必须大于 0".to_string());
+        }
+        Ok(())
+    }
+}
+
+impl Default for BackgroundRefreshConfig {
+    fn default() -> Self {
+        Self {
+            check_interval_secs: DEFAULT_CHECK_INTERVAL_SECS,
+            batch_size: DEFAULT_BATCH_SIZE,
+            concurrency: DEFAULT_CONCURRENCY,
+            refresh_before_expiry_mins: DEFAULT_REFRESH_BEFORE_EXPIRY_MINS,
+        }
+    }
+}
+
+/// 后台刷新器
+///
+/// 管理后台 Token 刷新任务
+pub struct BackgroundRefresher {
+    config: BackgroundRefreshConfig,
+    running: Arc<AtomicBool>,
+    shutdown_notify: Arc<Notify>,
+}
+
+impl BackgroundRefresher {
+    /// 创建新的后台刷新器
+    pub fn new(config: BackgroundRefreshConfig) -> Self {
+        Self {
+            config,
+            running: Arc::new(AtomicBool::new(false)),
+            shutdown_notify: Arc::new(Notify::new()),
+        }
+    }
+
+    /// 使用默认配置创建后台刷新器
+    pub fn with_defaults() -> Self {
+        Self::new(BackgroundRefreshConfig::default())
+    }
+
+    /// 启动后台刷新任务
+    ///
+    /// # Arguments
+    /// * `refresh_fn` - 刷新函数，接收凭据 ID，返回是否成功
+    /// * `get_expiring_ids_fn` - 获取即将过期的凭据 ID 列表
+    ///
+    /// # Returns
+    /// - `Ok(())` - 启动成功
+    /// - `Err(String)` - 配置无效或已在运行
+    pub fn start<F, G>(&self, refresh_fn: F, get_expiring_ids_fn: G) -> Result<(), String>
+    where
+        F: Fn(u64) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>
+            + Send
+            + Sync
+            + 'static,
+        G: Fn(i64) -> Vec<u64> + Send + Sync + 'static,
+    {
+        // P1 修复：启动前校验配置，避免 panic/hang
+        if let Err(e) = self.config.validate() {
+            tracing::error!("后台刷新器配置无效: {}", e);
+            return Err(e);
+        }
+
+        if self.running.swap(true, Ordering::SeqCst) {
+            tracing::warn!("后台刷新器已在运行");
+            return Err("后台刷新器已在运行".to_string());
+        }
+
+        let config = self.config.clone();
+        let running = Arc::clone(&self.running);
+        let shutdown_notify = Arc::clone(&self.shutdown_notify);
+        let refresh_fn = Arc::new(refresh_fn);
+
+        tokio::spawn(async move {
+            tracing::info!(
+                interval_secs = %config.check_interval_secs,
+                batch_size = %config.batch_size,
+                concurrency = %config.concurrency,
+                "后台 Token 刷新器已启动"
+            );
+
+            let mut check_interval = interval(Duration::from_secs(config.check_interval_secs));
+
+            loop {
+                tokio::select! {
+                    _ = check_interval.tick() => {
+                        if !running.load(Ordering::SeqCst) {
+                            break;
+                        }
+
+                        // 获取即将过期的凭据
+                        let expiring_ids = get_expiring_ids_fn(config.refresh_before_expiry_mins);
+
+                        if expiring_ids.is_empty() {
+                            tracing::debug!("没有需要刷新的 Token");
+                            continue;
+                        }
+
+                        tracing::info!("发现 {} 个即将过期的 Token，开始刷新", expiring_ids.len());
+
+                        // 批量刷新
+                        let mut success_count = 0;
+                        let mut fail_count = 0;
+
+                        for chunk in expiring_ids.chunks(config.batch_size) {
+                            let semaphore = Arc::new(tokio::sync::Semaphore::new(config.concurrency));
+                            let mut handles = Vec::new();
+
+                            for &id in chunk {
+                                let permit = semaphore.clone().acquire_owned().await;
+                                let refresh_fn = Arc::clone(&refresh_fn);
+
+                                let handle = tokio::spawn(async move {
+                                    let _permit = permit;
+                                    refresh_fn(id).await
+                                });
+                                handles.push(handle);
+                            }
+
+                            for handle in handles {
+                                match handle.await {
+                                    Ok(true) => success_count += 1,
+                                    Ok(false) => fail_count += 1,
+                                    Err(e) => {
+                                        tracing::warn!("刷新任务 panic: {}", e);
+                                        fail_count += 1;
+                                    }
+                                }
+                            }
+                        }
+
+                        tracing::info!(
+                            success = %success_count,
+                            failed = %fail_count,
+                            "后台 Token 刷新完成"
+                        );
+                    }
+                    _ = shutdown_notify.notified() => {
+                        tracing::info!("后台 Token 刷新器收到关闭信号");
+                        break;
+                    }
+                }
+            }
+
+            running.store(false, Ordering::SeqCst);
+            tracing::info!("后台 Token 刷新器已停止");
+        });
+
+        Ok(())
+    }
+
+    /// 停止后台刷新任务
+    pub fn stop(&self) {
+        if self.running.load(Ordering::SeqCst) {
+            self.running.store(false, Ordering::SeqCst);
+            self.shutdown_notify.notify_one();
+            tracing::info!("已发送后台刷新器停止信号");
+        }
+    }
+
+    /// 检查是否正在运行
+    pub fn is_running(&self) -> bool {
+        self.running.load(Ordering::SeqCst)
+    }
+
+    /// 获取配置
+    pub fn config(&self) -> &BackgroundRefreshConfig {
+        &self.config
+    }
+}
+
+impl Drop for BackgroundRefresher {
+    fn drop(&mut self) {
+        self.stop();
+    }
+}
+
+/// 刷新结果
+#[derive(Debug, Clone)]
+pub struct RefreshResult {
+    /// 凭据 ID
+    pub credential_id: u64,
+
+    /// 是否成功
+    pub success: bool,
+
+    /// 是否使用了降级方案
+    pub used_fallback: bool,
+
+    /// 错误信息（如果失败）
+    pub error: Option<String>,
+
+    /// 新的过期时间（如果成功）
+    pub new_expires_at: Option<String>,
+}
+
+impl RefreshResult {
+    /// 创建成功结果
+    pub fn success(credential_id: u64, new_expires_at: String) -> Self {
+        Self {
+            credential_id,
+            success: true,
+            used_fallback: false,
+            error: None,
+            new_expires_at: Some(new_expires_at),
+        }
+    }
+
+    /// 创建失败结果
+    pub fn failure(credential_id: u64, error: String) -> Self {
+        Self {
+            credential_id,
+            success: false,
+            used_fallback: false,
+            error: Some(error),
+            new_expires_at: None,
+        }
+    }
+
+    /// 创建降级结果（刷新失败但使用现有 Token）
+    pub fn fallback(credential_id: u64, existing_expires_at: String) -> Self {
+        Self {
+            credential_id,
+            success: true,
+            used_fallback: true,
+            error: None,
+            new_expires_at: Some(existing_expires_at),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_background_refresh_config_default() {
+        let config = BackgroundRefreshConfig::default();
+        assert_eq!(config.check_interval_secs, 60);
+        assert_eq!(config.batch_size, 50);
+        assert_eq!(config.concurrency, 10);
+        assert_eq!(config.refresh_before_expiry_mins, 15);
+    }
+
+    #[test]
+    fn test_background_refresher_new() {
+        let refresher = BackgroundRefresher::with_defaults();
+        assert!(!refresher.is_running());
+    }
+
+    #[test]
+    fn test_refresh_result_success() {
+        let result = RefreshResult::success(1, "2025-01-01T00:00:00Z".to_string());
+        assert!(result.success);
+        assert!(!result.used_fallback);
+        assert!(result.error.is_none());
+    }
+
+    #[test]
+    fn test_refresh_result_failure() {
+        let result = RefreshResult::failure(1, "Token expired".to_string());
+        assert!(!result.success);
+        assert!(result.error.is_some());
+    }
+
+    #[test]
+    fn test_refresh_result_fallback() {
+        let result = RefreshResult::fallback(1, "2025-01-01T00:00:00Z".to_string());
+        assert!(result.success);
+        assert!(result.used_fallback);
+    }
+
+    #[tokio::test]
+    async fn test_background_refresher_stop() {
+        let refresher = BackgroundRefresher::with_defaults();
+
+        // 启动一个空的刷新任务
+        let _ = refresher.start(|_id| Box::pin(async { true }), |_mins| vec![]);
+
+        // 等待启动
+        tokio::time::sleep(Duration::from_millis(100)).await;
+        assert!(refresher.is_running());
+
+        // 停止
+        refresher.stop();
+        tokio::time::sleep(Duration::from_millis(100)).await;
+        assert!(!refresher.is_running());
+    }
+}
diff --git a/src/kiro/cooldown.rs b/src/kiro/cooldown.rs
new file mode 100644
index 0000000..b022d9a
--- /dev/null
+++ b/src/kiro/cooldown.rs
@@ -0,0 +1,373 @@
+//! 冷却管理模块
+#![allow(dead_code)]
+//!
+//! 分类管理不同原因的冷却状态，支持差异化冷却时长和自动清理。
+//! 参考 CLIProxyAPIPlus 的实现。
+
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+/// 冷却原因
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum CooldownReason {
+    /// 429 速率限制
+    RateLimitExceeded,
+
+    /// 账户暂停
+    AccountSuspended,
+
+    /// 配额耗尽
+    QuotaExhausted,
+
+    /// Token 刷新失败
+    TokenRefreshFailed,
+
+    /// 认证失败
+    AuthenticationFailed,
+
+    /// 服务器错误
+    ServerError,
+
+    /// 模型暂时不可用
+    ModelUnavailable,
+}
+
+impl CooldownReason {
+    /// 获取默认冷却时长
+    pub fn default_duration(&self) -> Duration {
+        match self {
+            // 短冷却（1-5 分钟）
+            CooldownReason::RateLimitExceeded => Duration::from_secs(60),
+            CooldownReason::TokenRefreshFailed => Duration::from_secs(60),
+            CooldownReason::ServerError => Duration::from_secs(120),
+            CooldownReason::ModelUnavailable => Duration::from_secs(300),
+
+            // 长冷却（1-24 小时）
+            CooldownReason::AuthenticationFailed => Duration::from_secs(3600),
+            CooldownReason::AccountSuspended => Duration::from_secs(86400),
+            CooldownReason::QuotaExhausted => Duration::from_secs(86400),
+        }
+    }
+
+    /// 是否可以自动恢复
+    pub fn is_auto_recoverable(&self) -> bool {
+        match self {
+            CooldownReason::RateLimitExceeded => true,
+            CooldownReason::TokenRefreshFailed => true,
+            CooldownReason::ServerError => true,
+            CooldownReason::ModelUnavailable => true,
+            CooldownReason::AuthenticationFailed => false,
+            CooldownReason::AccountSuspended => false,
+            CooldownReason::QuotaExhausted => false,
+        }
+    }
+
+    /// 获取原因描述
+    pub fn description(&self) -> &'static str {
+        match self {
+            CooldownReason::RateLimitExceeded => "速率限制",
+            CooldownReason::AccountSuspended => "账户暂停",
+            CooldownReason::QuotaExhausted => "配额耗尽",
+            CooldownReason::TokenRefreshFailed => "Token 刷新失败",
+            CooldownReason::AuthenticationFailed => "认证失败",
+            CooldownReason::ServerError => "服务器错误",
+            CooldownReason::ModelUnavailable => "模型暂时不可用",
+        }
+    }
+}
+
+/// 冷却条目
+#[derive(Debug, Clone)]
+struct CooldownEntry {
+    /// 冷却原因
+    reason: CooldownReason,
+
+    /// 冷却开始时间
+    started_at: Instant,
+
+    /// 冷却结束时间
+    expires_at: Instant,
+
+    /// 连续触发次数（用于递增冷却时长）
+    trigger_count: u32,
+}
+
+/// 冷却管理器
+///
+/// 管理所有凭据的冷却状态
+pub struct CooldownManager {
+    /// 凭据冷却状态
+    entries: Mutex<HashMap<u64, CooldownEntry>>,
+
+    /// 最大短冷却时长（秒）
+    max_short_cooldown_secs: u64,
+
+    /// 长冷却时长（秒）
+    long_cooldown_secs: u64,
+}
+
+impl Default for CooldownManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CooldownManager {
+    /// 创建新的冷却管理器
+    pub fn new() -> Self {
+        Self {
+            entries: Mutex::new(HashMap::new()),
+            max_short_cooldown_secs: 300, // 5 分钟
+            long_cooldown_secs: 86400,    // 24 小时
+        }
+    }
+
+    /// 使用自定义配置创建冷却管理器
+    #[allow(dead_code)]
+    pub fn with_config(max_short_cooldown_secs: u64, long_cooldown_secs: u64) -> Self {
+        Self {
+            entries: Mutex::new(HashMap::new()),
+            max_short_cooldown_secs,
+            long_cooldown_secs,
+        }
+    }
+
+    /// 设置凭据冷却
+    ///
+    /// 返回实际的冷却时长
+    pub fn set_cooldown(&self, credential_id: u64, reason: CooldownReason) -> Duration {
+        self.set_cooldown_with_duration(credential_id, reason, None)
+    }
+
+    /// 设置凭据冷却（自定义时长）
+    pub fn set_cooldown_with_duration(
+        &self,
+        credential_id: u64,
+        reason: CooldownReason,
+        custom_duration: Option<Duration>,
+    ) -> Duration {
+        let mut entries = self.entries.lock();
+        let now = Instant::now();
+
+        // 获取或创建条目
+        let entry = entries
+            .entry(credential_id)
+            .or_insert_with(|| CooldownEntry {
+                reason,
+                started_at: now,
+                expires_at: now,
+                trigger_count: 0,
+            });
+
+        // 更新触发次数
+        if entry.reason == reason {
+            entry.trigger_count += 1;
+        } else {
+            entry.reason = reason;
+            entry.trigger_count = 1;
+        }
+
+        // 计算冷却时长
+        let duration = custom_duration
+            .unwrap_or_else(|| self.calculate_cooldown_duration(reason, entry.trigger_count));
+
+        entry.started_at = now;
+        entry.expires_at = now + duration;
+
+        tracing::info!(
+            credential_id = %credential_id,
+            reason = %reason.description(),
+            duration_secs = %duration.as_secs(),
+            trigger_count = %entry.trigger_count,
+            "凭据进入冷却"
+        );
+
+        duration
+    }
+
+    /// 检查凭据是否在冷却中
+    ///
+    /// 返回 `None` 表示不在冷却中，`Some((reason, remaining))` 表示冷却原因和剩余时间
+    pub fn check_cooldown(&self, credential_id: u64) -> Option<(CooldownReason, Duration)> {
+        let entries = self.entries.lock();
+        let now = Instant::now();
+
+        entries.get(&credential_id).and_then(|entry| {
+            if now < entry.expires_at {
+                Some((
+                    entry.reason,
+                    entry.expires_at.saturating_duration_since(now),
+                ))
+            } else {
+                None
+            }
+        })
+    }
+
+    /// 检查凭据是否可用（不在冷却中或冷却已过期）
+    pub fn is_available(&self, credential_id: u64) -> bool {
+        self.check_cooldown(credential_id).is_none()
+    }
+
+    /// 清除凭据冷却
+    pub fn clear_cooldown(&self, credential_id: u64) -> bool {
+        let mut entries = self.entries.lock();
+        entries.remove(&credential_id).is_some()
+    }
+
+    /// 清除所有已过期的冷却
+    pub fn cleanup_expired(&self) -> usize {
+        let mut entries = self.entries.lock();
+        let now = Instant::now();
+        let before_count = entries.len();
+
+        entries.retain(|_, entry| now < entry.expires_at);
+
+        let removed = before_count - entries.len();
+        if removed > 0 {
+            tracing::debug!("清理了 {} 个过期冷却条目", removed);
+        }
+        removed
+    }
+
+    /// 获取所有冷却中的凭据
+    pub fn get_all_cooldowns(&self) -> Vec<CooldownInfo> {
+        let entries = self.entries.lock();
+        let now = Instant::now();
+
+        entries
+            .iter()
+            .filter(|(_, entry)| now < entry.expires_at)
+            .map(|(&id, entry)| CooldownInfo {
+                credential_id: id,
+                reason: entry.reason,
+                started_at_ms: entry.started_at.elapsed().as_millis() as u64,
+                remaining_ms: entry.expires_at.saturating_duration_since(now).as_millis() as u64,
+                trigger_count: entry.trigger_count,
+            })
+            .collect()
+    }
+
+    /// 计算冷却时长
+    fn calculate_cooldown_duration(&self, reason: CooldownReason, trigger_count: u32) -> Duration {
+        let base = reason.default_duration();
+
+        if reason.is_auto_recoverable() {
+            // 可自动恢复的原因：递增冷却时长，但不超过最大值
+            let multiplier = 1.5_f64.powi((trigger_count.saturating_sub(1)) as i32);
+            let duration_secs = (base.as_secs() as f64 * multiplier) as u64;
+            let capped_secs = duration_secs.min(self.max_short_cooldown_secs);
+            Duration::from_secs(capped_secs)
+        } else {
+            // 不可自动恢复的原因：使用长冷却时长
+            Duration::from_secs(self.long_cooldown_secs)
+        }
+    }
+}
+
+/// 冷却信息（公开 API）
+#[derive(Debug, Clone)]
+pub struct CooldownInfo {
+    /// 凭据 ID
+    pub credential_id: u64,
+
+    /// 冷却原因
+    pub reason: CooldownReason,
+
+    /// 冷却开始时间（毫秒前）
+    pub started_at_ms: u64,
+
+    /// 剩余冷却时间（毫秒）
+    pub remaining_ms: u64,
+
+    /// 连续触发次数
+    pub trigger_count: u32,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cooldown_manager_new() {
+        let manager = CooldownManager::new();
+        assert!(manager.is_available(1));
+    }
+
+    #[test]
+    fn test_cooldown_set_and_check() {
+        let manager = CooldownManager::new();
+
+        let duration = manager.set_cooldown(1, CooldownReason::RateLimitExceeded);
+        assert!(duration.as_secs() >= 60);
+
+        let (reason, remaining) = manager.check_cooldown(1).unwrap();
+        assert_eq!(reason, CooldownReason::RateLimitExceeded);
+        assert!(remaining.as_secs() > 0);
+
+        assert!(!manager.is_available(1));
+    }
+
+    #[test]
+    fn test_cooldown_clear() {
+        let manager = CooldownManager::new();
+
+        manager.set_cooldown(1, CooldownReason::ServerError);
+        assert!(!manager.is_available(1));
+
+        assert!(manager.clear_cooldown(1));
+        assert!(manager.is_available(1));
+    }
+
+    #[test]
+    fn test_cooldown_incremental() {
+        let manager = CooldownManager::new();
+
+        // 第一次冷却
+        let d1 = manager.set_cooldown(1, CooldownReason::RateLimitExceeded);
+
+        // 清除后再次触发，应该有更长的冷却
+        manager.clear_cooldown(1);
+        let d2 = manager.set_cooldown(1, CooldownReason::RateLimitExceeded);
+
+        // 由于触发次数增加，第二次冷却应该更长
+        assert!(d2 >= d1);
+    }
+
+    #[test]
+    fn test_cooldown_reason_auto_recoverable() {
+        assert!(CooldownReason::RateLimitExceeded.is_auto_recoverable());
+        assert!(CooldownReason::ServerError.is_auto_recoverable());
+        assert!(!CooldownReason::AccountSuspended.is_auto_recoverable());
+        assert!(!CooldownReason::QuotaExhausted.is_auto_recoverable());
+    }
+
+    #[test]
+    fn test_cooldown_custom_duration() {
+        let manager = CooldownManager::new();
+
+        let custom = Duration::from_secs(10);
+        let duration =
+            manager.set_cooldown_with_duration(1, CooldownReason::ServerError, Some(custom));
+
+        assert_eq!(duration, custom);
+    }
+
+    #[test]
+    fn test_cooldown_get_all() {
+        let manager = CooldownManager::new();
+
+        manager.set_cooldown(1, CooldownReason::RateLimitExceeded);
+        manager.set_cooldown(2, CooldownReason::ServerError);
+
+        let cooldowns = manager.get_all_cooldowns();
+        assert_eq!(cooldowns.len(), 2);
+    }
+
+    #[test]
+    fn test_cooldown_reason_description() {
+        assert_eq!(CooldownReason::RateLimitExceeded.description(), "速率限制");
+        assert_eq!(CooldownReason::AccountSuspended.description(), "账户暂停");
+    }
+}
diff --git a/src/kiro/fingerprint.rs b/src/kiro/fingerprint.rs
new file mode 100644
index 0000000..cc406c2
--- /dev/null
+++ b/src/kiro/fingerprint.rs
@@ -0,0 +1,301 @@
+//! 多维度设备指纹系统
+#![allow(dead_code)]
+//!
+//! 模拟真实 Kiro IDE 客户端的完整环境特征，降低被检测风险。
+//! 参考 CLIProxyAPIPlus 的实现。
+
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+/// SDK 版本范围
+const SDK_VERSIONS: &[&str] = &["1.0.20", "1.0.22", "1.0.24", "1.0.25", "1.0.27"];
+
+/// Kiro IDE 版本范围
+const KIRO_VERSIONS: &[&str] = &["0.3.0", "0.4.0", "0.5.0", "0.6.0", "0.7.0", "0.8.0"];
+
+/// Node.js 版本范围
+const NODE_VERSIONS: &[&str] = &["18.20.4", "20.18.0", "22.11.0", "22.21.1"];
+
+/// 操作系统类型
+const OS_TYPES: &[&str] = &["darwin", "win32", "linux"];
+
+/// 操作系统版本（按类型分组）
+const DARWIN_VERSIONS: &[&str] = &["24.0.0", "24.1.0", "24.2.0", "24.4.0", "24.6.0"];
+const WIN32_VERSIONS: &[&str] = &["10.0.19045", "10.0.22621", "10.0.22631"];
+const LINUX_VERSIONS: &[&str] = &["6.5.0", "6.8.0", "6.11.0"];
+
+/// 语言偏好
+const ACCEPT_LANGUAGES: &[&str] = &[
+    "en-US,en;q=0.9",
+    "en-GB,en;q=0.9",
+    "zh-CN,zh;q=0.9,en;q=0.8",
+    "ja-JP,ja;q=0.9,en;q=0.8",
+    "de-DE,de;q=0.9,en;q=0.8",
+    "fr-FR,fr;q=0.9,en;q=0.8",
+];
+
+/// 屏幕分辨率
+const SCREEN_RESOLUTIONS: &[&str] = &[
+    "1920x1080",
+    "2560x1440",
+    "3840x2160",
+    "1440x900",
+    "2560x1600",
+    "3024x1964",
+];
+
+/// 颜色深度
+const COLOR_DEPTHS: &[u8] = &[24, 30, 32];
+
+/// CPU 核心数范围
+const HARDWARE_CONCURRENCY_RANGE: (u8, u8) = (4, 32);
+
+/// 时区偏移范围（分钟）
+const TIMEZONE_OFFSET_RANGE: (i16, i16) = (-720, 720);
+
+/// 设备指纹
+///
+/// 包含模拟真实 Kiro IDE 客户端的完整环境特征
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Fingerprint {
+    /// AWS SDK 版本
+    pub sdk_version: String,
+
+    /// 操作系统类型
+    pub os_type: String,
+
+    /// 操作系统版本
+    pub os_version: String,
+
+    /// Node.js 版本
+    pub node_version: String,
+
+    /// Kiro IDE 版本
+    pub kiro_version: String,
+
+    /// Kiro IDE 哈希（模拟）
+    pub kiro_hash: String,
+
+    /// 语言偏好
+    pub accept_language: String,
+
+    /// 屏幕分辨率
+    pub screen_resolution: String,
+
+    /// 颜色深度
+    pub color_depth: u8,
+
+    /// CPU 核心数
+    pub hardware_concurrency: u8,
+
+    /// 时区偏移（分钟）
+    pub timezone_offset: i16,
+
+    /// Machine ID（64 字符十六进制）
+    pub machine_id: String,
+}
+
+impl Fingerprint {
+    /// 基于种子生成确定性指纹
+    ///
+    /// 使用种子确保同一凭据始终生成相同的指纹，
+    /// 避免每次请求都生成不同的指纹导致被检测。
+    ///
+    /// # Arguments
+    /// * `seed` - 种子字符串（通常使用 refresh_token 或 machine_id）
+    pub fn generate_from_seed(seed: &str) -> Self {
+        // 使用种子生成确定性随机数
+        let hash = sha256_bytes(seed);
+
+        // 从哈希中提取各个字段的索引
+        let sdk_idx = hash[0] as usize % SDK_VERSIONS.len();
+        let kiro_idx = hash[1] as usize % KIRO_VERSIONS.len();
+        let node_idx = hash[2] as usize % NODE_VERSIONS.len();
+        let os_idx = hash[3] as usize % OS_TYPES.len();
+        let lang_idx = hash[4] as usize % ACCEPT_LANGUAGES.len();
+        let screen_idx = hash[5] as usize % SCREEN_RESOLUTIONS.len();
+        let color_idx = hash[6] as usize % COLOR_DEPTHS.len();
+
+        let os_type = OS_TYPES[os_idx];
+        let os_version = match os_type {
+            "darwin" => DARWIN_VERSIONS[hash[7] as usize % DARWIN_VERSIONS.len()],
+            "win32" => WIN32_VERSIONS[hash[7] as usize % WIN32_VERSIONS.len()],
+            "linux" => LINUX_VERSIONS[hash[7] as usize % LINUX_VERSIONS.len()],
+            _ => DARWIN_VERSIONS[0],
+        };
+
+        // 生成 hardware_concurrency（4-32）
+        let (min_cores, max_cores) = HARDWARE_CONCURRENCY_RANGE;
+        let cores_range = max_cores - min_cores + 1;
+        let hardware_concurrency = min_cores + (hash[8] % cores_range);
+
+        // 生成 timezone_offset（-720 到 720 分钟）
+        let (min_tz, max_tz) = TIMEZONE_OFFSET_RANGE;
+        let tz_range = (max_tz - min_tz + 1) as u16;
+        let tz_offset = hash[9] as u16 * 256 + hash[10] as u16;
+        let timezone_offset = min_tz + (tz_offset % tz_range) as i16;
+
+        // 生成 kiro_hash（模拟 SHA256）
+        let kiro_hash = sha256_hex(&format!("kiro-{}-{}", KIRO_VERSIONS[kiro_idx], seed));
+
+        // 生成 machine_id
+        let machine_id = sha256_hex(&format!("machine-{}", seed));
+
+        Self {
+            sdk_version: SDK_VERSIONS[sdk_idx].to_string(),
+            os_type: os_type.to_string(),
+            os_version: os_version.to_string(),
+            node_version: NODE_VERSIONS[node_idx].to_string(),
+            kiro_version: KIRO_VERSIONS[kiro_idx].to_string(),
+            kiro_hash,
+            accept_language: ACCEPT_LANGUAGES[lang_idx].to_string(),
+            screen_resolution: SCREEN_RESOLUTIONS[screen_idx].to_string(),
+            color_depth: COLOR_DEPTHS[color_idx],
+            hardware_concurrency,
+            timezone_offset,
+            machine_id,
+        }
+    }
+
+    /// 生成随机指纹
+    ///
+    /// 用于测试或不需要确定性的场景
+    #[allow(dead_code)]
+    pub fn generate_random() -> Self {
+        let seed = format!("random-{}", fastrand::u64(..));
+        Self::generate_from_seed(&seed)
+    }
+
+    /// 构建 User-Agent 字符串
+    pub fn user_agent(&self) -> String {
+        format!(
+            "aws-sdk-js/{} ua/2.1 os/{}#{} lang/js md/nodejs#{} api/codewhispererstreaming#{} m/E KiroIDE-{}-{}",
+            self.sdk_version,
+            self.os_type,
+            self.os_version,
+            self.node_version,
+            self.sdk_version,
+            self.kiro_version,
+            self.machine_id
+        )
+    }
+
+    /// 构建 x-amz-user-agent 字符串
+    pub fn x_amz_user_agent(&self) -> String {
+        format!(
+            "aws-sdk-js/{} KiroIDE-{}-{}",
+            self.sdk_version, self.kiro_version, self.machine_id
+        )
+    }
+
+    /// 获取格式化的操作系统字符串（用于 User-Agent）
+    pub fn os_string(&self) -> String {
+        format!("{}#{}", self.os_type, self.os_version)
+    }
+}
+
+/// SHA256 哈希（返回字节数组）
+fn sha256_bytes(input: &str) -> [u8; 32] {
+    let mut hasher = Sha256::new();
+    hasher.update(input.as_bytes());
+    hasher.finalize().into()
+}
+
+/// SHA256 哈希（返回十六进制字符串）
+fn sha256_hex(input: &str) -> String {
+    hex::encode(sha256_bytes(input))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fingerprint_deterministic() {
+        // 相同种子应生成相同指纹
+        let fp1 = Fingerprint::generate_from_seed("test_seed");
+        let fp2 = Fingerprint::generate_from_seed("test_seed");
+
+        assert_eq!(fp1.sdk_version, fp2.sdk_version);
+        assert_eq!(fp1.os_type, fp2.os_type);
+        assert_eq!(fp1.kiro_version, fp2.kiro_version);
+        assert_eq!(fp1.machine_id, fp2.machine_id);
+    }
+
+    #[test]
+    fn test_fingerprint_different_seeds() {
+        // 不同种子应生成不同指纹
+        let fp1 = Fingerprint::generate_from_seed("seed1");
+        let fp2 = Fingerprint::generate_from_seed("seed2");
+
+        // machine_id 一定不同
+        assert_ne!(fp1.machine_id, fp2.machine_id);
+    }
+
+    #[test]
+    fn test_user_agent_format() {
+        let fp = Fingerprint::generate_from_seed("test");
+        let ua = fp.user_agent();
+
+        assert!(ua.contains("aws-sdk-js/"));
+        assert!(ua.contains("KiroIDE-"));
+        assert!(ua.contains("lang/js"));
+        assert!(ua.contains("md/nodejs#"));
+    }
+
+    #[test]
+    fn test_x_amz_user_agent_format() {
+        let fp = Fingerprint::generate_from_seed("test");
+        let amz_ua = fp.x_amz_user_agent();
+
+        assert!(amz_ua.contains("aws-sdk-js/"));
+        assert!(amz_ua.contains("KiroIDE-"));
+    }
+
+    #[test]
+    fn test_machine_id_length() {
+        let fp = Fingerprint::generate_from_seed("test");
+        assert_eq!(fp.machine_id.len(), 64);
+    }
+
+    #[test]
+    fn test_hardware_concurrency_range() {
+        for i in 0..100 {
+            let fp = Fingerprint::generate_from_seed(&format!("test_{}", i));
+            assert!(fp.hardware_concurrency >= 4);
+            assert!(fp.hardware_concurrency <= 32);
+        }
+    }
+
+    #[test]
+    fn test_timezone_offset_range() {
+        for i in 0..100 {
+            let fp = Fingerprint::generate_from_seed(&format!("test_{}", i));
+            assert!(fp.timezone_offset >= -720);
+            assert!(fp.timezone_offset <= 720);
+        }
+    }
+
+    #[test]
+    fn test_os_version_matches_type() {
+        // darwin 类型应该有 darwin 版本
+        let fp = Fingerprint {
+            sdk_version: "1.0.27".to_string(),
+            os_type: "darwin".to_string(),
+            os_version: "24.6.0".to_string(),
+            node_version: "22.21.1".to_string(),
+            kiro_version: "0.8.0".to_string(),
+            kiro_hash: "test".to_string(),
+            accept_language: "en-US".to_string(),
+            screen_resolution: "1920x1080".to_string(),
+            color_depth: 24,
+            hardware_concurrency: 8,
+            timezone_offset: -480,
+            machine_id: "a".repeat(64),
+        };
+
+        let os_str = fp.os_string();
+        assert!(os_str.starts_with("darwin#"));
+    }
+}
diff --git a/src/kiro/machine_id.rs b/src/kiro/machine_id.rs
new file mode 100644
index 0000000..7978263
--- /dev/null
+++ b/src/kiro/machine_id.rs
@@ -0,0 +1,171 @@
+//! 设备指纹生成器
+//!
+
+use sha2::{Digest, Sha256};
+
+use crate::kiro::model::credentials::KiroCredentials;
+use crate::model::config::Config;
+
+/// 标准化 machineId 格式
+///
+/// 支持以下格式：
+/// - 64 字符十六进制字符串（直接返回）
+/// - UUID 格式（如 "2582956e-cc88-4669-b546-07adbffcb894"，移除连字符后补齐到 64 字符）
+fn normalize_machine_id(machine_id: &str) -> Option<String> {
+    let trimmed = machine_id.trim();
+
+    // 如果已经是 64 字符，直接返回
+    if trimmed.len() == 64 && trimmed.chars().all(|c| c.is_ascii_hexdigit()) {
+        return Some(trimmed.to_string());
+    }
+
+    // 尝试解析 UUID 格式（移除连字符）
+    let without_dashes: String = trimmed.chars().filter(|c| *c != '-').collect();
+
+    // UUID 去掉连字符后是 32 字符
+    if without_dashes.len() == 32 && without_dashes.chars().all(|c| c.is_ascii_hexdigit()) {
+        // 补齐到 64 字符（重复一次）
+        return Some(format!("{}{}", without_dashes, without_dashes));
+    }
+
+    // 无法识别的格式
+    None
+}
+
+/// 根据凭证信息生成唯一的 Machine ID
+///
+/// 优先使用凭据级 machineId，其次使用 config.machineId，然后使用 refreshToken 生成
+pub fn generate_from_credentials(credentials: &KiroCredentials, config: &Config) -> Option<String> {
+    // 如果配置了凭据级 machineId，优先使用
+    if let Some(ref machine_id) = credentials.machine_id
+        && let Some(normalized) = normalize_machine_id(machine_id)
+    {
+        return Some(normalized);
+    }
+
+    // 如果配置了全局 machineId，作为默认值
+    if let Some(ref machine_id) = config.machine_id
+        && let Some(normalized) = normalize_machine_id(machine_id)
+    {
+        return Some(normalized);
+    }
+
+    // 使用 refreshToken 生成
+    if let Some(ref refresh_token) = credentials.refresh_token
+        && !refresh_token.is_empty()
+    {
+        return Some(sha256_hex(&format!("KotlinNativeAPI/{}", refresh_token)));
+    }
+
+    // 没有有效的凭证
+    None
+}
+
+/// SHA256 哈希实现（返回十六进制字符串）
+fn sha256_hex(input: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(input.as_bytes());
+    let result = hasher.finalize();
+    hex::encode(result)
+}
+
+#[cfg(test)]
+#[allow(clippy::field_reassign_with_default)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sha256_hex() {
+        let result = sha256_hex("test");
+        assert_eq!(result.len(), 64);
+        assert_eq!(
+            result,
+            "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
+        );
+    }
+
+    #[test]
+    fn test_generate_with_custom_machine_id() {
+        let credentials = KiroCredentials::default();
+        let mut config = Config::default();
+        config.machine_id = Some("a".repeat(64));
+
+        let result = generate_from_credentials(&credentials, &config);
+        assert_eq!(result, Some("a".repeat(64)));
+    }
+
+    #[test]
+    fn test_generate_with_credential_machine_id_overrides_config() {
+        let mut credentials = KiroCredentials::default();
+        credentials.machine_id = Some("b".repeat(64));
+
+        let mut config = Config::default();
+        config.machine_id = Some("a".repeat(64));
+
+        let result = generate_from_credentials(&credentials, &config);
+        assert_eq!(result, Some("b".repeat(64)));
+    }
+
+    #[test]
+    fn test_generate_with_refresh_token() {
+        let mut credentials = KiroCredentials::default();
+        credentials.refresh_token = Some("test_refresh_token".to_string());
+        let config = Config::default();
+
+        let result = generate_from_credentials(&credentials, &config);
+        assert!(result.is_some());
+        assert_eq!(result.as_ref().unwrap().len(), 64);
+    }
+
+    #[test]
+    fn test_generate_without_credentials() {
+        let credentials = KiroCredentials::default();
+        let config = Config::default();
+
+        let result = generate_from_credentials(&credentials, &config);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_normalize_uuid_format() {
+        // UUID 格式应该被转换为 64 字符
+        let uuid = "2582956e-cc88-4669-b546-07adbffcb894";
+        let result = normalize_machine_id(uuid);
+        assert!(result.is_some());
+        let normalized = result.unwrap();
+        assert_eq!(normalized.len(), 64);
+        // UUID 去掉连字符后重复一次
+        assert_eq!(
+            normalized,
+            "2582956ecc884669b54607adbffcb8942582956ecc884669b54607adbffcb894"
+        );
+    }
+
+    #[test]
+    fn test_normalize_64_char_hex() {
+        // 64 字符十六进制应该直接返回
+        let hex64 = "a".repeat(64);
+        let result = normalize_machine_id(&hex64);
+        assert_eq!(result, Some(hex64));
+    }
+
+    #[test]
+    fn test_normalize_invalid_format() {
+        // 无效格式应该返回 None
+        assert!(normalize_machine_id("invalid").is_none());
+        assert!(normalize_machine_id("too-short").is_none());
+        assert!(normalize_machine_id(&"g".repeat(64)).is_none()); // 非十六进制
+    }
+
+    #[test]
+    fn test_generate_with_uuid_machine_id() {
+        let mut credentials = KiroCredentials::default();
+        credentials.machine_id = Some("2582956e-cc88-4669-b546-07adbffcb894".to_string());
+
+        let config = Config::default();
+
+        let result = generate_from_credentials(&credentials, &config);
+        assert!(result.is_some());
+        assert_eq!(result.as_ref().unwrap().len(), 64);
+    }
+}
diff --git a/src/kiro/mod.rs b/src/kiro/mod.rs
new file mode 100644
index 0000000..135e9b8
--- /dev/null
+++ b/src/kiro/mod.rs
@@ -0,0 +1,13 @@
+//! Kiro API 客户端模块
+
+pub mod affinity;
+pub mod background_refresh;
+pub mod cooldown;
+pub mod fingerprint;
+pub mod machine_id;
+pub mod model;
+pub mod parser;
+pub mod provider;
+pub mod rate_limiter;
+pub mod token_manager;
+pub mod web_portal;
diff --git a/src/kiro/model/common/mod.rs b/src/kiro/model/common/mod.rs
new file mode 100644
index 0000000..8a41409
--- /dev/null
+++ b/src/kiro/model/common/mod.rs
@@ -0,0 +1,4 @@
+//! 共享类型模块
+//!
+//! 此模块已简化，移除了未使用的类型定义。
+//! 如果将来需要扩展，可以在此添加新的共享类型。
diff --git a/src/kiro/model/credentials.rs b/src/kiro/model/credentials.rs
new file mode 100644
index 0000000..e486e2f
--- /dev/null
+++ b/src/kiro/model/credentials.rs
@@ -0,0 +1,849 @@
+//! Kiro OAuth 凭证数据模型
+//!
+//! 支持从 Kiro IDE 的凭证文件加载，使用 Social 认证方式
+//! 支持单凭据和多凭据配置格式
+
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::Path;
+
+use crate::http_client::ProxyConfig;
+use crate::model::config::Config;
+
+/// Kiro OAuth 凭证
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct KiroCredentials {
+    /// 凭据唯一标识符（自增 ID）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<u64>,
+
+    /// 访问令牌
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+
+    /// 刷新令牌
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<String>,
+
+    /// Profile ARN
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub profile_arn: Option<String>,
+
+    /// 过期时间 (RFC3339 格式)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub expires_at: Option<String>,
+
+    /// 认证方式 (social / idc)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub auth_method: Option<String>,
+
+    /// OIDC Client ID (IdC 认证需要)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+
+    /// OIDC Client Secret (IdC 认证需要)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<String>,
+
+    /// 凭据优先级（数字越小优先级越高，默认为 0）
+    #[serde(default)]
+    #[serde(skip_serializing_if = "is_zero")]
+    pub priority: u32,
+
+    /// 凭据级 Region 配置（用于 Token 刷新及 API 请求默认值）
+    /// 未配置时回退到 config.json 的全局 region
+    /// 兼容旧配置中的 authRegion 字段
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(alias = "authRegion")]
+    pub region: Option<String>,
+
+    /// 凭据级 API Region（用于 API 请求，可单独覆盖 region）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api_region: Option<String>,
+
+    /// 凭据级 Machine ID 配置（可选）
+    /// 未配置时回退到 config.json 的 machineId；都未配置时由 refreshToken 派生
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub machine_id: Option<String>,
+
+    /// 用户邮箱（从 Anthropic API 获取）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub email: Option<String>,
+
+    /// 订阅等级（KIRO PRO+ / KIRO FREE 等）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    pub subscription_title: Option<String>,
+
+    /// 凭据级代理 URL（可选）
+    /// 支持 http/https/socks5 协议
+    /// 特殊值 "direct" 表示显式不使用代理（即使全局配置了代理）
+    /// 未配置时回退到全局代理配置
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub proxy_url: Option<String>,
+
+    /// 凭据级代理认证用户名（可选）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub proxy_username: Option<String>,
+
+    /// 凭据级代理认证密码（可选）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub proxy_password: Option<String>,
+
+    /// 凭据是否被禁用（默认为 false）
+    #[serde(default)]
+    pub disabled: bool,
+}
+
+/// 判断是否为零（用于跳过序列化）
+fn is_zero(value: &u32) -> bool {
+    *value == 0
+}
+
+fn canonicalize_auth_method_value(value: &str) -> &str {
+    if value.eq_ignore_ascii_case("builder-id") || value.eq_ignore_ascii_case("iam") {
+        "idc"
+    } else {
+        value
+    }
+}
+
+/// 凭据配置（支持单对象或数组格式）
+///
+/// 自动识别配置文件格式：
+/// - 单对象格式（旧格式，向后兼容）
+/// - 数组格式（新格式，支持多凭据）
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+#[allow(clippy::large_enum_variant)]
+pub enum CredentialsConfig {
+    /// 单个凭据（旧格式）
+    Single(KiroCredentials),
+    /// 多凭据数组（新格式）
+    Multiple(Vec<KiroCredentials>),
+}
+
+impl CredentialsConfig {
+    /// 从文件加载凭据配置
+    ///
+    /// - 如果文件不存在，返回空数组
+    /// - 如果文件内容为空，返回空数组
+    /// - 支持单对象或数组格式
+    pub fn load<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
+        let path = path.as_ref();
+
+        // 文件不存在时返回空数组
+        if !path.exists() {
+            return Ok(CredentialsConfig::Multiple(vec![]));
+        }
+
+        let content = fs::read_to_string(path)?;
+
+        // 文件为空时返回空数组
+        if content.trim().is_empty() {
+            return Ok(CredentialsConfig::Multiple(vec![]));
+        }
+
+        let config = serde_json::from_str(&content)?;
+        Ok(config)
+    }
+
+    /// 转换为按优先级排序的凭据列表
+    pub fn into_sorted_credentials(self) -> Vec<KiroCredentials> {
+        match self {
+            CredentialsConfig::Single(mut cred) => {
+                cred.canonicalize_auth_method();
+                vec![cred]
+            }
+            CredentialsConfig::Multiple(mut creds) => {
+                // 按优先级排序（数字越小优先级越高）
+                creds.sort_by_key(|c| c.priority);
+                for cred in &mut creds {
+                    cred.canonicalize_auth_method();
+                }
+                creds
+            }
+        }
+    }
+
+    /// 获取凭据数量
+    #[allow(dead_code)]
+    pub fn len(&self) -> usize {
+        match self {
+            CredentialsConfig::Single(_) => 1,
+            CredentialsConfig::Multiple(creds) => creds.len(),
+        }
+    }
+
+    /// 判断是否为空
+    #[allow(dead_code)]
+    pub fn is_empty(&self) -> bool {
+        match self {
+            CredentialsConfig::Single(_) => false,
+            CredentialsConfig::Multiple(creds) => creds.is_empty(),
+        }
+    }
+
+    /// 判断是否为多凭据格式（数组格式）
+    pub fn is_multiple(&self) -> bool {
+        matches!(self, CredentialsConfig::Multiple(_))
+    }
+}
+
+#[allow(dead_code)]
+impl KiroCredentials {
+    /// 特殊值：显式不使用代理
+    pub const PROXY_DIRECT: &'static str = "direct";
+
+    /// 获取默认凭证文件路径
+    #[allow(dead_code)]
+    pub fn default_credentials_path() -> &'static str {
+        "credentials.json"
+    }
+
+    /// 获取有效的 Auth Region（用于 Token 刷新）
+    /// 优先级：凭据.region > config.region
+    pub fn effective_auth_region<'a>(&'a self, config: &'a Config) -> &'a str {
+        self.region
+            .as_deref()
+            .filter(|s| !s.trim().is_empty())
+            .unwrap_or(&config.region)
+    }
+
+    /// 获取有效的 API Region（用于 API 请求和额度查询）
+    /// 优先级：凭据.api_region > 凭据.region > config.api_region > config.region
+    pub fn effective_api_region<'a>(&'a self, config: &'a Config) -> &'a str {
+        self.api_region
+            .as_deref()
+            .filter(|s| !s.trim().is_empty())
+            .or_else(|| self.region.as_deref().filter(|s| !s.trim().is_empty()))
+            .unwrap_or(config.effective_api_region())
+    }
+
+    /// 获取有效的代理配置
+    /// 优先级：凭据代理 > 全局代理 > 无代理
+    /// 特殊值 "direct" 表示显式不使用代理（即使全局配置了代理）
+    pub fn effective_proxy(&self, global_proxy: Option<&ProxyConfig>) -> Option<ProxyConfig> {
+        match self.proxy_url.as_deref() {
+            Some(url) if url.eq_ignore_ascii_case(Self::PROXY_DIRECT) => None,
+            Some(url) => {
+                let mut proxy = ProxyConfig::new(url);
+                if let (Some(username), Some(password)) =
+                    (&self.proxy_username, &self.proxy_password)
+                {
+                    proxy = proxy.with_auth(username, password);
+                }
+                Some(proxy)
+            }
+            None => global_proxy.cloned(),
+        }
+    }
+
+    /// 从 JSON 字符串解析凭证
+    #[allow(dead_code)]
+    pub fn from_json(json_string: &str) -> Result<Self, serde_json::Error> {
+        serde_json::from_str(json_string)
+    }
+
+    /// 从文件加载凭证
+    #[allow(dead_code)]
+    pub fn load<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
+        let content = fs::read_to_string(path.as_ref())?;
+        if content.is_empty() {
+            anyhow::bail!("凭证文件为空: {:?}", path.as_ref());
+        }
+        let credentials = Self::from_json(&content)?;
+        Ok(credentials)
+    }
+
+    /// 序列化为格式化的 JSON 字符串
+    #[allow(dead_code)]
+    pub fn to_pretty_json(&self) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(self)
+    }
+
+    pub fn canonicalize_auth_method(&mut self) {
+        let auth_method = match &self.auth_method {
+            Some(m) => m,
+            None => return,
+        };
+
+        let canonical = canonicalize_auth_method_value(auth_method);
+        if canonical != auth_method {
+            self.auth_method = Some(canonical.to_string());
+        }
+    }
+
+    /// 检查凭据是否支持 Opus 模型
+    ///
+    /// Free 账号不支持 Opus 模型，需要 PRO 或更高等级订阅
+    pub fn supports_opus(&self) -> bool {
+        match &self.subscription_title {
+            Some(title) => {
+                let title_upper = title.to_uppercase();
+                // 如果包含 FREE，则不支持 Opus
+                !title_upper.contains("FREE")
+            }
+            // 如果还没有获取订阅信息，暂时允许（首次使用时会获取）
+            None => true,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::config::Config;
+
+    #[test]
+    fn test_from_json() {
+        let json = r#"{
+            "accessToken": "test_token",
+            "refreshToken": "test_refresh",
+            "profileArn": "arn:aws:test",
+            "expiresAt": "2024-01-01T00:00:00Z",
+            "authMethod": "social"
+        }"#;
+
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.access_token, Some("test_token".to_string()));
+        assert_eq!(creds.refresh_token, Some("test_refresh".to_string()));
+        assert_eq!(creds.profile_arn, Some("arn:aws:test".to_string()));
+        assert_eq!(creds.expires_at, Some("2024-01-01T00:00:00Z".to_string()));
+        assert_eq!(creds.auth_method, Some("social".to_string()));
+    }
+
+    #[test]
+    fn test_from_json_with_unknown_keys() {
+        let json = r#"{
+            "accessToken": "test_token",
+            "unknownField": "should be ignored"
+        }"#;
+
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.access_token, Some("test_token".to_string()));
+    }
+
+    #[test]
+    fn test_to_json() {
+        let creds = KiroCredentials {
+            id: None,
+            access_token: Some("token".to_string()),
+            refresh_token: None,
+            profile_arn: None,
+            expires_at: None,
+            auth_method: Some("social".to_string()),
+            client_id: None,
+            client_secret: None,
+            priority: 0,
+            region: None,
+            api_region: None,
+            machine_id: None,
+            email: None,
+            subscription_title: None,
+            proxy_url: None,
+            proxy_username: None,
+            proxy_password: None,
+            disabled: false,
+        };
+
+        let json = creds.to_pretty_json().unwrap();
+        assert!(json.contains("accessToken"));
+        assert!(json.contains("authMethod"));
+        assert!(!json.contains("refreshToken"));
+        // priority 为 0 时不序列化
+        assert!(!json.contains("priority"));
+    }
+
+    #[test]
+    fn test_default_credentials_path() {
+        assert_eq!(
+            KiroCredentials::default_credentials_path(),
+            "credentials.json"
+        );
+    }
+
+    #[test]
+    fn test_priority_default() {
+        let json = r#"{"refreshToken": "test"}"#;
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.priority, 0);
+    }
+
+    #[test]
+    fn test_priority_explicit() {
+        let json = r#"{"refreshToken": "test", "priority": 5}"#;
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.priority, 5);
+    }
+
+    #[test]
+    fn test_credentials_config_single() {
+        let json = r#"{"refreshToken": "test", "expiresAt": "2025-12-31T00:00:00Z"}"#;
+        let config: CredentialsConfig = serde_json::from_str(json).unwrap();
+        assert!(matches!(config, CredentialsConfig::Single(_)));
+        assert_eq!(config.len(), 1);
+    }
+
+    #[test]
+    fn test_credentials_config_multiple() {
+        let json = r#"[
+            {"refreshToken": "test1", "priority": 1},
+            {"refreshToken": "test2", "priority": 0}
+        ]"#;
+        let config: CredentialsConfig = serde_json::from_str(json).unwrap();
+        assert!(matches!(config, CredentialsConfig::Multiple(_)));
+        assert_eq!(config.len(), 2);
+    }
+
+    #[test]
+    fn test_credentials_config_priority_sorting() {
+        let json = r#"[
+            {"refreshToken": "t1", "priority": 2},
+            {"refreshToken": "t2", "priority": 0},
+            {"refreshToken": "t3", "priority": 1}
+        ]"#;
+        let config: CredentialsConfig = serde_json::from_str(json).unwrap();
+        let list = config.into_sorted_credentials();
+
+        // 验证按优先级排序
+        assert_eq!(list[0].refresh_token, Some("t2".to_string())); // priority 0
+        assert_eq!(list[1].refresh_token, Some("t3".to_string())); // priority 1
+        assert_eq!(list[2].refresh_token, Some("t1".to_string())); // priority 2
+    }
+
+    // ============ Region 字段测试 ============
+
+    #[test]
+    fn test_region_field_parsing() {
+        // 测试解析包含 region 字段的 JSON
+        let json = r#"{
+            "refreshToken": "test_refresh",
+            "region": "us-east-1"
+        }"#;
+
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.refresh_token, Some("test_refresh".to_string()));
+        assert_eq!(creds.region, Some("us-east-1".to_string()));
+    }
+
+    #[test]
+    fn test_region_field_missing_backward_compat() {
+        // 测试向后兼容：不包含 region 字段的旧格式 JSON
+        let json = r#"{
+            "refreshToken": "test_refresh",
+            "authMethod": "social"
+        }"#;
+
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.refresh_token, Some("test_refresh".to_string()));
+        assert_eq!(creds.region, None);
+    }
+
+    #[test]
+    fn test_region_field_serialization() {
+        // 测试序列化时正确输出 region 字段
+        let creds = KiroCredentials {
+            id: None,
+            access_token: None,
+            refresh_token: Some("test".to_string()),
+            profile_arn: None,
+            expires_at: None,
+            auth_method: None,
+            client_id: None,
+            client_secret: None,
+            priority: 0,
+            region: Some("eu-west-1".to_string()),
+            api_region: None,
+            machine_id: None,
+            email: None,
+            subscription_title: None,
+            proxy_url: None,
+            proxy_username: None,
+            proxy_password: None,
+            disabled: false,
+        };
+
+        let json = creds.to_pretty_json().unwrap();
+        assert!(json.contains("region"));
+        assert!(json.contains("eu-west-1"));
+    }
+
+    #[test]
+    fn test_region_field_none_not_serialized() {
+        // 测试 region 为 None 时不序列化
+        let creds = KiroCredentials {
+            id: None,
+            access_token: None,
+            refresh_token: Some("test".to_string()),
+            profile_arn: None,
+            expires_at: None,
+            auth_method: None,
+            client_id: None,
+            client_secret: None,
+            priority: 0,
+            region: None,
+            api_region: None,
+            machine_id: None,
+            email: None,
+            subscription_title: None,
+            proxy_url: None,
+            proxy_username: None,
+            proxy_password: None,
+            disabled: false,
+        };
+
+        let json = creds.to_pretty_json().unwrap();
+        assert!(!json.contains("region"));
+    }
+
+    // ============ MachineId 字段测试 ============
+
+    #[test]
+    fn test_machine_id_field_parsing() {
+        let machine_id = "a".repeat(64);
+        let json = format!(
+            r#"{{
+                "refreshToken": "test_refresh",
+                "machineId": "{machine_id}"
+            }}"#
+        );
+
+        let creds = KiroCredentials::from_json(&json).unwrap();
+        assert_eq!(creds.refresh_token, Some("test_refresh".to_string()));
+        assert_eq!(creds.machine_id, Some(machine_id));
+    }
+
+    #[test]
+    fn test_machine_id_field_serialization() {
+        let creds = KiroCredentials {
+            refresh_token: Some("test".to_string()),
+            machine_id: Some("b".repeat(64)),
+            ..Default::default()
+        };
+
+        let json = creds.to_pretty_json().unwrap();
+        assert!(json.contains("machineId"));
+    }
+
+    #[test]
+    fn test_machine_id_field_none_not_serialized() {
+        let creds = KiroCredentials {
+            refresh_token: Some("test".to_string()),
+            machine_id: None,
+            ..Default::default()
+        };
+
+        let json = creds.to_pretty_json().unwrap();
+        assert!(!json.contains("machineId"));
+    }
+
+    #[test]
+    fn test_multiple_credentials_with_different_regions() {
+        // 测试多凭据场景下不同凭据使用各自的 region
+        let json = r#"[
+            {"refreshToken": "t1", "region": "us-east-1"},
+            {"refreshToken": "t2", "region": "eu-west-1"},
+            {"refreshToken": "t3"}
+        ]"#;
+
+        let config: CredentialsConfig = serde_json::from_str(json).unwrap();
+        let list = config.into_sorted_credentials();
+
+        assert_eq!(list[0].region, Some("us-east-1".to_string()));
+        assert_eq!(list[1].region, Some("eu-west-1".to_string()));
+        assert_eq!(list[2].region, None);
+    }
+
+    #[test]
+    fn test_region_field_with_all_fields() {
+        // 测试包含所有字段的完整 JSON
+        let json = r#"{
+            "id": 1,
+            "accessToken": "access",
+            "refreshToken": "refresh",
+            "profileArn": "arn:aws:test",
+            "expiresAt": "2025-12-31T00:00:00Z",
+            "authMethod": "idc",
+            "clientId": "client123",
+            "clientSecret": "secret456",
+            "priority": 5,
+            "region": "ap-northeast-1"
+        }"#;
+
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.id, Some(1));
+        assert_eq!(creds.access_token, Some("access".to_string()));
+        assert_eq!(creds.refresh_token, Some("refresh".to_string()));
+        assert_eq!(creds.profile_arn, Some("arn:aws:test".to_string()));
+        assert_eq!(creds.expires_at, Some("2025-12-31T00:00:00Z".to_string()));
+        assert_eq!(creds.auth_method, Some("idc".to_string()));
+        assert_eq!(creds.client_id, Some("client123".to_string()));
+        assert_eq!(creds.client_secret, Some("secret456".to_string()));
+        assert_eq!(creds.priority, 5);
+        assert_eq!(creds.region, Some("ap-northeast-1".to_string()));
+    }
+
+    #[test]
+    fn test_region_roundtrip() {
+        // 测试序列化和反序列化的往返一致性
+        let original = KiroCredentials {
+            id: Some(42),
+            access_token: Some("token".to_string()),
+            refresh_token: Some("refresh".to_string()),
+            profile_arn: None,
+            expires_at: None,
+            auth_method: Some("social".to_string()),
+            client_id: None,
+            client_secret: None,
+            priority: 3,
+            region: Some("us-west-2".to_string()),
+            api_region: None,
+            machine_id: Some("c".repeat(64)),
+            email: None,
+            subscription_title: None,
+            proxy_url: None,
+            proxy_username: None,
+            proxy_password: None,
+            disabled: false,
+        };
+
+        let json = original.to_pretty_json().unwrap();
+        let parsed = KiroCredentials::from_json(&json).unwrap();
+
+        assert_eq!(parsed.id, original.id);
+        assert_eq!(parsed.access_token, original.access_token);
+        assert_eq!(parsed.refresh_token, original.refresh_token);
+        assert_eq!(parsed.priority, original.priority);
+        assert_eq!(parsed.region, original.region);
+        assert_eq!(parsed.machine_id, original.machine_id);
+    }
+
+    // ============ api_region 字段测试 ============
+
+    #[test]
+    fn test_api_region_field_parsing() {
+        let json = r#"{
+            "refreshToken": "test_refresh",
+            "apiRegion": "ap-southeast-1"
+        }"#;
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.api_region, Some("ap-southeast-1".to_string()));
+    }
+
+    #[test]
+    fn test_api_region_serialization() {
+        let creds = KiroCredentials {
+            refresh_token: Some("test".to_string()),
+            api_region: Some("us-west-2".to_string()),
+            ..Default::default()
+        };
+
+        let json = creds.to_pretty_json().unwrap();
+        assert!(json.contains("apiRegion"));
+        assert!(json.contains("us-west-2"));
+    }
+
+    #[test]
+    fn test_api_region_none_not_serialized() {
+        let creds = KiroCredentials {
+            refresh_token: Some("test".to_string()),
+            api_region: None,
+            ..Default::default()
+        };
+
+        let json = creds.to_pretty_json().unwrap();
+        assert!(!json.contains("apiRegion"));
+    }
+
+    #[test]
+    fn test_api_region_roundtrip() {
+        let original = KiroCredentials {
+            refresh_token: Some("refresh".to_string()),
+            region: Some("us-east-1".to_string()),
+            api_region: Some("ap-northeast-1".to_string()),
+            ..Default::default()
+        };
+
+        let json = original.to_pretty_json().unwrap();
+        let parsed = KiroCredentials::from_json(&json).unwrap();
+
+        assert_eq!(parsed.region, original.region);
+        assert_eq!(parsed.api_region, original.api_region);
+    }
+
+    #[test]
+    fn test_backward_compat_no_api_region() {
+        // 旧格式 JSON 不包含 apiRegion，应正常解析
+        let json = r#"{
+            "refreshToken": "test_refresh",
+            "region": "us-east-1"
+        }"#;
+        let creds = KiroCredentials::from_json(json).unwrap();
+        assert_eq!(creds.region, Some("us-east-1".to_string()));
+        assert_eq!(creds.api_region, None);
+    }
+
+    // ============ effective_auth_region / effective_api_region 优先级测试 ============
+
+    #[test]
+    fn test_effective_auth_region_credential_region_wins() {
+        // 凭据.region > config.region
+        let mut config = Config::default();
+        config.region = "config-region".to_string();
+
+        let creds = KiroCredentials {
+            region: Some("cred-region".to_string()),
+            ..Default::default()
+        };
+
+        assert_eq!(creds.effective_auth_region(&config), "cred-region");
+    }
+
+    #[test]
+    fn test_effective_auth_region_fallback_to_config_region() {
+        let mut config = Config::default();
+        config.region = "config-region".to_string();
+
+        let creds = KiroCredentials::default();
+
+        assert_eq!(creds.effective_auth_region(&config), "config-region");
+    }
+
+    #[test]
+    fn test_effective_api_region_credential_api_region_highest() {
+        // 凭据.api_region > 凭据.region > config.api_region > config.region
+        let mut config = Config::default();
+        config.region = "config-region".to_string();
+        config.api_region = Some("config-api-region".to_string());
+
+        let creds = KiroCredentials {
+            region: Some("cred-region".to_string()),
+            api_region: Some("cred-api-region".to_string()),
+            ..Default::default()
+        };
+
+        assert_eq!(creds.effective_api_region(&config), "cred-api-region");
+    }
+
+    #[test]
+    fn test_effective_api_region_fallback_to_credential_region() {
+        let mut config = Config::default();
+        config.region = "config-region".to_string();
+        config.api_region = Some("config-api-region".to_string());
+
+        let creds = KiroCredentials {
+            region: Some("cred-region".to_string()),
+            ..Default::default()
+        };
+
+        assert_eq!(creds.effective_api_region(&config), "cred-region");
+    }
+
+    #[test]
+    fn test_effective_api_region_fallback_to_config_api_region() {
+        let mut config = Config::default();
+        config.region = "config-region".to_string();
+        config.api_region = Some("config-api-region".to_string());
+
+        let creds = KiroCredentials::default();
+
+        assert_eq!(creds.effective_api_region(&config), "config-api-region");
+    }
+
+    #[test]
+    fn test_effective_api_region_fallback_to_config_region() {
+        let mut config = Config::default();
+        config.region = "config-region".to_string();
+
+        let creds = KiroCredentials::default();
+
+        assert_eq!(creds.effective_api_region(&config), "config-region");
+    }
+
+    #[test]
+    fn test_region_and_api_region_independent() {
+        // region 用于 auth，api_region 可单独覆盖 API 请求
+        let mut config = Config::default();
+        config.region = "default".to_string();
+
+        let creds = KiroCredentials {
+            region: Some("eu-central-1".to_string()),
+            api_region: Some("us-east-1".to_string()),
+            ..Default::default()
+        };
+
+        assert_eq!(creds.effective_auth_region(&config), "eu-central-1");
+        assert_eq!(creds.effective_api_region(&config), "us-east-1");
+    }
+
+    // ============ 凭据级代理优先级测试 ============
+
+    #[test]
+    fn test_effective_proxy_credential_overrides_global() {
+        let global = ProxyConfig::new("http://global:8080");
+        let creds = KiroCredentials {
+            proxy_url: Some("socks5://cred:1080".to_string()),
+            ..Default::default()
+        };
+
+        let result = creds.effective_proxy(Some(&global));
+        assert_eq!(result, Some(ProxyConfig::new("socks5://cred:1080")));
+    }
+
+    #[test]
+    fn test_effective_proxy_credential_with_auth() {
+        let global = ProxyConfig::new("http://global:8080");
+        let creds = KiroCredentials {
+            proxy_url: Some("http://proxy:3128".to_string()),
+            proxy_username: Some("user".to_string()),
+            proxy_password: Some("pass".to_string()),
+            ..Default::default()
+        };
+
+        let result = creds.effective_proxy(Some(&global));
+        let expected = ProxyConfig::new("http://proxy:3128").with_auth("user", "pass");
+        assert_eq!(result, Some(expected));
+    }
+
+    #[test]
+    fn test_effective_proxy_direct_bypasses_global() {
+        let global = ProxyConfig::new("http://global:8080");
+        let creds = KiroCredentials {
+            proxy_url: Some("direct".to_string()),
+            ..Default::default()
+        };
+
+        let result = creds.effective_proxy(Some(&global));
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_effective_proxy_direct_case_insensitive() {
+        let global = ProxyConfig::new("http://global:8080");
+        let creds = KiroCredentials {
+            proxy_url: Some("DIRECT".to_string()),
+            ..Default::default()
+        };
+
+        let result = creds.effective_proxy(Some(&global));
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_effective_proxy_fallback_to_global() {
+        let global = ProxyConfig::new("http://global:8080");
+        let creds = KiroCredentials::default();
+
+        let result = creds.effective_proxy(Some(&global));
+        assert_eq!(result, Some(ProxyConfig::new("http://global:8080")));
+    }
+
+    #[test]
+    fn test_effective_proxy_none_when_no_proxy() {
+        let creds = KiroCredentials::default();
+        let result = creds.effective_proxy(None);
+        assert_eq!(result, None);
+    }
+}
diff --git a/src/kiro/model/events/assistant.rs b/src/kiro/model/events/assistant.rs
new file mode 100644
index 0000000..68f1114
--- /dev/null
+++ b/src/kiro/model/events/assistant.rs
@@ -0,0 +1,115 @@
+//! 助手响应事件
+//!
+//! 处理 assistantResponseEvent 类型的事件
+
+use serde::{Deserialize, Serialize};
+
+use crate::kiro::parser::error::ParseResult;
+use crate::kiro::parser::frame::Frame;
+
+use super::base::EventPayload;
+
+/// 助手响应事件
+///
+/// 包含 AI 助手的流式响应内容
+///
+/// # 设计说明
+///
+/// 此结构体只保留实际使用的 `content` 字段，其他 API 返回的字段
+/// 通过 `#[serde(flatten)]` 捕获到 `extra` 中，确保反序列化不会失败。
+///
+/// # 示例
+///
+/// ```rust
+/// use kiro_rs::kiro::model::events::AssistantResponseEvent;
+///
+/// let json = r#"{"content":"Hello, world!"}"#;
+/// let event: AssistantResponseEvent = serde_json::from_str(json).unwrap();
+/// assert_eq!(event.content, "Hello, world!");
+/// ```
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AssistantResponseEvent {
+    /// 响应内容片段
+    #[serde(default)]
+    pub content: String,
+
+    /// 捕获其他未使用的字段，确保反序列化兼容性
+    #[serde(flatten)]
+    #[serde(skip_serializing)]
+    #[allow(dead_code)]
+    extra: serde_json::Value,
+}
+
+impl EventPayload for AssistantResponseEvent {
+    fn from_frame(frame: &Frame) -> ParseResult<Self> {
+        frame.payload_as_json()
+    }
+}
+
+impl Default for AssistantResponseEvent {
+    fn default() -> Self {
+        Self {
+            content: String::new(),
+            extra: serde_json::Value::Null,
+        }
+    }
+}
+
+impl std::fmt::Display for AssistantResponseEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.content)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_deserialize_simple() {
+        let json = r#"{"content":"Hello, world!"}"#;
+        let event: AssistantResponseEvent = serde_json::from_str(json).unwrap();
+        assert_eq!(event.content, "Hello, world!");
+    }
+
+    #[test]
+    fn test_deserialize_with_extra_fields() {
+        // 确保包含额外字段时反序列化不会失败
+        let json = r#"{
+            "content": "Done",
+            "conversationId": "conv-123",
+            "messageId": "msg-456",
+            "messageStatus": "COMPLETED",
+            "followupPrompt": {
+                "content": "Would you like me to explain further?",
+                "userIntent": "EXPLAIN_CODE_SELECTION"
+            }
+        }"#;
+        let event: AssistantResponseEvent = serde_json::from_str(json).unwrap();
+        assert_eq!(event.content, "Done");
+    }
+
+    #[test]
+    fn test_serialize_minimal() {
+        let event = AssistantResponseEvent::default();
+        let event = AssistantResponseEvent {
+            content: "Test".to_string(),
+            ..event
+        };
+
+        let json = serde_json::to_string(&event).unwrap();
+        assert!(json.contains("\"content\":\"Test\""));
+        // extra 字段不应该被序列化
+        assert!(!json.contains("extra"));
+    }
+
+    #[test]
+    fn test_display() {
+        let event = AssistantResponseEvent {
+            content: "test".to_string(),
+            ..Default::default()
+        };
+        assert_eq!(format!("{}", event), "test");
+    }
+}
diff --git a/src/kiro/model/events/base.rs b/src/kiro/model/events/base.rs
new file mode 100644
index 0000000..28d2e74
--- /dev/null
+++ b/src/kiro/model/events/base.rs
@@ -0,0 +1,186 @@
+//! 事件基础定义
+//!
+//! 定义事件类型枚举、trait 和统一事件结构
+
+use crate::kiro::parser::error::{ParseError, ParseResult};
+use crate::kiro::parser::frame::Frame;
+
+/// 事件类型枚举
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum EventType {
+    /// 助手响应事件
+    AssistantResponse,
+    /// 工具使用事件
+    ToolUse,
+    /// 计费事件
+    Metering,
+    /// 上下文使用率事件
+    ContextUsage,
+    /// 未知事件类型
+    Unknown,
+}
+
+impl EventType {
+    /// 从事件类型字符串解析
+    pub fn from_str(s: &str) -> Self {
+        match s {
+            "assistantResponseEvent" => Self::AssistantResponse,
+            "toolUseEvent" => Self::ToolUse,
+            "meteringEvent" => Self::Metering,
+            "contextUsageEvent" => Self::ContextUsage,
+            _ => Self::Unknown,
+        }
+    }
+
+    /// 转换为事件类型字符串
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::AssistantResponse => "assistantResponseEvent",
+            Self::ToolUse => "toolUseEvent",
+            Self::Metering => "meteringEvent",
+            Self::ContextUsage => "contextUsageEvent",
+            Self::Unknown => "unknown",
+        }
+    }
+}
+
+impl std::fmt::Display for EventType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+/// 事件 payload trait
+///
+/// 所有具体事件类型都需要实现此 trait
+pub trait EventPayload: Sized {
+    /// 从帧解析事件负载
+    fn from_frame(frame: &Frame) -> ParseResult<Self>;
+}
+
+/// 统一事件枚举
+///
+/// 封装所有可能的事件类型
+#[derive(Debug, Clone)]
+pub enum Event {
+    /// 助手响应
+    AssistantResponse(super::AssistantResponseEvent),
+    /// 工具使用
+    ToolUse(super::ToolUseEvent),
+    /// 计费
+    Metering(()),
+    /// 上下文使用率
+    ContextUsage(super::ContextUsageEvent),
+    /// 未知事件 (保留原始帧数据)
+    Unknown {},
+    /// 服务端错误
+    Error {
+        /// 错误代码
+        error_code: String,
+        /// 错误消息
+        error_message: String,
+    },
+    /// 服务端异常
+    Exception {
+        /// 异常类型
+        exception_type: String,
+        /// 异常消息
+        message: String,
+    },
+}
+
+impl Event {
+    /// 从帧解析事件
+    pub fn from_frame(frame: Frame) -> ParseResult<Self> {
+        let message_type = frame.message_type().unwrap_or("event");
+
+        match message_type {
+            "event" => Self::parse_event(frame),
+            "error" => Self::parse_error(frame),
+            "exception" => Self::parse_exception(frame),
+            other => Err(ParseError::InvalidMessageType(other.to_string())),
+        }
+    }
+
+    /// 解析事件类型消息
+    fn parse_event(frame: Frame) -> ParseResult<Self> {
+        let event_type_str = frame.event_type().unwrap_or("unknown");
+        let event_type = EventType::from_str(event_type_str);
+
+        match event_type {
+            EventType::AssistantResponse => {
+                let payload = super::AssistantResponseEvent::from_frame(&frame)?;
+                Ok(Self::AssistantResponse(payload))
+            }
+            EventType::ToolUse => {
+                let payload = super::ToolUseEvent::from_frame(&frame)?;
+                Ok(Self::ToolUse(payload))
+            }
+            EventType::Metering => Ok(Self::Metering(())),
+            EventType::ContextUsage => {
+                let payload = super::ContextUsageEvent::from_frame(&frame)?;
+                Ok(Self::ContextUsage(payload))
+            }
+            EventType::Unknown => Ok(Self::Unknown {}),
+        }
+    }
+
+    /// 解析错误类型消息
+    fn parse_error(frame: Frame) -> ParseResult<Self> {
+        let error_code = frame
+            .headers
+            .error_code()
+            .unwrap_or("UnknownError")
+            .to_string();
+        let error_message = frame.payload_as_str();
+
+        Ok(Self::Error {
+            error_code,
+            error_message,
+        })
+    }
+
+    /// 解析异常类型消息
+    fn parse_exception(frame: Frame) -> ParseResult<Self> {
+        let exception_type = frame
+            .headers
+            .exception_type()
+            .unwrap_or("UnknownException")
+            .to_string();
+        let message = frame.payload_as_str();
+
+        Ok(Self::Exception {
+            exception_type,
+            message,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_event_type_from_str() {
+        assert_eq!(
+            EventType::from_str("assistantResponseEvent"),
+            EventType::AssistantResponse
+        );
+        assert_eq!(EventType::from_str("toolUseEvent"), EventType::ToolUse);
+        assert_eq!(EventType::from_str("meteringEvent"), EventType::Metering);
+        assert_eq!(
+            EventType::from_str("contextUsageEvent"),
+            EventType::ContextUsage
+        );
+        assert_eq!(EventType::from_str("unknown_type"), EventType::Unknown);
+    }
+
+    #[test]
+    fn test_event_type_as_str() {
+        assert_eq!(
+            EventType::AssistantResponse.as_str(),
+            "assistantResponseEvent"
+        );
+        assert_eq!(EventType::ToolUse.as_str(), "toolUseEvent");
+    }
+}
diff --git a/src/kiro/model/events/context_usage.rs b/src/kiro/model/events/context_usage.rs
new file mode 100644
index 0000000..3403492
--- /dev/null
+++ b/src/kiro/model/events/context_usage.rs
@@ -0,0 +1,40 @@
+//! 上下文使用率事件
+//!
+//! 处理 contextUsageEvent 类型的事件
+
+use serde::Deserialize;
+
+use crate::kiro::parser::error::ParseResult;
+use crate::kiro::parser::frame::Frame;
+
+use super::base::EventPayload;
+
+/// 上下文使用率事件
+///
+/// 包含当前上下文窗口的使用百分比
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ContextUsageEvent {
+    /// 上下文使用百分比 (0-100)
+    #[serde(default)]
+    pub context_usage_percentage: f64,
+}
+
+impl EventPayload for ContextUsageEvent {
+    fn from_frame(frame: &Frame) -> ParseResult<Self> {
+        frame.payload_as_json()
+    }
+}
+
+impl ContextUsageEvent {
+    /// 获取格式化的百分比字符串
+    pub fn formatted_percentage(&self) -> String {
+        format!("{:.2}%", self.context_usage_percentage)
+    }
+}
+
+impl std::fmt::Display for ContextUsageEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.formatted_percentage())
+    }
+}
diff --git a/src/kiro/model/events/mod.rs b/src/kiro/model/events/mod.rs
new file mode 100644
index 0000000..c9880f9
--- /dev/null
+++ b/src/kiro/model/events/mod.rs
@@ -0,0 +1,13 @@
+//! 事件模型
+//!
+//! 定义 generateAssistantResponse 流式响应的事件类型
+
+mod assistant;
+mod base;
+mod context_usage;
+mod tool_use;
+
+pub use assistant::AssistantResponseEvent;
+pub use base::Event;
+pub use context_usage::ContextUsageEvent;
+pub use tool_use::ToolUseEvent;
diff --git a/src/kiro/model/events/tool_use.rs b/src/kiro/model/events/tool_use.rs
new file mode 100644
index 0000000..9bfab9d
--- /dev/null
+++ b/src/kiro/model/events/tool_use.rs
@@ -0,0 +1,52 @@
+//! 工具使用事件
+//!
+//! 处理 toolUseEvent 类型的事件
+
+use serde::Deserialize;
+
+use crate::kiro::parser::error::ParseResult;
+use crate::kiro::parser::frame::Frame;
+
+use super::base::EventPayload;
+
+/// 工具使用事件
+///
+/// 包含工具调用的流式数据
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolUseEvent {
+    /// 工具名称
+    pub name: String,
+    /// 工具调用 ID
+    pub tool_use_id: String,
+    /// 工具输入数据 (JSON 字符串，可能是流式的部分数据)
+    #[serde(default)]
+    pub input: String,
+    /// 是否是最后一个块
+    #[serde(default)]
+    pub stop: bool,
+}
+
+impl EventPayload for ToolUseEvent {
+    fn from_frame(frame: &Frame) -> ParseResult<Self> {
+        frame.payload_as_json()
+    }
+}
+
+impl std::fmt::Display for ToolUseEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.stop {
+            write!(
+                f,
+                "ToolUse[{}] (id={}, complete): {}",
+                self.name, self.tool_use_id, self.input
+            )
+        } else {
+            write!(
+                f,
+                "ToolUse[{}] (id={}, partial): {}",
+                self.name, self.tool_use_id, self.input
+            )
+        }
+    }
+}
diff --git a/src/kiro/model/mod.rs b/src/kiro/model/mod.rs
new file mode 100644
index 0000000..b0342d7
--- /dev/null
+++ b/src/kiro/model/mod.rs
@@ -0,0 +1,16 @@
+//! Kiro 数据模型
+//!
+//! 包含 Kiro API 的所有数据类型定义：
+//! - `common`: 共享类型（枚举和辅助结构体）
+//! - `events`: 响应事件类型
+//! - `requests`: 请求类型
+//! - `credentials`: OAuth 凭证
+//! - `token_refresh`: Token 刷新
+//! - `usage_limits`: 使用额度查询
+
+pub mod common;
+pub mod credentials;
+pub mod events;
+pub mod requests;
+pub mod token_refresh;
+pub mod usage_limits;
diff --git a/src/kiro/model/requests/conversation.rs b/src/kiro/model/requests/conversation.rs
new file mode 100644
index 0000000..393b06e
--- /dev/null
+++ b/src/kiro/model/requests/conversation.rs
@@ -0,0 +1,408 @@
+//! 对话类型定义
+//!
+//! 定义 Kiro API 中对话相关的类型，包括消息、历史记录等
+
+use serde::{Deserialize, Serialize};
+
+use super::tool::{Tool, ToolResult, ToolUseEntry};
+
+/// 对话状态
+///
+/// Kiro API 请求中的核心结构，包含当前消息和历史记录
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConversationState {
+    /// 代理延续 ID
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub agent_continuation_id: Option<String>,
+    /// 代理任务类型（通常为 "vibe"）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub agent_task_type: Option<String>,
+    /// 聊天触发类型（"MANUAL" 或 "AUTO"）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub chat_trigger_type: Option<String>,
+    /// 当前消息
+    pub current_message: CurrentMessage,
+    /// 会话 ID
+    pub conversation_id: String,
+    /// 历史消息列表
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub history: Vec<Message>,
+}
+
+impl ConversationState {
+    /// 创建新的对话状态
+    pub fn new(conversation_id: impl Into<String>) -> Self {
+        Self {
+            agent_continuation_id: None,
+            agent_task_type: None,
+            chat_trigger_type: None,
+            current_message: CurrentMessage::default(),
+            conversation_id: conversation_id.into(),
+            history: Vec::new(),
+        }
+    }
+
+    /// 设置代理延续 ID
+    pub fn with_agent_continuation_id(mut self, id: impl Into<String>) -> Self {
+        self.agent_continuation_id = Some(id.into());
+        self
+    }
+
+    /// 设置代理任务类型
+    pub fn with_agent_task_type(mut self, task_type: impl Into<String>) -> Self {
+        self.agent_task_type = Some(task_type.into());
+        self
+    }
+
+    /// 设置聊天触发类型
+    pub fn with_chat_trigger_type(mut self, trigger_type: impl Into<String>) -> Self {
+        self.chat_trigger_type = Some(trigger_type.into());
+        self
+    }
+
+    /// 设置当前消息
+    pub fn with_current_message(mut self, message: CurrentMessage) -> Self {
+        self.current_message = message;
+        self
+    }
+
+    /// 添加历史消息
+    pub fn with_history(mut self, history: Vec<Message>) -> Self {
+        self.history = history;
+        self
+    }
+}
+
+/// 当前消息容器
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CurrentMessage {
+    /// 用户输入消息
+    pub user_input_message: UserInputMessage,
+}
+
+impl CurrentMessage {
+    /// 创建新的当前消息
+    pub fn new(user_input_message: UserInputMessage) -> Self {
+        Self { user_input_message }
+    }
+}
+
+/// 用户输入消息
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UserInputMessage {
+    /// 用户输入消息上下文
+    pub user_input_message_context: UserInputMessageContext,
+    /// 消息内容
+    pub content: String,
+    /// 模型 ID
+    pub model_id: String,
+    /// 图片列表
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub images: Vec<KiroImage>,
+    /// 消息来源（通常为 "AI_EDITOR"）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub origin: Option<String>,
+}
+
+impl UserInputMessage {
+    /// 创建新的用户输入消息
+    pub fn new(content: impl Into<String>, model_id: impl Into<String>) -> Self {
+        Self {
+            user_input_message_context: UserInputMessageContext::default(),
+            content: content.into(),
+            model_id: model_id.into(),
+            images: Vec::new(),
+            origin: Some("AI_EDITOR".to_string()),
+        }
+    }
+
+    /// 设置消息上下文
+    pub fn with_context(mut self, context: UserInputMessageContext) -> Self {
+        self.user_input_message_context = context;
+        self
+    }
+
+    /// 添加图片
+    pub fn with_images(mut self, images: Vec<KiroImage>) -> Self {
+        self.images = images;
+        self
+    }
+
+    /// 设置来源
+    pub fn with_origin(mut self, origin: impl Into<String>) -> Self {
+        self.origin = Some(origin.into());
+        self
+    }
+}
+
+/// 用户输入消息上下文
+///
+/// 包含工具定义和工具执行结果
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UserInputMessageContext {
+    /// 工具执行结果列表
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tool_results: Vec<ToolResult>,
+    /// 可用工具列表
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tools: Vec<Tool>,
+}
+
+impl UserInputMessageContext {
+    /// 创建新的消息上下文
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// 设置工具列表
+    pub fn with_tools(mut self, tools: Vec<Tool>) -> Self {
+        self.tools = tools;
+        self
+    }
+
+    /// 设置工具结果
+    pub fn with_tool_results(mut self, results: Vec<ToolResult>) -> Self {
+        self.tool_results = results;
+        self
+    }
+}
+
+/// Kiro 图片
+///
+/// API 中使用的图片格式
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct KiroImage {
+    /// 图片格式（"jpeg", "png", "gif", "webp"）
+    pub format: String,
+    /// 图片数据源
+    pub source: KiroImageSource,
+}
+
+impl KiroImage {
+    /// 从 base64 数据创建图片
+    pub fn from_base64(format: impl Into<String>, data: impl Into<String>) -> Self {
+        Self {
+            format: format.into(),
+            source: KiroImageSource { bytes: data.into() },
+        }
+    }
+}
+
+/// Kiro 图片数据源
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct KiroImageSource {
+    /// base64 编码的图片数据
+    pub bytes: String,
+}
+
+/// 历史消息
+///
+/// 可以是用户消息或助手消息
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Message {
+    /// 用户消息
+    User(HistoryUserMessage),
+    /// 助手消息
+    Assistant(HistoryAssistantMessage),
+}
+
+#[allow(dead_code)]
+impl Message {
+    /// 创建用户消息
+    pub fn user(content: impl Into<String>, model_id: impl Into<String>) -> Self {
+        Self::User(HistoryUserMessage::new(content, model_id))
+    }
+
+    /// 创建助手消息
+    pub fn assistant(content: impl Into<String>) -> Self {
+        Self::Assistant(HistoryAssistantMessage::new(content))
+    }
+
+    /// 判断是否为用户消息
+    pub fn is_user(&self) -> bool {
+        matches!(self, Self::User(_))
+    }
+
+    /// 判断是否为助手消息
+    pub fn is_assistant(&self) -> bool {
+        matches!(self, Self::Assistant(_))
+    }
+}
+
+/// 历史用户消息
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HistoryUserMessage {
+    /// 用户输入消息
+    pub user_input_message: UserMessage,
+}
+
+impl HistoryUserMessage {
+    /// 创建新的历史用户消息
+    pub fn new(content: impl Into<String>, model_id: impl Into<String>) -> Self {
+        Self {
+            user_input_message: UserMessage::new(content, model_id),
+        }
+    }
+}
+
+/// 用户消息（历史记录中使用）
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UserMessage {
+    /// 消息内容
+    pub content: String,
+    /// 模型 ID
+    pub model_id: String,
+    /// 消息来源
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub origin: Option<String>,
+    /// 图片列表
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub images: Vec<KiroImage>,
+    /// 用户输入消息上下文
+    #[serde(default, skip_serializing_if = "is_default_context")]
+    pub user_input_message_context: UserInputMessageContext,
+}
+
+fn is_default_context(ctx: &UserInputMessageContext) -> bool {
+    ctx.tools.is_empty() && ctx.tool_results.is_empty()
+}
+
+impl UserMessage {
+    /// 创建新的用户消息
+    pub fn new(content: impl Into<String>, model_id: impl Into<String>) -> Self {
+        Self {
+            content: content.into(),
+            model_id: model_id.into(),
+            origin: Some("AI_EDITOR".to_string()),
+            images: Vec::new(),
+            user_input_message_context: UserInputMessageContext::default(),
+        }
+    }
+
+    /// 设置图片
+    pub fn with_images(mut self, images: Vec<KiroImage>) -> Self {
+        self.images = images;
+        self
+    }
+
+    /// 设置上下文
+    pub fn with_context(mut self, context: UserInputMessageContext) -> Self {
+        self.user_input_message_context = context;
+        self
+    }
+}
+
+/// 历史助手消息
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HistoryAssistantMessage {
+    /// 助手响应消息
+    pub assistant_response_message: AssistantMessage,
+}
+
+impl HistoryAssistantMessage {
+    /// 创建新的历史助手消息
+    pub fn new(content: impl Into<String>) -> Self {
+        Self {
+            assistant_response_message: AssistantMessage::new(content),
+        }
+    }
+}
+
+/// 助手消息（历史记录中使用）
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AssistantMessage {
+    /// 响应内容
+    pub content: String,
+    /// 工具使用列表
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tool_uses: Option<Vec<ToolUseEntry>>,
+}
+
+impl AssistantMessage {
+    /// 创建新的助手消息
+    pub fn new(content: impl Into<String>) -> Self {
+        Self {
+            content: content.into(),
+            tool_uses: None,
+        }
+    }
+
+    /// 设置工具使用
+    pub fn with_tool_uses(mut self, tool_uses: Vec<ToolUseEntry>) -> Self {
+        self.tool_uses = Some(tool_uses);
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_conversation_state_new() {
+        let state = ConversationState::new("conv-123")
+            .with_agent_task_type("vibe")
+            .with_chat_trigger_type("MANUAL");
+
+        assert_eq!(state.conversation_id, "conv-123");
+        assert_eq!(state.agent_task_type, Some("vibe".to_string()));
+        assert_eq!(state.chat_trigger_type, Some("MANUAL".to_string()));
+    }
+
+    #[test]
+    fn test_user_input_message() {
+        let msg = UserInputMessage::new("Hello", "claude-3-5-sonnet").with_origin("AI_EDITOR");
+
+        assert_eq!(msg.content, "Hello");
+        assert_eq!(msg.model_id, "claude-3-5-sonnet");
+        assert_eq!(msg.origin, Some("AI_EDITOR".to_string()));
+    }
+
+    #[test]
+    fn test_message_enum() {
+        let user_msg = Message::user("Hello", "model-id");
+        assert!(user_msg.is_user());
+        assert!(!user_msg.is_assistant());
+
+        let assistant_msg = Message::assistant("Hi there!");
+        assert!(assistant_msg.is_assistant());
+        assert!(!assistant_msg.is_user());
+    }
+
+    #[test]
+    fn test_history_serialize() {
+        let history = vec![
+            Message::user("Hello", "claude-3-5-sonnet"),
+            Message::assistant("Hi! How can I help you?"),
+        ];
+
+        let json = serde_json::to_string(&history).unwrap();
+        assert!(json.contains("userInputMessage"));
+        assert!(json.contains("assistantResponseMessage"));
+    }
+
+    #[test]
+    fn test_conversation_state_serialize() {
+        let state = ConversationState::new("conv-123")
+            .with_agent_task_type("vibe")
+            .with_current_message(CurrentMessage::new(UserInputMessage::new(
+                "Hello",
+                "claude-3-5-sonnet",
+            )));
+
+        let json = serde_json::to_string(&state).unwrap();
+        assert!(json.contains("\"conversationId\":\"conv-123\""));
+        assert!(json.contains("\"agentTaskType\":\"vibe\""));
+        assert!(json.contains("\"content\":\"Hello\""));
+    }
+}
diff --git a/src/kiro/model/requests/kiro.rs b/src/kiro/model/requests/kiro.rs
new file mode 100644
index 0000000..4af7066
--- /dev/null
+++ b/src/kiro/model/requests/kiro.rs
@@ -0,0 +1,68 @@
+//! Kiro 请求类型定义
+//!
+//! 定义 Kiro API 的主请求结构
+
+use serde::{Deserialize, Serialize};
+
+use super::conversation::ConversationState;
+
+/// Kiro API 请求
+///
+/// 用于构建发送给 Kiro API 的请求
+///
+/// # 示例
+///
+/// ```rust
+/// use kiro_rs::kiro::model::requests::{
+///     KiroRequest, ConversationState, CurrentMessage, UserInputMessage, Tool
+/// };
+///
+/// // 创建简单请求
+/// let state = ConversationState::new("conv-123")
+///     .with_agent_task_type("vibe")
+///     .with_current_message(CurrentMessage::new(
+///         UserInputMessage::new("Hello", "claude-3-5-sonnet")
+///     ));
+///
+/// let request = KiroRequest::new(state);
+/// let json = request.to_json().unwrap();
+/// ```
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct KiroRequest {
+    /// 对话状态
+    pub conversation_state: ConversationState,
+    /// Profile ARN（可选）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub profile_arn: Option<String>,
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_kiro_request_deserialize() {
+        let json = r#"{
+            "conversationState": {
+                "conversationId": "conv-456",
+                "currentMessage": {
+                    "userInputMessage": {
+                        "content": "Test message",
+                        "modelId": "claude-3-5-sonnet",
+                        "userInputMessageContext": {}
+                    }
+                }
+            }
+        }"#;
+
+        let request: KiroRequest = serde_json::from_str(json).unwrap();
+        assert_eq!(request.conversation_state.conversation_id, "conv-456");
+        assert_eq!(
+            request
+                .conversation_state
+                .current_message
+                .user_input_message
+                .content,
+            "Test message"
+        );
+    }
+}
diff --git a/src/kiro/model/requests/mod.rs b/src/kiro/model/requests/mod.rs
new file mode 100644
index 0000000..ec82c6d
--- /dev/null
+++ b/src/kiro/model/requests/mod.rs
@@ -0,0 +1,7 @@
+//! 请求类型模块
+//!
+//! 包含 Kiro API 请求相关的类型定义
+
+pub mod conversation;
+pub mod kiro;
+pub mod tool;
diff --git a/src/kiro/model/requests/tool.rs b/src/kiro/model/requests/tool.rs
new file mode 100644
index 0000000..c251d61
--- /dev/null
+++ b/src/kiro/model/requests/tool.rs
@@ -0,0 +1,192 @@
+//! 工具类型定义
+//!
+//! 定义 Kiro API 中工具相关的类型
+
+use serde::{Deserialize, Serialize};
+
+/// 工具定义
+///
+/// 用于在请求中定义可用的工具
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Tool {
+    /// 工具规范
+    pub tool_specification: ToolSpecification,
+}
+
+/// 工具规范
+///
+/// 定义工具的名称、描述和输入模式
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolSpecification {
+    /// 工具名称
+    pub name: String,
+    /// 工具描述
+    pub description: String,
+    /// 输入模式（JSON Schema）
+    pub input_schema: InputSchema,
+}
+
+/// 输入模式
+///
+/// 包装 JSON Schema 定义
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InputSchema {
+    /// JSON Schema 定义
+    pub json: serde_json::Value,
+}
+
+impl Default for InputSchema {
+    fn default() -> Self {
+        Self {
+            json: serde_json::json!({
+                "type": "object",
+                "properties": {}
+            }),
+        }
+    }
+}
+
+impl InputSchema {
+    /// 从 JSON 值创建
+    pub fn from_json(json: serde_json::Value) -> Self {
+        Self { json }
+    }
+}
+
+/// 工具执行结果
+///
+/// 用于返回工具执行的结果
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolResult {
+    /// 工具使用 ID（与请求中的 tool_use_id 对应）
+    pub tool_use_id: String,
+    /// 结果内容（数组格式）
+    pub content: Vec<serde_json::Map<String, serde_json::Value>>,
+    /// 执行状态（"success" 或 "error"）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    /// 是否为错误
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub is_error: bool,
+}
+
+fn is_false(b: &bool) -> bool {
+    !*b
+}
+
+impl ToolResult {
+    /// 创建成功的工具结果
+    pub fn success(tool_use_id: impl Into<String>, content: impl Into<String>) -> Self {
+        let mut map = serde_json::Map::new();
+        map.insert(
+            "text".to_string(),
+            serde_json::Value::String(content.into()),
+        );
+
+        Self {
+            tool_use_id: tool_use_id.into(),
+            content: vec![map],
+            status: Some("success".to_string()),
+            is_error: false,
+        }
+    }
+
+    /// 创建错误的工具结果
+    pub fn error(tool_use_id: impl Into<String>, error_message: impl Into<String>) -> Self {
+        let mut map = serde_json::Map::new();
+        map.insert(
+            "text".to_string(),
+            serde_json::Value::String(error_message.into()),
+        );
+
+        Self {
+            tool_use_id: tool_use_id.into(),
+            content: vec![map],
+            status: Some("error".to_string()),
+            is_error: true,
+        }
+    }
+}
+
+/// 工具使用条目
+///
+/// 用于历史消息中记录工具调用
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolUseEntry {
+    /// 工具使用 ID
+    pub tool_use_id: String,
+    /// 工具名称
+    pub name: String,
+    /// 工具输入参数
+    pub input: serde_json::Value,
+}
+
+impl ToolUseEntry {
+    /// 创建新的工具使用条目
+    pub fn new(tool_use_id: impl Into<String>, name: impl Into<String>) -> Self {
+        Self {
+            tool_use_id: tool_use_id.into(),
+            name: name.into(),
+            input: serde_json::json!({}),
+        }
+    }
+
+    /// 设置输入参数
+    pub fn with_input(mut self, input: serde_json::Value) -> Self {
+        self.input = input;
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tool_result_success() {
+        let result = ToolResult::success("tool-123", "Operation completed");
+
+        assert!(!result.is_error);
+        assert_eq!(result.status, Some("success".to_string()));
+    }
+
+    #[test]
+    fn test_tool_result_error() {
+        let result = ToolResult::error("tool-456", "File not found");
+
+        assert!(result.is_error);
+        assert_eq!(result.status, Some("error".to_string()));
+    }
+
+    #[test]
+    fn test_tool_result_serialize() {
+        let result = ToolResult::success("tool-789", "Done");
+        let json = serde_json::to_string(&result).unwrap();
+
+        assert!(json.contains("\"toolUseId\":\"tool-789\""));
+        assert!(json.contains("\"status\":\"success\""));
+        // is_error = false 应该被跳过
+        assert!(!json.contains("isError"));
+    }
+
+    #[test]
+    fn test_tool_use_entry() {
+        let entry = ToolUseEntry::new("use-123", "read_file")
+            .with_input(serde_json::json!({"path": "/test.txt"}));
+
+        let json = serde_json::to_string(&entry).unwrap();
+        assert!(json.contains("\"toolUseId\":\"use-123\""));
+        assert!(json.contains("\"name\":\"read_file\""));
+        assert!(json.contains("\"path\":\"/test.txt\""));
+    }
+
+    #[test]
+    fn test_input_schema_default() {
+        let schema = InputSchema::default();
+        assert_eq!(schema.json["type"], "object");
+    }
+}
diff --git a/src/kiro/model/token_refresh.rs b/src/kiro/model/token_refresh.rs
new file mode 100644
index 0000000..4a3846b
--- /dev/null
+++ b/src/kiro/model/token_refresh.rs
@@ -0,0 +1,44 @@
+use serde::{Deserialize, Serialize};
+
+/// 刷新 Token 的请求体 (Social 认证)
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RefreshRequest {
+    pub refresh_token: String,
+}
+
+/// 刷新 Token 的响应体 (Social 认证)
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RefreshResponse {
+    pub access_token: String,
+    #[serde(default)]
+    pub refresh_token: Option<String>,
+    #[serde(default)]
+    pub profile_arn: Option<String>,
+    #[serde(default)]
+    pub expires_in: Option<i64>,
+}
+
+/// IdC Token 刷新请求体 (AWS SSO OIDC)
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IdcRefreshRequest {
+    pub client_id: String,
+    pub client_secret: String,
+    pub refresh_token: String,
+    pub grant_type: String,
+}
+
+/// IdC Token 刷新响应体 (AWS SSO OIDC)
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IdcRefreshResponse {
+    pub access_token: String,
+    #[serde(default)]
+    pub refresh_token: Option<String>,
+    // #[serde(default)]
+    // pub token_type: Option<String>,
+    #[serde(default)]
+    pub expires_in: Option<i64>,
+}
diff --git a/src/kiro/model/usage_limits.rs b/src/kiro/model/usage_limits.rs
new file mode 100644
index 0000000..0ffc7e9
--- /dev/null
+++ b/src/kiro/model/usage_limits.rs
@@ -0,0 +1,213 @@
+//! 使用额度查询数据模型
+//!
+//! 包含 getUsageLimits API 的响应类型定义
+
+use serde::Deserialize;
+
+/// 使用额度查询响应
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UsageLimitsResponse {
+    /// 下次重置日期 (Unix 时间戳)
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub next_date_reset: Option<f64>,
+
+    /// 订阅信息
+    #[serde(default)]
+    pub subscription_info: Option<SubscriptionInfo>,
+
+    /// 使用量明细列表
+    #[serde(default)]
+    pub usage_breakdown_list: Vec<UsageBreakdown>,
+}
+
+/// 订阅信息
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SubscriptionInfo {
+    /// 订阅标题 (KIRO PRO+ / KIRO FREE 等)
+    #[serde(default)]
+    pub subscription_title: Option<String>,
+}
+
+/// 使用量明细
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UsageBreakdown {
+    /// 当前使用量
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub current_usage: i64,
+
+    /// 当前使用量（精确值）
+    #[serde(default)]
+    pub current_usage_with_precision: f64,
+
+    /// 奖励额度列表（可能为 null）
+    #[serde(default)]
+    pub bonuses: Option<Vec<Bonus>>,
+
+    /// 免费试用信息
+    #[serde(default)]
+    pub free_trial_info: Option<FreeTrialInfo>,
+
+    /// 下次重置日期 (Unix 时间戳)
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub next_date_reset: Option<f64>,
+
+    /// 使用限额
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub usage_limit: i64,
+
+    /// 使用限额（精确值）
+    #[serde(default)]
+    pub usage_limit_with_precision: f64,
+}
+
+/// 奖励额度
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Bonus {
+    /// 当前使用量
+    #[serde(default)]
+    pub current_usage: f64,
+
+    /// 使用限额
+    #[serde(default)]
+    pub usage_limit: f64,
+
+    /// 状态 (ACTIVE / EXPIRED)
+    #[serde(default)]
+    pub status: Option<String>,
+}
+
+impl Bonus {
+    /// 检查 bonus 是否处于激活状态（大小写不敏感）
+    pub fn is_active(&self) -> bool {
+        self.status
+            .as_deref()
+            .map(|s| s.eq_ignore_ascii_case("ACTIVE"))
+            .unwrap_or(false)
+    }
+}
+
+/// 免费试用信息
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FreeTrialInfo {
+    /// 当前使用量
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub current_usage: i64,
+
+    /// 当前使用量（精确值）
+    #[serde(default)]
+    pub current_usage_with_precision: f64,
+
+    /// 免费试用过期时间 (Unix 时间戳)
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub free_trial_expiry: Option<f64>,
+
+    /// 免费试用状态 (ACTIVE / EXPIRED)
+    #[serde(default)]
+    pub free_trial_status: Option<String>,
+
+    /// 使用限额
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub usage_limit: i64,
+
+    /// 使用限额（精确值）
+    #[serde(default)]
+    pub usage_limit_with_precision: f64,
+}
+
+// ============ 便捷方法实现 ============
+
+impl FreeTrialInfo {
+    /// 检查免费试用是否处于激活状态
+    pub fn is_active(&self) -> bool {
+        self.free_trial_status
+            .as_deref()
+            .map(|s| s == "ACTIVE")
+            .unwrap_or(false)
+    }
+}
+
+impl UsageLimitsResponse {
+    /// 获取订阅标题
+    pub fn subscription_title(&self) -> Option<&str> {
+        self.subscription_info
+            .as_ref()
+            .and_then(|info| info.subscription_title.as_deref())
+    }
+
+    /// 获取第一个使用量明细
+    fn primary_breakdown(&self) -> Option<&UsageBreakdown> {
+        self.usage_breakdown_list.first()
+    }
+
+    /// 获取总使用限额（精确值）
+    ///
+    /// 累加基础额度、激活的免费试用额度和激活的奖励额度
+    #[allow(clippy::collapsible_if)]
+    pub fn usage_limit(&self) -> f64 {
+        let Some(breakdown) = self.primary_breakdown() else {
+            return 0.0;
+        };
+
+        let mut total = breakdown.usage_limit_with_precision;
+
+        // 累加激活的 free trial 额度
+        if let Some(trial) = &breakdown.free_trial_info {
+            if trial.is_active() {
+                total += trial.usage_limit_with_precision;
+            }
+        }
+
+        // 累加激活的 bonus 额度
+        if let Some(bonuses) = &breakdown.bonuses {
+            for bonus in bonuses {
+                if bonus.is_active() {
+                    total += bonus.usage_limit;
+                }
+            }
+        }
+
+        total
+    }
+
+    /// 获取总当前使用量（精确值）
+    ///
+    /// 累加基础使用量、激活的免费试用使用量和激活的奖励使用量
+    #[allow(clippy::collapsible_if)]
+    pub fn current_usage(&self) -> f64 {
+        let Some(breakdown) = self.primary_breakdown() else {
+            return 0.0;
+        };
+
+        let mut total = breakdown.current_usage_with_precision;
+
+        // 累加激活的 free trial 使用量
+        if let Some(trial) = &breakdown.free_trial_info {
+            if trial.is_active() {
+                total += trial.current_usage_with_precision;
+            }
+        }
+
+        // 累加激活的 bonus 使用量
+        if let Some(bonuses) = &breakdown.bonuses {
+            for bonus in bonuses {
+                if bonus.is_active() {
+                    total += bonus.current_usage;
+                }
+            }
+        }
+
+        total
+    }
+}
diff --git a/src/kiro/parser/crc.rs b/src/kiro/parser/crc.rs
new file mode 100644
index 0000000..03f47f4
--- /dev/null
+++ b/src/kiro/parser/crc.rs
@@ -0,0 +1,37 @@
+//! CRC32 校验实现
+//!
+//! AWS Event Stream 使用 CRC32 (ISO-HDLC/以太网/ZIP 标准)
+
+use crc::{CRC_32_ISO_HDLC, Crc};
+
+/// CRC32 计算器实例 (ISO-HDLC 标准，多项式 0xEDB88320)
+const CRC32: Crc<u32> = Crc::<u32>::new(&CRC_32_ISO_HDLC);
+
+/// 计算 CRC32 校验和 (ISO-HDLC 标准)
+///
+/// # Arguments
+/// * `data` - 要计算校验和的数据
+///
+/// # Returns
+/// CRC32 校验和值
+pub fn crc32(data: &[u8]) -> u32 {
+    CRC32.checksum(data)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_crc32_empty() {
+        // 空数据的 CRC32 应该是 0
+        assert_eq!(crc32(&[]), 0);
+    }
+
+    #[test]
+    fn test_crc32_known_value() {
+        // "123456789" 的 CRC32 (ISO-HDLC) 值是 0xCBF43926
+        let data = b"123456789";
+        assert_eq!(crc32(data), 0xCBF43926);
+    }
+}
diff --git a/src/kiro/parser/decoder.rs b/src/kiro/parser/decoder.rs
new file mode 100644
index 0000000..5baf132
--- /dev/null
+++ b/src/kiro/parser/decoder.rs
@@ -0,0 +1,476 @@
+//! AWS Event Stream 流式解码器
+//!
+//! 使用状态机处理流式数据，支持断点续传和容错处理
+//!
+//! ## 状态机设计
+//!
+//! 参考 kiro-kt 项目的状态机设计，采用四态模型：
+//!
+//! ```text
+//! ┌─────────────────┐
+//! │      Ready      │  (初始态，就绪接收数据)
+//! └────────┬────────┘
+//!          │ feed() 提供数据
+//!          ↓
+//! ┌─────────────────┐
+//! │     Parsing     │  decode() 尝试解析
+//! └────────┬────────┘
+//!          │
+//!     ┌────┴────────────┐
+//!     ↓                 ↓
+//!  [成功]            [失败]
+//!     │                 │
+//!     ↓                 ├─> error_count++
+//! ┌─────────┐           │
+//! │  Ready  │           ├─> error_count < max_errors?
+//! └─────────┘           │    YES → Recovering → Ready
+//!                       │    NO  ↓
+//!                  ┌────────────┐
+//!                  │   Stopped  │ (终止态)
+//!                  └────────────┘
+//! ```
+
+use super::error::{ParseError, ParseResult};
+use super::frame::{Frame, PRELUDE_SIZE, parse_frame};
+use bytes::{Buf, BytesMut};
+
+/// 默认最大缓冲区大小 (16 MB)
+pub const DEFAULT_MAX_BUFFER_SIZE: usize = 16 * 1024 * 1024;
+
+/// 默认最大连续错误数
+pub const DEFAULT_MAX_ERRORS: usize = 5;
+
+/// 默认初始缓冲区容量
+pub const DEFAULT_BUFFER_CAPACITY: usize = 8192;
+
+/// 解码器状态
+///
+/// 采用四态模型，参考 kiro-kt 的设计：
+/// - Ready: 就绪状态，可以接收数据
+/// - Parsing: 正在解析帧
+/// - Recovering: 恢复中（尝试跳过损坏数据）
+/// - Stopped: 已停止（错误过多，终止态）
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DecoderState {
+    /// 就绪，可以接收数据
+    Ready,
+    /// 正在解析帧
+    Parsing,
+    /// 恢复中（跳过损坏数据）
+    Recovering,
+    /// 已停止（错误过多）
+    Stopped,
+}
+
+/// 流式事件解码器
+///
+/// 用于从字节流中解析 AWS Event Stream 消息帧
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use kiro_rs::kiro::parser::EventStreamDecoder;
+///
+/// let mut decoder = EventStreamDecoder::new();
+///
+/// // 提供流数据
+/// decoder.feed(chunk)?;
+///
+/// // 解码所有可用帧
+/// for result in decoder.decode_iter() {
+///     match result {
+///         Ok(frame) => println!("Got frame: {:?}", frame.event_type()),
+///         Err(e) => eprintln!("Parse error: {}", e),
+///     }
+/// }
+/// ```
+pub struct EventStreamDecoder {
+    /// 内部缓冲区
+    buffer: BytesMut,
+    /// 当前状态
+    state: DecoderState,
+    /// 已处理的帧数量
+    frames_decoded: usize,
+    /// 连续错误计数
+    error_count: usize,
+    /// 最大连续错误数
+    max_errors: usize,
+    /// 最大缓冲区大小
+    max_buffer_size: usize,
+    /// 跳过的字节数（用于调试）
+    bytes_skipped: usize,
+}
+
+impl Default for EventStreamDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EventStreamDecoder {
+    /// 创建新的解码器
+    pub fn new() -> Self {
+        Self::with_capacity(DEFAULT_BUFFER_CAPACITY)
+    }
+
+    /// 创建具有指定缓冲区大小的解码器
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            buffer: BytesMut::with_capacity(capacity),
+            state: DecoderState::Ready,
+            frames_decoded: 0,
+            error_count: 0,
+            max_errors: DEFAULT_MAX_ERRORS,
+            max_buffer_size: DEFAULT_MAX_BUFFER_SIZE,
+            bytes_skipped: 0,
+        }
+    }
+
+    /// 创建具有自定义配置的解码器
+    #[allow(dead_code)]
+    pub fn with_config(capacity: usize, max_errors: usize, max_buffer_size: usize) -> Self {
+        Self {
+            buffer: BytesMut::with_capacity(capacity),
+            state: DecoderState::Ready,
+            frames_decoded: 0,
+            error_count: 0,
+            max_errors,
+            max_buffer_size,
+            bytes_skipped: 0,
+        }
+    }
+
+    /// 向解码器提供数据
+    ///
+    /// # Returns
+    /// - `Ok(())` - 数据已添加到缓冲区
+    /// - `Err(BufferOverflow)` - 缓冲区已满
+    pub fn feed(&mut self, data: &[u8]) -> ParseResult<()> {
+        // 检查缓冲区大小限制
+        let new_size = self.buffer.len() + data.len();
+        if new_size > self.max_buffer_size {
+            return Err(ParseError::BufferOverflow {
+                size: new_size,
+                max: self.max_buffer_size,
+            });
+        }
+
+        self.buffer.extend_from_slice(data);
+
+        // 从 Recovering 状态恢复到 Ready
+        if self.state == DecoderState::Recovering {
+            self.state = DecoderState::Ready;
+        }
+
+        Ok(())
+    }
+
+    /// 尝试解码下一个帧
+    ///
+    /// # Returns
+    /// - `Ok(Some(frame))` - 成功解码一个帧
+    /// - `Ok(None)` - 数据不足，需要更多数据
+    /// - `Err(e)` - 解码错误
+    pub fn decode(&mut self) -> ParseResult<Option<Frame>> {
+        // 如果已停止，直接返回错误
+        if self.state == DecoderState::Stopped {
+            return Err(ParseError::TooManyErrors {
+                count: self.error_count,
+                last_error: "解码器已停止".to_string(),
+            });
+        }
+
+        // 缓冲区为空，保持 Ready 状态
+        if self.buffer.is_empty() {
+            self.state = DecoderState::Ready;
+            return Ok(None);
+        }
+
+        // 转移到 Parsing 状态
+        self.state = DecoderState::Parsing;
+
+        match parse_frame(&self.buffer) {
+            Ok(Some((frame, consumed))) => {
+                // 成功解析
+                self.buffer.advance(consumed);
+                self.state = DecoderState::Ready;
+                self.frames_decoded += 1;
+                self.error_count = 0; // 重置连续错误计数
+                Ok(Some(frame))
+            }
+            Ok(None) => {
+                // 数据不足，回到 Ready 状态等待更多数据
+                self.state = DecoderState::Ready;
+                Ok(None)
+            }
+            Err(e) => {
+                self.error_count += 1;
+                let error_msg = e.to_string();
+
+                // 检查是否超过最大错误数
+                if self.error_count >= self.max_errors {
+                    self.state = DecoderState::Stopped;
+                    tracing::error!(
+                        "解码器停止: 连续 {} 次错误，最后错误: {}",
+                        self.error_count,
+                        error_msg
+                    );
+                    return Err(ParseError::TooManyErrors {
+                        count: self.error_count,
+                        last_error: error_msg,
+                    });
+                }
+
+                // 根据错误类型采用不同的恢复策略
+                self.try_recover(&e);
+                self.state = DecoderState::Recovering;
+                Err(e)
+            }
+        }
+    }
+
+    /// 创建解码迭代器
+    pub fn decode_iter(&mut self) -> DecodeIter<'_> {
+        DecodeIter { decoder: self }
+    }
+
+    /// 尝试容错恢复
+    ///
+    /// 根据错误类型采用不同的恢复策略（参考 kiro-kt 的设计）：
+    /// - Prelude 阶段错误（CRC 失败、长度异常）：跳过 1 字节，尝试找下一帧边界
+    /// - Data 阶段错误（Message CRC 失败、Header 解析失败）：跳过整个损坏帧
+    fn try_recover(&mut self, error: &ParseError) {
+        if self.buffer.is_empty() {
+            return;
+        }
+
+        match error {
+            // Prelude 阶段错误：可能是帧边界错位，逐字节扫描找下一个有效边界
+            ParseError::PreludeCrcMismatch { .. }
+            | ParseError::MessageTooSmall { .. }
+            | ParseError::MessageTooLarge { .. } => {
+                let skipped_byte = self.buffer[0];
+                self.buffer.advance(1);
+                self.bytes_skipped += 1;
+                tracing::warn!(
+                    "Prelude 错误恢复: 跳过字节 0x{:02x} (累计跳过 {} 字节)",
+                    skipped_byte,
+                    self.bytes_skipped
+                );
+            }
+
+            // Data 阶段错误：帧边界正确但数据损坏，跳过整个帧
+            ParseError::MessageCrcMismatch { .. } | ParseError::HeaderParseFailed(_) => {
+                // 尝试读取 total_length 来跳过整帧
+                if self.buffer.len() >= PRELUDE_SIZE {
+                    let total_length = u32::from_be_bytes([
+                        self.buffer[0],
+                        self.buffer[1],
+                        self.buffer[2],
+                        self.buffer[3],
+                    ]) as usize;
+
+                    // 确保 total_length 合理且缓冲区有足够数据
+                    if total_length >= 16 && total_length <= self.buffer.len() {
+                        tracing::warn!("Data 错误恢复: 跳过损坏帧 ({} 字节)", total_length);
+                        self.buffer.advance(total_length);
+                        self.bytes_skipped += total_length;
+                        return;
+                    }
+                }
+
+                // 无法确定帧长度，回退到逐字节跳过
+                let skipped_byte = self.buffer[0];
+                self.buffer.advance(1);
+                self.bytes_skipped += 1;
+                tracing::warn!(
+                    "Data 错误恢复 (回退): 跳过字节 0x{:02x} (累计跳过 {} 字节)",
+                    skipped_byte,
+                    self.bytes_skipped
+                );
+            }
+
+            // 其他错误：逐字节跳过
+            _ => {
+                let skipped_byte = self.buffer[0];
+                self.buffer.advance(1);
+                self.bytes_skipped += 1;
+                tracing::warn!(
+                    "通用错误恢复: 跳过字节 0x{:02x} (累计跳过 {} 字节)",
+                    skipped_byte,
+                    self.bytes_skipped
+                );
+            }
+        }
+    }
+
+    // ==================== 生命周期管理方法 ====================
+
+    /// 重置解码器到初始状态
+    ///
+    /// 清空缓冲区和所有计数器，恢复到 Ready 状态
+    #[allow(dead_code)]
+    pub fn reset(&mut self) {
+        self.buffer.clear();
+        self.state = DecoderState::Ready;
+        self.frames_decoded = 0;
+        self.error_count = 0;
+        self.bytes_skipped = 0;
+    }
+
+    /// 获取当前状态
+    #[allow(dead_code)]
+    pub fn state(&self) -> DecoderState {
+        self.state
+    }
+
+    /// 检查是否处于 Ready 状态
+    #[allow(dead_code)]
+    pub fn is_ready(&self) -> bool {
+        self.state == DecoderState::Ready
+    }
+
+    /// 检查是否处于 Stopped 状态
+    #[allow(dead_code)]
+    pub fn is_stopped(&self) -> bool {
+        self.state == DecoderState::Stopped
+    }
+
+    /// 检查是否处于 Recovering 状态
+    #[allow(dead_code)]
+    pub fn is_recovering(&self) -> bool {
+        self.state == DecoderState::Recovering
+    }
+
+    /// 获取已解码的帧数量
+    #[allow(dead_code)]
+    pub fn frames_decoded(&self) -> usize {
+        self.frames_decoded
+    }
+
+    /// 获取当前连续错误计数
+    #[allow(dead_code)]
+    pub fn error_count(&self) -> usize {
+        self.error_count
+    }
+
+    /// 获取跳过的字节数
+    #[allow(dead_code)]
+    pub fn bytes_skipped(&self) -> usize {
+        self.bytes_skipped
+    }
+
+    /// 获取缓冲区中待处理的字节数
+    #[allow(dead_code)]
+    pub fn buffer_len(&self) -> usize {
+        self.buffer.len()
+    }
+
+    /// 尝试从 Stopped 状态恢复
+    ///
+    /// 重置错误计数并转移到 Ready 状态
+    /// 注意：缓冲区内容保留，可能仍包含损坏数据
+    #[allow(dead_code)]
+    pub fn try_resume(&mut self) {
+        if self.state == DecoderState::Stopped {
+            self.error_count = 0;
+            self.state = DecoderState::Ready;
+            tracing::info!("解码器从 Stopped 状态恢复");
+        }
+    }
+}
+
+/// 解码迭代器
+pub struct DecodeIter<'a> {
+    decoder: &'a mut EventStreamDecoder,
+}
+
+impl<'a> Iterator for DecodeIter<'a> {
+    type Item = ParseResult<Frame>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // 如果处于 Stopped 或 Recovering 状态，停止迭代
+        match self.decoder.state {
+            DecoderState::Stopped => return None,
+            DecoderState::Recovering => return None,
+            _ => {}
+        }
+
+        match self.decoder.decode() {
+            Ok(Some(frame)) => Some(Ok(frame)),
+            Ok(None) => None,
+            Err(e) => Some(Err(e)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_decoder_new() {
+        let decoder = EventStreamDecoder::new();
+        assert_eq!(decoder.state(), DecoderState::Ready);
+        assert_eq!(decoder.frames_decoded(), 0);
+        assert_eq!(decoder.error_count(), 0);
+    }
+
+    #[test]
+    fn test_decoder_feed() {
+        let mut decoder = EventStreamDecoder::new();
+        assert!(decoder.feed(&[1, 2, 3, 4]).is_ok());
+        assert_eq!(decoder.buffer_len(), 4);
+    }
+
+    #[test]
+    fn test_decoder_buffer_overflow() {
+        let mut decoder = EventStreamDecoder::with_config(1024, 5, 100);
+        let result = decoder.feed(&[0u8; 101]);
+        assert!(matches!(result, Err(ParseError::BufferOverflow { .. })));
+    }
+
+    #[test]
+    fn test_decoder_insufficient_data() {
+        let mut decoder = EventStreamDecoder::new();
+        decoder.feed(&[0u8; 10]).unwrap();
+
+        let result = decoder.decode();
+        assert!(matches!(result, Ok(None)));
+        assert_eq!(decoder.state(), DecoderState::Ready);
+    }
+
+    #[test]
+    fn test_decoder_reset() {
+        let mut decoder = EventStreamDecoder::new();
+        decoder.feed(&[1, 2, 3, 4]).unwrap();
+
+        decoder.reset();
+        assert_eq!(decoder.state(), DecoderState::Ready);
+        assert_eq!(decoder.buffer_len(), 0);
+        assert_eq!(decoder.frames_decoded(), 0);
+    }
+
+    #[test]
+    fn test_decoder_state_transitions() {
+        let decoder = EventStreamDecoder::new();
+
+        // 初始状态
+        assert!(decoder.is_ready());
+        assert!(!decoder.is_stopped());
+        assert!(!decoder.is_recovering());
+    }
+
+    #[test]
+    fn test_decoder_try_resume() {
+        let mut decoder = EventStreamDecoder::new();
+
+        // 手动设置为 Stopped 状态进行测试
+        decoder.state = DecoderState::Stopped;
+        decoder.error_count = 5;
+
+        decoder.try_resume();
+        assert!(decoder.is_ready());
+        assert_eq!(decoder.error_count(), 0);
+    }
+}
diff --git a/src/kiro/parser/error.rs b/src/kiro/parser/error.rs
new file mode 100644
index 0000000..5918a6d
--- /dev/null
+++ b/src/kiro/parser/error.rs
@@ -0,0 +1,94 @@
+//! AWS Event Stream 解析错误定义
+
+use std::fmt;
+
+/// 解析错误类型
+#[derive(Debug)]
+pub enum ParseError {
+    /// 数据不足，需要更多字节
+    Incomplete { needed: usize, available: usize },
+    /// Prelude CRC 校验失败
+    PreludeCrcMismatch { expected: u32, actual: u32 },
+    /// Message CRC 校验失败
+    MessageCrcMismatch { expected: u32, actual: u32 },
+    /// 无效的头部值类型
+    InvalidHeaderType(u8),
+    /// 头部解析错误
+    HeaderParseFailed(String),
+    /// 消息长度超限
+    MessageTooLarge { length: u32, max: u32 },
+    /// 消息长度过小
+    MessageTooSmall { length: u32, min: u32 },
+    /// 无效的消息类型
+    InvalidMessageType(String),
+    /// Payload 反序列化失败
+    PayloadDeserialize(serde_json::Error),
+    /// IO 错误
+    Io(std::io::Error),
+    /// 连续错误过多，解码器已停止
+    TooManyErrors { count: usize, last_error: String },
+    /// 缓冲区溢出
+    BufferOverflow { size: usize, max: usize },
+}
+
+impl std::error::Error for ParseError {}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Incomplete { needed, available } => {
+                write!(f, "数据不足: 需要 {} 字节, 当前 {} 字节", needed, available)
+            }
+            Self::PreludeCrcMismatch { expected, actual } => {
+                write!(
+                    f,
+                    "Prelude CRC 校验失败: 期望 0x{:08x}, 实际 0x{:08x}",
+                    expected, actual
+                )
+            }
+            Self::MessageCrcMismatch { expected, actual } => {
+                write!(
+                    f,
+                    "Message CRC 校验失败: 期望 0x{:08x}, 实际 0x{:08x}",
+                    expected, actual
+                )
+            }
+            Self::InvalidHeaderType(t) => write!(f, "无效的头部值类型: {}", t),
+            Self::HeaderParseFailed(msg) => write!(f, "头部解析失败: {}", msg),
+            Self::MessageTooLarge { length, max } => {
+                write!(f, "消息长度超限: {} 字节 (最大 {})", length, max)
+            }
+            Self::MessageTooSmall { length, min } => {
+                write!(f, "消息长度过小: {} 字节 (最小 {})", length, min)
+            }
+            Self::InvalidMessageType(t) => write!(f, "无效的消息类型: {}", t),
+            Self::PayloadDeserialize(e) => write!(f, "Payload 反序列化失败: {}", e),
+            Self::Io(e) => write!(f, "IO 错误: {}", e),
+            Self::TooManyErrors { count, last_error } => {
+                write!(
+                    f,
+                    "连续错误过多 ({} 次)，解码器已停止: {}",
+                    count, last_error
+                )
+            }
+            Self::BufferOverflow { size, max } => {
+                write!(f, "缓冲区溢出: {} 字节 (最大 {})", size, max)
+            }
+        }
+    }
+}
+
+impl From<std::io::Error> for ParseError {
+    fn from(e: std::io::Error) -> Self {
+        Self::Io(e)
+    }
+}
+
+impl From<serde_json::Error> for ParseError {
+    fn from(e: serde_json::Error) -> Self {
+        Self::PayloadDeserialize(e)
+    }
+}
+
+/// 解析结果类型
+pub type ParseResult<T> = Result<T, ParseError>;
diff --git a/src/kiro/parser/frame.rs b/src/kiro/parser/frame.rs
new file mode 100644
index 0000000..0bf8db8
--- /dev/null
+++ b/src/kiro/parser/frame.rs
@@ -0,0 +1,178 @@
+//! AWS Event Stream 消息帧解析
+//!
+//! ## 消息格式
+//!
+//! ```text
+//! ┌──────────────┬──────────────┬──────────────┬──────────┬──────────┬───────────┐
+//! │ Total Length │ Header Length│ Prelude CRC  │ Headers  │ Payload  │ Msg CRC   │
+//! │   (4 bytes)  │   (4 bytes)  │   (4 bytes)  │ (变长)    │ (变长)    │ (4 bytes) │
+//! └──────────────┴──────────────┴──────────────┴──────────┴──────────┴───────────┘
+//! ```
+//!
+//! - Total Length: 整个消息的总长度（包括自身 4 字节）
+//! - Header Length: 头部数据的长度
+//! - Prelude CRC: 前 8 字节（Total Length + Header Length）的 CRC32 校验
+//! - Headers: 头部数据
+//! - Payload: 载荷数据（通常是 JSON）
+//! - Message CRC: 整个消息（不含 Message CRC 自身）的 CRC32 校验
+
+use super::crc::crc32;
+use super::error::{ParseError, ParseResult};
+use super::header::{Headers, parse_headers};
+
+/// Prelude 固定大小 (12 字节)
+pub const PRELUDE_SIZE: usize = 12;
+
+/// 最小消息大小 (Prelude + Message CRC)
+pub const MIN_MESSAGE_SIZE: usize = PRELUDE_SIZE + 4;
+
+/// 最大消息大小限制 (16 MB)
+pub const MAX_MESSAGE_SIZE: u32 = 16 * 1024 * 1024;
+
+/// 解析后的消息帧
+#[derive(Debug, Clone)]
+pub struct Frame {
+    /// 消息头部
+    pub headers: Headers,
+    /// 消息负载
+    pub payload: Vec<u8>,
+}
+
+impl Frame {
+    /// 获取消息类型
+    pub fn message_type(&self) -> Option<&str> {
+        self.headers.message_type()
+    }
+
+    /// 获取事件类型
+    pub fn event_type(&self) -> Option<&str> {
+        self.headers.event_type()
+    }
+
+    /// 将 payload 解析为 JSON
+    pub fn payload_as_json<T: serde::de::DeserializeOwned>(&self) -> ParseResult<T> {
+        serde_json::from_slice(&self.payload).map_err(ParseError::PayloadDeserialize)
+    }
+
+    /// 将 payload 解析为字符串
+    pub fn payload_as_str(&self) -> String {
+        String::from_utf8_lossy(&self.payload).to_string()
+    }
+}
+
+/// 尝试从缓冲区解析一个完整的帧
+///
+/// 这是一个无状态的纯函数，每次调用独立解析。
+/// 缓冲区管理由上层 `EventStreamDecoder` 负责。
+///
+/// # Arguments
+/// * `buffer` - 输入缓冲区
+///
+/// # Returns
+/// - `Ok(Some((frame, consumed)))` - 成功解析，返回帧和消费的字节数
+/// - `Ok(None)` - 数据不足，需要更多数据
+/// - `Err(e)` - 解析错误
+pub fn parse_frame(buffer: &[u8]) -> ParseResult<Option<(Frame, usize)>> {
+    // 检查是否有足够的数据读取 prelude
+    if buffer.len() < PRELUDE_SIZE {
+        return Ok(None);
+    }
+
+    // 读取 prelude
+    let total_length = u32::from_be_bytes([buffer[0], buffer[1], buffer[2], buffer[3]]);
+    let header_length = u32::from_be_bytes([buffer[4], buffer[5], buffer[6], buffer[7]]);
+    let prelude_crc = u32::from_be_bytes([buffer[8], buffer[9], buffer[10], buffer[11]]);
+
+    // 验证消息长度范围
+    if total_length < MIN_MESSAGE_SIZE as u32 {
+        return Err(ParseError::MessageTooSmall {
+            length: total_length,
+            min: MIN_MESSAGE_SIZE as u32,
+        });
+    }
+
+    if total_length > MAX_MESSAGE_SIZE {
+        return Err(ParseError::MessageTooLarge {
+            length: total_length,
+            max: MAX_MESSAGE_SIZE,
+        });
+    }
+
+    let total_length = total_length as usize;
+    let header_length = header_length as usize;
+
+    // 检查是否有完整的消息
+    if buffer.len() < total_length {
+        return Ok(None);
+    }
+
+    // 验证 Prelude CRC
+    let actual_prelude_crc = crc32(&buffer[..8]);
+    if actual_prelude_crc != prelude_crc {
+        return Err(ParseError::PreludeCrcMismatch {
+            expected: prelude_crc,
+            actual: actual_prelude_crc,
+        });
+    }
+
+    // 读取 Message CRC
+    let message_crc = u32::from_be_bytes([
+        buffer[total_length - 4],
+        buffer[total_length - 3],
+        buffer[total_length - 2],
+        buffer[total_length - 1],
+    ]);
+
+    // 验证 Message CRC (对整个消息不含最后4字节)
+    let actual_message_crc = crc32(&buffer[..total_length - 4]);
+    if actual_message_crc != message_crc {
+        return Err(ParseError::MessageCrcMismatch {
+            expected: message_crc,
+            actual: actual_message_crc,
+        });
+    }
+
+    // 解析头部
+    let headers_start = PRELUDE_SIZE;
+    let headers_end = headers_start + header_length;
+
+    // 验证头部边界
+    if headers_end > total_length - 4 {
+        return Err(ParseError::HeaderParseFailed(
+            "头部长度超出消息边界".to_string(),
+        ));
+    }
+
+    let headers = parse_headers(&buffer[headers_start..headers_end], header_length)?;
+
+    // 提取 payload (去除最后4字节的 message_crc)
+    let payload_start = headers_end;
+    let payload_end = total_length - 4;
+    let payload = buffer[payload_start..payload_end].to_vec();
+
+    Ok(Some((Frame { headers, payload }, total_length)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_frame_insufficient_data() {
+        let buffer = [0u8; 10]; // 小于 PRELUDE_SIZE
+        assert!(matches!(parse_frame(&buffer), Ok(None)));
+    }
+
+    #[test]
+    fn test_frame_message_too_small() {
+        // 构造一个 total_length = 10 的 prelude (小于最小值)
+        let mut buffer = vec![0u8; 16];
+        buffer[0..4].copy_from_slice(&10u32.to_be_bytes()); // total_length
+        buffer[4..8].copy_from_slice(&0u32.to_be_bytes()); // header_length
+        let prelude_crc = crc32(&buffer[0..8]);
+        buffer[8..12].copy_from_slice(&prelude_crc.to_be_bytes());
+
+        let result = parse_frame(&buffer);
+        assert!(matches!(result, Err(ParseError::MessageTooSmall { .. })));
+    }
+}
diff --git a/src/kiro/parser/header.rs b/src/kiro/parser/header.rs
new file mode 100644
index 0000000..449832c
--- /dev/null
+++ b/src/kiro/parser/header.rs
@@ -0,0 +1,317 @@
+//! AWS Event Stream 头部解析
+//!
+//! 实现 AWS Event Stream 协议的头部解析功能
+
+use super::error::{ParseError, ParseResult};
+use std::collections::HashMap;
+
+/// 头部值类型标识
+///
+/// AWS Event Stream 协议定义的 10 种值类型
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum HeaderValueType {
+    BoolTrue = 0,
+    BoolFalse = 1,
+    Byte = 2,
+    Short = 3,
+    Integer = 4,
+    Long = 5,
+    ByteArray = 6,
+    String = 7,
+    Timestamp = 8,
+    Uuid = 9,
+}
+
+impl TryFrom<u8> for HeaderValueType {
+    type Error = ParseError;
+
+    fn try_from(value: u8) -> ParseResult<Self> {
+        match value {
+            0 => Ok(Self::BoolTrue),
+            1 => Ok(Self::BoolFalse),
+            2 => Ok(Self::Byte),
+            3 => Ok(Self::Short),
+            4 => Ok(Self::Integer),
+            5 => Ok(Self::Long),
+            6 => Ok(Self::ByteArray),
+            7 => Ok(Self::String),
+            8 => Ok(Self::Timestamp),
+            9 => Ok(Self::Uuid),
+            _ => Err(ParseError::InvalidHeaderType(value)),
+        }
+    }
+}
+
+/// 头部值
+///
+/// 支持 AWS Event Stream 协议定义的所有值类型
+#[derive(Debug, Clone, PartialEq)]
+pub enum HeaderValue {
+    Bool(bool),
+    Byte(i8),
+    Short(i16),
+    Integer(i32),
+    Long(i64),
+    ByteArray(Vec<u8>),
+    String(String),
+    Timestamp(i64),
+    Uuid([u8; 16]),
+}
+
+impl HeaderValue {
+    /// 尝试获取字符串值
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            Self::String(s) => Some(s),
+            _ => None,
+        }
+    }
+}
+
+/// 消息头部集合
+#[derive(Debug, Clone, Default)]
+pub struct Headers {
+    inner: HashMap<String, HeaderValue>,
+}
+
+impl Headers {
+    /// 创建空的头部集合
+    pub fn new() -> Self {
+        Self {
+            inner: HashMap::new(),
+        }
+    }
+
+    /// 插入头部
+    pub fn insert(&mut self, name: String, value: HeaderValue) {
+        self.inner.insert(name, value);
+    }
+
+    /// 获取头部值
+    pub fn get(&self, name: &str) -> Option<&HeaderValue> {
+        self.inner.get(name)
+    }
+
+    /// 获取字符串类型的头部值
+    pub fn get_string(&self, name: &str) -> Option<&str> {
+        self.get(name).and_then(|v| v.as_str())
+    }
+
+    /// 获取消息类型 (:message-type)
+    pub fn message_type(&self) -> Option<&str> {
+        self.get_string(":message-type")
+    }
+
+    /// 获取事件类型 (:event-type)
+    pub fn event_type(&self) -> Option<&str> {
+        self.get_string(":event-type")
+    }
+
+    /// 获取异常类型 (:exception-type)
+    pub fn exception_type(&self) -> Option<&str> {
+        self.get_string(":exception-type")
+    }
+
+    /// 获取错误代码 (:error-code)
+    pub fn error_code(&self) -> Option<&str> {
+        self.get_string(":error-code")
+    }
+}
+
+/// 从字节流解析头部
+///
+/// # Arguments
+/// * `data` - 头部数据切片
+/// * `header_length` - 头部总长度
+///
+/// # Returns
+/// 解析后的 Headers 结构
+pub fn parse_headers(data: &[u8], header_length: usize) -> ParseResult<Headers> {
+    // 验证数据长度是否足够
+    if data.len() < header_length {
+        return Err(ParseError::Incomplete {
+            needed: header_length,
+            available: data.len(),
+        });
+    }
+
+    let mut headers = Headers::new();
+    let mut offset = 0;
+
+    while offset < header_length {
+        // 读取头部名称长度 (1 byte)
+        if offset >= data.len() {
+            break;
+        }
+        let name_len = data[offset] as usize;
+        offset += 1;
+
+        // 验证名称长度
+        if name_len == 0 {
+            return Err(ParseError::HeaderParseFailed(
+                "头部名称长度不能为 0".to_string(),
+            ));
+        }
+
+        // 读取头部名称
+        if offset + name_len > data.len() {
+            return Err(ParseError::Incomplete {
+                needed: name_len,
+                available: data.len() - offset,
+            });
+        }
+        let name = String::from_utf8_lossy(&data[offset..offset + name_len]).to_string();
+        offset += name_len;
+
+        // 读取值类型 (1 byte)
+        if offset >= data.len() {
+            return Err(ParseError::Incomplete {
+                needed: 1,
+                available: 0,
+            });
+        }
+        let value_type = HeaderValueType::try_from(data[offset])?;
+        offset += 1;
+
+        // 根据类型解析值
+        let value = parse_header_value(&data[offset..], value_type, &mut offset)?;
+        headers.insert(name, value);
+    }
+
+    Ok(headers)
+}
+
+/// 解析头部值
+fn parse_header_value(
+    data: &[u8],
+    value_type: HeaderValueType,
+    global_offset: &mut usize,
+) -> ParseResult<HeaderValue> {
+    let mut local_offset = 0;
+
+    let result = match value_type {
+        HeaderValueType::BoolTrue => Ok(HeaderValue::Bool(true)),
+        HeaderValueType::BoolFalse => Ok(HeaderValue::Bool(false)),
+        HeaderValueType::Byte => {
+            ensure_bytes(data, 1)?;
+            let v = data[0] as i8;
+            local_offset = 1;
+            Ok(HeaderValue::Byte(v))
+        }
+        HeaderValueType::Short => {
+            ensure_bytes(data, 2)?;
+            let v = i16::from_be_bytes([data[0], data[1]]);
+            local_offset = 2;
+            Ok(HeaderValue::Short(v))
+        }
+        HeaderValueType::Integer => {
+            ensure_bytes(data, 4)?;
+            let v = i32::from_be_bytes([data[0], data[1], data[2], data[3]]);
+            local_offset = 4;
+            Ok(HeaderValue::Integer(v))
+        }
+        HeaderValueType::Long => {
+            ensure_bytes(data, 8)?;
+            let v = i64::from_be_bytes([
+                data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
+            ]);
+            local_offset = 8;
+            Ok(HeaderValue::Long(v))
+        }
+        HeaderValueType::Timestamp => {
+            ensure_bytes(data, 8)?;
+            let v = i64::from_be_bytes([
+                data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
+            ]);
+            local_offset = 8;
+            Ok(HeaderValue::Timestamp(v))
+        }
+        HeaderValueType::ByteArray => {
+            ensure_bytes(data, 2)?;
+            let len = u16::from_be_bytes([data[0], data[1]]) as usize;
+            ensure_bytes(data, 2 + len)?;
+            let v = data[2..2 + len].to_vec();
+            local_offset = 2 + len;
+            Ok(HeaderValue::ByteArray(v))
+        }
+        HeaderValueType::String => {
+            ensure_bytes(data, 2)?;
+            let len = u16::from_be_bytes([data[0], data[1]]) as usize;
+            ensure_bytes(data, 2 + len)?;
+            let v = String::from_utf8_lossy(&data[2..2 + len]).to_string();
+            local_offset = 2 + len;
+            Ok(HeaderValue::String(v))
+        }
+        HeaderValueType::Uuid => {
+            ensure_bytes(data, 16)?;
+            let mut uuid = [0u8; 16];
+            uuid.copy_from_slice(&data[..16]);
+            local_offset = 16;
+            Ok(HeaderValue::Uuid(uuid))
+        }
+    };
+
+    *global_offset += local_offset;
+    result
+}
+
+/// 确保有足够的字节
+fn ensure_bytes(data: &[u8], needed: usize) -> ParseResult<()> {
+    if data.len() < needed {
+        Err(ParseError::Incomplete {
+            needed,
+            available: data.len(),
+        })
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_header_value_type_conversion() {
+        assert_eq!(
+            HeaderValueType::try_from(0).unwrap(),
+            HeaderValueType::BoolTrue
+        );
+        assert_eq!(
+            HeaderValueType::try_from(7).unwrap(),
+            HeaderValueType::String
+        );
+        assert!(HeaderValueType::try_from(10).is_err());
+    }
+
+    #[test]
+    fn test_header_value_as_str() {
+        let value = HeaderValue::String("test".to_string());
+        assert_eq!(value.as_str(), Some("test"));
+
+        let value = HeaderValue::Bool(true);
+        assert_eq!(value.as_str(), None);
+    }
+
+    #[test]
+    fn test_headers_get_string() {
+        let mut headers = Headers::new();
+        headers.insert(
+            ":message-type".to_string(),
+            HeaderValue::String("event".to_string()),
+        );
+        assert_eq!(headers.message_type(), Some("event"));
+    }
+
+    #[test]
+    fn test_parse_headers_string() {
+        // 构造一个简单的头部: name_len(1) + name + type(7=string) + value_len(2) + value
+        // 头部名: "x" (长度 1)
+        // 值类型: 7 (String)
+        // 值: "ab" (长度 2)
+        let data = [1u8, b'x', 7, 0, 2, b'a', b'b'];
+        let headers = parse_headers(&data, data.len()).unwrap();
+        assert_eq!(headers.get_string("x"), Some("ab"));
+    }
+}
diff --git a/src/kiro/parser/mod.rs b/src/kiro/parser/mod.rs
new file mode 100644
index 0000000..d7ab70e
--- /dev/null
+++ b/src/kiro/parser/mod.rs
@@ -0,0 +1,10 @@
+//! AWS Event Stream 解析器
+//!
+//! 提供对 AWS Event Stream 协议的解析支持，
+//! 用于处理 generateAssistantResponse 端点的流式响应
+
+pub mod crc;
+pub mod decoder;
+pub mod error;
+pub mod frame;
+pub mod header;
diff --git a/src/kiro/provider.rs b/src/kiro/provider.rs
new file mode 100644
index 0000000..ae902cc
--- /dev/null
+++ b/src/kiro/provider.rs
@@ -0,0 +1,1335 @@
+//! Kiro API Provider
+//!
+//! 核心组件，负责与 Kiro API 通信
+//! 支持流式和非流式请求
+//! 支持多凭据故障转移和重试
+
+use parking_lot::Mutex;
+use reqwest::Client;
+use reqwest::header::{AUTHORIZATION, CONNECTION, CONTENT_TYPE, HOST, HeaderMap, HeaderValue};
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::sleep;
+use uuid::Uuid;
+
+#[cfg(not(feature = "sensitive-logs"))]
+use crate::common::utf8::floor_char_boundary;
+use crate::http_client::{ProxyConfig, build_client};
+use crate::kiro::machine_id;
+use crate::kiro::model::credentials::KiroCredentials;
+use crate::kiro::token_manager::{CallContext, MultiTokenManager};
+
+/// 每个凭据的最大重试次数
+const MAX_RETRIES_PER_CREDENTIAL: usize = 2;
+
+/// 总重试次数硬上限（避免无限重试）
+const MAX_TOTAL_RETRIES: usize = 3;
+
+/// Kiro API Provider
+///
+/// 核心组件，负责与 Kiro API 通信
+/// 支持多凭据故障转移和重试机制
+pub struct KiroProvider {
+    token_manager: Arc<MultiTokenManager>,
+    /// 默认 client（无代理或全局代理）
+    default_client: Client,
+    /// 全局代理配置
+    global_proxy: Option<ProxyConfig>,
+    /// 凭据级代理 client 缓存（key: credential_id）
+    client_cache: Mutex<HashMap<u64, Client>>,
+}
+
+impl KiroProvider {
+    /// 创建新的 KiroProvider 实例
+    #[allow(dead_code)]
+    pub fn new(token_manager: Arc<MultiTokenManager>) -> Self {
+        Self::with_proxy(token_manager, None)
+    }
+
+    /// 创建带代理配置的 KiroProvider 实例
+    pub fn with_proxy(token_manager: Arc<MultiTokenManager>, proxy: Option<ProxyConfig>) -> Self {
+        let default_client = build_client(proxy.as_ref(), 720, token_manager.config().tls_backend)
+            .expect("创建 HTTP 客户端失败");
+
+        Self {
+            token_manager,
+            default_client,
+            global_proxy: proxy,
+            client_cache: Mutex::new(HashMap::new()),
+        }
+    }
+
+    /// 获取凭据对应的 HTTP Client
+    ///
+    /// 优先使用凭据级代理，否则使用默认 client
+    fn get_client_for_credential(&self, ctx: &CallContext) -> Client {
+        let effective_proxy = ctx.credentials.effective_proxy(self.global_proxy.as_ref());
+
+        // 如果凭据代理与全局代理相同，使用默认 client
+        if effective_proxy == self.global_proxy {
+            return self.default_client.clone();
+        }
+
+        // 检查缓存
+        {
+            let cache = self.client_cache.lock();
+            if let Some(client) = cache.get(&ctx.id) {
+                return client.clone();
+            }
+        }
+
+        // 创建新 client 并缓存
+        let client = build_client(
+            effective_proxy.as_ref(),
+            720,
+            self.token_manager.config().tls_backend,
+        )
+        .unwrap_or_else(|e| {
+            tracing::warn!("创建凭据级代理 client 失败，使用默认 client: {}", e);
+            self.default_client.clone()
+        });
+
+        {
+            let mut cache = self.client_cache.lock();
+            cache.insert(ctx.id, client.clone());
+        }
+
+        client
+    }
+
+    /// 获取 token_manager 的引用
+    #[allow(dead_code)]
+    pub fn token_manager(&self) -> &MultiTokenManager {
+        &self.token_manager
+    }
+
+    /// 获取 API 基础 URL（使用凭据级 effective_api_region）
+    fn base_url(&self, credentials: &KiroCredentials) -> String {
+        format!(
+            "https://q.{}.amazonaws.com/generateAssistantResponse",
+            credentials.effective_api_region(self.token_manager.config())
+        )
+    }
+
+    /// 获取 MCP API URL（使用凭据级 effective_api_region）
+    fn mcp_url(&self, credentials: &KiroCredentials) -> String {
+        format!(
+            "https://q.{}.amazonaws.com/mcp",
+            credentials.effective_api_region(self.token_manager.config())
+        )
+    }
+
+    /// 获取 API 基础域名（使用凭据级 effective_api_region）
+    fn base_domain(&self, credentials: &KiroCredentials) -> String {
+        format!(
+            "q.{}.amazonaws.com",
+            credentials.effective_api_region(self.token_manager.config())
+        )
+    }
+
+    /// 后台异步刷新余额缓存（如果需要）
+    fn spawn_balance_refresh(&self, id: u64) {
+        // 检查缓存是否需要刷新
+        if !self.token_manager.should_refresh_balance(id) {
+            return;
+        }
+        let tm = Arc::clone(&self.token_manager);
+        tokio::spawn(async move {
+            match tm.get_usage_limits_for(id).await {
+                Ok(resp) => {
+                    let remaining = resp.usage_limit() - resp.current_usage();
+                    tm.update_balance_cache(id, remaining);
+                    tracing::debug!("凭据 #{} 余额缓存已刷新: {:.2}", id, remaining);
+                    if remaining < 1.0 {
+                        tm.mark_insufficient_balance(id);
+                        tracing::warn!("凭据 #{} 余额不足 ({:.2})，已主动禁用", id, remaining);
+                    }
+                }
+                Err(e) => {
+                    tracing::warn!("凭据 #{} 余额刷新失败: {}", id, e);
+                }
+            }
+        });
+    }
+
+    /// 构建请求头
+    ///
+    /// # Arguments
+    /// * `ctx` - API 调用上下文，包含凭据和 token
+    fn build_headers(&self, ctx: &CallContext) -> anyhow::Result<HeaderMap> {
+        let config = self.token_manager.config();
+
+        let machine_id = machine_id::generate_from_credentials(&ctx.credentials, config)
+            .ok_or_else(|| anyhow::anyhow!("无法生成 machine_id，请检查凭证配置"))?;
+
+        let kiro_version = &config.kiro_version;
+        let os_name = &config.system_version;
+        let node_version = &config.node_version;
+
+        let x_amz_user_agent = format!("aws-sdk-js/1.0.27 KiroIDE-{}-{}", kiro_version, machine_id);
+
+        let user_agent = format!(
+            "aws-sdk-js/1.0.27 ua/2.1 os/{} lang/js md/nodejs#{} api/codewhispererstreaming#1.0.27 m/E KiroIDE-{}-{}",
+            os_name, node_version, kiro_version, machine_id
+        );
+
+        let mut headers = HeaderMap::new();
+
+        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+        headers.insert(
+            "x-amzn-codewhisperer-optout",
+            HeaderValue::from_static("true"),
+        );
+        headers.insert("x-amzn-kiro-agent-mode", HeaderValue::from_static("vibe"));
+        headers.insert(
+            "x-amz-user-agent",
+            HeaderValue::from_str(&x_amz_user_agent)?,
+        );
+        headers.insert(
+            reqwest::header::USER_AGENT,
+            HeaderValue::from_str(&user_agent)?,
+        );
+        headers.insert(
+            HOST,
+            HeaderValue::from_str(&self.base_domain(&ctx.credentials))?,
+        );
+        headers.insert(
+            "amz-sdk-invocation-id",
+            HeaderValue::from_str(&Uuid::new_v4().to_string())?,
+        );
+        headers.insert(
+            "amz-sdk-request",
+            HeaderValue::from_static("attempt=1; max=3"),
+        );
+        headers.insert(
+            AUTHORIZATION,
+            HeaderValue::from_str(&format!("Bearer {}", ctx.token))?,
+        );
+        headers.insert(CONNECTION, HeaderValue::from_static("close"));
+
+        Ok(headers)
+    }
+
+    /// 构建 MCP 请求头
+    fn build_mcp_headers(&self, ctx: &CallContext) -> anyhow::Result<HeaderMap> {
+        let config = self.token_manager.config();
+
+        let machine_id = machine_id::generate_from_credentials(&ctx.credentials, config)
+            .ok_or_else(|| anyhow::anyhow!("无法生成 machine_id，请检查凭证配置"))?;
+
+        let kiro_version = &config.kiro_version;
+        let os_name = &config.system_version;
+        let node_version = &config.node_version;
+
+        let x_amz_user_agent = format!("aws-sdk-js/1.0.27 KiroIDE-{}-{}", kiro_version, machine_id);
+
+        let user_agent = format!(
+            "aws-sdk-js/1.0.27 ua/2.1 os/{} lang/js md/nodejs#{} api/codewhispererstreaming#1.0.27 m/E KiroIDE-{}-{}",
+            os_name, node_version, kiro_version, machine_id
+        );
+
+        let mut headers = HeaderMap::new();
+
+        // 按照严格顺序添加请求头
+        headers.insert("content-type", HeaderValue::from_static("application/json"));
+        headers.insert(
+            "x-amz-user-agent",
+            HeaderValue::from_str(&x_amz_user_agent)?,
+        );
+        headers.insert("user-agent", HeaderValue::from_str(&user_agent)?);
+        headers.insert(
+            "host",
+            HeaderValue::from_str(&self.base_domain(&ctx.credentials))?,
+        );
+
+        headers.insert(
+            "amz-sdk-invocation-id",
+            HeaderValue::from_str(&Uuid::new_v4().to_string())?,
+        );
+        headers.insert(
+            "amz-sdk-request",
+            HeaderValue::from_static("attempt=1; max=3"),
+        );
+        headers.insert(
+            "Authorization",
+            HeaderValue::from_str(&format!("Bearer {}", ctx.token))?,
+        );
+        headers.insert("Connection", HeaderValue::from_static("close"));
+
+        Ok(headers)
+    }
+
+    /// 发送非流式 API 请求
+    ///
+    /// 支持多凭据故障转移：
+    /// - 400 Bad Request: 直接返回错误，不计入凭据失败
+    /// - 401/403: 视为凭据/权限问题，计入失败次数并允许故障转移
+    /// - 402 MONTHLY_REQUEST_COUNT: 视为额度用尽，禁用凭据并切换
+    /// - 429/5xx/网络等瞬态错误: 重试但不禁用或切换凭据（避免误把所有凭据锁死）
+    ///
+    /// # Arguments
+    /// * `request_body` - JSON 格式的请求体字符串
+    ///
+    /// # Returns
+    /// 返回原始的 HTTP Response，不做解析
+    pub async fn call_api(
+        &self,
+        request_body: &str,
+        user_id: Option<&str>,
+    ) -> anyhow::Result<reqwest::Response> {
+        self.call_api_with_retry(request_body, false, user_id).await
+    }
+
+    /// 发送流式 API 请求
+    ///
+    /// 支持多凭据故障转移：
+    /// - 400 Bad Request: 直接返回错误，不计入凭据失败
+    /// - 401/403: 视为凭据/权限问题，计入失败次数并允许故障转移
+    /// - 402 MONTHLY_REQUEST_COUNT: 视为额度用尽，禁用凭据并切换
+    /// - 429/5xx/网络等瞬态错误: 重试但不禁用或切换凭据（避免误把所有凭据锁死）
+    ///
+    /// # Arguments
+    /// * `request_body` - JSON 格式的请求体字符串
+    ///
+    /// # Returns
+    /// 返回原始的 HTTP Response，调用方负责处理流式数据
+    pub async fn call_api_stream(
+        &self,
+        request_body: &str,
+        user_id: Option<&str>,
+    ) -> anyhow::Result<reqwest::Response> {
+        self.call_api_with_retry(request_body, true, user_id).await
+    }
+
+    /// 发送 MCP API 请求
+    ///
+    /// 用于 WebSearch 等工具调用
+    ///
+    /// # Arguments
+    /// * `request_body` - JSON 格式的 MCP 请求体字符串
+    ///
+    /// # Returns
+    /// 返回原始的 HTTP Response
+    pub async fn call_mcp(&self, request_body: &str) -> anyhow::Result<reqwest::Response> {
+        self.call_mcp_with_retry(request_body).await
+    }
+
+    /// 内部方法：带重试逻辑的 MCP API 调用
+    async fn call_mcp_with_retry(&self, request_body: &str) -> anyhow::Result<reqwest::Response> {
+        let total_credentials = self.token_manager.total_count();
+        let max_retries = (total_credentials * MAX_RETRIES_PER_CREDENTIAL).min(MAX_TOTAL_RETRIES);
+        let mut last_error: Option<anyhow::Error> = None;
+        let mut forced_token_refresh: HashSet<u64> = HashSet::new();
+
+        for attempt in 0..max_retries {
+            // 获取调用上下文
+            let ctx = match self.token_manager.acquire_context().await {
+                Ok(c) => c,
+                Err(e) => {
+                    last_error = Some(e);
+                    continue;
+                }
+            };
+
+            let url = self.mcp_url(&ctx.credentials);
+            let headers = match self.build_mcp_headers(&ctx) {
+                Ok(h) => h,
+                Err(e) => {
+                    last_error = Some(e);
+                    continue;
+                }
+            };
+            // 克隆 headers 用于错误日志（原 headers 会被 move）
+            #[cfg(feature = "sensitive-logs")]
+            let headers_for_log = headers.clone();
+
+            // 获取凭据对应的 client（支持凭据级代理）
+            let client = self.get_client_for_credential(&ctx);
+
+            // 发送请求
+            let response = match client
+                .post(&url)
+                .headers(headers)
+                .body(request_body.to_string())
+                .send()
+                .await
+            {
+                Ok(resp) => resp,
+                Err(e) => {
+                    tracing::warn!(
+                        "MCP 请求发送失败（尝试 {}/{}）: {}",
+                        attempt + 1,
+                        max_retries,
+                        e
+                    );
+                    last_error = Some(e.into());
+                    if attempt + 1 < max_retries {
+                        sleep(Self::retry_delay(attempt)).await;
+                    }
+                    continue;
+                }
+            };
+
+            let status = response.status();
+
+            // 成功响应
+            if status.is_success() {
+                self.token_manager.report_success(ctx.id);
+                return Ok(response);
+            }
+
+            // 失败响应
+            let body = response.text().await.unwrap_or_default();
+
+            // 402 额度用尽
+            if status.as_u16() == 402 && Self::is_monthly_request_limit(&body) {
+                let has_available = self.token_manager.report_quota_exhausted(ctx.id);
+                if !has_available {
+                    anyhow::bail!("MCP 请求失败（所有凭据已用尽）: {} {}", status, body);
+                }
+                last_error = Some(anyhow::anyhow!("MCP 请求失败: {} {}", status, body));
+                continue;
+            }
+
+            // 400 Bad Request
+            if status.as_u16() == 400 {
+                let is_too_long = Self::is_input_too_long(&body);
+                // 输入过长错误：只记录请求体大小，不输出完整内容（太占空间且无调试价值）
+                if is_too_long {
+                    let body_bytes = request_body.len();
+                    let estimated_tokens = Self::estimate_tokens(request_body);
+                    tracing::error!(
+                        status = %status,
+                        response_body_bytes = body.len(),
+                        request_url = %url,
+                        request_body_bytes = body_bytes,
+                        estimated_input_tokens = estimated_tokens,
+                        "MCP 400 Bad Request - 输入上下文过长"
+                    );
+                } else {
+                    // 其他 400 错误：记录请求信息以便调试
+                    #[cfg(feature = "sensitive-logs")]
+                    tracing::error!(
+                        status = %status,
+                        response_body = %body,
+                        request_url = %url,
+                        request_headers = %Self::format_headers_for_log(&headers_for_log),
+                        request_body = %Self::truncate_body_for_log(request_body, 1200),
+                        "MCP 400 Bad Request - 请求格式错误"
+                    );
+                    #[cfg(not(feature = "sensitive-logs"))]
+                    tracing::error!(
+                        status = %status,
+                        response_body_bytes = body.len(),
+                        request_url = %url,
+                        request_body_bytes = request_body.len(),
+                        "MCP 400 Bad Request - 请求格式错误"
+                    );
+                }
+                #[cfg(feature = "sensitive-logs")]
+                anyhow::bail!("MCP 请求失败: {} {}", status, body);
+                #[cfg(not(feature = "sensitive-logs"))]
+                {
+                    if is_too_long {
+                        let body_bytes = request_body.len();
+                        let estimated_tokens = Self::estimate_tokens(request_body);
+                        anyhow::bail!(
+                            "MCP 请求失败: {} Input is too long. (request_body_bytes={}, estimated_input_tokens={})",
+                            status,
+                            body_bytes,
+                            estimated_tokens
+                        );
+                    }
+
+                    let summary = Self::summarize_error_body(&body);
+                    anyhow::bail!("MCP 请求失败: {} {}", status, summary);
+                }
+            }
+
+            // 401/403 凭据问题
+            if matches!(status.as_u16(), 401 | 403) {
+                // bearer token 失效：优先触发刷新再重试（避免因 expiresAt 不准导致误判/误禁用）
+                if Self::is_invalid_bearer_token(&body) && forced_token_refresh.insert(ctx.id) {
+                    tracing::warn!(
+                        "MCP 请求失败（Bearer token 无效，触发刷新后重试，尝试 {}/{}）: {} {}",
+                        attempt + 1,
+                        max_retries,
+                        status,
+                        body
+                    );
+                    self.token_manager.invalidate_access_token(ctx.id);
+                    last_error = Some(anyhow::anyhow!("MCP 请求失败: {} {}", status, body));
+                    continue;
+                }
+
+                let has_available = self.token_manager.report_failure(ctx.id);
+                if !has_available {
+                    anyhow::bail!("MCP 请求失败（所有凭据已用尽）: {} {}", status, body);
+                }
+                last_error = Some(anyhow::anyhow!("MCP 请求失败: {} {}", status, body));
+                continue;
+            }
+
+            // 瞬态错误
+            if matches!(status.as_u16(), 408 | 429) || status.is_server_error() {
+                tracing::warn!(
+                    "MCP 请求失败（上游瞬态错误，尝试 {}/{}）: {} {}",
+                    attempt + 1,
+                    max_retries,
+                    status,
+                    body
+                );
+
+                // 检测 MODEL_TEMPORARILY_UNAVAILABLE 并触发熔断机制
+                if Self::is_model_temporarily_unavailable(&body)
+                    && self.token_manager.report_model_unavailable()
+                {
+                    // 熔断已触发，所有凭据已禁用，立即返回错误
+                    anyhow::bail!(
+                        "MCP 请求失败（模型暂时不可用，已触发熔断）: {} {}",
+                        status,
+                        body
+                    );
+                }
+
+                last_error = Some(anyhow::anyhow!("MCP 请求失败: {} {}", status, body));
+                if attempt + 1 < max_retries {
+                    sleep(Self::retry_delay(attempt)).await;
+                }
+                continue;
+            }
+
+            // 其他 4xx
+            if status.is_client_error() {
+                anyhow::bail!("MCP 请求失败: {} {}", status, body);
+            }
+
+            // 兜底
+            last_error = Some(anyhow::anyhow!("MCP 请求失败: {} {}", status, body));
+            if attempt + 1 < max_retries {
+                sleep(Self::retry_delay(attempt)).await;
+            }
+        }
+
+        Err(last_error.unwrap_or_else(|| {
+            anyhow::anyhow!("MCP 请求失败：已达到最大重试次数（{}次）", max_retries)
+        }))
+    }
+
+    /// 内部方法：带重试逻辑的 API 调用
+    ///
+    /// 重试策略：
+    /// - 每个凭据最多重试 MAX_RETRIES_PER_CREDENTIAL 次
+    /// - 总重试次数 = min(凭据数量 × 每凭据重试次数, MAX_TOTAL_RETRIES)
+    /// - 硬上限 3 次，避免无限重试
+    async fn call_api_with_retry(
+        &self,
+        request_body: &str,
+        is_stream: bool,
+        user_id: Option<&str>,
+    ) -> anyhow::Result<reqwest::Response> {
+        let total_credentials = self.token_manager.total_count();
+        let max_retries = (total_credentials * MAX_RETRIES_PER_CREDENTIAL).min(MAX_TOTAL_RETRIES);
+        let mut last_error: Option<anyhow::Error> = None;
+        let mut forced_token_refresh: HashSet<u64> = HashSet::new();
+        let api_type = if is_stream { "流式" } else { "非流式" };
+
+        for attempt in 0..max_retries {
+            // 获取调用上下文（绑定 index、credentials、token），支持用户亲和性
+            let ctx = match self.token_manager.acquire_context_for_user(user_id).await {
+                Ok(c) => c,
+                Err(e) => {
+                    last_error = Some(e);
+                    continue;
+                }
+            };
+
+            let url = self.base_url(&ctx.credentials);
+            let headers = match self.build_headers(&ctx) {
+                Ok(h) => h,
+                Err(e) => {
+                    last_error = Some(e);
+                    continue;
+                }
+            };
+            // 克隆 headers 用于错误日志（原 headers 会被 move）
+            #[cfg(feature = "sensitive-logs")]
+            let headers_for_log = headers.clone();
+
+            // 动态注入当前凭据的 profile_arn（修复 IDC 凭据 403 问题）
+            // IDC 凭据的 Token 刷新不返回 profile_arn，需要使用凭据自身的 profile_arn
+            let final_body = match Self::inject_profile_arn(request_body, &ctx.credentials) {
+                Ok(body) => body,
+                Err(e) => {
+                    tracing::warn!("注入 profile_arn 失败，使用原始请求体: {}", e);
+                    request_body.to_string()
+                }
+            };
+            // 克隆 final_body 用于错误日志（原 final_body 会被 move 到 body()）
+            let final_body_for_log = final_body.clone();
+
+            // 获取凭据对应的 client（支持凭据级代理）
+            let client = self.get_client_for_credential(&ctx);
+
+            // 发送请求
+            let response = match client
+                .post(&url)
+                .headers(headers)
+                .body(final_body)
+                .send()
+                .await
+            {
+                Ok(resp) => resp,
+                Err(e) => {
+                    tracing::warn!(
+                        "API 请求发送失败（尝试 {}/{}）: {}",
+                        attempt + 1,
+                        max_retries,
+                        e
+                    );
+                    // 网络错误通常是上游/链路瞬态问题，不应导致"禁用凭据"或"切换凭据"
+                    // （否则一段时间网络抖动会把所有凭据都误禁用，需要重启才能恢复）
+                    last_error = Some(e.into());
+                    if attempt + 1 < max_retries {
+                        sleep(Self::retry_delay(attempt)).await;
+                    }
+                    continue;
+                }
+            };
+
+            let status = response.status();
+
+            // 成功响应
+            if status.is_success() {
+                self.token_manager.report_success(ctx.id);
+                tracing::info!(credential_id = %ctx.id, "API 请求成功");
+                // 后台异步刷新余额缓存
+                self.spawn_balance_refresh(ctx.id);
+                return Ok(response);
+            }
+
+            // 失败响应：读取 body 用于日志/错误信息
+            let body = response.text().await.unwrap_or_default();
+
+            // 402 Payment Required 且额度用尽：禁用凭据并故障转移
+            if status.as_u16() == 402 && Self::is_monthly_request_limit(&body) {
+                tracing::warn!(
+                    "API 请求失败（额度已用尽，禁用凭据并切换，尝试 {}/{}）: {} {}",
+                    attempt + 1,
+                    max_retries,
+                    status,
+                    body
+                );
+
+                let has_available = self.token_manager.report_quota_exhausted(ctx.id);
+                self.token_manager.update_balance_cache(ctx.id, 0.0);
+                if !has_available {
+                    anyhow::bail!(
+                        "{} API 请求失败（所有凭据已用尽）: {} {}",
+                        api_type,
+                        status,
+                        body
+                    );
+                }
+
+                last_error = Some(anyhow::anyhow!(
+                    "{} API 请求失败: {} {}",
+                    api_type,
+                    status,
+                    body
+                ));
+                continue;
+            }
+
+            // 400 Bad Request - 请求问题，重试/切换凭据无意义
+            if status.as_u16() == 400 {
+                let is_too_long = Self::is_input_too_long(&body);
+                // 输入过长错误：只记录请求体大小，不输出完整内容（太占空间且无调试价值）
+                if is_too_long {
+                    let body_bytes = final_body_for_log.len();
+                    let estimated_tokens = Self::estimate_tokens(&final_body_for_log);
+                    tracing::error!(
+                        status = %status,
+                        response_body_bytes = body.len(),
+                        request_url = %url,
+                        request_body_bytes = body_bytes,
+                        estimated_input_tokens = estimated_tokens,
+                        "400 Bad Request - 输入上下文过长"
+                    );
+                } else {
+                    // 其他 400 错误：记录请求信息以便调试
+                    #[cfg(feature = "sensitive-logs")]
+                    tracing::error!(
+                        status = %status,
+                        response_body = %body,
+                        request_url = %url,
+                        request_headers = %Self::format_headers_for_log(&headers_for_log),
+                        request_body = %Self::truncate_body_for_log(&final_body_for_log, 1200),
+                        "400 Bad Request - 请求格式错误"
+                    );
+                    #[cfg(not(feature = "sensitive-logs"))]
+                    tracing::error!(
+                        status = %status,
+                        response_body_bytes = body.len(),
+                        request_url = %url,
+                        request_body_bytes = final_body_for_log.len(),
+                        "400 Bad Request - 请求格式错误"
+                    );
+                }
+                #[cfg(feature = "sensitive-logs")]
+                anyhow::bail!("{} API 请求失败: {} {}", api_type, status, body);
+                #[cfg(not(feature = "sensitive-logs"))]
+                {
+                    // 对用户保留可区分的错误信息（例如 Input is too long），但避免返回过长内容。
+                    if is_too_long {
+                        let body_bytes = final_body_for_log.len();
+                        let estimated_tokens = Self::estimate_tokens(&final_body_for_log);
+                        anyhow::bail!(
+                            "{} API 请求失败: {} Input is too long. (request_body_bytes={}, estimated_input_tokens={})",
+                            api_type,
+                            status,
+                            body_bytes,
+                            estimated_tokens
+                        );
+                    }
+
+                    let summary = Self::summarize_error_body(&body);
+                    anyhow::bail!("{} API 请求失败: {} {}", api_type, status, summary);
+                }
+            }
+
+            // 401/403 - 更可能是凭据/权限问题：计入失败并允许故障转移
+            if matches!(status.as_u16(), 401 | 403) {
+                // bearer token 失效：优先触发刷新再重试（避免因 expiresAt 不准导致误判/误禁用）
+                if Self::is_invalid_bearer_token(&body) && forced_token_refresh.insert(ctx.id) {
+                    tracing::warn!(
+                        "API 请求失败（Bearer token 无效，触发刷新后重试，尝试 {}/{}）: {} {}",
+                        attempt + 1,
+                        max_retries,
+                        status,
+                        body
+                    );
+                    self.token_manager.invalidate_access_token(ctx.id);
+                    last_error = Some(anyhow::anyhow!(
+                        "{} API 请求失败: {} {}",
+                        api_type,
+                        status,
+                        body
+                    ));
+                    continue;
+                }
+
+                tracing::warn!(
+                    "API 请求失败（可能为凭据错误，尝试 {}/{}）: {} {}",
+                    attempt + 1,
+                    max_retries,
+                    status,
+                    body
+                );
+
+                let has_available = self.token_manager.report_failure(ctx.id);
+                if !has_available {
+                    anyhow::bail!(
+                        "{} API 请求失败（所有凭据已用尽）: {} {}",
+                        api_type,
+                        status,
+                        body
+                    );
+                }
+
+                last_error = Some(anyhow::anyhow!(
+                    "{} API 请求失败: {} {}",
+                    api_type,
+                    status,
+                    body
+                ));
+                continue;
+            }
+
+            // 429/408/5xx - 瞬态上游错误：重试但不禁用或切换凭据
+            // （避免 429 high traffic / 502 high load 等瞬态错误把所有凭据锁死）
+            if matches!(status.as_u16(), 408 | 429) || status.is_server_error() {
+                tracing::warn!(
+                    "API 请求失败（上游瞬态错误，尝试 {}/{}）: {} {}",
+                    attempt + 1,
+                    max_retries,
+                    status,
+                    body
+                );
+                last_error = Some(anyhow::anyhow!(
+                    "{} API 请求失败: {} {}",
+                    api_type,
+                    status,
+                    body
+                ));
+                if attempt + 1 < max_retries {
+                    sleep(Self::retry_delay(attempt)).await;
+                }
+                continue;
+            }
+
+            // 其他 4xx - 通常为请求/配置问题：直接返回，不计入凭据失败
+            if status.is_client_error() {
+                anyhow::bail!("{} API 请求失败: {} {}", api_type, status, body);
+            }
+
+            // 兜底：当作可重试的瞬态错误处理（不切换凭据）
+            tracing::warn!(
+                "API 请求失败（未知错误，尝试 {}/{}）: {} {}",
+                attempt + 1,
+                max_retries,
+                status,
+                body
+            );
+            last_error = Some(anyhow::anyhow!(
+                "{} API 请求失败: {} {}",
+                api_type,
+                status,
+                body
+            ));
+            if attempt + 1 < max_retries {
+                sleep(Self::retry_delay(attempt)).await;
+            }
+        }
+
+        // 所有重试都失败
+        Err(last_error.unwrap_or_else(|| {
+            anyhow::anyhow!(
+                "{} API 请求失败：已达到最大重试次数（{}次）",
+                api_type,
+                max_retries
+            )
+        }))
+    }
+
+    /// 根据认证方式处理请求体中的 profileArn 字段
+    ///
+    /// 参考 CLIProxyAPIPlus 的 getEffectiveProfileArn 实现：
+    /// - AWS SSO OIDC (Builder ID/IDC) 用户**不需要** profileArn，发送它会导致 403 错误
+    /// - 只有 Kiro Desktop (social auth) 用户需要 profileArn
+    ///
+    /// # 行为
+    /// - 如果是 builder-id 或 idc 认证：移除请求体中的 profileArn 字段
+    /// - 如果是 social 认证且凭据有 profile_arn：注入/覆盖 profileArn 字段
+    /// - 其他情况：保持请求体不变
+    fn inject_profile_arn(
+        request_body: &str,
+        credentials: &crate::kiro::model::credentials::KiroCredentials,
+    ) -> anyhow::Result<String> {
+        // 检查认证方式
+        let auth_method = credentials.auth_method.as_deref();
+
+        // AWS SSO OIDC (Builder ID/IDC) - 不需要 profileArn，发送会导致 403
+        // 同时检查 client_id + client_secret 的存在（AWS SSO OIDC 的特征）
+        let is_aws_sso_oidc = matches!(auth_method, Some("builder-id") | Some("idc"))
+            || (credentials.client_id.is_some() && credentials.client_secret.is_some());
+
+        if is_aws_sso_oidc {
+            // 解析请求体，移除 profileArn 字段
+            let mut request: serde_json::Value = serde_json::from_str(request_body)?;
+
+            if let Some(obj) = request.as_object_mut()
+                && obj.remove("profileArn").is_some()
+            {
+                tracing::debug!(
+                    "已移除 profileArn 字段（auth_method={:?}，AWS SSO OIDC 不需要）",
+                    auth_method
+                );
+            }
+
+            return Ok(serde_json::to_string(&request)?);
+        }
+
+        // Social auth - 需要 profileArn
+        // 凭据没有 profile_arn 时，保持请求体不变
+        let Some(profile_arn) = &credentials.profile_arn else {
+            return Ok(request_body.to_string());
+        };
+
+        // 解析请求体为 JSON
+        let mut request: serde_json::Value = serde_json::from_str(request_body)?;
+
+        // 安全检查：确保是对象类型，避免在非对象 JSON 上 panic
+        let obj = request
+            .as_object_mut()
+            .ok_or_else(|| anyhow::anyhow!("request body is not a JSON object"))?;
+
+        // 注入 profile_arn（覆盖原有值）
+        obj.insert(
+            "profileArn".to_string(),
+            serde_json::Value::String(profile_arn.clone()),
+        );
+
+        // 序列化回字符串
+        Ok(serde_json::to_string(&request)?)
+    }
+
+    fn retry_delay(attempt: usize) -> Duration {
+        // 指数退避 + 少量抖动，避免上游抖动时放大故障
+        const BASE_MS: u64 = 200;
+        const MAX_MS: u64 = 2_000;
+        let exp = BASE_MS.saturating_mul(2u64.saturating_pow(attempt.min(6) as u32));
+        let backoff = exp.min(MAX_MS);
+        let jitter_max = (backoff / 4).max(1);
+        let jitter = fastrand::u64(0..=jitter_max);
+        Duration::from_millis(backoff.saturating_add(jitter))
+    }
+
+    fn is_monthly_request_limit(body: &str) -> bool {
+        if body.contains("MONTHLY_REQUEST_COUNT") {
+            return true;
+        }
+
+        let Ok(value) = serde_json::from_str::<serde_json::Value>(body) else {
+            return false;
+        };
+
+        if value
+            .get("reason")
+            .and_then(|v| v.as_str())
+            .is_some_and(|v| v == "MONTHLY_REQUEST_COUNT")
+        {
+            return true;
+        }
+
+        value
+            .pointer("/error/reason")
+            .and_then(|v| v.as_str())
+            .is_some_and(|v| v == "MONTHLY_REQUEST_COUNT")
+    }
+
+    /// 检测是否为 MODEL_TEMPORARILY_UNAVAILABLE 错误
+    fn is_model_temporarily_unavailable(body: &str) -> bool {
+        if body.contains("MODEL_TEMPORARILY_UNAVAILABLE") {
+            return true;
+        }
+
+        let Ok(value) = serde_json::from_str::<serde_json::Value>(body) else {
+            return false;
+        };
+
+        if value
+            .get("reason")
+            .and_then(|v| v.as_str())
+            .is_some_and(|v| v == "MODEL_TEMPORARILY_UNAVAILABLE")
+        {
+            return true;
+        }
+
+        value
+            .pointer("/error/reason")
+            .and_then(|v| v.as_str())
+            .is_some_and(|v| v == "MODEL_TEMPORARILY_UNAVAILABLE")
+    }
+
+    /// 检测是否为「bearer token invalid」类错误
+    ///
+    /// 典型返回：
+    /// `{"message":"The bearer token included in the request is invalid.","reason":null}`
+    fn is_invalid_bearer_token(body: &str) -> bool {
+        let lower = body.to_ascii_lowercase();
+        lower.contains("bearer token") && lower.contains("invalid")
+    }
+
+    /// 检测是否为「输入过长」类错误
+    ///
+    /// 典型返回：
+    /// `{"message":"Input is too long.","reason":"CONTENT_LENGTH_EXCEEDS_THRESHOLD"}`
+    fn is_input_too_long(body: &str) -> bool {
+        body.contains("CONTENT_LENGTH_EXCEEDS_THRESHOLD") || body.contains("Input is too long")
+    }
+
+    /// 从上游响应体提取一个适合返回给客户端的错误摘要
+    ///
+    /// 目标：
+    /// - 保留关键错误信息（例如 "Input is too long" / "Improperly formed request"）
+    /// - 避免返回过长/不可控的内容导致客户端难以区分或处理
+    #[cfg(not(feature = "sensitive-logs"))]
+    fn summarize_error_body(body: &str) -> String {
+        const MAX_LEN: usize = 256;
+        let trimmed = body.trim();
+        if trimmed.is_empty() {
+            return "<empty response body>".to_string();
+        }
+
+        // 优先尝试解析 JSON，从常见字段中提取 message / reason。
+        if let Ok(value) = serde_json::from_str::<serde_json::Value>(trimmed) {
+            let message = value
+                .get("message")
+                .and_then(|v| v.as_str())
+                .or_else(|| value.get("Message").and_then(|v| v.as_str()))
+                .or_else(|| value.pointer("/error/message").and_then(|v| v.as_str()))
+                .or_else(|| value.pointer("/error/Message").and_then(|v| v.as_str()));
+
+            let reason = value
+                .get("reason")
+                .and_then(|v| v.as_str())
+                .or_else(|| value.get("Reason").and_then(|v| v.as_str()))
+                .or_else(|| value.pointer("/error/reason").and_then(|v| v.as_str()))
+                .or_else(|| value.pointer("/error/Reason").and_then(|v| v.as_str()));
+
+            if let Some(msg) = message {
+                let mut s = msg.to_string();
+                if let Some(r) = reason.filter(|r| !r.is_empty() && *r != "null") {
+                    // 避免重复拼接（有些上游会把 reason 直接写入 message）
+                    if !msg.contains(r) {
+                        s.push_str(&format!(" (reason={})", r));
+                    }
+                }
+                return Self::truncate_one_line(&s, MAX_LEN);
+            }
+        }
+
+        // JSON 解析失败或不含常见字段，回退到压缩后的纯文本。
+        Self::truncate_one_line(trimmed, MAX_LEN)
+    }
+
+    #[cfg(not(feature = "sensitive-logs"))]
+    fn truncate_one_line(s: &str, max_len: usize) -> String {
+        let one_line = s.split_whitespace().collect::<Vec<_>>().join(" ");
+        if one_line.len() <= max_len {
+            return one_line;
+        }
+
+        let end = floor_char_boundary(&one_line, max_len);
+        format!("{}...", &one_line[..end])
+    }
+
+    /// 估算文本的 token 数量
+    ///
+    /// 基于字符类型的估算公式：
+    /// - CJK 字符（中/日/韩）: token 数 = 字符数 / 1.5
+    /// - 其他字符（英文等）: token 数 = 字符数 / 3.5
+    fn estimate_tokens(text: &str) -> usize {
+        let mut cjk_count = 0usize;
+        let mut other_count = 0usize;
+
+        for c in text.chars() {
+            if Self::is_cjk_char(c) {
+                cjk_count += 1;
+            } else {
+                other_count += 1;
+            }
+        }
+
+        let cjk_tokens = cjk_count as f64 / 1.5;
+        let other_tokens = other_count as f64 / 3.5;
+        (cjk_tokens + other_tokens + 0.5) as usize
+    }
+
+    /// 判断是否为 CJK（中日韩）字符
+    #[inline]
+    fn is_cjk_char(c: char) -> bool {
+        matches!(c,
+            '\u{4E00}'..='\u{9FFF}'   |  // CJK 统一汉字
+            '\u{3400}'..='\u{4DBF}'   |  // CJK 扩展 A
+            '\u{20000}'..='\u{2A6DF}' |  // CJK 扩展 B
+            '\u{2A700}'..='\u{2B73F}' |  // CJK 扩展 C
+            '\u{2B740}'..='\u{2B81F}' |  // CJK 扩展 D
+            '\u{F900}'..='\u{FAFF}'   |  // CJK 兼容汉字
+            '\u{2F800}'..='\u{2FA1F}' |  // CJK 兼容扩展
+            '\u{3000}'..='\u{303F}'   |  // CJK 标点符号
+            '\u{3040}'..='\u{309F}'   |  // 平假名
+            '\u{30A0}'..='\u{30FF}'   |  // 片假名
+            '\u{AC00}'..='\u{D7AF}'      // 韩文音节
+        )
+    }
+
+    /// 格式化 HeaderMap 为可读字符串（用于日志输出）
+    /// 敏感头部（Authorization）会被脱敏处理
+    #[cfg(feature = "sensitive-logs")]
+    fn format_headers_for_log(headers: &HeaderMap) -> String {
+        headers
+            .iter()
+            .map(|(name, value)| {
+                let value_str = value.to_str().unwrap_or("<binary>");
+                // 脱敏 Authorization 头
+                if name.as_str().eq_ignore_ascii_case("authorization") {
+                    let masked = if value_str.len() > 20 {
+                        format!(
+                            "{}...{}",
+                            &value_str[..10],
+                            &value_str[value_str.len() - 6..]
+                        )
+                    } else {
+                        "***".to_string()
+                    };
+                    format!("{}: {}", name, masked)
+                } else {
+                    format!("{}: {}", name, value_str)
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    /// 截断请求体用于日志输出，保留头尾各 `keep` 个字符
+    ///
+    /// 避免在 sensitive-logs 模式下输出包含大量 base64 图片数据的完整请求体。
+    #[cfg(feature = "sensitive-logs")]
+    fn truncate_body_for_log(s: &str, keep: usize) -> std::borrow::Cow<'_, str> {
+        let char_count = s.chars().count();
+        let min_omit = 30;
+        if char_count <= keep * 2 + min_omit {
+            return std::borrow::Cow::Borrowed(s);
+        }
+
+        let head_end = s
+            .char_indices()
+            .nth(keep)
+            .map(|(i, _)| i)
+            .unwrap_or(s.len());
+
+        let tail_start = s
+            .char_indices()
+            .nth_back(keep - 1)
+            .map(|(i, _)| i)
+            .unwrap_or(0);
+
+        let omitted = s.len() - head_end - (s.len() - tail_start);
+        std::borrow::Cow::Owned(format!(
+            "{}...({} bytes omitted)...{}",
+            &s[..head_end],
+            omitted,
+            &s[tail_start..]
+        ))
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::field_reassign_with_default)]
+mod tests {
+    use super::*;
+    use crate::kiro::model::credentials::KiroCredentials;
+    use crate::kiro::token_manager::CallContext;
+    use crate::model::config::Config;
+
+    fn create_test_provider(config: Config, credentials: KiroCredentials) -> KiroProvider {
+        let tm = MultiTokenManager::new(config, vec![credentials], None, None, false).unwrap();
+        KiroProvider::new(Arc::new(tm))
+    }
+
+    #[test]
+    fn test_base_url() {
+        let config = Config::default();
+        let credentials = KiroCredentials::default();
+        let provider = create_test_provider(config, credentials.clone());
+        assert!(provider.base_url(&credentials).contains("amazonaws.com"));
+        assert!(
+            provider
+                .base_url(&credentials)
+                .contains("generateAssistantResponse")
+        );
+    }
+
+    #[test]
+    fn test_base_domain() {
+        let mut config = Config::default();
+        config.region = "us-east-1".to_string();
+        let credentials = KiroCredentials::default();
+        let provider = create_test_provider(config, credentials.clone());
+        assert_eq!(
+            provider.base_domain(&credentials),
+            "q.us-east-1.amazonaws.com"
+        );
+    }
+
+    #[test]
+    fn test_build_headers() {
+        let mut config = Config::default();
+        config.region = "us-east-1".to_string();
+        config.kiro_version = "0.8.0".to_string();
+
+        let mut credentials = KiroCredentials::default();
+        credentials.profile_arn = Some("arn:aws:sso::123456789:profile/test".to_string());
+        credentials.refresh_token = Some("a".repeat(150));
+
+        let provider = create_test_provider(config, credentials.clone());
+        let ctx = CallContext {
+            id: 1,
+            credentials,
+            token: "test_token".to_string(),
+        };
+        let headers = provider.build_headers(&ctx).unwrap();
+
+        assert_eq!(headers.get(CONTENT_TYPE).unwrap(), "application/json");
+        assert_eq!(headers.get("x-amzn-codewhisperer-optout").unwrap(), "true");
+        assert_eq!(headers.get("x-amzn-kiro-agent-mode").unwrap(), "vibe");
+        assert!(
+            headers
+                .get(AUTHORIZATION)
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .starts_with("Bearer ")
+        );
+        assert_eq!(headers.get(CONNECTION).unwrap(), "close");
+    }
+
+    #[test]
+    fn test_is_monthly_request_limit_detects_reason() {
+        let body = r#"{"message":"You have reached the limit.","reason":"MONTHLY_REQUEST_COUNT"}"#;
+        assert!(KiroProvider::is_monthly_request_limit(body));
+    }
+
+    #[test]
+    fn test_is_monthly_request_limit_nested_reason() {
+        let body = r#"{"error":{"reason":"MONTHLY_REQUEST_COUNT"}}"#;
+        assert!(KiroProvider::is_monthly_request_limit(body));
+    }
+
+    #[test]
+    fn test_is_monthly_request_limit_false() {
+        let body = r#"{"message":"nope","reason":"DAILY_REQUEST_COUNT"}"#;
+        assert!(!KiroProvider::is_monthly_request_limit(body));
+    }
+
+    #[test]
+    fn test_is_invalid_bearer_token_true() {
+        let body =
+            r#"{"message":"The bearer token included in the request is invalid.","reason":null}"#;
+        assert!(KiroProvider::is_invalid_bearer_token(body));
+    }
+
+    #[test]
+    fn test_is_invalid_bearer_token_false() {
+        let body = r#"{"message":"Forbidden","reason":null}"#;
+        assert!(!KiroProvider::is_invalid_bearer_token(body));
+    }
+
+    #[test]
+    #[cfg(not(feature = "sensitive-logs"))]
+    fn test_summarize_error_body_extracts_message_and_reason() {
+        let body =
+            r#"{"message":"Input is too long.","reason":"CONTENT_LENGTH_EXCEEDS_THRESHOLD"}"#;
+        let summary = KiroProvider::summarize_error_body(body);
+        assert!(summary.contains("Input is too long"));
+        assert!(summary.contains("CONTENT_LENGTH_EXCEEDS_THRESHOLD"));
+    }
+
+    #[test]
+    #[cfg(not(feature = "sensitive-logs"))]
+    fn test_summarize_error_body_extracts_nested_message_and_reason() {
+        let body = r#"{"error":{"message":"Improperly formed request","reason":"BAD_REQUEST"}}"#;
+        let summary = KiroProvider::summarize_error_body(body);
+        assert!(summary.contains("Improperly formed request"));
+        assert!(summary.contains("BAD_REQUEST"));
+    }
+
+    #[test]
+    #[cfg(not(feature = "sensitive-logs"))]
+    fn test_summarize_error_body_truncates_long_text() {
+        let body = "x".repeat(1000);
+        let summary = KiroProvider::summarize_error_body(&body);
+        assert!(summary.len() <= 256 + 3);
+        assert!(summary.ends_with("..."));
+    }
+
+    #[test]
+    fn test_inject_profile_arn_with_social_auth() {
+        // Social 认证且凭据有 profile_arn 时，应覆盖请求体中的 profileArn
+        let mut credentials = KiroCredentials::default();
+        credentials.auth_method = Some("social".to_string());
+        credentials.profile_arn = Some("arn:aws:sso::111111111:profile/social-profile".to_string());
+
+        let request_body =
+            r#"{"conversationState":{},"profileArn":"arn:aws:sso::999999999:profile/old"}"#;
+        let result = KiroProvider::inject_profile_arn(request_body, &credentials).unwrap();
+
+        let parsed: serde_json::Value = serde_json::from_str(&result).unwrap();
+        assert_eq!(
+            parsed["profileArn"].as_str().unwrap(),
+            "arn:aws:sso::111111111:profile/social-profile"
+        );
+    }
+
+    #[test]
+    fn test_inject_profile_arn_idc_removes_field() {
+        // IDC 认证时，应移除请求体中的 profileArn 字段
+        let mut credentials = KiroCredentials::default();
+        credentials.auth_method = Some("idc".to_string());
+        credentials.profile_arn = Some("arn:aws:sso::111111111:profile/idc-profile".to_string());
+
+        let request_body =
+            r#"{"conversationState":{},"profileArn":"arn:aws:sso::999999999:profile/old"}"#;
+        let result = KiroProvider::inject_profile_arn(request_body, &credentials).unwrap();
+
+        let parsed: serde_json::Value = serde_json::from_str(&result).unwrap();
+        // profileArn 应被移除
+        assert!(parsed.get("profileArn").is_none());
+        // 其他字段应保留
+        assert!(parsed.get("conversationState").is_some());
+    }
+
+    #[test]
+    fn test_inject_profile_arn_builder_id_removes_field() {
+        // Builder ID 认证时，应移除请求体中的 profileArn 字段
+        let mut credentials = KiroCredentials::default();
+        credentials.auth_method = Some("builder-id".to_string());
+
+        let request_body =
+            r#"{"conversationState":{},"profileArn":"arn:aws:sso::999999999:profile/old"}"#;
+        let result = KiroProvider::inject_profile_arn(request_body, &credentials).unwrap();
+
+        let parsed: serde_json::Value = serde_json::from_str(&result).unwrap();
+        // profileArn 应被移除
+        assert!(parsed.get("profileArn").is_none());
+    }
+
+    #[test]
+    fn test_inject_profile_arn_aws_sso_oidc_by_client_credentials() {
+        // 有 client_id + client_secret 时（AWS SSO OIDC 特征），应移除 profileArn
+        let mut credentials = KiroCredentials::default();
+        credentials.client_id = Some("client123".to_string());
+        credentials.client_secret = Some("secret456".to_string());
+        credentials.profile_arn = Some("arn:aws:sso::111111111:profile/test".to_string());
+
+        let request_body =
+            r#"{"conversationState":{},"profileArn":"arn:aws:sso::999999999:profile/old"}"#;
+        let result = KiroProvider::inject_profile_arn(request_body, &credentials).unwrap();
+
+        let parsed: serde_json::Value = serde_json::from_str(&result).unwrap();
+        // profileArn 应被移除
+        assert!(parsed.get("profileArn").is_none());
+    }
+
+    #[test]
+    fn test_inject_profile_arn_without_credential_arn() {
+        // Social 认证但凭据没有 profile_arn 时，应保持请求体不变
+        let mut credentials = KiroCredentials::default();
+        credentials.auth_method = Some("social".to_string());
+        assert!(credentials.profile_arn.is_none());
+
+        let request_body =
+            r#"{"conversationState":{},"profileArn":"arn:aws:sso::999999999:profile/original"}"#;
+        let result = KiroProvider::inject_profile_arn(request_body, &credentials).unwrap();
+
+        // 应返回原始请求体（未修改）
+        assert_eq!(result, request_body);
+    }
+
+    #[test]
+    fn test_inject_profile_arn_adds_missing_field() {
+        // Social 认证且请求体没有 profileArn 字段时，应添加
+        let mut credentials = KiroCredentials::default();
+        credentials.auth_method = Some("social".to_string());
+        credentials.profile_arn = Some("arn:aws:sso::222222222:profile/new".to_string());
+
+        let request_body = r#"{"conversationState":{"conversationId":"test"}}"#;
+        let result = KiroProvider::inject_profile_arn(request_body, &credentials).unwrap();
+
+        let parsed: serde_json::Value = serde_json::from_str(&result).unwrap();
+        assert_eq!(
+            parsed["profileArn"].as_str().unwrap(),
+            "arn:aws:sso::222222222:profile/new"
+        );
+        // 确保原有字段保留
+        assert_eq!(
+            parsed["conversationState"]["conversationId"]
+                .as_str()
+                .unwrap(),
+            "test"
+        );
+    }
+}
diff --git a/src/kiro/rate_limiter.rs b/src/kiro/rate_limiter.rs
new file mode 100644
index 0000000..4d127a4
--- /dev/null
+++ b/src/kiro/rate_limiter.rs
@@ -0,0 +1,461 @@
+//! 精细化速率限制系统
+#![allow(dead_code)]
+//!
+//! 实现每日请求限制、请求间隔控制、指数退避等策略，
+//! 模拟人类使用模式，降低被检测风险。
+//! 参考 CLIProxyAPIPlus 的实现。
+
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+/// 默认每日最大请求数
+const DEFAULT_DAILY_MAX_REQUESTS: u32 = 500;
+
+/// 默认最小请求间隔（毫秒）
+const DEFAULT_MIN_INTERVAL_MS: u64 = 1000;
+
+/// 默认最大请求间隔（毫秒）
+const DEFAULT_MAX_INTERVAL_MS: u64 = 2000;
+
+/// 默认抖动百分比
+const DEFAULT_JITTER_PERCENT: f64 = 0.3;
+
+/// 默认退避基数（毫秒）
+const DEFAULT_BACKOFF_BASE_MS: u64 = 30_000;
+
+/// 默认最大退避时间（毫秒）
+const DEFAULT_BACKOFF_MAX_MS: u64 = 300_000;
+
+/// 默认退避倍数
+const DEFAULT_BACKOFF_MULTIPLIER: f64 = 1.5;
+
+/// 暂停检测关键词
+const SUSPEND_KEYWORDS: &[&str] = &[
+    "suspended",
+    "banned",
+    "quota exceeded",
+    "rate limit",
+    "too many requests",
+    "account disabled",
+];
+
+/// 速率限制配置
+#[derive(Debug, Clone)]
+pub struct RateLimitConfig {
+    /// 每日最大请求数
+    pub daily_max_requests: u32,
+
+    /// 最小请求间隔（毫秒）
+    pub min_interval_ms: u64,
+
+    /// 最大请求间隔（毫秒）
+    pub max_interval_ms: u64,
+
+    /// 抖动百分比（0.0 - 1.0）
+    pub jitter_percent: f64,
+
+    /// 退避基数（毫秒）
+    pub backoff_base_ms: u64,
+
+    /// 最大退避时间（毫秒）
+    pub backoff_max_ms: u64,
+
+    /// 退避倍数
+    pub backoff_multiplier: f64,
+}
+
+impl Default for RateLimitConfig {
+    fn default() -> Self {
+        Self {
+            daily_max_requests: DEFAULT_DAILY_MAX_REQUESTS,
+            min_interval_ms: DEFAULT_MIN_INTERVAL_MS,
+            max_interval_ms: DEFAULT_MAX_INTERVAL_MS,
+            jitter_percent: DEFAULT_JITTER_PERCENT,
+            backoff_base_ms: DEFAULT_BACKOFF_BASE_MS,
+            backoff_max_ms: DEFAULT_BACKOFF_MAX_MS,
+            backoff_multiplier: DEFAULT_BACKOFF_MULTIPLIER,
+        }
+    }
+}
+
+/// 凭据速率状态
+#[derive(Debug, Clone)]
+struct CredentialRateState {
+    /// 今日请求计数
+    daily_count: u32,
+
+    /// 计数重置时间
+    count_reset_at: Instant,
+
+    /// 上次请求时间
+    last_request_at: Option<Instant>,
+
+    /// 连续失败次数（用于退避计算）
+    consecutive_failures: u32,
+
+    /// 当前退避结束时间
+    backoff_until: Option<Instant>,
+}
+
+impl Default for CredentialRateState {
+    fn default() -> Self {
+        Self {
+            daily_count: 0,
+            count_reset_at: Instant::now() + Duration::from_secs(86400),
+            last_request_at: None,
+            consecutive_failures: 0,
+            backoff_until: None,
+        }
+    }
+}
+
+/// 速率限制器
+///
+/// 管理所有凭据的速率限制状态
+pub struct RateLimiter {
+    config: RateLimitConfig,
+    states: Mutex<HashMap<u64, CredentialRateState>>,
+}
+
+impl RateLimiter {
+    /// 创建新的速率限制器
+    pub fn new(config: RateLimitConfig) -> Self {
+        Self {
+            config,
+            states: Mutex::new(HashMap::new()),
+        }
+    }
+
+    /// 使用默认配置创建速率限制器
+    pub fn with_defaults() -> Self {
+        Self::new(RateLimitConfig::default())
+    }
+
+    /// 检查凭据是否可以发送请求
+    ///
+    /// 返回 `Ok(())` 表示可以发送，`Err(Duration)` 表示需要等待的时间
+    pub fn check_rate_limit(&self, credential_id: u64) -> Result<(), Duration> {
+        let mut states = self.states.lock();
+        let state = states.entry(credential_id).or_default();
+        let now = Instant::now();
+
+        // 检查是否需要重置每日计数
+        if now >= state.count_reset_at {
+            state.daily_count = 0;
+            state.count_reset_at = now + Duration::from_secs(86400);
+        }
+
+        // 检查每日限制
+        if state.daily_count >= self.config.daily_max_requests {
+            let wait_time = state.count_reset_at.saturating_duration_since(now);
+            return Err(wait_time);
+        }
+
+        // 检查退避状态
+        if let Some(backoff_until) = state.backoff_until {
+            if now < backoff_until {
+                return Err(backoff_until.saturating_duration_since(now));
+            }
+            // 退避已结束，清除状态
+            state.backoff_until = None;
+        }
+
+        // 检查请求间隔
+        if let Some(last_request) = state.last_request_at {
+            let min_interval = self.calculate_interval();
+            let elapsed = now.saturating_duration_since(last_request);
+            if elapsed < min_interval {
+                return Err(min_interval - elapsed);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// 尝试获取一次“发送许可”（原子检查 + 占位）
+    ///
+    /// `check_rate_limit()` 仅做检查，不会更新状态，无法在并发场景下避免“同时放行”。
+    /// 本方法在同一把锁内完成检查与 `last_request_at` 更新，用于：
+    /// - 限制单个凭据的请求频率（近似 RPM/最小间隔）
+    /// - 在并发请求下将流量自然分流到其他可用凭据
+    ///
+    /// 返回 `Ok(())` 表示已占用一个发送窗口；`Err(Duration)` 表示需要等待的时间。
+    pub fn try_acquire(&self, credential_id: u64) -> Result<(), Duration> {
+        let min_interval = self.calculate_interval();
+
+        let mut states = self.states.lock();
+        let state = states.entry(credential_id).or_default();
+        let now = Instant::now();
+
+        // 检查是否需要重置每日计数
+        if now >= state.count_reset_at {
+            state.daily_count = 0;
+            state.count_reset_at = now + Duration::from_secs(86400);
+        }
+
+        // 检查每日限制
+        if state.daily_count >= self.config.daily_max_requests {
+            let wait_time = state.count_reset_at.saturating_duration_since(now);
+            return Err(wait_time);
+        }
+
+        // 检查退避状态
+        if let Some(backoff_until) = state.backoff_until {
+            if now < backoff_until {
+                return Err(backoff_until.saturating_duration_since(now));
+            }
+            // 退避已结束，清除状态
+            state.backoff_until = None;
+        }
+
+        // 检查请求间隔
+        if let Some(last_request) = state.last_request_at {
+            let elapsed = now.saturating_duration_since(last_request);
+            if elapsed < min_interval {
+                return Err(min_interval - elapsed);
+            }
+        }
+
+        // 占位：更新上次请求时间，避免并发下同一凭据被同时放行
+        state.last_request_at = Some(now);
+        Ok(())
+    }
+
+    /// 记录请求成功
+    pub fn record_success(&self, credential_id: u64) {
+        let mut states = self.states.lock();
+        let state = states.entry(credential_id).or_default();
+
+        state.daily_count += 1;
+        state.last_request_at = Some(Instant::now());
+        state.consecutive_failures = 0;
+        state.backoff_until = None;
+    }
+
+    /// 记录请求失败
+    ///
+    /// 返回下次可以重试的等待时间
+    pub fn record_failure(&self, credential_id: u64, error_message: Option<&str>) -> Duration {
+        let mut states = self.states.lock();
+        let state = states.entry(credential_id).or_default();
+        let now = Instant::now();
+
+        state.consecutive_failures += 1;
+        state.last_request_at = Some(now);
+
+        // 检查是否触发暂停检测
+        let is_suspended = error_message
+            .map(|msg| {
+                let lower = msg.to_ascii_lowercase();
+                SUSPEND_KEYWORDS.iter().any(|kw| lower.contains(kw))
+            })
+            .unwrap_or(false);
+
+        // 计算退避时间
+        let backoff = if is_suspended {
+            // 暂停检测触发长时间退避（1 小时）
+            Duration::from_secs(3600)
+        } else {
+            self.calculate_backoff(state.consecutive_failures)
+        };
+
+        state.backoff_until = Some(now + backoff);
+        backoff
+    }
+
+    /// 获取凭据的当前状态
+    pub fn get_state(&self, credential_id: u64) -> Option<RateLimitState> {
+        let states = self.states.lock();
+        states.get(&credential_id).map(|s| {
+            let now = Instant::now();
+            RateLimitState {
+                daily_count: s.daily_count,
+                daily_remaining: self.config.daily_max_requests.saturating_sub(s.daily_count),
+                consecutive_failures: s.consecutive_failures,
+                is_in_backoff: s.backoff_until.map(|t| now < t).unwrap_or(false),
+                backoff_remaining_ms: s
+                    .backoff_until
+                    .map(|t| t.saturating_duration_since(now).as_millis() as u64)
+                    .unwrap_or(0),
+            }
+        })
+    }
+
+    /// 重置凭据的速率限制状态
+    pub fn reset(&self, credential_id: u64) {
+        let mut states = self.states.lock();
+        states.remove(&credential_id);
+    }
+
+    /// 重置所有凭据的速率限制状态
+    #[allow(dead_code)]
+    pub fn reset_all(&self) {
+        let mut states = self.states.lock();
+        states.clear();
+    }
+
+    /// 计算请求间隔（带抖动）
+    fn calculate_interval(&self) -> Duration {
+        let base = (self.config.min_interval_ms + self.config.max_interval_ms) / 2;
+        let jitter_range = (base as f64 * self.config.jitter_percent) as u64;
+        let jitter = if jitter_range > 0 {
+            fastrand::u64(0..=jitter_range * 2) as i64 - jitter_range as i64
+        } else {
+            0
+        };
+        let interval = (base as i64 + jitter)
+            .max(self.config.min_interval_ms as i64)
+            .min(self.config.max_interval_ms as i64) as u64;
+        Duration::from_millis(interval)
+    }
+
+    /// 计算指数退避时间
+    fn calculate_backoff(&self, failures: u32) -> Duration {
+        let base = self.config.backoff_base_ms as f64;
+        let multiplier = self.config.backoff_multiplier;
+        let max = self.config.backoff_max_ms;
+
+        // 指数退避：base * multiplier^(failures-1)
+        let backoff = base * multiplier.powi((failures.saturating_sub(1)) as i32);
+        let backoff_ms = (backoff as u64).min(max);
+
+        // 添加抖动
+        let jitter_range = (backoff_ms as f64 * self.config.jitter_percent) as u64;
+        let jitter = if jitter_range > 0 {
+            fastrand::u64(0..=jitter_range)
+        } else {
+            0
+        };
+
+        // 在添加抖动后再进行上限约束，确保不超过 backoff_max_ms
+        let final_backoff = (backoff_ms + jitter).min(max);
+        Duration::from_millis(final_backoff)
+    }
+}
+
+/// 速率限制状态（公开 API）
+#[derive(Debug, Clone)]
+pub struct RateLimitState {
+    /// 今日请求计数
+    pub daily_count: u32,
+
+    /// 今日剩余请求数
+    pub daily_remaining: u32,
+
+    /// 连续失败次数
+    pub consecutive_failures: u32,
+
+    /// 是否处于退避状态
+    pub is_in_backoff: bool,
+
+    /// 退避剩余时间（毫秒）
+    pub backoff_remaining_ms: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rate_limiter_new() {
+        let limiter = RateLimiter::with_defaults();
+        assert!(limiter.check_rate_limit(1).is_ok());
+    }
+
+    #[test]
+    fn test_rate_limiter_daily_limit() {
+        let config = RateLimitConfig {
+            daily_max_requests: 2,
+            min_interval_ms: 0,
+            max_interval_ms: 0,
+            ..Default::default()
+        };
+        let limiter = RateLimiter::new(config);
+
+        // 前两次请求应该成功
+        assert!(limiter.check_rate_limit(1).is_ok());
+        limiter.record_success(1);
+        assert!(limiter.check_rate_limit(1).is_ok());
+        limiter.record_success(1);
+
+        // 第三次应该被限制
+        assert!(limiter.check_rate_limit(1).is_err());
+    }
+
+    #[test]
+    fn test_rate_limiter_backoff() {
+        let config = RateLimitConfig {
+            backoff_base_ms: 100,
+            backoff_multiplier: 2.0,
+            jitter_percent: 0.0, // 禁用抖动以便测试
+            min_interval_ms: 0,
+            max_interval_ms: 0,
+            ..Default::default()
+        };
+        let limiter = RateLimiter::new(config);
+
+        // 记录失败
+        let backoff1 = limiter.record_failure(1, None);
+        assert!(backoff1.as_millis() >= 100);
+
+        // 第二次失败应该有更长的退避
+        let backoff2 = limiter.record_failure(1, None);
+        assert!(backoff2.as_millis() >= 200);
+    }
+
+    #[test]
+    fn test_rate_limiter_suspend_detection() {
+        let limiter = RateLimiter::with_defaults();
+
+        // 触发暂停检测
+        let backoff = limiter.record_failure(1, Some("Your account has been suspended"));
+        assert!(backoff.as_secs() >= 3600);
+    }
+
+    #[test]
+    fn test_rate_limiter_success_resets_failures() {
+        let limiter = RateLimiter::with_defaults();
+
+        // 记录几次失败
+        limiter.record_failure(1, None);
+        limiter.record_failure(1, None);
+
+        let state = limiter.get_state(1).unwrap();
+        assert_eq!(state.consecutive_failures, 2);
+
+        // 成功后重置
+        limiter.reset(1);
+        limiter.record_success(1);
+
+        let state = limiter.get_state(1).unwrap();
+        assert_eq!(state.consecutive_failures, 0);
+    }
+
+    #[test]
+    fn test_rate_limiter_get_state() {
+        let limiter = RateLimiter::with_defaults();
+
+        // 初始状态不存在
+        assert!(limiter.get_state(1).is_none());
+
+        // 记录成功后有状态
+        limiter.record_success(1);
+        let state = limiter.get_state(1).unwrap();
+        assert_eq!(state.daily_count, 1);
+        assert_eq!(state.consecutive_failures, 0);
+    }
+
+    #[test]
+    fn test_rate_limiter_reset() {
+        let limiter = RateLimiter::with_defaults();
+
+        limiter.record_success(1);
+        limiter.record_failure(1, None);
+
+        assert!(limiter.get_state(1).is_some());
+
+        limiter.reset(1);
+        assert!(limiter.get_state(1).is_none());
+    }
+}
diff --git a/src/kiro/token_manager.rs b/src/kiro/token_manager.rs
new file mode 100644
index 0000000..1be8b14
--- /dev/null
+++ b/src/kiro/token_manager.rs
@@ -0,0 +1,3152 @@
+//! Token 管理模块
+//!
+//! 负责 Token 过期检测和刷新，支持 Social 和 IdC 认证方式
+//! 支持单凭据 (TokenManager) 和多凭据 (MultiTokenManager) 管理
+//!
+//! ## 增强特性
+//!
+//! - **多维度设备指纹**: 每个凭据生成独立的设备指纹，模拟真实客户端
+//! - **后台 Token 刷新**: 定期检查并预刷新即将过期的 Token
+//! - **精细化速率限制**: 每日请求限制、请求间隔控制、指数退避
+//! - **冷却管理**: 分类管理不同原因的冷却状态
+//! - **优雅降级**: Token 刷新失败时使用现有 Token
+
+use anyhow::bail;
+use chrono::{DateTime, Duration, Utc};
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
+use std::time::{Duration as StdDuration, Instant};
+use tokio::sync::Mutex as TokioMutex;
+
+use crate::common::utf8::floor_char_boundary;
+use crate::http_client::{ProxyConfig, build_client};
+use crate::kiro::affinity::UserAffinityManager;
+use crate::kiro::background_refresh::{
+    BackgroundRefreshConfig, BackgroundRefresher, RefreshResult,
+};
+use crate::kiro::cooldown::{CooldownManager, CooldownReason};
+use crate::kiro::fingerprint::Fingerprint;
+use crate::kiro::machine_id;
+use crate::kiro::model::credentials::KiroCredentials;
+use crate::kiro::model::token_refresh::{
+    IdcRefreshRequest, IdcRefreshResponse, RefreshRequest, RefreshResponse,
+};
+use crate::kiro::model::usage_limits::UsageLimitsResponse;
+use crate::kiro::rate_limiter::{RateLimitConfig, RateLimiter};
+use crate::model::config::Config;
+
+/// 对 user_id 进行掩码处理，保护隐私
+fn mask_user_id(user_id: Option<&str>) -> String {
+    match user_id {
+        Some(id) => {
+            let len = id.len();
+            if len > 12 {
+                format!("{}***{}", &id[..4], &id[len - 4..])
+            } else {
+                "***".to_string()
+            }
+        }
+        None => "None".to_string(),
+    }
+}
+
+/// Token 管理器
+///
+/// 负责管理凭据和 Token 的自动刷新
+#[allow(dead_code)]
+pub struct TokenManager {
+    config: Config,
+    credentials: KiroCredentials,
+    proxy: Option<ProxyConfig>,
+}
+
+#[allow(dead_code)]
+impl TokenManager {
+    /// 创建新的 TokenManager 实例
+    pub fn new(config: Config, credentials: KiroCredentials, proxy: Option<ProxyConfig>) -> Self {
+        Self {
+            config,
+            credentials,
+            proxy,
+        }
+    }
+
+    /// 获取凭据的引用
+    pub fn credentials(&self) -> &KiroCredentials {
+        &self.credentials
+    }
+
+    /// 获取配置的引用
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+
+    /// 确保获取有效的访问 Token
+    ///
+    /// 如果 Token 过期或即将过期，会自动刷新
+    pub async fn ensure_valid_token(&mut self) -> anyhow::Result<String> {
+        let token_missing_or_truncated = self
+            .credentials
+            .access_token
+            .as_deref()
+            .is_none_or(|t| t.trim().is_empty() || t.ends_with("...") || t.contains("..."));
+
+        if token_missing_or_truncated
+            || is_token_expired(&self.credentials)
+            || is_token_expiring_soon(&self.credentials)
+        {
+            self.credentials =
+                refresh_token(&self.credentials, &self.config, self.proxy.as_ref()).await?;
+
+            // 刷新后再次检查 token 时间有效性
+            if is_token_expired(&self.credentials) {
+                anyhow::bail!("刷新后的 Token 仍然无效或已过期");
+            }
+        }
+
+        self.credentials
+            .access_token
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("没有可用的 accessToken"))
+    }
+
+    /// 获取使用额度信息
+    ///
+    /// 调用 getUsageLimits API 查询当前账户的使用额度
+    pub async fn get_usage_limits(&mut self) -> anyhow::Result<UsageLimitsResponse> {
+        let token = self.ensure_valid_token().await?;
+        get_usage_limits(&self.credentials, &self.config, &token, self.proxy.as_ref()).await
+    }
+}
+
+/// 检查 Token 是否在指定时间内过期
+pub(crate) fn is_token_expiring_within(
+    credentials: &KiroCredentials,
+    minutes: i64,
+) -> Option<bool> {
+    credentials
+        .expires_at
+        .as_ref()
+        .and_then(|expires_at| DateTime::parse_from_rfc3339(expires_at).ok())
+        .map(|expires| expires <= Utc::now() + Duration::minutes(minutes))
+}
+
+/// 检查 Token 是否已过期（提前 5 分钟判断）
+pub(crate) fn is_token_expired(credentials: &KiroCredentials) -> bool {
+    is_token_expiring_within(credentials, 5).unwrap_or(true)
+}
+
+/// 检查 Token 是否即将过期（10分钟内）
+pub(crate) fn is_token_expiring_soon(credentials: &KiroCredentials) -> bool {
+    is_token_expiring_within(credentials, 10).unwrap_or(false)
+}
+
+fn sha256_hex(input: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(input.as_bytes());
+    let result = hasher.finalize();
+    format!("{:x}", result)
+}
+
+/// 验证 refreshToken 的基本有效性
+pub(crate) fn validate_refresh_token(credentials: &KiroCredentials) -> anyhow::Result<()> {
+    let refresh_token = credentials
+        .refresh_token
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("缺少 refreshToken"))?;
+
+    if refresh_token.is_empty() {
+        bail!("refreshToken 为空");
+    }
+
+    if refresh_token.len() < 100 || refresh_token.ends_with("...") || refresh_token.contains("...")
+    {
+        bail!(
+            "refreshToken 已被截断（长度: {} 字符）。\n\
+             这通常是 Kiro IDE 为了防止凭证被第三方工具使用而故意截断的。",
+            refresh_token.len()
+        );
+    }
+
+    Ok(())
+}
+
+/// 刷新 Token
+pub(crate) async fn refresh_token(
+    credentials: &KiroCredentials,
+    config: &Config,
+    proxy: Option<&ProxyConfig>,
+) -> anyhow::Result<KiroCredentials> {
+    // 使用凭据自身的 ID（如果有）
+    let id = credentials.id.unwrap_or(0);
+    refresh_token_with_id(credentials, config, proxy, id).await
+}
+
+/// 刷新 Token（带凭证 ID）
+pub(crate) async fn refresh_token_with_id(
+    credentials: &KiroCredentials,
+    config: &Config,
+    proxy: Option<&ProxyConfig>,
+    _id: u64,
+) -> anyhow::Result<KiroCredentials> {
+    validate_refresh_token(credentials)?;
+
+    // 根据 auth_method 选择刷新方式
+    // 如果未指定 auth_method，根据是否有 clientId/clientSecret 自动判断
+    let auth_method = credentials.auth_method.as_deref().unwrap_or_else(|| {
+        if credentials.client_id.is_some() && credentials.client_secret.is_some() {
+            "idc"
+        } else {
+            "social"
+        }
+    });
+
+    if auth_method.eq_ignore_ascii_case("idc")
+        || auth_method.eq_ignore_ascii_case("builder-id")
+        || auth_method.eq_ignore_ascii_case("iam")
+    {
+        refresh_idc_token(credentials, config, proxy).await
+    } else {
+        refresh_social_token(credentials, config, proxy).await
+    }
+}
+
+/// 刷新 Social Token
+async fn refresh_social_token(
+    credentials: &KiroCredentials,
+    config: &Config,
+    proxy: Option<&ProxyConfig>,
+) -> anyhow::Result<KiroCredentials> {
+    tracing::info!("正在刷新 Social Token...");
+
+    let refresh_token = credentials.refresh_token.as_ref().unwrap();
+    // 优先使用凭据级 region，未配置或为空时回退到 config.region
+    let region = credentials
+        .region
+        .as_ref()
+        .filter(|r| !r.trim().is_empty())
+        .unwrap_or(&config.region);
+
+    let refresh_url = format!("https://prod.{}.auth.desktop.kiro.dev/refreshToken", region);
+    let refresh_domain = format!("prod.{}.auth.desktop.kiro.dev", region);
+    let machine_id = machine_id::generate_from_credentials(credentials, config)
+        .ok_or_else(|| anyhow::anyhow!("无法生成 machineId"))?;
+    let kiro_version = &config.kiro_version;
+
+    let client = build_client(proxy, 60, config.tls_backend)?;
+    let body = RefreshRequest {
+        refresh_token: refresh_token.to_string(),
+    };
+
+    let response = client
+        .post(&refresh_url)
+        .header("Accept", "application/json, text/plain, */*")
+        .header("Content-Type", "application/json")
+        .header(
+            "User-Agent",
+            format!("KiroIDE-{}-{}", kiro_version, machine_id),
+        )
+        .header("Accept-Encoding", "gzip, compress, deflate, br")
+        .header("host", &refresh_domain)
+        .header("Connection", "close")
+        .json(&body)
+        .send()
+        .await?;
+
+    let status = response.status();
+    if !status.is_success() {
+        let body_text = response.text().await.unwrap_or_default();
+        let error_msg = match status.as_u16() {
+            401 => "OAuth 凭证已过期或无效，需要重新认证",
+            403 => "权限不足，无法刷新 Token",
+            429 => "请求过于频繁，已被限流",
+            500..=599 => "服务器错误，AWS OAuth 服务暂时不可用",
+            _ => "Token 刷新失败",
+        };
+        bail!("{}: {} {}", error_msg, status, body_text);
+    }
+
+    let data: RefreshResponse = response.json().await?;
+
+    let mut new_credentials = credentials.clone();
+    new_credentials.access_token = Some(data.access_token);
+
+    if let Some(new_refresh_token) = data.refresh_token {
+        new_credentials.refresh_token = Some(new_refresh_token);
+    }
+
+    if let Some(profile_arn) = data.profile_arn {
+        new_credentials.profile_arn = Some(profile_arn);
+    }
+
+    if let Some(expires_in) = data.expires_in {
+        let expires_at = Utc::now() + Duration::seconds(expires_in);
+        new_credentials.expires_at = Some(expires_at.to_rfc3339());
+        tracing::info!(expires_in = %expires_in, "Social Token 刷新成功");
+    } else {
+        tracing::info!("Social Token 刷新成功（无过期时间）");
+    }
+
+    Ok(new_credentials)
+}
+
+/// IdC Token 刷新所需的 x-amz-user-agent header
+const IDC_AMZ_USER_AGENT: &str = "aws-sdk-js/3.738.0 ua/2.1 os/other lang/js md/browser#unknown_unknown api/sso-oidc#3.738.0 m/E KiroIDE";
+
+/// 刷新 IdC Token (AWS SSO OIDC)
+async fn refresh_idc_token(
+    credentials: &KiroCredentials,
+    config: &Config,
+    proxy: Option<&ProxyConfig>,
+) -> anyhow::Result<KiroCredentials> {
+    tracing::info!("正在刷新 IdC Token...");
+
+    let refresh_token = credentials.refresh_token.as_ref().unwrap();
+    let client_id = credentials
+        .client_id
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("IdC 刷新需要 clientId"))?;
+    let client_secret = credentials
+        .client_secret
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("IdC 刷新需要 clientSecret"))?;
+
+    // 优先使用凭据级 region，未配置或为空时回退到 config.region
+    let region = credentials
+        .region
+        .as_ref()
+        .filter(|r| !r.trim().is_empty())
+        .unwrap_or(&config.region);
+    let refresh_url = format!("https://oidc.{}.amazonaws.com/token", region);
+
+    let client = build_client(proxy, 60, config.tls_backend)?;
+    let body = IdcRefreshRequest {
+        client_id: client_id.to_string(),
+        client_secret: client_secret.to_string(),
+        refresh_token: refresh_token.to_string(),
+        grant_type: "refresh_token".to_string(),
+    };
+
+    let response = client
+        .post(&refresh_url)
+        .header("Content-Type", "application/json")
+        .header("Host", format!("oidc.{}.amazonaws.com", region))
+        .header("Connection", "keep-alive")
+        .header("x-amz-user-agent", IDC_AMZ_USER_AGENT)
+        .header("Accept", "*/*")
+        .header("Accept-Language", "*")
+        .header("sec-fetch-mode", "cors")
+        .header("User-Agent", "node")
+        .header("Accept-Encoding", "br, gzip, deflate")
+        .json(&body)
+        .send()
+        .await?;
+
+    let status = response.status();
+    if !status.is_success() {
+        let body_text = response.text().await.unwrap_or_default();
+        let error_msg = match status.as_u16() {
+            401 => "IdC 凭证已过期或无效，需要重新认证",
+            403 => "权限不足，无法刷新 Token",
+            429 => "请求过于频繁，已被限流",
+            500..=599 => "服务器错误，AWS OIDC 服务暂时不可用",
+            _ => "IdC Token 刷新失败",
+        };
+        bail!("{}: {} {}", error_msg, status, body_text);
+    }
+
+    let data: IdcRefreshResponse = response.json().await?;
+
+    let mut new_credentials = credentials.clone();
+    new_credentials.access_token = Some(data.access_token);
+
+    if let Some(new_refresh_token) = data.refresh_token {
+        new_credentials.refresh_token = Some(new_refresh_token);
+    }
+
+    if let Some(expires_in) = data.expires_in {
+        let expires_at = Utc::now() + Duration::seconds(expires_in);
+        new_credentials.expires_at = Some(expires_at.to_rfc3339());
+        tracing::info!(expires_in = %expires_in, "IdC Token 刷新成功");
+    } else {
+        tracing::info!("IdC Token 刷新成功（无过期时间）");
+    }
+
+    // 注意：IDC 凭据（auth_method = "idc" 或 "builder-id"）不需要 profileArn
+    // 参考 CLIProxyAPIPlus：AWS SSO OIDC 用户发送 profileArn 反而会导致 403 错误
+    // 因此这里不再尝试获取 profileArn，保持为 None 即可
+
+    Ok(new_credentials)
+}
+
+/// getUsageLimits API 所需的 x-amz-user-agent header 前缀
+const USAGE_LIMITS_AMZ_USER_AGENT_PREFIX: &str = "aws-sdk-js/1.0.0";
+
+/// 获取使用额度信息
+pub(crate) async fn get_usage_limits(
+    credentials: &KiroCredentials,
+    config: &Config,
+    token: &str,
+    proxy: Option<&ProxyConfig>,
+) -> anyhow::Result<UsageLimitsResponse> {
+    tracing::debug!("正在获取使用额度信息...");
+
+    // 优先级：凭据.api_region > 凭据.region > config.api_region > config.region
+    let region = credentials.effective_api_region(config);
+    let host = format!("q.{}.amazonaws.com", region);
+    let machine_id = machine_id::generate_from_credentials(credentials, config)
+        .ok_or_else(|| anyhow::anyhow!("无法生成 machineId"))?;
+    let kiro_version = &config.kiro_version;
+
+    // 构建 URL
+    let mut url = format!(
+        "https://{}/getUsageLimits?origin=AI_EDITOR&resourceType=AGENTIC_REQUEST",
+        host
+    );
+
+    // profileArn 是可选的
+    if let Some(profile_arn) = &credentials.profile_arn {
+        url.push_str(&format!("&profileArn={}", urlencoding::encode(profile_arn)));
+    }
+
+    // 构建 User-Agent headers
+    let user_agent = format!(
+        "aws-sdk-js/1.0.0 ua/2.1 os/darwin#24.6.0 lang/js md/nodejs#22.21.1 \
+         api/codewhispererruntime#1.0.0 m/N,E KiroIDE-{}-{}",
+        kiro_version, machine_id
+    );
+    let amz_user_agent = format!(
+        "{} KiroIDE-{}-{}",
+        USAGE_LIMITS_AMZ_USER_AGENT_PREFIX, kiro_version, machine_id
+    );
+
+    let client = build_client(proxy, 60, config.tls_backend)?;
+
+    let response = client
+        .get(&url)
+        .header("x-amz-user-agent", &amz_user_agent)
+        .header("User-Agent", &user_agent)
+        .header("host", &host)
+        .header("amz-sdk-invocation-id", uuid::Uuid::new_v4().to_string())
+        .header("amz-sdk-request", "attempt=1; max=1")
+        .header("Authorization", format!("Bearer {}", token))
+        .header("Connection", "close")
+        .send()
+        .await?;
+
+    let status = response.status();
+    if !status.is_success() {
+        let body_text = response.text().await.unwrap_or_default();
+        let error_msg = match status.as_u16() {
+            401 => "认证失败，Token 无效或已过期",
+            403 => "权限不足，无法获取使用额度",
+            429 => "请求过于频繁，已被限流",
+            500..=599 => "服务器错误，AWS 服务暂时不可用",
+            _ => "获取使用额度失败",
+        };
+        bail!("{}: {} {}", error_msg, status, body_text);
+    }
+
+    // 先获取原始响应文本，便于调试 JSON 解析错误
+    let body_text = response.text().await?;
+
+    let data: UsageLimitsResponse = serde_json::from_str(&body_text).map_err(|e| {
+        tracing::error!(
+            "getUsageLimits JSON 解析失败: {}，原始响应: {}",
+            e,
+            body_text
+        );
+        anyhow::anyhow!("JSON 解析失败: {}", e)
+    })?;
+    Ok(data)
+}
+
+// ============================================================================
+// 多凭据 Token 管理器
+// ============================================================================
+
+/// 凭据禁用原因
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DisableReason {
+    /// 连续失败次数过多
+    FailureLimit,
+    /// 余额不足
+    #[allow(dead_code)]
+    InsufficientBalance,
+    /// 模型临时不可用（全局禁用）
+    ModelUnavailable,
+    /// 手动禁用
+    Manual,
+    /// 额度已用尽（如 MONTHLY_REQUEST_COUNT）
+    QuotaExceeded,
+}
+
+/// 单个凭据条目的状态
+#[allow(dead_code)]
+struct CredentialEntry {
+    /// 凭据唯一 ID
+    id: u64,
+    /// 凭据信息
+    credentials: KiroCredentials,
+    /// API 调用连续失败次数
+    failure_count: u32,
+    /// 是否已禁用
+    disabled: bool,
+    /// 自愈原因（用于区分手动禁用 vs 自动禁用，便于自愈逻辑判断）
+    auto_heal_reason: Option<AutoHealReason>,
+    /// 禁用原因（公共 API 展示用）
+    disable_reason: Option<DisableReason>,
+    /// 设备指纹（每个凭据独立）
+    fingerprint: Fingerprint,
+    /// API 调用成功次数
+    success_count: u64,
+    /// 最后一次 API 调用时间（RFC3339 格式）
+    last_used_at: Option<String>,
+    /// refreshToken 的 SHA-256 哈希缓存（避免 snapshot 重复计算）
+    refresh_token_hash: Option<String>,
+}
+
+/// 自愈原因（内部使用，用于判断是否可自动恢复）
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum AutoHealReason {
+    /// Admin API 手动禁用（不自动恢复）
+    Manual,
+    /// 连续失败达到阈值后自动禁用（可自动恢复）
+    TooManyFailures,
+    /// 额度已用尽（如 MONTHLY_REQUEST_COUNT）
+    #[allow(dead_code)]
+    QuotaExceeded,
+}
+
+/// 统计数据持久化条目
+#[derive(Serialize, Deserialize)]
+struct StatsEntry {
+    success_count: u64,
+    last_used_at: Option<String>,
+}
+
+// ============================================================================
+// Admin API 公开结构
+// ============================================================================
+
+/// 凭据条目快照（用于 Admin API 读取）
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CredentialEntrySnapshot {
+    /// 凭据唯一 ID
+    pub id: u64,
+    /// 优先级
+    pub priority: u32,
+    /// 是否被禁用
+    pub disabled: bool,
+    /// 禁用原因
+    pub disable_reason: Option<DisableReason>,
+    /// 连续失败次数
+    pub failure_count: u32,
+    /// 认证方式
+    pub auth_method: Option<String>,
+    /// 是否有 Profile ARN
+    pub has_profile_arn: bool,
+    /// Token 过期时间
+    pub expires_at: Option<String>,
+    /// refreshToken 的 SHA-256 哈希（用于前端重复检测）
+    pub refresh_token_hash: Option<String>,
+    /// 用户邮箱（用于前端显示）
+    pub email: Option<String>,
+    /// API 调用成功次数
+    pub success_count: u64,
+    /// 最后一次 API 调用时间（RFC3339 格式）
+    pub last_used_at: Option<String>,
+    /// 凭据级 Region（用于 Token 刷新）
+    pub region: Option<String>,
+    /// 凭据级 API Region（单独覆盖 API 请求）
+    pub api_region: Option<String>,
+}
+
+/// 凭据管理器状态快照
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ManagerSnapshot {
+    /// 凭据条目列表
+    pub entries: Vec<CredentialEntrySnapshot>,
+    /// 总凭据数量
+    pub total: usize,
+    /// 可用凭据数量
+    pub available: usize,
+}
+
+/// 缓存余额信息（用于 Admin API）
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CachedBalanceInfo {
+    /// 凭据 ID
+    pub id: u64,
+    /// 缓存的剩余额度
+    pub remaining: f64,
+    /// 缓存时间（Unix 毫秒时间戳）
+    pub cached_at: u64,
+    /// 缓存存活时间（秒）
+    pub ttl_secs: u64,
+}
+
+/// 余额缓存条目
+struct CachedBalance {
+    remaining: f64,
+    cached_at: std::time::Instant,
+    /// 是否已初始化（区分"未获取过余额"和"余额为零"）
+    initialized: bool,
+    /// 最近一段时间的使用次数（用于判断高频/低频）
+    recent_usage: u32,
+    /// 上次重置使用计数的时间
+    usage_reset_at: std::time::Instant,
+}
+
+/// 高频渠道 TTL（10 分钟）
+const BALANCE_TTL_HIGH_FREQ_SECS: u64 = 600;
+/// 低频渠道 TTL（30 分钟）
+const BALANCE_TTL_LOW_FREQ_SECS: u64 = 1800;
+/// 低余额渠道 TTL（24 小时）
+const BALANCE_TTL_LOW_BALANCE_SECS: u64 = 86400;
+/// 高频判定阈值（10分钟内使用超过此次数视为高频）
+const HIGH_FREQ_THRESHOLD: u32 = 20;
+/// 使用计数重置周期（10 分钟）
+const USAGE_COUNT_RESET_SECS: u64 = 600;
+/// 低余额阈值
+const LOW_BALANCE_THRESHOLD: f64 = 1.0;
+
+/// 多凭据 Token 管理器
+///
+/// 支持多个凭据的管理，实现负载均衡 + 故障转移策略
+/// 故障统计基于 API 调用结果，而非 Token 刷新结果
+///
+/// ## 增强特性
+///
+/// - **多维度设备指纹**: 每个凭据生成独立的设备指纹
+/// - **后台 Token 刷新**: 定期预刷新即将过期的 Token
+/// - **精细化速率限制**: 每日请求限制、请求间隔控制
+/// - **冷却管理**: 分类管理不同原因的冷却状态
+/// - **优雅降级**: Token 刷新失败时使用现有 Token
+#[allow(dead_code)]
+pub struct MultiTokenManager {
+    config: Config,
+    proxy: Option<ProxyConfig>,
+    /// 凭据条目列表
+    entries: Mutex<Vec<CredentialEntry>>,
+    /// Token 刷新锁，确保同一时间只有一个刷新操作
+    refresh_lock: TokioMutex<()>,
+    /// 凭据文件路径（用于回写）
+    credentials_path: Option<PathBuf>,
+    /// 是否为多凭据格式（数组格式才回写）
+    is_multiple_format: bool,
+    /// MODEL_TEMPORARILY_UNAVAILABLE 错误计数
+    model_unavailable_count: AtomicU32,
+    /// 选择抖动计数器（用于同权重候选的轮询，避免总选第一个）
+    selection_rr: AtomicU64,
+    /// 全局禁用恢复时间（None 表示未被全局禁用）
+    global_recovery_time: Mutex<Option<DateTime<Utc>>>,
+    /// 用户亲和性管理器
+    affinity: UserAffinityManager,
+    /// 余额缓存（用于负载均衡和故障转移时选择最优凭据）
+    balance_cache: Mutex<HashMap<u64, CachedBalance>>,
+    /// 速率限制器
+    rate_limiter: RateLimiter,
+    /// 冷却管理器
+    cooldown_manager: CooldownManager,
+    /// 后台刷新器
+    background_refresher: Option<Arc<BackgroundRefresher>>,
+    /// 最近一次统计持久化时间（用于 debounce）
+    last_stats_save_at: Mutex<Option<Instant>>,
+    /// 统计数据是否有未落盘更新
+    stats_dirty: AtomicBool,
+}
+
+/// 凭据可用性诊断：被禁用的凭据
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+struct DisabledCredentialDiag {
+    id: u64,
+    disable_reason: Option<DisableReason>,
+    failure_count: u32,
+    priority: u32,
+}
+
+/// 凭据可用性诊断：处于冷却的凭据
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+struct CooldownCredentialDiag {
+    id: u64,
+    reason: CooldownReason,
+    remaining_ms: u64,
+}
+
+/// 凭据可用性诊断：被速率限制挡住的凭据
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+struct RateLimitedCredentialDiag {
+    id: u64,
+    wait_ms: u64,
+}
+
+/// 每个凭据最大 API 调用失败次数
+const MAX_FAILURES_PER_CREDENTIAL: u32 = 3;
+
+/// MODEL_TEMPORARILY_UNAVAILABLE 触发全局禁用的阈值
+const MODEL_UNAVAILABLE_THRESHOLD: u32 = 2;
+
+/// 全局禁用恢复时间（分钟）
+const GLOBAL_DISABLE_RECOVERY_MINUTES: i64 = 5;
+
+/// 统计数据持久化防抖间隔
+const STATS_SAVE_DEBOUNCE: StdDuration = StdDuration::from_secs(30);
+
+/// API 调用上下文
+///
+/// 绑定特定凭据的调用上下文，确保 token、credentials 和 id 的一致性
+#[derive(Clone)]
+pub struct CallContext {
+    /// 凭据 ID（用于 report_success/report_failure）
+    pub id: u64,
+    /// 凭据信息（用于构建请求头）
+    pub credentials: KiroCredentials,
+    /// 访问 Token
+    pub token: String,
+}
+
+/// 解析 symlink 目标路径
+///
+/// 优先使用 `canonicalize`（解析所有 symlink 并返回绝对路径）。
+/// 如果失败（例如目标文件不存在），则尝试用 `read_link` 解析一层 symlink。
+/// 如果都失败，返回原路径。
+fn resolve_symlink_target(path: &PathBuf) -> PathBuf {
+    // 优先尝试 canonicalize（目标文件存在时最可靠）
+    if let Ok(real) = std::fs::canonicalize(path) {
+        return real;
+    }
+
+    // canonicalize 失败（目标可能不存在），尝试 read_link 解析 symlink
+    if let Ok(target) = std::fs::read_link(path) {
+        // read_link 返回的可能是相对路径，需要相对于 symlink 所在目录解析
+        if target.is_absolute() {
+            return target;
+        }
+        if let Some(parent) = path.parent() {
+            return parent.join(target);
+        }
+        return target;
+    }
+
+    // 都失败，返回原路径
+    path.clone()
+}
+
+impl MultiTokenManager {
+    /// 创建多凭据 Token 管理器
+    ///
+    /// # Arguments
+    /// * `config` - 应用配置
+    /// * `credentials` - 凭据列表
+    /// * `proxy` - 可选的代理配置
+    /// * `credentials_path` - 凭据文件路径（用于回写）
+    /// * `is_multiple_format` - 是否为多凭据格式（数组格式才回写）
+    pub fn new(
+        config: Config,
+        credentials: Vec<KiroCredentials>,
+        proxy: Option<ProxyConfig>,
+        credentials_path: Option<PathBuf>,
+        is_multiple_format: bool,
+    ) -> anyhow::Result<Self> {
+        let rate_limit_config = {
+            let mut cfg = RateLimitConfig::default();
+            if let Some(rpm) = config.credential_rpm.filter(|&v| v > 0) {
+                // RPM -> 固定间隔（ms），例如 20 RPM => 3000ms
+                let interval_ms = (60_000u64 / rpm as u64).max(1);
+                cfg.min_interval_ms = interval_ms;
+                cfg.max_interval_ms = interval_ms;
+                // 固定间隔下抖动无意义，避免反复计算造成误差
+                cfg.jitter_percent = 0.0;
+            }
+            cfg
+        };
+
+        // 计算当前最大 ID，为没有 ID 的凭据分配新 ID
+        let max_existing_id = credentials.iter().filter_map(|c| c.id).max().unwrap_or(0);
+        let mut next_id = max_existing_id + 1;
+        let mut has_new_ids = false;
+        let mut has_new_machine_ids = false;
+        let config_ref = &config;
+
+        let entries: Vec<CredentialEntry> = credentials
+            .into_iter()
+            .map(|mut cred| {
+                cred.canonicalize_auth_method();
+                let id = cred.id.unwrap_or_else(|| {
+                    let id = next_id;
+                    next_id += 1;
+                    cred.id = Some(id);
+                    has_new_ids = true;
+                    id
+                });
+                if cred.machine_id.is_none()
+                    && let Some(machine_id) =
+                        machine_id::generate_from_credentials(&cred, config_ref)
+                {
+                    cred.machine_id = Some(machine_id);
+                    has_new_machine_ids = true;
+                }
+                // 为每个凭据生成独立的设备指纹
+                let fingerprint_seed = cred
+                    .refresh_token
+                    .as_deref()
+                    .or(cred.machine_id.as_deref())
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| format!("credential-{}", id));
+                let fingerprint = Fingerprint::generate_from_seed(&fingerprint_seed);
+
+                let refresh_token_hash = cred.refresh_token.as_deref().map(sha256_hex);
+                CredentialEntry {
+                    id,
+                    credentials: cred.clone(),
+                    failure_count: 0,
+                    disabled: cred.disabled, // 从配置文件读取 disabled 状态
+                    auto_heal_reason: if cred.disabled {
+                        Some(AutoHealReason::Manual)
+                    } else {
+                        None
+                    },
+                    disable_reason: if cred.disabled {
+                        Some(DisableReason::Manual)
+                    } else {
+                        None
+                    },
+                    fingerprint,
+                    success_count: 0,
+                    last_used_at: None,
+                    refresh_token_hash,
+                }
+            })
+            .collect();
+
+        // 检测重复 ID
+        let mut seen_ids = std::collections::HashSet::new();
+        let mut duplicate_ids = Vec::new();
+        for entry in &entries {
+            if !seen_ids.insert(entry.id) {
+                duplicate_ids.push(entry.id);
+            }
+        }
+        if !duplicate_ids.is_empty() {
+            anyhow::bail!("检测到重复的凭据 ID: {:?}", duplicate_ids);
+        }
+
+        // 初始化余额缓存（为每个凭据创建初始条目，支持负载均衡）
+        let now = std::time::Instant::now();
+        let initial_cache: HashMap<u64, CachedBalance> = entries
+            .iter()
+            .map(|e| {
+                (
+                    e.id,
+                    CachedBalance {
+                        remaining: 0.0,
+                        cached_at: now,
+                        initialized: false,
+                        recent_usage: 0,
+                        usage_reset_at: now,
+                    },
+                )
+            })
+            .collect();
+
+        let manager = Self {
+            config,
+            proxy,
+            entries: Mutex::new(entries),
+            refresh_lock: TokioMutex::new(()),
+            credentials_path,
+            is_multiple_format,
+            model_unavailable_count: AtomicU32::new(0),
+            selection_rr: AtomicU64::new(0),
+            global_recovery_time: Mutex::new(None),
+            affinity: UserAffinityManager::new(),
+            balance_cache: Mutex::new(initial_cache),
+            rate_limiter: RateLimiter::new(rate_limit_config),
+            cooldown_manager: CooldownManager::new(),
+            background_refresher: None,
+            last_stats_save_at: Mutex::new(None),
+            stats_dirty: AtomicBool::new(false),
+        };
+
+        // 如果有新分配的 ID 或新生成的 machineId，立即持久化到配置文件
+        if has_new_ids || has_new_machine_ids {
+            if let Err(e) = manager.persist_credentials() {
+                tracing::warn!("补全凭据 ID/machineId 后持久化失败: {}", e);
+            } else {
+                tracing::info!("已补全凭据 ID/machineId 并写回配置文件");
+            }
+        }
+
+        // 加载持久化的统计数据（success_count, last_used_at）
+        manager.load_stats();
+
+        Ok(manager)
+    }
+
+    /// 获取配置的引用
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+
+    /// 获取凭据总数
+    pub fn total_count(&self) -> usize {
+        self.entries.lock().len()
+    }
+
+    /// 获取可用凭据数量
+    pub fn available_count(&self) -> usize {
+        self.entries.lock().iter().filter(|e| !e.disabled).count()
+    }
+
+    /// 输出一份"为什么当前没有可用凭据"的诊断信息（用于排障）
+    ///
+    /// 注意：该方法只在 DEBUG 日志级别开启时执行，避免给正常路径引入额外开销。
+    fn debug_log_availability_diagnostics(
+        &self,
+        event: &'static str,
+        tried_ids: &[u64],
+        min_wait: Option<std::time::Duration>,
+        min_wait_detail: Option<(u64, &'static str, std::time::Duration)>,
+    ) {
+        if !tracing::enabled!(tracing::Level::DEBUG) {
+            return;
+        }
+
+        // 先快照 entries，避免在持有 entries 锁时再去访问 rate_limiter/cooldown_manager。
+        let (total, mut enabled_ids, mut disabled) = {
+            let entries = self.entries.lock();
+            let mut enabled_ids: Vec<u64> = Vec::with_capacity(entries.len());
+            let mut disabled: Vec<DisabledCredentialDiag> = Vec::new();
+
+            for e in entries.iter() {
+                if e.disabled {
+                    disabled.push(DisabledCredentialDiag {
+                        id: e.id,
+                        disable_reason: e.disable_reason,
+                        failure_count: e.failure_count,
+                        priority: e.credentials.priority,
+                    });
+                } else {
+                    enabled_ids.push(e.id);
+                }
+            }
+
+            (entries.len(), enabled_ids, disabled)
+        };
+
+        enabled_ids.sort_unstable();
+        disabled.sort_by_key(|d| d.id);
+
+        let enabled_total = enabled_ids.len();
+        let disabled_total = disabled.len();
+
+        let mut cooldowns: Vec<CooldownCredentialDiag> = Vec::new();
+        let mut rate_limited: Vec<RateLimitedCredentialDiag> = Vec::new();
+        let mut ready: Vec<u64> = Vec::new();
+
+        for id in &enabled_ids {
+            if let Some((reason, remaining)) = self.cooldown_manager.check_cooldown(*id) {
+                cooldowns.push(CooldownCredentialDiag {
+                    id: *id,
+                    reason,
+                    remaining_ms: remaining.as_millis() as u64,
+                });
+                continue;
+            }
+
+            match self.rate_limiter.check_rate_limit(*id) {
+                Ok(()) => ready.push(*id),
+                Err(wait) => rate_limited.push(RateLimitedCredentialDiag {
+                    id: *id,
+                    wait_ms: wait.as_millis() as u64,
+                }),
+            }
+        }
+
+        cooldowns.sort_by_key(|c| (c.remaining_ms, c.id));
+        rate_limited.sort_by_key(|r| (r.wait_ms, r.id));
+        ready.sort_unstable();
+
+        // 基于诊断时刻的 check_rate_limit/check_cooldown 计算"下一次可能可用"的最短等待
+        let computed_min_wait_ms = cooldowns
+            .iter()
+            .map(|c| c.remaining_ms)
+            .chain(rate_limited.iter().map(|r| r.wait_ms))
+            .min();
+
+        let min_wait_ms = min_wait.map(|d| d.as_millis() as u64);
+        let (min_wait_from_id, min_wait_source, min_wait_source_ms) = match min_wait_detail {
+            Some((id, source, d)) => (Some(id), Some(source), Some(d.as_millis() as u64)),
+            None => (None, None, None),
+        };
+
+        tracing::debug!(
+            event = event,
+            total = total,
+            enabled_total = enabled_total,
+            disabled_total = disabled_total,
+            tried = tried_ids.len(),
+            tried_ids = ?tried_ids,
+            config_credential_rpm = ?self.config.credential_rpm,
+            min_wait_ms = ?min_wait_ms,
+            min_wait_from_id = ?min_wait_from_id,
+            min_wait_source = ?min_wait_source,
+            min_wait_source_ms = ?min_wait_source_ms,
+            computed_min_wait_ms = ?computed_min_wait_ms,
+            disabled = ?disabled,
+            cooldowns = ?cooldowns,
+            rate_limited = ?rate_limited,
+            ready = ?ready,
+            "凭据可用性诊断"
+        );
+    }
+
+    /// 选择最佳凭据（两级排序：使用次数最少 + 余额最多；完全相同则轮询）
+    fn select_best_candidate_id(&self, candidate_ids: &[u64]) -> Option<u64> {
+        if candidate_ids.is_empty() {
+            return None;
+        }
+
+        let rr = self.selection_rr.fetch_add(1, Ordering::Relaxed) as usize;
+        let cache = self.balance_cache.lock();
+
+        let mut scored: Vec<(u64, u32, f64)> = Vec::with_capacity(candidate_ids.len());
+        for &id in candidate_ids {
+            let (usage, balance, initialized) = cache
+                .get(&id)
+                .map(|c| (c.recent_usage, c.remaining, c.initialized))
+                .unwrap_or((0, 0.0, false));
+            // 未初始化的凭据视为使用次数最大，避免被优先选中
+            let effective_usage = if initialized { usage } else { u32::MAX };
+            // NaN 余额归一化为 0.0，避免 total_cmp 将 NaN 视为最大值
+            let effective_balance = if balance.is_finite() { balance } else { 0.0 };
+            scored.push((id, effective_usage, effective_balance));
+        }
+
+        // 第一优先级：使用次数最少
+        let min_usage = scored.iter().map(|(_, usage, _)| *usage).min()?;
+        scored.retain(|(_, usage, _)| *usage == min_usage);
+
+        // 第二优先级：余额最多（使用次数相同）
+        let mut max_balance = scored.first().map(|(_, _, b)| *b).unwrap_or(0.0);
+        for &(_, _, balance) in &scored {
+            if balance > max_balance {
+                max_balance = balance;
+            }
+        }
+        scored.retain(|(_, _, balance)| *balance == max_balance);
+
+        if scored.len() == 1 {
+            return Some(scored[0].0);
+        }
+
+        // 兜底：完全相同则轮询，避免总选第一个
+        let index = rr % scored.len();
+        Some(scored[index].0)
+    }
+
+    /// 获取 API 调用上下文
+    ///
+    /// 返回绑定了 id、credentials 和 token 的调用上下文
+    /// 确保整个 API 调用过程中使用一致的凭据信息
+    ///
+    /// 选择策略：按优先级选择可用凭据
+    /// 如果 Token 过期或即将过期，会自动刷新
+    /// Token 刷新失败时会尝试下一个可用凭据（不计入失败次数）
+    pub async fn acquire_context(&self) -> anyhow::Result<CallContext> {
+        // 检查是否需要自动恢复
+        self.check_and_recover();
+
+        let total = self.total_count();
+        let mut tried_ids: Vec<u64> = Vec::new();
+        // 当所有凭据都因“临时不可用”（冷却/速率限制）被跳过时，等待最短可用时间再重试。
+        let mut min_wait: Option<std::time::Duration> = None;
+        // 记录最短等待时间来自哪个凭据/原因，便于排障定位（冷却 vs 速率限制）。
+        let mut min_wait_detail: Option<(u64, &'static str, std::time::Duration)> = None;
+
+        loop {
+            // tried_ids 只会记录“本轮已经尝试过的可用凭据”（disabled 的不会被选中）。
+            // 因此当存在部分 disabled 凭据时，tried_ids.len() 可能永远达不到 total，
+            // 但已用尽所有可用凭据（常见于：全部被速率限制/冷却短暂挡住）。
+            //
+            // 这里用 available_count() 判断“可用集合是否已被尝试完”，避免误报
+            // "所有凭据均已禁用（x/y）" 这类与事实不符的错误。
+            let enabled_total = self.available_count();
+            if enabled_total > 0 && tried_ids.len() >= enabled_total {
+                if let Some(wait) = min_wait {
+                    self.debug_log_availability_diagnostics(
+                        "enabled_exhausted_sleep",
+                        &tried_ids,
+                        min_wait,
+                        min_wait_detail,
+                    );
+                    tokio::time::sleep(wait).await;
+                    tried_ids.clear();
+                    min_wait = None;
+                    min_wait_detail = None;
+                    continue;
+                }
+                self.debug_log_availability_diagnostics(
+                    "enabled_exhausted_bail",
+                    &tried_ids,
+                    min_wait,
+                    min_wait_detail,
+                );
+                anyhow::bail!(
+                    "所有可用凭据均无法获取有效 Token（可用: {}/{}）",
+                    enabled_total,
+                    total
+                );
+            }
+
+            if tried_ids.len() >= total {
+                if let Some(wait) = min_wait {
+                    self.debug_log_availability_diagnostics(
+                        "total_exhausted_sleep",
+                        &tried_ids,
+                        min_wait,
+                        min_wait_detail,
+                    );
+                    tokio::time::sleep(wait).await;
+                    tried_ids.clear();
+                    min_wait = None;
+                    min_wait_detail = None;
+                    continue;
+                }
+                self.debug_log_availability_diagnostics(
+                    "total_exhausted_bail",
+                    &tried_ids,
+                    min_wait,
+                    min_wait_detail,
+                );
+                anyhow::bail!(
+                    "所有凭据均无法获取有效 Token（可用: {}/{}）",
+                    self.available_count(),
+                    total
+                );
+            }
+
+            let candidate_infos: Vec<(u64, u32)> = {
+                let mut entries = self.entries.lock();
+
+                let mut candidates: Vec<(u64, u32)> = entries
+                    .iter()
+                    .filter(|e| !e.disabled && !tried_ids.contains(&e.id))
+                    .map(|e| (e.id, e.credentials.priority))
+                    .collect();
+
+                // 没有可用凭据：如果是"自动禁用导致全灭"，做一次类似重启的自愈
+                if candidates.is_empty()
+                    && entries.iter().any(|e| {
+                        e.disabled && e.auto_heal_reason == Some(AutoHealReason::TooManyFailures)
+                    })
+                {
+                    tracing::warn!(
+                        "所有凭据均已被自动禁用，执行自愈：重置失败计数并重新启用（等价于重启）"
+                    );
+                    for e in entries.iter_mut() {
+                        if e.auto_heal_reason == Some(AutoHealReason::TooManyFailures) {
+                            e.disabled = false;
+                            e.auto_heal_reason = None;
+                            e.disable_reason = None;
+                            e.failure_count = 0;
+                        }
+                    }
+
+                    candidates = entries
+                        .iter()
+                        .filter(|e| !e.disabled && !tried_ids.contains(&e.id))
+                        .map(|e| (e.id, e.credentials.priority))
+                        .collect();
+                }
+
+                if candidates.is_empty() {
+                    let available = entries.iter().filter(|e| !e.disabled).count();
+                    if available == 0 {
+                        anyhow::bail!("所有凭据均已禁用（{}/{}）", available, total);
+                    }
+                    anyhow::bail!(
+                        "所有可用凭据均已尝试（可用: {}/{}，已尝试: {}/{}）",
+                        available,
+                        total,
+                        tried_ids.len(),
+                        available
+                    );
+                }
+
+                candidates
+            };
+
+            // 按优先级选出候选集合，再在同优先级内做负载均衡选择
+            let min_priority = candidate_infos.iter().map(|(_, p)| *p).min().unwrap_or(0);
+            let candidate_ids: Vec<u64> = candidate_infos
+                .iter()
+                .filter(|(_, p)| *p == min_priority)
+                .map(|(id, _)| *id)
+                .collect();
+            let id = self
+                .select_best_candidate_id(&candidate_ids)
+                .ok_or_else(|| anyhow::anyhow!("没有可用凭据"))?;
+
+            // 冷却/速率限制：把“临时不可用”的凭据视为本轮不可选，从而自然分流到其他凭据。
+            if let Some((reason, remaining)) = self.cooldown_manager.check_cooldown(id) {
+                tracing::trace!(
+                    credential_id = %id,
+                    reason = ?reason,
+                    remaining_ms = %remaining.as_millis(),
+                    "凭据处于冷却，跳过"
+                );
+                if min_wait.map(|w| remaining < w).unwrap_or(true) {
+                    min_wait_detail = Some((id, "cooldown", remaining));
+                }
+                min_wait = Some(min_wait.map(|w| w.min(remaining)).unwrap_or(remaining));
+                tried_ids.push(id);
+                continue;
+            }
+            if let Err(wait) = self.rate_limiter.try_acquire(id) {
+                tracing::trace!(
+                    credential_id = %id,
+                    wait_ms = %wait.as_millis(),
+                    "凭据触发速率限制，跳过"
+                );
+                if min_wait.map(|w| wait < w).unwrap_or(true) {
+                    min_wait_detail = Some((id, "rate_limit", wait));
+                }
+                min_wait = Some(min_wait.map(|w| w.min(wait)).unwrap_or(wait));
+                tried_ids.push(id);
+                continue;
+            }
+
+            let credentials = {
+                let entries = self.entries.lock();
+                entries
+                    .iter()
+                    .find(|e| e.id == id)
+                    .map(|e| e.credentials.clone())
+                    .ok_or_else(|| anyhow::anyhow!("凭据 #{} 不存在", id))?
+            };
+
+            // 尝试获取/刷新 Token
+            match self.try_ensure_token(id, &credentials).await {
+                Ok(ctx) => {
+                    return Ok(ctx);
+                }
+                Err(e) => {
+                    tracing::warn!("凭据 #{} Token 刷新失败，尝试下一个凭据: {}", id, e);
+                    tried_ids.push(id);
+                }
+            }
+        }
+    }
+
+    /// 获取指定用户的 API 调用上下文（带亲和性）
+    ///
+    /// 如果用户已绑定凭据且该凭据可用，优先使用绑定的凭据
+    /// 否则使用默认的 acquire_context() 逻辑并建立新绑定
+    pub async fn acquire_context_for_user(
+        &self,
+        user_id: Option<&str>,
+    ) -> anyhow::Result<CallContext> {
+        // 无 user_id 时走默认逻辑
+        let user_id = match user_id {
+            Some(id) if !id.is_empty() => id,
+            _ => return self.acquire_context().await,
+        };
+
+        // 默认保持用户绑定（用于连续对话）。当绑定凭据“临时不可用”（速率限制/短冷却）时，
+        // 允许分流到其他凭据，但不强制重绑，避免频繁抖动。
+        let mut keep_affinity_binding = false;
+
+        if let Some(bound_id) = self.affinity.get(user_id) {
+            let is_enabled = {
+                let entries = self.entries.lock();
+                entries.iter().any(|e| e.id == bound_id && !e.disabled)
+            };
+
+            if is_enabled {
+                if let Some((reason, remaining)) = self.cooldown_manager.check_cooldown(bound_id) {
+                    // 对“长冷却”原因不保留绑定，避免长期命中后每次都先失败再回退。
+                    keep_affinity_binding = matches!(
+                        reason,
+                        CooldownReason::RateLimitExceeded
+                            | CooldownReason::TokenRefreshFailed
+                            | CooldownReason::ServerError
+                            | CooldownReason::ModelUnavailable
+                    );
+                    tracing::debug!(
+                        user_id = %user_id,
+                        credential_id = %bound_id,
+                        reason = ?reason,
+                        remaining_ms = %remaining.as_millis(),
+                        keep_affinity_binding = %keep_affinity_binding,
+                        "亲和性绑定凭据处于冷却，本次将分流"
+                    );
+                } else if let Err(wait) = self.rate_limiter.check_rate_limit(bound_id) {
+                    // 只读检查，不消耗速率限制配额
+                    keep_affinity_binding = true;
+                    tracing::info!(
+                        user_id = %mask_user_id(Some(user_id)),
+                        credential_id = %bound_id,
+                        wait_ms = %wait.as_millis(),
+                        "亲和性绑定凭据触发速率限制，本次将分流"
+                    );
+                } else if let Err(wait) = self.rate_limiter.try_acquire(bound_id) {
+                    // check_rate_limit 通过但 try_acquire 竞争失败（TOCTOU），保留绑定分流
+                    keep_affinity_binding = true;
+                    tracing::debug!(
+                        user_id = %mask_user_id(Some(user_id)),
+                        credential_id = %bound_id,
+                        wait_ms = %wait.as_millis(),
+                        "亲和性凭据 try_acquire 竞争失败，本次将分流"
+                    );
+                } else {
+                    let credentials = {
+                        let entries = self.entries.lock();
+                        entries
+                            .iter()
+                            .find(|e| e.id == bound_id)
+                            .map(|e| e.credentials.clone())
+                    };
+
+                    match credentials {
+                        Some(creds) => match self.try_ensure_token(bound_id, &creds).await {
+                            Ok(ctx) => {
+                                self.affinity.touch(user_id);
+                                return Ok(ctx);
+                            }
+                            Err(e) => {
+                                tracing::debug!(
+                                    user_id = %user_id,
+                                    credential_id = %bound_id,
+                                    error = %e,
+                                    "亲和性绑定凭据 token 获取/刷新失败，本次将分流"
+                                );
+                            }
+                        },
+                        None => {
+                            tracing::warn!(
+                                user_id = %user_id,
+                                credential_id = %bound_id,
+                                "亲和性命中但凭据不存在，本次将分流"
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        let ctx = self.acquire_context().await?;
+        if !keep_affinity_binding {
+            self.affinity.set(user_id, ctx.id);
+        }
+        Ok(ctx)
+    }
+
+    /// 获取缓存的余额（用于故障转移选择）
+    #[allow(dead_code)]
+    fn get_cached_balance(&self, id: u64) -> f64 {
+        let cache = self.balance_cache.lock();
+        if let Some(entry) = cache.get(&id) {
+            // 动态 TTL：低余额 > 低频 > 高频
+            let ttl = if entry.remaining < LOW_BALANCE_THRESHOLD {
+                BALANCE_TTL_LOW_BALANCE_SECS
+            } else if entry.recent_usage >= HIGH_FREQ_THRESHOLD {
+                BALANCE_TTL_HIGH_FREQ_SECS
+            } else {
+                BALANCE_TTL_LOW_FREQ_SECS
+            };
+            if entry.cached_at.elapsed().as_secs() < ttl {
+                return entry.remaining;
+            }
+        }
+        // 缓存不存在或过期，返回 0（会回退到优先级选择）
+        0.0
+    }
+
+    /// 更新余额缓存
+    pub fn update_balance_cache(&self, id: u64, remaining: f64) {
+        let mut cache = self.balance_cache.lock();
+        let now = std::time::Instant::now();
+        // 保留现有使用计数
+        let (recent_usage, usage_reset_at) = cache
+            .get(&id)
+            .map(|e| (e.recent_usage, e.usage_reset_at))
+            .unwrap_or((0, now));
+        cache.insert(
+            id,
+            CachedBalance {
+                remaining,
+                cached_at: now,
+                initialized: true,
+                recent_usage,
+                usage_reset_at,
+            },
+        );
+    }
+
+    /// 检查是否需要刷新余额缓存
+    pub fn should_refresh_balance(&self, id: u64) -> bool {
+        let cache = self.balance_cache.lock();
+        if let Some(entry) = cache.get(&id) {
+            // 未初始化的缓存需要立即刷新
+            if !entry.initialized {
+                return true;
+            }
+            // 使用动态 TTL 判断是否过期
+            let ttl = if entry.remaining < LOW_BALANCE_THRESHOLD {
+                BALANCE_TTL_LOW_BALANCE_SECS
+            } else if entry.recent_usage >= HIGH_FREQ_THRESHOLD {
+                BALANCE_TTL_HIGH_FREQ_SECS
+            } else {
+                BALANCE_TTL_LOW_FREQ_SECS
+            };
+            entry.cached_at.elapsed().as_secs() >= ttl
+        } else {
+            true // 无缓存，需要刷新
+        }
+    }
+
+    /// 记录凭据使用（用于动态 TTL 计算和负载均衡）
+    pub fn record_usage(&self, id: u64) {
+        let mut cache = self.balance_cache.lock();
+        let now = std::time::Instant::now();
+        if let Some(entry) = cache.get_mut(&id) {
+            // 重置周期过期则清零
+            if entry.usage_reset_at.elapsed().as_secs() >= USAGE_COUNT_RESET_SECS {
+                entry.recent_usage = 1;
+                entry.usage_reset_at = now;
+            } else {
+                entry.recent_usage = entry.recent_usage.saturating_add(1);
+            }
+        } else {
+            // 缓存条目不存在时创建新条目（余额未知设为 0）
+            cache.insert(
+                id,
+                CachedBalance {
+                    remaining: 0.0,
+                    cached_at: now,
+                    initialized: false,
+                    recent_usage: 1,
+                    usage_reset_at: now,
+                },
+            );
+        }
+    }
+
+    /// 获取所有凭据的缓存余额信息（用于 Admin API）
+    ///
+    /// 返回每个凭据的缓存余额、缓存时间和 TTL
+    pub fn get_all_cached_balances(&self) -> Vec<CachedBalanceInfo> {
+        // 先获取 entries 的 ID 列表，避免同时持有两个锁
+        let entry_ids: Vec<u64> = {
+            let entries = self.entries.lock();
+            entries.iter().map(|e| e.id).collect()
+        };
+
+        let cache = self.balance_cache.lock();
+        let now_unix_ms = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_millis() as u64;
+
+        entry_ids
+            .iter()
+            .filter_map(|&id| {
+                cache.get(&id).map(|cached| {
+                    // 计算动态 TTL
+                    let ttl_secs = if !cached.initialized {
+                        // 未初始化的缓存，TTL 设为 0（已过期）
+                        0
+                    } else if cached.remaining < LOW_BALANCE_THRESHOLD {
+                        BALANCE_TTL_LOW_BALANCE_SECS
+                    } else if cached.recent_usage >= HIGH_FREQ_THRESHOLD {
+                        BALANCE_TTL_HIGH_FREQ_SECS
+                    } else {
+                        BALANCE_TTL_LOW_FREQ_SECS
+                    };
+
+                    // 计算缓存时间的 Unix 毫秒时间戳
+                    let elapsed_ms = cached.cached_at.elapsed().as_millis() as u64;
+                    let cached_at_unix_ms = now_unix_ms.saturating_sub(elapsed_ms);
+
+                    CachedBalanceInfo {
+                        id,
+                        remaining: cached.remaining,
+                        cached_at: cached_at_unix_ms,
+                        ttl_secs,
+                    }
+                })
+            })
+            .collect()
+    }
+
+    /// 尝试使用指定凭据获取有效 Token
+    ///
+    /// 使用双重检查锁定模式，确保同一时间只有一个刷新操作
+    ///
+    /// # Arguments
+    /// * `id` - 凭据 ID，用于更新正确的条目
+    /// * `credentials` - 凭据信息
+    async fn try_ensure_token(
+        &self,
+        id: u64,
+        credentials: &KiroCredentials,
+    ) -> anyhow::Result<CallContext> {
+        let token_missing_or_truncated = |creds: &KiroCredentials| {
+            creds
+                .access_token
+                .as_deref()
+                .is_none_or(|t| t.trim().is_empty() || t.ends_with("...") || t.contains("..."))
+        };
+
+        // 第一次检查（无锁）：快速判断是否需要刷新
+        let needs_refresh = token_missing_or_truncated(credentials)
+            || is_token_expired(credentials)
+            || is_token_expiring_soon(credentials);
+
+        let creds = if needs_refresh {
+            // 获取刷新锁，确保同一时间只有一个刷新操作
+            let _guard = self.refresh_lock.lock().await;
+
+            // 第二次检查：获取锁后重新读取凭据，因为其他请求可能已经完成刷新
+            let current_creds = {
+                let entries = self.entries.lock();
+                entries
+                    .iter()
+                    .find(|e| e.id == id)
+                    .map(|e| e.credentials.clone())
+                    .ok_or_else(|| anyhow::anyhow!("凭据 #{} 不存在", id))?
+            };
+
+            if token_missing_or_truncated(&current_creds)
+                || is_token_expired(&current_creds)
+                || is_token_expiring_soon(&current_creds)
+            {
+                // 确实需要刷新
+                let new_creds =
+                    refresh_token_with_id(&current_creds, &self.config, self.proxy.as_ref(), id)
+                        .await?;
+
+                if is_token_expired(&new_creds) {
+                    anyhow::bail!("刷新后的 Token 仍然无效或已过期");
+                }
+
+                // 更新凭据
+                {
+                    let mut entries = self.entries.lock();
+                    if let Some(entry) = entries.iter_mut().find(|e| e.id == id) {
+                        entry.credentials = new_creds.clone();
+                        // 更新哈希缓存
+                        entry.refresh_token_hash =
+                            new_creds.refresh_token.as_deref().map(sha256_hex);
+                    }
+                }
+
+                // 回写凭据到文件（仅多凭据格式），失败只记录警告
+                if let Err(e) = self.persist_credentials() {
+                    tracing::warn!("Token 刷新后持久化失败（不影响本次请求）: {}", e);
+                }
+
+                new_creds
+            } else {
+                // 其他请求已经完成刷新，直接使用新凭据
+                tracing::debug!("Token 已被其他请求刷新，跳过刷新");
+                current_creds
+            }
+        } else {
+            credentials.clone()
+        };
+
+        let token = creds
+            .access_token
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("没有可用的 accessToken"))?;
+
+        Ok(CallContext {
+            id,
+            credentials: creds,
+            token,
+        })
+    }
+
+    /// 标记指定凭据的 accessToken 失效（强制触发后续刷新）
+    ///
+    /// 用于处理上游返回「bearer token invalid」但本地 expiresAt 未及时更新的场景：
+    /// - 清空 accessToken（避免继续复用无效 token）
+    /// - 将 expiresAt 设为当前时间（确保 is_token_expired() 为 true）
+    ///
+    /// 返回是否找到并更新了该凭据。
+    pub fn invalidate_access_token(&self, id: u64) -> bool {
+        let mut entries = self.entries.lock();
+        let Some(entry) = entries.iter_mut().find(|e| e.id == id) else {
+            return false;
+        };
+
+        entry.credentials.access_token = None;
+        entry.credentials.expires_at = Some(Utc::now().to_rfc3339());
+        true
+    }
+
+    /// 将凭据列表回写到源文件
+    ///
+    /// 仅在以下条件满足时回写：
+    /// - 源文件是多凭据格式（数组）
+    /// - credentials_path 已设置
+    ///
+    /// 注意：调用方应确保适当的同步机制，避免并发写入导致数据丢失。
+    ///
+    /// # Returns
+    /// - `Ok(true)` - 成功写入文件
+    /// - `Ok(false)` - 跳过写入（非多凭据格式或无路径配置）
+    /// - `Err(_)` - 写入失败
+    fn persist_credentials(&self) -> anyhow::Result<bool> {
+        use anyhow::Context;
+
+        // 仅多凭据格式才回写
+        if !self.is_multiple_format {
+            return Ok(false);
+        }
+
+        let path = match &self.credentials_path {
+            Some(p) => p.clone(),
+            None => return Ok(false),
+        };
+
+        // 在持有 entries 锁的情况下收集凭据并序列化
+        // 这确保了快照的一致性
+        let json = {
+            let entries = self.entries.lock();
+            let credentials: Vec<KiroCredentials> = entries
+                .iter()
+                .map(|e| {
+                    let mut cred = e.credentials.clone();
+                    cred.canonicalize_auth_method();
+                    // 仅持久化手动禁用状态，自动禁用（失败阈值/额度用尽等）不落盘，
+                    // 避免重启后自动禁用被误标记为手动禁用导致无法自愈
+                    cred.disabled = e.disable_reason == Some(DisableReason::Manual);
+                    cred
+                })
+                .collect();
+            serde_json::to_string_pretty(&credentials).context("序列化凭据失败")?
+        };
+
+        // 原子写入：先写临时文件，再 rename 替换目标文件
+        // rename 在同一文件系统上是原子操作，避免进程崩溃导致凭据文件损坏
+        // 解析 symlink 以确保 rename 写入真实目标（而非替换 symlink 本身）
+        let real_path = resolve_symlink_target(&path);
+        let tmp_path = real_path.with_extension("json.tmp");
+
+        let do_atomic_write = || -> anyhow::Result<()> {
+            // 尝试保留原文件权限（避免 umask 导致权限放宽）
+            let original_perms = std::fs::metadata(&real_path).ok().map(|m| m.permissions());
+
+            std::fs::write(&tmp_path, &json)
+                .with_context(|| format!("写入临时凭据文件失败: {:?}", tmp_path))?;
+
+            if let Some(perms) = original_perms {
+                // best-effort：权限复制失败不阻塞回写
+                let _ = std::fs::set_permissions(&tmp_path, perms);
+            }
+
+            // 跨平台原子替换：Windows 上 rename 无法覆盖已存在文件，需先删除
+            #[cfg(windows)]
+            if real_path.exists() {
+                std::fs::remove_file(&real_path)
+                    .with_context(|| format!("删除旧凭据文件失败: {:?}", real_path))?;
+            }
+
+            std::fs::rename(&tmp_path, &real_path).with_context(|| {
+                format!("原子替换凭据文件失败: {:?} -> {:?}", tmp_path, real_path)
+            })?;
+            Ok(())
+        };
+
+        if tokio::runtime::Handle::try_current().is_ok() {
+            tokio::task::block_in_place(do_atomic_write)?;
+        } else {
+            do_atomic_write()?;
+        }
+
+        tracing::debug!("已回写凭据到文件: {:?}", path);
+        Ok(true)
+    }
+
+    /// 获取缓存目录（凭据文件所在目录）
+    pub fn cache_dir(&self) -> Option<PathBuf> {
+        self.credentials_path
+            .as_ref()
+            .and_then(|p| p.parent().map(|d| d.to_path_buf()))
+    }
+
+    /// 统计数据文件路径
+    fn stats_path(&self) -> Option<PathBuf> {
+        self.cache_dir().map(|d| d.join("kiro_stats.json"))
+    }
+
+    /// 从磁盘加载统计数据并应用到当前条目
+    fn load_stats(&self) {
+        let path = match self.stats_path() {
+            Some(p) => p,
+            None => return,
+        };
+
+        let content = match std::fs::read_to_string(&path) {
+            Ok(c) => c,
+            Err(_) => return, // 首次运行时文件不存在
+        };
+
+        let stats: HashMap<String, StatsEntry> = match serde_json::from_str(&content) {
+            Ok(s) => s,
+            Err(e) => {
+                tracing::warn!("解析统计缓存失败，将忽略: {}", e);
+                return;
+            }
+        };
+
+        let mut entries = self.entries.lock();
+        for entry in entries.iter_mut() {
+            if let Some(s) = stats.get(&entry.id.to_string()) {
+                entry.success_count = s.success_count;
+                entry.last_used_at = s.last_used_at.clone();
+            }
+        }
+        *self.last_stats_save_at.lock() = Some(Instant::now());
+        self.stats_dirty.store(false, Ordering::Relaxed);
+        tracing::info!("已从缓存加载 {} 条统计数据", stats.len());
+    }
+
+    /// 将当前统计数据持久化到磁盘
+    fn save_stats(&self) {
+        let path = match self.stats_path() {
+            Some(p) => p,
+            None => return,
+        };
+
+        let stats: HashMap<String, StatsEntry> = {
+            let entries = self.entries.lock();
+            entries
+                .iter()
+                .map(|e| {
+                    (
+                        e.id.to_string(),
+                        StatsEntry {
+                            success_count: e.success_count,
+                            last_used_at: e.last_used_at.clone(),
+                        },
+                    )
+                })
+                .collect()
+        };
+
+        match serde_json::to_string_pretty(&stats) {
+            Ok(json) => {
+                // 原子写入：先写临时文件，再重命名
+                let tmp_path = path.with_extension("json.tmp");
+                match std::fs::write(&tmp_path, json) {
+                    Ok(_) => {
+                        if let Err(e) = std::fs::rename(&tmp_path, &path) {
+                            tracing::warn!("原子重命名统计缓存失败: {}", e);
+                            let _ = std::fs::remove_file(&tmp_path);
+                        } else {
+                            *self.last_stats_save_at.lock() = Some(Instant::now());
+                            self.stats_dirty.store(false, Ordering::Relaxed);
+                        }
+                    }
+                    Err(e) => tracing::warn!("写入临时统计文件失败: {}", e),
+                }
+            }
+            Err(e) => tracing::warn!("序列化统计数据失败: {}", e),
+        }
+    }
+
+    /// 标记统计数据已更新，并按 debounce 策略决定是否立即落盘
+    fn save_stats_debounced(&self) {
+        self.stats_dirty.store(true, Ordering::Relaxed);
+
+        let should_flush = {
+            let last = *self.last_stats_save_at.lock();
+            match last {
+                Some(last_saved_at) => last_saved_at.elapsed() >= STATS_SAVE_DEBOUNCE,
+                None => true,
+            }
+        };
+
+        if should_flush {
+            self.save_stats();
+        }
+    }
+
+    /// 报告指定凭据 API 调用成功
+    ///
+    /// 重置该凭据的失败计数
+    ///
+    /// # Arguments
+    /// * `id` - 凭据 ID（来自 CallContext）
+    pub fn report_success(&self, id: u64) {
+        // 重置 MODEL_TEMPORARILY_UNAVAILABLE 计数器
+        self.model_unavailable_count.store(0, Ordering::SeqCst);
+
+        // 记录使用次数（用于动态 TTL）
+        self.record_usage(id);
+
+        {
+            let mut entries = self.entries.lock();
+            if let Some(entry) = entries.iter_mut().find(|e| e.id == id) {
+                entry.failure_count = 0;
+                entry.success_count += 1;
+                entry.last_used_at = Some(Utc::now().to_rfc3339());
+                tracing::debug!(
+                    "凭据 #{} API 调用成功（累计 {} 次）",
+                    id,
+                    entry.success_count
+                );
+            }
+        }
+        self.save_stats_debounced();
+    }
+
+    /// 报告指定凭据 API 调用失败
+    ///
+    /// 增加失败计数，达到阈值时禁用凭据
+    /// 返回是否还有可用凭据可以重试
+    ///
+    /// # Arguments
+    /// * `id` - 凭据 ID（来自 CallContext）
+    pub fn report_failure(&self, id: u64) -> bool {
+        let result = {
+            let mut entries = self.entries.lock();
+
+            let entry = match entries.iter_mut().find(|e| e.id == id) {
+                Some(e) => e,
+                None => return entries.iter().any(|e| !e.disabled),
+            };
+
+            entry.failure_count += 1;
+            entry.last_used_at = Some(Utc::now().to_rfc3339());
+            let failure_count = entry.failure_count;
+
+            tracing::warn!(
+                "凭据 #{} API 调用失败（{}/{}）",
+                id,
+                failure_count,
+                MAX_FAILURES_PER_CREDENTIAL
+            );
+
+            if failure_count >= MAX_FAILURES_PER_CREDENTIAL {
+                entry.disabled = true;
+                entry.auto_heal_reason = Some(AutoHealReason::TooManyFailures);
+                entry.disable_reason = Some(DisableReason::FailureLimit);
+                tracing::error!("凭据 #{} 已连续失败 {} 次，已被禁用", id, failure_count);
+
+                // 移除该凭据的亲和性绑定
+                drop(entries);
+                self.affinity.remove_by_credential(id);
+
+                let entries = self.entries.lock();
+                return entries.iter().any(|e| !e.disabled);
+            }
+
+            // 检查是否还有可用凭据
+            entries.iter().any(|e| !e.disabled)
+        };
+        self.save_stats_debounced();
+        result
+    }
+
+    /// 报告指定凭据额度已用尽
+    ///
+    /// 用于处理 402 Payment Required 且 reason 为 `MONTHLY_REQUEST_COUNT` 的场景：
+    /// - 立即禁用该凭据（不等待连续失败阈值）
+    /// - 切换到下一个可用凭据继续重试
+    /// - 返回是否还有可用凭据
+    pub fn report_quota_exhausted(&self, id: u64) -> bool {
+        let result = {
+            let mut entries = self.entries.lock();
+
+            let entry = match entries.iter_mut().find(|e| e.id == id) {
+                Some(e) => e,
+                None => return entries.iter().any(|e| !e.disabled),
+            };
+
+            if entry.disabled {
+                return entries.iter().any(|e| !e.disabled);
+            }
+
+            entry.disabled = true;
+            entry.auto_heal_reason = Some(AutoHealReason::QuotaExceeded);
+            entry.disable_reason = Some(DisableReason::QuotaExceeded);
+            entry.last_used_at = Some(Utc::now().to_rfc3339());
+            // 设为阈值，便于在管理面板中直观看到该凭据已不可用
+            entry.failure_count = MAX_FAILURES_PER_CREDENTIAL;
+
+            tracing::error!("凭据 #{} 额度已用尽（MONTHLY_REQUEST_COUNT），已被禁用", id);
+
+            entries.iter().any(|e| !e.disabled)
+        };
+        self.save_stats_debounced();
+        result
+    }
+
+    /// 报告 MODEL_TEMPORARILY_UNAVAILABLE 错误
+    ///
+    /// 累计达到阈值后禁用所有凭据，5分钟后自动恢复
+    /// 返回是否触发了全局禁用
+    pub fn report_model_unavailable(&self) -> bool {
+        let count = self.model_unavailable_count.fetch_add(1, Ordering::SeqCst) + 1;
+        tracing::warn!(
+            "MODEL_TEMPORARILY_UNAVAILABLE 错误（{}/{}）",
+            count,
+            MODEL_UNAVAILABLE_THRESHOLD
+        );
+
+        if count >= MODEL_UNAVAILABLE_THRESHOLD {
+            self.disable_all_credentials(DisableReason::ModelUnavailable);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// 禁用所有凭据
+    fn disable_all_credentials(&self, reason: DisableReason) {
+        let mut entries = self.entries.lock();
+        let mut recovery_time = self.global_recovery_time.lock();
+
+        for entry in entries.iter_mut() {
+            if !entry.disabled {
+                entry.disabled = true;
+                entry.disable_reason = Some(reason);
+            }
+        }
+
+        // 设置恢复时间
+        let recover_at = Utc::now() + Duration::minutes(GLOBAL_DISABLE_RECOVERY_MINUTES);
+        *recovery_time = Some(recover_at);
+
+        tracing::error!(
+            "所有凭据已被禁用（原因: {:?}），将于 {} 自动恢复",
+            reason,
+            recover_at.format("%H:%M:%S")
+        );
+    }
+
+    /// 检查并执行自动恢复
+    ///
+    /// 如果已到恢复时间，恢复因 ModelUnavailable 禁用的凭据
+    /// 余额不足的凭据不会被恢复
+    ///
+    /// 返回是否执行了恢复
+    pub fn check_and_recover(&self) -> bool {
+        let should_recover = {
+            let recovery_time = self.global_recovery_time.lock();
+            recovery_time.map(|t| Utc::now() >= t).unwrap_or(false)
+        };
+
+        if !should_recover {
+            return false;
+        }
+
+        let mut entries = self.entries.lock();
+        let mut recovery_time = self.global_recovery_time.lock();
+        let mut recovered_count = 0;
+
+        for entry in entries.iter_mut() {
+            // 只恢复因 ModelUnavailable 禁用的凭据，余额不足的不恢复
+            if entry.disabled && entry.disable_reason == Some(DisableReason::ModelUnavailable) {
+                entry.disabled = false;
+                entry.disable_reason = None;
+                entry.failure_count = 0;
+                recovered_count += 1;
+            }
+        }
+
+        // 重置全局状态
+        *recovery_time = None;
+        self.model_unavailable_count.store(0, Ordering::SeqCst);
+
+        if recovered_count > 0 {
+            tracing::info!("已自动恢复 {} 个凭据", recovered_count);
+        }
+
+        recovered_count > 0
+    }
+
+    /// 标记凭据为余额不足（不会被自动恢复）
+    pub fn mark_insufficient_balance(&self, id: u64) {
+        let mut entries = self.entries.lock();
+        if let Some(entry) = entries.iter_mut().find(|e| e.id == id) {
+            entry.disabled = true;
+            entry.auto_heal_reason = None; // 清除自愈原因，防止被自愈循环错误恢复
+            entry.disable_reason = Some(DisableReason::InsufficientBalance);
+            tracing::warn!("凭据 #{} 已标记为余额不足", id);
+        }
+    }
+
+    /// 获取全局恢复时间（用于 Admin API）
+    #[allow(dead_code)]
+    pub fn get_recovery_time(&self) -> Option<DateTime<Utc>> {
+        *self.global_recovery_time.lock()
+    }
+
+    /// 获取使用额度信息
+    #[allow(dead_code)]
+    pub async fn get_usage_limits(&self) -> anyhow::Result<UsageLimitsResponse> {
+        let ctx = self.acquire_context().await?;
+        get_usage_limits(
+            &ctx.credentials,
+            &self.config,
+            &ctx.token,
+            self.proxy.as_ref(),
+        )
+        .await
+    }
+
+    /// 初始化所有凭据的余额缓存
+    ///
+    /// 启动时顺序查询所有凭据的余额，每次间隔 0.5 秒避免触发限流。
+    /// 查询失败的凭据会被跳过（保持 initialized: false）。
+    ///
+    /// # 返回
+    /// - 成功初始化的凭据数量
+    pub async fn initialize_balances(&self) -> usize {
+        let credential_ids: Vec<u64> = {
+            let entries = self.entries.lock();
+            entries
+                .iter()
+                .filter(|e| !e.disabled)
+                .map(|e| e.id)
+                .collect()
+        };
+
+        if credential_ids.is_empty() {
+            tracing::info!("无可用凭据，跳过余额初始化");
+            return 0;
+        }
+
+        tracing::info!("正在初始化 {} 个凭据的余额...", credential_ids.len());
+
+        let mut success_count = 0;
+
+        // 顺序查询每个凭据的余额，间隔 0.5 秒避免触发限流
+        for (index, &id) in credential_ids.iter().enumerate() {
+            match self.get_usage_limits_for(id).await {
+                Ok(limits) => {
+                    // 计算剩余额度
+                    let used = limits.current_usage();
+                    let limit = limits.usage_limit();
+                    let remaining = (limit - used).max(0.0);
+
+                    self.update_balance_cache(id, remaining);
+
+                    // 余额小于 1 时自动禁用凭据
+                    if remaining < 1.0 {
+                        let mut entries = self.entries.lock();
+                        if let Some(entry) = entries.iter_mut().find(|e| e.id == id) {
+                            entry.disabled = true;
+                            entry.disable_reason = Some(DisableReason::InsufficientBalance);
+                            tracing::warn!("凭据 #{} 余额不足 ({:.2})，已自动禁用", id, remaining);
+                        }
+                    } else {
+                        tracing::info!("凭据 #{} 余额初始化成功: {:.2}", id, remaining);
+                    }
+                    success_count += 1;
+                }
+                Err(e) => {
+                    tracing::warn!("凭据 #{} 余额查询失败: {}", id, e);
+                }
+            }
+
+            // 非最后一个凭据时，间隔 0.5 秒
+            if index < credential_ids.len() - 1 {
+                tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+            }
+        }
+
+        tracing::info!(
+            "余额初始化完成: {}/{} 成功",
+            success_count,
+            credential_ids.len()
+        );
+
+        success_count
+    }
+
+    // ========================================================================
+    // Admin API 方法
+    // ========================================================================
+
+    /// 获取管理器状态快照（用于 Admin API）
+    pub fn snapshot(&self) -> ManagerSnapshot {
+        let entries = self.entries.lock();
+        let available = entries.iter().filter(|e| !e.disabled).count();
+
+        ManagerSnapshot {
+            entries: entries
+                .iter()
+                .map(|e| {
+                    // 使用缓存的哈希，如果不存在则计算并缓存
+                    let hash = e
+                        .refresh_token_hash
+                        .clone()
+                        .or_else(|| e.credentials.refresh_token.as_deref().map(sha256_hex));
+
+                    CredentialEntrySnapshot {
+                        id: e.id,
+                        priority: e.credentials.priority,
+                        disabled: e.disabled,
+                        disable_reason: e.disable_reason,
+                        failure_count: e.failure_count,
+                        auth_method: e.credentials.auth_method.as_deref().map(|m| {
+                            if m.eq_ignore_ascii_case("builder-id") || m.eq_ignore_ascii_case("iam")
+                            {
+                                "idc".to_string()
+                            } else {
+                                m.to_string()
+                            }
+                        }),
+                        has_profile_arn: e.credentials.profile_arn.is_some(),
+                        expires_at: e.credentials.expires_at.clone(),
+                        refresh_token_hash: hash,
+                        email: e.credentials.email.clone(),
+                        success_count: e.success_count,
+                        last_used_at: e.last_used_at.clone(),
+                        region: e.credentials.region.clone(),
+                        api_region: e.credentials.api_region.clone(),
+                    }
+                })
+                .collect(),
+            total: entries.len(),
+            available,
+        }
+    }
+
+    /// 设置凭据禁用状态（Admin API）
+    pub fn set_disabled(&self, id: u64, disabled: bool) -> anyhow::Result<()> {
+        {
+            let mut entries = self.entries.lock();
+            let entry = entries
+                .iter_mut()
+                .find(|e| e.id == id)
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?;
+            entry.disabled = disabled;
+            if !disabled {
+                // 启用时重置失败计数
+                entry.failure_count = 0;
+                entry.auto_heal_reason = None;
+                entry.disable_reason = None;
+            } else {
+                entry.auto_heal_reason = Some(AutoHealReason::Manual);
+                entry.disable_reason = Some(DisableReason::Manual);
+            }
+        }
+        // 持久化更改
+        self.persist_credentials()?;
+        Ok(())
+    }
+
+    /// 设置凭据优先级（Admin API）
+    pub fn set_priority(&self, id: u64, priority: u32) -> anyhow::Result<()> {
+        {
+            let mut entries = self.entries.lock();
+            let entry = entries
+                .iter_mut()
+                .find(|e| e.id == id)
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?;
+            entry.credentials.priority = priority;
+        }
+        // 持久化更改
+        self.persist_credentials()?;
+        Ok(())
+    }
+
+    /// 设置凭据 Region（Admin API）
+    pub fn set_region(
+        &self,
+        id: u64,
+        region: Option<String>,
+        api_region: Option<String>,
+    ) -> anyhow::Result<()> {
+        {
+            let mut entries = self.entries.lock();
+            let entry = entries
+                .iter_mut()
+                .find(|e| e.id == id)
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?;
+            entry.credentials.region = region;
+            entry.credentials.api_region = api_region;
+        }
+        self.persist_credentials()?;
+        Ok(())
+    }
+
+    /// 重置凭据失败计数并重新启用（Admin API）
+    pub fn reset_and_enable(&self, id: u64) -> anyhow::Result<()> {
+        {
+            let mut entries = self.entries.lock();
+            let entry = entries
+                .iter_mut()
+                .find(|e| e.id == id)
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?;
+            entry.failure_count = 0;
+            entry.disabled = false;
+            entry.auto_heal_reason = None;
+            entry.disable_reason = None;
+        }
+        // 持久化更改
+        self.persist_credentials()?;
+        Ok(())
+    }
+
+    /// 获取指定凭据的使用额度（Admin API）
+    pub async fn get_usage_limits_for(&self, id: u64) -> anyhow::Result<UsageLimitsResponse> {
+        let credentials = {
+            let entries = self.entries.lock();
+            entries
+                .iter()
+                .find(|e| e.id == id)
+                .map(|e| e.credentials.clone())
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?
+        };
+
+        // 检查是否需要刷新 token
+        let needs_refresh = is_token_expired(&credentials) || is_token_expiring_soon(&credentials);
+
+        let token = if needs_refresh {
+            let _guard = self.refresh_lock.lock().await;
+            let current_creds = {
+                let entries = self.entries.lock();
+                entries
+                    .iter()
+                    .find(|e| e.id == id)
+                    .map(|e| e.credentials.clone())
+                    .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?
+            };
+
+            if is_token_expired(&current_creds) || is_token_expiring_soon(&current_creds) {
+                let new_creds =
+                    refresh_token_with_id(&current_creds, &self.config, self.proxy.as_ref(), id)
+                        .await?;
+                {
+                    let mut entries = self.entries.lock();
+                    if let Some(entry) = entries.iter_mut().find(|e| e.id == id) {
+                        entry.credentials = new_creds.clone();
+                        // 更新哈希缓存
+                        entry.refresh_token_hash =
+                            new_creds.refresh_token.as_deref().map(sha256_hex);
+                    }
+                }
+                // 持久化失败只记录警告，不影响本次请求
+                if let Err(e) = self.persist_credentials() {
+                    tracing::warn!("Token 刷新后持久化失败（不影响本次请求）: {}", e);
+                }
+                new_creds
+                    .access_token
+                    .ok_or_else(|| anyhow::anyhow!("刷新后无 access_token"))?
+            } else {
+                current_creds
+                    .access_token
+                    .ok_or_else(|| anyhow::anyhow!("凭据无 access_token"))?
+            }
+        } else {
+            credentials
+                .access_token
+                .ok_or_else(|| anyhow::anyhow!("凭据无 access_token"))?
+        };
+
+        let credentials = {
+            let entries = self.entries.lock();
+            entries
+                .iter()
+                .find(|e| e.id == id)
+                .map(|e| e.credentials.clone())
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?
+        };
+
+        get_usage_limits(&credentials, &self.config, &token, self.proxy.as_ref()).await
+    }
+
+    /// 添加新凭据（Admin API）
+    ///
+    /// # 流程
+    /// 1. 验证凭据基本字段（refresh_token 不为空）
+    /// 2. 基于 refreshToken 的 SHA-256 哈希检测重复
+    /// 3. 尝试刷新 Token 验证凭据有效性
+    /// 4. 分配新 ID（当前最大 ID + 1）
+    /// 5. 添加到 entries 列表
+    /// 6. 持久化到配置文件
+    ///
+    /// # 返回
+    /// - `Ok(u64)` - 新凭据 ID
+    /// - `Err(_)` - 验证失败或添加失败
+    pub async fn add_credential(&self, new_cred: KiroCredentials) -> anyhow::Result<u64> {
+        // 1. 基本验证
+        validate_refresh_token(&new_cred)?;
+
+        // 2. 基于 refreshToken 的 SHA-256 哈希检测重复
+        let new_refresh_token = new_cred
+            .refresh_token
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("缺少 refreshToken"))?;
+        let new_refresh_token_hash = sha256_hex(new_refresh_token);
+        let duplicate_exists = {
+            let entries = self.entries.lock();
+            entries.iter().any(|entry| {
+                let hash = entry
+                    .refresh_token_hash
+                    .clone()
+                    .or_else(|| entry.credentials.refresh_token.as_deref().map(sha256_hex));
+                hash.as_deref() == Some(new_refresh_token_hash.as_str())
+            })
+        };
+        if duplicate_exists {
+            anyhow::bail!("凭据已存在（refreshToken 重复）");
+        }
+
+        // 3. 尝试刷新 Token 验证凭据有效性
+        let mut validated_cred =
+            refresh_token(&new_cred, &self.config, self.proxy.as_ref()).await?;
+
+        // 4. 分配新 ID
+        let new_id = {
+            let entries = self.entries.lock();
+            entries.iter().map(|e| e.id).max().unwrap_or(0) + 1
+        };
+
+        // 5. 设置 ID 并保留用户输入的元数据
+        validated_cred.id = Some(new_id);
+        validated_cred.priority = new_cred.priority;
+        validated_cred.auth_method = new_cred.auth_method.map(|m| {
+            if m.eq_ignore_ascii_case("builder-id") || m.eq_ignore_ascii_case("iam") {
+                "idc".to_string()
+            } else {
+                m
+            }
+        });
+        validated_cred.client_id = new_cred.client_id;
+        validated_cred.client_secret = new_cred.client_secret;
+        validated_cred.region = new_cred.region;
+        validated_cred.machine_id = new_cred.machine_id;
+        validated_cred.email = new_cred.email;
+
+        // 为新凭据生成设备指纹
+        let fingerprint_seed = validated_cred
+            .refresh_token
+            .as_deref()
+            .or(validated_cred.machine_id.as_deref())
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| format!("credential-{}", new_id));
+        let fingerprint = Fingerprint::generate_from_seed(&fingerprint_seed);
+
+        {
+            let mut entries = self.entries.lock();
+            entries.push(CredentialEntry {
+                id: new_id,
+                credentials: validated_cred,
+                failure_count: 0,
+                disabled: false,
+                auto_heal_reason: None,
+                disable_reason: None,
+                fingerprint,
+                success_count: 0,
+                last_used_at: None,
+                refresh_token_hash: new_cred.refresh_token.as_deref().map(sha256_hex),
+            });
+        }
+
+        // 6. 持久化
+        self.persist_credentials()?;
+
+        tracing::info!("成功添加凭据 #{}", new_id);
+        Ok(new_id)
+    }
+
+    /// 删除凭据（Admin API）
+    ///
+    /// # 前置条件
+    /// - 凭据必须已禁用（disabled = true）
+    ///
+    /// # 行为
+    /// 1. 验证凭据存在
+    /// 2. 验证凭据已禁用
+    /// 3. 从 entries 移除
+    /// 4. 持久化到文件
+    ///
+    /// # 返回
+    /// - `Ok(())` - 删除成功
+    /// - `Err(_)` - 凭据不存在、未禁用或持久化失败
+    pub fn delete_credential(&self, id: u64) -> anyhow::Result<()> {
+        {
+            let mut entries = self.entries.lock();
+
+            // 查找凭据
+            let entry = entries
+                .iter()
+                .find(|e| e.id == id)
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?;
+
+            // 检查是否已禁用
+            if !entry.disabled {
+                anyhow::bail!("只能删除已禁用的凭据（请先禁用凭据 #{}）", id);
+            }
+
+            // 删除凭据
+            entries.retain(|e| e.id != id);
+        }
+
+        // 持久化更改
+        self.persist_credentials()?;
+
+        // 立即回写统计数据，清除已删除凭据的残留条目
+        self.save_stats();
+
+        tracing::info!("已删除凭据 #{}", id);
+        Ok(())
+    }
+
+    /// 检查是否存在具有相同 refreshToken 前缀的凭据
+    ///
+    /// 用于批量导入时的去重检查，通过比较 refreshToken 前 32 字符判断是否重复
+    /// 使用 floor_char_boundary 安全截断，避免在多字节字符中间切割导致 panic
+    pub fn has_refresh_token_prefix(&self, refresh_token: &str) -> bool {
+        let prefix_len = floor_char_boundary(refresh_token, 32);
+        let new_prefix = &refresh_token[..prefix_len];
+
+        let entries = self.entries.lock();
+        entries.iter().any(|e| {
+            e.credentials
+                .refresh_token
+                .as_ref()
+                .map(|rt| {
+                    let existing_prefix_len = floor_char_boundary(rt, 32);
+                    &rt[..existing_prefix_len] == new_prefix
+                })
+                .unwrap_or(false)
+        })
+    }
+
+    // ========================================================================
+    // 增强特性：设备指纹、速率限制、冷却管理、后台刷新
+    // ========================================================================
+
+    #[allow(dead_code)]
+    /// 获取凭据的设备指纹
+    pub fn get_fingerprint(&self, id: u64) -> Option<Fingerprint> {
+        let entries = self.entries.lock();
+        entries
+            .iter()
+            .find(|e| e.id == id)
+            .map(|e| e.fingerprint.clone())
+    }
+
+    #[allow(dead_code)]
+    /// 获取速率限制器引用
+    pub fn rate_limiter(&self) -> &RateLimiter {
+        &self.rate_limiter
+    }
+
+    /// 获取冷却管理器引用
+    #[allow(dead_code)]
+    pub fn cooldown_manager(&self) -> &CooldownManager {
+        &self.cooldown_manager
+    }
+
+    /// 检查凭据是否可用（综合检查：未禁用、未冷却、未超速率限制）
+    #[allow(dead_code)]
+    pub fn is_credential_available(&self, id: u64) -> bool {
+        // 检查是否禁用
+        let is_disabled = {
+            let entries = self.entries.lock();
+            entries
+                .iter()
+                .find(|e| e.id == id)
+                .map(|e| e.disabled)
+                .unwrap_or(true)
+        };
+        if is_disabled {
+            return false;
+        }
+
+        // 检查冷却状态
+        if !self.cooldown_manager.is_available(id) {
+            return false;
+        }
+
+        // 检查速率限制
+        self.rate_limiter.check_rate_limit(id).is_ok()
+    }
+
+    /// 设置凭据冷却（带原因分类）
+    #[allow(dead_code)]
+    pub fn set_credential_cooldown(&self, id: u64, reason: CooldownReason) -> std::time::Duration {
+        self.cooldown_manager.set_cooldown(id, reason)
+    }
+
+    /// 清除凭据冷却
+    #[allow(dead_code)]
+    pub fn clear_credential_cooldown(&self, id: u64) -> bool {
+        self.cooldown_manager.clear_cooldown(id)
+    }
+
+    /// 获取即将过期的凭据 ID 列表
+    ///
+    /// # Arguments
+    /// * `minutes_before_expiry` - 过期前多少分钟视为即将过期
+    #[allow(dead_code)]
+    pub fn get_expiring_credential_ids(&self, minutes_before_expiry: i64) -> Vec<u64> {
+        let entries = self.entries.lock();
+        entries
+            .iter()
+            .filter(|e| {
+                !e.disabled
+                    && is_token_expiring_within(&e.credentials, minutes_before_expiry)
+                        .unwrap_or(false)
+            })
+            .map(|e| e.id)
+            .collect()
+    }
+
+    /// 启动后台 Token 刷新任务
+    ///
+    /// 定期检查并预刷新即将过期的 Token，避免请求时的刷新延迟。
+    /// 返回 `BackgroundRefresher` 的 `Arc` 引用，调用方需要保持该引用以维持后台任务运行。
+    #[allow(dead_code)]
+    pub fn start_background_refresh(
+        self: &Arc<Self>,
+        config: BackgroundRefreshConfig,
+    ) -> Arc<BackgroundRefresher> {
+        let refresher = Arc::new(BackgroundRefresher::new(config.clone()));
+        let manager = Arc::clone(self);
+        let manager_for_ids = Arc::clone(self);
+
+        let refresh_before_mins = config.refresh_before_expiry_mins;
+
+        if let Err(e) = refresher.start(
+            move |id| {
+                let manager = Arc::clone(&manager);
+                Box::pin(async move {
+                    match manager.refresh_token_for_credential(id).await {
+                        Ok(_) => {
+                            tracing::debug!("后台刷新凭据 #{} Token 成功", id);
+                            true
+                        }
+                        Err(e) => {
+                            tracing::warn!("后台刷新凭据 #{} Token 失败: {}", id, e);
+                            false
+                        }
+                    }
+                })
+            },
+            move |mins| manager_for_ids.get_expiring_credential_ids(mins.max(refresh_before_mins)),
+        ) {
+            tracing::error!("启动后台刷新任务失败: {}", e);
+        }
+
+        tracing::info!("后台 Token 刷新任务已启动");
+        refresher
+    }
+
+    /// 刷新指定凭据的 Token（带优雅降级）
+    ///
+    /// 如果刷新失败但现有 Token 仍有效，返回现有 Token（优雅降级）
+    #[allow(dead_code)]
+    pub async fn refresh_token_for_credential(&self, id: u64) -> anyhow::Result<RefreshResult> {
+        let credentials = {
+            let entries = self.entries.lock();
+            entries
+                .iter()
+                .find(|e| e.id == id)
+                .map(|e| e.credentials.clone())
+                .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?
+        };
+
+        // 尝试刷新
+        match refresh_token_with_id(&credentials, &self.config, self.proxy.as_ref(), id).await {
+            Ok(new_creds) => {
+                // 更新凭据
+                {
+                    let mut entries = self.entries.lock();
+                    if let Some(entry) = entries.iter_mut().find(|e| e.id == id) {
+                        entry.credentials = new_creds.clone();
+                        // 更新哈希缓存
+                        entry.refresh_token_hash =
+                            new_creds.refresh_token.as_deref().map(sha256_hex);
+                    }
+                }
+
+                // 持久化
+                if let Err(e) = self.persist_credentials() {
+                    tracing::warn!("Token 刷新后持久化失败: {}", e);
+                }
+
+                let expires_at = new_creds.expires_at.unwrap_or_default();
+                Ok(RefreshResult::success(id, expires_at))
+            }
+            Err(e) => {
+                // 优雅降级：检查现有 Token 是否仍有效
+                if !is_token_expired(&credentials) {
+                    let expires_at = credentials.expires_at.unwrap_or_default();
+                    tracing::warn!(
+                        "凭据 #{} Token 刷新失败，使用现有 Token（优雅降级）: {}",
+                        id,
+                        e
+                    );
+                    Ok(RefreshResult::fallback(id, expires_at))
+                } else {
+                    // 设置冷却
+                    self.cooldown_manager
+                        .set_cooldown(id, CooldownReason::TokenRefreshFailed);
+                    Err(e)
+                }
+            }
+        }
+    }
+
+    /// 记录 API 调用成功（更新速率限制器）
+    #[allow(dead_code)]
+    pub fn record_api_success(&self, id: u64) {
+        self.report_success(id);
+        self.rate_limiter.record_success(id);
+    }
+
+    /// 记录 API 调用失败（更新速率限制器和冷却管理器）
+    #[allow(dead_code)]
+    pub fn record_api_failure(&self, id: u64, error_message: Option<&str>) -> bool {
+        let has_available = self.report_failure(id);
+
+        // 更新速率限制器
+        let backoff = self.rate_limiter.record_failure(id, error_message);
+        tracing::debug!("凭据 #{} 退避时间: {:?}", id, backoff);
+
+        has_available
+    }
+
+    /// 清理过期的冷却状态
+    #[allow(dead_code)]
+    pub fn cleanup_expired_cooldowns(&self) -> usize {
+        self.cooldown_manager.cleanup_expired()
+    }
+}
+
+impl Drop for MultiTokenManager {
+    fn drop(&mut self) {
+        if self.stats_dirty.load(Ordering::Relaxed) {
+            self.save_stats();
+        }
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::field_reassign_with_default)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_token_manager_new() {
+        let config = Config::default();
+        let credentials = KiroCredentials::default();
+        let tm = TokenManager::new(config, credentials, None);
+        assert!(tm.credentials().access_token.is_none());
+    }
+
+    #[test]
+    fn test_is_token_expired_with_expired_token() {
+        let mut credentials = KiroCredentials::default();
+        credentials.expires_at = Some("2020-01-01T00:00:00Z".to_string());
+        assert!(is_token_expired(&credentials));
+    }
+
+    #[test]
+    fn test_is_token_expired_with_valid_token() {
+        let mut credentials = KiroCredentials::default();
+        let future = Utc::now() + Duration::hours(1);
+        credentials.expires_at = Some(future.to_rfc3339());
+        assert!(!is_token_expired(&credentials));
+    }
+
+    #[test]
+    fn test_is_token_expired_within_5_minutes() {
+        let mut credentials = KiroCredentials::default();
+        let expires = Utc::now() + Duration::minutes(3);
+        credentials.expires_at = Some(expires.to_rfc3339());
+        assert!(is_token_expired(&credentials));
+    }
+
+    #[test]
+    fn test_is_token_expired_no_expires_at() {
+        let credentials = KiroCredentials::default();
+        assert!(is_token_expired(&credentials));
+    }
+
+    #[test]
+    fn test_is_token_expiring_soon_within_10_minutes() {
+        let mut credentials = KiroCredentials::default();
+        let expires = Utc::now() + Duration::minutes(8);
+        credentials.expires_at = Some(expires.to_rfc3339());
+        assert!(is_token_expiring_soon(&credentials));
+    }
+
+    #[test]
+    fn test_is_token_expiring_soon_beyond_10_minutes() {
+        let mut credentials = KiroCredentials::default();
+        let expires = Utc::now() + Duration::minutes(15);
+        credentials.expires_at = Some(expires.to_rfc3339());
+        assert!(!is_token_expiring_soon(&credentials));
+    }
+
+    #[test]
+    fn test_validate_refresh_token_missing() {
+        let credentials = KiroCredentials::default();
+        let result = validate_refresh_token(&credentials);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_validate_refresh_token_valid() {
+        let mut credentials = KiroCredentials::default();
+        credentials.refresh_token = Some("a".repeat(150));
+        let result = validate_refresh_token(&credentials);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_sha256_hex() {
+        let result = sha256_hex("test");
+        assert_eq!(
+            result,
+            "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_add_credential_reject_duplicate_refresh_token() {
+        let config = Config::default();
+
+        let mut existing = KiroCredentials::default();
+        existing.refresh_token = Some("a".repeat(150));
+
+        let manager = MultiTokenManager::new(config, vec![existing], None, None, false).unwrap();
+
+        let mut duplicate = KiroCredentials::default();
+        duplicate.refresh_token = Some("a".repeat(150));
+
+        let result = manager.add_credential(duplicate).await;
+        assert!(result.is_err());
+        assert!(result.err().unwrap().to_string().contains("凭据已存在"));
+    }
+
+    // MultiTokenManager 测试
+
+    #[test]
+    fn test_multi_token_manager_new() {
+        let config = Config::default();
+        let mut cred1 = KiroCredentials::default();
+        cred1.priority = 0;
+        let mut cred2 = KiroCredentials::default();
+        cred2.priority = 1;
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+        assert_eq!(manager.total_count(), 2);
+        assert_eq!(manager.available_count(), 2);
+    }
+
+    #[test]
+    fn test_invalidate_access_token_marks_expired() {
+        let config = Config::default();
+        let mut credentials = KiroCredentials::default();
+        credentials.refresh_token = Some("a".repeat(150));
+        credentials.access_token = Some("some_token".to_string());
+        credentials.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+
+        let manager = MultiTokenManager::new(config, vec![credentials], None, None, false).unwrap();
+        assert!(manager.invalidate_access_token(1));
+
+        let snapshot = manager.snapshot();
+        let entry = snapshot.entries.iter().find(|e| e.id == 1).unwrap();
+        let mut cred = KiroCredentials::default();
+        cred.expires_at = entry.expires_at.clone();
+        assert!(is_token_expired(&cred));
+    }
+
+    #[test]
+    fn test_multi_token_manager_empty_credentials() {
+        let config = Config::default();
+        let result = MultiTokenManager::new(config, vec![], None, None, false);
+        // 支持 0 个凭据启动（可通过管理面板添加）
+        assert!(result.is_ok());
+        let manager = result.unwrap();
+        assert_eq!(manager.total_count(), 0);
+        assert_eq!(manager.available_count(), 0);
+    }
+
+    #[test]
+    fn test_multi_token_manager_duplicate_ids() {
+        let config = Config::default();
+        let mut cred1 = KiroCredentials::default();
+        cred1.id = Some(1);
+        let mut cred2 = KiroCredentials::default();
+        cred2.id = Some(1); // 重复 ID
+
+        let result = MultiTokenManager::new(config, vec![cred1, cred2], None, None, false);
+        assert!(result.is_err());
+        let err_msg = result.err().unwrap().to_string();
+        assert!(
+            err_msg.contains("重复的凭据 ID"),
+            "错误消息应包含 '重复的凭据 ID'，实际: {}",
+            err_msg
+        );
+    }
+
+    #[test]
+    fn test_multi_token_manager_report_failure() {
+        let config = Config::default();
+        let cred1 = KiroCredentials::default();
+        let cred2 = KiroCredentials::default();
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        // 凭据会自动分配 ID（从 1 开始）
+        // MAX_FAILURES_PER_CREDENTIAL = 3，所以前两次失败不会禁用
+        assert!(manager.report_failure(1));
+        assert_eq!(manager.available_count(), 2);
+        assert!(manager.report_failure(1));
+        assert_eq!(manager.available_count(), 2);
+
+        // 第三次失败会禁用第一个凭据
+        assert!(manager.report_failure(1));
+        assert_eq!(manager.available_count(), 1);
+
+        // 继续失败第二个凭据（使用 ID 2），需要 3 次才会禁用
+        assert!(manager.report_failure(2));
+        assert!(manager.report_failure(2));
+        assert!(!manager.report_failure(2)); // 所有凭据都禁用了
+        assert_eq!(manager.available_count(), 0);
+    }
+
+    #[test]
+    fn test_multi_token_manager_report_success() {
+        let config = Config::default();
+        let cred = KiroCredentials::default();
+
+        let manager = MultiTokenManager::new(config, vec![cred], None, None, false).unwrap();
+
+        // 失败一次（使用 ID 1）
+        manager.report_failure(1);
+
+        // 成功后重置计数（使用 ID 1）
+        manager.report_success(1);
+
+        // 再失败一次不会禁用（因为计数已重置）
+        manager.report_failure(1);
+        assert_eq!(manager.available_count(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_multi_token_manager_acquire_context_auto_recovers_all_disabled() {
+        let config = Config::default();
+        let mut cred1 = KiroCredentials::default();
+        cred1.access_token = Some("t1".to_string());
+        cred1.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+        let mut cred2 = KiroCredentials::default();
+        cred2.access_token = Some("t2".to_string());
+        cred2.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        // 凭据会自动分配 ID（从 1 开始）
+        for _ in 0..MAX_FAILURES_PER_CREDENTIAL {
+            manager.report_failure(1);
+        }
+        for _ in 0..MAX_FAILURES_PER_CREDENTIAL {
+            manager.report_failure(2);
+        }
+
+        assert_eq!(manager.available_count(), 0);
+
+        // 应触发自愈：重置失败计数并重新启用，避免必须重启进程
+        let ctx = manager.acquire_context().await.unwrap();
+        assert!(ctx.token == "t1" || ctx.token == "t2");
+        assert_eq!(manager.available_count(), 2);
+    }
+
+    #[tokio::test]
+    async fn test_multi_token_manager_acquire_context_prefers_higher_balance_when_usage_equal() {
+        let config = Config::default();
+        let mut cred1 = KiroCredentials::default();
+        cred1.access_token = Some("t1".to_string());
+        cred1.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+        let mut cred2 = KiroCredentials::default();
+        cred2.access_token = Some("t2".to_string());
+        cred2.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        // 两个凭据使用次数都为 0 时，应优先选择余额更高的
+        manager.update_balance_cache(1, 100.0);
+        manager.update_balance_cache(2, 200.0);
+
+        let ctx = manager.acquire_context().await.unwrap();
+        assert_eq!(ctx.id, 2);
+    }
+
+    #[tokio::test]
+    async fn test_multi_token_manager_acquire_context_round_robin_when_balance_and_usage_equal() {
+        let config = Config::default();
+        let mut cred1 = KiroCredentials::default();
+        cred1.access_token = Some("t1".to_string());
+        cred1.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+        let mut cred2 = KiroCredentials::default();
+        cred2.access_token = Some("t2".to_string());
+        cred2.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        manager.update_balance_cache(1, 100.0);
+        manager.update_balance_cache(2, 100.0);
+
+        let ctx1 = manager.acquire_context().await.unwrap();
+        let ctx2 = manager.acquire_context().await.unwrap();
+        assert_ne!(ctx1.id, ctx2.id);
+    }
+
+    #[test]
+    fn test_multi_token_manager_report_quota_exhausted() {
+        let config = Config::default();
+        let cred1 = KiroCredentials::default();
+        let cred2 = KiroCredentials::default();
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        // 凭据会自动分配 ID（从 1 开始）
+        assert_eq!(manager.available_count(), 2);
+        assert!(manager.report_quota_exhausted(1));
+        assert_eq!(manager.available_count(), 1);
+
+        // 再禁用第二个后，无可用凭据
+        assert!(!manager.report_quota_exhausted(2));
+        assert_eq!(manager.available_count(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_multi_token_manager_quota_disabled_is_not_auto_recovered() {
+        let config = Config::default();
+        let cred1 = KiroCredentials::default();
+        let cred2 = KiroCredentials::default();
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        manager.report_quota_exhausted(1);
+        manager.report_quota_exhausted(2);
+        assert_eq!(manager.available_count(), 0);
+
+        let err = manager.acquire_context().await.err().unwrap().to_string();
+        assert!(
+            err.contains("所有凭据均已禁用"),
+            "错误应提示所有凭据禁用，实际: {}",
+            err
+        );
+        assert_eq!(manager.available_count(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_multi_token_manager_rate_limited_with_some_disabled_does_not_report_all_disabled()
+    {
+        // 复现线上日志：
+        // - total > available（部分凭据被禁用）
+        // - 所有可用凭据都被速率限制/冷却暂时挡住
+        // 期望：等待最短可用时间后继续尝试，而不是误报“所有凭据均已禁用（x/y）”。
+
+        let mut config = Config::default();
+        // 固定间隔 10ms，避免测试过慢且消除抖动带来的不确定性
+        config.credential_rpm = Some(6000);
+
+        let cred1 = KiroCredentials {
+            access_token: Some("token-1".to_string()),
+            expires_at: Some("2999-01-01T00:00:00Z".to_string()),
+            ..Default::default()
+        };
+        let cred2 = KiroCredentials {
+            access_token: Some("token-2".to_string()),
+            expires_at: Some("2999-01-01T00:00:00Z".to_string()),
+            ..Default::default()
+        };
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        // 禁用 #2，仅保留一个可用凭据
+        assert!(manager.report_quota_exhausted(2));
+        assert_eq!(manager.available_count(), 1);
+
+        // 预先占位：让 #1 在下一次 acquire_context() 时必然触发速率限制
+        assert!(manager.rate_limiter().try_acquire(1).is_ok());
+
+        // 关键断言：不会抛出“所有凭据均已禁用（1/2）”，而是等待后成功返回。
+        let ctx = manager.acquire_context().await.unwrap();
+        assert_eq!(ctx.id, 1);
+    }
+
+    // ============ 凭据级 Region 优先级测试 ============
+
+    /// 辅助函数：获取 OIDC 刷新使用的 region（用于测试）
+    fn get_oidc_region_for_credential<'a>(
+        credentials: &'a KiroCredentials,
+        config: &'a Config,
+    ) -> &'a str {
+        credentials.region.as_ref().unwrap_or(&config.region)
+    }
+
+    #[test]
+    fn test_credential_region_priority_uses_credential_region() {
+        // 凭据配置了 region 时，应使用凭据的 region
+        let mut config = Config::default();
+        config.region = "us-west-2".to_string();
+
+        let mut credentials = KiroCredentials::default();
+        credentials.region = Some("eu-west-1".to_string());
+
+        let region = get_oidc_region_for_credential(&credentials, &config);
+        assert_eq!(region, "eu-west-1");
+    }
+
+    #[test]
+    fn test_credential_region_priority_fallback_to_config() {
+        // 凭据未配置 region 时，应回退到 config.region
+        let mut config = Config::default();
+        config.region = "us-west-2".to_string();
+
+        let credentials = KiroCredentials::default();
+        assert!(credentials.region.is_none());
+
+        let region = get_oidc_region_for_credential(&credentials, &config);
+        assert_eq!(region, "us-west-2");
+    }
+
+    #[test]
+    fn test_multiple_credentials_use_respective_regions() {
+        // 多凭据场景下，不同凭据使用各自的 region
+        let mut config = Config::default();
+        config.region = "ap-northeast-1".to_string();
+
+        let mut cred1 = KiroCredentials::default();
+        cred1.region = Some("us-east-1".to_string());
+
+        let mut cred2 = KiroCredentials::default();
+        cred2.region = Some("eu-west-1".to_string());
+
+        let cred3 = KiroCredentials::default(); // 无 region，使用 config
+
+        assert_eq!(get_oidc_region_for_credential(&cred1, &config), "us-east-1");
+        assert_eq!(get_oidc_region_for_credential(&cred2, &config), "eu-west-1");
+        assert_eq!(
+            get_oidc_region_for_credential(&cred3, &config),
+            "ap-northeast-1"
+        );
+    }
+
+    #[test]
+    fn test_idc_oidc_endpoint_uses_credential_region() {
+        // 验证 IdC OIDC endpoint URL 使用凭据 region
+        let mut config = Config::default();
+        config.region = "us-west-2".to_string();
+
+        let mut credentials = KiroCredentials::default();
+        credentials.region = Some("eu-central-1".to_string());
+
+        let region = get_oidc_region_for_credential(&credentials, &config);
+        let refresh_url = format!("https://oidc.{}.amazonaws.com/token", region);
+
+        assert_eq!(refresh_url, "https://oidc.eu-central-1.amazonaws.com/token");
+    }
+
+    #[test]
+    fn test_social_refresh_endpoint_uses_credential_region() {
+        // 验证 Social refresh endpoint URL 使用凭据 region
+        let mut config = Config::default();
+        config.region = "us-west-2".to_string();
+
+        let mut credentials = KiroCredentials::default();
+        credentials.region = Some("ap-southeast-1".to_string());
+
+        let region = get_oidc_region_for_credential(&credentials, &config);
+        let refresh_url = format!("https://prod.{}.auth.desktop.kiro.dev/refreshToken", region);
+
+        assert_eq!(
+            refresh_url,
+            "https://prod.ap-southeast-1.auth.desktop.kiro.dev/refreshToken"
+        );
+    }
+
+    #[test]
+    fn test_api_call_still_uses_config_region() {
+        // 验证 API 调用（如 getUsageLimits）仍使用 config.region
+        // 这确保只有 OIDC 刷新使用凭据 region，API 调用行为不变
+        let mut config = Config::default();
+        config.region = "us-west-2".to_string();
+
+        let mut credentials = KiroCredentials::default();
+        credentials.region = Some("eu-west-1".to_string());
+
+        // API 调用应使用 config.region，而非 credentials.region
+        let api_region = &config.region;
+        let api_host = format!("q.{}.amazonaws.com", api_region);
+
+        assert_eq!(api_host, "q.us-west-2.amazonaws.com");
+        // 确认凭据 region 不影响 API 调用
+        assert_ne!(api_region, credentials.region.as_ref().unwrap());
+    }
+
+    #[test]
+    fn test_credential_region_empty_string_fallback_to_config() {
+        // 空字符串 region 应回退到 config.region
+        let mut config = Config::default();
+        config.region = "us-west-2".to_string();
+
+        let mut credentials = KiroCredentials::default();
+        credentials.region = Some("".to_string());
+
+        let region = credentials
+            .region
+            .as_ref()
+            .filter(|r| !r.trim().is_empty())
+            .unwrap_or(&config.region);
+        // 空字符串应回退到 config.region
+        assert_eq!(region, "us-west-2");
+    }
+
+    #[test]
+    fn test_credential_region_whitespace_fallback_to_config() {
+        // 纯空白字符 region 应回退到 config.region
+        let mut config = Config::default();
+        config.region = "us-west-2".to_string();
+
+        let mut credentials = KiroCredentials::default();
+        credentials.region = Some("   ".to_string());
+
+        let region = credentials
+            .region
+            .as_ref()
+            .filter(|r| !r.trim().is_empty())
+            .unwrap_or(&config.region);
+        assert_eq!(region, "us-west-2");
+    }
+}
diff --git a/src/kiro/web_portal.rs b/src/kiro/web_portal.rs
new file mode 100644
index 0000000..ef0cb84
--- /dev/null
+++ b/src/kiro/web_portal.rs
@@ -0,0 +1,554 @@
+//! Kiro Web Portal API（app.kiro.dev）
+//!
+//! 参考 Kiro-account-manager：
+//! - POST https://app.kiro.dev/service/KiroWebPortalService/operation/{Operation}
+//! - 协议：rpc-v2-cbor
+//! - Content-Type/Accept: application/cbor
+//! - Authorization: Bearer <accessToken>
+//! - Cookie: Idp=<idp>; AccessToken=<accessToken>
+
+#![allow(dead_code)]
+
+use std::time::Duration;
+
+use anyhow::Context;
+use chrono::{DateTime, Utc};
+use reqwest::header::{ACCEPT, AUTHORIZATION, CONTENT_TYPE, COOKIE, HeaderMap, HeaderValue};
+
+use crate::http_client::{ProxyConfig, build_client};
+
+#[allow(dead_code)]
+const KIRO_API_BASE: &str = "https://app.kiro.dev/service/KiroWebPortalService/operation";
+#[allow(dead_code)]
+const SMITHY_PROTOCOL: &str = "rpc-v2-cbor";
+const AMZ_SDK_REQUEST: &str = "attempt=1; max=1";
+const X_AMZ_USER_AGENT: &str = "aws-sdk-js/1.0.0 kiro-rs/1.0.0";
+
+#[derive(Debug, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetUserInfoRequest {
+    pub origin: String,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct UserInfoResponse {
+    pub email: Option<String>,
+    pub user_id: Option<String>,
+    pub idp: Option<String>,
+    pub status: Option<String>,
+    pub feature_flags: Option<Vec<String>>,
+}
+
+#[derive(Debug, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetUserUsageAndLimitsRequest {
+    pub is_email_required: bool,
+    pub origin: String,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct UsageUserInfo {
+    pub email: Option<String>,
+    pub user_id: Option<String>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SubscriptionInfo {
+    pub r#type: Option<String>,
+    pub subscription_title: Option<String>,
+    pub upgrade_capability: Option<String>,
+    pub overage_capability: Option<String>,
+    pub subscription_management_target: Option<String>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Bonus {
+    pub bonus_code: Option<String>,
+    pub display_name: Option<String>,
+
+    pub usage_limit: Option<f64>,
+    pub usage_limit_with_precision: Option<f64>,
+    pub current_usage: Option<f64>,
+    pub current_usage_with_precision: Option<f64>,
+
+    pub status: Option<String>,
+    pub expires_at: Option<String>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct FreeTrialInfo {
+    pub usage_limit: Option<f64>,
+    pub usage_limit_with_precision: Option<f64>,
+    pub current_usage: Option<f64>,
+    pub current_usage_with_precision: Option<f64>,
+
+    pub free_trial_expiry: Option<String>,
+    pub free_trial_status: Option<String>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct UsageBreakdownItem {
+    pub resource_type: Option<String>,
+
+    pub current_usage: Option<f64>,
+    pub current_usage_with_precision: Option<f64>,
+    pub usage_limit: Option<f64>,
+    pub usage_limit_with_precision: Option<f64>,
+
+    pub display_name: Option<String>,
+    pub display_name_plural: Option<String>,
+    pub currency: Option<String>,
+    pub unit: Option<String>,
+    pub overage_rate: Option<f64>,
+    pub overage_cap: Option<f64>,
+
+    pub free_trial_info: Option<FreeTrialInfo>,
+    pub bonuses: Option<Vec<Bonus>>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct OverageConfiguration {
+    pub overage_enabled: Option<bool>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct UsageAndLimitsResponse {
+    pub user_info: Option<UsageUserInfo>,
+    pub subscription_info: Option<SubscriptionInfo>,
+    pub usage_breakdown_list: Option<Vec<UsageBreakdownItem>>,
+    pub next_date_reset: Option<String>,
+    pub overage_configuration: Option<OverageConfiguration>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct CborErrorResponse {
+    #[serde(rename = "__type")]
+    pub type_name: Option<String>,
+    pub message: Option<String>,
+}
+
+fn header_value(s: &str, name: &'static str) -> anyhow::Result<HeaderValue> {
+    HeaderValue::from_str(s).with_context(|| format!("{} header 无效", name))
+}
+
+fn build_headers(access_token: &str, idp: &str) -> anyhow::Result<HeaderMap> {
+    let mut headers = HeaderMap::new();
+
+    headers.insert(ACCEPT, HeaderValue::from_static("application/cbor"));
+    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/cbor"));
+    headers.insert("smithy-protocol", HeaderValue::from_static(SMITHY_PROTOCOL));
+    headers.insert(
+        "amz-sdk-invocation-id",
+        header_value(&uuid::Uuid::new_v4().to_string(), "amz-sdk-invocation-id")?,
+    );
+    headers.insert("amz-sdk-request", HeaderValue::from_static(AMZ_SDK_REQUEST));
+    headers.insert(
+        "x-amz-user-agent",
+        header_value(X_AMZ_USER_AGENT, "x-amz-user-agent")?,
+    );
+
+    headers.insert(
+        AUTHORIZATION,
+        header_value(&format!("Bearer {}", access_token), "authorization")?,
+    );
+
+    // Kiro-account-manager 里同时带了 Idp / AccessToken cookie。
+    headers.insert(
+        COOKIE,
+        header_value(
+            &format!("Idp={}; AccessToken={}", idp, access_token),
+            "cookie",
+        )?,
+    );
+
+    Ok(headers)
+}
+
+async fn request_cbor<TResp, TReq>(
+    operation: &str,
+    req: &TReq,
+    access_token: &str,
+    idp: &str,
+    proxy: Option<&ProxyConfig>,
+) -> anyhow::Result<TResp>
+where
+    TResp: for<'de> serde::Deserialize<'de>,
+    TReq: serde::Serialize,
+{
+    let url = format!("{}/{}", KIRO_API_BASE, operation);
+
+    let body = serde_cbor::to_vec(req).context("CBOR 编码失败")?;
+
+    let client = build_client(proxy, 60, crate::model::config::TlsBackend::NativeTls)?;
+
+    let resp = client
+        .post(&url)
+        .headers(build_headers(access_token, idp)?)
+        .timeout(Duration::from_secs(60))
+        .body(body)
+        .send()
+        .await
+        .context("请求 Kiro Web Portal API 失败")?;
+
+    let status = resp.status();
+    let bytes = resp.bytes().await.context("读取响应失败")?;
+
+    if !status.is_success() {
+        // 尽力解析 CBOR 错误体
+        if let Ok(err) = serde_cbor::from_slice::<CborErrorResponse>(&bytes) {
+            let type_name = err
+                .type_name
+                .as_deref()
+                .and_then(|s| s.split('#').next_back())
+                .unwrap_or("HTTPError");
+            let msg = err.message.unwrap_or_else(|| format!("HTTP {}", status));
+            anyhow::bail!("{}: {}", type_name, msg);
+        }
+
+        let raw = String::from_utf8_lossy(&bytes);
+        anyhow::bail!("HTTP {}: {}", status, raw);
+    }
+
+    let out = serde_cbor::from_slice::<TResp>(&bytes).context("CBOR 解码失败")?;
+    Ok(out)
+}
+
+pub async fn get_user_info(
+    access_token: &str,
+    idp: &str,
+    proxy: Option<&ProxyConfig>,
+) -> anyhow::Result<UserInfoResponse> {
+    request_cbor(
+        "GetUserInfo",
+        &GetUserInfoRequest {
+            origin: "KIRO_IDE".to_string(),
+        },
+        access_token,
+        idp,
+        proxy,
+    )
+    .await
+}
+
+pub async fn get_user_usage_and_limits(
+    access_token: &str,
+    idp: &str,
+    proxy: Option<&ProxyConfig>,
+) -> anyhow::Result<UsageAndLimitsResponse> {
+    request_cbor(
+        "GetUserUsageAndLimits",
+        &GetUserUsageAndLimitsRequest {
+            is_email_required: true,
+            origin: "KIRO_IDE".to_string(),
+        },
+        access_token,
+        idp,
+        proxy,
+    )
+    .await
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreditBonus {
+    pub code: String,
+    pub name: String,
+    pub current: f64,
+    pub limit: f64,
+    pub expires_at: Option<String>,
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreditsUsageSummary {
+    pub current: f64,
+    pub limit: f64,
+
+    pub base_current: f64,
+    pub base_limit: f64,
+
+    pub free_trial_current: f64,
+    pub free_trial_limit: f64,
+    pub free_trial_expiry: Option<String>,
+
+    pub bonuses: Vec<CreditBonus>,
+
+    pub next_reset_date: Option<String>,
+    pub overage_enabled: Option<bool>,
+
+    pub resource_detail: Option<CreditsResourceDetail>,
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreditsResourceDetail {
+    pub display_name: Option<String>,
+    pub display_name_plural: Option<String>,
+    pub resource_type: Option<String>,
+    pub currency: Option<String>,
+    pub unit: Option<String>,
+    pub overage_rate: Option<f64>,
+    pub overage_cap: Option<f64>,
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ResourceUsageSummary {
+    pub resource_type: Option<String>,
+    pub display_name: Option<String>,
+    pub unit: Option<String>,
+    pub currency: Option<String>,
+    pub current: f64,
+    pub limit: f64,
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AccountAggregateInfo {
+    pub email: Option<String>,
+    pub user_id: Option<String>,
+    pub idp: Option<String>,
+    pub status: Option<String>,
+    pub feature_flags: Option<Vec<String>>,
+
+    pub subscription_title: Option<String>,
+    pub subscription_type: String,
+    pub subscription: AccountSubscriptionDetails,
+
+    /// 兼容旧 UI：Credits 汇总（如有）
+    pub usage: CreditsUsageSummary,
+
+    /// 全部资源用量明细（用于展示/调试）
+    pub resources: Vec<ResourceUsageSummary>,
+
+    /// 原始 GetUserUsageAndLimits 响应（不包含 token，仅包含用量/订阅信息）
+    pub raw_usage: UsageAndLimitsResponse,
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AccountSubscriptionDetails {
+    pub raw_type: Option<String>,
+    pub management_target: Option<String>,
+    pub upgrade_capability: Option<String>,
+    pub overage_capability: Option<String>,
+}
+
+fn norm_subscription_type(title: Option<&str>) -> String {
+    let Some(t) = title else {
+        return "Free".to_string();
+    };
+    let up = t.to_uppercase();
+    if up.contains("PRO") {
+        return "Pro".to_string();
+    }
+    if up.contains("ENTERPRISE") {
+        return "Enterprise".to_string();
+    }
+    if up.contains("TEAMS") {
+        return "Teams".to_string();
+    }
+    "Free".to_string()
+}
+
+fn pick_f64(primary: Option<f64>, fallback: Option<f64>) -> f64 {
+    primary.or(fallback).unwrap_or(0.0)
+}
+
+fn parse_rfc3339(s: &str) -> Option<DateTime<Utc>> {
+    DateTime::parse_from_rfc3339(s)
+        .ok()
+        .map(|dt| dt.with_timezone(&Utc))
+}
+
+fn free_trial_is_effective(ft: &FreeTrialInfo) -> bool {
+    match ft.free_trial_status.as_deref() {
+        Some(s) => s.eq_ignore_ascii_case("ACTIVE"),
+        None => {
+            let limit = pick_f64(ft.usage_limit_with_precision, ft.usage_limit);
+            let current = pick_f64(ft.current_usage_with_precision, ft.current_usage);
+            limit > 0.0 || current > 0.0
+        }
+    }
+}
+
+fn bonus_is_effective(b: &Bonus) -> bool {
+    match b.status.as_deref() {
+        Some(s) => s.eq_ignore_ascii_case("ACTIVE"),
+        None => {
+            // 没有 status 时：优先用 expiresAt 判断是否仍有效；再用 limit/current 兜底。
+            if let Some(exp) = b.expires_at.as_deref()
+                && let Some(dt) = parse_rfc3339(exp)
+            {
+                return dt > Utc::now();
+            }
+            let limit = pick_f64(b.usage_limit_with_precision, b.usage_limit);
+            let current = pick_f64(b.current_usage_with_precision, b.current_usage);
+            limit > 0.0 || current > 0.0
+        }
+    }
+}
+
+pub fn aggregate_account_info(
+    user_info: Option<UserInfoResponse>,
+    usage: UsageAndLimitsResponse,
+) -> AccountAggregateInfo {
+    let credit = usage.usage_breakdown_list.as_ref().and_then(|l| {
+        l.iter().find(|b| {
+            b.resource_type
+                .as_deref()
+                .map(|t| t.eq_ignore_ascii_case("CREDIT"))
+                .unwrap_or(false)
+                || b.display_name
+                    .as_deref()
+                    .map(|t| t.eq_ignore_ascii_case("Credits"))
+                    .unwrap_or(false)
+        })
+    });
+
+    let base_limit = credit
+        .map(|c| pick_f64(c.usage_limit_with_precision, c.usage_limit))
+        .unwrap_or(0.0);
+    let base_current = credit
+        .map(|c| pick_f64(c.current_usage_with_precision, c.current_usage))
+        .unwrap_or(0.0);
+
+    let (free_trial_limit, free_trial_current, free_trial_expiry) =
+        match credit.and_then(|c| c.free_trial_info.as_ref()) {
+            Some(t) if free_trial_is_effective(t) => (
+                pick_f64(t.usage_limit_with_precision, t.usage_limit),
+                pick_f64(t.current_usage_with_precision, t.current_usage),
+                t.free_trial_expiry.clone(),
+            ),
+            _ => (0.0, 0.0, None),
+        };
+
+    let bonuses: Vec<CreditBonus> = credit
+        .and_then(|c| c.bonuses.as_ref())
+        .map(|bs| {
+            bs.iter()
+                .filter(|b| bonus_is_effective(b))
+                .map(|b| CreditBonus {
+                    code: b.bonus_code.clone().unwrap_or_default(),
+                    name: b.display_name.clone().unwrap_or_default(),
+                    current: pick_f64(b.current_usage_with_precision, b.current_usage),
+                    limit: pick_f64(b.usage_limit_with_precision, b.usage_limit),
+                    expires_at: b.expires_at.clone(),
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+
+    let bonuses_limit: f64 = bonuses.iter().map(|b| b.limit).sum();
+    let bonuses_current: f64 = bonuses.iter().map(|b| b.current).sum();
+
+    let total_limit = base_limit + free_trial_limit + bonuses_limit;
+    let total_current = base_current + free_trial_current + bonuses_current;
+
+    let subscription_title = usage
+        .subscription_info
+        .as_ref()
+        .and_then(|s| s.subscription_title.clone());
+
+    let subscription_type = norm_subscription_type(subscription_title.as_deref());
+
+    let email = usage
+        .user_info
+        .as_ref()
+        .and_then(|u| u.email.clone())
+        .or_else(|| user_info.as_ref().and_then(|u| u.email.clone()));
+
+    let user_id = usage
+        .user_info
+        .as_ref()
+        .and_then(|u| u.user_id.clone())
+        .or_else(|| user_info.as_ref().and_then(|u| u.user_id.clone()));
+
+    let overage_enabled = usage
+        .overage_configuration
+        .as_ref()
+        .and_then(|o| o.overage_enabled);
+
+    let resource_detail = credit.map(|c| CreditsResourceDetail {
+        display_name: c.display_name.clone(),
+        display_name_plural: c.display_name_plural.clone(),
+        resource_type: c.resource_type.clone(),
+        currency: c.currency.clone(),
+        unit: c.unit.clone(),
+        overage_rate: c.overage_rate,
+        overage_cap: c.overage_cap,
+    });
+
+    AccountAggregateInfo {
+        email,
+        user_id,
+        idp: user_info.as_ref().and_then(|u| u.idp.clone()),
+        status: user_info.as_ref().and_then(|u| u.status.clone()),
+        feature_flags: user_info.as_ref().and_then(|u| u.feature_flags.clone()),
+
+        subscription_title,
+        subscription_type,
+        subscription: AccountSubscriptionDetails {
+            raw_type: usage
+                .subscription_info
+                .as_ref()
+                .and_then(|s| s.r#type.clone()),
+            management_target: usage
+                .subscription_info
+                .as_ref()
+                .and_then(|s| s.subscription_management_target.clone()),
+            upgrade_capability: usage
+                .subscription_info
+                .as_ref()
+                .and_then(|s| s.upgrade_capability.clone()),
+            overage_capability: usage
+                .subscription_info
+                .as_ref()
+                .and_then(|s| s.overage_capability.clone()),
+        },
+
+        usage: CreditsUsageSummary {
+            current: total_current,
+            limit: total_limit,
+
+            base_current,
+            base_limit,
+
+            free_trial_current,
+            free_trial_limit,
+            free_trial_expiry,
+
+            bonuses,
+
+            next_reset_date: usage.next_date_reset.clone(),
+            overage_enabled,
+
+            resource_detail,
+        },
+        resources: usage
+            .usage_breakdown_list
+            .as_ref()
+            .map(|l| {
+                l.iter()
+                    .map(|b| ResourceUsageSummary {
+                        resource_type: b.resource_type.clone(),
+                        display_name: b.display_name.clone(),
+                        unit: b.unit.clone(),
+                        currency: b.currency.clone(),
+                        current: pick_f64(b.current_usage_with_precision, b.current_usage),
+                        limit: pick_f64(b.usage_limit_with_precision, b.usage_limit),
+                    })
+                    .collect()
+            })
+            .unwrap_or_default(),
+        raw_usage: usage,
+    }
+}
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..ac41748
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,196 @@
+mod admin;
+mod admin_ui;
+mod anthropic;
+mod common;
+mod http_client;
+pub mod image;
+mod kiro;
+mod model;
+pub mod token;
+
+use std::sync::Arc;
+
+use clap::Parser;
+use kiro::model::credentials::{CredentialsConfig, KiroCredentials};
+use kiro::provider::KiroProvider;
+use kiro::token_manager::MultiTokenManager;
+use model::arg::Args;
+use model::config::Config;
+
+#[tokio::main]
+async fn main() {
+    // 解析命令行参数
+    let args = Args::parse();
+
+    // 初始化日志
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
+        )
+        .init();
+
+    // 加载配置
+    let config_path = args
+        .config
+        .unwrap_or_else(|| Config::default_config_path().to_string());
+    let config = Config::load(&config_path).unwrap_or_else(|e| {
+        tracing::error!("加载配置失败: {}", e);
+        std::process::exit(1);
+    });
+
+    // 加载凭证（支持单对象或数组格式）
+    let credentials_path = args
+        .credentials
+        .unwrap_or_else(|| KiroCredentials::default_credentials_path().to_string());
+    let credentials_config = CredentialsConfig::load(&credentials_path).unwrap_or_else(|e| {
+        tracing::error!("加载凭证失败: {}", e);
+        std::process::exit(1);
+    });
+
+    // 判断是否为多凭据格式（用于刷新后回写）
+    let is_multiple_format = credentials_config.is_multiple();
+
+    // 转换为按优先级排序的凭据列表
+    let credentials_list = credentials_config.into_sorted_credentials();
+    tracing::info!("已加载 {} 个凭据配置", credentials_list.len());
+
+    // 获取第一个凭据用于日志显示
+    let first_credentials = credentials_list.first().cloned().unwrap_or_default();
+    #[cfg(feature = "sensitive-logs")]
+    tracing::debug!("主凭证: {:?}", first_credentials);
+    #[cfg(not(feature = "sensitive-logs"))]
+    tracing::debug!(
+        id = ?first_credentials.id,
+        priority = first_credentials.priority,
+        has_profile_arn = first_credentials.profile_arn.is_some(),
+        has_expires_at = first_credentials.expires_at.is_some(),
+        auth_method = ?first_credentials.auth_method.as_deref(),
+        "主凭证摘要"
+    );
+
+    // 获取 API Key
+    let api_key = config.api_key.clone().unwrap_or_else(|| {
+        tracing::error!("配置文件中未设置 apiKey");
+        std::process::exit(1);
+    });
+
+    // 构建代理配置
+    let proxy_config = config.proxy_url.as_ref().map(|url| {
+        let mut proxy = http_client::ProxyConfig::new(url);
+        if let (Some(username), Some(password)) = (&config.proxy_username, &config.proxy_password) {
+            proxy = proxy.with_auth(username, password);
+        }
+        proxy
+    });
+
+    if proxy_config.is_some() {
+        tracing::info!("已配置 HTTP 代理: {}", config.proxy_url.as_ref().unwrap());
+    }
+
+    // 创建 MultiTokenManager 和 KiroProvider
+    let token_manager = MultiTokenManager::new(
+        config.clone(),
+        credentials_list,
+        proxy_config.clone(),
+        Some(credentials_path.into()),
+        is_multiple_format,
+    )
+    .unwrap_or_else(|e| {
+        tracing::error!("创建 Token 管理器失败: {}", e);
+        std::process::exit(1);
+    });
+    let token_manager = Arc::new(token_manager);
+
+    // 初始化余额缓存并按余额选择初始凭据
+    let init_count = token_manager.initialize_balances().await;
+    if init_count == 0 && token_manager.total_count() > 0 {
+        tracing::warn!("所有凭据余额初始化失败，将按优先级选择凭据");
+    }
+
+    let kiro_provider = KiroProvider::with_proxy(token_manager.clone(), proxy_config.clone());
+
+    // 初始化 count_tokens 配置
+    token::init_config(token::CountTokensConfig {
+        api_url: config.count_tokens_api_url.clone(),
+        api_key: config.count_tokens_api_key.clone(),
+        auth_type: config.count_tokens_auth_type.clone(),
+        proxy: proxy_config,
+        tls_backend: config.tls_backend,
+    });
+
+    // 构建 Anthropic API 路由（从第一个凭据获取 profile_arn）
+    let anthropic_app = anthropic::create_router_with_provider(
+        &api_key,
+        Some(kiro_provider),
+        first_credentials.profile_arn.clone(),
+        config.compression.clone(),
+    );
+
+    // 构建 Admin API 路由（如果配置了非空的 admin_api_key）
+    // 安全检查：空字符串被视为未配置，防止空 key 绕过认证
+    let admin_key_valid = config
+        .admin_api_key
+        .as_ref()
+        .map(|k| !k.trim().is_empty())
+        .unwrap_or(false);
+
+    let app = if let Some(admin_key) = &config.admin_api_key {
+        if admin_key.trim().is_empty() {
+            tracing::warn!("admin_api_key 配置为空，Admin API 未启用");
+            anthropic_app
+        } else {
+            let admin_service = admin::AdminService::new(token_manager.clone());
+            let admin_state = admin::AdminState::new(admin_key, admin_service);
+            let admin_app = admin::create_admin_router(admin_state);
+
+            // 创建 Admin UI 路由
+            let admin_ui_app = admin_ui::create_admin_ui_router();
+
+            tracing::info!("Admin API 已启用");
+            tracing::info!("Admin UI 已启用: /admin");
+            anthropic_app
+                .nest("/api/admin", admin_app)
+                .nest("/admin", admin_ui_app)
+        }
+    } else {
+        anthropic_app
+    };
+
+    // 启动服务器
+    let addr = format!("{}:{}", config.host, config.port);
+    tracing::info!("启动 Anthropic API 端点: {}", addr);
+    #[cfg(feature = "sensitive-logs")]
+    tracing::debug!("API Key: {}***", &api_key[..(api_key.len() / 2)]);
+    #[cfg(not(feature = "sensitive-logs"))]
+    tracing::info!(
+        "API Key: ***{} (长度: {})",
+        &api_key[api_key.len().saturating_sub(4)..],
+        api_key.len()
+    );
+    tracing::info!("可用 API:");
+    tracing::info!("  GET  /v1/models");
+    tracing::info!("  POST /v1/messages");
+    tracing::info!("  POST /v1/messages/count_tokens");
+    if admin_key_valid {
+        tracing::info!("Admin API:");
+        tracing::info!("  GET  /api/admin/credentials");
+        tracing::info!("  POST /api/admin/credentials/:index/disabled");
+        tracing::info!("  POST /api/admin/credentials/:index/priority");
+        tracing::info!("  POST /api/admin/credentials/:index/reset");
+        tracing::info!("  GET  /api/admin/credentials/:index/balance");
+        tracing::info!("Admin UI:");
+        tracing::info!("  GET  /admin");
+    }
+
+    let listener = tokio::net::TcpListener::bind(&addr)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!("绑定监听地址失败 ({}): {}", addr, e);
+            std::process::exit(1);
+        });
+    if let Err(e) = axum::serve(listener, app).await {
+        tracing::error!("HTTP 服务异常退出: {}", e);
+        std::process::exit(1);
+    }
+}
diff --git a/src/model/arg.rs b/src/model/arg.rs
new file mode 100644
index 0000000..f572d83
--- /dev/null
+++ b/src/model/arg.rs
@@ -0,0 +1,14 @@
+use clap::Parser;
+
+/// Anthropic <-> Kiro API 客户端
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+pub struct Args {
+    /// 配置文件路径
+    #[arg(short, long)]
+    pub config: Option<String>,
+
+    /// 凭证文件路径
+    #[arg(long)]
+    pub credentials: Option<String>,
+}
diff --git a/src/model/config.rs b/src/model/config.rs
new file mode 100644
index 0000000..bc1e1df
--- /dev/null
+++ b/src/model/config.rs
@@ -0,0 +1,341 @@
+use anyhow::Context;
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum TlsBackend {
+    #[default]
+    Rustls,
+    NativeTls,
+}
+
+/// KNA 应用配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Config {
+    #[serde(default = "default_host")]
+    pub host: String,
+
+    #[serde(default = "default_port")]
+    pub port: u16,
+
+    #[serde(default = "default_region")]
+    pub region: String,
+
+    /// API Region（用于 API 请求），未配置时回退到 region
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api_region: Option<String>,
+
+    #[serde(default = "default_kiro_version")]
+    pub kiro_version: String,
+
+    #[serde(default)]
+    pub machine_id: Option<String>,
+
+    #[serde(default)]
+    pub api_key: Option<String>,
+
+    #[serde(default = "default_system_version")]
+    pub system_version: String,
+
+    #[serde(default = "default_node_version")]
+    pub node_version: String,
+
+    #[serde(default = "default_tls_backend")]
+    pub tls_backend: TlsBackend,
+
+    /// 外部 count_tokens API 地址（可选）
+    #[serde(default)]
+    pub count_tokens_api_url: Option<String>,
+
+    /// count_tokens API 密钥（可选）
+    #[serde(default)]
+    pub count_tokens_api_key: Option<String>,
+
+    /// count_tokens API 认证类型（可选，"x-api-key" 或 "bearer"，默认 "x-api-key"）
+    #[serde(default = "default_count_tokens_auth_type")]
+    pub count_tokens_auth_type: String,
+
+    /// HTTP 代理地址（可选）
+    /// 支持格式: http://host:port, https://host:port, socks5://host:port
+    #[serde(default)]
+    pub proxy_url: Option<String>,
+
+    /// 代理认证用户名（可选）
+    #[serde(default)]
+    pub proxy_username: Option<String>,
+
+    /// 代理认证密码（可选）
+    #[serde(default)]
+    pub proxy_password: Option<String>,
+
+    /// Admin API 密钥（可选，启用 Admin API 功能）
+    #[serde(default)]
+    pub admin_api_key: Option<String>,
+
+    /// 单个凭据的目标请求速率（RPM，每分钟请求数）
+    ///
+    /// 用于凭据级节流/分流：当某个凭据短时间内请求过密时，优先将流量分配到其他可用凭据，
+    /// 从而减少上游 429 的概率。
+    ///
+    /// - `None` 或 `0`: 使用内置默认节流策略
+    /// - `>0`: 将最小/最大请求间隔固定为 `60_000 / rpm` 毫秒
+    #[serde(default)]
+    pub credential_rpm: Option<u32>,
+
+    /// 输入压缩配置
+    #[serde(default)]
+    pub compression: CompressionConfig,
+
+    /// 配置文件路径（运行时元数据，不写入 JSON）
+    #[serde(skip)]
+    config_path: Option<PathBuf>,
+}
+
+fn default_host() -> String {
+    "127.0.0.1".to_string()
+}
+
+fn default_port() -> u16 {
+    8080
+}
+
+fn default_region() -> String {
+    "us-east-1".to_string()
+}
+
+fn default_kiro_version() -> String {
+    "0.10.0".to_string()
+}
+
+fn default_system_version() -> String {
+    const SYSTEM_VERSIONS: &[&str] = &["darwin#24.6.0", "win32#10.0.22631"];
+    SYSTEM_VERSIONS[fastrand::usize(..SYSTEM_VERSIONS.len())].to_string()
+}
+
+fn default_node_version() -> String {
+    "22.21.1".to_string()
+}
+
+fn default_count_tokens_auth_type() -> String {
+    "x-api-key".to_string()
+}
+
+fn default_tls_backend() -> TlsBackend {
+    TlsBackend::Rustls
+}
+
+fn default_true() -> bool {
+    true
+}
+
+fn default_thinking_strategy() -> String {
+    "discard".to_string()
+}
+
+fn default_8000() -> usize {
+    8000
+}
+
+fn default_80() -> usize {
+    80
+}
+
+fn default_40() -> usize {
+    40
+}
+
+fn default_6000() -> usize {
+    6000
+}
+
+fn default_4000() -> usize {
+    4000
+}
+
+fn default_80_turns() -> usize {
+    80
+}
+
+fn default_400k() -> usize {
+    400_000
+}
+
+fn default_image_max_long_edge() -> u32 {
+    4000
+}
+
+fn default_image_max_pixels_single() -> u32 {
+    4_000_000
+}
+
+fn default_image_max_pixels_multi() -> u32 {
+    4_000_000
+}
+
+fn default_image_multi_threshold() -> usize {
+    20
+}
+
+fn default_max_request_body_bytes() -> usize {
+    // 上游对请求体大小存在硬性限制（实测约 5MiB 左右会触发 400），
+    // 这里默认设置为 4.5MiB 留出安全余量。
+    4_718_592
+}
+
+/// 输入压缩配置
+///
+/// 控制请求体在协议转换后、发送到上游前的多层压缩策略。
+/// 所有阈值均可通过配置文件调整，默认开启。
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CompressionConfig {
+    /// 总开关，默认 true
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    /// 空白压缩（连续空行、行尾空格），默认 true
+    #[serde(default = "default_true")]
+    pub whitespace_compression: bool,
+    /// thinking 块处理策略: "discard" | "truncate" | "keep"
+    #[serde(default = "default_thinking_strategy")]
+    pub thinking_strategy: String,
+    /// tool_result 截断阈值（字符数），默认 8000
+    #[serde(default = "default_8000")]
+    pub tool_result_max_chars: usize,
+    /// 智能截断保留头部行数，默认 80
+    #[serde(default = "default_80")]
+    pub tool_result_head_lines: usize,
+    /// 智能截断保留尾部行数，默认 40
+    #[serde(default = "default_40")]
+    pub tool_result_tail_lines: usize,
+    /// tool_use input 截断阈值（字符数），默认 6000
+    #[serde(default = "default_6000")]
+    pub tool_use_input_max_chars: usize,
+    /// 工具描述截断阈值（字符数），覆盖原 10000 硬编码，默认 4000
+    #[serde(default = "default_4000")]
+    pub tool_description_max_chars: usize,
+    /// 历史最大轮数，默认 80（0=不限）
+    #[serde(default = "default_80_turns")]
+    pub max_history_turns: usize,
+    /// 历史最大字符数，默认 400000（0=不限）
+    #[serde(default = "default_400k")]
+    pub max_history_chars: usize,
+    /// 图片长边最大像素，默认 4000（Anthropic 硬限制 8000，留安全余量；窄长图受益于更大长边）
+    #[serde(default = "default_image_max_long_edge")]
+    pub image_max_long_edge: u32,
+    /// 单张图片最大总像素，默认 4_000_000（2000×2000，与多图限制一致）
+    #[serde(default = "default_image_max_pixels_single")]
+    pub image_max_pixels_single: u32,
+    /// 多图模式下单张图片最大总像素，默认 4_000_000（2000×2000）
+    #[serde(default = "default_image_max_pixels_multi")]
+    pub image_max_pixels_multi: u32,
+    /// 触发多图限制的图片数量阈值，默认 20
+    #[serde(default = "default_image_multi_threshold")]
+    pub image_multi_threshold: usize,
+    /// 请求体最大字节数，超过则直接拒绝（0 = 不限制）
+    #[serde(default = "default_max_request_body_bytes")]
+    pub max_request_body_bytes: usize,
+}
+
+impl Default for CompressionConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            whitespace_compression: true,
+            thinking_strategy: default_thinking_strategy(),
+            tool_result_max_chars: default_8000(),
+            tool_result_head_lines: default_80(),
+            tool_result_tail_lines: default_40(),
+            tool_use_input_max_chars: default_6000(),
+            tool_description_max_chars: default_4000(),
+            max_history_turns: default_80_turns(),
+            max_history_chars: default_400k(),
+            image_max_long_edge: default_image_max_long_edge(),
+            image_max_pixels_single: default_image_max_pixels_single(),
+            image_max_pixels_multi: default_image_max_pixels_multi(),
+            image_multi_threshold: default_image_multi_threshold(),
+            max_request_body_bytes: default_max_request_body_bytes(),
+        }
+    }
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            host: default_host(),
+            port: default_port(),
+            region: default_region(),
+            api_region: None,
+            kiro_version: default_kiro_version(),
+            machine_id: None,
+            api_key: None,
+            system_version: default_system_version(),
+            node_version: default_node_version(),
+            tls_backend: default_tls_backend(),
+            count_tokens_api_url: None,
+            count_tokens_api_key: None,
+            count_tokens_auth_type: default_count_tokens_auth_type(),
+            proxy_url: None,
+            proxy_username: None,
+            proxy_password: None,
+            admin_api_key: None,
+            credential_rpm: None,
+            compression: CompressionConfig::default(),
+            config_path: None,
+        }
+    }
+}
+
+impl Config {
+    /// 获取默认配置文件路径
+    pub fn default_config_path() -> &'static str {
+        "config.json"
+    }
+
+    /// 获取有效的 API Region（用于 API 请求）
+    /// 优先使用 api_region，未配置时回退到 region
+    #[allow(dead_code)]
+    pub fn effective_api_region(&self) -> &str {
+        self.api_region.as_deref().unwrap_or(&self.region)
+    }
+
+    /// 从文件加载配置
+    pub fn load<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
+        let path = path.as_ref();
+        if !path.exists() {
+            // 配置文件不存在，返回默认配置
+            return Ok(Self {
+                config_path: Some(path.to_path_buf()),
+                ..Default::default()
+            });
+        }
+
+        let content = fs::read_to_string(path)?;
+        let mut config: Config = serde_json::from_str(&content)?;
+        config.config_path = Some(path.to_path_buf());
+        Ok(config)
+    }
+
+    /// 获取配置文件路径（如果有）
+    #[allow(dead_code)]
+    pub fn config_path(&self) -> Option<&Path> {
+        self.config_path.as_deref()
+    }
+
+    /// 将当前配置写回原始配置文件
+    #[allow(dead_code)]
+    pub fn save(&self) -> anyhow::Result<()> {
+        let path = self
+            .config_path
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("配置文件路径未知，无法保存配置"))?;
+
+        let content = serde_json::to_string_pretty(self).context("序列化配置失败")?;
+        fs::write(path, content)
+            .with_context(|| format!("写入配置文件失败: {}", path.display()))?;
+        Ok(())
+    }
+}
diff --git a/src/model/mod.rs b/src/model/mod.rs
new file mode 100644
index 0000000..31871f7
--- /dev/null
+++ b/src/model/mod.rs
@@ -0,0 +1,4 @@
+//! 应用配置模型
+
+pub mod arg;
+pub mod config;
diff --git a/src/test.rs b/src/test.rs
new file mode 100644
index 0000000..744fe94
--- /dev/null
+++ b/src/test.rs
@@ -0,0 +1,107 @@
+use futures::StreamExt;
+
+use crate::debug::{print_event, print_event_verbose, debug_crc, print_hex};
+use crate::kiro::model::credentials::KiroCredentials;
+use crate::kiro::model::events::Event;
+use crate::kiro::model::requests::KiroRequest;
+use crate::kiro::parser::EventStreamDecoder;
+use crate::kiro::provider::KiroProvider;
+use crate::kiro::token_manager::TokenManager;
+use crate::model::config::Config;
+
+
+/// 调用流式 API 并实时打印返回
+pub(crate) async fn call_stream_api() -> anyhow::Result<()> {
+    // 读取 test.json 作为请求体
+    let request_body = std::fs::read_to_string("test.json")?;
+    println!("已加载请求体，长度: {} 字节", request_body.len());
+
+    // 解析请求体为 KiroRequest 对象
+    let request: KiroRequest = serde_json::from_str(&request_body)?;
+    println!("已解析请求对象:");
+    println!("  会话 ID: {}", request.conversation_id());
+    println!("  模型 ID: {}", request.model_id());
+    println!("  消息内容长度: {} 字符", request.current_content().len());
+    if let Some(ref task_type) = request.conversation_state.agent_task_type {
+        println!("  任务类型: {}", task_type);
+    }
+    if let Some(ref trigger_type) = request.conversation_state.chat_trigger_type {
+        println!("  触发类型: {}", trigger_type);
+    }
+    println!("  历史消息数: {}", request.conversation_state.history.len());
+    println!("  工具数量: {}", request.conversation_state.current_message.user_input_message.user_input_message_context.tools.len());
+
+    // 加载凭证
+    let credentials = KiroCredentials::load_default()?;
+    println!("已加载凭证");
+
+    // 加载配置
+    let config = Config::load_default()?;
+    println!("API 区域: {}", config.region);
+
+    // 创建 TokenManager 和 KiroProvider
+    let token_manager = TokenManager::new(config, credentials);
+    let mut provider = KiroProvider::new(token_manager);
+
+    println!("\n开始调用流式 API...\n");
+    println!("{}", "=".repeat(60));
+
+    // 调用流式 API
+    let response = provider.call_api_stream(&request_body, None).await?;
+
+    // 获取字节流
+    let mut stream = response.bytes_stream();
+    let mut decoder = EventStreamDecoder::new();
+
+    // 处理流式数据
+    let mut total_bytes = 0usize;
+    while let Some(chunk_result) = stream.next().await {
+        match chunk_result {
+            Ok(chunk) => {
+                // 调试模式：打印原始 hex 数据
+                // println!("\n[收到数据块] {} 字节, 偏移 {}", chunk.len(), total_bytes);
+                // print_hex(&chunk);
+                // debug_crc(&chunk);
+
+                total_bytes += chunk.len();
+
+                // 将数据喂给解码器
+                if let Err(e) = decoder.feed(&chunk) {
+                    eprintln!("[缓冲区错误] {}", e);
+                    continue;
+                }
+
+                // 解码所有可用的帧
+                for result in decoder.decode_iter() {
+                    match result {
+                        Ok(frame) => {
+                            // 解析事件
+                            match Event::from_frame(frame) {
+                                Ok(event) => {
+                                    // 简洁输出
+                                    // print_event(&event);
+                                    // 详细输出 (调试用)
+                                    print_event_verbose(&event);
+                                }
+                                Err(e) => eprintln!("[解析错误] {}", e),
+                            }
+                        }
+                        Err(e) => {
+                            eprintln!("[帧解析错误] {}", e);
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("[网络错误] {}", e);
+                break;
+            }
+        }
+    }
+
+    println!("\n{}", "=".repeat(60));
+    println!("流式响应结束");
+    println!("共接收 {} 字节，解码 {} 帧", total_bytes, decoder.frames_decoded());
+
+    Ok(())
+}
\ No newline at end of file
diff --git a/src/token.rs b/src/token.rs
new file mode 100644
index 0000000..32a8962
--- /dev/null
+++ b/src/token.rs
@@ -0,0 +1,242 @@
+//! Token 计算模块
+//!
+//! 提供文本 token 数量计算功能。
+//!
+//! # 计算规则
+//! - 非西文字符：每个计 4.5 个字符单位
+//! - 西文字符：每个计 1 个字符单位
+//! - 4 个字符单位 = 1 token（四舍五入）
+
+use crate::anthropic::types::{
+    CountTokensRequest, CountTokensResponse, Message, SystemMessage, Tool,
+};
+use crate::http_client::{ProxyConfig, build_client};
+use crate::model::config::TlsBackend;
+use std::sync::OnceLock;
+
+/// Count Tokens API 配置
+#[derive(Clone, Default)]
+pub struct CountTokensConfig {
+    /// 外部 count_tokens API 地址
+    pub api_url: Option<String>,
+    /// count_tokens API 密钥
+    pub api_key: Option<String>,
+    /// count_tokens API 认证类型（"x-api-key" 或 "bearer"）
+    pub auth_type: String,
+    /// 代理配置
+    pub proxy: Option<ProxyConfig>,
+
+    pub tls_backend: TlsBackend,
+}
+
+/// 全局配置存储
+static COUNT_TOKENS_CONFIG: OnceLock<CountTokensConfig> = OnceLock::new();
+
+/// 初始化 count_tokens 配置
+///
+/// 应在应用启动时调用一次
+pub fn init_config(config: CountTokensConfig) {
+    let _ = COUNT_TOKENS_CONFIG.set(config);
+}
+
+/// 获取配置
+fn get_config() -> Option<&'static CountTokensConfig> {
+    COUNT_TOKENS_CONFIG.get()
+}
+
+/// 判断字符是否为非西文字符
+///
+/// 西文字符包括：
+/// - ASCII 字符 (U+0000..U+007F)
+/// - 拉丁字母扩展 (U+0080..U+024F)
+/// - 拉丁字母扩展附加 (U+1E00..U+1EFF)
+///
+/// 返回 true 表示该字符是非西文字符（如中文、日文、韩文、阿拉伯文等）
+fn is_non_western_char(c: char) -> bool {
+    !matches!(c,
+        // 基本 ASCII
+        '\u{0000}'..='\u{007F}' |
+        // 拉丁字母扩展-A (Latin Extended-A)
+        '\u{0080}'..='\u{00FF}' |
+        // 拉丁字母扩展-B (Latin Extended-B)
+        '\u{0100}'..='\u{024F}' |
+        // 拉丁字母扩展附加 (Latin Extended Additional)
+        '\u{1E00}'..='\u{1EFF}' |
+        // 拉丁字母扩展-C/D/E
+        '\u{2C60}'..='\u{2C7F}' |
+        '\u{A720}'..='\u{A7FF}' |
+        '\u{AB30}'..='\u{AB6F}'
+    )
+}
+
+/// 计算文本的 token 数量
+///
+/// # 计算规则
+/// - 非西文字符：每个计 4.5 个字符单位
+/// - 西文字符：每个计 1 个字符单位
+/// - 4 个字符单位 = 1 token（四舍五入）
+/// ```
+pub fn count_tokens(text: &str) -> u64 {
+    // println!("text: {}", text);
+
+    let char_units: f64 = text
+        .chars()
+        .map(|c| if is_non_western_char(c) { 4.0 } else { 1.0 })
+        .sum();
+
+    let tokens = char_units / 4.0;
+
+    if tokens < 100.0 {
+        (tokens * 1.5) as u64
+    } else if tokens < 200.0 {
+        (tokens * 1.3) as u64
+    } else if tokens < 300.0 {
+        (tokens * 1.25) as u64
+    } else if tokens < 800.0 {
+        (tokens * 1.2) as u64
+    } else {
+        tokens as u64
+    }
+}
+
+/// 估算请求的输入 tokens
+///
+/// 优先调用远程 API，失败时回退到本地计算
+pub(crate) fn count_all_tokens(
+    model: String,
+    system: Option<Vec<SystemMessage>>,
+    messages: Vec<Message>,
+    tools: Option<Vec<Tool>>,
+) -> u64 {
+    // 检查是否配置了远程 API
+    if let Some(config) = get_config()
+        && config.api_url.is_some()
+    {
+        // 尝试调用远程 API
+        let result = tokio::task::block_in_place(|| {
+            tokio::runtime::Handle::current().block_on(call_remote_count_tokens(
+                config, model, &system, &messages, &tools,
+            ))
+        });
+
+        match result {
+            Ok(tokens) => {
+                tracing::debug!("远程 count_tokens API 返回: {}", tokens);
+                return tokens;
+            }
+            Err(e) => {
+                tracing::warn!("远程 count_tokens API 调用失败，回退到本地计算: {}", e);
+            }
+        }
+    }
+
+    // 本地计算
+    count_all_tokens_local(system, messages, tools)
+}
+
+/// 调用远程 count_tokens API
+async fn call_remote_count_tokens(
+    config: &CountTokensConfig,
+    model: String,
+    system: &Option<Vec<SystemMessage>>,
+    messages: &[Message],
+    tools: &Option<Vec<Tool>>,
+) -> Result<u64, Box<dyn std::error::Error + Send + Sync>> {
+    let api_url = config.api_url.as_ref().unwrap();
+    let client = build_client(config.proxy.as_ref(), 300, config.tls_backend)?;
+
+    // 构建请求体
+    let request = CountTokensRequest {
+        model,
+        messages: messages.to_vec(),
+        system: system.clone(),
+        tools: tools.clone(),
+    };
+
+    // 构建请求
+    let mut req_builder = client.post(api_url);
+
+    // 设置认证头
+    if let Some(api_key) = &config.api_key {
+        if config.auth_type == "bearer" {
+            req_builder = req_builder.header("Authorization", format!("Bearer {}", api_key));
+        } else {
+            req_builder = req_builder.header("x-api-key", api_key);
+        }
+    }
+
+    // 发送请求
+    let response = req_builder
+        .header("Content-Type", "application/json")
+        .json(&request)
+        .send()
+        .await?;
+
+    if !response.status().is_success() {
+        return Err(format!("API 返回错误状态: {}", response.status()).into());
+    }
+
+    let result: CountTokensResponse = response.json().await?;
+    Ok(result.input_tokens as u64)
+}
+
+/// 本地计算请求的输入 tokens
+fn count_all_tokens_local(
+    system: Option<Vec<SystemMessage>>,
+    messages: Vec<Message>,
+    tools: Option<Vec<Tool>>,
+) -> u64 {
+    let mut total = 0;
+
+    // 系统消息
+    if let Some(ref system) = system {
+        for msg in system {
+            total += count_tokens(&msg.text);
+        }
+    }
+
+    // 用户消息
+    for msg in &messages {
+        if let serde_json::Value::String(s) = &msg.content {
+            total += count_tokens(s);
+        } else if let serde_json::Value::Array(arr) = &msg.content {
+            for item in arr {
+                if let Some(text) = item.get("text").and_then(|v| v.as_str()) {
+                    total += count_tokens(text);
+                }
+            }
+        }
+    }
+
+    // 工具定义
+    if let Some(ref tools) = tools {
+        for tool in tools {
+            total += count_tokens(&tool.name);
+            total += count_tokens(&tool.description);
+            let input_schema_json = serde_json::to_string(&tool.input_schema).unwrap_or_default();
+            total += count_tokens(&input_schema_json);
+        }
+    }
+
+    total.max(1)
+}
+
+/// 估算输出 tokens
+pub(crate) fn estimate_output_tokens(content: &[serde_json::Value]) -> i32 {
+    let mut total = 0;
+
+    for block in content {
+        if let Some(text) = block.get("text").and_then(|v| v.as_str()) {
+            total += count_tokens(text) as i32;
+        }
+        if block.get("type").and_then(|v| v.as_str()) == Some("tool_use") {
+            // 工具调用开销
+            if let Some(input) = block.get("input") {
+                let input_str = serde_json::to_string(input).unwrap_or_default();
+                total += count_tokens(&input_str) as i32;
+            }
+        }
+    }
+
+    total.max(1)
+}
diff --git a/tools/analyze_compression.py b/tools/analyze_compression.py
new file mode 100644
index 0000000..8217134
--- /dev/null
+++ b/tools/analyze_compression.py
@@ -0,0 +1,691 @@
+#!/usr/bin/env python3
+"""
+离线分析上下文压缩管道表现。
+
+从 Docker 日志中提取压缩相关的 tracing 结构化数据，
+生成汇总报告，帮助评估五层压缩管道的实际效果。
+
+使用方法：
+  python3 tools/analyze_compression.py logs/docker.log
+  python3 tools/analyze_compression.py --top 10 logs/docker.log
+  python3 tools/analyze_compression.py --csv output.csv logs/docker.log
+  python3 tools/analyze_compression.py --json logs/docker.log
+  cat logs/docker.log | python3 tools/analyze_compression.py -
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import re
+import sys
+from collections import defaultdict
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, List, Optional, Sequence
+
+
+# ---------------------------------------------------------------------------
+# ANSI 清理（复用 diagnose_improper_request.py 的模式）
+# ---------------------------------------------------------------------------
+
+# 覆盖常见 CSI 序列（含少见的 ':' 参数分隔符），避免污染 URL/字段解析。
+ANSI_RE = re.compile(r"\x1b\[[0-9;:?]*[A-Za-z]")
+
+
+def strip_ansi(s: str) -> str:
+    return ANSI_RE.sub("", s)
+
+
+# ---------------------------------------------------------------------------
+# 时间戳提取
+# ---------------------------------------------------------------------------
+
+# ISO 8601 时间戳（行首），兼容带/不带时区
+TIMESTAMP_RE = re.compile(r"(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})")
+
+
+def extract_timestamp(line: str) -> Optional[str]:
+    """提取行首 ISO 时间戳，返回秒级精度字符串或 None。"""
+    m = TIMESTAMP_RE.search(line[:40])
+    return m.group(1) if m else None
+
+
+def hour_bucket(ts: str) -> str:
+    """截取到小时：2025-01-15T10:23:45 -> 2025-01-15T10"""
+    return ts[:13]
+
+
+# ---------------------------------------------------------------------------
+# tracing key=value 解析
+# ---------------------------------------------------------------------------
+
+KV_RE = re.compile(r"(\w+)=(\d+(?:\.\d+)?|\"[^\"]*\"|[^\s,]+)")
+
+
+def parse_kv(line: str) -> Dict[str, str]:
+    """从 tracing 结构化行中提取所有 key=value 对。"""
+    return {m.group(1): m.group(2).strip('"') for m in KV_RE.finditer(line)}
+
+
+def kv_int(kv: Dict[str, str], key: str, default: int = 0) -> int:
+    v = kv.get(key)
+    if v is None:
+        return default
+    try:
+        return int(v)
+    except ValueError:
+        return default
+
+
+def kv_float(kv: Dict[str, str], key: str, default: float = 0.0) -> float:
+    v = kv.get(key)
+    if v is None:
+        return default
+    try:
+        return float(v)
+    except ValueError:
+        return default
+
+
+# ---------------------------------------------------------------------------
+# 数据模型
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class RequestRecord:
+    """一次请求行的数据。"""
+    line_no: int
+    timestamp: Optional[str] = None
+    model: str = ""
+    max_tokens: int = 0
+    stream: bool = True
+    message_count: int = 0
+    estimated_input_tokens: int = 0
+
+
+@dataclass
+class CompressionRecord:
+    """一次压缩统计行的数据。"""
+    line_no: int
+    timestamp: Optional[str] = None
+    estimated_input_tokens: int = 0
+    bytes_saved_total: int = 0
+    whitespace_bytes_saved: int = 0
+    thinking_bytes_saved: int = 0
+    tool_result_bytes_saved: int = 0
+    tool_use_input_bytes_saved: int = 0
+    history_turns_removed: int = 0
+    history_bytes_saved: int = 0
+
+
+@dataclass
+class ContextUsageRecord:
+    """contextUsageEvent 行的数据。"""
+    line_no: int
+    context_usage_percentage: float = 0.0
+    actual_input_tokens: int = 0
+
+
+@dataclass
+class RejectionRecord:
+    """上游拒绝行的数据。"""
+    line_no: int
+    kiro_request_body_bytes: int = 0
+
+
+@dataclass
+class AdaptiveShrinkRecord:
+    """自适应二次压缩触发行的数据。"""
+    line_no: int
+    timestamp: Optional[str] = None
+    conversation_id: Optional[str] = None
+    initial_bytes: int = 0
+    final_bytes: int = 0
+    threshold: int = 0
+    iters: int = 0
+    additional_history_turns_removed: int = 0
+
+
+@dataclass
+class LocalRejectRecord:
+    """本地超限拒绝行的数据。"""
+    line_no: int
+    timestamp: Optional[str] = None
+    conversation_id: Optional[str] = None
+    request_body_bytes: int = 0
+    image_bytes: int = 0
+    effective_bytes: int = 0
+    threshold: int = 0
+
+
+@dataclass
+class MergedRequest:
+    """关联后的完整请求记录。"""
+    line_no: int = 0
+    timestamp: Optional[str] = None
+    model: str = ""
+    max_tokens: int = 0
+    stream: bool = True
+    message_count: int = 0
+    estimated_input_tokens: int = 0
+    # 压缩统计
+    bytes_saved_total: int = 0
+    whitespace_bytes_saved: int = 0
+    thinking_bytes_saved: int = 0
+    tool_result_bytes_saved: int = 0
+    tool_use_input_bytes_saved: int = 0
+    history_turns_removed: int = 0
+    history_bytes_saved: int = 0
+    has_compression: bool = False
+    # 上下文使用
+    context_usage_percentage: Optional[float] = None
+    actual_input_tokens: Optional[int] = None
+    # 压缩率
+    compression_rate: float = 0.0
+
+
+# ---------------------------------------------------------------------------
+# 日志解析
+# ---------------------------------------------------------------------------
+
+# 匹配标记
+MARKER_REQUEST = "Received POST /v1/messages request"
+MARKER_COMPRESSION = "输入压缩完成"
+MARKER_CONTEXT_USAGE = "收到 contextUsageEvent"
+MARKER_REJECTION = "上游拒绝请求：输入上下文过长"
+MARKER_ADAPTIVE_SHRINK = "请求体超过阈值，已执行自适应二次压缩"
+MARKER_LOCAL_REJECT = "请求体超过安全阈值，拒绝发送"
+
+# contextUsageEvent 格式：收到 contextUsageEvent: 67.2%, 计算 input_tokens: 12345
+CONTEXT_USAGE_RE = re.compile(
+    r"收到 contextUsageEvent:\s*([\d.]+)%.*?input_tokens:\s*(\d+)"
+)
+
+
+def parse_log(
+    lines: Sequence[str],
+    *,
+    min_tokens: int = 0,
+    model_pattern: Optional[str] = None,
+) -> tuple[
+    list[MergedRequest],
+    list[RejectionRecord],
+    list[AdaptiveShrinkRecord],
+    list[LocalRejectRecord],
+    int,
+]:
+    """
+    解析日志行，返回 (merged_requests, rejections, total_lines)。
+
+    关联策略：连续出现的请求行和压缩统计行，
+    基于 estimated_input_tokens 匹配 + 行号邻近（间距 ≤ 50 行）。
+    """
+    requests: list[RequestRecord] = []
+    compressions: list[CompressionRecord] = []
+    context_usages: list[ContextUsageRecord] = []
+    rejections: list[RejectionRecord] = []
+    adaptive_shrinks: list[AdaptiveShrinkRecord] = []
+    local_rejects: list[LocalRejectRecord] = []
+
+    model_re = re.compile(model_pattern, re.IGNORECASE) if model_pattern else None
+
+    for idx, raw_line in enumerate(lines):
+        line_no = idx + 1
+        line = strip_ansi(raw_line)
+
+        if MARKER_REQUEST in line:
+            kv = parse_kv(line)
+            model = kv.get("model", "")
+            if model_re and not model_re.search(model):
+                continue
+            est = kv_int(kv, "estimated_input_tokens")
+            if est < min_tokens:
+                continue
+            requests.append(RequestRecord(
+                line_no=line_no,
+                timestamp=extract_timestamp(line),
+                model=model,
+                max_tokens=kv_int(kv, "max_tokens"),
+                stream=kv.get("stream", "true") == "true",
+                message_count=kv_int(kv, "message_count"),
+                estimated_input_tokens=est,
+            ))
+
+        elif MARKER_COMPRESSION in line:
+            kv = parse_kv(line)
+            est = kv_int(kv, "estimated_input_tokens")
+            if est < min_tokens:
+                continue
+            compressions.append(CompressionRecord(
+                line_no=line_no,
+                timestamp=extract_timestamp(line),
+                estimated_input_tokens=est,
+                bytes_saved_total=kv_int(kv, "bytes_saved_total"),
+                whitespace_bytes_saved=kv_int(kv, "whitespace_bytes_saved"),
+                thinking_bytes_saved=kv_int(kv, "thinking_bytes_saved"),
+                tool_result_bytes_saved=kv_int(kv, "tool_result_bytes_saved"),
+                tool_use_input_bytes_saved=kv_int(kv, "tool_use_input_bytes_saved"),
+                history_turns_removed=kv_int(kv, "history_turns_removed"),
+                history_bytes_saved=kv_int(kv, "history_bytes_saved"),
+            ))
+
+        elif MARKER_CONTEXT_USAGE in line:
+            m = CONTEXT_USAGE_RE.search(line)
+            if m:
+                context_usages.append(ContextUsageRecord(
+                    line_no=line_no,
+                    context_usage_percentage=float(m.group(1)),
+                    actual_input_tokens=int(m.group(2)),
+                ))
+
+        elif MARKER_REJECTION in line:
+            kv = parse_kv(line)
+            rejections.append(RejectionRecord(
+                line_no=line_no,
+                kiro_request_body_bytes=kv_int(kv, "kiro_request_body_bytes"),
+            ))
+
+        elif MARKER_ADAPTIVE_SHRINK in line:
+            kv = parse_kv(line)
+            adaptive_shrinks.append(AdaptiveShrinkRecord(
+                line_no=line_no,
+                timestamp=extract_timestamp(line),
+                conversation_id=kv.get("conversation_id"),
+                initial_bytes=kv_int(kv, "initial_bytes"),
+                final_bytes=kv_int(kv, "final_bytes"),
+                threshold=kv_int(kv, "threshold"),
+                iters=kv_int(kv, "iters"),
+                additional_history_turns_removed=kv_int(kv, "additional_history_turns_removed"),
+            ))
+
+        elif MARKER_LOCAL_REJECT in line:
+            kv = parse_kv(line)
+            local_rejects.append(LocalRejectRecord(
+                line_no=line_no,
+                timestamp=extract_timestamp(line),
+                conversation_id=kv.get("conversation_id"),
+                request_body_bytes=kv_int(kv, "request_body_bytes"),
+                image_bytes=kv_int(kv, "image_bytes"),
+                effective_bytes=kv_int(kv, "effective_bytes"),
+                threshold=kv_int(kv, "threshold"),
+            ))
+
+    # --- 关联请求行与压缩统计行 ---
+    merged = _merge_records(requests, compressions, context_usages)
+
+    return merged, rejections, adaptive_shrinks, local_rejects, len(lines)
+
+
+def _merge_records(
+    requests: list[RequestRecord],
+    compressions: list[CompressionRecord],
+    context_usages: list[ContextUsageRecord],
+) -> list[MergedRequest]:
+    """
+    关联请求行与压缩统计行。
+
+    策略：对每个请求行，在其后 50 行内查找 estimated_input_tokens 相同的压缩统计行。
+    """
+    merged: list[MergedRequest] = []
+    used_comp_indices: set[int] = set()
+    used_ctx_indices: set[int] = set()
+
+    for req in requests:
+        mr = MergedRequest(
+            line_no=req.line_no,
+            timestamp=req.timestamp,
+            model=req.model,
+            max_tokens=req.max_tokens,
+            stream=req.stream,
+            message_count=req.message_count,
+            estimated_input_tokens=req.estimated_input_tokens,
+        )
+
+        # 查找匹配的压缩统计行
+        for ci, comp in enumerate(compressions):
+            if ci in used_comp_indices:
+                continue
+            # 行号邻近（压缩行在请求行之后 50 行内）
+            if not (0 < comp.line_no - req.line_no <= 50):
+                continue
+            # estimated_input_tokens 匹配
+            if comp.estimated_input_tokens != req.estimated_input_tokens:
+                continue
+            # 匹配成功
+            mr.bytes_saved_total = comp.bytes_saved_total
+            mr.whitespace_bytes_saved = comp.whitespace_bytes_saved
+            mr.thinking_bytes_saved = comp.thinking_bytes_saved
+            mr.tool_result_bytes_saved = comp.tool_result_bytes_saved
+            mr.tool_use_input_bytes_saved = comp.tool_use_input_bytes_saved
+            mr.history_turns_removed = comp.history_turns_removed
+            mr.history_bytes_saved = comp.history_bytes_saved
+            mr.has_compression = True
+            used_comp_indices.add(ci)
+            break
+
+        # 查找匹配的 contextUsageEvent（在请求行之后 500 行内）
+        for ui, ctx in enumerate(context_usages):
+            if ui in used_ctx_indices:
+                continue
+            if not (0 < ctx.line_no - req.line_no <= 500):
+                continue
+            mr.context_usage_percentage = ctx.context_usage_percentage
+            mr.actual_input_tokens = ctx.actual_input_tokens
+            used_ctx_indices.add(ui)
+            break
+
+        # 计算压缩率（基于估算 token 数，假设 1 token ≈ 4 bytes）
+        if mr.estimated_input_tokens > 0 and mr.bytes_saved_total > 0:
+            estimated_bytes = mr.estimated_input_tokens * 4
+            mr.compression_rate = mr.bytes_saved_total / estimated_bytes * 100
+
+        merged.append(mr)
+
+    return merged
+
+
+# ---------------------------------------------------------------------------
+# 统计计算
+# ---------------------------------------------------------------------------
+
+
+def median(values: list[float]) -> float:
+    if not values:
+        return 0.0
+    s = sorted(values)
+    n = len(s)
+    if n % 2 == 1:
+        return s[n // 2]
+    return (s[n // 2 - 1] + s[n // 2]) / 2
+
+
+def percentile(values: list[float], p: float) -> float:
+    if not values:
+        return 0.0
+    s = sorted(values)
+    k = (len(s) - 1) * p / 100
+    f = int(k)
+    c = f + 1 if f + 1 < len(s) else f
+    return s[f] + (s[c] - s[f]) * (k - f)
+
+
+def fmt_bytes(n: int) -> str:
+    """格式化字节数为人类可读形式。"""
+    if n >= 1_000_000:
+        return f"{n:,} ({n / 1_000_000:.1f} MB)"
+    if n >= 1_000:
+        return f"{n:,} ({n / 1_000:.1f} KB)"
+    return f"{n:,}"
+
+
+# ---------------------------------------------------------------------------
+# 报告生成
+# ---------------------------------------------------------------------------
+
+
+def generate_report(
+    merged: list[MergedRequest],
+    rejections: list[RejectionRecord],
+    adaptive_shrinks: list[AdaptiveShrinkRecord],
+    local_rejects: list[LocalRejectRecord],
+    total_lines: int,
+    *,
+    top_n: int = 5,
+) -> str:
+    """生成文本格式的分析报告。"""
+    lines: list[str] = []
+    w = lines.append
+
+    w("=== 上下文压缩分析报告 ===")
+    w("")
+    w(f"扫描行数: {total_lines:,}")
+    w(f"匹配请求: {len(merged)}")
+    with_comp = [r for r in merged if r.has_compression]
+    w(f"有压缩统计: {len(with_comp)}")
+    w("")
+
+    if not with_comp:
+        w("未找到压缩统计数据。")
+        return "\n".join(lines)
+
+    # --- 总体概览 ---
+    total_saved = sum(r.bytes_saved_total for r in with_comp)
+    avg_saved = total_saved // len(with_comp) if with_comp else 0
+    rates = [r.compression_rate for r in with_comp if r.compression_rate > 0]
+    median_rate = median(rates)
+
+    w("--- 总体概览 ---")
+    w(f"总节省字节: {fmt_bytes(total_saved)}")
+    w(f"平均每请求节省: {avg_saved:,} bytes")
+    w(f"压缩率中位数: {median_rate:.1f}%")
+    w("")
+
+    # --- 各层贡献 ---
+    ws_total = sum(r.whitespace_bytes_saved for r in with_comp)
+    th_total = sum(r.thinking_bytes_saved for r in with_comp)
+    tr_total = sum(r.tool_result_bytes_saved for r in with_comp)
+    tu_total = sum(r.tool_use_input_bytes_saved for r in with_comp)
+    hi_total = sum(r.history_bytes_saved for r in with_comp)
+
+    def layer_line(name: str, val: int) -> str:
+        pct = val / total_saved * 100 if total_saved > 0 else 0
+        avg = val // len(with_comp) if with_comp else 0
+        return f"  {name:<18}{val:>12,} bytes ({pct:>5.1f}%)  avg {avg:,}/req"
+
+    w("--- 各层贡献 ---")
+    w(layer_line("空白压缩:", ws_total))
+    w(layer_line("thinking 截断:", th_total))
+    w(layer_line("tool_result:", tr_total))
+    w(layer_line("tool_use_input:", tu_total))
+    w(layer_line("历史截断:", hi_total))
+    w("")
+
+    # --- 历史截断详情 ---
+    with_history = [r for r in with_comp if r.history_turns_removed > 0]
+    w("--- 历史截断详情 ---")
+    w(f"触发历史截断的请求: {len(with_history)}/{len(with_comp)} ({len(with_history)/len(with_comp)*100:.1f}%)")
+    if with_history:
+        turns = [r.history_turns_removed for r in with_history]
+        w(f"平均移除轮数: {sum(turns)/len(turns):.1f}")
+        w(f"最大移除轮数: {max(turns)}")
+    w("")
+
+    # --- 上下文窗口使用 ---
+    with_ctx = [r for r in merged if r.context_usage_percentage is not None]
+    w("--- 上下文窗口使用 (contextUsageEvent) ---")
+    if with_ctx:
+        usages = [r.context_usage_percentage for r in with_ctx]
+        avg_usage = sum(usages) / len(usages)
+        over_80 = sum(1 for u in usages if u > 80)
+        over_95 = sum(1 for u in usages if u > 95)
+        overflow = sum(1 for u in usages if u >= 100)
+        w(f"平均使用率: {avg_usage:.1f}%")
+        w(f">80% 使用率的请求: {over_80} ({over_80/len(with_ctx)*100:.1f}%)")
+        w(f">95% 使用率的请求: {over_95} ({over_95/len(with_ctx)*100:.1f}%)")
+        w(f"100% (溢出): {overflow} ({overflow/len(with_ctx)*100:.1f}%)")
+    else:
+        w("无 contextUsageEvent 数据（需要 DEBUG 日志级别）")
+    w("")
+
+    # --- 上游拒绝 ---
+    w("--- 上游拒绝 ---")
+    w(f"输入过长拒绝: {len(rejections)} 次")
+    w("")
+
+    # --- 自适应二次压缩 ---
+    w("--- 自适应二次压缩 ---")
+    w(f"触发次数: {len(adaptive_shrinks)}")
+    if adaptive_shrinks:
+        initial_avg = sum(r.initial_bytes for r in adaptive_shrinks) // len(adaptive_shrinks)
+        final_avg = sum(r.final_bytes for r in adaptive_shrinks) // len(adaptive_shrinks)
+        iters_avg = sum(r.iters for r in adaptive_shrinks) / len(adaptive_shrinks)
+        hist_avg = sum(r.additional_history_turns_removed for r in adaptive_shrinks) / len(adaptive_shrinks)
+        w(f"平均压缩前: {fmt_bytes(initial_avg)}")
+        w(f"平均压缩后: {fmt_bytes(final_avg)}")
+        w(f"平均迭代次数: {iters_avg:.1f}")
+        w(f"平均额外移除轮数: {hist_avg:.1f}")
+    w("")
+
+    # --- 本地拒绝（请求体超限） ---
+    w("--- 本地拒绝 (请求体超限) ---")
+    w(f"拒绝发送: {len(local_rejects)} 次")
+    if local_rejects:
+        top = sorted(local_rejects, key=lambda r: r.effective_bytes, reverse=True)[:5]
+        for r in top:
+            w(
+                "  line={line} effective={eff} threshold={th} body={body} image={img} conversationId={cid}".format(
+                    line=r.line_no,
+                    eff=r.effective_bytes,
+                    th=r.threshold,
+                    body=r.request_body_bytes,
+                    img=r.image_bytes,
+                    cid=r.conversation_id or "None",
+                )
+            )
+    w("")
+
+    # --- 高压缩请求 TOP-N ---
+    sorted_by_saved = sorted(with_comp, key=lambda r: r.bytes_saved_total, reverse=True)
+    w(f"--- 高压缩请求 TOP-{top_n} ---")
+    for i, r in enumerate(sorted_by_saved[:top_n], 1):
+        w(f"  #{i}  line={r.line_no}  saved={r.bytes_saved_total:,}  rate={r.compression_rate:.1f}%  model={r.model}  tokens={r.estimated_input_tokens:,}")
+    w("")
+
+    # --- 低效/无压缩请求样本 ---
+    no_comp = [r for r in with_comp if r.bytes_saved_total == 0]
+    w("--- 低效/无压缩请求样本 ---")
+    if no_comp:
+        for r in no_comp[:5]:
+            w(f"  line={r.line_no}  saved=0  tokens={r.estimated_input_tokens:,}  message_count={r.message_count}")
+    else:
+        w("  (无)")
+    w("")
+
+    # --- 时间趋势 ---
+    hourly: Dict[str, list[MergedRequest]] = defaultdict(list)
+    for r in with_comp:
+        if r.timestamp:
+            hourly[hour_bucket(r.timestamp)].append(r)
+
+    if hourly:
+        w("--- 时间趋势 (按小时) ---")
+        for hour in sorted(hourly.keys()):
+            reqs = hourly[hour]
+            avg_s = sum(r.bytes_saved_total for r in reqs) // len(reqs)
+            ctx_reqs = [r for r in reqs if r.context_usage_percentage is not None]
+            avg_ctx = sum(r.context_usage_percentage for r in ctx_reqs) / len(ctx_reqs) if ctx_reqs else 0
+            ctx_str = f"  avg_context_usage={avg_ctx:.1f}%" if ctx_reqs else ""
+            w(f"  {hour}:  requests={len(reqs)}  avg_saved={avg_s:,}{ctx_str}")
+        w("")
+
+    return "\n".join(lines)
+
+
+def generate_json_report(
+    merged: list[MergedRequest],
+    rejections: list[RejectionRecord],
+    adaptive_shrinks: list[AdaptiveShrinkRecord],
+    local_rejects: list[LocalRejectRecord],
+    total_lines: int,
+) -> str:
+    """生成 JSON 格式的汇总报告。"""
+    with_comp = [r for r in merged if r.has_compression]
+    total_saved = sum(r.bytes_saved_total for r in with_comp)
+
+    report = {
+        "total_lines": total_lines,
+        "matched_requests": len(merged),
+        "with_compression": len(with_comp),
+        "total_bytes_saved": total_saved,
+        "avg_bytes_saved": total_saved // len(with_comp) if with_comp else 0,
+        "layers": {
+            "whitespace": sum(r.whitespace_bytes_saved for r in with_comp),
+            "thinking": sum(r.thinking_bytes_saved for r in with_comp),
+            "tool_result": sum(r.tool_result_bytes_saved for r in with_comp),
+            "tool_use_input": sum(r.tool_use_input_bytes_saved for r in with_comp),
+            "history": sum(r.history_bytes_saved for r in with_comp),
+        },
+        "rejections": len(rejections),
+        "adaptive_shrinks": len(adaptive_shrinks),
+        "local_rejects": len(local_rejects),
+    }
+    return json.dumps(report, indent=2, ensure_ascii=False)
+
+
+def write_csv(merged: list[MergedRequest], path: str) -> None:
+    """导出每条请求的明细为 CSV。"""
+    fieldnames = [
+        "line_no", "timestamp", "model", "max_tokens", "stream",
+        "message_count", "estimated_input_tokens", "bytes_saved_total",
+        "whitespace_bytes_saved", "thinking_bytes_saved",
+        "tool_result_bytes_saved", "tool_use_input_bytes_saved",
+        "history_turns_removed", "history_bytes_saved",
+        "compression_rate", "context_usage_percentage", "actual_input_tokens",
+    ]
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for r in merged:
+            row = asdict(r)
+            row = {k: row[k] for k in fieldnames}
+            writer.writerow(row)
+
+
+# ---------------------------------------------------------------------------
+# CLI 入口
+# ---------------------------------------------------------------------------
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(
+        description="分析上下文压缩管道表现",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument(
+        "logfile", nargs="?", default="logs/docker.log",
+        help="日志文件路径，使用 '-' 从 stdin 读取（默认: logs/docker.log）"
+    )
+    parser.add_argument("--top", type=int, default=5, help="高压缩请求 TOP-N（默认: 5）")
+    parser.add_argument("--csv", metavar="FILE", help="导出每条请求的明细为 CSV")
+    parser.add_argument("--json", action="store_true", help="JSON 格式输出汇总")
+    parser.add_argument("--min-tokens", type=int, default=0, help="仅分析 estimated_input_tokens >= N 的请求")
+    parser.add_argument("--model", metavar="PATTERN", help="按模型名过滤（正则）")
+    args = parser.parse_args(argv)
+
+    # 读取日志
+    if args.logfile == "-":
+        log_lines = sys.stdin.read().splitlines()
+    else:
+        try:
+            with open(args.logfile, "r", encoding="utf-8", errors="replace") as f:
+                log_lines = f.read().splitlines()
+        except FileNotFoundError:
+            print(f"ERROR: 日志文件不存在: {args.logfile}", file=sys.stderr)
+            return 2
+
+    # 解析
+    merged, rejections, adaptive_shrinks, local_rejects, total_lines = parse_log(
+        log_lines,
+        min_tokens=args.min_tokens,
+        model_pattern=args.model,
+    )
+
+    # 输出
+    if args.json:
+        print(generate_json_report(merged, rejections, adaptive_shrinks, local_rejects, total_lines))
+    else:
+        print(generate_report(merged, rejections, adaptive_shrinks, local_rejects, total_lines, top_n=args.top))
+
+    # CSV 导出
+    if args.csv:
+        write_csv(merged, args.csv)
+        print(f"CSV 已导出: {args.csv}", file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/tools/diagnose_improper_request.py b/tools/diagnose_improper_request.py
new file mode 100644
index 0000000..5ef0e4f
--- /dev/null
+++ b/tools/diagnose_improper_request.py
@@ -0,0 +1,646 @@
+#!/usr/bin/env python3
+"""
+离线诊断 `Improperly formed request`（上游 400）常见成因。
+
+使用方法：
+  python3 tools/diagnose_improper_request.py logs/docker.log
+
+脚本会从日志中提取 `request_body=...{json}`，对请求做一组启发式校验并输出汇总与样本。
+目标是快速定位“项目侧可修复的请求构造问题”，而不是复现上游的完整校验逻辑。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+
+# 覆盖常见 CSI 序列（含少见的 ':' 参数分隔符），避免污染 URL/字段解析。
+ANSI_RE = re.compile(r"\x1b\[[0-9;:?]*[A-Za-z]")
+KV_RE = re.compile(r"(\w+)=(\d+(?:\.\d+)?|\"[^\"]*\"|[^\s,]+)")
+
+
+@dataclass(frozen=True)
+class RequestSummary:
+    line_no: int
+    conversation_id: Optional[str]
+    content_len: int
+    tools_n: int
+    tool_results_n: int
+    history_n: int
+    json_len: int
+
+
+def strip_ansi(s: str) -> str:
+    return ANSI_RE.sub("", s)
+
+
+def parse_kv(line: str) -> Dict[str, str]:
+    """从 tracing 结构化行中提取所有 key=value 对。"""
+    return {m.group(1): m.group(2).strip('"') for m in KV_RE.finditer(line)}
+
+
+def iter_request_bodies(log_text: str) -> Iterable[Tuple[int, Dict[str, Any]]]:
+    """从日志中提取 request_body JSON。
+
+    支持两种日志格式：
+    1. sensitive-logs 模式：request_body={"conversationState":...}（可能被截断）
+    2. 普通模式：kiro_request_body_bytes=135777（无 JSON 内容）
+
+    对于截断的 JSON，尝试用 raw_decode 解析到第一个完整 JSON 对象。
+    同时排除 response_body 的误匹配。
+    """
+    decoder = json.JSONDecoder()
+    # 两种来源：
+    # 1. handler DEBUG: "Kiro request body: {json}"（发送前，完整内容）
+    # 2. provider ERROR: "request_body={json}"（400 后，可能被截断）
+    kiro_body_marker = "Kiro request body: "
+    body_re = re.compile(r"(?<![a-z_])request_body=")
+
+    for line_no, line in enumerate(log_text.splitlines(), 1):
+        clean = strip_ansi(line)
+
+        # 来源 1: handler 的 DEBUG 日志（优先，内容更完整）
+        kiro_idx = clean.find(kiro_body_marker)
+        if kiro_idx != -1:
+            brace = clean.find("{", kiro_idx + len(kiro_body_marker))
+            if brace == -1:
+                continue
+        elif "request_body=" in clean:
+            # 来源 2: provider 的 ERROR 日志
+            match = body_re.search(clean)
+            if not match:
+                continue
+            brace = clean.find("{", match.end())
+            if brace == -1:
+                continue
+        else:
+            continue
+
+        # 使用 raw_decode 解析第一个完整 JSON 对象（忽略行尾其他 tracing 字段）
+        try:
+            body, _ = decoder.raw_decode(clean, brace)
+        except json.JSONDecodeError:
+            # JSON 被截断（sensitive-logs 的 truncate_middle），尝试提取可用信息
+            body_str = clean[brace:]
+            yield line_no, _partial_parse_request_body(body_str, line_no)
+            continue
+
+        if isinstance(body, dict):
+            yield line_no, body
+
+
+def _partial_parse_request_body(truncated_json: str, line_no: int) -> Dict[str, Any]:
+    """从截断的 JSON 中尽量提取结构信息。
+
+    即使 JSON 不完整，也能通过正则提取 conversationId、工具数量等关键字段，
+    用于启发式诊断。
+    """
+    info: Dict[str, Any] = {"_partial": True, "_raw_len": len(truncated_json)}
+
+    # 提取 conversationId
+    m = re.search(r'"conversationId"\s*:\s*"([^"]+)"', truncated_json)
+    if m:
+        info["_conversationId"] = m.group(1)
+
+    # 统计 toolUseId 出现次数（近似 tool_use 数量）
+    info["_toolUseId_count"] = len(re.findall(r'"toolUseId"', truncated_json))
+
+    # 统计 toolSpecification 出现次数（近似 tool 定义数量）
+    info["_toolSpec_count"] = len(re.findall(r'"toolSpecification"', truncated_json))
+
+    # 统计 assistantResponseMessage 出现次数（近似 history 轮数）
+    info["_assistant_msg_count"] = len(re.findall(r'"assistantResponseMessage"', truncated_json))
+
+    # 统计 userInputMessage 出现次数
+    info["_user_msg_count"] = len(re.findall(r'"userInputMessage"', truncated_json))
+
+    return info
+
+
+def _get(d: Dict[str, Any], path: str, default: Any = None) -> Any:
+    cur: Any = d
+    for part in path.split("."):
+        if not isinstance(cur, dict):
+            return default
+        cur = cur.get(part)
+    return cur if cur is not None else default
+
+
+def summarize(body: Dict[str, Any], line_no: int) -> RequestSummary:
+    # 处理 partial 解析的情况
+    if body.get("_partial"):
+        return RequestSummary(
+            line_no=line_no,
+            conversation_id=body.get("_conversationId"),
+            content_len=-1,
+            tools_n=body.get("_toolSpec_count", -1),
+            tool_results_n=body.get("_toolUseId_count", -1),
+            history_n=body.get("_assistant_msg_count", -1),
+            json_len=body.get("_raw_len", 0),
+        )
+
+    conversation_id = _get(body, "conversationState.conversationId")
+    content = _get(body, "conversationState.currentMessage.userInputMessage.content", "")
+    tools = _get(body, "conversationState.currentMessage.userInputMessage.userInputMessageContext.tools", [])
+    tool_results = _get(
+        body,
+        "conversationState.currentMessage.userInputMessage.userInputMessageContext.toolResults",
+        [],
+    )
+    history = _get(body, "conversationState.history", [])
+
+    json_len = len(json.dumps(body, ensure_ascii=False, separators=(",", ":")))
+
+    return RequestSummary(
+        line_no=line_no,
+        conversation_id=conversation_id if isinstance(conversation_id, str) else None,
+        content_len=len(content) if isinstance(content, str) else -1,
+        tools_n=len(tools) if isinstance(tools, list) else -1,
+        tool_results_n=len(tool_results) if isinstance(tool_results, list) else -1,
+        history_n=len(history) if isinstance(history, list) else -1,
+        json_len=json_len,
+    )
+
+
+def find_issues(
+    body: Dict[str, Any],
+    *,
+    max_history_messages: int,
+    large_payload_bytes: int,
+    huge_payload_bytes: int,
+) -> List[str]:
+    # partial 解析的请求只能做有限诊断
+    if body.get("_partial"):
+        issues: List[str] = ["W_TRUNCATED_LOG"]
+        raw_len = body.get("_raw_len", 0)
+        if raw_len > large_payload_bytes:
+            issues.append("W_PAYLOAD_LARGE")
+        return issues
+
+    issues = []
+
+    cs = body.get("conversationState") or {}
+    cm = _get(body, "conversationState.currentMessage.userInputMessage", {})
+    ctx = cm.get("userInputMessageContext") or {}
+
+    content = cm.get("content")
+    images = cm.get("images") or []
+    tools = ctx.get("tools") or []
+    tool_results = ctx.get("toolResults") or []
+    history = cs.get("history") or []
+
+    if isinstance(content, str) and content.strip() == "":
+        if images:
+            issues.append("E_CONTENT_EMPTY_WITH_IMAGES")
+        elif tool_results:
+            issues.append("E_CONTENT_EMPTY_WITH_TOOL_RESULTS")
+        else:
+            issues.append("E_CONTENT_EMPTY")
+
+    # Tool 规范检查：description/schema
+    empty_desc: List[str] = []
+    missing_schema: List[str] = []
+    missing_type: List[str] = []
+    for t in tools if isinstance(tools, list) else []:
+        if not isinstance(t, dict):
+            issues.append("E_TOOL_SHAPE_INVALID")
+            continue
+        spec = t.get("toolSpecification")
+        if not isinstance(spec, dict):
+            issues.append("E_TOOL_SPEC_MISSING")
+            continue
+
+        name = spec.get("name")
+        name_s = name if isinstance(name, str) else "<noname>"
+
+        desc = spec.get("description")
+        if isinstance(desc, str) and desc.strip() == "":
+            empty_desc.append(name_s)
+
+        inp = spec.get("inputSchema")
+        js = inp.get("json") if isinstance(inp, dict) else None
+        if isinstance(js, dict):
+            if "$schema" not in js:
+                missing_schema.append(name_s)
+            if "type" not in js:
+                missing_type.append(name_s)
+        else:
+            issues.append("E_TOOL_INPUT_SCHEMA_NOT_OBJECT")
+
+    if empty_desc:
+        issues.append("E_TOOL_DESCRIPTION_EMPTY")
+    if missing_schema:
+        issues.append("W_TOOL_SCHEMA_MISSING_$SCHEMA")
+    if missing_type:
+        issues.append("W_TOOL_SCHEMA_MISSING_TYPE")
+
+    # Tool result 是否能在 history 的 tool_use 里找到（启发式）
+    tool_use_ids: set[str] = set()
+    history_tool_result_ids: set[str] = set()
+    tool_def_names_ci: set[str] = set()
+
+    for t in tools if isinstance(tools, list) else []:
+        spec = t.get("toolSpecification") if isinstance(t, dict) else None
+        if isinstance(spec, dict) and isinstance(spec.get("name"), str):
+            tool_def_names_ci.add(spec["name"].lower())
+
+    for h in history if isinstance(history, list) else []:
+        if not isinstance(h, dict):
+            continue
+        am = h.get("assistantResponseMessage")
+        if not isinstance(am, dict):
+            # 也可能是 user 消息（含 tool_result）
+            um = h.get("userInputMessage")
+            if not isinstance(um, dict):
+                continue
+            uctx = um.get("userInputMessageContext")
+            if not isinstance(uctx, dict):
+                continue
+            trs = uctx.get("toolResults")
+            if not isinstance(trs, list):
+                continue
+            for tr in trs:
+                if not isinstance(tr, dict):
+                    continue
+                tid = tr.get("toolUseId")
+                if isinstance(tid, str):
+                    history_tool_result_ids.add(tid)
+            continue
+
+        tus = am.get("toolUses")
+        if isinstance(tus, list):
+            for tu in tus:
+                if not isinstance(tu, dict):
+                    continue
+                tid = tu.get("toolUseId")
+                if isinstance(tid, str):
+                    tool_use_ids.add(tid)
+                # 历史 tool_use 的 name 必须在 tools 中有定义（上游常见约束）
+                nm = tu.get("name")
+                if isinstance(nm, str) and tool_def_names_ci and nm.lower() not in tool_def_names_ci:
+                    issues.append("E_HISTORY_TOOL_USE_NAME_NOT_IN_TOOLS")
+
+        # 同一条历史消息可能同时包含 userInputMessage（少见，但兼容）
+        um = h.get("userInputMessage")
+        if isinstance(um, dict):
+            uctx = um.get("userInputMessageContext")
+            if isinstance(uctx, dict):
+                trs = uctx.get("toolResults")
+                if isinstance(trs, list):
+                    for tr in trs:
+                        if not isinstance(tr, dict):
+                            continue
+                        tid = tr.get("toolUseId")
+                        if isinstance(tid, str):
+                            history_tool_result_ids.add(tid)
+
+    # history 内部的 tool_result 必须能在 history 的 tool_use 中找到（否则极易触发 400）
+    if history_tool_result_ids and tool_use_ids:
+        if any(tid not in tool_use_ids for tid in history_tool_result_ids):
+            issues.append("E_HISTORY_TOOL_RESULT_ORPHAN")
+    elif history_tool_result_ids and not tool_use_ids:
+        issues.append("E_HISTORY_TOOL_RESULT_ORPHAN")
+
+    # currentMessage 的 tool_result 必须能在 history 的 tool_use 中找到
+    orphan_results = 0
+    current_tool_result_ids: set[str] = set()
+    if tool_use_ids and isinstance(tool_results, list):
+        for tr in tool_results:
+            if not isinstance(tr, dict):
+                continue
+            tid = tr.get("toolUseId")
+            if isinstance(tid, str):
+                current_tool_result_ids.add(tid)
+                if tid not in tool_use_ids:
+                    orphan_results += 1
+    if orphan_results:
+        issues.append("W_TOOL_RESULT_ORPHAN")
+
+    # history 的 tool_use 必须在 history/currentMessage 的 tool_result 中出现（否则极易触发 400）
+    all_tool_result_ids = history_tool_result_ids | current_tool_result_ids
+    if tool_use_ids and all_tool_result_ids:
+        if any(tid not in all_tool_result_ids for tid in tool_use_ids):
+            issues.append("E_HISTORY_TOOL_USE_ORPHAN")
+    elif tool_use_ids and not all_tool_result_ids:
+        issues.append("E_HISTORY_TOOL_USE_ORPHAN")
+
+    # history 过长（强启发式；日志里经常与 400 同现）
+    if isinstance(history, list) and len(history) > max_history_messages:
+        issues.append("W_HISTORY_TOO_LONG")
+
+    # payload 大小（强启发式；上游可能有不透明的硬限制）
+    json_len = len(json.dumps(body, ensure_ascii=False, separators=(",", ":")))
+    if json_len > huge_payload_bytes:
+        issues.append("W_PAYLOAD_HUGE")
+    elif json_len > large_payload_bytes:
+        issues.append("W_PAYLOAD_LARGE")
+
+    return issues
+
+
+def main(argv: List[str]) -> int:
+    parser = argparse.ArgumentParser(
+        description="离线诊断 Improperly formed request（上游 400）常见成因"
+    )
+    parser.add_argument("log", nargs="?", default="logs/docker.log", help="docker.log 路径")
+    parser.add_argument("--max-samples", type=int, default=5, help="每类问题输出样本数量")
+    parser.add_argument("--dump-dir", default=None, help="可选：把 request_body JSON 按行号落盘")
+    parser.add_argument("--max-history", type=int, default=100, help="history 过长阈值（启发式）")
+    # 上游存在约 5MiB 左右的硬限制；默认用 4.5MiB 作为“接近风险”的提示阈值。
+    parser.add_argument("--large-bytes", type=int, default=4_718_592, help="payload 大阈值（启发式）")
+    parser.add_argument("--huge-bytes", type=int, default=8_388_608, help="payload 巨大阈值（启发式）")
+    args = parser.parse_args(argv)
+
+    log_path = args.log
+    try:
+        log_text = open(log_path, "r", encoding="utf-8", errors="replace").read()
+    except FileNotFoundError:
+        print(f"ERROR: log file not found: {log_path}", file=sys.stderr)
+        return 2
+
+    dump_dir = args.dump_dir
+    if dump_dir:
+        os.makedirs(dump_dir, exist_ok=True)
+
+    # 先扫描项目侧“请求体超限，拒绝发送”的本地拦截（用于验证 4.5MiB 截断/拒绝是否生效）
+    print("=" * 60)
+    print("Phase 0: 扫描本地请求体超限拒绝")
+    print("=" * 60)
+    local_rejects = _scan_local_rejects(log_text)
+    if local_rejects:
+        for r in local_rejects[: args.max_samples]:
+            print(
+                "\n  [line {line}] effective_bytes={eff} threshold={th} body={body} image={img} conversationId={cid}".format(
+                    line=r.get("line_no"),
+                    eff=r.get("effective_bytes", "?"),
+                    th=r.get("threshold", "?"),
+                    body=r.get("request_body_bytes", "?"),
+                    img=r.get("image_bytes", "?"),
+                    cid=r.get("conversation_id") or "None",
+                )
+            )
+        if len(local_rejects) > args.max_samples:
+            print(f"\n  ... ({len(local_rejects) - args.max_samples} more)")
+    else:
+        print("  未发现本地请求体超限拒绝")
+    print("")
+
+    # 先扫描所有 400 Improperly formed request 的 ERROR 行，提取上下文
+    print("=" * 60)
+    print("Phase 1: 扫描 400 Improperly formed request 错误")
+    print("=" * 60)
+    error_lines = _scan_400_errors(
+        log_text,
+        max_history_messages=args.max_history,
+        large_payload_bytes=args.large_bytes,
+        huge_payload_bytes=args.huge_bytes,
+    )
+    if error_lines:
+        for el in error_lines:
+            print(f"\n  [line {el['line_no']}] bytes={el.get('body_bytes', '?')} "
+                  f"url={el.get('url', '?')}")
+            if "_req_body_line" in el:
+                print(f"    ↳ 关联请求体: line {el['_req_body_line']}"
+                      f"{' (truncated)' if el.get('_req_body_partial') else ''}")
+            if "summary" in el:
+                s = el["summary"]
+                print(f"    ↳ conversationId={s.conversation_id or 'None'} "
+                      f"content_len={s.content_len} tools={s.tools_n} "
+                      f"toolResults={s.tool_results_n} history={s.history_n} "
+                      f"json_len={s.json_len}")
+            if "issues" in el and el["issues"]:
+                print(f"    ↳ issues: {', '.join(el['issues'])}")
+            elif "_req_body" in el and el["_req_body"].get("_partial"):
+                body = el["_req_body"]
+                print(f"    ↳ partial: toolSpecs={body.get('_toolSpec_count', '?')} "
+                      f"toolUseIds={body.get('_toolUseId_count', '?')} "
+                      f"assistantMsgs={body.get('_assistant_msg_count', '?')} "
+                      f"userMsgs={body.get('_user_msg_count', '?')} "
+                      f"raw_len={body.get('_raw_len', '?')}")
+    else:
+        print("  未发现 400 Improperly formed request 错误")
+    print()
+
+    # 再扫描 request_body 条目
+    print("=" * 60)
+    print("Phase 2: 解析 request_body 条目")
+    print("=" * 60)
+
+    issue_counter: Counter[str] = Counter()
+    issues_to_samples: Dict[str, List[RequestSummary]] = defaultdict(list)
+    total = 0
+    partial_count = 0
+
+    for line_no, body in iter_request_bodies(log_text):
+        total += 1
+        if body.get("_partial"):
+            partial_count += 1
+        summary = summarize(body, line_no)
+        issues = find_issues(
+            body,
+            max_history_messages=args.max_history,
+            large_payload_bytes=args.large_bytes,
+            huge_payload_bytes=args.huge_bytes,
+        )
+
+        # 允许 dump 以便做最小化重放/差分调试
+        if dump_dir:
+            out_path = os.path.join(dump_dir, f"req_line_{line_no}.json")
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(body, f, ensure_ascii=False, indent=2)
+
+        if not issues:
+            issues = ["(NO_HEURISTIC_MATCH)"]
+
+        for issue in set(issues):
+            issue_counter[issue] += 1
+            if len(issues_to_samples[issue]) < args.max_samples:
+                issues_to_samples[issue].append(summary)
+
+    print(f"Parsed request_body entries: {total} (complete: {total - partial_count}, truncated: {partial_count})")
+    print("")
+
+    if not issue_counter:
+        print("No request_body entries found.")
+        if not error_lines:
+            print("\nHint: 如果使用非 sensitive-logs 模式，日志中不包含 request_body 内容。")
+            print("      请使用 --features sensitive-logs 重新编译，或检查 kiro_request_body_bytes 字段。")
+        return 0
+
+    print("Issue counts:")
+    for issue, cnt in issue_counter.most_common():
+        print(f"  {cnt:4d}  {issue}")
+    print("")
+
+    print("Samples:")
+    for issue, cnt in issue_counter.most_common():
+        samples = issues_to_samples.get(issue) or []
+        if not samples:
+            continue
+        print(f"- {issue} (showing {len(samples)}/{cnt})")
+        for s in samples:
+            print(
+                "  line={line} conversationId={cid} content_len={cl} tools={tn} toolResults={trn} history={hn} json_len={jl}".format(
+                    line=s.line_no,
+                    cid=s.conversation_id or "None",
+                    cl=s.content_len,
+                    tn=s.tools_n,
+                    trn=s.tool_results_n,
+                    hn=s.history_n,
+                    jl=s.json_len,
+                )
+            )
+        print("")
+
+    return 0
+
+
+def _scan_400_errors(
+    log_text: str,
+    *,
+    max_history_messages: int,
+    large_payload_bytes: int,
+    huge_payload_bytes: int,
+) -> List[Dict[str, Any]]:
+    """扫描日志中的 400 Improperly formed request 错误行，关联最近的请求体。
+
+    对每个 400 错误，向上查找最近的 'Kiro request body:' DEBUG 行，
+    解析其中的请求体并做启发式诊断。
+    """
+    lines = log_text.splitlines()
+    results = []
+    body_bytes_re = re.compile(r"(?:kiro_)?request_body_bytes=(\d+)")
+    url_re = re.compile(r"request_url=(\S+)")
+    decoder = json.JSONDecoder()
+
+    for line_no_0, line in enumerate(lines):
+        if "Improperly formed request" not in line:
+            continue
+        clean = strip_ansi(line)
+        # 避免同一错误被多条日志重复命中（provider ERROR 与 handler WARN 都可能包含该子串）
+        # 优先仅统计 provider ERROR（通常包含 request_url=...）
+        if "request_url=" not in clean:
+            continue
+        entry: Dict[str, Any] = {"line_no": line_no_0 + 1}
+
+        m = body_bytes_re.search(clean)
+        if m:
+            entry["body_bytes"] = int(m.group(1))
+        else:
+            # provider ERROR 行通常不带 body bytes，向上关联最近的构建日志/handler WARN（最多回溯 30 行）
+            for back in range(1, min(31, line_no_0 + 1)):
+                prev = strip_ansi(lines[line_no_0 - back])
+                m2 = body_bytes_re.search(prev)
+                if not m2:
+                    continue
+                entry["body_bytes"] = int(m2.group(1))
+                entry["_body_bytes_line"] = line_no_0 - back + 1
+                break
+
+        m = url_re.search(clean)
+        if m:
+            entry["url"] = m.group(1)
+
+        req_body = None
+
+        body_re = re.compile(r"(?<![a-z_])request_body=")
+
+        # 1) 向下查找错误块中的 request_body=...（provider 往往把 headers/body 打到后续行）
+        for fwd in range(0, min(31, len(lines) - line_no_0)):
+            cand = strip_ansi(lines[line_no_0 + fwd])
+            match = body_re.search(cand)
+            if not match:
+                continue
+            brace = cand.find("{", match.end())
+            if brace == -1:
+                continue
+            try:
+                req_body, _ = decoder.raw_decode(cand, brace)
+            except json.JSONDecodeError:
+                entry["_req_body_partial"] = True
+                req_body = _partial_parse_request_body(cand[brace:], line_no_0 + fwd + 1)
+            entry["_req_body_line"] = line_no_0 + fwd + 1
+            break
+
+        # 2) 若未找到，再向上查找 handler DEBUG 的 "Kiro request body:"（最多回溯 20 行）
+        if req_body is None:
+            for back in range(1, min(21, line_no_0 + 1)):
+                prev_line = strip_ansi(lines[line_no_0 - back])
+                marker = "Kiro request body: "
+                idx = prev_line.find(marker)
+                if idx == -1:
+                    continue
+                brace = prev_line.find("{", idx + len(marker))
+                if brace == -1:
+                    break
+                try:
+                    req_body, _ = decoder.raw_decode(prev_line, brace)
+                except json.JSONDecodeError:
+                    entry["_req_body_partial"] = True
+                    req_body = _partial_parse_request_body(prev_line[brace:], line_no_0 - back + 1)
+                entry["_req_body_line"] = line_no_0 - back + 1
+                break
+
+        if req_body and isinstance(req_body, dict):
+            entry["_req_body"] = req_body
+            issues = find_issues(
+                req_body,
+                max_history_messages=max_history_messages,
+                large_payload_bytes=large_payload_bytes,
+                huge_payload_bytes=huge_payload_bytes,
+            )
+            # 基于实际请求体字节数的强信号（日志 JSON 可能被截断/脱敏，不适合用 json_len 判断大小）
+            body_bytes = entry.get("body_bytes")
+            if isinstance(body_bytes, int):
+                if body_bytes > huge_payload_bytes:
+                    issues.append("W_BODY_BYTES_HUGE")
+                elif body_bytes > large_payload_bytes:
+                    issues.append("W_BODY_BYTES_LARGE")
+            entry["issues"] = sorted(set(issues))
+            entry["summary"] = summarize(req_body, entry.get("_req_body_line", 0))
+
+        results.append(entry)
+
+    return results
+
+
+def _scan_local_rejects(log_text: str) -> List[Dict[str, Any]]:
+    """扫描本地请求体超限拒绝日志。"""
+    marker = "请求体超过安全阈值，拒绝发送"
+    results: List[Dict[str, Any]] = []
+    for line_no, raw in enumerate(log_text.splitlines(), 1):
+        if marker not in raw:
+            continue
+        clean = strip_ansi(raw)
+        kv = parse_kv(clean)
+        results.append(
+            {
+                "line_no": line_no,
+                "conversation_id": kv.get("conversation_id"),
+                "request_body_bytes": _safe_int(kv.get("request_body_bytes")),
+                "image_bytes": _safe_int(kv.get("image_bytes")),
+                "effective_bytes": _safe_int(kv.get("effective_bytes")),
+                "threshold": _safe_int(kv.get("threshold")),
+            }
+        )
+    return results
+
+
+def _safe_int(v: Optional[str]) -> Optional[int]:
+    if v is None:
+        return None
+    try:
+        return int(v)
+    except ValueError:
+        return None
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/tools/event-viewer.html b/tools/event-viewer.html
new file mode 100644
index 0000000..98cea73
--- /dev/null
+++ b/tools/event-viewer.html
@@ -0,0 +1,896 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AWS Event Stream Viewer</title>
+    <style>
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+            background: #0d1117;
+            color: #c9d1d9;
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+        h1 {
+            color: #58a6ff;
+            margin-bottom: 20px;
+            font-size: 24px;
+        }
+        .input-section {
+            margin-bottom: 20px;
+        }
+        .input-section label {
+            display: block;
+            margin-bottom: 8px;
+            color: #8b949e;
+            font-size: 14px;
+        }
+        .input-controls {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 10px;
+            flex-wrap: wrap;
+        }
+        .format-select {
+            padding: 8px 16px;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            background: #21262d;
+            color: #c9d1d9;
+            font-size: 14px;
+        }
+        textarea {
+            width: 100%;
+            height: 200px;
+            padding: 12px;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            background: #161b22;
+            color: #c9d1d9;
+            font-family: 'SF Mono', Monaco, 'Courier New', monospace;
+            font-size: 13px;
+            resize: vertical;
+        }
+        textarea:focus {
+            outline: none;
+            border-color: #58a6ff;
+        }
+        .btn {
+            padding: 10px 20px;
+            border: none;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 500;
+            transition: all 0.2s;
+        }
+        .btn-primary {
+            background: #238636;
+            color: white;
+        }
+        .btn-primary:hover {
+            background: #2ea043;
+        }
+        .btn-secondary {
+            background: #21262d;
+            color: #c9d1d9;
+            border: 1px solid #30363d;
+        }
+        .btn-secondary:hover {
+            background: #30363d;
+        }
+        .results {
+            margin-top: 20px;
+        }
+        .stats {
+            display: flex;
+            gap: 20px;
+            margin-bottom: 20px;
+            flex-wrap: wrap;
+        }
+        .stat-card {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            padding: 16px 20px;
+            min-width: 150px;
+        }
+        .stat-card .label {
+            color: #8b949e;
+            font-size: 12px;
+            margin-bottom: 4px;
+        }
+        .stat-card .value {
+            color: #58a6ff;
+            font-size: 24px;
+            font-weight: 600;
+        }
+        .message-list {
+            display: flex;
+            flex-direction: column;
+            gap: 12px;
+        }
+        .message {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        .message-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 12px 16px;
+            background: #21262d;
+            border-bottom: 1px solid #30363d;
+            cursor: pointer;
+        }
+        .message-header:hover {
+            background: #30363d;
+        }
+        .message-info {
+            display: flex;
+            gap: 12px;
+            align-items: center;
+            flex-wrap: wrap;
+        }
+        .message-index {
+            background: #30363d;
+            color: #8b949e;
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+        .message-type {
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+        .message-type.event {
+            background: rgba(56, 139, 253, 0.15);
+            color: #58a6ff;
+        }
+        .message-type.error {
+            background: rgba(248, 81, 73, 0.15);
+            color: #f85149;
+        }
+        .message-type.exception {
+            background: rgba(210, 153, 34, 0.15);
+            color: #d29922;
+        }
+        .event-type {
+            color: #7ee787;
+            font-size: 13px;
+        }
+        .message-size {
+            color: #8b949e;
+            font-size: 12px;
+        }
+        .expand-icon {
+            color: #8b949e;
+            transition: transform 0.2s;
+        }
+        .message.expanded .expand-icon {
+            transform: rotate(90deg);
+        }
+        .message-content {
+            display: none;
+            padding: 16px;
+        }
+        .message.expanded .message-content {
+            display: block;
+        }
+        .section-title {
+            color: #8b949e;
+            font-size: 12px;
+            font-weight: 500;
+            margin-bottom: 8px;
+            text-transform: uppercase;
+        }
+        .headers-table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-bottom: 16px;
+            font-size: 13px;
+        }
+        .headers-table th,
+        .headers-table td {
+            text-align: left;
+            padding: 8px 12px;
+            border-bottom: 1px solid #21262d;
+        }
+        .headers-table th {
+            color: #8b949e;
+            font-weight: 500;
+            background: #0d1117;
+        }
+        .headers-table td {
+            font-family: 'SF Mono', Monaco, 'Courier New', monospace;
+        }
+        .header-name {
+            color: #ff7b72;
+        }
+        .header-type {
+            color: #d2a8ff;
+        }
+        .header-value {
+            color: #a5d6ff;
+        }
+        .payload-container {
+            background: #0d1117;
+            border-radius: 6px;
+            overflow: hidden;
+        }
+        .payload-tabs {
+            display: flex;
+            border-bottom: 1px solid #21262d;
+        }
+        .payload-tab {
+            padding: 8px 16px;
+            background: transparent;
+            border: none;
+            color: #8b949e;
+            cursor: pointer;
+            font-size: 13px;
+            border-bottom: 2px solid transparent;
+            margin-bottom: -1px;
+        }
+        .payload-tab.active {
+            color: #58a6ff;
+            border-bottom-color: #58a6ff;
+        }
+        .payload-content {
+            padding: 12px;
+            font-family: 'SF Mono', Monaco, 'Courier New', monospace;
+            font-size: 13px;
+            overflow-x: auto;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .payload-json {
+            white-space: pre-wrap;
+            word-break: break-word;
+        }
+        .payload-raw {
+            white-space: pre;
+            color: #8b949e;
+        }
+        .payload-hex {
+            white-space: pre;
+            color: #8b949e;
+            font-size: 12px;
+        }
+        .json-key {
+            color: #ff7b72;
+        }
+        .json-string {
+            color: #a5d6ff;
+        }
+        .json-number {
+            color: #79c0ff;
+        }
+        .json-boolean {
+            color: #ff7b72;
+        }
+        .json-null {
+            color: #8b949e;
+        }
+        .error-box {
+            background: rgba(248, 81, 73, 0.1);
+            border: 1px solid rgba(248, 81, 73, 0.4);
+            border-radius: 6px;
+            padding: 12px 16px;
+            color: #f85149;
+            margin-bottom: 16px;
+        }
+        .hex-view {
+            display: grid;
+            grid-template-columns: 80px 1fr 1fr;
+            gap: 8px;
+            font-family: 'SF Mono', Monaco, 'Courier New', monospace;
+            font-size: 12px;
+        }
+        .hex-offset {
+            color: #8b949e;
+        }
+        .hex-bytes {
+            color: #7ee787;
+        }
+        .hex-ascii {
+            color: #d2a8ff;
+        }
+        .raw-section {
+            margin-top: 20px;
+            padding: 16px;
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 8px;
+        }
+        .raw-section h3 {
+            color: #8b949e;
+            font-size: 14px;
+            margin-bottom: 12px;
+        }
+        .copy-btn {
+            padding: 4px 8px;
+            font-size: 12px;
+            margin-left: 8px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>AWS Event Stream Viewer</h1>
+
+        <div class="input-section">
+            <label>粘贴二进制数据（支持 Hex / Base64 格式）</label>
+            <div class="input-controls">
+                <select id="inputFormat" class="format-select">
+                    <option value="auto">自动检测</option>
+                    <option value="hex">Hex</option>
+                    <option value="base64">Base64</option>
+                </select>
+                <button class="btn btn-primary" onclick="parseInput()">解析</button>
+                <button class="btn btn-secondary" onclick="clearAll()">清空</button>
+                <button class="btn btn-secondary" onclick="loadExample()">加载示例</button>
+            </div>
+            <textarea id="inputData" placeholder="粘贴 Hex 数据 (如: 00 00 00 3e 00 00 00 1d...) 或 Base64 编码数据..."></textarea>
+        </div>
+
+        <div id="error" class="error-box" style="display: none;"></div>
+
+        <div class="results" id="results" style="display: none;">
+            <div class="stats" id="stats"></div>
+            <div class="message-list" id="messageList"></div>
+        </div>
+
+        <div class="raw-section" id="rawSection" style="display: none;">
+            <h3>原始字节数据 <button class="btn btn-secondary copy-btn" onclick="copyRawHex()">复制 Hex</button></h3>
+            <div class="payload-hex" id="rawHex"></div>
+        </div>
+    </div>
+
+    <script>
+        // CRC32 (IEEE/ISO-HDLC) 实现
+        const CRC32_TABLE = (() => {
+            const table = new Uint32Array(256);
+            for (let i = 0; i < 256; i++) {
+                let crc = i;
+                for (let j = 0; j < 8; j++) {
+                    crc = (crc & 1) ? (0xEDB88320 ^ (crc >>> 1)) : (crc >>> 1);
+                }
+                table[i] = crc >>> 0;
+            }
+            return table;
+        })();
+
+        function crc32(data) {
+            let crc = 0xFFFFFFFF;
+            for (let i = 0; i < data.length; i++) {
+                crc = CRC32_TABLE[(crc ^ data[i]) & 0xFF] ^ (crc >>> 8);
+            }
+            return (crc ^ 0xFFFFFFFF) >>> 0;
+        }
+
+        // 值类型定义
+        const VALUE_TYPES = {
+            0: { name: 'BoolTrue', size: 0 },
+            1: { name: 'BoolFalse', size: 0 },
+            2: { name: 'Byte', size: 1 },
+            3: { name: 'Short', size: 2 },
+            4: { name: 'Integer', size: 4 },
+            5: { name: 'Long', size: 8 },
+            6: { name: 'ByteArray', size: -1 },
+            7: { name: 'String', size: -1 },
+            8: { name: 'Timestamp', size: 8 },
+            9: { name: 'UUID', size: 16 }
+        };
+
+        // 输入格式检测
+        function detectFormat(input) {
+            const cleaned = input.replace(/[\s\n\r]/g, '');
+
+            // 检测是否是Base64
+            if (/^[A-Za-z0-9+/]+=*$/.test(cleaned) && cleaned.length % 4 === 0) {
+                // 尝试解码验证
+                try {
+                    atob(cleaned);
+                    return 'base64';
+                } catch {}
+            }
+
+            // 检测是否是Hex
+            if (/^[0-9A-Fa-f\s]+$/.test(input)) {
+                return 'hex';
+            }
+
+            return 'unknown';
+        }
+
+        // 解析输入数据为字节数组
+        function parseInputData(input, format) {
+            const cleaned = input.trim();
+
+            if (format === 'auto') {
+                format = detectFormat(cleaned);
+            }
+
+            if (format === 'base64') {
+                try {
+                    const binary = atob(cleaned.replace(/[\s\n\r]/g, ''));
+                    return new Uint8Array([...binary].map(c => c.charCodeAt(0)));
+                } catch (e) {
+                    throw new Error('Base64 解码失败: ' + e.message);
+                }
+            }
+
+            if (format === 'hex') {
+                const hex = cleaned.replace(/[\s\n\r]/g, '').replace(/0x/gi, '');
+                if (hex.length % 2 !== 0) {
+                    throw new Error('Hex 数据长度必须是偶数');
+                }
+                const bytes = new Uint8Array(hex.length / 2);
+                for (let i = 0; i < hex.length; i += 2) {
+                    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+                }
+                return bytes;
+            }
+
+            throw new Error('无法识别输入格式');
+        }
+
+        // 读取大端序整数
+        function readUint32BE(data, offset) {
+            return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+        }
+
+        function readUint16BE(data, offset) {
+            return (data[offset] << 8 | data[offset + 1]) >>> 0;
+        }
+
+        function readInt64BE(data, offset) {
+            // JavaScript BigInt for 64-bit
+            let high = readUint32BE(data, offset);
+            let low = readUint32BE(data, offset + 4);
+            return BigInt(high) << 32n | BigInt(low);
+        }
+
+        // 解析头部
+        function parseHeaders(data, headerLength) {
+            const headers = [];
+            let offset = 0;
+
+            while (offset < headerLength) {
+                // 读取名称长度
+                const nameLength = data[offset];
+                offset++;
+
+                if (nameLength === 0 || offset + nameLength > headerLength) {
+                    break;
+                }
+
+                // 读取名称
+                const name = new TextDecoder().decode(data.slice(offset, offset + nameLength));
+                offset += nameLength;
+
+                if (offset >= headerLength) break;
+
+                // 读取值类型
+                const valueType = data[offset];
+                offset++;
+
+                const typeInfo = VALUE_TYPES[valueType] || { name: 'Unknown', size: 0 };
+                let value;
+                let valueSize = typeInfo.size;
+
+                // 解析值
+                switch (valueType) {
+                    case 0: // BoolTrue
+                        value = true;
+                        break;
+                    case 1: // BoolFalse
+                        value = false;
+                        break;
+                    case 2: // Byte
+                        value = data[offset];
+                        offset++;
+                        break;
+                    case 3: // Short
+                        value = readUint16BE(data, offset);
+                        offset += 2;
+                        break;
+                    case 4: // Integer
+                        value = readUint32BE(data, offset);
+                        offset += 4;
+                        break;
+                    case 5: // Long
+                        value = readInt64BE(data, offset).toString();
+                        offset += 8;
+                        break;
+                    case 6: // ByteArray
+                        valueSize = readUint16BE(data, offset);
+                        offset += 2;
+                        value = Array.from(data.slice(offset, offset + valueSize)).map(b => b.toString(16).padStart(2, '0')).join(' ');
+                        offset += valueSize;
+                        break;
+                    case 7: // String
+                        valueSize = readUint16BE(data, offset);
+                        offset += 2;
+                        value = new TextDecoder().decode(data.slice(offset, offset + valueSize));
+                        offset += valueSize;
+                        break;
+                    case 8: // Timestamp
+                        value = new Date(Number(readInt64BE(data, offset))).toISOString();
+                        offset += 8;
+                        break;
+                    case 9: // UUID
+                        const uuidBytes = data.slice(offset, offset + 16);
+                        value = Array.from(uuidBytes).map(b => b.toString(16).padStart(2, '0')).join('');
+                        value = `${value.slice(0,8)}-${value.slice(8,12)}-${value.slice(12,16)}-${value.slice(16,20)}-${value.slice(20)}`;
+                        offset += 16;
+                        break;
+                    default:
+                        value = '(unknown type)';
+                }
+
+                headers.push({ name, type: typeInfo.name, typeCode: valueType, value });
+            }
+
+            return headers;
+        }
+
+        // 解析单个消息帧
+        function parseFrame(data, offset) {
+            if (data.length - offset < 16) {
+                return null;
+            }
+
+            const totalLength = readUint32BE(data, offset);
+            const headerLength = readUint32BE(data, offset + 4);
+            const preludeCrc = readUint32BE(data, offset + 8);
+
+            if (totalLength < 16 || totalLength > 16 * 1024 * 1024) {
+                throw new Error(`消息长度异常: ${totalLength}`);
+            }
+
+            if (data.length - offset < totalLength) {
+                return null;
+            }
+
+            // 验证 Prelude CRC
+            const actualPreludeCrc = crc32(data.slice(offset, offset + 8));
+            const preludeCrcValid = preludeCrc === actualPreludeCrc;
+
+            // 验证 Message CRC
+            const messageCrc = readUint32BE(data, offset + totalLength - 4);
+            const actualMessageCrc = crc32(data.slice(offset, offset + totalLength - 4));
+            const messageCrcValid = messageCrc === actualMessageCrc;
+
+            // 解析头部
+            const headersStart = offset + 12;
+            const headersEnd = headersStart + headerLength;
+            const headers = parseHeaders(data.slice(headersStart, headersEnd), headerLength);
+
+            // 提取 payload
+            const payloadStart = headersEnd;
+            const payloadEnd = offset + totalLength - 4;
+            const payload = data.slice(payloadStart, payloadEnd);
+
+            // 获取消息类型
+            const messageType = headers.find(h => h.name === ':message-type')?.value || 'event';
+            const eventType = headers.find(h => h.name === ':event-type')?.value || '';
+            const contentType = headers.find(h => h.name === ':content-type')?.value || 'application/json';
+
+            return {
+                totalLength,
+                headerLength,
+                preludeCrc: { expected: preludeCrc, actual: actualPreludeCrc, valid: preludeCrcValid },
+                messageCrc: { expected: messageCrc, actual: actualMessageCrc, valid: messageCrcValid },
+                headers,
+                payload,
+                messageType,
+                eventType,
+                contentType,
+                rawBytes: data.slice(offset, offset + totalLength)
+            };
+        }
+
+        // 解析所有消息
+        function parseAllMessages(data) {
+            const messages = [];
+            let offset = 0;
+
+            while (offset < data.length) {
+                try {
+                    const frame = parseFrame(data, offset);
+                    if (!frame) {
+                        break;
+                    }
+                    messages.push(frame);
+                    offset += frame.totalLength;
+                } catch (e) {
+                    console.error('Parse error at offset', offset, e);
+                    // 尝试跳过一个字节继续
+                    offset++;
+                }
+            }
+
+            return messages;
+        }
+
+        // 格式化 JSON 带语法高亮
+        function formatJson(obj, indent = 0) {
+            const spaces = '  '.repeat(indent);
+
+            if (obj === null) {
+                return '<span class="json-null">null</span>';
+            }
+
+            if (typeof obj === 'boolean') {
+                return `<span class="json-boolean">${obj}</span>`;
+            }
+
+            if (typeof obj === 'number') {
+                return `<span class="json-number">${obj}</span>`;
+            }
+
+            if (typeof obj === 'string') {
+                const escaped = obj.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+                return `<span class="json-string">"${escaped}"</span>`;
+            }
+
+            if (Array.isArray(obj)) {
+                if (obj.length === 0) return '[]';
+                const items = obj.map(item => spaces + '  ' + formatJson(item, indent + 1));
+                return '[\n' + items.join(',\n') + '\n' + spaces + ']';
+            }
+
+            if (typeof obj === 'object') {
+                const keys = Object.keys(obj);
+                if (keys.length === 0) return '{}';
+                const items = keys.map(key => {
+                    const escapedKey = key.replace(/"/g, '\\"');
+                    return spaces + '  ' + `<span class="json-key">"${escapedKey}"</span>: ` + formatJson(obj[key], indent + 1);
+                });
+                return '{\n' + items.join(',\n') + '\n' + spaces + '}';
+            }
+
+            return String(obj);
+        }
+
+        // 格式化 Hex 视图
+        function formatHexView(data) {
+            const lines = [];
+            for (let i = 0; i < data.length; i += 16) {
+                const offset = i.toString(16).padStart(8, '0');
+                const bytes = [];
+                const ascii = [];
+
+                for (let j = 0; j < 16; j++) {
+                    if (i + j < data.length) {
+                        bytes.push(data[i + j].toString(16).padStart(2, '0'));
+                        const char = data[i + j];
+                        ascii.push(char >= 32 && char <= 126 ? String.fromCharCode(char) : '.');
+                    } else {
+                        bytes.push('  ');
+                        ascii.push(' ');
+                    }
+                }
+
+                lines.push(`<span class="hex-offset">${offset}</span>  <span class="hex-bytes">${bytes.join(' ')}</span>  <span class="hex-ascii">${ascii.join('')}</span>`);
+            }
+            return lines.join('\n');
+        }
+
+        // 渲染单个消息
+        function renderMessage(message, index) {
+            const messageTypeClass = message.messageType === 'error' ? 'error' :
+                                    message.messageType === 'exception' ? 'exception' : 'event';
+
+            let payloadText = '';
+            let payloadJson = null;
+
+            try {
+                payloadText = new TextDecoder().decode(message.payload);
+                try {
+                    payloadJson = JSON.parse(payloadText);
+                } catch {}
+            } catch {}
+
+            const headersHtml = message.headers.map(h => `
+                <tr>
+                    <td><span class="header-name">${h.name}</span></td>
+                    <td><span class="header-type">${h.type}</span></td>
+                    <td><span class="header-value">${typeof h.value === 'string' ? h.value.replace(/</g, '&lt;').replace(/>/g, '&gt;') : h.value}</span></td>
+                </tr>
+            `).join('');
+
+            const crcStatus = (crc) => crc.valid
+                ? '<span style="color: #7ee787;">&#10003;</span>'
+                : `<span style="color: #f85149;">&#10007; (expected: ${crc.expected.toString(16)}, got: ${crc.actual.toString(16)})</span>`;
+
+            return `
+                <div class="message" id="message-${index}">
+                    <div class="message-header" onclick="toggleMessage(${index})">
+                        <div class="message-info">
+                            <span class="message-index">#${index + 1}</span>
+                            <span class="message-type ${messageTypeClass}">${message.messageType}</span>
+                            ${message.eventType ? `<span class="event-type">${message.eventType}</span>` : ''}
+                        </div>
+                        <div style="display: flex; align-items: center; gap: 12px;">
+                            <span class="message-size">${message.totalLength} bytes</span>
+                            <span class="expand-icon">&#9654;</span>
+                        </div>
+                    </div>
+                    <div class="message-content">
+                        <div class="section-title">CRC 校验</div>
+                        <table class="headers-table" style="margin-bottom: 16px;">
+                            <tr><td>Prelude CRC</td><td>${crcStatus(message.preludeCrc)}</td></tr>
+                            <tr><td>Message CRC</td><td>${crcStatus(message.messageCrc)}</td></tr>
+                        </table>
+
+                        <div class="section-title">Headers (${message.headers.length})</div>
+                        <table class="headers-table">
+                            <thead>
+                                <tr><th>Name</th><th>Type</th><th>Value</th></tr>
+                            </thead>
+                            <tbody>
+                                ${headersHtml}
+                            </tbody>
+                        </table>
+
+                        <div class="section-title">Payload (${message.payload.length} bytes)</div>
+                        <div class="payload-container">
+                            <div class="payload-tabs">
+                                <button class="payload-tab active" onclick="switchPayloadTab(${index}, 'json')">JSON</button>
+                                <button class="payload-tab" onclick="switchPayloadTab(${index}, 'raw')">Raw</button>
+                                <button class="payload-tab" onclick="switchPayloadTab(${index}, 'hex')">Hex</button>
+                            </div>
+                            <div class="payload-content">
+                                <div class="payload-json" id="payload-json-${index}">${payloadJson ? formatJson(payloadJson) : `<span style="color: #8b949e;">${payloadText.replace(/</g, '&lt;').replace(/>/g, '&gt;') || '(empty)'}</span>`}</div>
+                                <div class="payload-raw" id="payload-raw-${index}" style="display: none;">${payloadText.replace(/</g, '&lt;').replace(/>/g, '&gt;') || '(empty)'}</div>
+                                <div class="payload-hex" id="payload-hex-${index}" style="display: none;">${formatHexView(message.payload)}</div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            `;
+        }
+
+        let parsedData = null;
+
+        function parseInput() {
+            const input = document.getElementById('inputData').value;
+            const format = document.getElementById('inputFormat').value;
+            const errorBox = document.getElementById('error');
+            const resultsBox = document.getElementById('results');
+            const rawSection = document.getElementById('rawSection');
+
+            errorBox.style.display = 'none';
+            resultsBox.style.display = 'none';
+            rawSection.style.display = 'none';
+
+            if (!input.trim()) {
+                errorBox.textContent = '请输入数据';
+                errorBox.style.display = 'block';
+                return;
+            }
+
+            try {
+                const data = parseInputData(input, format);
+                parsedData = data;
+
+                // 显示原始 Hex
+                document.getElementById('rawHex').innerHTML = formatHexView(data);
+                rawSection.style.display = 'block';
+
+                const messages = parseAllMessages(data);
+
+                if (messages.length === 0) {
+                    errorBox.textContent = '未能解析出任何消息。请检查输入数据格式。';
+                    errorBox.style.display = 'block';
+                    return;
+                }
+
+                // 统计
+                const eventTypes = {};
+                const messageTypes = {};
+                messages.forEach(m => {
+                    messageTypes[m.messageType] = (messageTypes[m.messageType] || 0) + 1;
+                    if (m.eventType) {
+                        eventTypes[m.eventType] = (eventTypes[m.eventType] || 0) + 1;
+                    }
+                });
+
+                document.getElementById('stats').innerHTML = `
+                    <div class="stat-card">
+                        <div class="label">总消息数</div>
+                        <div class="value">${messages.length}</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="label">总字节数</div>
+                        <div class="value">${data.length}</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="label">消息类型</div>
+                        <div class="value" style="font-size: 14px;">${Object.entries(messageTypes).map(([k, v]) => `${k}: ${v}`).join(', ')}</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="label">事件类型</div>
+                        <div class="value" style="font-size: 14px;">${Object.entries(eventTypes).map(([k, v]) => `${k}: ${v}`).join(', ') || '-'}</div>
+                    </div>
+                `;
+
+                document.getElementById('messageList').innerHTML = messages.map((m, i) => renderMessage(m, i)).join('');
+                resultsBox.style.display = 'block';
+
+            } catch (e) {
+                errorBox.textContent = '解析错误: ' + e.message;
+                errorBox.style.display = 'block';
+            }
+        }
+
+        function toggleMessage(index) {
+            const msg = document.getElementById(`message-${index}`);
+            msg.classList.toggle('expanded');
+        }
+
+        function switchPayloadTab(index, tab) {
+            const tabs = document.querySelectorAll(`#message-${index} .payload-tab`);
+            tabs.forEach(t => t.classList.remove('active'));
+            event.target.classList.add('active');
+
+            document.getElementById(`payload-json-${index}`).style.display = tab === 'json' ? 'block' : 'none';
+            document.getElementById(`payload-raw-${index}`).style.display = tab === 'raw' ? 'block' : 'none';
+            document.getElementById(`payload-hex-${index}`).style.display = tab === 'hex' ? 'block' : 'none';
+        }
+
+        function clearAll() {
+            document.getElementById('inputData').value = '';
+            document.getElementById('error').style.display = 'none';
+            document.getElementById('results').style.display = 'none';
+            document.getElementById('rawSection').style.display = 'none';
+            parsedData = null;
+        }
+
+        function copyRawHex() {
+            if (!parsedData) return;
+            const hex = Array.from(parsedData).map(b => b.toString(16).padStart(2, '0')).join(' ');
+            navigator.clipboard.writeText(hex).then(() => {
+                alert('已复制到剪贴板');
+            });
+        }
+
+        function loadExample() {
+            // 构造一个示例事件流消息
+            // 这是一个简单的 assistantResponseEvent 消息
+            const example = `
+00 00 00 8f 00 00 00 47 7d 83 6e 75 0d 3a 6d 65
+73 73 61 67 65 2d 74 79 70 65 07 00 05 65 76 65
+6e 74 0b 3a 65 76 65 6e 74 2d 74 79 70 65 07 00
+16 61 73 73 69 73 74 61 6e 74 52 65 73 70 6f 6e
+73 65 45 76 65 6e 74 0d 3a 63 6f 6e 74 65 6e 74
+2d 74 79 70 65 07 00 10 61 70 70 6c 69 63 61 74
+69 6f 6e 2f 6a 73 6f 6e 7b 22 63 6f 6e 74 65 6e
+74 22 3a 22 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64
+21 22 2c 22 73 74 6f 70 22 3a 66 61 6c 73 65 7d
+c7 8d c2 bc
+            `.trim();
+            document.getElementById('inputData').value = example;
+            document.getElementById('inputFormat').value = 'hex';
+        }
+    </script>
+</body>
+</html>
diff --git a/tools/test_empty_content.py b/tools/test_empty_content.py
new file mode 100644
index 0000000..5269724
--- /dev/null
+++ b/tools/test_empty_content.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""测试空消息内容和 prefill 处理的改进"""
+
+import json
+import requests
+
+BASE_URL = "http://localhost:8080"
+API_KEY = "test-key"
+
+def safe_print_response(response):
+    """安全打印响应，处理非 JSON 情况"""
+    try:
+        data = response.json()
+        print(f"响应: {json.dumps(data, indent=2, ensure_ascii=False)}")
+        return data
+    except (json.JSONDecodeError, ValueError):
+        print(f"响应 (非 JSON): {response.text}")
+        return None
+
+def test_empty_content():
+    """测试空消息内容应返回 400 错误"""
+    print("测试 1: 空消息内容")
+    response = requests.post(
+        f"{BASE_URL}/v1/messages",
+        headers={
+            "x-api-key": API_KEY,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        },
+        json={
+            "model": "claude-sonnet-4",
+            "max_tokens": 1024,
+            "messages": [
+                {"role": "user", "content": ""}
+            ]
+        }
+    )
+    print(f"状态码: {response.status_code}")
+    data = safe_print_response(response)
+    assert response.status_code == 400, "应返回 400 错误"
+    if data:
+        assert "消息内容为空" in data.get("error", {}).get("message", ""), "错误消息应包含'消息内容为空'"
+    print("✓ 测试通过\n")
+
+def test_empty_text_blocks():
+    """测试仅包含空白文本块的消息"""
+    print("测试 2: 仅包含空白文本块")
+    response = requests.post(
+        f"{BASE_URL}/v1/messages",
+        headers={
+            "x-api-key": API_KEY,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        },
+        json={
+            "model": "claude-sonnet-4",
+            "max_tokens": 1024,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": "   "},
+                        {"type": "text", "text": "\n\t"}
+                    ]
+                }
+            ]
+        }
+    )
+    print(f"状态码: {response.status_code}")
+    data = safe_print_response(response)
+    assert response.status_code == 400, "应返回 400 错误"
+    if data:
+        assert "消息内容为空" in data.get("error", {}).get("message", ""), "错误消息应包含'消息内容为空'"
+    print("✓ 测试通过\n")
+
+def test_prefill_with_empty_user():
+    """测试 prefill 场景下空 user 消息"""
+    print("测试 3: Prefill 场景下空 user 消息")
+    response = requests.post(
+        f"{BASE_URL}/v1/messages",
+        headers={
+            "x-api-key": API_KEY,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        },
+        json={
+            "model": "claude-sonnet-4",
+            "max_tokens": 1024,
+            "messages": [
+                {"role": "user", "content": ""},
+                {"role": "assistant", "content": "Hi there"}
+            ]
+        }
+    )
+    print(f"状态码: {response.status_code}")
+    data = safe_print_response(response)
+    assert response.status_code == 400, "应返回 400 错误"
+    if data:
+        assert "消息内容为空" in data.get("error", {}).get("message", ""), "错误消息应包含'消息内容为空'"
+    print("✓ 测试通过\n")
+
+def test_valid_message():
+    """测试正常消息应该成功"""
+    print("测试 4: 正常消息（对照组）")
+    response = requests.post(
+        f"{BASE_URL}/v1/messages",
+        headers={
+            "x-api-key": API_KEY,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        },
+        json={
+            "model": "claude-sonnet-4",
+            "max_tokens": 50,
+            "messages": [
+                {"role": "user", "content": "Say 'test' only"}
+            ]
+        }
+    )
+    print(f"状态码: {response.status_code}")
+    if response.status_code == 200:
+        print("✓ 测试通过：正常消息处理成功\n")
+    else:
+        safe_print_response(response)
+        print()
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("空消息内容验证测试")
+    print("=" * 60 + "\n")
+
+    try:
+        test_empty_content()
+        test_empty_text_blocks()
+        test_prefill_with_empty_user()
+        test_valid_message()
+        print("=" * 60)
+        print("所有测试通过！")
+        print("=" * 60)
+    except AssertionError as e:
+        print(f"\n✗ 测试失败: {e}")
+    except requests.exceptions.ConnectionError:
+        print("\n✗ 无法连接到服务器，请确保服务正在运行")
+    except Exception as e:
+        print(f"\n✗ 发生错误: {e}")