@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,290 @@
+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;
+export class CodexAppServerRpcError extends Error {
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "CodexAppServerRpcError";
+    }
+}
+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.unexpectedTerminationHandler = 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");
+            this.handleUnexpectedTermination(err);
+        });
+        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());
+            this.handleUnexpectedTermination(error);
+        });
+    }
+    setUnexpectedTerminationHandler(handler) {
+        this.unexpectedTerminationHandler = handler;
+    }
+    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() {
+        this.disposed = true;
+        this.unexpectedTerminationHandler = null;
+        this.rl.close();
+        this.rejectPending(new Error("Codex app-server client is closed"));
+        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") {
+            throw new Error("Codex app-server did not report exit after SIGKILL");
+        }
+    }
+    handleUnexpectedTermination(error) {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.rl.close();
+        this.rejectPending(error);
+        const handler = this.unexpectedTerminationHandler;
+        this.unexpectedTerminationHandler = null;
+        if (!handler) {
+            return;
+        }
+        try {
+            handler(error);
+        }
+        catch (handlerError) {
+            this.logger.warn({ err: handlerError }, "Codex app-server termination handler threw");
+        }
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    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 CodexAppServerRpcError(raw.error.message ?? "Unknown error", raw.error.code, raw.error.data));
+                }
+                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, request.id) : {};
+                    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/async-questions.d.ts

@@ -0,0 +1,18 @@
+import type { AgentPermissionRequest, AgentPermissionResponse, ToolCallTimelineItem } from "../../agent-sdk-types.js";
+export declare function codexAsyncQuestionToTimeline(item: unknown): ToolCallTimelineItem | null;
+/** Codex emits these as completed messages; the outstanding answer belongs to the session. */
+export declare class CodexAsyncQuestions {
+    private readonly records;
+    constructor(saved: unknown);
+    receive(item: unknown): AgentPermissionRequest | null;
+    pending(): AgentPermissionRequest[];
+    hasPending(id: string): boolean;
+    prepareResponse(id: string, response: AgentPermissionResponse): {
+        prompt?: string;
+        complete: () => ToolCallTimelineItem;
+    };
+    timeline(itemId: string): ToolCallTimelineItem | null;
+    retain(itemIds: ReadonlySet<string>): string[];
+    serialize(): unknown;
+}
+//# sourceMappingURL=async-questions.d.ts.map

