@mmmbuto/zai-codex-bridge 0.1.13 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/zai-codex-bridge",
-  "version": "0.1.13",
+  "version": "0.2.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

@@ -18,6 +18,10 @@ const HOST = process.env.HOST || '127.0.0.1';
 const ZAI_BASE_URL = process.env.ZAI_BASE_URL || 'https://api.z.ai/api/coding/paas/v4';
 const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
 
+// Env toggles for compatibility
+const ALLOW_SYSTEM = process.env.ALLOW_SYSTEM === '1';
+const ALLOW_TOOLS = process.env.ALLOW_TOOLS === '1';
+
 /**
  * Logger
  */
@@ -42,18 +46,22 @@ function detectFormat(body) {
 }
 
 /**
- * Flatten content parts to string
+ * Flatten content parts to string - supports text, input_text, output_text
  */
 function flattenContent(content) {
   if (typeof content === 'string') {
     return content;
   }
   if (Array.isArray(content)) {
-    const textParts = content
-      .filter(part => part.type === 'text' && part.text)
-      .map(part => part.text);
-    return textParts.length > 0 ? textParts.join('\n') : JSON.stringify(content);
+    const texts = content
+      .filter(p =>
+        (p && (p.type === 'text' || p.type === 'input_text' || p.type === 'output_text')) && p.text
+      )
+      .map(p => p.text);
+    if (texts.length) return texts.join('\n');
+    try { return JSON.stringify(content); } catch { return String(content); }
   }
+  if (content == null) return '';
   return String(content);
 }
 
