@getpaseo/server 0.1.80 → 0.1.82

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

@@ -9,14 +9,15 @@ import { z } from "zod";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
 import { curateAgentActivity } from "../activity-curator.js";
-import { mapCodexRolloutToolCall, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
+import { mapCodexToolCallEnvelope, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
 import { createProviderEnv, createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable, probeExecutable } from "../../../utils/executable.js";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
-import { CodexAppServerClient, } from "./codex/app-server-transport.js";
+import { CodexAppServerClient, parseCodexThreadForkResponse, parseCodexThreadRollbackResponse, } from "./codex/app-server-transport.js";
+import { revertCodexConversation } from "./codex/rewind.js";
 import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
@@ -89,6 +90,9 @@ const CODEX_APP_SERVER_CAPABILITIES = {
     supportsMcpServers: true,
     supportsReasoningStream: true,
     supportsToolInvocations: true,
+    supportsRewindConversation: true,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
 };
 const CODEX_MODES = [
     {
@@ -210,7 +214,7 @@ function normalizeCodexOutputSchemaNode(schema, schemaPath) {
     normalized.required = Array.from(new Set([...existingRequired, ...propertyKeys]));
     return normalized;
 }
-function normalizeCodexOutputSchema(schema) {
+export function normalizeCodexOutputSchema(schema) {
     if (!isSchemaRecord(schema)) {
         throw new Error("Codex structured outputs require a JSON object schema.");
     }
@@ -233,7 +237,7 @@ function codexMicrosoftStorePackageRoot() {
     }
     return path.join(localAppData, "Packages");
 }
-async function findCodexMicrosoftStoreBinary() {
+export async function findCodexMicrosoftStoreBinary() {
     if (process.platform !== "win32") {
         return null;
     }
@@ -260,7 +264,7 @@ async function findCodexMicrosoftStoreBinary() {
     }
     return null;
 }
-async function findDefaultCodexBinary() {
+export async function findDefaultCodexBinary() {
     return (await findExecutable("codex")) ?? (await findCodexMicrosoftStoreBinary());
 }
 async function resolveCodexBinary() {
@@ -408,7 +412,7 @@ async function listCodexCustomPrompts() {
     const commands = parsedCommands.filter((cmd) => cmd !== null);
     return commands.sort((a, b) => a.name.localeCompare(b.name));
 }
-async function listCodexSkills(cwd, workspaceGitService) {
+export async function listCodexSkills(cwd, workspaceGitService) {
     const candidates = [];
     candidates.push(path.join(cwd, ".codex", "skills"));
     const repoRoot = workspaceGitService
@@ -552,7 +556,7 @@ function filterCodexThreadsByCwd(threads, cwd) {
     const matchesCwd = createPathEquivalenceMatcher(cwd);
     return threads.filter((thread) => typeof thread.cwd === "string" && matchesCwd(thread.cwd));
 }
-function toAgentUsage(tokenUsage) {
+export function toAgentUsage(tokenUsage) {
     const usage = toObjectRecord(tokenUsage);
     if (!usage)
         return undefined;
@@ -589,7 +593,7 @@ function normalizePlanMarkdown(text) {
         .join("\n")
         .trim();
 }
-function planStepsToMarkdown(steps) {
+export function planStepsToMarkdown(steps) {
     const lines = steps
         .map((entry) => entry.step.trim())
         .filter((step) => step.length > 0)
@@ -601,7 +605,7 @@ function planStepsToMarkdown(steps) {
     });
     return normalizePlanMarkdown(lines.join("\n"));
 }
-function mapCodexPlanToToolCall(params) {
+export function mapCodexPlanToToolCall(params) {
     const text = normalizePlanMarkdown(params.text);
     if (!text) {
         return null;
@@ -658,7 +662,7 @@ function buildCodexPlanImplementationPrompt(planText) {
         "Carry out the work, make the necessary code changes, and verify the result.",
     ].join("\n\n");
 }
-function normalizeCodexQuestionPrompts(raw) {
+export function normalizeCodexQuestionPrompts(raw) {
     if (!Array.isArray(raw)) {
         return [];
     }
@@ -707,7 +711,7 @@ function normalizeCodexQuestionPrompts(raw) {
     }
     return questions;
 }
-function formatCodexQuestionPrompts(questions) {
+export function formatCodexQuestionPrompts(questions) {
     return questions
         .map((question) => {
         const lines = [`${question.header}: ${question.question}`];
@@ -719,7 +723,7 @@ function formatCodexQuestionPrompts(questions) {
         .join("\n\n")
         .trim();
 }
-function mapCodexQuestionRequestToToolCall(params) {
+export function mapCodexQuestionRequestToToolCall(params) {
     const formattedQuestions = formatCodexQuestionPrompts(params.questions);
     const formattedAnswers = params.answers && Object.keys(params.answers).length > 0
         ? Object.entries(params.answers)
@@ -1025,7 +1029,7 @@ function mapCodexExecNotificationToToolCall(params) {
                 ? { exitCode: params.exitCode }
                 : {}),
         };
-    const mapped = mapCodexRolloutToolCall({
+    const mapped = mapCodexToolCallEnvelope({
         callId: params.callId ?? null,
         name: "shell",
         input: {
@@ -1041,7 +1045,7 @@ function mapCodexExecNotificationToToolCall(params) {
     }
     return params.running ? toRunningToolCall(mapped) : mapped;
 }
-function mapCodexPatchNotificationToToolCall(params) {
+export function mapCodexPatchNotificationToToolCall(params) {
     const files = parseCodexPatchChanges(params.changes);
     const firstPath = files[0]?.path;
     const firstPatchText = files
@@ -1049,7 +1053,7 @@ function mapCodexPatchNotificationToToolCall(params) {
         .find((value) => typeof value === "string" && value.length > 0);
     const patchText = firstPatchText;
     const patchFields = codexPatchTextFields(patchText);
-    const mapped = mapCodexRolloutToolCall({
+    const mapped = mapCodexToolCallEnvelope({
         callId: params.callId ?? null,
         name: "apply_patch",
         input: firstPath
@@ -1125,7 +1129,12 @@ function mapCodexThreadUserMessageItem(normalizedItem, includeUserMessage) {
         return null;
     }
     const text = extractUserText(normalizedItem.content) ?? "";
-    return { type: "user_message", text };
+    const messageId = nonEmptyString(normalizedItem.id);
+    return {
+        type: "user_message",
+        text,
+        ...(messageId ? { messageId } : {}),
+    };
 }
 function firstStringField(record, fields) {
     for (const field of fields) {
@@ -1209,7 +1218,7 @@ function mapCodexThreadImageItem(normalizedType, normalizedItem) {
         mimeType: result?.mimeType ?? null,
     }, { materialize: materializeCodexImageOutput });
 }
-function threadItemToTimeline(item, options) {
+export function threadItemToTimeline(item, options) {
     const itemRecord = toObjectRecord(item);
     if (!itemRecord)
         return null;
@@ -1292,6 +1301,18 @@ function readCodexThread(client, threadId) {
         includeTurns: true,
     });
 }
+export async function forkCodexThread(client, params) {
+    if (client.forkThread) {
+        return client.forkThread(params);
+    }
+    return parseCodexThreadForkResponse(await client.request("thread/fork", params));
+}
+export async function rollbackCodexThread(client, params) {
+    if (client.rollbackThread) {
+        return client.rollbackThread(params);
+    }
+    return parseCodexThreadRollbackResponse(await client.request("thread/rollback", params));
+}
 function toSandboxPolicy(type, networkAccess) {
     switch (type) {
         case "read-only":
@@ -1547,6 +1568,23 @@ const CodexEventTurnDiffNotificationSchema = z
         .passthrough(),
 })
     .passthrough();
+const CodexEventThreadRolledBackNotificationSchema = z
+    .object({
+    msg: z
+        .object({
+        type: z.literal("thread_rolled_back"),
+        num_turns: z.number().int().nonnegative().optional(),
+        numTurns: z.number().int().nonnegative().optional(),
+    })
+        .passthrough(),
+})
+    .passthrough();
+function isCodexDeltaNotification(parsed) {
+    return (parsed.kind === "agent_message_delta" ||
+        parsed.kind === "reasoning_delta" ||
+        parsed.kind === "exec_command_output_delta" ||
+        parsed.kind === "file_change_output_delta");
+}
 const CodexNotificationSchema = z.union([
     z
         .object({ method: z.literal("thread/started"), params: ThreadStartedNotificationSchema })
@@ -1920,6 +1958,20 @@ const CodexNotificationSchema = z.union([
         method,
         params,
     })),
+    z
+        .object({
+        method: z.literal("codex/event/thread_rolled_back"),
+        params: CodexEventThreadRolledBackNotificationSchema,
+    })
+        .transform(({ params }) => ({
+        kind: "thread_rolled_back",
+        numTurns: params.msg.num_turns ?? params.msg.numTurns ?? 0,
+    })),
+    z.object({ method: z.literal("codex/event/thread_rolled_back"), params: z.unknown() }).transform(({ method, params }) => ({
+        kind: "invalid_payload",
+        method,
+        params,
+    })),
     z
         .object({ method: z.string(), params: z.unknown() })
         .transform(({ method, params }) => ({ kind: "unknown_method", method, params })),
@@ -2013,7 +2065,7 @@ function toCodexTextInput(text) {
         text_elements: [],
     };
 }
-function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
+export function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
     return createProviderEnv({
         runtimeSettings,
         overlays: [launchEnv],
@@ -2070,7 +2122,7 @@ function buildCodexCustomProviderConfig(runtimeSettings, customProvider) {
         },
     };
 }
-class CodexAppServerAgentSession {
+export class CodexAppServerAgentSession {
     constructor(config, resumeHandle, logger, spawnAppServer, deps = {}, ephemeral = false, goalsEnabled = false, autoReviewEnabled = false, agentId) {
         this.resumeHandle = resumeHandle;
         this.spawnAppServer = spawnAppServer;
@@ -2113,6 +2165,8 @@ class CodexAppServerAgentSession {
         this.warnedInvalidNotificationPayloads = new Set();
         this.warnedIncompleteEditToolCallIds = new Set();
         this.latestPlanResult = null;
+        this.userMessageTurnIndexes = new Map();
+        this.userMessageTurnIds = [];
         this.pendingManualCompactionStarts = 0;
         this.compactionTriggerByItemId = new Map();
         // Codex can report one completed compaction through both channels:
@@ -2362,21 +2416,22 @@ class CodexAppServerAgentSession {
             return;
         const client = this.client;
         const threadId = this.currentThreadId;
-        try {
-            const timeline = await loadCodexThreadHistoryTimeline({
-                threadId,
-                cwd: this.config.cwd ?? null,
-                requestThread: (threadIdToRead) => {
-                    return readCodexThread(client, threadIdToRead);
-                },
-            });
-            if (timeline.length > 0) {
-                this.persistedHistory = timeline;
-                this.historyPending = true;
+        const timeline = await loadCodexThreadHistoryTimeline({
+            threadId,
+            cwd: this.config.cwd ?? null,
+            requestThread: (threadIdToRead) => {
+                return readCodexThread(client, threadIdToRead);
+            },
+        });
+        this.resetCodexUserMessageTurns();
+        for (const entry of timeline) {
+            if (entry.item.type === "user_message") {
+                this.rememberCodexUserMessageTurn(entry.item.messageId);
             }
         }
-        catch (error) {
-            this.logger.warn({ error }, "Failed to load Codex thread history");
+        if (timeline.length > 0) {
+            this.persistedHistory = timeline;
+            this.historyPending = true;
         }
     }
     async ensureThreadLoaded() {
@@ -2592,6 +2647,37 @@ class CodexAppServerAgentSession {
         }
         return { turnId };
     }
+    rememberCodexUserMessageTurn(messageId) {
+        if (typeof messageId !== "string" || messageId.length === 0) {
+            return false;
+        }
+        if (this.userMessageTurnIndexes.has(messageId)) {
+            return false;
+        }
+        this.userMessageTurnIndexes.set(messageId, this.userMessageTurnIds.length);
+        this.userMessageTurnIds.push(messageId);
+        return true;
+    }
+    resetCodexUserMessageTurns() {
+        this.userMessageTurnIndexes.clear();
+        this.userMessageTurnIds.length = 0;
+    }
+    truncateCodexUserMessageTurns(numTurns) {
+        if (numTurns <= 0) {
+            return;
+        }
+        this.userMessageTurnIds.length = Math.max(0, this.userMessageTurnIds.length - numTurns);
+        this.userMessageTurnIndexes.clear();
+        this.userMessageTurnIds.forEach((messageId, index) => {
+            this.userMessageTurnIndexes.set(messageId, index);
+        });
+    }
+    codexUserMessageTurns() {
+        return {
+            resolve: (messageId) => this.userMessageTurnIndexes.get(messageId) ?? null,
+            count: () => this.userMessageTurnIds.length,
+        };
+    }
     subscribe(callback) {
         this.subscribers.add(callback);
         return () => {
@@ -2826,6 +2912,34 @@ class CodexAppServerAgentSession {
             },
         };
     }
+    async revertConversation(input) {
+        await this.connect();
+        if (!this.client) {
+            throw new Error("Codex client is not initialized");
+        }
+        if (this.currentThreadId) {
+            await this.ensureThreadLoaded();
+        }
+        else {
+            await this.ensureThread();
+        }
+        await revertCodexConversation({
+            client: this.client,
+            threadId: this.currentThreadId,
+            messageId: input.messageId,
+            cwd: this.config.cwd ?? null,
+            model: this.config.model ?? null,
+            serviceTier: this.serviceTier,
+            userMessageTurns: this.codexUserMessageTurns(),
+            setThreadId: async (threadId) => {
+                this.currentThreadId = threadId;
+                this.cachedRuntimeInfo = null;
+                this.persistedHistory = [];
+                this.historyPending = false;
+                await this.loadPersistedHistory();
+            },
+        });
+    }
     async interrupt() {
         if (!this.client || !this.currentThreadId || !this.currentTurnId)
             return;
@@ -3142,6 +3256,13 @@ class CodexAppServerAgentSession {
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
         this.traceParsedNotification(method, params, parsed);
+        if (isCodexDeltaNotification(parsed)) {
+            this.handleCodexDeltaNotification(parsed);
+            return;
+        }
+        if (this.handleThreadStateNotification(parsed)) {
+            return;
+        }
         switch (parsed.kind) {
             case "thread_started":
                 this.handleThreadStartedNotification(parsed);
@@ -3163,15 +3284,6 @@ class CodexAppServerAgentSession {
             case "token_usage_updated":
                 this.handleTokenUsageUpdatedNotification(parsed);
                 return;
-            case "context_compacted":
-                this.handleContextCompactedNotification(parsed);
-                return;
-            case "agent_message_delta":
-            case "reasoning_delta":
-            case "exec_command_output_delta":
-            case "file_change_output_delta":
-                this.handleCodexDeltaNotification(parsed);
-                return;
             case "exec_command_started":
                 this.handleExecCommandStartedNotification(parsed);
                 return;
@@ -3196,8 +3308,23 @@ class CodexAppServerAgentSession {
             case "invalid_payload":
                 this.warnInvalidNotificationPayload(parsed.method, parsed.params);
                 return;
-            default:
+            case "unknown_method":
                 this.warnUnknownNotificationMethod(parsed.method, parsed.params);
+                return;
+            default:
+                return;
+        }
+    }
+    handleThreadStateNotification(parsed) {
+        switch (parsed.kind) {
+            case "context_compacted":
+                this.handleContextCompactedNotification(parsed);
+                return true;
+            case "thread_rolled_back":
+                this.handleThreadRolledBackNotification(parsed);
+                return true;
+            default:
+                return false;
         }
     }
     traceParsedNotification(method, params, parsed) {
@@ -3501,6 +3628,13 @@ class CodexAppServerAgentSession {
         return (normalizeCodexThreadItemType(typeof item.type === "string" ? item.type : undefined) ===
             CODEX_CONTEXT_COMPACTION_TYPE);
     }
+    isUserMessageItem(item) {
+        return (normalizeCodexThreadItemType(typeof item.type === "string" ? item.type : undefined) ===
+            "userMessage");
+    }
+    handleThreadRolledBackNotification(parsed) {
+        this.truncateCodexUserMessageTurns(parsed.numTurns);
+    }
     handleContextCompactedNotification(parsed) {
         if (parsed.threadId !== this.currentThreadId) {
             return;
@@ -3613,6 +3747,10 @@ class CodexAppServerAgentSession {
         if (parsed.source === "codex_event") {
             return;
         }
+        if (this.isUserMessageItem(parsed.item)) {
+            this.handleUserMessageItem(parsed);
+            return;
+        }
         if (this.isContextCompactionItem(parsed.item)) {
             if (this.unpairedCompactionNotificationCompletions > 0) {
                 this.unpairedCompactionNotificationCompletions -= 1;
@@ -3738,6 +3876,10 @@ class CodexAppServerAgentSession {
         if (parsed.source === "codex_event") {
             return;
         }
+        if (this.isUserMessageItem(parsed.item)) {
+            this.handleUserMessageItem(parsed);
+            return;
+        }
         if (this.isContextCompactionItem(parsed.item)) {
             this.emitEvent({
                 type: "timeline",
@@ -3781,6 +3923,28 @@ class CodexAppServerAgentSession {
             this.pendingFileChangeOutputDeltas.delete(itemId);
         }
     }
+    handleUserMessageItem(parsed) {
+        const itemId = parsed.item.id;
+        const timelineItem = threadItemToTimeline(parsed.item, {
+            includeUserMessage: true,
+            cwd: this.config.cwd ?? null,
+        });
+        if (!timelineItem || timelineItem.type !== "user_message") {
+            return;
+        }
+        const childSubAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+        if (childSubAgentCallId) {
+            if (itemId) {
+                this.upsertSubAgentChildItem(childSubAgentCallId, itemId, timelineItem);
+            }
+            this.emitSubAgentActivityUpdate(childSubAgentCallId, "running");
+            return;
+        }
+        if (!this.rememberCodexUserMessageTurn(timelineItem.messageId)) {
+            return;
+        }
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+    }
     warnUnknownNotificationMethod(method, params) {
         if (this.warnedUnknownNotificationMethods.has(method)) {
             return;
@@ -4343,22 +4507,4 @@ function resolveSkillDescription(skill) {
     }
     return "Skill";
 }
-export const __codexAppServerInternals = {
-    buildCodexAppServerEnv,
-    CodexAppServerClient,
-    codexModelSupportsFastMode,
-    CodexAppServerAgentSession,
-    findCodexMicrosoftStoreBinary,
-    findDefaultCodexBinary,
-    formatCodexQuestionPrompts,
-    mapCodexQuestionRequestToToolCall,
-    mapCodexPatchNotificationToToolCall,
-    planStepsToMarkdown,
-    mapCodexPlanToToolCall,
-    listCodexSkills,
-    normalizeCodexOutputSchema,
-    normalizeCodexQuestionPrompts,
-    toAgentUsage,
-    threadItemToTimeline,
-};
 //# sourceMappingURL=codex-app-server-agent.js.map