@inetafrica/open-claudia 2.14.8 → 3.0.0

package/core/providers/claude-events.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const {
+  normalizeDecoderError,
+  normalizedUsage,
+  providerErrorFlags,
+} = require("./events");
+
+function createClaudeParserState() {
+  return {
+    sessionId: null,
+    sawText: false,
+    terminal: false,
+    tools: new Map(),
+    seenUsage: new Set(),
+    totalCostUsd: 0,
+  };
+}
+
+function sessionEvent(sessionId, state) {
+  if (!sessionId || state.sessionId === sessionId) return null;
+  state.sessionId = sessionId;
+  return { type: "session", sessionId };
+}
+
+function claudeErrorMessage(rawEvent) {
+  if (typeof rawEvent.result === "string" && rawEvent.result.trim()) return rawEvent.result.trim();
+  if (Array.isArray(rawEvent.errors) && rawEvent.errors.length) return rawEvent.errors.map(String).join("; ");
+  if (typeof rawEvent.message === "string" && rawEvent.message.trim()) return rawEvent.message.trim();
+  return "Claude provider failed";
+}
+
+function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
+  if (!rawEvent || typeof rawEvent !== "object") return [];
+  const decoderFailure = normalizeDecoderError(rawEvent);
+  if (decoderFailure) return [decoderFailure];
+
+  if (rawEvent.type === "system" && rawEvent.subtype === "init") {
+    const event = sessionEvent(rawEvent.session_id, state);
+    return event ? [event] : [];
+  }
+
+  if (rawEvent.type === "stream_event") {
+    const delta = rawEvent.event?.type === "content_block_delta" ? rawEvent.event.delta : null;
+    if (delta?.type === "text_delta" && typeof delta.text === "string" && delta.text) {
+      state.sawText = true;
+      return [{ type: "text_delta", text: delta.text }];
+    }
+    return [];
+  }
+
+  if (rawEvent.type === "assistant") {
+    const events = [];
+    for (const block of rawEvent.message?.content || []) {
+      if (block?.type === "text" && typeof block.text === "string" && block.text) {
+        state.sawText = true;
+        events.push({ type: "text_final", text: block.text });
+      } else if (block?.type === "tool_use" && block.id && block.name) {
+        state.tools.set(block.id, block.name);
+        events.push({
+          type: "tool_start",
+          id: block.id,
+          name: block.name,
+          detail: block.input ?? null,
+        });
+      }
+    }
+    const usage = normalizedUsage(rawEvent.message?.usage, "provider_call", state.seenUsage);
+    if (usage) events.push(usage);
+    return events;
+  }
+
+  if (rawEvent.type === "user") {
+    const events = [];
+    for (const block of rawEvent.message?.content || []) {
+      if (block?.type !== "tool_result" || !block.tool_use_id) continue;
+      const name = state.tools.get(block.tool_use_id) || "unknown";
+      events.push({
+        type: "tool_end",
+        id: block.tool_use_id,
+        name,
+        detail: block.content ?? null,
+        exitCode: block.is_error ? 1 : 0,
+      });
+    }
+    return events;
+  }
+
+  if (rawEvent.type === "result") {
+    if (state.terminal) return [];
+    state.terminal = true;
+    if (Number.isFinite(rawEvent.total_cost_usd)) state.totalCostUsd = rawEvent.total_cost_usd;
+    if (rawEvent.is_error || /^error/.test(String(rawEvent.subtype || ""))) {
+      const message = claudeErrorMessage(rawEvent);
+      return [{ type: "error", message, ...providerErrorFlags(message) }];
+    }
+    const events = [];
+    const session = sessionEvent(rawEvent.session_id, state);
+    if (session) events.push(session);
+    const usage = normalizedUsage(rawEvent.usage, "turn", state.seenUsage);
+    if (usage) events.push(usage);
+    const hasStructuredOutput = Object.prototype.hasOwnProperty.call(rawEvent, "structured_output");
+    const structuredText = hasStructuredOutput ? JSON.stringify(rawEvent.structured_output) : "";
+    events.push({
+      type: "result",
+      text: hasStructuredOutput
+        ? (structuredText === undefined ? "" : structuredText)
+        : (state.sawText ? "" : (typeof rawEvent.result === "string" ? rawEvent.result : "")),
+      sessionId: rawEvent.session_id || state.sessionId || null,
+    });
+    return events;
+  }
+
+  return [];
+}
+
+module.exports = { createClaudeParserState, normalizeClaudeEvent };

