@corbat-tech/coco 2.12.0 → 2.13.0

package/dist/index.js

@@ -12527,7 +12527,7 @@ var OpenAIProvider = class {
         once: true
       });
       const providerName = this.name;
-      const parseArguments = (builder) => {
+      const parseArguments2 = (builder) => {
         let input = {};
         try {
           input = builder.arguments ? JSON.parse(builder.arguments) : {};
@@ -12608,7 +12608,7 @@ var OpenAIProvider = class {
                 toolCall: {
                   id: builder.id,
                   name: builder.name,
-                  input: parseArguments(builder)
+                  input: parseArguments2(builder)
                 }
               };
             }
@@ -12621,7 +12621,7 @@ var OpenAIProvider = class {
             toolCall: {
               id: builder.id,
               name: builder.name,
-              input: parseArguments(builder)
+              input: parseArguments2(builder)
             }
           };
         }
@@ -13623,6 +13623,7 @@ var CONTEXT_WINDOWS3 = {
   "gpt-5.2": 2e5,
   "gpt-5.1": 2e5
 };
+var STREAM_TIMEOUT_MS = 12e4;
 function parseJwtClaims(token) {
   const parts = token.split(".");
   if (parts.length !== 3 || !parts[1]) return void 0;
@@ -13638,12 +13639,28 @@ function extractAccountId(accessToken) {
   const auth = claims["https://api.openai.com/auth"];
   return claims["chatgpt_account_id"] || auth?.["chatgpt_account_id"] || claims["organizations"]?.[0]?.id;
 }
+function parseArguments(args) {
+  try {
+    return args ? JSON.parse(args) : {};
+  } catch {
+    try {
+      if (args) {
+        const repaired = jsonrepair(args);
+        return JSON.parse(repaired);
+      }
+    } catch {
+      console.error(`[Codex] Cannot parse tool arguments: ${args.slice(0, 200)}`);
+    }
+    return {};
+  }
+}
 var CodexProvider = class {
   id = "codex";
   name = "OpenAI Codex (ChatGPT Plus/Pro)";
   config = {};
   accessToken = null;
   accountId;
+  retryConfig = DEFAULT_RETRY_CONFIG;
   /**
    * Initialize the provider with OAuth tokens
    */
@@ -13728,166 +13745,466 @@ var CodexProvider = class {
   /**
    * Extract text content from a message
    */
-  extractTextContent(msg) {
-    if (typeof msg.content === "string") {
-      return msg.content;
-    }
-    if (Array.isArray(msg.content)) {
-      return msg.content.map((part) => {
-        if (part.type === "text") return part.text;
-        if (part.type === "tool_result") return `Tool result: ${JSON.stringify(part.content)}`;
-        return "";
-      }).join("\n");
+  contentToString(content) {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
     }
     return "";
   }
   /**
-   * Convert messages to Codex Responses API format
-   * Codex uses a different format than Chat Completions:
-   * {
-   *   "input": [
-   *     { "type": "message", "role": "developer|user", "content": [{ "type": "input_text", "text": "..." }] },
-   *     { "type": "message", "role": "assistant", "content": [{ "type": "output_text", "text": "..." }] }
-   *   ]
-   * }
+   * Convert messages to Responses API input format.
    *
-   * IMPORTANT: User/developer messages use "input_text", assistant messages use "output_text"
+   * Handles:
+   * - system messages → extracted as instructions
+   * - user text messages → { role: "user", content: "..." }
+   * - user tool_result messages → function_call_output items
+   * - assistant text → { role: "assistant", content: "..." }
+   * - assistant tool_use → function_call items
    */
-  convertMessagesToResponsesFormat(messages) {
-    return messages.map((msg) => {
-      const text = this.extractTextContent(msg);
-      const role = msg.role === "system" ? "developer" : msg.role;
-      const contentType = msg.role === "assistant" ? "output_text" : "input_text";
-      return {
-        type: "message",
-        role,
-        content: [{ type: contentType, text }]
-      };
-    });
+  convertToResponsesInput(messages, systemPrompt) {
+    const input = [];
+    let instructions = systemPrompt ?? null;
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        instructions = (instructions ? instructions + "\n\n" : "") + this.contentToString(msg.content);
+      } else if (msg.role === "user") {
+        if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "tool_result")) {
+          for (const block of msg.content) {
+            if (block.type === "tool_result") {
+              const tr = block;
+              input.push({
+                type: "function_call_output",
+                call_id: tr.tool_use_id,
+                output: tr.content
+              });
+            }
+          }
+        } else {
+          input.push({
+            role: "user",
+            content: this.contentToString(msg.content)
+          });
+        }
+      } else if (msg.role === "assistant") {
+        if (typeof msg.content === "string") {
+          input.push({ role: "assistant", content: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          const textParts = [];
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              textParts.push(block.text);
+            } else if (block.type === "tool_use") {
+              if (textParts.length > 0) {
+                input.push({ role: "assistant", content: textParts.join("") });
+                textParts.length = 0;
+              }
+              const tu = block;
+              input.push({
+                type: "function_call",
+                call_id: tu.id,
+                name: tu.name,
+                arguments: JSON.stringify(tu.input)
+              });
+            }
+          }
+          if (textParts.length > 0) {
+            input.push({ role: "assistant", content: textParts.join("") });
+          }
+        }
+      }
+    }
+    return { input, instructions };
   }
   /**
-   * Send a chat message using Codex Responses API format
+   * Convert tool definitions to Responses API function tool format
    */
-  async chat(messages, options) {
-    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
-    const systemMsg = messages.find((m) => m.role === "system");
-    const instructions = systemMsg ? this.extractTextContent(systemMsg) : "You are a helpful coding assistant.";
-    const inputMessages = messages.filter((m) => m.role !== "system").map((msg) => this.convertMessagesToResponsesFormat([msg])[0]);
+  convertTools(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description ?? void 0,
+      parameters: tool.input_schema ?? null,
+      strict: false
+    }));
+  }
+  /**
+   * Build the request body for the Codex Responses API
+   */
+  buildRequestBody(model, input, instructions, options) {
     const body = {
       model,
-      instructions,
-      input: inputMessages,
-      tools: [],
+      input,
+      instructions: instructions ?? "You are a helpful coding assistant.",
+      max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+      temperature: options?.temperature ?? this.config.temperature ?? 0,
       store: false,
       stream: true
       // Codex API requires streaming
     };
-    const response = await this.makeRequest(body);
+    if (options?.tools && options.tools.length > 0) {
+      body.tools = this.convertTools(options.tools);
+    }
+    return body;
+  }
+  /**
+   * Read SSE stream and call handler for each parsed event.
+   * Returns when stream ends.
+   */
+  async readSSEStream(response, onEvent) {
     if (!response.body) {
-      throw new ProviderError("No response body from Codex API", {
-        provider: this.id
-      });
+      throw new ProviderError("No response body from Codex API", { provider: this.id });
     }
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    let content = "";
-    let responseId = `codex-${Date.now()}`;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let status = "completed";
+    let lastActivityTime = Date.now();
+    const timeoutController = new AbortController();
+    const timeoutInterval = setInterval(() => {
+      if (Date.now() - lastActivityTime > STREAM_TIMEOUT_MS) {
+        clearInterval(timeoutInterval);
+        timeoutController.abort();
+      }
+    }, 5e3);
     try {
       while (true) {
+        if (timeoutController.signal.aborted) break;
         const { done, value } = await reader.read();
         if (done) break;
+        lastActivityTime = Date.now();
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6).trim();
-            if (!data || data === "[DONE]") continue;
-            try {
-              const parsed = JSON.parse(data);
-              if (parsed.id) {
-                responseId = parsed.id;
-              }
-              if (parsed.type === "response.output_text.delta" && parsed.delta) {
-                content += parsed.delta;
-              } else if (parsed.type === "response.completed" && parsed.response) {
-                if (parsed.response.usage) {
-                  inputTokens = parsed.response.usage.input_tokens ?? 0;
-                  outputTokens = parsed.response.usage.output_tokens ?? 0;
-                }
-                status = parsed.response.status ?? "completed";
-              } else if (parsed.type === "response.output_text.done" && parsed.text) {
-                content = parsed.text;
-              }
-            } catch {
-            }
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (!data || data === "[DONE]") continue;
+          try {
+            onEvent(JSON.parse(data));
+          } catch {
           }
         }
       }
     } finally {
+      clearInterval(timeoutInterval);
       reader.releaseLock();
     }
