coding-proxy 0.4.1a1__tar.gz → 0.4.1a3__tar.gz

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/.gitignore

@@ -27,4 +27,4 @@ config.yaml
 .playwright-mcp/
 
 # Log files (dual-write logging)
-coding-proxy.log*
+.logs/

coding_proxy-0.4.1a3/AGENTS.md

@@ -0,0 +1,55 @@
+# AGENTS.md
+
+## Collaboration Protocol (协作协议)
+
+本文件旨在规范 AI Agent（Claude Code、Antigravity 等）在本项目中的代码与文档协作行为。项目定位详见 [README.md](./README.md)。
+
+- **Core Language**: Output MUST be in **Chinese (Simplified)** unless serving code/technical constraints.
+- **Tone**: Professional, precise, and evidence-based.
+
+## Engineering Code of Conduct (工程行为准则)
+
+**Core Philosophy**: **Entropy Reduction (熵减)**. 通过上下文锚定、复用驱动与标准化流水线，对抗软件系统的无序熵增。
+
+### 道 (Mindset - 认知心法)
+
+- **Context-Driven (上下文驱动)**: 上下文是第一性要素 (Context Quality First)。任何变更需建立在深度理解之上（CDD），拒绝基于关键字匹配的机械式修改。
+- **Minimal Intervention (最小干预)**: 遵循奥卡姆剃刀与 YAGNI 原则，仅实施必要的变更，推崇演进式设计 (Evolutionary Design) 而非过度设计。
+- **Evidence-Based (循证工程)**: 杜绝主观臆断，核心决策需以**最新**且**权威**的文献（IEEE 格式）为佐证，构建“设计-实现-验证”的完整反馈闭环，确保每一项工程行动都能产生可观测的反馈信号（测试、日志、监控），以验证假设并指导迭代。
+- **Systemic Integrity (系统完整性)**: 具备全局视角与二阶思维 (Second-Order Thinking)，评估变更对上下游依赖及整个生态（Engine, Adapter, Agent, UI）的“涟漪效应”，不只关注变更的直接结果，更要预测“结果的结果”（如引入缓存导致的陈旧数据、重试机制引发的雪崩），优先保障整体稳定性与逻辑自洽。
+- **Knowledge Crystallization (知识结晶)**: 将系统视为有机体，通过将工程错误与 AI 失败案例转化为经验约束 (Negative Prompts) 和持久化知识，驱动系统的自我进化与持续熵减。
+- **Proactive Navigation (主动导航)**: 智能体不应止步于被动响应，需即时转化为“领航者”。在交付任务结果的同时，**必须**基于上下文预判并提出**下一步最佳行动建议 (Next Best Action)**，不仅交付“答案”，更要交付“路径”，消除用户决策的认知摩擦。
+
+### 法 (Strategy - 架构原则)
+
+- **Plan-First Default (规划先行)**: 面对任何非琐碎任务（预估步骤 > 3 或涉及架构级决策），**必须**率先进入 Plan 模式。规划产物需明确界定：功能边界、边缘 Case 应对策略、与现有逻辑的交互锚点以及预计改动的爆炸半径。
+- **Subagent Strategy (子代理并发策略)**: 面对高复杂度命题，严禁主 Agent 单点统揽。应贯彻“算力换空间”思路，果断编排 Subagent 进行任务拆解与并行攻坚，主 Agent 的职责需严格收敛于上下文协同与最终成果的组装整合。
+- **Verification Before Done (交付前验证定式)**: 严禁在缺乏确凿运行证据的情况下标记任务为“已完成”。交付阶段**强制要求**提供客观自证材料：Diff 变更分析、测试用例覆盖、实施日志截图及核心链路边缘 Case 验证结果，并时刻以“方案是否能通过 Staff Engineer 严格审查”的视角自检。
+- **Reuse-Driven (复用驱动)**: Compose over Reinvent。系统变更**必须**主动参考业界经典设计模式与最佳实践。在进入实质性编码前，需率先对相关领域的成熟范式进行深度调研，并结合当前项目上下文输出充分的关联分析与方案梳理。坚决贯彻“拿来主义”，优先通过组合与集成来构建系统，防范闭门造车与重复造轮子。
+- **Boundary Management (边界管理)**: 严控模块/Agent 间的职责边界与契约，确保高内聚低耦合，防范隐式依赖穿透。
+- **Orthogonal Decomposition (正交分解)**: 坚持“正交地提取概念主体”。识别系统中独立变化的维度并进行解耦（如机制与策略分离），确保单一概念主体的变更具备局部性，避免逻辑纠缠。
+- **Single Source of Truth (单一事实源)**：严格维护唯一的权威定义源。引用时**必须**使用轻量级指针 (Link/ID) 而非数据副本 (Copy-Paste)，从根源消除断裂 (Split-Brain) 风险。
+
+### 术 (Tactics - 执行规范)
+
+- **Structured AI-Pair Pipeline (规范化 AI 结对流水线)**: 遵循 **Specification-Driven (规约驱动)** + **Context-Anchored (上下文锚定)** + **AI-Pair (AI 结对)** 模式，将开发固化为可审计的流水线，避免代码腐化为无法维护的“大泥球 (Big Ball of Mud)”。
+- **Visual Documentation (图文并茂)**: 对于复杂逻辑，优先使用 Mermaid 图表（Sequence/Flowchart/Class）辅助说明，构建“图文并茂”的直观文档。
+- **Direct Hyperlinking (直接跳转)**: 在文档中提及 Repo 内其他资源（文档/代码）时，**必须**构建可跳转的相对路径链接（如 `[Doc Name](./path.md)`），严禁使用“死文本”引用，以降低信息检索熵。
+- **Operational Excellence (卓越运营)**:
+  1. **Git Discipline**: 默认严禁调用 git commit；当用户显式要求提交时，一律使用 Claude Code 的自定义 Slash Command: `/commit-no-push` 进行操作（若非 Claude Code 运行环境，则读取 /commit-no-push 命令中的规则执行）。严禁执行 Rebase；
+  2. **Temp Management**: 临时产物（执行计划等）一律收敛至 `.temp/` 并及时清理；
+  3. **Link Validity**: 确保所有引用的 URL 可访问且具备明确的上下文价值；
+  4. **Testing**: 统一在 tests/ 下维护测试用例，区分单元测试（unit）和集成测试（integration），所有测试的本地运行总时间控制在 3 min 以内；
+  5. **Pre-commit Hooks**: 首次克隆仓库使用 `uv run pre-commit install` 激活本地 Git hooks，使 Ruff lint（含 auto-fix）、Ruff format 及通用代码卫生检查在每次 commit 前自动运行。若 hooks 自动修复了问题，提交会被中断，执行 `git add -p` 审阅修复内容后重新提交即可；
+  6. **Issue**: 在 docs/issue.md 中维护你处理过的 Issue 摘要（问题描述、表因根因、处理方式、后续防范、同类问题影响与处理注意事项等），便于同类问题的跨上下文处理；注意识别相同 Issue，不要同 Issue 多处维护；
+- **Package Management Standardization (包管理规范)**:
+  1. **Python**: 严禁使用 pip/poetry，**必须**统一使用 `uv` 进行包管理与脚本执行（如 `uv run`）；
+  2. **JavaScript/TypeScript**: 严禁使用 npm/yarn，**必须**统一使用 `pnpm` 进行包管理与脚本执行；
+- **Database Management**: 谨慎操作，数据迁移、测试等操作严禁将现有数据删除，谨慎操作数据迁移的回滚，防止数据被清理。
+- **Browser Validation Protocol (浏览器验证准则)**：Agent 不得自行完成、绕过或模拟任何 OAuth / SSO 认证流程，所有登录态均来源于用户已认证的 Chrome 主 profile（真实用户登录态）。完整协议（连通性自检、凭证管理、E2E 集成、实机回归等）详见 [浏览器验证协议](./docs/agents/browser-validation.md)；
+  1. **安全红线**：禁止在 Sandbox 浏览器中跳转 Google 同意屏；禁止以模拟用户或第三方账号替代真实登录态；禁止要求用户在 chat 中粘贴密码、Cookie 或验证码；
+- **Knowledge Map (知识索引)**：项目所有文档索引统一维护在 [知识索引](./docs/agents/knowledge-map.md)，并在文档目录变更时即时同步跟新；
+- **Documentation Standards (文档规范)**：采用**Mermaid Visualization Norms (Mermaid 可视化规范)**；
+  1. **色彩语义与兼容性**：为图表节点配置具备语义辨识度的色彩，并确保在深色模式（Dark Mode）下具有极高的对比度与清晰度；
+  2. **逻辑模块化解构**：针对业务跨度较大的架构流程，强制采用 `subgraph` 容器进行层级解构与边界划分，以增强图表的自解说（Self-explaining）能力；
+- **Reference Specifications (IEEE)**：为保障工程决策的可追溯性与学术严谨性，核心引用需遵循 [reference-specifications.md](docs/agents/reference-specifications.md)IEEE 标准引用格式；

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-proxy
-Version: 0.4.1a1
+Version: 0.4.1a3
 Summary: A High-Availability, Transparent, and Smart Multi-Vendor Proxy for Claude Code. Support Claude Plans, GitHub Copilot, Google Antigravity, ZAI/GLM, MiniMax, Qwen, Xiaomi, Kimi, Doubao...
 Project-URL: Source Code, https://github.com/ThreeFish-AI/coding-proxy
 Project-URL: User Guide, https://github.com/ThreeFish-AI/coding-proxy/blob/master/docs/user-guide.md