package/core/providers/claude-hook.js

@@ -0,0 +1,114 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { resolveConfigDir } = require("../config-dir");
+const { atomicWriteFileSync } = require("../fsutil");
+const { buildDenyGateCommand } = require("./hook-command");
+
+const HOOK_TIMEOUT_SECONDS = 10;
+
+function hookError(code, message, cause) {
+  const error = new Error(message);
+  error.name = "ToolHookInitializationError";
+  error.code = code;
+  if (cause) error.cause = cause;
+  return error;
+}
+
+function buildClaudeHookSettings(options = {}) {
+  return {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: "Bash",
+          hooks: [
+            {
+              type: "command",
+              command: buildDenyGateCommand(options),
+              timeout: HOOK_TIMEOUT_SECONDS,
+            },
+          ],
+        },
+      ],
+    },
+  };
+}
+
+function settingsBody(options = {}) {
+  return `${JSON.stringify(buildClaudeHookSettings(options), null, 2)}\n`;
+}
+
+function defaultSettingsFile() {
+  return process.env.DENY_GATE_SETTINGS
+    ? path.resolve(process.env.DENY_GATE_SETTINGS)
+    : path.join(resolveConfigDir(), "deny-gate.settings.json");
+}
+
+function assertSafeTarget(file) {
+  let stat;
+  try { stat = fs.lstatSync(file); }
+  catch (error) {
+    if (error.code === "ENOENT") return;
+    throw hookError("TOOL_HOOK_INIT_FAILED", "Could not inspect Claude tool-hook settings", error);
+  }
+  if (stat.isSymbolicLink() || !stat.isFile()) {
+    throw hookError("UNSAFE_TOOL_HOOK_PATH", "Refusing to replace a non-regular Claude tool-hook settings path");
+  }
+}
+
+function verifySettingsFile(file, expected) {
+  assertSafeTarget(file);
+  let actual;
+  try { actual = fs.readFileSync(file, "utf8"); }
+  catch (error) { throw hookError("TOOL_HOOK_INIT_FAILED", "Could not verify Claude tool-hook settings", error); }
+  if (actual !== expected) {
+    throw hookError("TOOL_HOOK_CONFIG_UNVERIFIED", "Generated Claude tool-hook settings failed content verification");
+  }
+  try { fs.chmodSync(file, 0o600); }
+  catch (error) {
+    if (process.platform !== "win32") {
+      throw hookError("TOOL_HOOK_INIT_FAILED", "Could not make Claude tool-hook settings private", error);
+    }
+  }
+}
+
+function ensureClaudeHookSettings(options = {}) {
+  const file = path.resolve(options.settingsFile || defaultSettingsFile());
+  const expected = settingsBody(options);
+  assertSafeTarget(file);
+  try {
+    if (fs.readFileSync(file, "utf8") === expected) {
+      verifySettingsFile(file, expected);
+      return file;
+    }
+  } catch (error) {
+    if (error.code && !["ENOENT", "EACCES", "EPERM", "EISDIR"].includes(error.code)) throw error;
+  }
+  try { atomicWriteFileSync(file, expected, { mode: 0o600 }); }
+  catch (error) { throw hookError("TOOL_HOOK_INIT_FAILED", "Could not generate Claude tool-hook settings", error); }
+  verifySettingsFile(file, expected);
+  return file;
+}
+
+function prepareClaudeHook(options = {}) {
+  const settingsFile = ensureClaudeHookSettings(options);
+  const fingerprint = crypto.createHash("sha256").update(settingsBody(options)).digest("hex");
+  return Object.freeze({ providerId: "claude", settingsFile, fingerprint });
+}
+
+function createClaudeHookTransport(options = {}) {
+  return Object.freeze({
+    prepare() { return prepareClaudeHook(options); },
+  });
+}
+
+module.exports = {
+  HOOK_TIMEOUT_SECONDS,
+  buildClaudeHookSettings,
+  createClaudeHookTransport,
+  defaultSettingsFile,
+  ensureClaudeHookSettings,
+  prepareClaudeHook,
+};

package/core/providers/claude.js