package/dist/server/server/agent/providers/codex/async-questions.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+const QuestionSchema = z.object({
+    title: z.string().trim().min(1),
+    options: z.array(z.string().min(1)).nullish(),
+});
+const ItemSchema = z.object({
+    type: z.literal("agentMessage"),
+    id: z.string().min(1),
+    delivery: z.literal("async"),
+    questions: z.array(QuestionSchema).min(1),
+});
+const RecordSchema = z.object({
+    item: ItemSchema,
+    resolution: z.union([z.literal("dismissed"), z.array(z.string())]).optional(),
+});
+function requestId(itemId) {
+    return `permission-${itemId}`;
+}
+function toPermission(record) {
+    return {
+        id: requestId(record.item.id),
+        provider: "codex",
+        name: "request_user_input_async",
+        kind: "question",
+        title: "Question",
+        input: {
+            questions: record.item.questions.map((question, index) => ({
+                id: String(index),
+                header: `Question ${index + 1}`,
+                question: question.title,
+                options: (question.options ?? []).map((label) => ({ label })),
+                isOther: true,
+            })),
+        },
+    };
+}
+function toTimeline(record) {
+    const answers = Array.isArray(record.resolution) ? record.resolution : undefined;
+    return {
+        type: "tool_call",
+        callId: record.item.id,
+        name: "request_user_input_async",
+        status: "completed",
+        error: null,
+        detail: {
+            type: "plain_text",
+            icon: "brain",
+            text: record.item.questions
+                .map((question, index) => [question.title, answers ? answers[index] : (question.options ?? []).join(", ")]
+                .filter(Boolean)
+                .join("\n"))
+                .join("\n\n") + (record.resolution === "dismissed" ? "\n\nDismissed" : ""),
+        },
+    };
+}
+export function codexAsyncQuestionToTimeline(item) {
+    const parsed = ItemSchema.safeParse(item);
+    return parsed.success ? toTimeline({ item: parsed.data }) : null;
+}
+/** Codex emits these as completed messages; the outstanding answer belongs to the session. */
+export class CodexAsyncQuestions {
+    constructor(saved) {
+        this.records = new Map();
+        const parsed = z.array(RecordSchema).safeParse(saved);
+        if (parsed.success) {
+            for (const record of parsed.data)
+                this.records.set(requestId(record.item.id), record);
+        }
+    }
+    receive(item) {
+        const parsed = ItemSchema.safeParse(item);
+        if (!parsed.success || this.records.has(requestId(parsed.data.id)))
+            return null;
+        const record = { item: parsed.data };
+        this.records.set(requestId(parsed.data.id), record);
+        return toPermission(record);
+    }
+    pending() {
+        return Array.from(this.records.values())
+            .filter((record) => record.resolution === undefined)
+            .map(toPermission);
+    }
+    hasPending(id) {
+        const record = this.records.get(id);
+        return record !== undefined && record.resolution === undefined;
+    }
+    prepareResponse(id, response) {
+        const record = this.records.get(id);
+        if (!record || record.resolution !== undefined)
+            throw new Error("Question is no longer pending");
+        let resolution = "dismissed";
+        let prompt;
+        if (response.behavior === "allow") {
+            const answers = z.record(z.string(), z.string()).parse(response.updatedInput?.answers);
+            resolution = record.item.questions.map((_, index) => {
+                const answer = answers[`Question ${index + 1}`]?.trim();
+                if (!answer)
+                    throw new Error(`Answer Question ${index + 1} before submitting`);
+                return answer;
+            });
+            const values = resolution;
+            prompt =
+                "Answers to your questions:\n\n" +
+                    record.item.questions
+                        .map((question, index) => `${question.title}\n${values[index]}`)
+                        .join("\n\n");
+        }
+        return {
+            prompt,
+            complete: () => {
+                record.resolution = resolution;
+                return toTimeline(record);
+            },
+        };
+    }
+    timeline(itemId) {
+        const record = this.records.get(requestId(itemId));
+        return record ? toTimeline(record) : null;
+    }
+    retain(itemIds) {
+        const removedPendingIds = [];
+        for (const [id, record] of this.records) {
+            if (itemIds.has(record.item.id))
+                continue;
+            this.records.delete(id);
+            if (record.resolution === undefined)
+                removedPendingIds.push(id);
+        }
+        return removedPendingIds;
+    }
+    serialize() {
+        return Array.from(this.records.values());
+    }
+}
+//# sourceMappingURL=async-questions.js.map

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

