@otto-code/server 0.5.0

package/dist/server/server/agent/providers/claude/tool-call-detail-parser.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import { ToolEditInputSchema, ToolEditOutputSchema, ToolReadInputSchema, ToolReadOutputSchema, ToolSearchInputSchema, ToolGrepOutputSchema, ToolGlobOutputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWebFetchInputSchema, ToolWebFetchOutputSchema, ToolWebSearchOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toFetchToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, toolDetailBranchByName, } from "../tool-call-detail-primitives.js";
+const ClaudeGrepOutputSchema = z
+    .union([
+    ToolGrepOutputSchema,
+    z
+        .object({ output: z.string() })
+        .passthrough()
+        .transform(({ output }) => ({ numFiles: 0, filenames: [], content: output })),
+])
+    .nullable();
+const ClaudeToolEnvelopeSchema = z
+    .object({
+    name: z.string().min(1),
+    input: z.unknown().nullable(),
+    output: z.unknown().nullable(),
+})
+    .passthrough();
+const ClaudeSpeakToolDetailSchema = z
+    .object({
+    name: z.literal("speak"),
+    input: z
+        .union([
+        z.string().transform((text) => ({ text })),
+        z.object({ text: z.string() }).passthrough(),
+    ])
+        .nullable(),
+    output: z.unknown().nullable(),
+})
+    .transform(({ input }) => {
+    const text = input?.text?.trim() ?? "";
+    if (!text) {
+        return undefined;
+    }
+    return {
+        type: "unknown",
+        input: text,
+        output: null,
+    };
+});
+const ClaudeToolDetailPass2Schema = z.union([
+    toolDetailBranchByName("Bash", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("bash", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("shell", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("exec_command", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("Read", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("read", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("read_file", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("view_file", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("Write", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("write", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("write_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("create_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("Edit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("MultiEdit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("multi_edit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("edit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("apply_patch", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("apply_diff", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("str_replace_editor", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("WebSearch", ToolSearchInputSchema, ToolWebSearchOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "web_search" })),
+    toolDetailBranchByName("web_search", ToolSearchInputSchema, ToolWebSearchOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "web_search" })),
+    toolDetailBranchByName("search", ToolSearchInputSchema, z.unknown(), (input) => toSearchToolDetail({ input, toolName: "search" })),
+    toolDetailBranchByName("Grep", ToolSearchInputSchema, ClaudeGrepOutputSchema, (input, output) => toSearchToolDetail({ input, output, toolName: "grep" })),
+    toolDetailBranchByName("grep", ToolSearchInputSchema, ClaudeGrepOutputSchema, (input, output) => toSearchToolDetail({ input, output, toolName: "grep" })),
+    toolDetailBranchByName("Glob", ToolSearchInputSchema, ToolGlobOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "glob" })),
+    toolDetailBranchByName("glob", ToolSearchInputSchema, ToolGlobOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "glob" })),
+    toolDetailBranchByName("WebFetch", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("web_fetch", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("WebFetchTool", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("web_fetch_tool", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("webfetch", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("Skill", z.object({ skill: z.string() }).passthrough(), z
+        .union([
+        z
+            .object({ output: z.string() })
+            .passthrough()
+            .transform((value) => value.output),
+        z.string(),
+    ])
+        .nullable(), (input, output) => {
+        const skillName = input?.skill;
+        if (!skillName) {
+            return undefined;
+        }
+        return {
+            type: "plain_text",
+            label: skillName,
+            icon: "sparkles",
+            ...(output ? { text: output } : {}),
+        };
+    }),
+    ClaudeSpeakToolDetailSchema,
+]);
+export function deriveClaudeToolDetail(name, input, output) {
+    const pass1 = ClaudeToolEnvelopeSchema.safeParse({
+        name,
+        input: input ?? null,
+        output: output ?? null,
+    });
+    if (!pass1.success) {
+        return {
+            type: "unknown",
+            input: input ?? null,
+            output: output ?? null,
+        };
+    }
+    const pass2 = ClaudeToolDetailPass2Schema.safeParse(pass1.data);
+    if (pass2.success && pass2.data) {
+        return pass2.data;
+    }
+    return {
+        type: "unknown",
+        input: pass1.data.input,
+        output: pass1.data.output,
+    };
+}
+//# sourceMappingURL=tool-call-detail-parser.js.map

package/dist/server/server/agent/providers/claude/tool-call-mapper.d.ts

@@ -0,0 +1,16 @@
+import type { ToolCallTimelineItem } from "../../agent-sdk-types.js";
+interface MapperParams {
+    callId?: string | null;
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export declare function mapClaudeRunningToolCall(params: MapperParams): ToolCallTimelineItem | null;
+export declare function mapClaudeCompletedToolCall(params: MapperParams): ToolCallTimelineItem | null;
+export declare function mapClaudeFailedToolCall(params: MapperParams & {
+    error: unknown;
+}): ToolCallTimelineItem | null;
+export declare function mapClaudeCanceledToolCall(params: MapperParams): ToolCallTimelineItem | null;
+export {};
+//# sourceMappingURL=tool-call-mapper.d.ts.map

package/dist/server/server/agent/providers/claude/tool-call-mapper.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+import { isSpeakToolName } from "@otto-code/protocol/tool-name-normalization";
+import { deriveClaudeToolDetail } from "./tool-call-detail-parser.js";
+const ClaudeToolCallStatusSchema = z.enum(["running", "completed", "failed", "canceled"]);
+const ClaudeRawToolCallSchema = z
+    .object({
+    callId: z.string().optional().nullable(),
+    name: z.string().min(1),
+    input: z.unknown().optional(),
+    output: z.unknown().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    error: z.unknown().nullable().optional(),
+    status: ClaudeToolCallStatusSchema,
+})
+    .passthrough();
+const SHELL_NAMES = new Set(["Bash", "bash", "shell", "exec_command"]);
+const READ_NAMES = new Set(["Read", "read", "read_file", "view_file"]);
+const WRITE_NAMES = new Set(["Write", "write", "write_file", "create_file"]);
+const EDIT_NAMES = new Set([
+    "Edit",
+    "MultiEdit",
+    "multi_edit",
+    "edit",
+    "apply_patch",
+    "apply_diff",
+    "str_replace_editor",
+]);
+const SEARCH_NAMES = new Set([
+    "WebSearch",
+    "web_search",
+    "search",
+    "Grep",
+    "grep",
+    "Glob",
+    "glob",
+]);
+const FETCH_NAMES = new Set([
+    "WebFetch",
+    "web_fetch",
+    "WebFetchTool",
+    "web_fetch_tool",
+    "webfetch",
+]);
+function resolveClaudeToolKind(name) {
+    if (SHELL_NAMES.has(name))
+        return "shell";
+    if (READ_NAMES.has(name))
+        return "read";
+    if (WRITE_NAMES.has(name))
+        return "write";
+    if (EDIT_NAMES.has(name))
+        return "edit";
+    if (SEARCH_NAMES.has(name))
+        return "search";
+    if (FETCH_NAMES.has(name))
+        return "fetch";
+    if (isSpeakToolName(name))
+        return "speak";
+    return "unknown";
+}
+function resolveDetailName(toolKind, name) {
+    switch (toolKind) {
+        case "shell":
+            return "shell";
+        case "read":
+            return "read_file";
+        case "write":
+            return "write_file";
+        case "edit":
+            return "apply_patch";
+        case "search":
+        case "fetch":
+            return name;
+        case "speak":
+            return "speak";
+        default:
+            return name;
+    }
+}
+function mapClaudeToolCall(params, status, error) {
+    const parsed = ClaudeRawToolCallSchema.safeParse({ ...params, status, error });
+    if (!parsed.success) {
+        return null;
+    }
+    const raw = parsed.data;
+    const callId = typeof raw.callId === "string" && raw.callId.trim().length > 0 ? raw.callId : null;
+    if (callId === null) {
+        return null;
+    }
+    const trimmedName = raw.name.trim();
+    const toolKind = resolveClaudeToolKind(trimmedName);
+    const name = toolKind === "speak" ? "speak" : trimmedName;
+    const input = raw.input ?? null;
+    const output = raw.output ?? null;
+    const detail = deriveClaudeToolDetail(resolveDetailName(toolKind, name), input, output);
+    if (raw.status === "failed") {
+        return {
+            type: "tool_call",
+            callId,
+            name,
+            detail,
+            status: "failed",
+            error: raw.error ?? { message: "Tool call failed" },
+            ...(raw.metadata ? { metadata: raw.metadata } : {}),
+        };
+    }
+    return {
+        type: "tool_call",
+        callId,
+        name,
+        detail,
+        status: raw.status,
+        error: null,
+        ...(raw.metadata ? { metadata: raw.metadata } : {}),
+    };
+}
+export function mapClaudeRunningToolCall(params) {
+    return mapClaudeToolCall(params, "running", null);
+}
+export function mapClaudeCompletedToolCall(params) {
+    return mapClaudeToolCall(params, "completed", null);
+}
+export function mapClaudeFailedToolCall(params) {
+    return mapClaudeToolCall(params, "failed", params.error);
+}
+export function mapClaudeCanceledToolCall(params) {
+    return mapClaudeToolCall(params, "canceled", null);
+}
+//# sourceMappingURL=tool-call-mapper.js.map

package/dist/server/server/agent/providers/codex/app-server-transport.d.ts

@@ -0,0 +1,90 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { Logger } from "pino";
+import { z } from "zod";
+type RequestHandler = (params: unknown) => unknown;
+type NotificationHandler = (method: string, params: unknown) => void;
+export interface CodexThreadForkParams {
+    threadId: string;
+    path?: string | null;
+    model?: string | null;
+    modelProvider?: string | null;
+    serviceTier?: string | null;
+    cwd?: string | null;
+    runtimeWorkspaceRoots?: string[] | null;
+    approvalPolicy?: unknown;
+    approvalsReviewer?: unknown;
+    sandbox?: unknown;
+    permissions?: string | null;
+    config?: Record<string, unknown> | null;
+    baseInstructions?: string | null;
+    developerInstructions?: string | null;
+    ephemeral?: boolean;
+    threadSource?: unknown;
+    excludeTurns?: boolean;
+    persistExtendedHistory?: boolean;
+}
+declare const CodexThreadForkResponseSchema: z.ZodObject<{
+    thread: z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>;
+    model: z.ZodString;
+    modelProvider: z.ZodString;
+    serviceTier: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodString;
+    runtimeWorkspaceRoots: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    instructionSources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    approvalPolicy: z.ZodUnknown;
+    approvalsReviewer: z.ZodUnknown;
+    sandbox: z.ZodUnknown;
+    activePermissionProfile: z.ZodOptional<z.ZodUnknown>;
+    reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type CodexThreadForkResponse = z.infer<typeof CodexThreadForkResponseSchema>;
+export declare function parseCodexThreadForkResponse(response: unknown): CodexThreadForkResponse;
+export interface CodexThreadRollbackParams {
+    threadId: string;
+    numTurns: number;
+}
+declare const CodexThreadRollbackResponseSchema: z.ZodObject<{
+    thread: z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type CodexThreadRollbackResponse = z.infer<typeof CodexThreadRollbackResponseSchema>;
+export declare function parseCodexThreadRollbackResponse(response: unknown): CodexThreadRollbackResponse;
+export interface CodexAppServerTraceContext {
+    agentId?: string;
+    sessionId?: string;
+    turnId?: string;
+}
+export declare class CodexAppServerClient {
+    private readonly child;
+    private readonly logger;
+    private readonly getTraceContext;
+    private readonly rl;
+    private readonly pending;
+    private readonly requestHandlers;
+    private notificationHandler;
+    private nextId;
+    private disposed;
+    private stderrBuffer;
+    constructor(child: ChildProcessWithoutNullStreams, logger: Logger, getTraceContext?: () => CodexAppServerTraceContext);
+    setNotificationHandler(handler: NotificationHandler): void;
+    setRequestHandler(method: string, handler: RequestHandler): void;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    forkThread(params: CodexThreadForkParams): Promise<CodexThreadForkResponse>;
+    rollbackThread(params: CodexThreadRollbackParams): Promise<CodexThreadRollbackResponse>;
+    notify(method: string, params?: unknown): void;
+    dispose(): Promise<void>;
+    private writeJsonRpcResponse;
+    private handleLine;
+    private traceRawEvent;
+}
+export {};
+//# sourceMappingURL=app-server-transport.d.ts.map

package/dist/server/server/agent/providers/codex/app-server-transport.js

@@ -0,0 +1,262 @@
+import readline from "node:readline";
+import { z } from "zod";
+import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
+const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
+const APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 2000;
+const APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
+const STDERR_BUFFER_LIMIT = 8192;
+const CodexThreadForkResponseSchema = z
+    .object({
+    thread: z
+        .object({
+        id: z.string(),
+        sessionId: z.string().optional(),
+        forkedFromId: z.string().nullable().optional(),
+        turns: z.array(z.unknown()).optional(),
+    })
+        .passthrough(),
+    model: z.string(),
+    modelProvider: z.string(),
+    serviceTier: z.string().nullable(),
+    cwd: z.string(),
+    runtimeWorkspaceRoots: z.array(z.string()).optional().default([]),
+    instructionSources: z.array(z.string()).optional().default([]),
+    approvalPolicy: z.unknown(),
+    approvalsReviewer: z.unknown(),
+    sandbox: z.unknown(),
+    activePermissionProfile: z.unknown().optional(),
+    reasoningEffort: z.string().nullable().optional(),
+})
+    .passthrough();
+export function parseCodexThreadForkResponse(response) {
+    return CodexThreadForkResponseSchema.parse(response);
+}
+const CodexThreadRollbackResponseSchema = z
+    .object({
+    thread: z
+        .object({
+        id: z.string(),
+        sessionId: z.string().optional(),
+        forkedFromId: z.string().nullable().optional(),
+        turns: z.array(z.unknown()).optional(),
+    })
+        .passthrough(),
+})
+    .passthrough();
+export function parseCodexThreadRollbackResponse(response) {
+    return CodexThreadRollbackResponseSchema.parse(response);
+}
+function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isJsonRpcResponse(msg) {
+    if (!isRecord(msg))
+        return false;
+    return typeof msg.id === "number";
+}
+function isJsonRpcRequest(msg) {
+    if (!isRecord(msg))
+        return false;
+    return typeof msg.id === "number" && typeof msg.method === "string";
+}
+function isJsonRpcNotification(msg) {
+    if (!isRecord(msg))
+        return false;
+    return typeof msg.method === "string" && msg.id === undefined;
+}
+function readProviderSessionId(params) {
+    if (!isRecord(params)) {
+        return undefined;
+    }
+    return typeof params.threadId === "string" ? params.threadId : undefined;
+}
+function readProviderTurnId(params) {
+    if (!isRecord(params)) {
+        return undefined;
+    }
+    if (typeof params.turnId === "string") {
+        return params.turnId;
+    }
+    const turn = params.turn;
+    return isRecord(turn) && typeof turn.id === "string" ? turn.id : undefined;
+}
+export class CodexAppServerClient {
+    constructor(child, logger, getTraceContext = () => ({})) {
+        this.child = child;
+        this.logger = logger;
+        this.getTraceContext = getTraceContext;
+        this.pending = new Map();
+        this.requestHandlers = new Map();
+        this.notificationHandler = null;
+        this.nextId = 1;
+        this.disposed = false;
+        this.stderrBuffer = "";
+        this.rl = readline.createInterface({ input: child.stdout });
+        this.rl.on("line", (line) => {
+            void this.handleLine(line).catch((error) => {
+                this.logger.warn({ error, line }, "Failed to handle Codex app-server stdout line");
+            });
+        });
+        child.stderr.on("data", (chunk) => {
+            this.stderrBuffer += chunk.toString();
+            if (this.stderrBuffer.length > STDERR_BUFFER_LIMIT) {
+                this.stderrBuffer = this.stderrBuffer.slice(-STDERR_BUFFER_LIMIT);
+            }
+        });
+        child.on("error", (err) => {
+            this.logger.error({ err }, "Codex app-server child process error");
+            for (const pending of this.pending.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(err);
+            }
+            this.pending.clear();
+            this.disposed = true;
+        });
+        child.on("exit", (code, signal) => {
+            const message = code === 0 && !signal
+                ? "Codex app-server exited"
+                : `Codex app-server exited with code ${code ?? "null"} and signal ${signal ?? "null"}`;
+            const error = new Error(`${message}\n${this.stderrBuffer}`.trim());
+            for (const pending of this.pending.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(error);
+            }
+            this.pending.clear();
+            this.disposed = true;
+        });
+    }
+    setNotificationHandler(handler) {
+        this.notificationHandler = handler;
+    }
+    setRequestHandler(method, handler) {
+        this.requestHandlers.set(method, handler);
+    }
+    request(method, params, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        if (this.disposed) {
+            return Promise.reject(new Error("Codex app-server client is closed"));
+        }
+        const id = this.nextId++;
+        const payload = { id, method, params };
+        const serialized = JSON.stringify(payload);
+        this.child.stdin.write(`${serialized}\n`);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Codex app-server request timed out for ${method}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+    }
+    async forkThread(params) {
+        return parseCodexThreadForkResponse(await this.request("thread/fork", params));
+    }
+    async rollbackThread(params) {
+        return parseCodexThreadRollbackResponse(await this.request("thread/rollback", params));
+    }
+    notify(method, params) {
+        if (this.disposed) {
+            return;
+        }
+        const payload = { method, params };
+        this.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.rl.close();
+        try {
+            this.child.stdin.end();
+        }
+        catch {
+            // ignore
+        }
+        const result = await terminateWithTreeKill(this.child, {
+            gracefulTimeoutMs: APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
+            forceTimeoutMs: APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
+            onForceSignal: () => {
+                this.logger.warn({ timeoutMs: APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS }, "Codex app-server did not exit after SIGTERM; sending SIGKILL");
+            },
+        });
+        if (result === "kill-timeout") {
+            this.logger.warn({ timeoutMs: APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "Codex app-server did not report exit after SIGKILL");
+        }
+    }
+    writeJsonRpcResponse(response) {
+        if (this.disposed || this.child.stdin.destroyed || !this.child.stdin.writable) {
+            return;
+        }
+        try {
+            this.child.stdin.write(`${JSON.stringify(response)}\n`);
+        }
+        catch (error) {
+            this.logger.debug({ error }, "Failed to write Codex app-server JSON-RPC response");
+        }
+    }
+    async handleLine(line) {
+        if (!line.trim())
+            return;
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch (error) {
+            this.logger.warn({ error, line }, "Ignoring non-JSON Codex app-server stdout line");
+            return;
+        }
+        if (!isRecord(raw)) {
+            this.logger.warn({ line }, "Parsed JSON is not an object");
+            return;
+        }
+        if (isJsonRpcResponse(raw)) {
+            const id = raw.id;
+            if (raw.result !== undefined || raw.error) {
+                const pending = this.pending.get(id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                this.pending.delete(id);
+                if (raw.error) {
+                    pending.reject(new Error(raw.error.message ?? "Unknown error"));
+                }
+                else {
+                    pending.resolve(raw.result);
+                }
+                return;
+            }
+            if (isJsonRpcRequest(raw)) {
+                const request = raw;
+                this.traceRawEvent(request);
+                const handler = this.requestHandlers.get(request.method);
+                try {
+                    const result = handler ? await handler(request.params) : {};
+                    this.writeJsonRpcResponse({ id: request.id, result });
+                }
+                catch (error) {
+                    this.writeJsonRpcResponse({
+                        id: request.id,
+                        error: { message: error instanceof Error ? error.message : String(error) },
+                    });
+                }
+                return;
+            }
+        }
+        if (isJsonRpcNotification(raw)) {
+            this.traceRawEvent(raw);
+            this.notificationHandler?.(raw.method, raw.params);
+        }
+    }
+    traceRawEvent(raw) {
+        const traceContext = this.getTraceContext();
+        this.logger.trace({
+            provider: "codex",
+            agentId: traceContext.agentId,
+            sessionId: traceContext.sessionId ?? readProviderSessionId(raw.params),
+            turnId: traceContext.turnId ?? readProviderTurnId(raw.params),
+            method: raw.method,
+            params: raw.params,
+            rawEvent: raw,
+        }, "provider.codex.raw_event");
+    }
+}
+//# sourceMappingURL=app-server-transport.js.map

package/dist/server/server/agent/providers/codex/rewind.d.ts

@@ -0,0 +1,21 @@
+import type { CodexThreadForkParams, CodexThreadForkResponse, CodexThreadRollbackParams, CodexThreadRollbackResponse } from "./app-server-transport.js";
+export interface CodexRewindClient {
+    forkThread?(params: CodexThreadForkParams): Promise<CodexThreadForkResponse>;
+    rollbackThread?(params: CodexThreadRollbackParams): Promise<CodexThreadRollbackResponse>;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+}
+export interface CodexUserMessageTurnIndex {
+    resolve(messageId: string): number | null;
+    count(): number;
+}
+export declare function revertCodexConversation(input: {
+    client: CodexRewindClient;
+    threadId: string | null;
+    messageId: string;
+    cwd?: string | null;
+    model?: string | null;
+    serviceTier?: string | null;
+    userMessageTurns: CodexUserMessageTurnIndex;
+    setThreadId: (threadId: string) => void | Promise<void>;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map