@@ -0,0 +1,296 @@
+"use strict";
+
+const config = require("../config");
+const auth = require("../auth-flow");
+const { createJsonlDecoder } = require("./events");
+const { createClaudeParserState, normalizeClaudeEvent } = require("./claude-events");
+const { createClaudeHookTransport } = require("./claude-hook");
+
+const CLAUDE_MODELS = Object.freeze([
+  "claude-fable-5",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5-20251001",
+]);
+const CLAUDE_EFFORT_VALUES = Object.freeze(["low", "medium", "high", "xhigh", "max"]);
+const CLAUDE_DEFAULT_MODEL = config.config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-opus-4-8";
+const REQUIRED_HELP_FLAGS = Object.freeze([
+  "--append-system-prompt",
+  "--output-format",
+  "--resume",
+  "--permission-mode",
+  "--settings",
+]);
+
+const capabilities = Object.freeze({
+  resume: { support: "native", reason: null },
+  readOnlyMode: { support: "native", reason: null },
+  effort: { support: "native", values: [...CLAUDE_EFFORT_VALUES], reason: null },
+  budget: { support: "native", reason: null },
+  worktree: { support: "native", reason: null },
+  partialStreaming: { support: "native", reason: null },
+  maxTurns: { support: "native", reason: null },
+  imageFlag: { support: "unsupported", reason: "Claude Code has no dedicated image CLI flag; image ingress is represented in the prepared turn prompt" },
+  persistentUtilityStream: { support: "native", reason: null },
+  preToolHook: { support: "native", reason: null },
+});
+
+function providerError(code, message, details = {}) {
+  const error = new Error(message);
+  error.name = "ProviderInvocationError";
+  error.code = code;
+  error.details = details;
+  return error;
+}
+
+function requiredString(value, code, label) {
+  if (typeof value !== "string" || !value.trim()) throw providerError(code, `${label} is required`);
+  return value;
+}
+
+function settingsOf(context) {
+  return context.providerSettings || context.settings || {};
+}
+
+function preparedPrompt(context) {
+  const userPrompt = typeof context.userPrompt === "string"
+    ? context.userPrompt
+    : (typeof context.prompt === "string" ? context.prompt : null);
+  if (userPrompt === null) throw providerError("INVALID_PROVIDER_CONTEXT", "userPrompt must be a string");
+  const dynamic = typeof context.dynamicContext === "string" ? context.dynamicContext : "";
+  return dynamic ? `${dynamic}\n\n${userPrompt}` : userPrompt;
+}
+
+function appendSessionArgs(args, context) {
+  if (context.resumeSessionId && context.continueSession) {
+    throw providerError("INVALID_PROVIDER_CONTEXT", "resumeSessionId and continueSession are mutually exclusive");
+  }
+  if (context.fresh) return;
+  if (context.resumeSessionId) args.push("--resume", String(context.resumeSessionId));
+  else if (context.continueSession) args.push("--continue");
+  else if (context.sessionId) args.push("--resume", String(context.sessionId));
+}
+
+function appendModelAndLimits(args, context, defaultModel, utility) {
+  const settings = settingsOf(context);
+  let model = context.model || settings.model || null;
+  if (!model && utility && context.tier) {
+    model = context.tier === "low"
+      ? "claude-haiku-4-5-20251001"
+      : (context.tier === "medium" ? "claude-sonnet-4-6" : defaultModel);
+  }
+  args.push("--model", String(model || defaultModel));
+
+  const maxTurns = context.maxTurns ?? null;
+  if (maxTurns !== null) {
+    if (!Number.isSafeInteger(maxTurns) || maxTurns < 1) {
+      throw providerError("INVALID_PROVIDER_CONTEXT", "maxTurns must be a positive integer");
+    }
+    args.push("--max-turns", String(maxTurns));
+  }
+
+  const effort = context.effort || settings.effort || null;
+  if (effort) {
+    if (!CLAUDE_EFFORT_VALUES.includes(effort)) {
+      throw providerError("UNSUPPORTED_PROVIDER_SETTING", `Unsupported Claude effort: ${effort}`, { setting: "effort", value: effort });
+    }
+    args.push("--effort", effort);
+  }
+
+  const budget = context.budget ?? settings.budget ?? null;
+  if (budget !== null) {
+    const numericBudget = Number(budget);
+    if (!Number.isFinite(numericBudget) || numericBudget <= 0) {
+      throw providerError("INVALID_PROVIDER_CONTEXT", "budget must be a positive number");
+    }
+    args.push("--max-budget-usd", String(numericBudget));
+  }
+}
+
+function appendPermissionArgs(args, context, utility) {
+  const settings = settingsOf(context);
+  let permissionMode = context.permissionMode ?? settings.permissionMode ?? null;
+  if (utility && context.readOnly) permissionMode = "plan";
+  if (permissionMode === "ask") permissionMode = "plan";
+  if (permissionMode && permissionMode !== "direct") {
+    const supported = new Set(["acceptEdits", "auto", "bypassPermissions", "default", "dontAsk", "plan"]);
+    if (!supported.has(permissionMode)) {
+      throw providerError("UNSUPPORTED_PROVIDER_SETTING", `Unsupported Claude permission mode: ${permissionMode}`, { setting: "permissionMode", value: permissionMode });
+    }
+    args.push("--permission-mode", permissionMode);
+  } else {
+    args.push("--dangerously-skip-permissions");
+  }
+}
+
+function appendToolLists(args, context) {
+  for (const [field, flag] of [["allowedTools", "--allowedTools"], ["disallowedTools", "--disallowedTools"]]) {
+    if (context[field] === undefined || context[field] === null) continue;
+    if (!Array.isArray(context[field]) || context[field].some((tool) => typeof tool !== "string" || !tool.trim())) {
+      throw providerError("INVALID_PROVIDER_CONTEXT", `${field} must be an array of non-empty strings`);
+    }
+    args.push(flag, context[field].join(","));
+  }
+}
+
+function createClaudeProvider(options = {}) {
+  const resolveExecutable = options.resolveExecutable || (() => config.discoverProviderExecutable("claude"));
+  const defaultModel = options.defaultModel || CLAUDE_DEFAULT_MODEL;
+  const buildEnv = options.buildEnv || auth.claudeSubprocessEnv;
+  const getAuthStatus = options.getAuthStatus || ((binary) => auth.claudeProviderAuthStatus({ binary }));
+  const runCommand = options.runCommand || auth.runCommand;
+  // Factories are safe by default. `false` is reserved for hermetic argv tests
+  // that do not launch a real provider process.
+  const hookTransport = options.hookTransport === false
+    ? null
+    : (options.hookTransport || createClaudeHookTransport());
+
+  function executable() {
+    return resolveExecutable() || null;
+  }
+
+  function requireExecutable() {
+    const binary = executable();
+    if (!binary) throw providerError("NO_AVAILABLE_PROVIDER", "Claude Code is not configured or installed", { providerId: "claude" });
+    return binary;
+  }
+
+  function buildInvocation(context, utility) {
+    if (!context || typeof context !== "object") throw providerError("INVALID_PROVIDER_CONTEXT", "provider context must be an object");
+    const coreInstructions = requiredString(context.coreInstructions, "MISSING_CORE_INSTRUCTIONS", "coreInstructions");
+    if ((context.images || context.imagePaths)?.length) {
+      throw providerError("UNSUPPORTED_PROVIDER_CAPABILITY", capabilities.imageFlag.reason, { capability: "imageFlag" });
+    }
+
+    const binary = requireExecutable();
+    const env = { ...buildEnv() };
+    let toolHookSettings = context.toolHookSettings || null;
+    if (hookTransport) {
+      try {
+        const prepared = hookTransport.prepare({ binary, env, cwd: context.cwd || process.cwd(), runCommand });
+        toolHookSettings = prepared.settingsFile;
+      } catch (error) {
+        throw providerError(
+          "MANDATORY_TOOL_HOOK_UNAVAILABLE",
+          error?.message || "Claude's mandatory tool hook could not be initialized",
+          { providerId: "claude", causeCode: error?.code || null },
+        );
+      }
+    }
+
+    const args = ["-p"];
+    if (utility) appendToolLists(args, context);
+    args.push(
+      "--verbose",
+      "--output-format", "stream-json",
+      "--append-system-prompt", coreInstructions,
+    );
+    if (utility) args.push("--no-session-persistence");
+
+    if (toolHookSettings) args.push("--settings", String(toolHookSettings));
+    const transcriptDirectory = context.transcriptDirectory
+      || context.transcriptPaths?.transcriptsDir
+      || context.transcriptPaths?.directory
+      || null;
+    if (transcriptDirectory) args.push("--add-dir", String(transcriptDirectory));
+
+    if (!utility) appendSessionArgs(args, context);
+    appendModelAndLimits(args, context, defaultModel, utility);
+
+    if (context.outputSchema) {
+      let schema;
+      try { schema = JSON.stringify(context.outputSchema); }
+      catch (error) { throw providerError("INVALID_PROVIDER_CONTEXT", "outputSchema must be JSON-serializable"); }
+      if (!schema) throw providerError("INVALID_PROVIDER_CONTEXT", "outputSchema must be JSON-serializable");
+      args.push("--json-schema", schema);
+    }
+
+    appendPermissionArgs(args, context, utility);
+    const settings = settingsOf(context);
+    if (!utility && (context.worktree ?? settings.worktree)) args.push("--worktree");
+    if (!utility && context.voiceStream) args.push("--include-partial-messages");
+    const prompt = preparedPrompt(context);
+    if (!utility) args.push(prompt);
+
+    return {
+      binary,
+      args,
+      env,
+      // Utility prompts can contain memory, mandates, or reviewer payloads.
+      // Keep them out of argv/process listings; `claude -p` reads stdin when
+      // no positional prompt is supplied. Foreground compatibility is kept
+      // unchanged until its separately-scoped migration.
+      stdin: utility ? prompt : null,
+      parserState: createClaudeParserState(),
+    };
+  }
+
+  const provider = {
+    id: "claude",
+    label: "Claude Code",
+    capabilities,
+
+    isAvailable: () => !!executable(),
+    executable,
+    defaultModel: () => defaultModel,
+    modelChoices: () => [...CLAUDE_MODELS],
+
+    compatibilityStatus() {
+      const binary = executable();
+      if (!binary) return { state: "not_checked", version: null, reason: "Claude CLI not found" };
+      const versionResult = runCommand(binary, ["--version"], { env: buildEnv(), timeout: 10000 });
+      if (!versionResult.ok) return { state: "unknown", version: null, reason: "Claude version probe failed" };
+      const version = (String(versionResult.output).match(/\b(\d+\.\d+\.\d+)\b/) || [null, null])[1];
+      const helpResult = runCommand(binary, ["--help"], { env: buildEnv(), timeout: 10000 });
+      if (!helpResult.ok) return { state: "unknown", version, reason: "Claude compatibility probe failed" };
+      const missing = REQUIRED_HELP_FLAGS.filter((flag) => !String(helpResult.output).includes(flag));
+      if (missing.length) {
+        return { state: "incompatible", version, reason: `Claude CLI is missing required options: ${missing.join(", ")}` };
+      }
+      return { state: "compatible", version, reason: null };
+    },
+
+    buildMainInvocation: (context) => buildInvocation(context, false),
+    buildCompactionInvocation(context) {
+      if (!context?.fresh || !context.readOnly || context.maxTurns !== 1) {
+        throw providerError("INVALID_PROVIDER_CONTEXT", "Claude compaction seed requires a fresh read-only one-turn context");
+      }
+      return buildInvocation({ ...context, permissionMode: "plan" }, false);
+    },
+    buildUtilityInvocation: (context) => buildInvocation({ ...context, fresh: true }, true),
+    createEventDecoder: (decoderOptions) => createJsonlDecoder(decoderOptions),
+    normalizeEvent: normalizeClaudeEvent,
+    authStatus: () => getAuthStatus(executable()),
+    authHelp: () => auth.claudeAuthRecoveryMessage(),
+    preflightAuth() {
+      const status = provider.authStatus();
+      if (status.state !== "unauthenticated") return null;
+      return {
+        code: "PROVIDER_UNAUTHENTICATED",
+        providerId: "claude",
+        message: auth.claudeAuthRecoveryMessage(status.reason || "Claude Code authentication failed"),
+      };
+    },
+    nativeToolsNote: "Claude Code exposes its native tools; Open Claudia's tool hook and approval policy remain authoritative.",
+    tierModel(tier) {
+      if (tier === "low") return "claude-haiku-4-5-20251001";
+      if (tier === "medium") return "claude-sonnet-4-6";
+      return defaultModel;
+    },
+  };
+
+  return provider;
+}
+
+const claudeProvider = createClaudeProvider();
+
+module.exports = {
+  CLAUDE_EFFORT_VALUES,
+  CLAUDE_MODELS,
+  REQUIRED_HELP_FLAGS,
+  capabilities,
+  claudeProvider,
+  createClaudeProvider,
+};