coding_proxy-0.4.1a3/docs/agents/knowledge-map.md

@@ -0,0 +1,3 @@
+# Knowledge Map（知识索引）
+
+(WIP)

coding_proxy-0.4.1a3/docs/agents/reference-specifications.md

@@ -0,0 +1,16 @@
+# Reference Specifications (IEEE)
+
+> **模版准则**：[编号] 作者缩写. 姓, "文章标题," _刊名/会议名缩写 (斜体)_, 卷号, 期数, 页码, 年份.
+
+```latex
+[1] A. Author, B. Author, and C. Author, "Title of paper," *Abbrev. Title of Journal*, vol. X, no. Y, pp. XX–XX, Year.
+```
+
+**引用实践**
+
+- **文内锚定**：采用标准上标链接形式：`描述内容<sup>[[1]](#ref1)</sup>`。
+- **文献索引**：底层采用 HTML 锚点 `id` 实现跳转稳定性。
+
+```latex
+<a id="ref1"></a>[1] A. Vaswani et al., "Attention is all you need," Adv. Neural Inf. Process. Syst., vol. 30, pp. 5998–6008, 2017.
+```

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/docs/guide/monitoring.md

@@ -31,7 +31,7 @@
 ```yaml
 logging:
   level: "DEBUG"    # 查看详细的模型映射和路由决策
-  file: "coding-proxy.log"  # 输出到文件
+  file: ".logs/coding-proxy.log"  # 输出到文件
   max_bytes: 5242880        # 单文件 5 MB，触发轮转
   backup_count: 5           # 保留 5 个 gzip 压缩备份
 ```

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/docs/issue.md

