@wwkit/llmproxy 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wwkit/llmproxy",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "author": "bluesliu <langcai163@163.com>",
   "description": "Generic OpenAI-compatible proxy for multiple LLM providers (codearts, ...). Pluggable via config.json5.",
   "type": "module",
@@ -21,8 +21,8 @@
   "dependencies": {
     "json5": "^2.2.3",
     "undici": "^8.10.1",
-    "@wwkit/cft": "1.0.4",
-    "@wwkit/shared": "1.0.4"
+    "@wwkit/shared": "1.0.5",
+    "@wwkit/cft": "1.0.5"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

package/src/config.json5

@@ -6,6 +6,21 @@
   // 客户端访问本代理时的 API Key
   proxyApiKey: "noapikey",
 
+  // openai-tool-bridge（OpenAI tools → prompt 注入桥）
+  // 端口独立于 llmproxy；进程随 start/stop/restart 一起管理。
+  bridge: {
+    port: 1083,
+    // 上游即本 llmproxy 的 deepseek-web 入口（不带 /v1，joinUpstreamURL 会处理）
+    upstreamBaseUrl: "http://127.0.0.1:1082/deepseek-web/v1",
+    model: "deepseek-chat",
+    authMode: "passthrough",
+    timeoutSeconds: 120,
+    // 二进制路径；未指定时依次尝试 ~/.local/bin/openai-tool-bridge / openai-tool-bridge
+    binary: "",
+    // TOML 配置文件路径；留空则用默认值动态生成
+    configFile: "",
+  },
+
   // 全局重试 + 冷却参数（所有 provider 共享）
   retry: {
     sessionLimitMaxWaitMs: 600000,  // TM.00001041 等并发超限：最多等 10 分钟
@@ -47,5 +62,24 @@
         "deepseek-v4-pro-0813",
       ],
     },
+    "deepseek-web": {
+      auth: {
+        type: "web",          // 浏览器手动登录（手机验证码），CDP 捕获凭证
+      },
+      models: [
+        "deepseek-chat",
+        "deepseek-reasoner",
+      ],
+    },
+    "qianwen-web": {
+      auth: {
+        type: "web",          // 浏览器手动登录（手机验证码），CDP 捕获凭证
+      },
+      models: [
+        "qwen",
+        "qwen3.8-max",
+        "qwen3.7-max",
+      ],
+    },
   },
 }

package/src/core/factory.js

@@ -4,7 +4,7 @@
 // 新增 provider 只需在 providers/<id>/ 下放对应模块文件，factory 自动发现。
 //
 // 模块文件必须 export default class（继承对应抽象基类）。
-// 可选导出常量：SIGN_CONFIG, ERROR_CONFIG, BENEFIT_MODELS（固定实现细节，无需用户配置）。
+// 可选导出常量：SIGN_CONFIG, ERROR_CONFIG（固定实现细节，无需用户配置）。
 
 import path from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
@@ -86,17 +86,3 @@ export async function buildClient(providerId, providerConfig, deps) {
     basePath: signConfig.basePath,
   })
 }
-
-/**
- * 获取 provider 的 benefit 模型列表（从 config.js 模块读取）
- * @param {string} providerId
- * @returns {Promise<string[]>}
- */
-export async function getBenefitModels(providerId) {
-  try {
-    const mod = await loadModule(providerModule(providerId, 'config.js'))
-    return mod.BENEFIT_MODELS || []
-  } catch {
-    return []
-  }
-}

package/src/core/transport.js

@@ -3,40 +3,10 @@
 // 把上游 fetch Response 流到下游 http.ServerResponse。
 // 上游按 fetch Response 形式传入（可以是流式或非流式）。
 // 处理客户端断开：res 'close' → signal abort → 上游 fetch 被 abort。
-// 通用：与具体 provider 无关，codearts / anthropic / openai 共用。
-//
-// 异常 SSE chunk 处理：snap-access 等上游偶尔会在 SSE 流中嵌入非标准错误
-// （如 `{"text":"[DONE]","error_code":"InferHub.ModelArts.81027.400","error_msg":"..."}`），
-// 客户端 AI SDK 无法解析会抛 Zod 校验错。这里检测到异常 chunk 时改写为标准
-// OpenAI 错误响应并提前结束流。
+// 通用：与具体 provider 无关，所有 provider 共用。
 
 import { log, openaiError } from "../util.js";
 