@@ -0,0 +1,59 @@
+import type { ToolPolicy } from "@camerontaylor/paseo-protocol/agent-types";
+import { z } from "zod";
+export declare const CodexProviderOptionsSchema: z.ZodObject<{
+    approval_policy: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        never: "never";
+        untrusted: "untrusted";
+        "on-request": "on-request";
+    }>, z.ZodObject<{
+        granular: z.ZodObject<{
+            sandbox_approval: z.ZodOptional<z.ZodBoolean>;
+            rules: z.ZodOptional<z.ZodBoolean>;
+            mcp_elicitations: z.ZodOptional<z.ZodBoolean>;
+            request_permissions: z.ZodOptional<z.ZodBoolean>;
+            skill_approval: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>;
+    sandbox_mode: z.ZodOptional<z.ZodEnum<{
+        "read-only": "read-only";
+        "workspace-write": "workspace-write";
+        "danger-full-access": "danger-full-access";
+    }>>;
+    sandbox_workspace_write: z.ZodOptional<z.ZodObject<{
+        writable_roots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        network_access: z.ZodOptional<z.ZodBoolean>;
+        exclude_slash_tmp: z.ZodOptional<z.ZodBoolean>;
+        exclude_tmpdir_env_var: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    web_search: z.ZodOptional<z.ZodEnum<{
+        live: "live";
+        disabled: "disabled";
+        cached: "cached";
+        indexed: "indexed";
+    }>>;
+    features: z.ZodOptional<z.ZodObject<{
+        network_proxy: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            proxy_url: z.ZodOptional<z.ZodString>;
+            socks_url: z.ZodOptional<z.ZodString>;
+            enable_socks5: z.ZodOptional<z.ZodBoolean>;
+            enable_socks5_udp: z.ZodOptional<z.ZodBoolean>;
+            allow_local_binding: z.ZodOptional<z.ZodBoolean>;
+            allow_upstream_proxy: z.ZodOptional<z.ZodBoolean>;
+            dangerously_allow_all_unix_sockets: z.ZodOptional<z.ZodBoolean>;
+            dangerously_allow_non_loopback_proxy: z.ZodOptional<z.ZodBoolean>;
+            domains: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>>>;
+            unix_sockets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>>>;
+        }, z.core.$strict>]>>;
+        multi_agent_v2: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CodexProviderOptions = z.infer<typeof CodexProviderOptionsSchema>;
+export declare function applyCodexToolPolicy(config: Record<string, unknown>, toolPolicy: ToolPolicy | undefined): Record<string, unknown>;
+//# sourceMappingURL=options.d.ts.map

package/dist/server/server/agent/providers/codex/options.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+const ApprovalPolicySchema = z.union([
+    z.enum(["untrusted", "on-request", "never"]),
+    z
+        .object({
+        granular: z
+            .object({
+            sandbox_approval: z.boolean().optional(),
+            rules: z.boolean().optional(),
+            mcp_elicitations: z.boolean().optional(),
+            request_permissions: z.boolean().optional(),
+            skill_approval: z.boolean().optional(),
+        })
+            .strict(),
+    })
+        .strict(),
+]);
+const NetworkPolicySchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    proxy_url: z.string().optional(),
+    socks_url: z.string().optional(),
+    enable_socks5: z.boolean().optional(),
+    enable_socks5_udp: z.boolean().optional(),
+    allow_local_binding: z.boolean().optional(),
+    allow_upstream_proxy: z.boolean().optional(),
+    dangerously_allow_all_unix_sockets: z.boolean().optional(),
+    dangerously_allow_non_loopback_proxy: z.boolean().optional(),
+    domains: z.record(z.string(), z.enum(["allow", "deny"])).optional(),
+    unix_sockets: z.record(z.string(), z.enum(["allow", "deny"])).optional(),
+})
+    .strict();
+// Codex config reference, maintained against Codex CLI 0.143+.
+export const CodexProviderOptionsSchema = z
+    .object({
+    approval_policy: ApprovalPolicySchema.optional(),
+    sandbox_mode: z.enum(["read-only", "workspace-write", "danger-full-access"]).optional(),
+    sandbox_workspace_write: z
+        .object({
+        writable_roots: z.array(z.string()).optional(),
+        network_access: z.boolean().optional(),
+        exclude_slash_tmp: z.boolean().optional(),
+        exclude_tmpdir_env_var: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+    web_search: z.enum(["disabled", "cached", "indexed", "live"]).optional(),
+    features: z
+        .object({
+        network_proxy: z.union([z.boolean(), NetworkPolicySchema]).optional(),
+        multi_agent_v2: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export function applyCodexToolPolicy(config, toolPolicy) {
+    if (!toolPolicy)
+        return config;
+    const mcpServers = readRecord(config.mcp_servers);
+    const grantsByServer = new Map();
+    for (const grant of toolPolicy.preapproved) {
+        const tools = grantsByServer.get(grant.server) ?? [];
+        tools.push(grant.tool);
+        grantsByServer.set(grant.server, tools);
+    }
+    for (const [server, tools] of grantsByServer) {
+        const serverConfig = readRecord(mcpServers[server]);
+        const approvals = Object.fromEntries(tools.map((tool) => [tool, { approval_mode: "approve" }]));
+        mcpServers[server] = {
+            ...serverConfig,
+            enabled_tools: tools,
+            default_tools_approval_mode: "prompt",
+            tools: approvals,
+        };
+    }
+    return { ...config, mcp_servers: mcpServers };
+}
+function readRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+//# sourceMappingURL=options.js.map

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

@@ -0,0 +1,24 @@
+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): {
+        index: number;
+        turnId: string | null;
+    } | 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

package/dist/server/server/agent/providers/codex/rewind.js

@@ -0,0 +1,77 @@
+import { parseCodexThreadForkResponse, parseCodexThreadRollbackResponse, } from "./app-server-transport.js";
+async function readCodexThreadHistoryMode(client, threadId) {
+    const response = await client.request("thread/read", { threadId, includeTurns: false });
+    if (typeof response !== "object" || response === null || !("thread" in response)) {
+        throw new Error("Codex thread/read did not return thread metadata");
+    }
+    const thread = response.thread;
+    if (typeof thread !== "object" || thread === null || !("historyMode" in thread)) {
+        return "legacy";
+    }
+    if (thread.historyMode === "legacy" || thread.historyMode === "paginated") {
+        return thread.historyMode;
+    }
+    throw new Error(`Codex thread/read returned unknown history mode ${String(thread.historyMode)}`);
+}
+async function forkCodexThread(client, params) {
+    if (client.forkThread) {
+        return client.forkThread(params);
+    }
+    return parseCodexThreadForkResponse(await client.request("thread/fork", params));
+}
+async function rollbackCodexThread(client, params) {
+    if (client.rollbackThread) {
+        return client.rollbackThread(params);
+    }
+    return parseCodexThreadRollbackResponse(await client.request("thread/rollback", params));
+}
+export async function revertCodexConversation(input) {
+    if (!input.threadId) {
+        throw new Error("Codex thread is not ready for rewind");
+    }
+    const targetTurn = input.userMessageTurns.resolve(input.messageId);
+    if (targetTurn === null) {
+        throw new Error(`Codex could not find user message ${input.messageId} in the current thread`);
+    }
+    const currentUserTurnCount = input.userMessageTurns.count();
+    const numTurns = currentUserTurnCount - targetTurn.index;
+    if (numTurns < 0) {
+        throw new Error(`Codex user message ${input.messageId} is outside the current thread`);
+    }
+    const historyMode = await readCodexThreadHistoryMode(input.client, input.threadId);
+    if (historyMode === "paginated") {
+        if (!targetTurn.turnId) {
+            throw new Error(`Codex could not find the turn containing user message ${input.messageId}`);
+        }
+        const forked = await forkCodexThread(input.client, {
+            threadId: input.threadId,
+            beforeTurnId: targetTurn.turnId,
+            cwd: input.cwd ?? null,
+            model: input.model ?? null,
+            serviceTier: input.serviceTier ?? null,
+            excludeTurns: false,
+            persistExtendedHistory: true,
+        });
+        await input.setThreadId(forked.thread.id);
+        return;
+    }
+    // Fork is non-destructive: the old thread file stays on disk and remains
+    // recoverable with `codex resume <old-uuid>` if the rewind target was wrong.
+    const forked = await forkCodexThread(input.client, {
+        threadId: input.threadId,
+        cwd: input.cwd ?? null,
+        model: input.model ?? null,
+        serviceTier: input.serviceTier ?? null,
+        excludeTurns: false,
+        persistExtendedHistory: true,
+    });
+    const forkedThreadId = forked.thread.id;
+    // Codex rollback is chat-only by design. File edits from rewound turns stay
+    // on disk; a future file primitive would be a separate capability.
+    const rolledBack = await rollbackCodexThread(input.client, {
+        threadId: forkedThreadId,
+        numTurns,
+    });
+    await input.setThreadId(rolledBack.thread.id);
+}
+//# sourceMappingURL=rewind.js.map