package/core/providers/codex-events.js

@@ -0,0 +1,121 @@
+"use strict";
+
+const {
+  normalizeDecoderError,
+  normalizedUsage,
+  providerErrorFlags,
+} = require("./events");
+
+function createCodexParserState() {
+  return {
+    sessionId: null,
+    sawText: false,
+    terminal: false,
+    tools: new Map(),
+    completedItems: new Set(),
+    seenUsage: new Set(),
+  };
+}
+
+function sessionEvent(sessionId, state) {
+  if (!sessionId || state.sessionId === sessionId) return null;
+  state.sessionId = sessionId;
+  return { type: "session", sessionId };
+}
+
+function toolInfo(item) {
+  if (!item || typeof item !== "object") return null;
+  if (item.type === "command_execution") {
+    return { name: "Shell", startDetail: item.command ?? null, endDetail: item.aggregated_output ?? item.command ?? null };
+  }
+  if (item.type === "file_change") {
+    return { name: "Edit", startDetail: item.path ?? item.file_path ?? item.changes ?? null, endDetail: item.changes ?? item.path ?? item.file_path ?? null };
+  }
+  if (item.type === "web_search") {
+    return { name: "Web", startDetail: item.query ?? null, endDetail: item.result ?? item.query ?? null };
+  }
+  return null;
+}
+
+function codexErrorMessage(rawEvent) {
+  if (typeof rawEvent.message === "string" && rawEvent.message.trim()) return rawEvent.message.trim();
+  if (typeof rawEvent.error?.message === "string" && rawEvent.error.message.trim()) return rawEvent.error.message.trim();
+  return "Codex provider failed";
+}
+
+function normalizeCodexEvent(rawEvent, state = createCodexParserState()) {
+  if (!rawEvent || typeof rawEvent !== "object") return [];
+  const decoderFailure = normalizeDecoderError(rawEvent);
+  if (decoderFailure) return [decoderFailure];
+
+  if (rawEvent.type === "thread.started") {
+    const event = sessionEvent(rawEvent.thread_id, state);
+    return event ? [event] : [];
+  }
+
+  if (rawEvent.type === "item.started") {
+    const info = toolInfo(rawEvent.item);
+    if (!info || !rawEvent.item.id) return [];
+    state.tools.set(rawEvent.item.id, info.name);
+    return [{
+      type: "tool_start",
+      id: rawEvent.item.id,
+      name: info.name,
+      detail: info.startDetail,
+    }];
+  }
+
+  if (rawEvent.type === "item.updated" && rawEvent.item?.type === "agent_message") {
+    const text = rawEvent.delta?.text ?? rawEvent.item.delta ?? null;
+    if (typeof text !== "string" || !text) return [];
+    state.sawText = true;
+    return [{ type: "text_delta", text }];
+  }
+
+  if (rawEvent.type === "item.completed") {
+    const item = rawEvent.item;
+    if (!item || !item.id || state.completedItems.has(item.id)) return [];
+    state.completedItems.add(item.id);
+    if (item.type === "agent_message" && typeof item.text === "string" && item.text) {
+      state.sawText = true;
+      return [{ type: "text_final", text: item.text }];
+    }
+    const info = toolInfo(item);
+    if (!info) return [];
+    const exitCode = Number.isInteger(item.exit_code)
+      ? item.exit_code
+      : (/failed|error/i.test(String(item.status || "")) ? 1 : 0);
+    return [{
+      type: "tool_end",
+      id: item.id,
+      name: state.tools.get(item.id) || info.name,
+      detail: info.endDetail,
+      exitCode,
+    }];
+  }
+
+  if (rawEvent.type === "turn.completed") {
+    if (state.terminal) return [];
+    state.terminal = true;
+    const events = [];
+    const usage = normalizedUsage(rawEvent.usage, "session_total", state.seenUsage);
+    if (usage) events.push(usage);
+    events.push({
+      type: "result",
+      text: "",
+      sessionId: rawEvent.thread_id || state.sessionId || null,
+    });
+    return events;
+  }
+
+  if (rawEvent.type === "error" || rawEvent.type === "turn.failed") {
+    if (state.terminal) return [];
+    state.terminal = true;
+    const message = codexErrorMessage(rawEvent);
+    return [{ type: "error", message, ...providerErrorFlags(message) }];
+  }
+
+  return [];
+}
+
+module.exports = { createCodexParserState, normalizeCodexEvent };