@mmmbuto/zai-codex-bridge 0.3.2 → 0.4.2

package/src/server.js

@@ -11,20 +11,62 @@
  */
 
 const http = require('http');
-const crypto = require('crypto');
-const { createGunzip } = require('zlib');
-const { pipeline } = require('stream');
+const { randomUUID } = require('crypto');
 
 // Configuration from environment
 const PORT = parseInt(process.env.PORT || '31415', 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';
+const DEFAULT_MODEL = process.env.DEFAULT_MODEL || 'glm-4.7';
 
 // Env toggles for compatibility
 const ALLOW_SYSTEM = process.env.ALLOW_SYSTEM === '1';
 const ALLOW_TOOLS = process.env.ALLOW_TOOLS === '1';
 
+function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+function buildResponseObject({
+  id,
+  model,
+  status,
+  created_at,
+  completed_at = null,
+  input = [],
+  output = [],
+  tools = [],
+}) {
+  // Struttura compatibile con Responses API per Codex CLI
+  return {
+    id,
+    object: 'response',
+    created_at,
+    status,
+    completed_at,
+    error: null,
+    incomplete_details: null,
+    input,
+    instructions: null,
+    max_output_tokens: null,
+    model,
+    output,
+    previous_response_id: null,
+    reasoning_effort: null,
+    store: false,
+    temperature: 1,
+    text: { format: { type: 'text' } },
+    tool_choice: 'auto',
+    tools,
+    top_p: 1,
+    truncation: 'disabled',
+    usage: null,
+    user: null,
+    metadata: {},
+  };
+}
+
 /**
  * Logger
  */
@@ -101,18 +143,41 @@ function translateResponsesToChat(request) {
         content: request.input
       });
     } else if (Array.isArray(request.input)) {
-      // Array of ResponseItem objects - filter only Message items with role
+      // Array of ResponseItem objects
       for (const item of request.input) {
+        // Handle function_call_output items (tool responses) - only if ALLOW_TOOLS
+        if (ALLOW_TOOLS && item.type === 'function_call_output') {
+          const toolMsg = {
+            role: 'tool',
+            tool_call_id: item.call_id || item.tool_call_id || '',
+            content: ''
+          };
+
+          // Extract content from output or content field
+          if (item.output !== undefined) {
+            toolMsg.content = typeof item.output === 'string'
+              ? item.output
+              : JSON.stringify(item.output);
+          } else if (item.content !== undefined) {
+            toolMsg.content = typeof item.content === 'string'
+              ? item.content
+              : JSON.stringify(item.content);
+          }
+
+          messages.push(toolMsg);
+          continue;
+        }
+
         // Only process items with a 'role' field (Message items)
         // Skip Reasoning, FunctionCall, LocalShellCall, etc.
         if (!item.role) continue;
 
         // Map non-standard roles to Z.AI-compatible roles
-        // Z.AI accepts: system, user, assistant
+        // Z.AI accepts: system, user, assistant, tool
         let role = item.role;
         if (role === 'developer') {
           role = 'user'; // Map developer to user
-        } else if (role !== 'system' && role !== 'user' && role !== 'assistant') {
+        } else if (role !== 'system' && role !== 'user' && role !== 'assistant' && role !== 'tool') {
           // Skip any other non-standard roles
           continue;
         }
@@ -196,42 +261,62 @@ function translateResponsesToChat(request) {
 /**
  * Translate Chat Completions response to Responses format
  * Handles both output_text and reasoning_text content
+ * Handles tool_calls if present (only if ALLOW_TOOLS)
  */
-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);
+function translateChatToResponses(chatResponse, responsesRequest, ids) {
+  const msg = chatResponse.choices?.[0]?.message ?? {};
+  const outputText = msg.content ?? '';
+  const reasoningText = msg.reasoning_content ?? '';
+
+  const createdAt = ids?.createdAt ?? nowSec();
+  const responseId = ids?.responseId ?? `resp_${randomUUID().replace(/-/g, '')}`;
+  const msgId = ids?.msgId ?? `msg_${randomUUID().replace(/-/g, '')}`;
 
   const content = [];
   if (reasoningText) {
-    content.push({ type: 'reasoning_text', text: reasoningText });
+    content.push({ type: 'reasoning_text', text: reasoningText, annotations: [] });
   }
-  content.push({ type: 'output_text', text: outputText });
+  content.push({ type: 'output_text', text: outputText, annotations: [] });
 
-  const response = {
-    id: rid,
-    object: 'response',
-    created_at: createdAt,
-    model,
+  const msgItem = {
+    id: msgId,
+    type: 'message',
     status: 'completed',
-    output: [
-      {
-        type: 'message',
-        id: mid,
-        role: 'assistant',
-        content
-      }
-    ]
+    role: 'assistant',
+    content,
   };
 
-  log('debug', 'Translated Chat->Responses:', {
-    id: response.id,
-    outputLength: outputText.length,
-    reasoningLength: reasoningText.length,
-    status: response.status
-  });
+  // Build output array: message item + any function_call items
+  const finalOutput = [msgItem];
 
-  return response;
+  // Handle tool_calls (only if ALLOW_TOOLS)
+  if (ALLOW_TOOLS && msg.tool_calls && Array.isArray(msg.tool_calls)) {
+    for (const tc of msg.tool_calls) {
+      const callId = tc.id || `call_${randomUUID().replace(/-/g, '')}`;
+      const name = tc.function?.name || '';
+      const args = tc.function?.arguments || '';
+
+      finalOutput.push({
+        id: callId,
+        type: 'function_call',
+        status: 'completed',
+        call_id: callId,
+        name: name,
+        arguments: typeof args === 'string' ? args : JSON.stringify(args),
+      });
+    }
+  }
+
+  return buildResponseObject({
+    id: responseId,
+    model: responsesRequest?.model || chatResponse.model || DEFAULT_MODEL,
+    status: 'completed',
+    created_at: createdAt,
+    completed_at: nowSec(),
+    input: responsesRequest?.input || [],
+    output: finalOutput,
+    tools: responsesRequest?.tools || [],
+  });
 }
 
 /**
@@ -301,291 +386,294 @@ async function makeUpstreamRequest(path, body, headers) {
  * 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, messageItemId) {
+async function streamChatToResponses(upstreamBody, res, responsesRequest, ids) {
+  const decoder = new TextDecoder();
+  const reader = upstreamBody.getReader();
   let buffer = '';
-  let seq = 0;
 
-  let outputText = '';
-  let reasoningText = '';
+  const createdAt = ids.createdAt;
+  const responseId = ids.responseId;
+  const msgId = ids.msgId;
 
-  // 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
+  let seq = 1;
+  const OUTPUT_INDEX = 0;
+  const CONTENT_INDEX = 0;
 
-  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`);
+  function sse(obj) {
+    if (obj.sequence_number == null) obj.sequence_number = seq++;
+    res.write(`data: ${JSON.stringify(obj)}\n\n`);
   }
 
-  // 1) response.created
-  send({
-    type: 'response.created',
-    sequence_number: seq++,
-    response: {
-      id: responseId,
-      object: 'response',
-      created_at: createdAt,
-      status: 'in_progress',
-      output: [],
-    },
+  // response.created / response.in_progress
+  const baseResp = buildResponseObject({
+    id: responseId,
+    model: responsesRequest?.model || DEFAULT_MODEL,
+    status: 'in_progress',
+    created_at: createdAt,
+    completed_at: null,
+    input: responsesRequest?.input || [],
+    output: [],
+    tools: responsesRequest?.tools || [],
   });
 
-  // 2) response.in_progress
-  send({
-    type: 'response.in_progress',
-    sequence_number: seq++,
-    response: {
-      id: responseId,
-      object: 'response',
-      created_at: createdAt,
-      status: 'in_progress',
-      output: [],
-    },
-  });
+  sse({ type: 'response.created', response: baseResp });
+  sse({ type: 'response.in_progress', response: baseResp });
+
+  // output_item.added + content_part.added (output_text)
+  const msgItemInProgress = {
+    id: msgId,
+    type: 'message',
+    status: 'in_progress',
+    role: 'assistant',
+    content: [],
+  };
 
-  // 3) message item added (output_index=0)
-  send({
+  sse({
     type: 'response.output_item.added',
-    sequence_number: seq++,
-    output_index: 0,
-    item: {
-      type: 'message',
-      id: messageItemId,
-      role: 'assistant',
-      content: [],
-    },
+    output_index: OUTPUT_INDEX,
+    item: msgItemInProgress,
   });
 
-  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,
-      });
-    }
-
-    send({
-      type: 'response.output_text.done',
-      sequence_number: seq++,
-      item_id: messageItemId,
-      output_index: 0,
-      content_index: reasoningText ? 1 : 0,
-      text: outputText,
-    });
-
-    // 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,
-        },
-      });
-    }
-
-    // output_item.done for message
-    const messageContent = [];
-    if (reasoningText) messageContent.push({ type: 'reasoning_text', text: reasoningText });
-    messageContent.push({ type: 'output_text', text: outputText });
-
-    send({
-      type: 'response.output_item.done',
-      sequence_number: seq++,
-      output_index: 0,
-      item: {
-        type: 'message',
-        id: messageItemId,
-        role: 'assistant',
-        content: messageContent,
-      },
-    });
-
-    // 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,
-      },
-    });
+  sse({
+    type: 'response.content_part.added',
+    item_id: msgId,
+    output_index: OUTPUT_INDEX,
+    content_index: CONTENT_INDEX,
+    part: { type: 'output_text', text: '', annotations: [] },
+  });
 
-    // SSE terminator
-    res.write('data: [DONE]\n\n');
-    res.end();
+  let out = '';
+  let reasoning = '';
 
-    log('info', `Stream completed - ${outputText.length} output, ${reasoningText.length} reasoning, ${toolCalls.size} tools`);
-  }
+  // Tool call tracking (only if ALLOW_TOOLS)
+  const toolCallsMap = new Map(); // index -> { callId, name, arguments, partialArgs }
+  let nextOutputIndex = 1; // After message item
 
-  try {
-    for await (const chunk of stream) {
-      const chunkStr = Buffer.from(chunk).toString('utf8');
-      buffer += chunkStr;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
 
-      // Z.ai stream: SSE lines "data: {...}\n"
-      // Split by newline and process each complete line
-      const lines = buffer.split('\n');
-      // Keep the last line if it's incomplete (doesn't end with data pattern)
-      buffer = lines.pop() || '';
+    buffer += decoder.decode(value, { stream: true });
+    const events = buffer.split('\n\n');
+    buffer = events.pop() || '';
 
+    for (const evt of events) {
+      const lines = evt.split('\n');
       for (const line of lines) {
-        if (!line.trim() || !line.startsWith('data:')) {
-          // Skip empty lines and comments (starting with :)
-          if (line.trim() && !line.startsWith(':')) {
-            log('debug', 'Non-data line:', line.substring(0, 50));
-          }
-          continue;
-        }
-
+        if (!line.startsWith('data:')) continue;
         const payload = line.slice(5).trim();
+        if (!payload) continue;
         if (payload === '[DONE]') {
-          log('info', 'Stream received [DONE]');
-          await finalizeAndClose();
-          return;
+          // termina upstream
+          continue;
         }
 
-        if (!payload) continue;
-
-        let json;
+        let chunk;
         try {
-          json = JSON.parse(payload);
-        } catch (e) {
-          log('warn', 'Failed to parse SSE payload:', e.message, 'payload:', payload.substring(0, 100));
+          chunk = JSON.parse(payload);
+        } catch {
           continue;
         }
 
-        const choice = json?.choices?.[0];
-        const delta = choice?.delta ?? {};
+        const delta = chunk.choices?.[0]?.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)}...`);
-        }
+        // Handle tool_calls (only if ALLOW_TOOLS)
+        if (ALLOW_TOOLS && delta.tool_calls && Array.isArray(delta.tool_calls)) {
+          for (const tc of delta.tool_calls) {
+            const index = tc.index;
+            if (index == null) continue;
 
-        // 2) normal output
-        if (typeof delta.content === 'string' && delta.content.length) {
-          outputText += delta.content;
-          send({
-            type: 'response.output_text.delta',
-            sequence_number: seq++,
-            item_id: messageItemId,
-            output_index: 0,
-            content_index: reasoningText ? 1 : 0,
-            delta: delta.content,
-          });
-          log('debug', `Output delta: ${delta.content.substring(0, 30)}...`);
-        }
+            if (!toolCallsMap.has(index)) {
+              // New tool call - send output_item.added
+              const callId = tc.id || `call_${randomUUID().replace(/-/g, '')}`;
+              const name = tc.function?.name || '';
 
-        // 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++,
+              toolCallsMap.set(index, {
+                callId,
                 name,
-                args: '',
+                arguments: '',
+                partialArgs: ''
+              });
+
+              const fnItemInProgress = {
+                id: callId,
+                type: 'function_call',
+                status: 'in_progress',
+                call_id: callId,
+                name: name,
+                arguments: '',
               };
-              toolCalls.set(callId, st);
 
-              send({
+              sse({
                 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: '',
-                },
+                output_index: nextOutputIndex,
+                item: fnItemInProgress,
+              });
+
+              if (name) {
+                sse({
+                  type: 'response.function_call_name.done',
+                  item_id: callId,
+                  output_index: nextOutputIndex,
+                  name: name,
+                });
+              }
+            }
+
+            const tcData = toolCallsMap.get(index);
+
+            // Handle name update if it comes later
+            if (tc.function?.name && !tcData.name) {
+              tcData.name = tc.function.name;
+              sse({
+                type: 'response.function_call_name.done',
+                item_id: tcData.callId,
+                output_index: OUTPUT_INDEX + index,
+                name: tcData.name,
               });
-              log('debug', `Tool call added: ${name} (${callId})`);
             }
 
-            if (argsDelta) {
-              st.args += argsDelta;
-              send({
+            // Handle arguments delta
+            if (tc.function?.arguments && typeof tc.function.arguments === 'string') {
+              tcData.partialArgs += tc.function.arguments;
+
+              sse({
                 type: 'response.function_call_arguments.delta',
-                sequence_number: seq++,
-                item_id: st.itemId,
-                output_index: st.outputIndex,
-                delta: argsDelta,
+                item_id: tcData.callId,
+                output_index: OUTPUT_INDEX + index,
+                delta: tc.function.arguments,
+              });
+            }
+
+            // Check if this tool call is done (finish_reason comes later in the choice)
+            const finishReason = chunk.choices?.[0]?.finish_reason;
+            if (finishReason === 'tool_calls' || (tc.function?.arguments && tc.function.arguments.length > 0 && chunk.choices?.[0]?.delta !== null)) {
+              tcData.arguments = tcData.partialArgs;
+
+              sse({
+                type: 'response.function_call_arguments.done',
+                item_id: tcData.callId,
+                output_index: OUTPUT_INDEX + index,
+                arguments: tcData.arguments,
+              });
+
+              const fnItemDone = {
+                id: tcData.callId,
+                type: 'function_call',
+                status: 'completed',
+                call_id: tcData.callId,
+                name: tcData.name,
+                arguments: tcData.arguments,
+              };
+
+              sse({
+                type: 'response.output_item.done',
+                output_index: OUTPUT_INDEX + index,
+                item: fnItemDone,
               });
             }
           }
+          // Skip to next iteration after handling tool_calls
+          continue;
         }
 
-        // 4) finish
-        if (choice?.finish_reason) {
-          log('info', `Stream finish_reason: ${choice.finish_reason}`);
-          await finalizeAndClose();
-          return;
+        // NON mescolare reasoning in output_text
+        if (typeof delta.reasoning_content === 'string' && delta.reasoning_content.length) {
+          reasoning += delta.reasoning_content;
+          sse({
+            type: 'response.reasoning_text.delta',
+            item_id: msgId,
+            output_index: OUTPUT_INDEX,
+            content_index: CONTENT_INDEX,
+            delta: delta.reasoning_content,
+          });
+        }
+
+        if (typeof delta.content === 'string' && delta.content.length) {
+          out += delta.content;
+          sse({
+            type: 'response.output_text.delta',
+            item_id: msgId,
+            output_index: OUTPUT_INDEX,
+            content_index: CONTENT_INDEX,
+            delta: delta.content,
+          });
         }
       }
     }
-  } catch (e) {
-    log('error', 'Stream processing error:', e);
   }
 
-  // fallback (stream finished without finish_reason)
-  log('warn', 'Stream ended without finish_reason, finalizing anyway');
-  await finalizeAndClose();
+  // done events
+  if (reasoning.length) {
+    sse({
+      type: 'response.reasoning_text.done',
+      item_id: msgId,
+      output_index: OUTPUT_INDEX,
+      content_index: CONTENT_INDEX,
+      text: reasoning,
+    });
+  }
+
+  sse({
+    type: 'response.output_text.done',
+    item_id: msgId,
+    output_index: OUTPUT_INDEX,
+    content_index: CONTENT_INDEX,
+    text: out,
+  });
+
+  sse({
+    type: 'response.content_part.done',
+    item_id: msgId,
+    output_index: OUTPUT_INDEX,
+    content_index: CONTENT_INDEX,
+    part: { type: 'output_text', text: out, annotations: [] },
+  });
+
+  const msgItemDone = {
+    id: msgId,
+    type: 'message',
+    status: 'completed',
+    role: 'assistant',
+    content: [{ type: 'output_text', text: out, annotations: [] }],
+  };
+
+  sse({
+    type: 'response.output_item.done',
+    output_index: OUTPUT_INDEX,
+    item: msgItemDone,
+  });
+
+  // Build final output array: message item + any function_call items
+  const finalOutput = [msgItemDone];
+  if (ALLOW_TOOLS && toolCallsMap.size > 0) {
+    for (const [index, tcData] of toolCallsMap.entries()) {
+      finalOutput.push({
+        id: tcData.callId,
+        type: 'function_call',
+        status: 'completed',
+        call_id: tcData.callId,
+        name: tcData.name,
+        arguments: tcData.arguments,
+      });
+    }
+  }
+
+  const completed = buildResponseObject({
+    id: responseId,
+    model: responsesRequest?.model || DEFAULT_MODEL,
+    status: 'completed',
+    created_at: createdAt,
+    completed_at: nowSec(),
+    input: responsesRequest?.input || [],
+    output: finalOutput,
+    tools: responsesRequest?.tools || [],
+  });
+
+  sse({ type: 'response.completed', response: completed });
+  res.end();
+
+  log('info', `Stream completed - ${out.length} output, ${reasoning.length} reasoning, ${toolCallsMap.size} tool_calls`);
 }
 
 /**
@@ -667,17 +755,21 @@ async function handlePostRequest(req, res) {
 
     // Handle streaming response
     if (upstreamBody.stream) {
-      const responseId = `resp_${crypto.randomUUID().replace(/-/g, '')}`;
-      const messageItemId = `msg_${crypto.randomUUID().replace(/-/g, '')}`;
+      const ids = {
+        createdAt: nowSec(),
+        responseId: `resp_${randomUUID().replace(/-/g, '')}`,
+        msgId: `msg_${randomUUID().replace(/-/g, '')}`,
+      };
       log('info', 'Starting streaming response');
       res.writeHead(200, {
         'Content-Type': 'text/event-stream; charset=utf-8',
         'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive'
+        'Connection': 'keep-alive',
+        'X-Accel-Buffering': 'no',
       });
 
       try {
-        await streamChatToResponses(upstreamResponse.body, res, responseId, messageItemId);
+        await streamChatToResponses(upstreamResponse.body, res, request, ids);
         log('info', 'Streaming completed');
       } catch (e) {
         log('error', 'Streaming error:', e);
@@ -685,12 +777,14 @@ async function handlePostRequest(req, res) {
     } else {
       // Non-streaming response
       const chatResponse = await upstreamResponse.json();
-      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);
+      const ids = {
+        createdAt: nowSec(),
+        responseId: `resp_${randomUUID().replace(/-/g, '')}`,
+        msgId: `msg_${randomUUID().replace(/-/g, '')}`,
+      };
+
+      const response = translateChatToResponses(chatResponse, request, ids);
 
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(response));