@@ -63,12 +71,22 @@ function flattenContent(content) {
 function translateResponsesToChat(request) {
   const messages = [];
 
-  // Add system message from instructions
+  // Add system message from instructions (with ALLOW_SYSTEM toggle)
   if (request.instructions) {
-    messages.push({
-      role: 'system',
-      content: request.instructions
-    });
+    if (ALLOW_SYSTEM) {
+      messages.push({
+        role: 'system',
+        content: request.instructions
+      });
+    } else {
+      // Prepend to first user message for Z.ai compatibility
+      const instr = String(request.instructions).trim();
+      if (messages.length && messages[0].role === 'user') {
+        messages[0].content = `[INSTRUCTIONS]\n${instr}\n[/INSTRUCTIONS]\n\n${messages[0].content || ''}`;
+      } else {
+        messages.unshift({ role: 'user', content: `[INSTRUCTIONS]\n${instr}\n[/INSTRUCTIONS]` });
+      }
+    }
   }
 
   // Handle input: can be string (simple user message) or array (message history)
@@ -101,13 +119,13 @@ function translateResponsesToChat(request) {
           content: flattenContent(item.content)
         };
 
-        // Handle tool calls if present
-        if (item.tool_calls && Array.isArray(item.tool_calls)) {
+        // Handle tool calls if present (only if ALLOW_TOOLS)
+        if (ALLOW_TOOLS && item.tool_calls && Array.isArray(item.tool_calls)) {
           msg.tool_calls = item.tool_calls;
         }
 
-        // Handle tool call ID for tool responses
-        if (item.tool_call_id) {
+        // Handle tool call ID for tool responses (only if ALLOW_TOOLS)
+        if (ALLOW_TOOLS && item.tool_call_id) {
           msg.tool_call_id = item.tool_call_id;
         }
 
@@ -140,7 +158,8 @@ function translateResponsesToChat(request) {
     chatRequest.top_p = request.top_p;
   }
 
-  if (request.tools && Array.isArray(request.tools)) {
+  // Tools handling (only if ALLOW_TOOLS)
+  if (ALLOW_TOOLS && request.tools && Array.isArray(request.tools)) {
     // Filter out tools with null or empty function
     chatRequest.tools = request.tools.filter(tool => {
       if (tool.type === 'function') {
@@ -158,7 +177,7 @@ function translateResponsesToChat(request) {
     }
   }
 
-  if (request.tool_choice) {
+  if (ALLOW_TOOLS && request.tool_choice) {
     chatRequest.tool_choice = request.tool_choice;
   }
 
@@ -273,12 +292,13 @@ async function streamChatToResponses(stream, res, responseId, itemId) {
   let chunkCount = 0;
   let deltaCount = 0;
   let lastParsed = null;
+  let didComplete = false;
 
   log('debug', 'Starting to process stream');
 
-  // Send initial event to create the output item
+  // Send initial event to create the output item - using "added" not "add"
   const addEvent = {
-    type: 'response.output_item.add',
+    type: 'response.output_item.added',
     item: {
       type: 'message',
       role: 'assistant',
@@ -289,104 +309,113 @@ async function streamChatToResponses(stream, res, responseId, itemId) {
     response_id: responseId
   };
   res.write(`data: ${JSON.stringify(addEvent)}\n\n`);
-  log('debug', 'Sent output_item.add event');
-
-  for await (const chunk of stream) {
-    buffer += decoder.decode(chunk, { stream: true });
-    const lines = buffer.split('\n');
-    buffer = lines.pop() || '';
+  log('debug', 'Sent output_item.added event');
 
-    chunkCount++;
-
-    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));
+  try {
+    for await (const chunk of stream) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      chunkCount++;
+
+      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;
         }
-        continue;
-      }
 
-      const data = line.slice(6).trim();
-      log('debug', 'SSE data:', data.substring(0, 100));
-
-      // Check for stream end
-      if (data === '[DONE]') {
-        log('info', `Stream end received - wrote ${deltaCount} deltas total`);
-
-        // Send response.completed event in OpenAI Responses API format
-        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
-        };
+        const data = line.slice(6).trim();
+        log('debug', 'SSE data:', data.substring(0, 100));
 
-        log('info', 'Sending response.completed event');
-        res.write(`data: ${JSON.stringify(completedEvent)}\n\n`);
-        log('info', 'Sent response.completed event');
-        return;
-      }
+        // Check for stream end
+        if (data === '[DONE]') {
+          log('info', `Stream end received - wrote ${deltaCount} deltas total`);
+          didComplete = true;
+          break;
+        }
 
-      try {
-        const parsed = JSON.parse(data);
-        lastParsed = parsed;
-        log('debug', 'Parsed SSE:', JSON.stringify(parsed).substring(0, 150));
-
-        const delta = parsed.choices?.[0]?.delta;
-        const content = delta?.content || delta?.reasoning_content || '';
-
-        if (content) {
-          deltaCount++;
-          log('debug', 'Writing delta:', content.substring(0, 30));
-          // OpenAI Responses API format for text delta
-          const deltaEvent = {
-            type: 'response.output_text.delta',
-            delta: content,
-            output_index: 0,
-            item_id: itemId,
-            sequence_number: deltaCount - 1
-          };
-          res.write(`data: ${JSON.stringify(deltaEvent)}\n\n`);
+        try {
+          const parsed = JSON.parse(data);
+          lastParsed = parsed;
+          log('debug', 'Parsed SSE:', JSON.stringify(parsed).substring(0, 150));
+
+          const delta = parsed.choices?.[0]?.delta;
+          const content = delta?.content || delta?.reasoning_content || '';
+
+          if (content) {
+            deltaCount++;
+            log('debug', 'Writing delta:', content.substring(0, 30));
+            // OpenAI Responses API format for text delta
+            const deltaEvent = {
+              type: 'response.output_text.delta',
+              delta: content,
+              output_index: 0,
+              item_id: itemId,
+              sequence_number: deltaCount - 1
+            };
+            res.write(`data: ${JSON.stringify(deltaEvent)}\n\n`);
+          }
+        } catch (e) {
+          log('warn', 'Failed to parse SSE chunk:', e.message, 'data:', data.substring(0, 100));
         }
-      } catch (e) {
-        log('warn', 'Failed to parse SSE chunk:', e.message, 'data:', data.substring(0, 100));
       }
-    }
 
-    if (chunkCount > 1000) {
-      log('warn', 'Too many chunks, possible loop');
-      return;
+      if (didComplete) break;
+
+      if (chunkCount > 1000) {
+        log('warn', 'Too many chunks, possible loop');
+        break;
+      }
     }
+  } catch (e) {
+    log('error', 'Stream processing error:', e);
   }
 
-  log('info', `Stream ended naturally - wrote ${deltaCount} deltas`);
+  // 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`);
 }
 
 /**
  * Handle POST requests
  */
 async function handlePostRequest(req, res) {
-  const path = req.url;
+  // Use normalized pathname instead of raw req.url
+  const { pathname: path } = new URL(req.url, 'http://127.0.0.1');
 
-  // Only handle /responses and /v1/responses
-  if (!path.endsWith('/responses') && !path.endsWith('/v1/responses')) {
+  // Handle both /responses and /v1/responses, /chat/completions and /v1/chat/completions
+  const isResponses = (path === '/responses' || path === '/v1/responses');
+  const isChat = (path === '/chat/completions' || path === '/v1/chat/completions');
+
+  if (!isResponses && !isChat) {
     res.writeHead(404, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ error: 'Not Found', path }));
     return;
@@ -488,16 +517,32 @@ async function handlePostRequest(req, res) {
  * Create HTTP server
  */
 const server = http.createServer(async (req, res) => {
-  log('debug', 'Request:', req.method, req.url);
+  // Use normalized pathname
+  const { pathname } = new URL(req.url, 'http://127.0.0.1');
+
+  log('debug', 'Request:', req.method, pathname);
 
   // Health check
-  if (req.url === '/health' && req.method === 'GET') {
+  if (pathname === '/health' && req.method === 'GET') {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ ok: true }));
     return;
   }
 
-  // POST /responses
+  // Models endpoint (Codex often calls /v1/models)
+  if ((pathname === '/v1/models' || pathname === '/models') && req.method === 'GET') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      object: 'list',
+      data: [
+        { id: 'GLM-4.7', object: 'model' },
+        { id: 'glm-4.7', object: 'model' }
+      ]
+    }));
+    return;
+  }
+
+  // POST requests
   if (req.method === 'POST') {
     await handlePostRequest(req, res);
     return;
@@ -515,4 +560,5 @@ server.listen(PORT, HOST, () => {
   log('info', `zai-codex-bridge listening on http://${HOST}:${PORT}`);
   log('info', `Proxying to Z.AI at: ${ZAI_BASE_URL}`);
   log('info', `Health check: http://${HOST}:${PORT}/health`);
+  log('info', `Models endpoint: http://${HOST}:${PORT}/v1/models`);
 });