@@ -132,3 +132,57 @@ AttributeError: 'ZhipuVendor' object has no attribute 'name'
 
 - 已 `grep -rn "vendor\.name\b" src/` 全仓扫描，确认 `target_vendor.name | vendor.name` 误用仅 routes.py 的这两处，已随本次修复一并消除。`/v1/messages` 主链路在 executor 中调用 `tier.name`（`Tier` 对象的合法 dataclass 属性），与 vendor 实例 `name` 无关，不受影响。
 - 若未来新增 Vendor 子类，仍只需实现 `get_name()` 抽象方法；外部调用方应遵循同一契约，本档案的修复模式可作为参考。
+
+---
+
+## Gemini embedding 透传至 Vertex AI 上游返回 `request body doesn't contain valid prompts`
+
+**问题描述**
+
+通过本代理调用 Gemini embedding 模型时，上游返回 400：
+
+```
+litellm.BadRequestError: GeminiException BadRequestError -
+{"error":{"message":"request body doesn't contain valid prompts"}}
+POST /api/gemini/v1beta/models/gemini-embedding-001%3AbatchEmbedContents 400
+```
+
+litellm 报错日志中 URL 路径是 `:batchEmbedContents`，调用端疑似格式不兼容。
+
+**表因**
+
+litellm 按 Google AI Studio 格式构造请求：
+- 路径：`POST {api_base}/v1beta/models/{model}:batchEmbedContents`
+- Body：`{"requests": [{"model": "models/...", "content": {"parts": [{"text": "..."}]}}]}`
+
+但实际上游（如 `llms.as-in.io` 这类 Vertex AI 风格网关）只接受 Vertex AI 格式：
+- 路径：`POST {api_base}/v1beta1/publishers/google/models/{model}:embedContent`
+- Body：`{"content": {"parts": [{"text": "..."}]}}`
+
+且无 `batchEmbedContents` 端点。
+
+**根因**
+
+1. 代理 `NativeProxyHandler.dispatch()` 是字节级透传，对 embedding 端点未做协议适配，直接把 Google AI Studio 格式的 URL/Body 转给 Vertex AI 上游，路由不匹配。
+2. litellm `_check_custom_proxy()` 在自定义 `api_base` 场景下会丢失 `v1beta/` 版本前缀，发送 `{api_base}/models/{model}:verb`，使代理原有的 `OperationClassifier` 正则（要求 `v1beta/` 前缀）失配，进而走原始透传分支再次失败。
+
+**处理方式**
+
+1. `src/coding/proxy/native_api/operation.py`：放宽 Gemini 路径正则中的 `v1(?:beta1?)?/` 段为可选，兼容 litellm 丢失版本前缀的异常路径。
+2. `src/coding/proxy/native_api/handler.py`：在 `dispatch()` 中新增 Gemini embedding Vertex AI 适配分支：
+   - 仅当 `provider == "gemini"`、`operation in {"embedding", "embedding.batch"}`、且 `base_url` 非官方 `generativelanguage.googleapis.com` 时启用；
+   - `embedContent` → 重写路径为 `v1beta1/publishers/google/models/{model}:embedContent`，剥离 body 中的 `model` 字段；
+   - `batchEmbedContents` → 拆分为多次并发 `embedContent` 调用（`asyncio.gather`），聚合响应为 `{"embeddings": [...]}` 返回；
+   - 用量抽取累加各子请求的 `usageMetadata`。
+3. `tests/test_native_api_handler.py`：新增 3 个回归测试覆盖单次 / 批量 / 官方上游透传不变三类场景。
+
+**后续防范**
+
+- 协议适配层只对**非官方上游**生效，官方 `generativelanguage.googleapis.com` 仍走字节级透传，避免引入不必要的转换开销与协议偏差。
+- 上游路径分支的判定优先用 base_url 域名而非依赖网关行为特征，便于后续扩展（如 Vertex Express、其他 LLM gateway）时的精确匹配。
+- 真实链路验证：使用 litellm `embedding(api_base=..., api_key=...)` 单输入 / 多输入分别调用，确认返回 3072 维向量及正确批量计数。
+
+**同类问题影响与处理注意事项**
+
+- litellm 在 Gemini 其他端点（`generateContent` / `countTokens`）同样存在 `_check_custom_proxy` 丢失 `v1beta/` 前缀的 bug；本次仅放宽了 `operation.py` 中的路径正则（让分类器能识别此类异常路径），未对这些端点做格式转换，因为非 embedding 端点的 Google AI Studio / Vertex AI 请求体差异较小，多数上游兼容。如未来出现类似失配再做针对性适配。
+- 若上游网关同时支持 OpenAI `/v1/embeddings` 与 Vertex AI 路径，建议优先在客户端配置 OpenAI 兼容路径，减少协议转换链路。

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/docs/user-guide.md

