axexec 1.0.0

package/dist/agents/claude-code/types.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Raw event types from Claude Code's JSONL stream.
+ *
+ * These types represent the raw output from:
+ * `claude -p "..." --output-format stream-json --verbose`
+ *
+ * The parser transforms these into normalized {@link AxexecEvent} types.
+ */
+import { z } from "zod";
+/** System event - emitted at startup with session info */
+declare const ClaudeSystemEvent: z.ZodObject<{
+    type: z.ZodLiteral<"system">;
+    subtype: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ClaudeSystemEvent = z.infer<typeof ClaudeSystemEvent>;
+/** Assistant event - model responses and tool calls */
+declare const ClaudeAssistantEvent: z.ZodObject<{
+    type: z.ZodLiteral<"assistant">;
+    subtype: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        tool_use: "tool_use";
+        thinking: "thinking";
+    }>>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        model: z.ZodOptional<z.ZodString>;
+        usage: z.ZodOptional<z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    content_block: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ClaudeAssistantEvent = z.infer<typeof ClaudeAssistantEvent>;
+/** User event - typically tool results */
+declare const ClaudeUserEvent: z.ZodObject<{
+    type: z.ZodLiteral<"user">;
+    timestamp: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                text: "text";
+                tool_result: "tool_result";
+            }>;
+            tool_use_id: z.ZodOptional<z.ZodString>;
+            content: z.ZodOptional<z.ZodUnknown>;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    tool_use_result: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+type ClaudeUserEvent = z.infer<typeof ClaudeUserEvent>;
+/** Result event - emitted when task completes */
+declare const ClaudeResultEvent: z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    subtype: z.ZodEnum<{
+        success: "success";
+        error: "error";
+        cancelled: "cancelled";
+    }>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    total_cost_usd: z.ZodOptional<z.ZodNumber>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ClaudeResultEvent = z.infer<typeof ClaudeResultEvent>;
+/** Union of all Claude Code event types */
+declare const ClaudeEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"system">;
+    subtype: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"assistant">;
+    subtype: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        tool_use: "tool_use";
+        thinking: "thinking";
+    }>>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        model: z.ZodOptional<z.ZodString>;
+        usage: z.ZodOptional<z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    content_block: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"user">;
+    timestamp: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                text: "text";
+                tool_result: "tool_result";
+            }>;
+            tool_use_id: z.ZodOptional<z.ZodString>;
+            content: z.ZodOptional<z.ZodUnknown>;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    tool_use_result: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    subtype: z.ZodEnum<{
+        success: "success";
+        error: "error";
+        cancelled: "cancelled";
+    }>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    total_cost_usd: z.ZodOptional<z.ZodNumber>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+type ClaudeEvent = z.infer<typeof ClaudeEvent>;
+/** Type guard for system events */
+declare function isSystemEvent(event: ClaudeEvent): event is ClaudeSystemEvent;
+/** Type guard for assistant events */
+declare function isAssistantEvent(event: ClaudeEvent): event is ClaudeAssistantEvent;
+/** Type guard for user events */
+declare function isUserEvent(event: ClaudeEvent): event is ClaudeUserEvent;
+/** Type guard for result events */
+declare function isResultEvent(event: ClaudeEvent): event is ClaudeResultEvent;
+export { ClaudeEvent, isAssistantEvent, isResultEvent, isSystemEvent, isUserEvent, };
+export type { ClaudeAssistantEvent, ClaudeResultEvent, ClaudeSystemEvent, ClaudeUserEvent, };

package/dist/agents/claude-code/types.js

