@corbat-tech/coco 2.12.0 → 2.13.0

package/dist/cli/index.js

@@ -1756,7 +1756,7 @@ var init_openai = __esm({
             once: true
           });
           const providerName = this.name;
-          const parseArguments = (builder) => {
+          const parseArguments2 = (builder) => {
             let input = {};
             try {
               input = builder.arguments ? JSON.parse(builder.arguments) : {};
@@ -1837,7 +1837,7 @@ var init_openai = __esm({
                     toolCall: {
                       id: builder.id,
                       name: builder.name,
-                      input: parseArguments(builder)
+                      input: parseArguments2(builder)
                     }
                   };
                 }
@@ -1850,7 +1850,7 @@ var init_openai = __esm({
                 toolCall: {
                   id: builder.id,
                   name: builder.name,
-                  input: parseArguments(builder)
+                  input: parseArguments2(builder)
                 }
               };
             }
@@ -4061,8 +4061,6 @@ var init_auth = __esm({
     init_gcloud();
   }
 });
-
-// src/providers/codex.ts
 function parseJwtClaims(token) {
   const parts = token.split(".");
   if (parts.length !== 3 || !parts[1]) return void 0;
@@ -4078,6 +4076,21 @@ 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 {};
+  }
+}
 function createCodexProvider(config) {
   const provider = new CodexProvider();
   if (config) {
@@ -4086,11 +4099,12 @@ function createCodexProvider(config) {
   }
   return provider;
 }
-var CODEX_API_ENDPOINT, DEFAULT_MODEL3, CONTEXT_WINDOWS3, CodexProvider;
+var CODEX_API_ENDPOINT, DEFAULT_MODEL3, CONTEXT_WINDOWS3, STREAM_TIMEOUT_MS, CodexProvider;
 var init_codex = __esm({
   "src/providers/codex.ts"() {
     init_errors();
     init_auth();
+    init_retry();
     CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
     DEFAULT_MODEL3 = "gpt-5.4-codex";
     CONTEXT_WINDOWS3 = {
@@ -4103,12 +4117,14 @@ var init_codex = __esm({
       "gpt-5.2": 2e5,
       "gpt-5.1": 2e5
     };
+    STREAM_TIMEOUT_MS = 12e4;
     CodexProvider = class {
       id = "codex";
       name = "OpenAI Codex (ChatGPT Plus/Pro)";
       config = {};
       accessToken = null;
       accountId;
+      retryConfig = DEFAULT_RETRY_CONFIG;
       /**
        * Initialize the provider with OAuth tokens
        */
@@ -4193,166 +4209,466 @@ var init_codex = __esm({
       /**
        * 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 text13 = 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: text13 }]
-          };
-        });
+      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((resolve4) => setTimeout(resolve4, 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`
+          );
+        }
       }
     };
   }