@simonyea/holysheep-cli 1.6.14 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "1.6.14",
+  "version": "1.7.0",
   "description": "Claude Code/Cursor/Cline API relay for China — ¥1=$1, WeChat/Alipay payment, no credit card, no VPN. One command setup for all AI coding tools.",
   "keywords": [
     "openai-china",
@@ -42,7 +42,7 @@
   "homepage": "https://holysheep.ai",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/holysheep123/holysheep-cli.git"
+    "url": "git+https://gitee.com/holysheep123/holysheep-cli.git"
   },
   "license": "MIT",
   "bin": {

package/src/commands/doctor.js

@@ -58,6 +58,9 @@ async function doctor() {
     if (tool.id === 'openclaw' && installed) {
       printOpenClawDetails(tool, installState, nodeMajor)
     }
+    if (tool.id === 'claude-code' && installed && configured) {
+      printClaudeBridgeDetails(tool)
+    }
   }
 
   console.log()
@@ -156,6 +159,36 @@ function printOpenClawDetails(tool, installState, nodeMajor) {
   })
 }
 
+function printClaudeBridgeDetails(tool) {
+  const port = typeof tool.getBridgePort === 'function' ? tool.getBridgePort() : null
+  if (!port) return
+  const bridgeConfig = typeof tool.getBridgeConfig === 'function' ? tool.getBridgeConfig() : {}
+
+  let healthy = false
+  try {
+    execSync(
+      process.platform === 'win32'
+        ? `powershell -NonInteractive -Command "try{(Invoke-WebRequest -Uri http://127.0.0.1:${port}/health -TimeoutSec 1 -UseBasicParsing).StatusCode}catch{exit 1}"`
+        : `curl -sf http://127.0.0.1:${port}/health -o /dev/null --max-time 1`,
+      { stdio: 'ignore', timeout: 3000 }
+    )
+    healthy = true
+  } catch {}
+
+  const icon = healthy ? chalk.green('↳') : chalk.yellow('↳')
+  const text = healthy
+    ? chalk.green(`Claude Bridge 已运行：127.0.0.1:${port}`)
+    : chalk.yellow(`Claude Bridge 未运行：127.0.0.1:${port}（可运行 hs claude-bridge）`)
+  console.log(`    ${icon} ${text}`)
+
+  const relayUrl = bridgeConfig.relayUrl || bridgeConfig.controlPlaneUrl || ''
+  if (relayUrl) {
+    console.log(`    ${chalk.gray('↳')} ${chalk.gray(`Claude Relay: ${relayUrl}`)}`)
+  } else {
+    console.log(`    ${chalk.gray('↳')} ${chalk.gray('Claude Relay: 未配置，当前仍直连 Anthropic 兼容入口')}`)
+  }
+}
+
 function maskKey(key) {
   if (!key || key.length < 8) return '****'
   return key.slice(0, 6) + '...' + key.slice(-4)

package/src/index.js

@@ -167,6 +167,20 @@ program
     })
   })
 