@@ -0,0 +1,112 @@
+/**
+ * Raw event types from Claude Code's JSONL stream.
+ *
+ * These types represent the raw output from:
+ * `claude -p "..." --output-format stream-json --verbose`
+ *
+ * The parser transforms these into normalized {@link AxexecEvent} types.
+ */
+import { z } from "zod";
+/** Content block schema - used in assistant events */
+const ClaudeContentBlock = z.object({
+    type: z.string(),
+    text: z.string().optional(),
+    id: z.string().optional(),
+    name: z.string().optional(),
+    input: z.unknown().optional(),
+});
+/** System event - emitted at startup with session info */
+const ClaudeSystemEvent = z.object({
+    type: z.literal("system"),
+    subtype: z.string().optional(),
+    timestamp: z.string().optional(),
+    session_id: z.string().optional(),
+    model: z.string().optional(),
+    tools: z.array(z.string()).optional(),
+});
+/** Assistant event - model responses and tool calls */
+const ClaudeAssistantEvent = z.object({
+    type: z.literal("assistant"),
+    subtype: z.enum(["content", "tool_use", "thinking"]).optional(),
+    timestamp: z.string().optional(),
+    message: z
+        .object({
+        id: z.string().optional(),
+        role: z.string().optional(),
+        content: z.array(ClaudeContentBlock).optional(),
+        model: z.string().optional(),
+        usage: z
+            .object({
+            input_tokens: z.number().optional(),
+            output_tokens: z.number().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    content_block: ClaudeContentBlock.optional(),
+});
+/** Content block in user messages (tool results) */
+const ClaudeUserContentBlock = z.object({
+    type: z.enum(["tool_result", "text"]),
+    tool_use_id: z.string().optional(),
+    content: z.unknown().optional(),
+    text: z.string().optional(),
+});
+/** User event - typically tool results */
+const ClaudeUserEvent = z.object({
+    type: z.literal("user"),
+    timestamp: z.string().optional(),
+    message: z
+        .object({
+        role: z.string().optional(),
+        content: z.array(ClaudeUserContentBlock).optional(),
+    })
+        .optional(),
+    // Tool use result metadata (when present)
+    tool_use_result: z
+        .looseObject({
+        type: z.string().optional(),
+        status: z.string().optional(),
+    })
+        .optional(),
+});
+/** Result event - emitted when task completes */
+const ClaudeResultEvent = z.object({
+    type: z.literal("result"),
+    subtype: z.enum(["success", "error", "cancelled"]),
+    timestamp: z.string().optional(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+    duration_ms: z.number().optional(),
+    total_cost_usd: z.number().optional(),
+    usage: z
+        .object({
+        input_tokens: z.number().optional(),
+        output_tokens: z.number().optional(),
+    })
+        .optional(),
+});
+/** Union of all Claude Code event types */
+const ClaudeEvent = z.discriminatedUnion("type", [
+    ClaudeSystemEvent,
+    ClaudeAssistantEvent,
+    ClaudeUserEvent,
+    ClaudeResultEvent,
+]);
+/** Type guard for system events */
+function isSystemEvent(event) {
+    return event.type === "system";
+}
+/** Type guard for assistant events */
+function isAssistantEvent(event) {
+    return event.type === "assistant";
+}
+/** Type guard for user events */
+function isUserEvent(event) {
+    return event.type === "user";
+}
+/** Type guard for result events */
+function isResultEvent(event) {
+    return event.type === "result";
+}
+export { ClaudeEvent, isAssistantEvent, isResultEvent, isSystemEvent, isUserEvent, };

package/dist/agents/codex/adapter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Codex adapter implementation.
+ *
+ * Implements the {@link AgentAdapter} interface for Codex CLI.
+ */
+export {};

package/dist/agents/codex/adapter.js

@@ -0,0 +1,62 @@
+/**
+ * Codex adapter implementation.
+ *
+ * Implements the {@link AgentAdapter} interface for Codex CLI.
+ */
+import { determineSessionSuccess } from "../../determine-session-success.js";
+import { resolveBinary } from "../../resolve-binary.js";
+import { registerAdapter } from "../registry.js";
+import { createCodexParser } from "./parse-event.js";
+const CODEX_INFO = {
+    id: "codex",
+    name: "Codex",
+    package: "@openai/codex",
+};
+/**
+ * Prepares the command to spawn Codex CLI.
+ */
+function prepareCommand(options) {
+    // Build CLI arguments.
+    // Enable network access in sandbox: Codex blocks network by default in
+    // workspace-write mode, but other agents (Gemini, OpenCode) allow it by
+    // default. For unified behavior, enable it. This keeps file-level sandbox
+    // protections while allowing gh, curl, etc.
+    const cliArguments = [
+        "exec",
+        "--json",
+        "--full-auto",
+        "-c",
+        "sandbox_workspace_write.network_access=true",
+        // Add model flag if specified (o4-mini, gpt-5.1-codex, gpt-5.2, etc.)
+        ...(options.model ? ["--model", options.model] : []),
+        // Use "--" to prevent prompt from being misinterpreted as a flag
+        "--",
+        options.prompt,
+    ];
+    const environment = {};
+    // Pass through authentication environment variable.
+    // If not set, Codex CLI will handle auth errors on its own.
+    if (process.env["OPENAI_API_KEY"]) {
+        environment["OPENAI_API_KEY"] = process.env["OPENAI_API_KEY"];
+    }
+    const bin = resolveBinary({
+        name: "codex",
+        command: "codex",
+        environmentVariable: "AXEXEC_CODEX_PATH",
+        installHint: "npm install -g @openai/codex",
+    });
+    return {
+        bin,
+        args: cliArguments,
+        env: environment,
+    };
+}
+/** Codex adapter */
+const codexAdapter = {
+    info: () => CODEX_INFO,
+    prepareCommand,
+    createParser: (options) => createCodexParser(options?.model),
+    isSuccess: determineSessionSuccess,
+};
+// Self-register on import
+registerAdapter(codexAdapter);

package/dist/agents/codex/item-parsers.d.ts

@@ -0,0 +1,17 @@
+import type { AxexecEvent } from "../../types/events.js";
+import type { CodexItemCompletedEvent, CodexItemStartedEvent } from "./types.js";
+/**
+ * Parses item.started events.
+ *
+ * Only handles tool calls (command_execution, mcp_tool_call, file_change).
+ * Codex emits reasoning and agent_message only as item.completed, not item.started.
+ */
+export declare function parseItemStartedEvent(event: CodexItemStartedEvent, toolContext: Map<string, {
+    tool: string;
+    input: unknown;
+}>, timestamp: number): AxexecEvent | undefined;
+/** Parses item.completed events */
+export declare function parseItemCompletedEvent(event: CodexItemCompletedEvent, toolContext: Map<string, {
+    tool: string;
+    input: unknown;
+}>, timestamp: number): AxexecEvent | undefined;

package/dist/agents/codex/item-parsers.js

@@ -0,0 +1,126 @@
+/**
+ * Parses item.started events.
+ *
+ * Only handles tool calls (command_execution, mcp_tool_call, file_change).
+ * Codex emits reasoning and agent_message only as item.completed, not item.started.
+ */
+export function parseItemStartedEvent(event, toolContext, timestamp) {
+    const item = event.item;
+    if (item.type === "command_execution") {
+        const tool = "shell";
+        const input = { command: item.command };
+        toolContext.set(item.id, { tool, input });
+        return {
+            type: "tool.call",
+            callId: item.id,
+            tool,
+            input,
+            timestamp,
+        };
+    }
+    if (item.type === "mcp_tool_call") {
+        const tool = `${item.server}:${item.tool}`;
+        const input = item.arguments;
+        toolContext.set(item.id, { tool, input });
+        return {
+            type: "tool.call",
+            callId: item.id,
+            tool,
+            input,
+            timestamp,
+        };
+    }
+    if (item.type === "file_change") {
+        const tool = "file_change";
+        const input = item.changes;
+        toolContext.set(item.id, { tool, input });
+        return {
+            type: "tool.call",
+            callId: item.id,
+            tool,
+            input,
+            timestamp,
+        };
+    }
+    // Ignore other item types like web_search, todo_list, error (handled elsewhere or ignored)
+    return undefined;
+}
+/** Parses item.completed events */
+export function parseItemCompletedEvent(event, toolContext, timestamp) {
+    const item = event.item;
+    // Handle reasoning and agent_message items as progress events.
+    // Codex emits these as item.completed, not item.started.
+    if (item.type === "reasoning") {
+        return {
+            type: "agent.reasoning",
+            content: item.text,
+            timestamp,
+        };
+    }
+    if (item.type === "agent_message") {
+        return {
+            type: "agent.message",
+            content: item.text,
+            timestamp,
+        };
+    }
+    // Only handle tool completions below
+    if (item.type !== "command_execution" &&
+        item.type !== "mcp_tool_call" &&
+        item.type !== "file_change") {
+        return undefined;
+    }
+    const context = toolContext.get(item.id);
+    // If an item.completed event arrives without a corresponding item.started event,
+    // we won't have context, so deriveToolName reconstructs the tool name from the item type.
+    const toolName = context?.tool ?? deriveToolName(item.type, item);
+    // Clean up map
+    toolContext.delete(item.id);
+    let output;
+    switch (item.type) {
+        case "command_execution": {
+            output = item.aggregated_output;
+            break;
+        }
+        case "mcp_tool_call": {
+            output = item.result ?? item.error;
+            break;
+        }
+        case "file_change": {
+            // File change doesn't usually have an output other than success/fail status
+            // We can use the changes as output or just "File changes applied"
+            output = item.changes;
+            break;
+        }
+    }
+    return {
+        type: "tool.result",
+        callId: item.id,
+        tool: toolName,
+        output,
+        success: item.status === "completed",
+        timestamp,
+    };
+}
+/** Helper to derive tool name if context is missing */
+function deriveToolName(type, item) {
+    switch (type) {
+        case "command_execution": {
+            return "shell";
+        }
+        case "mcp_tool_call": {
+            // Validate mcp_tool_call has expected shape before accessing properties
+            if (typeof item === "object" &&
+                item !== null &&
+                "server" in item &&
+                "tool" in item) {
+                const mcp = item;
+                return `${mcp.server}:${mcp.tool}`;
+            }
+            return "unknown_mcp";
+        }
+        case "file_change": {
+            return "file_change";
+        }
+    }
+}

package/dist/agents/codex/parse-event.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Event parser for Codex CLI.
+ *
+ * Transforms raw Codex CLI JSONL events into normalized {@link AxexecEvent} types.
+ * Uses stateful correlation to resolve tool names in tool.result events.
+ *
+ * ## Turn Completion Semantics
+ *
+ * In `codex exec` mode (the mode used by this adapter), each process invocation
+ * handles exactly **one turn** before exiting. The event sequence is:
+ *
+ * 1. `thread.started` - session initialized
+ * 2. `turn.started` - single turn begins
+ * 3. `item.*` events - tool calls, messages, reasoning
+ * 4. `turn.completed` or `turn.failed` - turn ends
+ * 5. Process exits
+ *
+ * This means a single `codex exec` invocation will emit exactly one
+ * `turn.completed` (or `turn.failed`) event. The "resume" functionality
+ * (`codex exec resume <id>`) spawns a **new process** for each resumed turn.
+ *
+ * Therefore, mapping `turn.completed` to `task.complete` is correct; there is
+ * no risk of multiple `task.complete` events per session.
+ *
+ * @see https://github.com/openai/codex/blob/main/codex-rs/exec/src/lib.rs
+ *      Search for `TaskComplete` handling which triggers `InitiateShutdown`.
+ */
+import type { EventParser } from "../../types/adapter.js";
+/**
+ * Creates a parser for Codex CLI events.
+ *
+ * Maintains a mapping from item ID to tool info to support
+ * correlating start/complete events for tools.
+ *
+ * @param requestedModel - Model passed via --model flag (if any)
+ */
+declare function createCodexParser(requestedModel?: string): EventParser;
+export { createCodexParser };

package/dist/agents/codex/parse-event.js

@@ -0,0 +1,141 @@
+/**
+ * Event parser for Codex CLI.
+ *
+ * Transforms raw Codex CLI JSONL events into normalized {@link AxexecEvent} types.
+ * Uses stateful correlation to resolve tool names in tool.result events.
+ *
+ * ## Turn Completion Semantics
+ *
+ * In `codex exec` mode (the mode used by this adapter), each process invocation
+ * handles exactly **one turn** before exiting. The event sequence is:
+ *
+ * 1. `thread.started` - session initialized
+ * 2. `turn.started` - single turn begins
+ * 3. `item.*` events - tool calls, messages, reasoning
+ * 4. `turn.completed` or `turn.failed` - turn ends
+ * 5. Process exits
+ *
+ * This means a single `codex exec` invocation will emit exactly one
+ * `turn.completed` (or `turn.failed`) event. The "resume" functionality
+ * (`codex exec resume <id>`) spawns a **new process** for each resumed turn.
+ *
+ * Therefore, mapping `turn.completed` to `task.complete` is correct; there is
+ * no risk of multiple `task.complete` events per session.
+ *
+ * @see https://github.com/openai/codex/blob/main/codex-rs/exec/src/lib.rs
+ *      Search for `TaskComplete` handling which triggers `InitiateShutdown`.
+ */
+import { createTimestampParser } from "../../parse-iso-timestamp.js";
+import { CodexEvent, isErrorEvent, isItemCompletedEvent, isItemStartedEvent, isThreadStartedEvent, isTurnCompletedEvent, isTurnFailedEvent, } from "./types.js";
+import { parseItemCompletedEvent, parseItemStartedEvent, } from "./item-parsers.js";
+/**
+ * Creates a parser for Codex CLI events.
+ *
+ * Maintains a mapping from item ID to tool info to support
+ * correlating start/complete events for tools.
+ *
+ * @param requestedModel - Model passed via --model flag (if any)
+ */
+function createCodexParser(requestedModel) {
+    // Map from item ID to tool info for correlation
+    // This is needed because item.completed events might need context from item.started
+    // (specifically tool name, although AxexecEvent.tool.result needs it)
+    const toolContext = new Map();
+    // Stateful timestamp parser - falls back to previous timestamp when missing
+    const parseTimestamp = createTimestampParser();
+    // Track session start time to calculate duration (Codex doesn't provide it)
+    let sessionStartMs;
+    return (line) => {
+        const trimmed = line.trim();
+        if (trimmed === "") {
+            return undefined;
+        }
+        let json;
+        try {
+            json = JSON.parse(trimmed);
+        }
+        catch {
+            return undefined;
+        }
+        // Extract timestamp from RolloutLine envelope before schema validation.
+        // Codex wraps events in RolloutLine which adds a timestamp field at the top level.
+        const rawTimestamp = typeof json === "object" &&
+            json !== null &&
+            "timestamp" in json &&
+            typeof json["timestamp"] === "string"
+            ? json["timestamp"]
+            : undefined;
+        const timestamp = parseTimestamp(rawTimestamp);
+        const result = CodexEvent.safeParse(json);
+        if (!result.success) {
+            return undefined;
+        }
+        const raw = result.data;
+        if (isThreadStartedEvent(raw)) {
+            sessionStartMs = Date.now();
+            return parseThreadStartedEvent(raw, timestamp, requestedModel);
+        }
+        if (isItemStartedEvent(raw)) {
+            return parseItemStartedEvent(raw, toolContext, timestamp);
+        }
+        if (isItemCompletedEvent(raw)) {
+            return parseItemCompletedEvent(raw, toolContext, timestamp);
+        }
+        if (isTurnCompletedEvent(raw)) {
+            const durationMs = sessionStartMs === undefined ? 0 : Date.now() - sessionStartMs;
+            return parseTurnCompletedEvent(raw, durationMs, timestamp);
+        }
+        if (isTurnFailedEvent(raw)) {
+            return parseTurnFailedEvent(raw, timestamp);
+        }
+        if (isErrorEvent(raw)) {
+            return parseErrorEvent(raw, timestamp);
+        }
+        return undefined;
+    };
+}
+/** Parses a thread.started event (session start) */
+function parseThreadStartedEvent(event, timestamp, requestedModel) {
+    // Codex JSONL output doesn't include model info - it's stripped during
+    // conversion from SessionConfiguredEvent to ThreadStartedEvent.
+    // Use the model passed via CLI if available, otherwise report "unknown".
+    return {
+        type: "session.start",
+        sessionId: event.thread_id,
+        agent: "codex",
+        model: requestedModel ?? "unknown",
+        provider: "openai",
+        timestamp,
+    };
+}
+/** Parses turn.completed event (session complete) */
+function parseTurnCompletedEvent(event, durationMs, timestamp) {
+    return {
+        type: "session.complete",
+        stats: {
+            durationMs,
+            inputTokens: event.usage.input_tokens,
+            outputTokens: event.usage.output_tokens,
+        },
+        timestamp,
+    };
+}
+/** Parses turn.failed event (session error) */
+function parseTurnFailedEvent(event, timestamp) {
+    return {
+        type: "session.error",
+        code: "AGENT_ERROR",
+        message: event.error.message,
+        timestamp,
+    };
+}
+/** Parses error event (session error) */
+function parseErrorEvent(event, timestamp) {
+    return {
+        type: "session.error",
+        code: "AGENT_ERROR",
+        message: event.message,
+        timestamp,
+    };
+}
+export { createCodexParser };