@yhong91/cpac 0.1.3 → 0.1.4

package/README.md

@@ -101,16 +101,20 @@ cpac claude --model claude-sonnet-4-5
 cpac claude -- -p "检查当前项目"
 ```
 
-`cpac claude` 会为 Claude Code 子进程设置：
+`cpac claude` 会在本地起一个临时 loopback 代理，并为 Claude Code 子进程设置：
 
 ```text
-ANTHROPIC_BASE_URL=<CPA 地址>
+ANTHROPIC_BASE_URL=http://127.0.0.1:<临时端口>
 ANTHROPIC_AUTH_TOKEN=<CPA_API_KEY>
+CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
+CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST=1
 ```
 
 同时清除可能覆盖网关选择的 `ANTHROPIC_API_KEY` 和 Claude Code 云 provider 环境变量。它不会修改 `~/.claude/`，并原样返回 Claude Code 的退出码。
 
-> CPA 服务端必须支持 Claude Code 使用的 Anthropic Messages API（`/v1/messages`）。Claude 路径直接连接远端 CPA；CPAC 不负责协议转换。
+代理开启 Claude Code 的 gateway model discovery：`/model` 选择器会列出 CPA 目录里的全部模型。claude 系模型直接使用原 id；其它模型以 `claude-cpac--<模型名>` 别名出现（例如 `claude-cpac--gpt-5.6-sol`），请求发出时由代理还原为真实模型名。
+
+> CPA 服务端必须支持 Claude Code 使用的 Anthropic Messages API（`/v1/messages`）。
 
 ### Codex
 

package/dist/cpac.js

@@ -507,6 +507,134 @@ export async function createLoopbackProxy(cpaUrl, apiKey, proxyId, port) {
     }
     return { server, port: address.port };
 }
+const CLAUDE_ALIAS_PREFIX = "claude-cpac--";
+function catalogModelRows(document) {
+    if (!objectValue(document))
+        return undefined;
+    const source = Array.isArray(document.models)
+        ? document.models
+        : Array.isArray(document.data)
+            ? document.data
+            : undefined;
+    if (!source)
+        return undefined;
+    return source.filter(objectValue);
+}
+function catalogModelId(model) {
+    if (typeof model.slug === "string" && model.slug.trim())
+        return model.slug.trim();
+    if (typeof model.id === "string" && model.id.trim())
+        return model.id.trim();
+    return undefined;
+}
+async function claudeModelList(cpaUrl, apiKey, response) {
+    let rows;
+    try {
+        const catalog = await fetch(`${apiBase(cpaUrl)}/models?client_version=1`, {
+            headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+            signal: AbortSignal.timeout(20_000),
+        });
+        if (catalog.ok)
+            rows = catalogModelRows(await catalog.json());
+    }
+    catch {
+        rows = undefined;
+    }
+    if (!rows) {
+        response.writeHead(502, { "content-type": "application/json" });
+        response.end(JSON.stringify({ error: "CPA catalog request failed" }));
+        return;
+    }
+    // Claude Code's /model picker only lists ids starting with claude/anthropic;
+    // expose every other catalog model as claude-cpac--<id>.
+    const data = [];
+    for (const model of rows) {
+        const id = catalogModelId(model);
+        if (!id)
+            continue;
+        const alias = id.startsWith("claude") ? id : `${CLAUDE_ALIAS_PREFIX}${id}`;
+        data.push({
+            type: "model",
+            id: alias,
+            display_name: typeof model.display_name === "string" && model.display_name.trim()
+                ? model.display_name
+                : id,
+        });
+    }
+    response.writeHead(200, { "content-type": "application/json" });
+    response.end(JSON.stringify({
+        data,
+        has_more: false,
+        first_id: data.length > 0 ? data[0].id : null,
+        last_id: data.length > 0 ? data[data.length - 1].id : null,
+    }));
+}
+export async function createClaudeProxy(cpaUrl, apiKey) {
+    const server = createServer((request, response) => {
+        const requestUrl = request.url ?? "/";
+        if (request.method === "GET" && requestUrl.startsWith("/v1/models")) {
+            void claudeModelList(cpaUrl, apiKey, response);
+            return;
+        }
+        let target;
+        try {
+            target = upstreamUrl(cpaUrl, requestUrl);
+        }
+        catch {
+            response.writeHead(400).end("invalid request URL");
+            return;
+        }
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.once("error", () => response.destroy());
+        request.once("end", () => {
+            let body = Buffer.concat(chunks);
+            if (body.length > 0) {
+                try {
+                    const parsed = JSON.parse(body.toString("utf8"));
+                    if (objectValue(parsed) &&
+                        typeof parsed.model === "string" &&
+                        parsed.model.startsWith(CLAUDE_ALIAS_PREFIX)) {
+                        parsed.model = parsed.model.slice(CLAUDE_ALIAS_PREFIX.length);
+                        body = Buffer.from(JSON.stringify(parsed));
+                    }
+                }
+                catch {
+                    // not JSON; forward unchanged
+                }
+            }
+            const headers = proxyHeaders(request.headers, apiKey);
+            headers["content-length"] = String(body.length);
+            const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+            const upstream = send(target, { method: request.method, headers }, (upstreamResponse) => {
+                response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders(upstreamResponse.headers));
+                upstreamResponse.pipe(response);
+            });
+            upstream.once("error", () => {
+                if (!response.headersSent) {
+                    response.writeHead(502, { "content-type": "application/json" });
+                }
+                if (!response.writableEnded)
+                    response.end(JSON.stringify({ error: "CPA upstream request failed" }));
+            });
+            upstream.end(body);
+        });
+    });
+    server.on("clientError", (_error, socket) => socket.destroy());
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", rejectListen);
+            resolveListen();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new CPACError("cannot determine Claude proxy port");
+    }
+    return { server, port: address.port };
+}
 async function runProxyChild(port) {
     const cpaUrl = process.env.CPAC_PROXY_UPSTREAM;
     const apiKey = process.env.CPAC_PROXY_API_KEY;
@@ -895,9 +1023,6 @@ export async function status(config) {
         return 2;
     return 0;
 }
-function claudeBaseUrl(cpaUrl) {
-    return cpaUrl.replace(/\/v1$/, "");
-}
 async function promptSecret(name) {
     if (!process.stdin.isTTY || !process.stderr.isTTY) {
         throw new CPACError(`environment variable ${name} is not set; run: export ${name}="..."`);
@@ -965,10 +1090,17 @@ async function guide(config) {
 }
 export async function runClaude(config, args, executable = "claude") {
     const apiKey = await resolveApiKey(config.api_key_env);
+    const proxy = await createClaudeProxy(config.cpa_url, apiKey);
+    const stopProxy = () => {
+        proxy.server.closeAllConnections?.();
+        proxy.server.close();
+    };
     const env = {
         ...process.env,
-        ANTHROPIC_BASE_URL: claudeBaseUrl(config.cpa_url),
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${proxy.port}`,
         ANTHROPIC_AUTH_TOKEN: apiKey,
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
+        CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1",
     };
     delete env.ANTHROPIC_API_KEY;
     delete env.CLAUDE_CODE_USE_ANTHROPIC_AWS;
