@mmmbuto/zai-codex-bridge 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/zai-codex-bridge",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Local proxy that translates OpenAI Responses API format to Z.AI Chat Completions format for Codex",
   "main": "src/server.js",
   "bin": {

package/src/server.js

@@ -11,6 +11,7 @@
  */
 
 const http = require('http');
+const crypto = require('crypto');
 
 // Configuration from environment
 const PORT = parseInt(process.env.PORT || '31415', 10);
@@ -192,61 +193,69 @@ function translateResponsesToChat(request) {
 
 /**
  * Translate Chat Completions response to Responses format
+ * Handles both output_text and reasoning_text content
  */
-function translateChatToResponses(chatResponse) {
-  let text = '';
-
-  // Extract content from Chat format
-  if (chatResponse.choices && chatResponse.choices.length > 0) {
-    const choice = chatResponse.choices[0];
-    if (choice.message && choice.message.content) {
-      text = choice.message.content;
-    }
-  }
-
-  // Map usage
-  const usage = {};
-  if (chatResponse.usage) {
-    if (chatResponse.usage.prompt_tokens) {
-      usage.input_tokens = chatResponse.usage.prompt_tokens;
-    }
-    if (chatResponse.usage.completion_tokens) {
-      usage.output_tokens = chatResponse.usage.completion_tokens;
-    }
-    if (chatResponse.usage.total_tokens) {
-      usage.total_tokens = chatResponse.usage.total_tokens;
-    }
+function translateChatToResponses(outputText, reasoningText = '', responseId = null, messageItemId = null, model = 'unknown') {
+  const rid = responseId || `resp_${crypto.randomUUID().replace(/-/g, '')}`;
+  const mid = messageItemId || `msg_${crypto.randomUUID().replace(/-/g, '')}`;
+  const createdAt = Math.floor(Date.now() / 1000);
+
+  const content = [];
+  if (reasoningText) {
+    content.push({ type: 'reasoning_text', text: reasoningText });
   }
+  content.push({ type: 'output_text', text: outputText });
 
-  const responseId = 'resp_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
-
-  // OpenAI Responses API format
   const response = {
-    id: responseId,
+    id: rid,
     object: 'response',
-    created_at: Math.floor(Date.now() / 1000),
+    created_at: createdAt,
+    model,
     status: 'completed',
-    model: chatResponse.model || 'glm-4.7',
-    output: [{
-      type: 'message',
-      role: 'assistant',
-      content: [{
-        type: 'output_text',
-        text: text
-      }]
-    }],
-    usage: Object.keys(usage).length > 0 ? usage : undefined
+    output: [
+      {
+        type: 'message',
+        id: mid,
+        role: 'assistant',
+        content
+      }
+    ]
   };
 
   log('debug', 'Translated Chat->Responses:', {
     id: response.id,
-    outputLength: text.length,
+    outputLength: outputText.length,
+    reasoningLength: reasoningText.length,
     status: response.status
   });
 
   return response;
 }
 
+/**
+ * Extract and normalize Bearer token
+ */
+function getBearer(raw) {
+  if (!raw) return '';
+  let t = String(raw).trim();
+  if (!t) return '';
+  // If already "Bearer xxx" keep it, otherwise add it
+  if (!t.toLowerCase().startsWith('bearer ')) t = `Bearer ${t}`;
+  return t;
+}
+
+/**
+ * Pick auth token from env ZAI_API_KEY (priority) or incoming headers
+ */
+function pickAuth(incomingHeaders) {
+  // PRIORITY: env ZAI_API_KEY (force correct key) -> incoming header
+  const envTok = (process.env.ZAI_API_KEY || '').trim();
+  if (envTok) return getBearer(envTok);
+
+  const h = (incomingHeaders['authorization'] || incomingHeaders['Authorization'] || '').trim();
+  return getBearer(h);
+}
+
 /**
  * Make upstream request to Z.AI
  */
@@ -257,9 +266,10 @@ async function makeUpstreamRequest(path, body, headers) {
   const cleanPath = path.startsWith('/') ? path.slice(1) : path;
   const url = new URL(cleanPath, baseUrl);
 
+  const auth = pickAuth(headers);
   const upstreamHeaders = {
     'Content-Type': 'application/json',
-    'Authorization': headers['authorization'] || headers['Authorization'] || ''
+    'Authorization': auth
   };
 
   log('info', 'Upstream request:', {
@@ -267,7 +277,8 @@ async function makeUpstreamRequest(path, body, headers) {
     path: path,
     cleanPath: cleanPath,
     base: ZAI_BASE_URL,
-    hasAuth: !!upstreamHeaders.Authorization,
+    auth_len: auth.length,
+    auth_prefix: auth.slice(0, 14), // "Bearer xxxxxx"
     bodyKeys: Object.keys(body),
     bodyPreview: JSON.stringify(body).substring(0, 800),
     messagesCount: body.messages?.length || 0,
@@ -284,124 +295,277 @@ async function makeUpstreamRequest(path, body, headers) {
 }
 
 /**
- * Handle streaming response from Z.AI
+ * Handle streaming response from Z.AI with proper Responses API event format
+ * Separates reasoning_content, content, and tool_calls into distinct events
  */
-async function streamChatToResponses(stream, res, responseId, itemId) {
-  const decoder = new TextDecoder();
+async function streamChatToResponses(stream, res, responseId, messageItemId) {
   let buffer = '';
-  let chunkCount = 0;
-  let deltaCount = 0;
-  let lastParsed = null;
-  let didComplete = false;
+  let seq = 0;
+
+  let outputText = '';
+  let reasoningText = '';
+
+  // tool call state: key = call_id (or id), value = { itemId, outputIndex, name, args }
+  const toolCalls = new Map();
+  let nextOutputIndex = 1; // 0 is the message item
+
+  const createdAt = Math.floor(Date.now() / 1000);
+
+  function send(ev) {
+    // Responses streaming: only "data: {json}\n\n"
+    res.write(`data: ${JSON.stringify(ev)}\n\n`);
+  }
+
+  // 1) response.created
+  send({
+    type: 'response.created',
+    sequence_number: seq++,
+    response: {
+      id: responseId,
+      object: 'response',
+      created_at: createdAt,
+      status: 'in_progress',
+      output: [],
+    },
+  });
 
-  log('debug', 'Starting to process stream');
+  // 2) response.in_progress
+  send({
+    type: 'response.in_progress',
+    sequence_number: seq++,
+    response: {
+      id: responseId,
+      object: 'response',
+      created_at: createdAt,
+      status: 'in_progress',
+      output: [],
+    },
+  });
 
-  // Send initial event to create the output item - using "added" not "add"
-  const addEvent = {
+  // 3) message item added (output_index=0)
+  send({
     type: 'response.output_item.added',
+    sequence_number: seq++,
+    output_index: 0,
     item: {
       type: 'message',
+      id: messageItemId,
       role: 'assistant',
-      content: [{ type: 'output_text', text: '' }],
-      id: itemId
+      content: [],
     },
-    output_index: 0,
-    response_id: responseId
-  };
-  res.write(`data: ${JSON.stringify(addEvent)}\n\n`);
-  log('debug', 'Sent output_item.added event');
+  });
 
-  try {
-    for await (const chunk of stream) {
-      buffer += decoder.decode(chunk, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
+  async function finalizeAndClose() {
+    // done events (if we received deltas)
+    if (reasoningText) {
+      send({
+        type: 'response.reasoning_text.done',
+        sequence_number: seq++,
+        item_id: messageItemId,
+        output_index: 0,
+        content_index: 0,
+        text: reasoningText,
+      });
+    }
 
-      chunkCount++;
+    send({
+      type: 'response.output_text.done',
+      sequence_number: seq++,
+      item_id: messageItemId,
+      output_index: 0,
+      content_index: reasoningText ? 1 : 0,
+      text: outputText,
+    });
 
-      for (const line of lines) {
-        if (!line.trim() || !line.startsWith('data: ')) {
-          if (line.trim() && !line.startsWith(':')) {
-            log('debug', 'Non-data line:', line.substring(0, 50));
-          }
-          continue;
-        }
+    // close any tool call items
+    for (const [callId, st] of toolCalls.entries()) {
+      send({
+        type: 'response.function_call_arguments.done',
+        sequence_number: seq++,
+        item_id: st.itemId,
+        output_index: st.outputIndex,
+        arguments: st.args,
+      });
+
+      send({
+        type: 'response.output_item.done',
+        sequence_number: seq++,
+        output_index: st.outputIndex,
+        item: {
+          type: 'function_call',
+          id: st.itemId,
+          call_id: callId,
+          name: st.name,
+          arguments: st.args,
+        },
+      });
+    }
 
-        const data = line.slice(6).trim();
-        log('debug', 'SSE data:', data.substring(0, 100));
+    // output_item.done for message
+    const messageContent = [];
+    if (reasoningText) messageContent.push({ type: 'reasoning_text', text: reasoningText });
+    messageContent.push({ type: 'output_text', text: outputText });
 
-        // Check for stream end
-        if (data === '[DONE]') {
-          log('info', `Stream end received - wrote ${deltaCount} deltas total`);
-          didComplete = true;
-          break;
-        }
+    send({
+      type: 'response.output_item.done',
+      sequence_number: seq++,
+      output_index: 0,
+      item: {
+        type: 'message',
+        id: messageItemId,
+        role: 'assistant',
+        content: messageContent,
+      },
+    });
 
-        try {
-          const parsed = JSON.parse(data);
-          lastParsed = parsed;
-          log('debug', 'Parsed SSE:', JSON.stringify(parsed).substring(0, 150));
+    // response.completed
+    const outputItems = [
+      {
+        type: 'message',
+        id: messageItemId,
+        role: 'assistant',
+        content: messageContent,
+      },
+      ...Array.from(toolCalls.entries()).map(([callId, st]) => ({
+        type: 'function_call',
+        id: st.itemId,
+        call_id: callId,
+        name: st.name,
+        arguments: st.args,
+      })),
+    ];
+
+    send({
+      type: 'response.completed',
+      sequence_number: seq++,
+      response: {
+        id: responseId,
+        object: 'response',
+        created_at: createdAt,
+        status: 'completed',
+        output: outputItems,
+      },
+    });
 
-          const delta = parsed.choices?.[0]?.delta;
-          const content = delta?.content || delta?.reasoning_content || '';
+    // SSE terminator
+    res.write('data: [DONE]\n\n');
+    res.end();
+
+    log('info', `Stream completed - ${outputText.length} output, ${reasoningText.length} reasoning, ${toolCalls.size} tools`);
+  }
 
-          if (content) {
-            deltaCount++;
-            log('debug', 'Writing delta:', content.substring(0, 30));
-            // OpenAI Responses API format for text delta
-            const deltaEvent = {
+  try {
+    for await (const chunk of stream) {
+      buffer += chunk.toString('utf8');
+
+      // Z.ai stream: SSE lines "data: {...}\n\n"
+      let idx;
+      while ((idx = buffer.indexOf('\n\n')) !== -1) {
+        const raw = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+
+        const lines = raw.split('\n');
+        for (const line of lines) {
+          if (!line.startsWith('data:')) continue;
+          const payload = line.slice(5).trim();
+          if (!payload || payload === '[DONE]') continue;
+
+          let json;
+          try { json = JSON.parse(payload); } catch { continue; }
+
+          const choice = json?.choices?.[0];
+          const delta = choice?.delta ?? {};
+
+          // 1) reasoning
+          if (typeof delta.reasoning_content === 'string' && delta.reasoning_content.length) {
+            reasoningText += delta.reasoning_content;
+            send({
+              type: 'response.reasoning_text.delta',
+              sequence_number: seq++,
+              item_id: messageItemId,
+              output_index: 0,
+              content_index: 0,
+              delta: delta.reasoning_content,
+            });
+            log('debug', `Reasoning delta: ${delta.reasoning_content.substring(0, 30)}...`);
+          }
+
+          // 2) normal output
+          if (typeof delta.content === 'string' && delta.content.length) {
+            outputText += delta.content;
+            send({
               type: 'response.output_text.delta',
-              delta: content,
+              sequence_number: seq++,
+              item_id: messageItemId,
               output_index: 0,
-              item_id: itemId,
-              sequence_number: deltaCount - 1
-            };
-            res.write(`data: ${JSON.stringify(deltaEvent)}\n\n`);
+              content_index: reasoningText ? 1 : 0,
+              delta: delta.content,
+            });
+            log('debug', `Output delta: ${delta.content.substring(0, 30)}...`);
           }
-        } catch (e) {
-          log('warn', 'Failed to parse SSE chunk:', e.message, 'data:', data.substring(0, 100));
-        }
-      }
 
-      if (didComplete) break;
+          // 3) tool calls (OpenAI-style in chat.completions delta.tool_calls)
+          if (Array.isArray(delta.tool_calls)) {
+            for (const tc of delta.tool_calls) {
+              // tc: {id, type:"function", function:{name, arguments}}
+              const callId = tc.id || `call_${tc.index ?? 0}`;
+              const name = tc.function?.name || 'unknown';
+              const argsDelta = tc.function?.arguments || '';
+
+              let st = toolCalls.get(callId);
+              if (!st) {
+                st = {
+                  itemId: `fc_${crypto.randomUUID().replace(/-/g, '')}`,
+                  outputIndex: nextOutputIndex++,
+                  name,
+                  args: '',
+                };
+                toolCalls.set(callId, st);
+
+                send({
+                  type: 'response.output_item.added',
+                  sequence_number: seq++,
+                  output_index: st.outputIndex,
+                  item: {
+                    type: 'function_call',
+                    id: st.itemId,
+                    call_id: callId,
+                    name: st.name,
+                    arguments: '',
+                  },
+                });
+                log('debug', `Tool call added: ${name} (${callId})`);
+              }
+
+              if (argsDelta) {
+                st.args += argsDelta;
+                send({
+                  type: 'response.function_call_arguments.delta',
+                  sequence_number: seq++,
+                  item_id: st.itemId,
+                  output_index: st.outputIndex,
+                  delta: argsDelta,
+                });
+              }
+            }
+          }
 
-      if (chunkCount > 1000) {
-        log('warn', 'Too many chunks, possible loop');
-        break;
+          // 4) finish
+          if (choice?.finish_reason) {
+            log('info', `Stream finish_reason: ${choice.finish_reason}`);
+            await finalizeAndClose();
+            return;
+          }
+        }
       }
     }
   } catch (e) {
     log('error', 'Stream processing error:', e);
   }
 
-  // ALWAYS send response.completed event (even if stream ended without [DONE])
-  const zaiUsage = lastParsed?.usage;
-  const completedEvent = {
-    type: 'response.completed',
-    response: {
-      id: responseId,
-      status: 'completed',
-      output: [{
-        type: 'message',
-        role: 'assistant',
-        content: [{ type: 'output_text', text: '' }]
-      }],
-      usage: zaiUsage ? {
-        input_tokens: zaiUsage.prompt_tokens || 0,
-        output_tokens: zaiUsage.completion_tokens || 0,
-        total_tokens: zaiUsage.total_tokens || 0
-      } : {
-        input_tokens: 0,
-        output_tokens: 0,
-        total_tokens: 0
-      }
-    },
-    sequence_number: deltaCount + 1
-  };
-
-  log('info', 'Sending response.completed event');
-  res.write(`data: ${JSON.stringify(completedEvent)}\n\n`);
-  log('info', `Stream ended - wrote ${deltaCount} deltas total`);
+  // fallback (stream finished without finish_reason)
+  log('warn', 'Stream ended without finish_reason, finalizing anyway');
+  await finalizeAndClose();
 }
 
 /**
@@ -466,15 +630,16 @@ async function handlePostRequest(req, res) {
 
     if (!upstreamResponse.ok) {
       const errorBody = await upstreamResponse.text();
+      const status = upstreamResponse.status;
       log('error', 'Upstream error:', {
-        status: upstreamResponse.status,
+        status: status,
         body: errorBody.substring(0, 200)
       });
 
-      res.writeHead(502, { 'Content-Type': 'application/json' });
+      res.writeHead(status, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({
         error: 'Upstream request failed',
-        upstream_status: upstreamResponse.status,
+        upstream_status: status,
         upstream_body: errorBody
       }));
       return;
@@ -482,8 +647,8 @@ async function handlePostRequest(req, res) {
 
     // Handle streaming response
     if (upstreamBody.stream) {
-      const responseId = 'resp_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
-      const itemId = 'item_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+      const responseId = `resp_${crypto.randomUUID().replace(/-/g, '')}`;
+      const messageItemId = `msg_${crypto.randomUUID().replace(/-/g, '')}`;
       log('info', 'Starting streaming response');
       res.writeHead(200, {
         'Content-Type': 'text/event-stream; charset=utf-8',
@@ -492,16 +657,20 @@ async function handlePostRequest(req, res) {
       });
 
       try {
-        await streamChatToResponses(upstreamResponse.body, res, responseId, itemId);
+        await streamChatToResponses(upstreamResponse.body, res, responseId, messageItemId);
         log('info', 'Streaming completed');
       } catch (e) {
         log('error', 'Streaming error:', e);
       }
-      res.end();
     } else {
       // Non-streaming response
       const chatResponse = await upstreamResponse.json();
-      const response = translateChatToResponses(chatResponse);
+      const msg = chatResponse?.choices?.[0]?.message ?? {};
+      const outputText = msg.content ?? '';
+      const reasoningText = msg.reasoning_content ?? '';
+      const model = chatResponse?.model ?? upstreamBody.model ?? 'GLM';
+
+      const response = translateChatToResponses(outputText, reasoningText, null, null, model);
 
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(response));