spec-cat 0.1.0

package/.output/server/chunks/_/codexProvider.mjs

@@ -0,0 +1,757 @@
+import { R as registerProvider } from '../nitro/nitro.mjs';
+import { mkdtempSync, mkdirSync, existsSync, accessSync, constants } from 'node:fs';
+import { spawn, execSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import 'node:http';
+import 'node:https';
+import 'node:crypto';
+import 'stream';
+import 'events';
+import 'http';
+import 'crypto';
+import 'buffer';
+import 'zlib';
+import 'https';
+import 'net';
+import 'tls';
+import 'url';
+import 'node:events';
+import 'node:buffer';
+import 'node:fs/promises';
+import 'yaml';
+import 'node:util';
+import 'node:module';
+import 'node:url';
+
+function extractCodexDiagnosticFromEvent(event) {
+  const eventType = typeof event.type === "string" ? event.type : "";
+  if (eventType === "error") {
+    const message = typeof event.message === "string" ? event.message.trim() : "";
+    if (message) {
+      return `Codex error: ${message}`;
+    }
+  }
+  if (eventType === "turn.failed") {
+    const error = event.error;
+    if (error && typeof error === "object") {
+      const message = typeof error.message === "string" ? String(error.message).trim() : "";
+      if (message) {
+        return `Codex turn failed: ${message}`;
+      }
+    }
+  }
+  return null;
+}
+function getStringValue(obj, keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.trim()) {
+      return value;
+    }
+  }
+  return "";
+}
+function getObjectValue(obj, keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+  }
+  return null;
+}
+function parseJsonObject(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input;
+  }
+  if (typeof input === "string" && input.trim()) {
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+    return { raw: input };
+  }
+  return {};
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function deriveToolNameFromEventType(eventType) {
+  if (!eventType) return "";
+  if (eventType === "item.started" || eventType === "item.updated" || eventType === "item.completed") {
+    return "";
+  }
+  const base = eventType.replace(/^response\.output_item\./, "").replace(/(?:_begin|_end|_start|_stop|_done|_added|_updated|_completed|_failed)$/, "").replace(/(?:\.begin|\.end|\.start|\.stop|\.done|\.added|\.updated|\.completed|\.failed)$/, "").replace(/[._]+/g, " ").trim();
+  if (!base) return "";
+  const parts = base.split(/\s+/).filter(Boolean);
+  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function inferToolNameFromInput(input) {
+  if (typeof input.command === "string" || typeof input.cmd === "string") {
+    return "Bash";
+  }
+  const hasPath = typeof input.file_path === "string" || typeof input.path === "string";
+  const hasContent = typeof input.content === "string" || typeof input.text === "string";
+  const hasEditShape = typeof input.old_string === "string" || typeof input.new_string === "string";
+  if (hasPath && hasEditShape) return "Edit";
+  if (hasPath && hasContent) return "Write";
+  if (hasPath) return "Read";
+  return "";
+}
+function normalizeGenericToolName(name) {
+  if (!name) return "";
+  const lowered = name.toLowerCase();
+  const compact = lowered.replace(/[^a-z0-9]/g, "");
+  if (compact === "functioncall" || compact === "toolcall" || compact === "itemstarted" || compact === "itemupdated" || compact === "itemcompleted") {
+    return "";
+  }
+  return name;
+}
+function extractFallbackInputFromEvent(event) {
+  const keys = [
+    "file_path",
+    "filePath",
+    "path",
+    "command",
+    "cmd",
+    "pattern",
+    "query",
+    "glob",
+    "offset",
+    "limit",
+    "old_string",
+    "new_string",
+    "content",
+    "text"
+  ];
+  const input = {};
+  for (const key of keys) {
+    const value = event[key];
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      const normalizedKey = key === "filePath" ? "file_path" : key;
+      input[normalizedKey] = value;
+    }
+  }
+  return input;
+}
+function withSessionFields(event, source) {
+  const merged = { ...event };
+  for (const key of ["thread_id", "threadId", "session_id", "sessionId"]) {
+    if (merged[key] === void 0 && source[key] !== void 0) {
+      merged[key] = source[key];
+    }
+  }
+  return merged;
+}
+function extractPermissionRequest(event) {
+  const eventType = getStringValue(event, ["type"]).toLowerCase();
+  const permission = getObjectValue(event, ["permission"]);
+  if (permission) {
+    const tool2 = getStringValue(permission, ["tool", "name", "action"]) || "Permission";
+    return {
+      tool: tool2,
+      description: getStringValue(permission, ["description", "message", "text"]) || `Permission required: ${tool2}`,
+      path: getStringValue(permission, ["path"]),
+      file_path: getStringValue(permission, ["file_path", "filePath"]),
+      command: getStringValue(permission, ["command", "cmd"])
+    };
+  }
+  const looksLikePermissionEvent = eventType.includes("permission") || eventType.includes("approval") || eventType.includes("confirm");
+  if (!looksLikePermissionEvent) {
+    return null;
+  }
+  const tool = getStringValue(event, ["tool", "name", "action"]) || "Permission";
+  const description = getStringValue(event, ["description", "message", "text"]) || `Permission required: ${tool}`;
+  return {
+    tool,
+    description,
+    path: getStringValue(event, ["path"]),
+    file_path: getStringValue(event, ["file_path", "filePath"]),
+    command: getStringValue(event, ["command", "cmd"])
+  };
+}
+function extractToolUse(event) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const eventType = getStringValue(event, ["type"]).toLowerCase();
+  const disallowedTypes = /* @__PURE__ */ new Set([
+    "agent_message",
+    "agent_message_delta",
+    "task_complete",
+    "turn.completed",
+    "turn.failed",
+    "error",
+    "result"
+  ]);
+  if (disallowedTypes.has(eventType)) return null;
+  const toolObj = getObjectValue(event, ["tool", "function"]);
+  const explicitInput = toolObj ? (_c = (_b = (_a = toolObj.arguments) != null ? _a : toolObj.input) != null ? _b : toolObj.args) != null ? _c : toolObj.parameters : (_g = (_f = (_e = (_d = event.arguments) != null ? _d : event.input) != null ? _e : event.args) != null ? _f : event.parameters) != null ? _g : event.payload;
+  const parsedInput = parseJsonObject(explicitInput);
+  const fallbackInput = Object.keys(parsedInput).length === 0 ? extractFallbackInputFromEvent(event) : {};
+  const input = Object.keys(fallbackInput).length > 0 ? fallbackInput : parsedInput;
+  const explicitToolName = toolObj ? getStringValue(toolObj, ["name", "tool_name", "toolName"]) : getStringValue(event, ["name", "tool_name", "toolName", "function_name", "functionName", "item_type"]);
+  const derivedToolName = deriveToolNameFromEventType(eventType);
+  const toolName = normalizeGenericToolName(explicitToolName) || normalizeGenericToolName(derivedToolName) || inferToolNameFromInput(input);
+  if (!toolName) return null;
+  const hasToolShape = eventType.includes("tool") || eventType.includes("function_call") || eventType.includes("call.started") || eventType.includes("call.start") || eventType.includes("tool_call") || eventType.includes("item.started") || eventType.includes("item.updated") || eventType.endsWith("_begin") || eventType.endsWith(".begin") || eventType.endsWith("_start") || eventType.endsWith(".start") || !!event.tool_call_id || !!event.call_id || !!event.tool_use_id;
+  if (!hasToolShape && Object.keys(input).length === 0) {
+    return null;
+  }
+  const toolUseId = getStringValue(event, ["tool_use_id", "toolUseId", "tool_call_id", "call_id", "item_id", "id"]) || `codex-tool-${toolName}`;
+  return { toolUseId, name: toolName, input };
+}
+function extractToolResult(event) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const eventType = getStringValue(event, ["type"]).toLowerCase();
+  const resultObj = getObjectValue(event, ["result"]);
+  const toolUseId = getStringValue(event, ["tool_use_id", "toolUseId", "tool_call_id", "call_id", "item_id", "id"]);
+  const contentSource = (_h = (_d = (_c = (_b = (_a = event.output) != null ? _a : event.content) != null ? _b : event.result) != null ? _c : event.text) != null ? _d : event.message) != null ? _h : (_g = (_f = (_e = resultObj == null ? void 0 : resultObj.output) != null ? _e : resultObj == null ? void 0 : resultObj.content) != null ? _f : resultObj == null ? void 0 : resultObj.text) != null ? _g : resultObj == null ? void 0 : resultObj.message;
+  const content = stringifyUnknown(contentSource);
+  const status = getStringValue(event, ["status"]).toLowerCase();
+  const isError = event.is_error === true || status === "error" || status === "failed" || status === "failure";
+  const hasResultShape = eventType.includes("tool_result") || eventType.includes("tool.output") || eventType.includes("function_call_output") || eventType.includes("call.completed") || eventType.includes("tool.end") || eventType.includes("tool.finish") || eventType.includes("tool.result") || eventType.endsWith("_end") || eventType.endsWith(".end") || eventType.endsWith("_done") || eventType.endsWith(".done") || eventType.endsWith("_completed") || eventType.endsWith(".completed") || toolUseId.length > 0 && content.length > 0 && !eventType.includes("message");
+  if (!hasResultShape || !toolUseId || !content) {
+    return null;
+  }
+  return { toolUseId, content, isError };
+}
+function extractAgentTextFromEvent(event) {
+  const directText = typeof event.message === "string" ? event.message : typeof event.text === "string" ? event.text : "";
+  if (directText) {
+    return directText;
+  }
+  const content = event.content;
+  if (Array.isArray(content)) {
+    const chunks = content.map((entry) => {
+      if (!entry || typeof entry !== "object") return "";
+      const part = entry;
+      if (typeof part.text === "string") return part.text;
+      if (typeof part.content === "string") return part.content;
+      return "";
+    }).filter(Boolean);
+    if (chunks.length > 0) {
+      return chunks.join("");
+    }
+  }
+  return "";
+}
+function extractReasoningTextFromEvent(event) {
+  const directText = getStringValue(event, ["text", "message", "summary"]);
+  if (directText) return directText;
+  const summary = event.summary;
+  if (Array.isArray(summary)) {
+    const chunks = summary.map((entry) => {
+      if (!entry || typeof entry !== "object") return "";
+      const part = entry;
+      return getStringValue(part, ["text", "summary", "content"]);
+    }).filter(Boolean);
+    if (chunks.length > 0) {
+      return chunks.join("\n");
+    }
+  }
+  const content = event.content;
+  if (Array.isArray(content)) {
+    const chunks = content.map((entry) => {
+      if (!entry || typeof entry !== "object") return "";
+      const part = entry;
+      return getStringValue(part, ["text", "summary", "content"]);
+    }).filter(Boolean);
+    if (chunks.length > 0) {
+      return chunks.join("\n");
+    }
+  }
+  return "";
+}
+function mapCodexEventToProviderJson(event) {
+  const eventType = typeof event.type === "string" ? event.type : "";
+  const sessionId = typeof event.thread_id === "string" ? event.thread_id : typeof event.session_id === "string" ? event.session_id : void 0;
+  const asTextStreamEvents = (text) => [
+    {
+      type: "stream_event",
+      ...sessionId ? { session_id: sessionId } : {},
+      event: {
+        type: "content_block_start",
+        content_block: { type: "text", text }
+      }
+    },
+    {
+      type: "stream_event",
+      ...sessionId ? { session_id: sessionId } : {},
+      event: { type: "content_block_stop" }
+    }
+  ];
+  const asThinkingStreamEvents = (thinking) => [
+    {
+      type: "stream_event",
+      ...sessionId ? { session_id: sessionId } : {},
+      event: {
+        type: "content_block_start",
+        content_block: { type: "thinking", thinking }
+      }
+    },
+    {
+      type: "stream_event",
+      ...sessionId ? { session_id: sessionId } : {},
+      event: { type: "content_block_stop" }
+    }
+  ];
+  const mapPermissionRequest = () => {
+    const permission = extractPermissionRequest(event);
+    if (!permission) return null;
+    return {
+      type: "permission_request",
+      ...sessionId ? { session_id: sessionId } : {},
+      permission
+    };
+  };
+  const mapToolUseAsStreamEvents = () => {
+    const toolUse = extractToolUse(event);
+    if (!toolUse) return null;
+    const inputJson = JSON.stringify(toolUse.input);
+    return [
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: {
+          type: "content_block_start",
+          index: 0,
+          content_block: {
+            type: "tool_use",
+            id: toolUse.toolUseId,
+            name: toolUse.name
+          }
+        }
+      },
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: {
+          type: "content_block_delta",
+          index: 0,
+          delta: {
+            partial_json: inputJson
+          }
+        }
+      },
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: {
+          type: "content_block_stop",
+          index: 0
+        }
+      }
+    ];
+  };
+  const mapToolResult = () => {
+    const result = extractToolResult(event);
+    if (!result) return null;
+    return {
+      type: "tool_result",
+      ...sessionId ? { session_id: sessionId } : {},
+      tool_use_id: result.toolUseId,
+      content: result.content,
+      is_error: result.isError
+    };
+  };
+  const getFinalMessageText = () => {
+    const directCandidates = [
+      event.last_agent_message,
+      event.last_assistant_message,
+      event.final_message,
+      event.output_text,
+      event.response_text
+    ];
+    for (const value of directCandidates) {
+      if (typeof value === "string" && value.trim()) {
+        return value;
+      }
+    }
+    const result = event.result;
+    if (result && typeof result === "object") {
+      const resultObj = result;
+      const nestedCandidates = [resultObj.message, resultObj.text, resultObj.output_text];
+      for (const value of nestedCandidates) {
+        if (typeof value === "string" && value.trim()) {
+          return value;
+        }
+      }
+    }
+    return "";
+  };
+  if (eventType === "agent_message_delta") {
+    const text = typeof event.delta === "string" ? event.delta : typeof event.text === "string" ? event.text : "";
+    if (!text) return [];
+    return [
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: {
+          type: "content_block_start",
+          content_block: { type: "text", text: "" }
+        }
+      },
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: {
+          type: "content_block_delta",
+          delta: { text }
+        }
+      },
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: { type: "content_block_stop" }
+      }
+    ];
+  }
+  if (eventType === "agent_message") {
+    const text = extractAgentTextFromEvent(event);
+    if (!text) return [];
+    return [
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: {
+          type: "content_block_start",
+          content_block: { type: "text", text }
+        }
+      },
+      {
+        type: "stream_event",
+        ...sessionId ? { session_id: sessionId } : {},
+        event: { type: "content_block_stop" }
+      }
+    ];
+  }
+  if (eventType === "reasoning" || eventType === "agent_reasoning") {
+    const thinking = extractReasoningTextFromEvent(event);
+    if (!thinking) return [];
+    return asThinkingStreamEvents(thinking);
+  }
+  if (eventType === "task_complete" || eventType === "turn.completed") {
+    const finalText = getFinalMessageText();
+    const resultEvent = {
+      type: "result",
+      ...sessionId ? { session_id: sessionId } : {},
+      subtype: "success"
+    };
+    if (!finalText) {
+      return [resultEvent];
+    }
+    return [
+      ...asTextStreamEvents(finalText),
+      {
+        ...resultEvent
+      }
+    ];
+  }
+  const permissionEvent = mapPermissionRequest();
+  if (permissionEvent) {
+    return [permissionEvent];
+  }
+  const toolResultEvent = mapToolResult();
+  if (toolResultEvent) {
+    return [toolResultEvent];
+  }
+  const toolUseEvents = mapToolUseAsStreamEvents();
+  if (toolUseEvents) {
+    return toolUseEvents;
+  }
+  return [event];
+}
+function processCodexJsonLine(cleanedLine) {
+  try {
+    const parsed = JSON.parse(cleanedLine);
+    const eventsToProcess = (() => {
+      var _a, _b;
+      const outerType = typeof parsed.type === "string" ? parsed.type : "";
+      if (outerType === "event_msg") {
+        const payload = parsed.payload;
+        if (payload && typeof payload === "object") {
+          return [withSessionFields(payload, parsed)];
+        }
+      }
+      const isItemEnvelope = outerType === "item.started" || outerType === "item.completed" || outerType === "item.updated" || outerType === "item.added" || outerType.startsWith("response.output_item.");
+      if (isItemEnvelope) {
+        const item = parsed.item;
+        if (item && typeof item === "object") {
+          const itemEvent = withSessionFields(item, parsed);
+          if (typeof itemEvent.type === "string" && itemEvent.type.toLowerCase() === "message") {
+            itemEvent.type = "agent_message";
+          }
+          return [itemEvent];
+        }
+      }
+      if (outerType === "response.output_text.delta") {
+        const delta = getStringValue(parsed, ["delta", "text"]);
+        if (delta) {
+          return [withSessionFields({ type: "agent_message_delta", delta }, parsed)];
+        }
+      }
+      if (outerType === "response.completed") {
+        return [withSessionFields({ type: "turn.completed", result: (_a = parsed.response) != null ? _a : parsed.result }, parsed)];
+      }
+      if (outerType === "response.failed") {
+        return [withSessionFields({ type: "turn.failed", error: (_b = parsed.error) != null ? _b : parsed.response }, parsed)];
+      }
+      return [parsed];
+    })();
+    const diagnostics = eventsToProcess.map((event) => extractCodexDiagnosticFromEvent(event)).filter((diag) => !!diag);
+    const mappedEvents = eventsToProcess.flatMap((event) => mapCodexEventToProviderJson(event));
+    return {
+      mappedEvents,
+      diagnostics
+    };
+  } catch {
+    return {
+      mappedEvents: [],
+      diagnostics: [],
+      nonJson: cleanedLine
+    };
+  }
+}
+
+function detectCodexCli() {
+  if (typeof process.env.CODEX_CLI_PATH === "string" && process.env.CODEX_CLI_PATH.length > 0 && existsSync(process.env.CODEX_CLI_PATH)) {
+    return process.env.CODEX_CLI_PATH;
+  }
+  const systemPaths = [
+    join(process.env.HOME || "", ".local/bin/codex"),
+    "/usr/local/bin/codex",
+    "/usr/bin/codex"
+  ];
+  for (const candidate of systemPaths) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  try {
+    const whichResult = execSync("which codex 2>/dev/null", { encoding: "utf-8" }).trim();
+    if (whichResult && existsSync(whichResult)) {
+      return whichResult;
+    }
+  } catch {
+  }
+  return null;
+}
+let cachedCodexCliPath;
+function getCodexCliPath() {
+  if (cachedCodexCliPath === void 0) {
+    cachedCodexCliPath = detectCodexCli();
+  }
+  if (!cachedCodexCliPath) {
+    throw new Error("Codex CLI not found. Install codex CLI or set CODEX_CLI_PATH.");
+  }
+  return cachedCodexCliPath;
+}
+function isCodexAvailable() {
+  try {
+    getCodexCliPath();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProc(proc) {
+  try {
+    proc.kill("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+    }, 3e3);
+    proc.once("exit", () => clearTimeout(forceKillTimer));
+  } catch {
+  }
+}
+function resolveCodexHomeForSpawn(ephemeral) {
+  if (ephemeral) {
+    try {
+      return mkdtempSync(join(tmpdir(), "spec-cat-codex-home-"));
+    } catch {
+      const fallbackEphemeralHome = "/tmp/spec-cat-codex-home";
+      try {
+        mkdirSync(fallbackEphemeralHome, { recursive: true });
+        return fallbackEphemeralHome;
+      } catch {
+        return null;
+      }
+    }
+  }
+  if (typeof process.env.CODEX_HOME === "string" && process.env.CODEX_HOME.length > 0) {
+    return process.env.CODEX_HOME;
+  }
+  const homeDir = process.env.HOME || "";
+  const defaultCodexHome = join(homeDir, ".codex");
+  try {
+    if (existsSync(defaultCodexHome)) {
+      accessSync(defaultCodexHome, constants.W_OK);
+      return null;
+    }
+    if (homeDir) {
+      accessSync(homeDir, constants.W_OK);
+      return null;
+    }
+  } catch {
+  }
+  const fallbackCodexHome = "/tmp/spec-cat-codex-home";
+  try {
+    mkdirSync(fallbackCodexHome, { recursive: true });
+    return fallbackCodexHome;
+  } catch {
+    return null;
+  }
+}
+const metadata = {
+  id: "codex",
+  name: "OpenAI Codex CLI",
+  description: "Codex provider metadata and model defaults for capability-gated selection.",
+  models: [
+    {
+      key: "gpt-5.3-codex",
+      label: "gpt-5.3-codex (current)",
+      description: "Latest frontier agentic coding model.",
+      default: true
+    },
+    {
+      key: "gpt-5.3-codex-spark",
+      label: "gpt-5.3-codex-spark",
+      description: "Ultra-fast coding model."
+    },
+    {
+      key: "gpt-5.2-codex",
+      label: "gpt-5.2-codex",
+      description: "Frontier agentic coding model."
+    },
+    {
+      key: "gpt-5.1-codex-max",
+      label: "gpt-5.1-codex-max",
+      description: "Codex-optimized flagship for deep and fast reasoning."
+    },
+    {
+      key: "gpt-5.2",
+      label: "gpt-5.2",
+      description: "Latest frontier model with improvements across knowledge, reasoning and coding"
+    },
+    {
+      key: "gpt-5.1-codex-mini",
+      label: "gpt-5.1-codex-mini",
+      description: "Optimized for codex. Cheaper, faster, but less capable."
+    }
+  ],
+  capabilities: {
+    streaming: isCodexAvailable(),
+    permissions: isCodexAvailable(),
+    resume: isCodexAvailable(),
+    autoCommit: false,
+    conflictResolution: false
+  }
+};
+const codexProvider = {
+  metadata,
+  streamChat(opts, callbacks) {
+    var _a, _b, _c;
+    const cliPath = getCodexCliPath();
+    const fallbackCodexHome = resolveCodexHomeForSpawn(!!opts.ephemeral);
+    const args = ["exec", "--json", "--model", opts.selection.modelKey];
+    if (opts.ephemeral) {
+      args.push("--ephemeral");
+    }
+    if ((opts.permissionMode || "ask") === "bypass" || (opts.permissionMode || "ask") === "auto") {
+      args.push("--full-auto");
+    }
+    if (opts.resumeSessionId) {
+      args.push("resume", opts.resumeSessionId, opts.message);
+    } else {
+      args.push(opts.message);
+    }
+    const proc = spawn(cliPath, args, {
+      cwd: opts.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        NODE_NO_WARNINGS: "1",
+        NO_COLOR: "1",
+        ...fallbackCodexHome ? { CODEX_HOME: fallbackCodexHome } : {}
+      }
+    });
+    (_a = proc.stdin) == null ? void 0 : _a.end();
+    let stdoutBuffer = "";
+    let stderrBuffer = "";
+    const nonJsonOutput = [];
+    const handleStreamChunk = (chunk, stream) => {
+      const merged = (stream === "stdout" ? stdoutBuffer : stderrBuffer) + chunk;
+      const lines = merged.split("\n");
+      const tail = lines.pop() || "";
+      if (stream === "stdout") {
+        stdoutBuffer = tail;
+      } else {
+        stderrBuffer = tail;
+      }
+      for (const line of lines) {
+        const cleaned = line.trim();
+        if (!cleaned) continue;
+        const processed = processCodexJsonLine(cleaned);
+        nonJsonOutput.push(...processed.diagnostics);
+        if (processed.nonJson) {
+          nonJsonOutput.push(processed.nonJson);
+          continue;
+        }
+        for (const mapped of processed.mappedEvents) {
+          callbacks.onProviderJson(mapped);
+        }
+      }
+    };
+    (_b = proc.stdout) == null ? void 0 : _b.on("data", (data) => {
+      handleStreamChunk(data.toString(), "stdout");
+    });
+    (_c = proc.stderr) == null ? void 0 : _c.on("data", (data) => {
+      handleStreamChunk(data.toString(), "stderr");
+    });
+    proc.on("close", (exitCode, signal) => {
+      const flushTail = (tail) => {
+        const cleaned = tail.trim();
+        if (!cleaned) return;
+        const processed = processCodexJsonLine(cleaned);
+        nonJsonOutput.push(...processed.diagnostics);
+        if (processed.nonJson) {
+          nonJsonOutput.push(processed.nonJson);
+          return;
+        }
+        for (const mapped of processed.mappedEvents) {
+          callbacks.onProviderJson(mapped);
+        }
+      };
+      flushTail(stdoutBuffer);
+      flushTail(stderrBuffer);
+      callbacks.onClose({ exitCode, signal, nonJsonOutput });
+    });
+    proc.on("error", (error) => {
+      callbacks.onError(error);
+    });
+    return {
+      kill: () => killProc(proc)
+    };
+  },
+  isModelSupported(modelKey) {
+    return metadata.models.some((model) => model.key === modelKey);
+  }
+};
+registerProvider(codexProvider);
+
+export { codexProvider as default };
+//# sourceMappingURL=codexProvider.mjs.map