-    if (!content) {
-      throw new ProviderError("No response content from Codex API", {
-        provider: this.id
-      });
+    if (timeoutController.signal.aborted) {
+      throw new Error(
+        `Stream timeout: No response from Codex API for ${STREAM_TIMEOUT_MS / 1e3}s`
+      );
     }
-    const stopReason = status === "completed" ? "end_turn" : status === "incomplete" ? "max_tokens" : "end_turn";
-    return {
-      id: responseId,
-      content,
-      stopReason,
-      model,
-      usage: {
-        inputTokens,
-        outputTokens
-      }
-    };
   }
   /**
-   * Send a chat message with tool use
-   * Note: Codex Responses API tool support is complex; for now we delegate to chat()
-   * and return empty toolCalls. Full tool support can be added later.
+   * Send a chat message using Codex Responses API format
+   */
+  async chat(messages, options) {
+    return withRetry(async () => {
+      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+      const body = this.buildRequestBody(model, input, instructions, {
+        maxTokens: options?.maxTokens,
+        temperature: options?.temperature
+      });
+      const response = await this.makeRequest(body);
+      let content = "";
+      let responseId = `codex-${Date.now()}`;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let status = "completed";
+      await this.readSSEStream(response, (event) => {
+        if (event.id) responseId = event.id;
+        if (event.type === "response.output_text.delta" && event.delta) {
+          content += event.delta;
+        } else if (event.type === "response.output_text.done" && event.text) {
+          content = event.text;
+        } else if (event.type === "response.completed" && event.response) {
+          const resp = event.response;
+          const usage = resp.usage;
+          if (usage) {
+            inputTokens = usage.input_tokens ?? 0;
+            outputTokens = usage.output_tokens ?? 0;
+          }
+          status = resp.status ?? "completed";
+        }
+      });
+      const stopReason = status === "completed" ? "end_turn" : status === "incomplete" ? "max_tokens" : "end_turn";
+      return {
+        id: responseId,
+        content,
+        stopReason,
+        model,
+        usage: { inputTokens, outputTokens }
+      };
+    }, this.retryConfig);
+  }
+  /**
+   * Send a chat message with tool use via Responses API
    */
   async chatWithTools(messages, options) {
-    const response = await this.chat(messages, options);
-    return {
-      ...response,
-      toolCalls: []
-      // Tools not yet supported in Codex provider
-    };
+    return withRetry(async () => {
+      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+      const body = this.buildRequestBody(model, input, instructions, {
+        tools: options.tools,
+        maxTokens: options?.maxTokens
+      });
+      const response = await this.makeRequest(body);
+      let content = "";
+      let responseId = `codex-${Date.now()}`;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      const toolCalls = [];
+      const fnCallBuilders = /* @__PURE__ */ new Map();
+      await this.readSSEStream(response, (event) => {
+        if (event.id) responseId = event.id;
+        switch (event.type) {
+          case "response.output_text.delta":
+            content += event.delta ?? "";
+            break;
+          case "response.output_text.done":
+            content = event.text ?? content;
+            break;
+          case "response.output_item.added": {
+            const item = event.item;
+            if (item.type === "function_call") {
+              const itemKey = item.id ?? item.call_id;
+              fnCallBuilders.set(itemKey, {
+                callId: item.call_id,
+                name: item.name,
+                arguments: ""
+              });
+            }
+            break;
+          }
+          case "response.function_call_arguments.delta": {
+            const builder = fnCallBuilders.get(event.item_id);
+            if (builder) builder.arguments += event.delta ?? "";
+            break;
+          }
+          case "response.function_call_arguments.done": {
+            const builder = fnCallBuilders.get(event.item_id);
+            if (builder) {
+              toolCalls.push({
+                id: builder.callId,
+                name: builder.name,
+                input: parseArguments(event.arguments)
+              });
+              fnCallBuilders.delete(event.item_id);
+            }
+            break;
+          }
+          case "response.completed": {
+            const resp = event.response;
+            const usage = resp.usage;
+            if (usage) {
+              inputTokens = usage.input_tokens ?? 0;
+              outputTokens = usage.output_tokens ?? 0;
+            }
+            for (const [, builder] of fnCallBuilders) {
+              toolCalls.push({
+                id: builder.callId,
+                name: builder.name,
+                input: parseArguments(builder.arguments)
+              });
+            }
+            fnCallBuilders.clear();
+            break;
+          }
+        }
+      });
+      return {
+        id: responseId,
+        content,
+        stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn",
+        model,
+        usage: { inputTokens, outputTokens },
+        toolCalls
+      };
+    }, this.retryConfig);
   }
   /**
-   * Stream a chat response
-   * Note: True streaming with Codex Responses API is complex.
-   * For now, we make a non-streaming call and simulate streaming by emitting chunks.
+   * Stream a chat response (no tools)
    */
   async *stream(messages, options) {
-    const response = await this.chat(messages, options);
-    if (response.content) {
-      const content = response.content;
-      const chunkSize = 20;
-      for (let i = 0; i < content.length; i += chunkSize) {
-        const chunk = content.slice(i, i + chunkSize);
-        yield { type: "text", text: chunk };
-        if (i + chunkSize < content.length) {
-          await new Promise((resolve3) => setTimeout(resolve3, 5));
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+    const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+    const body = this.buildRequestBody(model, input, instructions, {
+      maxTokens: options?.maxTokens
+    });
+    const response = await this.makeRequest(body);
+    if (!response.body) {
+      throw new ProviderError("No response body from Codex API", { provider: this.id });
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let lastActivityTime = Date.now();
+    const timeoutController = new AbortController();
+    const timeoutInterval = setInterval(() => {
+      if (Date.now() - lastActivityTime > STREAM_TIMEOUT_MS) {
+        clearInterval(timeoutInterval);
+        timeoutController.abort();
+      }
+    }, 5e3);
+    try {
+      while (true) {
+        if (timeoutController.signal.aborted) break;
+        const { done, value } = await reader.read();
+        if (done) break;
+        lastActivityTime = Date.now();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (!data || data === "[DONE]") continue;
+          try {
+            const event = JSON.parse(data);
+            if (event.type === "response.output_text.delta" && event.delta) {
+              yield { type: "text", text: event.delta };
+            } else if (event.type === "response.completed") {
+              yield { type: "done", stopReason: "end_turn" };
+            }
+          } catch {
+          }
         }
       }
+    } finally {
+      clearInterval(timeoutInterval);
+      reader.releaseLock();
+    }
+    if (timeoutController.signal.aborted) {
+      throw new Error(
+        `Stream timeout: No response from Codex API for ${STREAM_TIMEOUT_MS / 1e3}s`
+      );
     }
-    yield { type: "done", stopReason: response.stopReason };
   }
   /**
-   * Stream a chat response with tool use
-   * Note: Tools and true streaming with Codex Responses API are not yet implemented.
-   * For now, we delegate to stream() which uses non-streaming under the hood.
+   * Stream a chat response with tool use via Responses API.
+   *
+   * IMPORTANT: fnCallBuilders is keyed by output item ID (item.id), NOT by
+   * call_id. The streaming events (function_call_arguments.delta/done) use
+   * item_id which references the output item's id field, not call_id.
    */
   async *streamWithTools(messages, options) {
-    yield* this.stream(messages, options);
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL3;
+    const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+    const body = this.buildRequestBody(model, input, instructions, {
+      tools: options.tools,
+      maxTokens: options?.maxTokens
+    });
+    const response = await this.makeRequest(body);
+    if (!response.body) {
+      throw new ProviderError("No response body from Codex API", { provider: this.id });
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const fnCallBuilders = /* @__PURE__ */ new Map();
+    let lastActivityTime = Date.now();
+    const timeoutController = new AbortController();
+    const timeoutInterval = setInterval(() => {
+      if (Date.now() - lastActivityTime > STREAM_TIMEOUT_MS) {
+        clearInterval(timeoutInterval);
+        timeoutController.abort();
+      }
+    }, 5e3);
+    try {
+      while (true) {
+        if (timeoutController.signal.aborted) break;
+        const { done, value } = await reader.read();
+        if (done) break;
+        lastActivityTime = Date.now();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (!data || data === "[DONE]") continue;
+          let event;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          switch (event.type) {
+            case "response.output_text.delta":
+              yield { type: "text", text: event.delta ?? "" };
+              break;
+            case "response.output_item.added": {
+              const item = event.item;
+              if (item.type === "function_call") {
+                const itemKey = item.id ?? item.call_id;
+                fnCallBuilders.set(itemKey, {
+                  callId: item.call_id,
+                  name: item.name,
+                  arguments: ""
+                });
+                yield {
+                  type: "tool_use_start",
+                  toolCall: { id: item.call_id, name: item.name }
+                };
+              }
+              break;
+            }
+            case "response.function_call_arguments.delta": {
+              const builder = fnCallBuilders.get(event.item_id);
+              if (builder) {
+                builder.arguments += event.delta ?? "";
+              }
+              break;
+            }
+            case "response.function_call_arguments.done": {
+              const builder = fnCallBuilders.get(event.item_id);
+              if (builder) {
+                yield {
+                  type: "tool_use_end",
+                  toolCall: {
+                    id: builder.callId,
+                    name: builder.name,
+                    input: parseArguments(event.arguments ?? builder.arguments)
+                  }
+                };
+                fnCallBuilders.delete(event.item_id);
+              }
+              break;
+            }
+            case "response.completed": {
+              for (const [, builder] of fnCallBuilders) {
+                yield {
+                  type: "tool_use_end",
+                  toolCall: {
+                    id: builder.callId,
+                    name: builder.name,
+                    input: parseArguments(builder.arguments)
+                  }
+                };
+              }
+              fnCallBuilders.clear();
+              const resp = event.response;
+              const output = resp?.output ?? [];
+              const hasToolCalls = output.some((i) => i.type === "function_call");
+              yield {
+                type: "done",
+                stopReason: hasToolCalls ? "tool_use" : "end_turn"
+              };
+              break;
+            }
+          }
+        }
+      }
+    } finally {
+      clearInterval(timeoutInterval);
+      reader.releaseLock();
+    }
+    if (timeoutController.signal.aborted) {
+      throw new Error(
+        `Stream timeout: No response from Codex API for ${STREAM_TIMEOUT_MS / 1e3}s`
+      );
+    }
   }
 };
 var CONTEXT_WINDOWS4 = {