@@ -202,7 +202,7 @@ database:
 
 logging:
   level: "INFO"          # DEBUG / INFO / WARNING / ERROR
-  # file: "coding-proxy.log"  # 输出到文件
+  # file: ".logs/coding-proxy.log"  # 输出到文件
   # max_bytes: 5242880        # 单文件 5 MB
   # backup_count: 5           # 保留 5 个备份
 ```

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "coding-proxy"
-version = "0.4.1a1"
+version = "0.4.1a3"
 description = "A High-Availability, Transparent, and Smart Multi-Vendor Proxy for Claude Code. Support Claude Plans, GitHub Copilot, Google Antigravity, ZAI/GLM, MiniMax, Qwen, Xiaomi, Kimi, Doubao..."
 readme = "README.md"
 requires-python = ">=3.12"

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/src/coding/proxy/cli/__init__.py

@@ -109,7 +109,7 @@ def start(
     print_banner(console, host=cfg.server.host, port=cfg.server.port)
 
     # 解析文件日志路径：未显式配置时使用默认值
-    _file_path: str | None = cfg.logging.file or "coding-proxy.log"
+    _file_path: str | None = cfg.logging.file or ".logs/coding-proxy.log"
     uvicorn.run(
         fastapi_app,
         host=cfg.server.host,

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/src/coding/proxy/config/config.default.yaml

@@ -8,7 +8,7 @@ server:
 
 logging:
   level: "INFO"
-  # file: "coding-proxy.log"          # 文件日志路径；设为 null 或空字符串禁用
+  # file: ".logs/coding-proxy.log"    # 文件日志路径；设为 null 或空字符串禁用
   # max_bytes: 5242880                # 单文件上限（5 MB），触发轮转
   # backup_count: 5                   # 保留 gzip 压缩备份文件数
 

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/src/coding/proxy/config/server.py

@@ -21,7 +21,7 @@ class LoggingConfig(BaseModel):
 
     Attributes:
         level: 控制台日志级别（INFO / WARNING / DEBUG 等）。
-        file: 文件日志路径。为 ``None`` 时使用默认值 ``coding-proxy.log``；
+        file: 文件日志路径。为 ``None`` 时使用默认值 ``.logs/coding-proxy.log``；
              设为空字符串可禁用文件日志。
         max_bytes: 单个日志文件最大字节数（触发轮转）。默认 5 MB。
         backup_count: 保留的已压缩备份文件数。默认 5。

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/src/coding/proxy/native_api/handler.py

@@ -13,8 +13,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
+import re
 import time
 from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING
@@ -194,6 +196,28 @@ class NativeProxyHandler:
         start_ts = time.perf_counter()
         client = self._get_client(provider)
 
+        # ── Gemini embedding Vertex AI 格式转换 ──────────────────
+        # 当上游非官方 Google AI Studio（generativelanguage.googleapis.com）时，
+        # litellm 发送的 Google AI Studio 格式（v1beta/models/{model}:batchEmbedContents）
+        # 需转换为 Vertex AI 格式（v1beta1/publishers/google/models/{model}:embedContent）。
+        vertex_rewrite = (
+            provider == "gemini"
+            and operation in ("embedding", "embedding.batch")
+            and cfg.base_url
+            and "generativelanguage.googleapis.com" not in cfg.base_url
+        )
+        if vertex_rewrite:
+            return await self._dispatch_gemini_vertex_embedding(
+                client=client,
+                operation=operation,
+                endpoint=endpoint,
+                body_bytes=body_bytes,
+                upstream_headers=upstream_headers,
+                query_string=query_string,
+                provider=provider,
+                start_ts=start_ts,
+            )
+
         # 构造上游 URL（保留 query）
         upstream_url = endpoint
         if query_string:
@@ -295,6 +319,313 @@ class NativeProxyHandler:
             media_type=content_type or None,
         )
 
+    # ── Gemini embedding → Vertex AI 格式转换 ──────────────────
+
+    # Google AI Studio 路径正则：[v1beta/]models/{model}:{verb}
+    # 版本段允许缺失以兼容 litellm `_check_custom_proxy` 丢失 v1beta 前缀的 bug。
+    _GEMINI_EMBED_PATH_RE = re.compile(
+        r"^/?(?:v1(?:beta1?)?/)?models/(?P<model>[^/:]+)(?::|%3A)(?P<verb>embedContent|batchEmbedContents)/?$"
+    )
+
+    async def _dispatch_gemini_vertex_embedding(
+        self,
+        *,
+        client: httpx.AsyncClient,
+        operation: str,
+        endpoint: str,
+        body_bytes: bytes,
+        upstream_headers: dict[str, str],
+        query_string: str,
+        provider: str,
+        start_ts: float,
+    ) -> StarletteResponse:
+        """将 Google AI Studio 格式的 embedding 请求转换为 Vertex AI 格式.
+
+        Google AI Studio:
+          POST v1beta/models/{model}:batchEmbedContents
+          Body: {"requests": [{"model": "models/{model}", "content": {...}}]}
+
+        Vertex AI:
+          POST v1beta1/publishers/google/models/{model}:embedContent
+          Body: {"content": {...}}
+        """
+        from fastapi.responses import Response as FastAPIResponse
+
+        match = self._GEMINI_EMBED_PATH_RE.match(endpoint)
+        if not match:
+            return FastAPIResponse(
+                content=json.dumps(
+                    {
+                        "error": {
+                            "message": f"unrecognized gemini embedding path: {endpoint}"
+                        }
+                    }
+                ).encode(),
+                status_code=400,
+                media_type="application/json",
+            )
+
+        model_name = match.group("model")
+        verb = match.group("verb")
+
+        # 解析原始请求体
+        try:
+            body = json.loads(body_bytes) if body_bytes else {}
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            return FastAPIResponse(
+                content=json.dumps(
+                    {"error": {"message": "invalid JSON body for embedding request"}}
+                ).encode(),
+                status_code=400,
+                media_type="application/json",
+            )
+
+        if verb == "batchEmbedContents":
+            return await self._vertex_batch_embed(
+                client=client,
+                model_name=model_name,
+                body=body,
+                upstream_headers=upstream_headers,
+                query_string=query_string,
+                provider=provider,
+                operation=operation,
+                endpoint=endpoint,
+                start_ts=start_ts,
+            )
+
+        # 单次 embedContent：直接转换
+        content = body.get("content", body)
+        return await self._vertex_single_embed(
+            client=client,
+            model_name=model_name,
+            content=content,
+            upstream_headers=upstream_headers,
+            query_string=query_string,
+            provider=provider,
+            operation=operation,
+            endpoint=endpoint,
+            start_ts=start_ts,
+        )
+
+    async def _vertex_single_embed(
+        self,
+        *,
+        client: httpx.AsyncClient,
+        model_name: str,
+        content: dict,
+        upstream_headers: dict[str, str],
+        query_string: str,
+        provider: str,
+        operation: str,
+        endpoint: str,
+        start_ts: float,
+    ) -> StarletteResponse:
+        """发送单次 Vertex AI embedContent 请求."""
+        from fastapi.responses import Response as FastAPIResponse
+
+        vertex_path = f"/v1beta1/publishers/google/models/{model_name}:embedContent"
+        vertex_url = vertex_path
+        if query_string:
+            vertex_url = f"{vertex_path}?{query_string}"
+
+        vertex_body = json.dumps({"content": content}).encode()
+
+        req = client.build_request(
+            method="POST",
+            url=vertex_url,
+            content=vertex_body,
+            headers=upstream_headers,
+        )
+
+        try:
+            upstream_resp = await client.send(req, stream=True)
+        except (
+            httpx.TimeoutException,
+            httpx.ConnectError,
+            httpx.ReadError,
+            httpx.RemoteProtocolError,
+        ) as exc:
+            duration_ms = int((time.perf_counter() - start_ts) * 1000)
+            await self._record_failure(
+                provider=provider,
+                operation=operation,
+                endpoint=endpoint,
+                duration_ms=duration_ms,
+                reason=str(exc),
+            )
+            return FastAPIResponse(
+                content=json.dumps(
+                    {
+                        "error": {
+                            "message": f"upstream unreachable: {exc}",
+                            "type": "api_error",
+                        }
+                    }
+                ).encode(),
+                status_code=502,
+                media_type="application/json",
+            )
+
+        try:
+            raw_body = await upstream_resp.aread()
+        finally:
+            await upstream_resp.aclose()
+
+        duration_ms = int((time.perf_counter() - start_ts) * 1000)
+        status = upstream_resp.status_code
+        content_type = upstream_resp.headers.get("content-type", "").lower()
+        resp_headers = _filter_response_headers(dict(upstream_resp.headers))
+
+        # 用量抽取
+        extraction = ExtractionResult()
+        if "application/json" in content_type and raw_body:
+            try:
+                parsed = json.loads(raw_body.decode("utf-8", errors="replace"))
+                if isinstance(parsed, dict):
+                    extraction = extract_usage(
+                        provider, operation, parsed, status, dict(upstream_resp.headers)
+                    )
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                pass
+
+        vendor_label = _VENDOR_LABEL[provider]
+        await self._record_usage(
+            provider=provider,
+            operation=operation,
+            endpoint=endpoint,
+            duration_ms=duration_ms,
+            status=status,
+            extraction=extraction,
+            evidence_records=_build_nonstream_evidence(
+                vendor=vendor_label, extraction=extraction
+            ),
+        )
+
+        return FastAPIResponse(
+            content=raw_body,
+            status_code=status,
+            headers=resp_headers,
+            media_type=content_type or None,
+        )
+
+    async def _vertex_batch_embed(
+        self,
+        *,
+        client: httpx.AsyncClient,
+        model_name: str,
+        body: dict,
+        upstream_headers: dict[str, str],
+        query_string: str,
+        provider: str,
+        operation: str,
+        endpoint: str,
+        start_ts: float,
+    ) -> StarletteResponse:
+        """将 batchEmbedContents 拆分为多次 embedContent 调用并聚合响应."""
+        from fastapi.responses import Response as FastAPIResponse
+
+        requests_list = body.get("requests", [])
+        if not requests_list:
+            return FastAPIResponse(
+                content=json.dumps(
+                    {
+                        "error": {
+                            "message": "batchEmbedContents requires non-empty 'requests' field"
+                        }
+                    }
+                ).encode(),
+                status_code=400,
+                media_type="application/json",
+            )
+
+        vertex_path = f"/v1beta1/publishers/google/models/{model_name}:embedContent"
+        vertex_url = vertex_path
+        if query_string:
+            vertex_url = f"{vertex_path}?{query_string}"
+
+        # 并发发送所有 embedContent 请求
+        async def _single(req_body: dict) -> tuple[dict, int]:
+            content = req_body.get("content", req_body)
+            vertex_body = json.dumps({"content": content}).encode()
+            req = client.build_request(
+                method="POST",
+                url=vertex_url,
+                content=vertex_body,
+                headers=upstream_headers,
+            )
+            try:
+                resp = await client.send(req, stream=False)
+            except (
+                httpx.TimeoutException,
+                httpx.ConnectError,
+                httpx.ReadError,
+                httpx.RemoteProtocolError,
+            ) as exc:
+                return {"error": {"message": f"upstream unreachable: {exc}"}}, 502
+            try:
+                return resp.json(), resp.status_code
+            except Exception:
+                return {"error": {"message": resp.text[:200]}}, resp.status_code
+
+        results = await asyncio.gather(*[_single(r) for r in requests_list])
+
+        # 检查是否有失败的请求
+        embeddings = []
+        for resp_json, resp_status in results:
+            if resp_status != 200:
+                # 返回第一个错误
+                return FastAPIResponse(
+                    content=json.dumps(resp_json).encode(),
+                    status_code=resp_status,
+                    media_type="application/json",
+                )
+            embedding_data = resp_json.get("embedding", {})
+            embeddings.append(embedding_data)
+
+        # 聚合为 batchEmbedContents 响应格式
+        batch_response = {"embeddings": embeddings}
+        duration_ms = int((time.perf_counter() - start_ts) * 1000)
+
+        # 用量抽取
+        extraction = ExtractionResult()
+        for resp_json, _ in results:
+            if isinstance(resp_json, dict):
+                ext = extract_usage(provider, operation, resp_json, 200, {})
+                extraction = ExtractionResult(
+                    input_tokens=extraction.input_tokens + ext.input_tokens,
+                    output_tokens=extraction.output_tokens + ext.output_tokens,
+                    cache_creation_tokens=extraction.cache_creation_tokens
+                    + ext.cache_creation_tokens,
+                    cache_read_tokens=extraction.cache_read_tokens
+                    + ext.cache_read_tokens,
+                    request_id=ext.request_id or extraction.request_id,
+                    model_served=ext.model_served or extraction.model_served,
+                    raw_usage=ext.raw_usage or extraction.raw_usage,
+                    source_field_map=ext.source_field_map
+                    or extraction.source_field_map,
+                    evidence_kind=ext.evidence_kind or extraction.evidence_kind,
+                    extra_usage=ext.extra_usage or extraction.extra_usage,
+                )
+
+        vendor_label = _VENDOR_LABEL[provider]
+        await self._record_usage(
+            provider=provider,
+            operation=operation,
+            endpoint=endpoint,
+            duration_ms=duration_ms,
+            status=200,
+            extraction=extraction,
+            evidence_records=_build_nonstream_evidence(
+                vendor=vendor_label, extraction=extraction
+            ),
+        )
+
+        return FastAPIResponse(
+            content=json.dumps(batch_response).encode(),
+            status_code=200,
+            media_type="application/json",
+        )
+
     # ── SSE 流式转发（同时累加 usage） ─────────────────────────
 
     async def _stream_and_accumulate(

{coding_proxy-0.4.1a1 → coding_proxy-0.4.1a3}/src/coding/proxy/native_api/operation.py

@@ -48,30 +48,34 @@ _OPENAI_RULES: tuple[_Rule, ...] = (
 )
 
 # ── Gemini ────────────────────────────────────────────────────────
-# Gemini 的方法动词作为路径后缀（``:generateContent``），通过正则提取
+# Gemini 的方法动词作为路径后缀（``:generateContent``），通过正则提取。
+# ``v1(?:beta1?)?/`` 前缀允许缺失，以兼容 litellm `_check_custom_proxy` 在
+# 自定义 ``api_base`` 场景下丢失版本段的 bug（参考 litellm issue #17759）。
 _GEMINI_RULES: tuple[_Rule, ...] = (
     _Rule(
-        re.compile(r"^/?v1(?:beta)?/models/[^/]+(?:%3A|:)streamGenerateContent/?$"),
+        re.compile(
+            r"^/?(?:v1(?:beta1?)?/)?models/[^/]+(?:%3A|:)streamGenerateContent/?$"
+        ),
         "generate_content",
     ),
     _Rule(
-        re.compile(r"^/?v1(?:beta)?/models/[^/]+(?:%3A|:)generateContent/?$"),
+        re.compile(r"^/?(?:v1(?:beta1?)?/)?models/[^/]+(?:%3A|:)generateContent/?$"),
         "generate_content",
     ),
     _Rule(
-        re.compile(r"^/?v1(?:beta)?/models/[^/]+(?:%3A|:)countTokens/?$"),
+        re.compile(r"^/?(?:v1(?:beta1?)?/)?models/[^/]+(?:%3A|:)countTokens/?$"),
         "count_tokens",
     ),
     _Rule(
-        re.compile(r"^/?v1(?:beta)?/models/[^/]+(?:%3A|:)embedContent/?$"),
+        re.compile(r"^/?(?:v1(?:beta1?)?/)?models/[^/]+(?:%3A|:)embedContent/?$"),
         "embedding",
     ),
     _Rule(
-        re.compile(r"^/?v1(?:beta)?/models/[^/]+(?:%3A|:)batchEmbedContents/?$"),
+        re.compile(r"^/?(?:v1(?:beta1?)?/)?models/[^/]+(?:%3A|:)batchEmbedContents/?$"),
         "embedding.batch",
     ),
     _Rule(
-        re.compile(r"^/?v1(?:beta)?/models/[^/]+(?:%3A|:)predict/?$"),
+        re.compile(r"^/?(?:v1(?:beta1?)?/)?models/[^/]+(?:%3A|:)predict/?$"),
         "predict",
     ),
     _Rule(