+// ── claude-bridge ────────────────────────────────────────────────────────────
+program
+  .command('claude-bridge')
+  .description('启动 HolySheep 的 Claude Code 本地桥接服务')
+  .option('--port <port>', '指定桥接服务端口')
+  .option('--host <host>', '指定桥接服务监听地址')
+  .action((opts) => {
+    const { startBridge } = require('./tools/claude-bridge')
+    startBridge({
+      port: opts.port ? Number(opts.port) : null,
+      host: opts.host || '127.0.0.1',
+    })
+  })
+
 // 默认：无命令时显示帮助 + 提示 setup
 program
   .action(() => {

package/src/tools/claude-bridge.js

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('fs')
+const http = require('http')
+const path = require('path')
+const os = require('os')
+const crypto = require('crypto')
+const { spawn, execSync } = require('child_process')
+const fetch = global.fetch || require('node-fetch')
+
+const HOLYSHEEP_DIR = path.join(os.homedir(), '.holysheep')
+const CLAUDE_BRIDGE_CONFIG_FILE = path.join(HOLYSHEEP_DIR, 'claude-bridge.json')
+const DEFAULT_BRIDGE_PORT = 14555
+const isWin = process.platform === 'win32'
+const leaseCache = new Map()
+
+function ensureDir() {
+  if (!fs.existsSync(HOLYSHEEP_DIR)) fs.mkdirSync(HOLYSHEEP_DIR, { recursive: true })
+}
+
+function parseArgs(argv) {
+  const args = { port: null, host: '127.0.0.1', config: CLAUDE_BRIDGE_CONFIG_FILE }
+  for (let i = 0; i < argv.length; i++) {
+    const value = argv[i]
+    if (value === '--port') args.port = Number(argv[++i])
+    else if (value === '--host') args.host = argv[++i]
+    else if (value === '--config') args.config = argv[++i]
+  }
+  return args
+}
+
+function readBridgeConfig(configPath = CLAUDE_BRIDGE_CONFIG_FILE) {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeBridgeConfig(data, configPath = CLAUDE_BRIDGE_CONFIG_FILE) {
+  ensureDir()
+  fs.writeFileSync(configPath, JSON.stringify(data, null, 2), 'utf8')
+}
+
+function getConfiguredBridgePort(config = readBridgeConfig()) {
+  const port = Number(config.port)
+  return Number.isInteger(port) && port > 0 ? port : DEFAULT_BRIDGE_PORT
+}
+
+function getBridgeBaseUrl(port = getConfiguredBridgePort()) {
+  return `http://127.0.0.1:${port}`
+}
+
+function sendJson(res, statusCode, payload) {
+  res.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  res.end(JSON.stringify(payload))
+}
+
+function readRawBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let size = 0
+    req.on('data', (chunk) => {
+      size += chunk.length
+      if (size > 20 * 1024 * 1024) {
+        reject(new Error('Request body too large'))
+        req.destroy()
+        return
+      }
+      chunks.push(chunk)
+    })
+    req.on('end', () => resolve(Buffer.concat(chunks)))
+    req.on('error', reject)
+  })
+}
+
+function stripBearer(value) {
+  const raw = String(value || '').trim()
+  if (!raw) return ''
+  if (/^Bearer\s+/i.test(raw)) return raw.replace(/^Bearer\s+/i, '').trim()
+  return raw
+}
+
+function buildBodyHash(body) {
+  return crypto.createHash('sha256').update(body || Buffer.alloc(0)).digest('hex')
+}
+
+function buildBridgeSignature(req, config, body, timestamp) {
+  const secret = String(config.bridgeSecret || '').trim()
+  if (!secret) return ''
+
+  const url = new URL(req.url, `http://${req.headers.host || '127.0.0.1'}`)
+  const canonical = [
+    String(req.method || 'GET').toUpperCase(),
+    url.pathname + (url.search || ''),
+    String(timestamp),
+    buildBodyHash(body),
+    String(config.bridgeId || '')
+  ].join('\n')
+
+  return crypto.createHmac('sha256', secret).update(canonical).digest('hex')
+}
+
+function getBridgeUpstream(config) {
+  return String(config.relayUrl || config.controlPlaneUrl || config.baseUrlAnthropic || '').replace(/\/+$/, '')
+}
+
+function parseJsonBody(body) {
+  if (!body || !body.length) return null
+  try {
+    return JSON.parse(body.toString('utf8'))
+  } catch {
+    return null
+  }
+}
+
+function extractSessionId(parsedBody, config) {
+  const headerSessionId =
+    parsedBody?.metadata?.session_id ||
+    parsedBody?.session_id ||
+    parsedBody?.metadata?.conversation_id ||
+    null
+  if (headerSessionId) return String(headerSessionId)
+
+  const metadataUserId = parsedBody?.metadata?.user_id
+  if (typeof metadataUserId === 'string' && metadataUserId.trim()) {
+    return metadataUserId.trim()
+  }
+
+  return `${config.bridgeId || 'local-bridge'}:default`
+}
+
+function isRelayMode(config) {
+  const upstream = getBridgeUpstream(config)
+  return /\/claude-relay(?:\/|$)/.test(upstream)
+}
+
+async function requestSessionLease(config, sessionId, parsedBody) {
+  const controlPlaneUrl = getBridgeUpstream(config)
+  const cached = leaseCache.get(sessionId)
+  if (cached && cached.expiresAt && new Date(cached.expiresAt).getTime() - Date.now() > 30_000) {
+    return cached
+  }
+
+  const response = await fetch(`${controlPlaneUrl}/session/open`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      sessionId,
+      bridgeId: config.bridgeId || 'local-bridge',
+      deviceId: config.deviceId || '',
+      model: parsedBody?.model || null,
+      installSource: config.installSource || 'holysheep-cli',
+    }),
+  })
+
+  const payload = await response.json().catch(() => null)
+  if (!response.ok || !payload?.success || !payload?.data?.nodeBaseUrl || !payload?.data?.ticket) {
+    const message =
+      payload?.error?.message ||
+      payload?.message ||
+      `Failed to open Claude relay session (HTTP ${response.status})`
+    throw new Error(message)
+  }
+
+  leaseCache.set(sessionId, payload.data)
+  return payload.data
+}
+
+function buildUpstreamHeaders(req, config, body) {
+  const headers = {}
+  for (const [key, value] of Object.entries(req.headers || {})) {
+    const normalized = key.toLowerCase()
+    if (normalized === 'host') continue
+    if (normalized === 'content-length') continue
+    headers[normalized] = value
+  }
+
+  const token = stripBearer(headers.authorization) || headers['x-api-key'] || config.apiKey || ''
+  delete headers.authorization
+  if (token) headers['x-api-key'] = token
+  if (!headers['anthropic-version']) headers['anthropic-version'] = '2023-06-01'
+  headers['user-agent'] = 'holysheep-claude-bridge/1.0'
+  headers['x-hs-bridge-id'] = config.bridgeId || 'local-bridge'
+  headers['x-hs-install-source'] = config.installSource || 'holysheep-cli'
+  if (config.deviceId) headers['x-hs-device-id'] = config.deviceId
+  if (config.userToken) headers['x-hs-user-token'] = config.userToken
+  if (config.nodeId) headers['x-hs-node-id'] = config.nodeId
+  if (config.sessionMode) headers['x-hs-session-mode'] = config.sessionMode
+  const timestamp = Math.floor(Date.now() / 1000)
+  headers['x-hs-bridge-timestamp'] = String(timestamp)
+  const signature = buildBridgeSignature(req, config, body, timestamp)
+  if (signature) headers['x-hs-bridge-signature'] = signature
+  if (body && body.length > 0) headers['content-length'] = String(body.length)
+
+  return headers
+}
+
+function createBridgeServer(configPath = CLAUDE_BRIDGE_CONFIG_FILE) {
+  return http.createServer(async (req, res) => {
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, {
+        'access-control-allow-origin': '*',
+        'access-control-allow-methods': 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+        'access-control-allow-headers': 'content-type,authorization,x-api-key,anthropic-version',
+      })
+      return res.end()
+    }
+
+    try {
+      const config = readBridgeConfig(configPath)
+      const url = new URL(req.url, `http://${req.headers.host || '127.0.0.1'}`)
+      const port = getConfiguredBridgePort(config)
+
+      if (req.method === 'GET' && url.pathname === '/health') {
+        return sendJson(res, 200, {
+          ok: true,
+          port,
+          upstream: getBridgeUpstream(config),
+          relayUrl: config.relayUrl || '',
+          mode: config.relayUrl ? 'relay' : 'direct',
+          bridgeId: config.bridgeId || null,
+          nodeId: config.nodeId || null,
+          installSource: config.installSource || 'holysheep-cli',
+        })
+      }
+
+      let upstreamBase = getBridgeUpstream(config)
+      if (!upstreamBase) {
+        return sendJson(res, 500, { error: { message: 'Bridge upstream is not configured' } })
+      }
+
+      const body = await readRawBody(req)
+      const parsedBody = parseJsonBody(body)
+      if (isRelayMode(config) && req.method !== 'GET' && url.pathname !== '/health') {
+        const sessionId = extractSessionId(parsedBody, config)
+        const lease = await requestSessionLease(config, sessionId, parsedBody)
+        upstreamBase = String(lease.nodeBaseUrl || '').replace(/\/+$/, '')
+        req.headers['x-hs-session-id'] = sessionId
+        req.headers['x-hs-bridge-ticket'] = lease.ticket
+        req.headers['x-hs-node-id'] = lease.nodeId || ''
+      }
+      const upstreamUrl = `${upstreamBase}${url.pathname}${url.search || ''}`
+      const upstream = await fetch(upstreamUrl, {
+        method: req.method,
+        headers: buildUpstreamHeaders(req, config, body),
+        body: body.length > 0 ? body : undefined,
+      })
+
+      res.writeHead(upstream.status, {
+        'content-type': upstream.headers.get('content-type') || 'application/json; charset=utf-8',
+        'cache-control': upstream.headers.get('cache-control') || 'no-store',
+      })
+
+      if (upstream.body && typeof upstream.body.pipe === 'function') {
+        upstream.body.pipe(res)
+        return
+      }
+
+      const text = await upstream.text()
+      res.end(text)
+    } catch (error) {
+      return sendJson(res, 500, { error: { message: error.message || 'Claude bridge error' } })
+    }
+  })
+}
+
+function waitForBridge(port) {
+  for (let i = 0; i < 12; i++) {
+    const t0 = Date.now()
+    while (Date.now() - t0 < 500) {}
+
+    try {
+      execSync(
+        isWin
+          ? `powershell -NonInteractive -Command "try{(Invoke-WebRequest -Uri http://127.0.0.1:${port}/health -TimeoutSec 1 -UseBasicParsing).StatusCode}catch{exit 1}"`
+          : `curl -sf http://127.0.0.1:${port}/health -o /dev/null --max-time 1`,
+        { stdio: 'ignore', timeout: 3000 }
+      )
+      return true
+    } catch {}
+  }
+
+  return false
+}
+
+function startBridge(args = parseArgs(process.argv.slice(2))) {
+  const config = readBridgeConfig(args.config)
+  const port = args.port || getConfiguredBridgePort(config)
+  const host = args.host || '127.0.0.1'
+  const server = createBridgeServer(args.config)
+
+  server.listen(port, host, () => {
+    process.stdout.write(`HolySheep Claude bridge listening on http://${host}:${port}\n`)
+  })
+
+  return server
+}
+
+function spawnBridge(port = getConfiguredBridgePort()) {
+  if (waitForBridge(port)) return true
+
+  const scriptPath = path.join(__dirname, '..', 'index.js')
+  const child = spawn(process.execPath, [scriptPath, 'claude-bridge', '--port', String(port)], {
+    detached: true,
+    stdio: 'ignore',
+  })
+  child.unref()
+
+  return waitForBridge(port)
+}
+
+module.exports = {
+  CLAUDE_BRIDGE_CONFIG_FILE,
+  DEFAULT_BRIDGE_PORT,
+  createBridgeServer,
+  getBridgeBaseUrl,
+  getConfiguredBridgePort,
+  parseArgs,
+  readBridgeConfig,
+  spawnBridge,
+  startBridge,
+  waitForBridge,
+  writeBridgeConfig,
+}