@@ -978,11 +1110,15 @@ export async function runClaude(config, args, executable = "claude") {
     return await new Promise((resolve, reject) => {
         const child = spawn(executable, args, { env, stdio: "inherit" });
         child.once("error", (error) => {
+            stopProxy();
             reject(new CPACError(error instanceof Error && "code" in error && error.code === "ENOENT"
                 ? `${executable} not found`
                 : `cannot start ${executable}: ${error.message}`));
         });
-        child.once("close", (code) => resolve(code ?? 1));
+        child.once("close", (code) => {
+            stopProxy();
+            resolve(code ?? 1);
+        });
     });
 }
 export async function runProxy(config) {

package/dist/pi-extension.template

@@ -40,20 +40,44 @@ function intField(value) {
 
 export default async function (pi) {
   const apiKey = (process.env.CPA_API_KEY || "").trim();
-  if (!apiKey) return;
+  if (!apiKey) {
+    console.error("[cpac] CPA_API_KEY not set; skipping CPA providers");
+    return;
+  }
   let payload;
   try {
     const res = await fetch(CPA + "/v1/models?client_version=1", {
       headers: { Authorization: "Bearer " + apiKey },
       signal: AbortSignal.timeout(10000),
     });
-    if (!res.ok) return;
+    if (!res.ok) {
+      console.error("[cpac] CPA models request failed: HTTP " + res.status);
+      return;
+    }
     payload = await res.json();
-  } catch { return; }
-  if (!payload || typeof payload !== "object" || !Array.isArray(payload.models)) return;
-  const rows = payload.models.filter(function (m) {
-    return m && typeof m === "object" && typeof m.slug === "string";
-  });
+  } catch (error) {
+    console.error("[cpac] CPA models request failed: " + (error && error.message || error));
+    return;
+  }
+  const source = payload && Array.isArray(payload.models)
+    ? payload.models
+    : payload && Array.isArray(payload.data) ? payload.data : null;
+  if (!source) {
+    console.error("[cpac] CPA models response has no models list");
+    return;
+  }
+  const rows = [];
+  for (const m of source) {
+    if (!m || typeof m !== "object") continue;
+    const slug = typeof m.slug === "string" && m.slug.trim()
+      ? m.slug.trim()
+      : typeof m.id === "string" && m.id.trim() ? m.id.trim() : null;
+    if (slug) rows.push({ slug: slug, display_name: m.display_name, supported_reasoning_levels: m.supported_reasoning_levels, context_window: m.context_window });
+  }
+  if (rows.length === 0) {
+    console.error("[cpac] CPA models response has no usable models");
+    return;
+  }
   const groups = new Map();
   for (const m of rows) {
     const name = groupName(vendorFor(m.slug));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yhong91/cpac",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Connect Codex and Claude Code to a remote CLIProxyAPI gateway",
   "type": "module",
   "bin": {