-/**
- * 检测 chunk 是否为 snap-access 异常错误格式
- * @param {string} text
- * @returns {boolean}
- */
-function isAbnormalErrorChunk(text) {
-  // InferHub.ModelArts.<n>.<n> 错误码 或 把 "[DONE]" 嵌入 text 字段
-  return /InferHub\.ModelArts\.\d+\.\d+/.test(text) ||
-         /"text"\s*:\s*"\[DONE\]"/.test(text);
-}
-
-/**
- * 从异常 chunk 中提取 error_code / error_msg
- * @param {string} text
- * @returns {{code: string, message: string}}
- */
-function parseAbnormalError(text) {
-  const codeMatch = text.match(/"error_code"\s*:\s*"([^"]+)"/);
-  const msgMatch = text.match(/"error_msg"\s*:\s*"([^"]+)"/);
-  return {
-    code: codeMatch?.[1] || "upstream_stream_error",
-    message: msgMatch?.[1] || text.slice(0, 200),
-  };
-}
-
 /**
  * 把上游 Response 透传到下游 res（流式 SSE）
  * @param {object} upstream  fetch Response（status, body, headers）
@@ -45,31 +15,17 @@ function parseAbnormalError(text) {
  * @returns {Promise<void>}
  */
 export async function streamSSE(upstream, res, ctx) {
-  const { id, clientGone } = ctx;
+  const { id } = ctx;
   res.writeHead(200, {
     "Content-Type": "text/event-stream; charset=utf-8",
     "Cache-Control": "no-cache",
     Connection: "keep-alive",
   });
   const reader = upstream.body.getReader();
-  let abnormalHandled = false;
   try {
     while (true) {
-      const { done: rdDone, value } = await reader.read();
-      if (rdDone) break;
-      const text = new TextDecoder().decode(value, { stream: true });
-      if (!abnormalHandled && isAbnormalErrorChunk(text)) {
-        const { code, message } = parseAbnormalError(text);
-        log(`[chat#${id}] 上游 SSE 流中检测到异常 chunk (${code})，改写为标准错误响应`);
-        const errBody = JSON.stringify({
-          error: { message, type: "upstream_error", code },
-        });
-        res.write(`data: ${errBody}\n\n`);
-        res.write("data: [DONE]\n\n");
-        abnormalHandled = true;
-        // 提前结束：不再透传后续 chunk
-        break;
-      }
+      const { done, value } = await reader.read();
+      if (done) break;
       res.write(value);
     }
   } catch (e) {
@@ -114,4 +70,4 @@ export function clientGoneSignal(res) {
 export function writeUpstreamError(res, status, text) {
   const code = status === 401 ? 502 : status;
   openaiError(res, `上游错误: ${text.slice(0, 500)}`, code, "upstream_error");
-}
+}

package/src/ctl-impl.js

@@ -1,5 +1,8 @@
 // src/ctl-impl.js — bridge 进程控制共享工具（探活/停止）
-import { execSync } from 'node:child_process'
+import { execSync, spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { fetchWithTimeout } from './util.js'
 
 export function pidsOnPort(port) {
@@ -31,6 +34,7 @@ export async function probeBridge(port, timeoutMs = 1500) {
   }
 }
 
+// ---- llmproxy 停止：只杀 node server.js ----
 export async function stopBridge(port, log = console.log) {
   const pids = pidsOnPort(port)
   if (!pids.length) {
@@ -53,3 +57,120 @@ export async function stopBridge(port, log = console.log) {
   }
   return killed
 }
+
+// ---- openai-tool-bridge 控制 ----
+
+// 定位 bridge 二进制
+export function resolveBridgeBinary(configured = '') {
+  const candidates = [
+    configured.trim(),
+    path.join(process.env.HOME || '', '.local/bin/openai-tool-bridge'),
+    'openai-tool-bridge',
+  ].filter(Boolean)
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c
+  }
+  return candidates[0] // 返回候选，spawn 时依赖 PATH
+}
+
+// 生成 bridge TOML 配置内容
+export function bridgeToml({ port, upstreamBaseUrl, model, authMode, timeoutSeconds, debug = false }) {
+  return `[server]
+listen = ":${port}"
+debug = ${debug}
+
+[upstream]
+base_url = "${upstreamBaseUrl}"
+model = "${model}"
+api_key = ""
+auth_mode = "${authMode}"
+timeout_seconds = ${timeoutSeconds}
+`
+}
+
+export const BRIDGE_CONFIG_FILE = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..', 'openai-tool-bridge.toml',
+)
+
+// 确保 bridge 配置就绪（不存在则写入），返回配置文件路径
+export function ensureBridgeConfig({ port, upstreamBaseUrl, model, authMode, timeoutSeconds }) {
+  if (fs.existsSync(BRIDGE_CONFIG_FILE)) {
+    // 若内容不一致则覆写，保证配置与 config.json5 同步
+    try {
+      const cur = fs.readFileSync(BRIDGE_CONFIG_FILE, 'utf8')
+      const want = bridgeToml({ port, upstreamBaseUrl, model, authMode, timeoutSeconds })
+      if (cur !== want) fs.writeFileSync(BRIDGE_CONFIG_FILE, want)
+    } catch {}
+  } else {
+    fs.writeFileSync(BRIDGE_CONFIG_FILE, bridgeToml({ port, upstreamBaseUrl, model, authMode, timeoutSeconds }))
+  }
+  return BRIDGE_CONFIG_FILE
+}
+
+// 探活 bridge（/healthz）
+export async function probeBridgeHealth(port, timeoutMs = 1500) {
+  if (!pidsOnPort(port).length) return null
+  try {
+    const res = await fetchWithTimeout(`http://127.0.0.1:${port}/healthz`, {}, timeoutMs)
+    if (!res.ok) return false
+    const body = await res.json().catch(() => null)
+    return Boolean(body && body.ok === true)
+  } catch {
+    return false
+  }
+}
+
+// 启动 bridge 为后台进程；返回是否成功
+export async function spawnBridge(config, log = console.log) {
+  const cfg = config?.bridge || {}
+  const port = cfg.port || 1083
+  const bin = resolveBridgeBinary(cfg.binary)
+  const configFile = ensureBridgeConfig({
+    port,
+    upstreamBaseUrl: cfg.upstreamBaseUrl || `http://127.0.0.1:${config?.port || 1082}/deepseek-web/v1`,
+    model: cfg.model || 'deepseek-chat',
+    authMode: cfg.authMode || 'passthrough',
+    timeoutSeconds: cfg.timeoutSeconds || 120,
+  })
+
+  if (!fs.existsSync(bin)) {
+    throw new Error(
+      `未找到 openai-tool-bridge 二进制（${bin}）\n请先安装: go install github.com/lfhy/openai-tool-bridge@latest 或下载 release 到 ~/.local/bin/`,
+    )
+  }
+
+  const out = fs.openSync('/tmp/openai-tool-bridge.log', 'a')
+  const child = spawn(bin, ['-c', configFile], {
+    stdio: ['ignore', out, out],
+    detached: true,
+  })
+  child.unref()
+
+  for (let i = 0; i < 30; i++) {
+    await new Promise(r => setTimeout(r, 200))
+    const ok = await probeBridgeHealth(port).catch(() => null)
+    if (ok === true) {
+      log(`openai-tool-bridge 已启动: http://127.0.0.1:${port}（日志: /tmp/openai-tool-bridge.log）`)
+      return true
+    }
+  }
+  throw new Error(`openai-tool-bridge 启动超时（端口 ${port}），日志: /tmp/openai-tool-bridge.log`)
+}
+
+// 停止 bridge（按进程命令匹配，不误杀 llmproxy）
+export async function stopBridgeProcess(log = console.log) {
+  const all = pidsOnPort(1083) // bridge 默认端口；更精确用命令名匹配
+  const targets = all.filter(pid => /openai-tool-bridge/.test(cmdOf(pid)))
+  if (!targets.length) {
+    log('openai-tool-bridge 未运行')
+    return false
+  }
+  for (const pid of targets) {
+    try { process.kill(pid, 'SIGTERM'); log(`已停止 openai-tool-bridge (pid=${pid})`) } catch {}
+  }
+  for (let i = 0; i < 20 && pidsOnPort(1083).length; i++) {
+    await new Promise(r => setTimeout(r, 250))
+  }
+  return true
+}

package/src/ctl.js

@@ -5,7 +5,14 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { getXdgConfigDir } from '@wwkit/shared'
 import { config, getProviderIds, getProviderConfig } from './config.js'
-import { stopBridge, probeBridge, pidsOnPort } from './ctl-impl.js'
+import {
+  stopBridge,
+  probeBridge,
+  pidsOnPort,
+  spawnBridge,
+  stopBridgeProcess,
+  probeBridgeHealth,
+} from './ctl-impl.js'
 import { sleep } from './util.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
@@ -34,6 +41,13 @@ export async function status() {
     const pidStr = pids.length ? ` (pid=${pids.join(',')})` : ''
     console.log(`已运行: http://127.0.0.1:${config.port}${pidStr}`)
     console.log('')
+    // openai-tool-bridge 状态
+    const bPort = config.bridge?.port || 1083
+    const b = await probeBridgeHealth(bPort).catch(() => null)
+    console.log(b === true
+      ? `tool-bridge 已运行: http://127.0.0.1:${bPort}`
+      : `tool-bridge 未运行（端口 ${bPort}）: llmproxy start 将一并启动`)
+    console.log('')
     console.log('Providers:')
     for (const id of getProviderIds()) {
       const status = getProviderStatus(id)
@@ -56,6 +70,7 @@ export async function status() {
 // ---- stop ----
 export async function stop() {
   await stopBridge(config.port)
+  await stopBridgeProcess()
 }
 
 // ---- start ----
@@ -72,14 +87,29 @@ export async function start() {
     process.exit(1)
   }
 
-  await spawnServer()
+  await spawnServer({}, async () => {
+    const bPort = config.bridge?.port || 1083
+    try {
+      const bRunning = await probeBridgeHealth(bPort).catch(() => null)
+      if (bRunning !== true) await spawnBridge(config)
+    } catch (e) {
+      console.error(`openai-tool-bridge 启动失败: ${e.message}`)
+    }
+  })
 }
 
 // ---- restart ----
 export async function restart() {
   const killed = await stopBridge(config.port)
   if (!killed) console.log('无旧实例，直接启动')
-  await spawnServer()
+  await stopBridgeProcess()
+  await spawnServer({}, async () => {
+    try {
+      await spawnBridge(config)
+    } catch (e) {
+      console.error(`openai-tool-bridge 启动失败: ${e.message}`)
+    }
+  })
 }
 
 // ---- login ----
@@ -195,7 +225,7 @@ export async function clearProvider(providerId) {
 
 // ---- 内部函数 ----
 
-async function spawnServer(env = {}) {
+async function spawnServer(env = {}, onReady = null) {
   try { truncateSync(LOG_FILE, 0) } catch {}
   const out = openSync(LOG_FILE, 'a')
   const child = spawn(process.execPath, [path.join(__dirname, 'server.js')], {
@@ -211,6 +241,7 @@ async function spawnServer(env = {}) {
       const res = await fetch(`http://127.0.0.1:${config.port}/health`)
       if (res.ok) {
         console.log(`llmproxy 已启动: http://127.0.0.1:${config.port}（日志: ${LOG_FILE}）`)
+        if (onReady) await onReady()
         process.exit(0)
       }
     } catch {}

package/src/providers/codearts/auth.js

@@ -16,23 +16,11 @@ import fs from "node:fs"
 import path from "node:path"
 import process from "node:process"
 import { getXdgConfigDir } from "@wwkit/shared"
-import { status as cftStatus } from "@wwkit/cft"
 import { AuthProvider } from "../../core/auth.js"
 import { log } from "../../util.js"
 
 const CREDS_FILE = path.join(getXdgConfigDir("llmproxy"), ".creds.json")
 
-// 获取 Chrome 路径（优先用 @wwkit/cft 安装的 Chrome for Testing）
-function getChromePath() {
-  try {
-    const info = cftStatus()
-    if (info?.chrome_path && fs.existsSync(info.chrome_path)) {
-      return info.chrome_path
-    }
-  } catch {}
-  return null
-}
-
 const STS_HOST = "https://sts.cn-north-4.myhuaweicloud.com";
 const TOKEN_API = "/v1/oauth2/tokens";
 const PORTAL_HOST = "https://codearts.huaweicloud.com/portal";
@@ -88,15 +76,9 @@ export default class CodeartsAuth extends AuthProvider {
 
     if (opts.manual !== false) {
       const { execSync } = await import("node:child_process");
-      const chromePath = getChromePath();
-      if (chromePath) {
-        try { execSync(`"${chromePath}" "${loginUrl}"`); } catch {}
-        log(`[auth:${this.id}] 已打开 Chrome，请手动完成登录...`);
-} else {
-        const openCmd = process.platform === 'darwin' ? 'open' : 'xdg-open'
-        try { execSync(`${openCmd} "${loginUrl}"`) } catch {}
-        log(`[auth:${this.id}] 已打开浏览器，请手动完成登录...`)
-      }
+      const openCmd = process.platform === 'darwin' ? 'open' : 'xdg-open'
+      try { execSync(`${openCmd} "${loginUrl}"`) } catch {}
+      log(`[auth:${this.id}] 已打开系统浏览器，请手动完成登录...`);
     } else {
       throw new Error(`auth:${this.id} 当前仅支持手动登录`);
     }

package/src/providers/codearts/client.js

@@ -3,8 +3,13 @@
 // 封装：auth 拿凭证 + sign 签名 + fetch 发请求
 // 上游 host / path 从 sign config 读
 // undici Agent 关闭 keep-alive 避免上游会话池占用
+//
+// benefit 模型：请求自动附加 maas_type: benefit 头（消耗每日免费额度）
+// SSE 异常检测：snap-access 偶尔在 SSE 流中嵌入非标准错误，需改写为标准 OpenAI 错误
 
 import { Agent, fetch } from "undici";
+import { log } from "../../util.js";
+import { BENEFIT_MODELS } from "./config.js";
 
 const upstreamAgent = new Agent({
   connections: 1,
@@ -13,6 +18,24 @@ const upstreamAgent = new Agent({
   pipelining: 0,
 });
 
+function isBenefitModel(modelId) {
+  return BENEFIT_MODELS.map(m => m.toLowerCase()).includes(String(modelId).toLowerCase())
+}
+
+function isAbnormalErrorChunk(text) {
+  return /InferHub\.ModelArts\.\d+\.\d+/.test(text) ||
+         /"text"\s*:\s*"\[DONE\]"/.test(text);
+}
+
+function parseAbnormalError(text) {
+  const codeMatch = text.match(/"error_code"\s*:\s*"([^"]+)"/);
+  const msgMatch = text.match(/"error_msg"\s*:\s*"([^"]+)"/);
+  return {
+    code: codeMatch?.[1] || "upstream_stream_error",
+    message: msgMatch?.[1] || text.slice(0, 200),
+  };
+}
+
 export default class CodeartsClient {
   constructor({ id, signProvider, authProvider, host, basePath }) {
     this.id = id;
@@ -25,7 +48,7 @@ export default class CodeartsClient {
   /**
    * POST /chat/completions
    * @param {object} body     OpenAI 风格请求体
-   * @param {object} [opts]   { headers?, signal? }
+   * @param {object} [opts]   { signal? }
    * @returns {Promise<Response>}
    */
   async chatCompletions(body, opts = {}) {
@@ -37,12 +60,16 @@ export default class CodeartsClient {
     const headers = {
       "Content-Type": "application/json",
       "Host": this.host,
-      ...opts.headers,
     };
     if (cred.securityToken) {
       headers["X-Security-Token"] = cred.securityToken;
     }
 
+    // benefit 模型注入 maas_type 头
+    if (isBenefitModel(body.model)) {
+      headers["maas_type"] = "benefit";
+    }
+
     const signHeaders = this.signProvider.sign({
       method: "POST",
       url,
@@ -53,12 +80,70 @@ export default class CodeartsClient {
     });
     Object.assign(headers, signHeaders);
 
-    return await fetch(url, {
+    const upstream = await fetch(url, {
       method: "POST",
       headers,
       body: bodyStr,
       signal: opts.signal || undefined,
       dispatcher: upstreamAgent,
     });
+
+    // 对流式响应包装异常 chunk 检测
+    if (upstream.ok && upstream.body) {
+      return wrapSSEAbnormalGuard(upstream, this.id);
+    }
+    return upstream;
   }
 }
+
+/**
+ * 包装上游 SSE Response，检测异常 chunk 并改写为标准 OpenAI 错误
+ * snap-access 偶尔在 SSE 流中嵌入 {"error_code":"InferHub.ModelArts.xxx","error_msg":"..."}
+ */
+function wrapSSEAbnormalGuard(upstream, providerId) {
+  const originalBody = upstream.body;
+  const reader = originalBody.getReader();
+  let abnormalHandled = false;
+
+  const stream = new ReadableStream({
+    async pull(controller) {
+      if (abnormalHandled) {
+        controller.close();
+        return;
+      }
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        const text = new TextDecoder().decode(value, { stream: true });
+        if (isAbnormalErrorChunk(text)) {
+          const { code, message } = parseAbnormalError(text);
+          log(`[${providerId}] 上游 SSE 流中检测到异常 chunk (${code})，改写为标准错误响应`);
+          const errBody = JSON.stringify({
+            error: { message, type: "upstream_error", code },
+          });
+          const errChunk = new TextEncoder().encode(`data: ${errBody}\n\ndata: [DONE]\n\n`);
+          controller.enqueue(errChunk);
+          abnormalHandled = true;
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (e) {
+        controller.error(e);
+      }
+    },
+    cancel() {
+      reader.releaseLock();
+      originalBody.cancel().catch(() => {});
+    },
+  });
+
+  return new Response(stream, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers: upstream.headers,
+  });
+}