package/src/tools/claude-code.js

@@ -11,6 +11,19 @@
 const fs = require('fs')
 const path = require('path')
 const os = require('os')
+const crypto = require('crypto')
+const {
+  BASE_URL_ANTHROPIC,
+  BASE_URL_CLAUDE_RELAY,
+} = require('../utils/config')
+const {
+  DEFAULT_BRIDGE_PORT,
+  getBridgeBaseUrl,
+  getConfiguredBridgePort,
+  readBridgeConfig,
+  spawnBridge,
+  writeBridgeConfig,
+} = require('./claude-bridge')
 
 const SETTINGS_FILE = path.join(os.homedir(), '.claude', 'settings.json')
 
@@ -38,15 +51,43 @@ module.exports = {
   },
   isConfigured() {
     const s = readSettings()
-    return !!(s.env?.ANTHROPIC_AUTH_TOKEN || s.env?.ANTHROPIC_API_KEY)
+    const bridge = readBridgeConfig()
+    const bridgePort = getConfiguredBridgePort(bridge)
+    return Boolean(
+      s.env?.ANTHROPIC_AUTH_TOKEN &&
+      s.env?.ANTHROPIC_BASE_URL === getBridgeBaseUrl(bridgePort) &&
+      bridge.apiKey &&
+      bridge.bridgeSecret
+    )
   },
   configure(apiKey, baseUrl) {
+    const bridge = readBridgeConfig()
+    const bridgePort = getConfiguredBridgePort(bridge)
+    const relayUrl = bridge.relayUrl || BASE_URL_CLAUDE_RELAY || ''
+    writeBridgeConfig({
+      port: bridgePort || DEFAULT_BRIDGE_PORT,
+      apiKey,
+      baseUrlAnthropic: baseUrl || BASE_URL_ANTHROPIC,
+      controlPlaneUrl: relayUrl || baseUrl || BASE_URL_ANTHROPIC,
+      relayUrl,
+      bridgeId: bridge.bridgeId || crypto.randomUUID(),
+      deviceId: bridge.deviceId || crypto.randomUUID(),
+      bridgeSecret: bridge.bridgeSecret || crypto.randomBytes(32).toString('hex'),
+      nodeId: bridge.nodeId || '',
+      sessionMode: bridge.sessionMode || 'pinned-node',
+      installSource: 'holysheep-cli',
+    })
+
+    if (!spawnBridge(bridgePort)) {
+      throw new Error('HolySheep Claude Bridge 启动失败')
+    }
+
     const settings = readSettings()
     if (!settings.env) settings.env = {}
-    // Claude Code 用 ANTHROPIC_AUTH_TOKEN（最高优先级），兼容 ANTHROPIC_API_KEY
     settings.env.ANTHROPIC_AUTH_TOKEN = apiKey
-    settings.env.ANTHROPIC_BASE_URL = baseUrl
+    settings.env.ANTHROPIC_BASE_URL = getBridgeBaseUrl(bridgePort)
     settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1'
+    settings.env.HOLYSHEEP_CLAUDE_BRIDGE = '1'
     // 清理旧的同义字段
     delete settings.env.ANTHROPIC_API_KEY
     writeSettings(settings)
@@ -59,12 +100,19 @@ module.exports = {
       delete settings.env.ANTHROPIC_API_KEY
       delete settings.env.ANTHROPIC_BASE_URL
       delete settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC
+      delete settings.env.HOLYSHEEP_CLAUDE_BRIDGE
     }
     writeSettings(settings)
   },
   getConfigPath() { return SETTINGS_FILE },
