@simonyea/holysheep-cli 2.1.40 → 2.1.41

package/src/tools/openclaw-bridge.js

@@ -1,987 +0,0 @@
-#!/usr/bin/env node
-'use strict'
-
-const fs = require('fs')
-const http = require('http')
-const path = require('path')
-const os = require('os')
-const fetch = global.fetch || require('node-fetch')
-const _nodeFetch = require('node-fetch')
-
-// Windows 上 api.holysheep.ai 有 IPv6 DNS 记录，但 Windows Server 普遍未启用 IPv6。
-// Node.js 默认 IPv6 优先，会导致每次请求先卡在 IPv6 连接超时再降级 IPv4，
-// 超过 OpenClaw embedded agent 的 timeout 阈值，触发 "LLM request timed out"。
-// 解决方案：Windows 下强制用 node-fetch + https.Agent({family:4}) 只走 IPv4。
-function upstreamFetch(url, options) {
-  if (process.platform === 'win32' && String(url).startsWith('https://')) {
-    const https = require('https')
-    return _nodeFetch(url, { ...options, agent: new https.Agent({ family: 4 }) })
-  }
-  return fetch(url, options)
-}
-
-const OPENCLAW_DIR = path.join(os.homedir(), '.openclaw')
-const BRIDGE_CONFIG_FILE = path.join(OPENCLAW_DIR, 'holysheep-bridge.json')
-const DEFAULT_WATCHDOG_INTERVAL_MS = 3000
-const DEFAULT_WATCHDOG_FAILURE_THRESHOLD = 3
-const DEFAULT_WATCHDOG_STARTUP_GRACE_MS = 30000
-const DEFAULT_WATCHDOG_REQUEST_TIMEOUT_MS = 1500
-
-function readBridgeConfig(configPath = BRIDGE_CONFIG_FILE) {
-  return JSON.parse(fs.readFileSync(configPath, 'utf8'))
-}
-
-function parseArgs(argv) {
-  const args = { port: null, host: '127.0.0.1', config: 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 readJsonBody(req) {
-  return new Promise((resolve, reject) => {
-    let raw = ''
-    req.on('data', (chunk) => {
-      raw += chunk
-      if (raw.length > 5 * 1024 * 1024) {
-        reject(new Error('Request body too large'))
-        req.destroy()
-      }
-    })
-    req.on('end', () => {
-      if (!raw) return resolve({})
-      try {
-        resolve(JSON.parse(raw))
-      } catch (error) {
-        reject(error)
-      }
-    })
-    req.on('error', reject)
-  })
-}
-
-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 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',
-    'cache-control': 'no-cache, no-transform',
-    connection: 'keep-alive',
-  })
-
-  const firstChunk = {
-    id: payload.id,
-    object: 'chat.completion.chunk',
-    created,
-    model: payload.model,
-    choices: [{
-      index: 0,
-      delta: {
-        role: 'assistant',
-        ...(messageContent ? { content: messageContent } : {}),
-        ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}),
-      },
-      finish_reason: null,
-    }],
-  }
-
-  const finalChunk = {
-    id: payload.id,
-    object: 'chat.completion.chunk',
-    created,
-    model: payload.model,
-    choices: [{ index: 0, delta: {}, finish_reason: choice.finish_reason || 'stop' }],
-    usage: payload.usage,
-  }
-
-  res.write(`data: ${JSON.stringify(firstChunk)}\n\n`)
-  res.write(`data: ${JSON.stringify(finalChunk)}\n\n`)
-  res.end('data: [DONE]\n\n')
-}
-
-function normalizeText(value) {
-  if (typeof value === 'string') return 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
-  return { mediaType: match[1], data: match[2] }
-}
-
-function openAIContentToAnthropicBlocks(content) {
-  if (typeof content === 'string') return [{ type: 'text', text: content }]
-  if (!Array.isArray(content)) return []
-
-  const blocks = []
-  for (const part of content) {
-    if (!part) continue
-    if (part.type === 'text' && typeof part.text === 'string') {
-      blocks.push({ type: 'text', text: part.text })
-      continue
-    }
-    if (part.type === 'image_url' && part.image_url?.url) {
-      const dataUrl = parseDataUrl(part.image_url.url)
-      if (dataUrl) {
-        blocks.push({
-          type: 'image',
-          source: { type: 'base64', media_type: dataUrl.mediaType, data: dataUrl.data },
-        })
-      }
-    }
-  }
-  return blocks
-}
-
-function pushAnthropicMessage(messages, role, blocks) {
-  if (!blocks.length) return
-  const previous = messages[messages.length - 1]
-  if (previous && previous.role === role) {
-    previous.content = previous.content.concat(blocks)
-    return
-  }
-  messages.push({ role, content: blocks })
-}
-
-function convertOpenAIToAnthropicMessages(messages) {
-  const anthropicMessages = []
-  const systemParts = []
-
-  for (const message of messages || []) {
-    if (!message) continue
-
-    if (message.role === 'system') {
-      const blocks = openAIContentToAnthropicBlocks(message.content)
-      if (blocks.length === 0) {
-        const text = normalizeText(message.content)
-        if (text) systemParts.push(text)
-      } else {
-        for (const block of blocks) {
-          if (block.type === 'text') systemParts.push(block.text)
-        }
-      }
-      continue
-    }
-
-    if (message.role === 'tool') {
-      pushAnthropicMessage(anthropicMessages, 'user', [{
-        type: 'tool_result',
-        tool_use_id: message.tool_call_id,
-        content: normalizeText(message.content),
-      }])
-      continue
-    }
-
-    if (message.role === 'assistant') {
-      const blocks = []
-      const textBlocks = openAIContentToAnthropicBlocks(message.content)
-      if (textBlocks.length) blocks.push(...textBlocks)
-      else if (typeof message.content === 'string' && message.content) blocks.push({ type: 'text', text: message.content })
-
-      for (const toolCall of message.tool_calls || []) {
-        let input = {}
-        try {
-          input = JSON.parse(toolCall.function?.arguments || '{}')
-        } catch {}
-        blocks.push({
-          type: 'tool_use',
-          id: toolCall.id,
-          name: toolCall.function?.name || 'tool',
-          input,
-        })
-      }
-
-      pushAnthropicMessage(anthropicMessages, 'assistant', blocks)
-      continue
-    }
-
-    const blocks = openAIContentToAnthropicBlocks(message.content)
-    if (blocks.length) pushAnthropicMessage(anthropicMessages, 'user', blocks)
-    else {
-      const text = normalizeText(message.content)
-      if (text) pushAnthropicMessage(anthropicMessages, 'user', [{ type: 'text', text }])
-    }
-  }
-
-  return {
-    system: systemParts.join('\n\n').trim() || undefined,
-    messages: anthropicMessages,
-  }
-}
-
-function convertOpenAIToolsToAnthropic(tools) {
-  return (tools || [])
-    .filter((tool) => tool?.type === 'function' && tool.function?.name)
-    .map((tool) => ({
-      name: tool.function.name,
-      description: tool.function.description || '',
-      input_schema: tool.function.parameters || { type: 'object', properties: {} },
-    }))
-}
-
-function convertToolChoice(toolChoice) {
-  if (!toolChoice || toolChoice === 'auto') return { type: 'auto' }
-  if (toolChoice === 'none') return { type: 'auto', disable_parallel_tool_use: true }
-  if (toolChoice === 'required') return { type: 'any' }
-  if (toolChoice.type === 'function' && toolChoice.function?.name) {
-    return { type: 'tool', name: toolChoice.function.name }
-  }
-  return { type: 'auto' }
-}
-
-function buildAnthropicPayload(requestBody, stream = false) {
-  const converted = convertOpenAIToAnthropicMessages(requestBody.messages)
-  const payload = {
-    model: requestBody.model,
-    max_tokens: requestBody.max_tokens || requestBody.max_completion_tokens || requestBody.max_output_tokens || 4096,
-    messages: converted.messages,
-    stream: Boolean(stream),
-  }
-
-  if (converted.system) payload.system = converted.system
-  if (requestBody.temperature != null) payload.temperature = requestBody.temperature
-  if (requestBody.top_p != null) payload.top_p = requestBody.top_p
-  if (Array.isArray(requestBody.stop) && requestBody.stop.length) payload.stop_sequences = requestBody.stop
-  if (typeof requestBody.stop === 'string') payload.stop_sequences = [requestBody.stop]
-
-  const tools = convertOpenAIToolsToAnthropic(requestBody.tools)
-  if (tools.length) payload.tools = tools
-  if (requestBody.tool_choice) payload.tool_choice = convertToolChoice(requestBody.tool_choice)
-
-  return payload
-}
-
-function mapFinishReason(stopReason) {
-  if (stopReason === 'tool_use') return 'tool_calls'
-  if (stopReason === 'max_tokens') return 'length'
-  return 'stop'
-}
-
-function buildToolCalls(content) {
-  const calls = []
-  for (const block of content || []) {
-    if (block?.type !== 'tool_use') continue
-    calls.push({
-      id: block.id,
-      type: 'function',
-      function: {
-        name: block.name,
-        arguments: JSON.stringify(block.input || {}),
-      },
-    })
-  }
-  return calls
-}
-
-function anthropicToOpenAIResponse(responseBody, requestedModel) {
-  const text = (responseBody.content || [])
-    .filter((block) => block?.type === 'text')
-    .map((block) => block.text)
-    .join('')
-  const toolCalls = buildToolCalls(responseBody.content)
-
-  return {
-    id: responseBody.id || `chatcmpl_${Date.now()}`,
-    object: 'chat.completion',
-    created: Math.floor(Date.now() / 1000),
-    model: requestedModel,
-    choices: [{
-      index: 0,
-      message: {
-        role: 'assistant',
-        content: text || null,
-        ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
-      },
-      finish_reason: mapFinishReason(responseBody.stop_reason),
-    }],
-    usage: responseBody.usage
-      ? {
-          prompt_tokens: responseBody.usage.input_tokens || 0,
-          completion_tokens: responseBody.usage.output_tokens || 0,
-          total_tokens: (responseBody.usage.input_tokens || 0) + (responseBody.usage.output_tokens || 0),
-        }
-      : undefined,
-  }
-}
-
-function pickRoute(model) {
-  if (String(model).startsWith('gpt-')) return 'openai'
-  if (String(model).startsWith('claude-')) return 'anthropic'
-  if (String(model).startsWith('MiniMax-')) return 'minimax'
-  return 'openai'
-}
-
-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 normalizeOpenAICompatibleResponse(parsed, requestedModel)
-    }
-  } catch {}
-
-  const blocks = String(text || '').split(/\r?\n\r?\n+/).filter(Boolean)
-  let responseCompleted = null
-  let finalChunk = null
-  let content = ''
-  let sawOutputTextDelta = false
-
-  for (const block of blocks) {
-    const eventMatch = block.match(/^event:\s*(.+)$/m)
-    const dataMatch = block.match(/^data:\s*(.+)$/m)
-    if (!dataMatch) continue
-
-    const eventName = eventMatch ? eventMatch[1].trim() : ''
-    const payload = dataMatch[1].trim()
-    if (!payload || payload === '[DONE]') continue
-
-    let chunk
-    try {
-      chunk = JSON.parse(payload)
-    } catch {
-      continue
-    }
-
-    if (eventName === 'response.output_text.delta' && typeof chunk.delta === 'string') {
-      sawOutputTextDelta = true
-      content += chunk.delta
-      continue
-    }
-
-    if (eventName === 'response.content_part.done' && chunk.part?.type === 'output_text' && typeof chunk.part.text === 'string') {
-      if (!sawOutputTextDelta) content += chunk.part.text
-      continue
-    }
-
-    if (eventName === 'response.completed' && chunk.response) {
-      responseCompleted = chunk.response
-      if (!content) {
-        const outputText = responseOutputToText(chunk.response.output)
-        if (outputText) content = outputText
-      }
-      continue
-    }
-
-    finalChunk = chunk
-    const choice = chunk.choices?.[0] || {}
-    const delta = choice.delta || {}
-    const deltaContent = extractOpenAITextContent(delta.content)
-    const messageContent = extractOpenAITextContent(choice.message?.content)
-    if (deltaContent) content += deltaContent
-    else if (messageContent) content += messageContent
-  }
-
-  if (responseCompleted) {
-    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 normalizeOpenAICompatibleResponse({
-    id: finalChunk.id || `chatcmpl_${Date.now()}`,
-    object: 'chat.completion',
-    created: finalChunk.created || Math.floor(Date.now() / 1000),
-    model: finalChunk.model,
-    choices: [{
-      index: 0,
-      message: { role: 'assistant', content: content || null },
-      finish_reason: finalChunk.choices?.[0]?.finish_reason || 'stop',
-    }],
-    usage: finalChunk.usage,
-  }, requestedModel)
-}
-
-async function relayOpenAIRequest(requestBody, config, res) {
-  const upstreamBody = {
-    ...requestBody,
-    stream: requestBody.stream === true,
-  }
-  const upstream = await upstreamFetch(`${config.baseUrlOpenAI.replace(/\/+$/, '')}/chat/completions`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      authorization: `Bearer ${config.apiKey}`,
-      'user-agent': 'holysheep-openclaw-bridge/1.0',
-    },
-    body: JSON.stringify(upstreamBody),
-  })
-
-  // 流式请求：直接字节透传（已是 OpenAI SSE 格式，无需转换）
-  if (requestBody.stream === true && upstream.ok) {
-    res.writeHead(200, {
-      'content-type': 'text/event-stream; charset=utf-8',
-      'cache-control': 'no-cache, no-transform',
-      connection: 'keep-alive',
-    })
-    try { await pipeStream(upstream.body, (chunk) => res.write(chunk)) } catch {}
-    if (!res.writableEnded) res.end()
-    return
-  }
-
-  const text = await upstream.text()
-  const parsed = parseOpenAIStreamText(text, requestBody.model)
-  if (upstream.ok && parsed) {
-    if (requestBody.stream) return sendOpenAIStream(res, parsed)
-    return sendJson(res, upstream.status, parsed)
-  }
-
-  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',
-  })
-  res.end(text)
-}
-
-// 兼容 native fetch (ReadableStream) 和 node-fetch v2 (Node.js stream) 的流读取
-async function pipeStream(body, onChunk) {
-  if (body == null) return
-  if (typeof body.getReader === 'function') {
-    const reader = body.getReader()
-    const decoder = new TextDecoder()
-    try {
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        onChunk(decoder.decode(value, { stream: true }))
-      }
-      onChunk(decoder.decode())
-    } finally {
-      reader.releaseLock()
-    }
-  } else {
-    for await (const chunk of body) {
-      onChunk(typeof chunk === 'string' ? chunk : chunk.toString())
-    }
-  }
-}
-
-// Anthropic SSE → OpenAI SSE 实时透传（避免整包缓冲导致 OpenClaw timeout）
-async function relayAnthropicStream(requestBody, config, route, res) {
-  const payload = buildAnthropicPayload(requestBody, true)
-  const baseUrl = route === 'minimax'
-    ? `${config.baseUrlAnthropic.replace(/\/+$/, '')}/minimax/v1/messages`
-    : `${config.baseUrlAnthropic.replace(/\/+$/, '')}/v1/messages`
-
-  let upstream
-  try {
-    upstream = await upstreamFetch(baseUrl, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'x-api-key': config.apiKey,
-        'anthropic-version': '2023-06-01',
-        'user-agent': 'holysheep-openclaw-bridge/1.0',
-      },
-      body: JSON.stringify(payload),
-    })
-  } catch (err) {
-    return sendJson(res, 500, { error: { message: err.message || 'Bridge upstream error' } })
-  }
-
-  if (!upstream.ok) {
-    let errBody
-    try { errBody = JSON.parse(await upstream.text()) } catch { errBody = { error: { message: 'Upstream error' } } }
-    return sendJson(res, upstream.status, errBody)
-  }
-
-  res.writeHead(200, {
-    'content-type': 'text/event-stream; charset=utf-8',
-    'cache-control': 'no-cache, no-transform',
-    connection: 'keep-alive',
-  })
-
-  const msgId = `chatcmpl_${Date.now()}`
-  const created = Math.floor(Date.now() / 1000)
-  const model = requestBody.model
-  let headerSent = false
-  let inputTokens = 0
-  // tool_use 流式：按 content block index 收集
-  const toolBlocks = {}  // index → {id, name, argsBuf}
-
-  function writeChunk(delta, finishReason, usage) {
-    const chunk = {
-      id: msgId,
-      object: 'chat.completion.chunk',
-      created,
-      model,
-      choices: [{ index: 0, delta, finish_reason: finishReason || null }],
-    }
-    if (usage) chunk.usage = usage
-    res.write(`data: ${JSON.stringify(chunk)}\n\n`)
-  }
-
-  function handleEvent(event, data) {
-    if (data === '[DONE]') return
-    let obj
-    try { obj = JSON.parse(data) } catch { return }
-
-    if (event === 'message_start') {
-      inputTokens = obj.message?.usage?.input_tokens || 0
-      if (!headerSent) {
-        writeChunk({ role: 'assistant', content: '' }, null, null)
-        headerSent = true
-      }
-    } else if (event === 'content_block_start') {
-      if (!headerSent) { writeChunk({ role: 'assistant', content: '' }, null, null); headerSent = true }
-      const block = obj.content_block || {}
-      if (block.type === 'tool_use') {
-        toolBlocks[obj.index] = { id: block.id, name: block.name, argsBuf: '' }
-        writeChunk({
-          tool_calls: [{ index: obj.index, id: block.id, type: 'function', function: { name: block.name, arguments: '' } }],
-        }, null, null)
-      }
-    } else if (event === 'content_block_delta') {
-      if (!headerSent) { writeChunk({ role: 'assistant', content: '' }, null, null); headerSent = true }
-      const delta = obj.delta || {}
-      if (delta.type === 'text_delta' && typeof delta.text === 'string') {
-        writeChunk({ content: delta.text }, null, null)
-      } else if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
-        if (toolBlocks[obj.index]) toolBlocks[obj.index].argsBuf += delta.partial_json
-        writeChunk({ tool_calls: [{ index: obj.index, function: { arguments: delta.partial_json } }] }, null, null)
-      }
-    } else if (event === 'message_delta') {
-      const stopReason = obj.delta?.stop_reason
-      const finishReason = mapFinishReason(stopReason)
-      const outputTokens = obj.usage?.output_tokens || 0
-      const usage = {
-        prompt_tokens: inputTokens,
-        completion_tokens: outputTokens,
-        total_tokens: inputTokens + outputTokens,
-      }
-      if (!headerSent) { writeChunk({ role: 'assistant', content: '' }, null, null); headerSent = true }
-      writeChunk({}, finishReason, usage)
-    }
-  }
-
-  let buf = ''
-  let curEvent = ''
-
-  function processBuffer(text) {
-    buf += text
-    const lines = buf.split('\n')
-    buf = lines.pop() ?? ''
-    for (const line of lines) {
-      const trimmed = line.trimEnd()
-      if (trimmed.startsWith('event:')) {
-        curEvent = trimmed.slice(6).trim()
-      } else if (trimmed.startsWith('data:')) {
-        handleEvent(curEvent, trimmed.slice(5).trim())
-        curEvent = ''
-      }
-    }
-  }
-
-  try {
-    await pipeStream(upstream.body, processBuffer)
-  } catch {}
-
-  if (!res.writableEnded) res.end('data: [DONE]\n\n')
-}
-
-async function relayAnthropicRequest(requestBody, config, route, res) {
-  if (requestBody.stream === true) {
-    return relayAnthropicStream(requestBody, config, route, res)
-  }
-  const payload = buildAnthropicPayload(requestBody)
-  const baseUrl = route === 'minimax'
-    ? `${config.baseUrlAnthropic.replace(/\/+$/, '')}/minimax/v1/messages`
-    : `${config.baseUrlAnthropic.replace(/\/+$/, '')}/v1/messages`
-
-  const upstream = await upstreamFetch(baseUrl, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      'x-api-key': config.apiKey,
-      'anthropic-version': '2023-06-01',
-      'user-agent': 'holysheep-openclaw-bridge/1.0',
-    },
-    body: JSON.stringify(payload),
-  })
-
-  const text = await upstream.text()
-  let body
-  try {
-    body = JSON.parse(text)
-  } catch {
-    body = { error: { message: text || 'Invalid upstream response' } }
-  }
-
-  if (!upstream.ok) {
-    return sendJson(res, upstream.status, body)
-  }
-
-  const openaiBody = anthropicToOpenAIResponse(body, requestBody.model)
-  if (requestBody.stream) return sendOpenAIStream(res, openaiBody)
-  return sendJson(res, 200, openaiBody)
-}
-
-function buildModelsResponse(config) {
-  return {
-    object: 'list',
-    data: (config.models || []).map((model) => ({
-      id: model,
-      object: 'model',
-      owned_by: 'holysheep',
-    })),
-  }
-}
-
-// ── Live HolySheep model list for OpenClaw ───────────────────────────────────
-// OpenClaw / AcpModelSelector hits `/v1/models` to populate its model dropdown.
-// Historically this returned only the static `config.models` from
-// `~/.openclaw/holysheep-bridge.json`, so users saw a stale hand-curated list.
-// We now fetch the full live catalog from the HolySheep API once per bridge
-// process (60s TTL) and merge it with the user's preferred models. The
-// config.models always wins on ordering — new entries from upstream are
-// appended afterwards so existing users don't see their default model jump.
-//
-// Env opt-out: HOLYSHEEP_BRIDGE_NO_LIVE_MODELS=1 keeps the old static behavior.
-let _liveModelsCache = { at: 0, ids: null }
-const LIVE_MODELS_TTL_MS = 60_000
-
-async function fetchLiveHolySheepModels(config) {
-  if (process.env.HOLYSHEEP_BRIDGE_NO_LIVE_MODELS === '1') return null
-  const now = Date.now()
-  if (_liveModelsCache.ids && now - _liveModelsCache.at < LIVE_MODELS_TTL_MS) {
-    return _liveModelsCache.ids
-  }
-  const base = (config.baseUrlOpenAI || 'https://api.holysheep.ai/v1').replace(/\/+$/, '')
-  const url = `${base}/models`
-  const apiKey = config.apiKey
-  if (!apiKey) return null
-  try {
-    const resp = await upstreamFetch(url, {
-      method: 'GET',
-      headers: { authorization: `Bearer ${apiKey}` },
-    })
-    if (!resp.ok) return null
-    const body = await resp.json()
-    const ids = Array.isArray(body?.data)
-      ? body.data.map((m) => (m && typeof m.id === 'string' ? m.id : null)).filter(Boolean)
-      : null
-    if (ids && ids.length) {
-      _liveModelsCache = { at: now, ids }
-      return ids
-    }
-  } catch {
-    // Network error / upstream 5xx — fall back to static config.models.
-  }
-  return null
-}
-
-async function buildLiveModelsResponse(config) {
-  const live = await fetchLiveHolySheepModels(config)
-  const configured = config.models || []
-  if (!live) return buildModelsResponse(config)
-  // Merge: preserve user's preferred ordering from config.models (typically
-  // the models they actively use for OpenClaw), then append new live entries.
-  const seen = new Set(configured)
-  const merged = [...configured]
-  for (const id of live) {
-    if (!seen.has(id)) {
-      merged.push(id)
-      seen.add(id)
-    }
-  }
-  return {
-    object: 'list',
-    data: merged.map((model) => ({
-      id: model,
-      object: 'model',
-      owned_by: 'holysheep',
-    })),
-  }
-}
-
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return null
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (error) {
-    if (error && error.code === 'EPERM') return true
-    return false
-  }
-}
-
-async function checkGatewayHealth(config) {
-  const gatewayPort = Number(config.gatewayPort)
-  if (!Number.isInteger(gatewayPort) || gatewayPort <= 0) {
-    return { ok: true, reason: 'no_gateway_port' }
-  }
-
-  const gatewayPid = Number(config.gatewayPid)
-  const pidAlive = isProcessAlive(gatewayPid)
-  if (pidAlive === false) {
-    return { ok: false, reason: 'gateway_pid_exited' }
-  }
-
-  const host = config.gatewayHost || '127.0.0.1'
-  const timeout = Number(config.watchdog?.requestTimeoutMs) || DEFAULT_WATCHDOG_REQUEST_TIMEOUT_MS
-
-  // 用 http.get + family:4 强制 IPv4，避免 Windows 上 Node.js 优先尝试 IPv6 (::1)
-  // 而 Gateway 只监听 127.0.0.1 导致 Watchdog 误判自杀
-  try {
-    const http = require('http')
-    await new Promise((resolve, reject) => {
-      const req = http.get({ hostname: host, port: gatewayPort, path: '/', family: 4 }, resolve)
-      req.setTimeout(timeout, () => { req.destroy(); reject(new Error('timeout')) })
-      req.on('error', reject)
-    })
-    return { ok: true, reason: 'gateway_http_ok' }
-  } catch {
-    return { ok: false, reason: 'gateway_http_unreachable' }
-  }
-}
-
-function stopBridge(server, reason) {
-  process.stdout.write(`HolySheep OpenClaw bridge stopping: ${reason}\n`)
-  server.close(() => process.exit(0))
-  setTimeout(() => process.exit(0), 250).unref()
-}
-
-function startGatewayWatchdog(server, configPath = BRIDGE_CONFIG_FILE) {
-  const bridgeStartedAt = Date.now()
-  let consecutiveFailures = 0
-  let stopping = false
-
-  const timer = setInterval(async () => {
-    if (stopping) return
-
-    let config
-    try {
-      config = readBridgeConfig(configPath)
-    } catch {
-      stopping = true
-      stopBridge(server, 'bridge config missing')
-      return
-    }
-
-    const watchdog = config.watchdog || {}
-    if (watchdog.enabled === false) return
-
-    const startupGraceMs = Number(watchdog.startupGraceMs) || DEFAULT_WATCHDOG_STARTUP_GRACE_MS
-    const failureThreshold = Number(watchdog.failureThreshold) || DEFAULT_WATCHDOG_FAILURE_THRESHOLD
-    const health = await checkGatewayHealth(config)
-
-    if (health.ok) {
-      consecutiveFailures = 0
-      return
-    }
-
-    const gatewayStartedAt = Date.parse(config.gatewayStartedAt || '') || bridgeStartedAt
-    if (Date.now() - gatewayStartedAt < startupGraceMs) {
-      return
-    }
-
-    consecutiveFailures += 1
-    if (consecutiveFailures < failureThreshold) return
-
-    stopping = true
-    stopBridge(server, `OpenClaw Gateway unavailable (${health.reason})`)
-  }, DEFAULT_WATCHDOG_INTERVAL_MS)
-
-  timer.unref()
-  server.on('close', () => clearInterval(timer))
-}
-
-function createBridgeServer(configPath = 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,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'}`)
-
-      if (req.method === 'GET' && url.pathname === '/health') {
-        return sendJson(res, 200, { ok: true, port: config.port, models: config.models || [] })
-      }
-
-      if (req.method === 'GET' && url.pathname === '/v1/models') {
-        return sendJson(res, 200, buildModelsResponse(config))
-      }
-
-      if (req.method === 'POST' && url.pathname === '/v1/chat/completions') {
-        const requestBody = await readJsonBody(req)
-        const route = pickRoute(requestBody.model)
-        if (route === 'openai') return relayOpenAIRequest(requestBody, config, res)
-        return relayAnthropicRequest(requestBody, config, route, res)
-      }
-
-      return sendJson(res, 404, { error: { message: 'Not found' } })
-    } catch (error) {
-      return sendJson(res, 500, { error: { message: error.message || 'Bridge error' } })
-    }
-  })
-}
-
-function startBridge(args = parseArgs(process.argv.slice(2))) {
-  const config = readBridgeConfig(args.config)
-  const port = args.port || config.port
-  const host = args.host || '127.0.0.1'
-  const server = createBridgeServer(args.config)
-
-  server.listen(port, host, () => {
-    process.stdout.write(`HolySheep OpenClaw bridge listening on http://${host}:${port}\n`)
-  })
-  startGatewayWatchdog(server, args.config)
-
-  return server
-}
-
-if (require.main === module) {
-  startBridge()
-}
-
-module.exports = {
-  BRIDGE_CONFIG_FILE,
-  buildAnthropicPayload,
-  anthropicToOpenAIResponse,
-  buildModelsResponse,
-  createBridgeServer,
-  parseArgs,
-  parseOpenAIStreamText,
-  pickRoute,
-  readBridgeConfig,
-  startBridge,
-}