@simonyea/holysheep-cli 1.6.14 → 1.6.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonyea/holysheep-cli",
-  "version": "1.6.14",
+  "version": "1.6.15",
   "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",

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)