-  hint: '支持热切换，无需重启终端',
+  hint: '通过 HolySheep 本地 Bridge 接入，支持热切换，无需重启终端',
   launchCmd: 'claude',
   installCmd: 'npm install -g @anthropic-ai/claude-code',
   docsUrl: 'https://docs.anthropic.com/claude-code',
+  getBridgePort() {
+    return getConfiguredBridgePort()
+  },
+  getBridgeConfig() {
+    return readBridgeConfig()
+  },
 }

package/src/tools/openclaw-bridge.js

@@ -59,6 +59,7 @@ function sendOpenAIStream(res, payload) {
   const choice = payload.choices?.[0] || {}
   const message = choice.message || {}
   const created = payload.created || Math.floor(Date.now() / 1000)
+  const messageContent = extractOpenAITextContent(message.content)
 
   res.writeHead(200, {
     'content-type': 'text/event-stream; charset=utf-8',
@@ -75,7 +76,7 @@ function sendOpenAIStream(res, payload) {
       index: 0,
       delta: {
         role: 'assistant',
-        ...(message.content ? { content: message.content } : {}),
+        ...(messageContent ? { content: messageContent } : {}),
         ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}),
       },
       finish_reason: null,
@@ -101,11 +102,30 @@ function normalizeText(value) {
   if (Array.isArray(value)) return value.map(normalizeText).filter(Boolean).join('\n')
   if (value && typeof value === 'object') {
     if (typeof value.text === 'string') return value.text
+    if (typeof value.output_text === 'string') return value.output_text
     if (typeof value.content === 'string') return value.content
+    if (typeof value.value === 'string') return value.value
   }
   return value == null ? '' : String(value)
 }
 
+function extractOpenAITextContent(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return normalizeText(content)
+
+  return content
+    .map((part) => {
+      if (typeof part === 'string') return part
+      if (!part || typeof part !== 'object') return ''
+      if (part.type === 'text') return normalizeText(part.text)
+      if (part.type === 'output_text') return normalizeText(part.text)
+      if (part.type === 'input_text') return normalizeText(part.text)
+      return normalizeText(part.text || part.content || part.value)
+    })
+    .filter(Boolean)
+    .join('')
+}
+
 function parseDataUrl(url) {
   const match = String(url || '').match(/^data:([^;]+);base64,(.+)$/)
   if (!match) return null
@@ -314,10 +334,102 @@ function pickRoute(model) {
   return 'openai'
 }
 
-function parseOpenAIStreamText(text) {
+function responseOutputToText(output) {
+  return (output || [])
+    .flatMap((item) => {
+      if (item?.type === 'message') return item.content || []
+      if (item?.content) return item.content
+      return []
+    })
+    .filter((item) => item?.type === 'output_text' || item?.type === 'text')
+    .map((item) => extractOpenAITextContent(item.text || item.content || item))
+    .filter(Boolean)
+    .join('')
+}
+
+function responseOutputToToolCalls(output) {
+  return (output || [])
+    .filter((item) => item?.type === 'function_call' && item.name)
+    .map((item, index) => ({
+      id: item.call_id || item.id || `call_${index + 1}`,
+      type: 'function',
+      function: {
+        name: item.name,
+        arguments: typeof item.arguments === 'string'
+          ? item.arguments
+          : JSON.stringify(item.arguments || {}),
+      },
+    }))
+}
+
+function responseToChatCompletion(responseBody, requestedModel) {
+  const response = responseBody?.response && typeof responseBody.response === 'object'
+    ? responseBody.response
+    : responseBody
+
+  const text = responseOutputToText(response.output)
+  const toolCalls = responseOutputToToolCalls(response.output)
+  const status = String(response.status || '').toLowerCase()
+  const finishReason = status === 'completed' || status === '' ? 'stop' : 'length'
+  const outputTokens = response.usage?.output_tokens || response.usage?.completion_tokens || 0
+  const promptTokens = response.usage?.input_tokens || response.usage?.prompt_tokens || 0
+
+  return {
+    id: response.id || `chatcmpl_${Date.now()}`,
+    object: 'chat.completion',
+    created: response.created_at || Math.floor(Date.now() / 1000),
+    model: requestedModel || response.model,
+    choices: [{
+      index: 0,
+      message: {
+        role: 'assistant',
+        content: text || null,
+        ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
+      },
+      finish_reason: finishReason,
+    }],
+    usage: response.usage
+      ? {
+          prompt_tokens: promptTokens,
+          completion_tokens: outputTokens,
+          total_tokens: response.usage.total_tokens || (promptTokens + outputTokens),
+        }
+      : undefined,
+  }
+}
+
+function normalizeOpenAICompatibleResponse(parsed, requestedModel) {
+  if (!parsed || typeof parsed !== 'object') return parsed
+
+  if (parsed.object === 'response' || Array.isArray(parsed.output)) {
+    return responseToChatCompletion(parsed, requestedModel)
+  }
+
+  if (parsed.object === 'chat.completion' || parsed.object === 'chat.completion.chunk') {
+    const choice = parsed.choices?.[0]
+    if (choice?.message) {
+      choice.message = {
+        ...choice.message,
+        content: extractOpenAITextContent(choice.message.content) || null,
+      }
+    }
+    if (choice?.delta?.content != null) {
+      choice.delta = {
+        ...choice.delta,
+        content: extractOpenAITextContent(choice.delta.content),
+      }
+    }
+  }
+
+  return parsed
+}
+
+function parseOpenAIStreamText(text, requestedModel) {
   try {
     const parsed = JSON.parse(String(text || ''))
-    if (parsed && typeof parsed === 'object') return parsed
+    if (parsed && typeof parsed === 'object') {
+      return normalizeOpenAICompatibleResponse(parsed, requestedModel)
+    }
   } catch {}
 
   const blocks = String(text || '').split(/\r?\n\r?\n+/).filter(Boolean)
@@ -356,11 +468,7 @@ function parseOpenAIStreamText(text) {
     if (eventName === 'response.completed' && chunk.response) {
       responseCompleted = chunk.response
       if (!content) {
-        const outputText = (chunk.response.output || [])
-          .flatMap((item) => item?.content || [])
-          .filter((item) => item?.type === 'output_text' && typeof item.text === 'string')
-          .map((item) => item.text)
-          .join('')
+        const outputText = responseOutputToText(chunk.response.output)
         if (outputText) content = outputText
       }
       continue
@@ -369,28 +477,23 @@ function parseOpenAIStreamText(text) {
     finalChunk = chunk
     const choice = chunk.choices?.[0] || {}
     const delta = choice.delta || {}
-    if (delta.content) content += delta.content
-    else if (choice.message?.content) content += choice.message.content
+    const deltaContent = extractOpenAITextContent(delta.content)
+    const messageContent = extractOpenAITextContent(choice.message?.content)
+    if (deltaContent) content += deltaContent
+    else if (messageContent) content += messageContent
   }
 
   if (responseCompleted) {
-    return {
-      id: responseCompleted.id || `chatcmpl_${Date.now()}`,
-      object: 'chat.completion',
-      created: responseCompleted.created_at || Math.floor(Date.now() / 1000),
-      model: responseCompleted.model,
-      choices: [{
-        index: 0,
-        message: { role: 'assistant', content: content || null },
-        finish_reason: responseCompleted.status === 'completed' ? 'stop' : 'length',
-      }],
-      usage: responseCompleted.usage,
+    const completion = responseToChatCompletion(responseCompleted, requestedModel || responseCompleted.model)
+    if (!completion.choices?.[0]?.message?.content && content) {
+      completion.choices[0].message.content = content
     }
+    return completion
   }
 
   if (!finalChunk) return null
 
-  return {
+  return normalizeOpenAICompatibleResponse({
     id: finalChunk.id || `chatcmpl_${Date.now()}`,
     object: 'chat.completion',
     created: finalChunk.created || Math.floor(Date.now() / 1000),
@@ -401,7 +504,7 @@ function parseOpenAIStreamText(text) {
       finish_reason: finalChunk.choices?.[0]?.finish_reason || 'stop',
     }],
     usage: finalChunk.usage,
-  }
+  }, requestedModel)
 }
 
 async function relayOpenAIRequest(requestBody, config, res) {
@@ -420,7 +523,7 @@ async function relayOpenAIRequest(requestBody, config, res) {
   })
 
   const text = await upstream.text()
-  const parsed = parseOpenAIStreamText(text)
+  const parsed = parseOpenAIStreamText(text, requestBody.model)
   if (upstream.ok && parsed) {
     if (requestBody.stream) return sendOpenAIStream(res, parsed)
     return sendJson(res, upstream.status, parsed)

package/src/utils/config.js

@@ -11,6 +11,7 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
 
 const BASE_URL_ANTHROPIC = 'https://api.holysheep.ai'         // 不带 /v1 (Anthropic SDK)
 const BASE_URL_OPENAI    = 'https://api.holysheep.ai/v1'      // 带 /v1 (OpenAI 兼容)
+const BASE_URL_CLAUDE_RELAY = process.env.HOLYSHEEP_CLAUDE_RELAY_URL || 'https://api.holysheep.ai/claude-relay'
 const SHOP_URL           = 'https://holysheep.ai'
 
 function ensureDir() {
@@ -45,6 +46,7 @@ module.exports = {
   CONFIG_FILE,
   BASE_URL_ANTHROPIC,
   BASE_URL_OPENAI,
+  BASE_URL_CLAUDE_RELAY,
   SHOP_URL,
   loadConfig,
   saveConfig,