@mmmbuto/zai-codex-bridge 0.3.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/zai-codex-bridge",
-  "version": "0.3.2",
+  "version": "0.4.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,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
  */
@@ -197,41 +239,39 @@ function translateResponsesToChat(request) {
  * Translate Chat Completions response to Responses format
  * Handles both output_text and reasoning_text content
  */
-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
+  return buildResponseObject({
+    id: responseId,
+    model: responsesRequest?.model || chatResponse.model || DEFAULT_MODEL,
+    status: 'completed',
+    created_at: createdAt,
+    completed_at: nowSec(),
+    input: responsesRequest?.input || [],
+    output: [msgItem],
+    tools: responsesRequest?.tools || [],
   });
-
-  return response;
 }
 
 /**
@@ -301,291 +341,175 @@ 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 = '';
 
-  // 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 = ids.createdAt;
+  const responseId = ids.responseId;
+  const msgId = ids.msgId;
 
-  const createdAt = Math.floor(Date.now() / 1000);
+  let seq = 1;
+  const OUTPUT_INDEX = 0;
+  const CONTENT_INDEX = 0;
 
-  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 });
 
-  // 3) message item added (output_index=0)
-  send({
+  // output_item.added + content_part.added (output_text)
+  const msgItemInProgress = {
+    id: msgId,
+    type: 'message',
+    status: 'in_progress',
+    role: 'assistant',
+    content: [],
+  };
+
+  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 terminator
-    res.write('data: [DONE]\n\n');
-    res.end();
+  sse({
+    type: 'response.content_part.added',
+    item_id: msgId,
+    output_index: OUTPUT_INDEX,
+    content_index: CONTENT_INDEX,
+    part: { type: 'output_text', text: '', annotations: [] },
+  });
 
-    log('info', `Stream completed - ${outputText.length} output, ${reasoningText.length} reasoning, ${toolCalls.size} tools`);
-  }
+  let out = '';
+  let reasoning = '';
 
-  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
+        // NON mescolare reasoning in output_text
         if (typeof delta.reasoning_content === 'string' && delta.reasoning_content.length) {
-          reasoningText += delta.reasoning_content;
-          send({
+          reasoning += delta.reasoning_content;
+          sse({
             type: 'response.reasoning_text.delta',
-            sequence_number: seq++,
-            item_id: messageItemId,
-            output_index: 0,
-            content_index: 0,
+            item_id: msgId,
+            output_index: OUTPUT_INDEX,
+            content_index: CONTENT_INDEX,
             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({
+          out += delta.content;
+          sse({
             type: 'response.output_text.delta',
-            sequence_number: seq++,
-            item_id: messageItemId,
-            output_index: 0,
-            content_index: reasoningText ? 1 : 0,
+            item_id: msgId,
+            output_index: OUTPUT_INDEX,
+            content_index: CONTENT_INDEX,
             delta: delta.content,
           });
-          log('debug', `Output delta: ${delta.content.substring(0, 30)}...`);
-        }
-
-        // 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,
-              });
-            }
-          }
-        }
-
-        // 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);
   }
 
-  // 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,
+  });
+
+  const completed = buildResponseObject({
+    id: responseId,
+    model: responsesRequest?.model || DEFAULT_MODEL,
+    status: 'completed',
+    created_at: createdAt,
+    completed_at: nowSec(),
+    input: responsesRequest?.input || [],
+    output: [msgItemDone],
+    tools: responsesRequest?.tools || [],
+  });
+
+  sse({ type: 'response.completed', response: completed });
+  res.end();
+
+  log('info', `Stream completed - ${out.length} output, ${reasoning.length} reasoning`);
 }
 
 /**
@@ -667,17 +591,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 +613,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));