@getpaseo/server 0.1.32 → 0.1.34

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

@@ -337,48 +337,6 @@ function toCodexMcpConfig(config) {
             };
     }
 }
-class Pushable {
-    constructor() {
-        this.queue = [];
-        this.resolvers = [];
-        this.closed = false;
-    }
-    push(item) {
-        if (this.closed) {
-            return;
-        }
-        if (this.resolvers.length > 0) {
-            const resolve = this.resolvers.shift();
-            resolve({ value: item, done: false });
-        }
-        else {
-            this.queue.push(item);
-        }
-    }
-    end() {
-        this.closed = true;
-        while (this.resolvers.length > 0) {
-            const resolve = this.resolvers.shift();
-            resolve({ value: undefined, done: true });
-        }
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                if (this.queue.length > 0) {
-                    const value = this.queue.shift();
-                    return Promise.resolve({ value, done: false });
-                }
-                if (this.closed) {
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                return new Promise((resolve) => {
-                    this.resolvers.push(resolve);
-                });
-            },
-        };
-    }
-}
 class CodexAppServerClient {
     constructor(child, logger) {
         this.child = child;
@@ -1585,7 +1543,18 @@ export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
     }
     return output;
 }
+function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
+    const env = applyProviderEnv(process.env, runtimeSettings);
+    if (!launchEnv) {
+        return env;
+    }
+    return {
+        ...env,
+        ...launchEnv,
+    };
+}
 export const __codexAppServerInternals = {
+    buildCodexAppServerEnv,
     mapCodexPatchNotificationToToolCall,
 };
 class CodexAppServerAgentSession {
@@ -1597,7 +1566,9 @@ class CodexAppServerAgentSession {
         this.currentThreadId = null;
         this.currentTurnId = null;
         this.client = null;
-        this.eventQueue = null;
+        this.subscribers = new Set();
+        this.nextTurnOrdinal = 0;
+        this.activeForegroundTurnId = null;
         this.cachedRuntimeInfo = null;
         this.historyPending = false;
         this.persistedHistory = [];
@@ -1609,6 +1580,7 @@ class CodexAppServerAgentSession {
         this.pendingCommandOutputDeltas = new Map();
         this.pendingFileChangeOutputDeltas = new Map();
         this.terminalCommandByProcessId = new Map();
+        this.pendingUnlabeledTerminalInteractions = new Set();
         this.emittedTerminalInteractionKeys = new Set();
         this.emittedExecCommandStartedCallIds = new Set();
         this.emittedExecCommandCompletedCallIds = new Set();
@@ -1880,32 +1852,69 @@ class CodexAppServerAgentSession {
         return args ? `$${commandName} ${args}` : `$${commandName}`;
     }
     async run(prompt, options) {
-        const slashCommand = await this.resolveSlashCommandInvocation(prompt);
-        if (slashCommand) {
-            const commandInput = await this.buildCommandPromptInput(slashCommand.commandName, slashCommand.args);
-            return this.runInternal(commandInput, options);
-        }
-        return this.runInternal(prompt, options);
-    }
-    async runInternal(prompt, options) {
-        const events = this.streamInternal(prompt, options);
         const timeline = [];
         let finalText = "";
         let usage;
-        for await (const event of events) {
+        let turnId = null;
+        const bufferedEvents = [];
+        let settled = false;
+        let resolveCompletion;
+        let rejectCompletion;
+        const processEvent = (event) => {
+            if (settled) {
+                return;
+            }
+            const eventTurnId = event.turnId;
+            if (turnId && eventTurnId && eventTurnId !== turnId) {
+                return;
+            }
             if (event.type === "timeline") {
                 timeline.push(event.item);
                 if (event.item.type === "assistant_message") {
                     finalText = event.item.text;
                 }
+                return;
             }
-            else if (event.type === "turn_completed") {
+            if (event.type === "turn_completed") {
                 usage = event.usage;
+                settled = true;
+                resolveCompletion();
+                return;
+            }
+            if (event.type === "turn_failed") {
+                settled = true;
+                rejectCompletion(new Error(event.error));
+                return;
+            }
+            if (event.type === "turn_canceled") {
+                settled = true;
+                resolveCompletion();
+            }
+        };
+        const completion = new Promise((resolve, reject) => {
+            resolveCompletion = resolve;
+            rejectCompletion = reject;
+        });
+        const unsubscribe = this.subscribe((event) => {
+            if (!turnId) {
+                bufferedEvents.push(event);
+                return;
+            }
+            processEvent(event);
+        });
+        try {
+            const result = await this.startTurn(prompt, options);
+            turnId = result.turnId;
+            for (const event of bufferedEvents) {
+                processEvent(event);
             }
-            else if (event.type === "turn_failed") {
-                throw new Error(event.error);
+            if (!settled) {
+                await completion;
             }
         }
+        finally {
+            unsubscribe();
+        }
         const info = await this.getRuntimeInfo();
         return {
             sessionId: info.sessionId ?? "",
@@ -1914,96 +1923,78 @@ class CodexAppServerAgentSession {
             timeline,
         };
     }
-    async *stream(prompt, options) {
-        const slashCommand = await this.resolveSlashCommandInvocation(prompt);
-        if (slashCommand) {
-            const commandInput = await this.buildCommandPromptInput(slashCommand.commandName, slashCommand.args);
-            yield* this.streamInternal(commandInput, options);
-            return;
+    async startTurn(prompt, options) {
+        if (this.activeForegroundTurnId) {
+            throw new Error("A foreground turn is already active");
         }
-        yield* this.streamInternal(prompt, options);
-    }
-    async *streamInternal(prompt, options) {
         await this.connect();
-        if (!this.client)
-            return;
-        const queue = new Pushable();
-        this.eventQueue = queue;
-        try {
-            if (this.currentThreadId) {
-                await this.ensureThreadLoaded();
-            }
-            else {
-                await this.ensureThread();
-            }
-            const input = await this.buildUserInput(prompt);
-            const preset = MODE_PRESETS[this.currentMode] ?? MODE_PRESETS[DEFAULT_CODEX_MODE_ID];
-            const approvalPolicy = this.config.approvalPolicy ?? preset.approvalPolicy;
-            const sandboxPolicyType = this.config.sandboxMode ?? preset.sandbox;
-            const params = {
-                threadId: this.currentThreadId,
-                input,
-                approvalPolicy,
-                sandboxPolicy: toSandboxPolicy(sandboxPolicyType, typeof this.config.networkAccess === "boolean"
-                    ? this.config.networkAccess
-                    : preset.networkAccess),
+        if (!this.client) {
+            throw new Error("Codex client not initialized");
+        }
+        const slashCommand = await this.resolveSlashCommandInvocation(prompt);
+        const effectivePrompt = slashCommand
+            ? await this.buildCommandPromptInput(slashCommand.commandName, slashCommand.args)
+            : prompt;
+        if (this.currentThreadId) {
+            await this.ensureThreadLoaded();
+        }
+        else {
+            await this.ensureThread();
+        }
+        const input = await this.buildUserInput(effectivePrompt);
+        const preset = MODE_PRESETS[this.currentMode] ?? MODE_PRESETS[DEFAULT_CODEX_MODE_ID];
+        const approvalPolicy = this.config.approvalPolicy ?? preset.approvalPolicy;
+        const sandboxPolicyType = this.config.sandboxMode ?? preset.sandbox;
+        const params = {
+            threadId: this.currentThreadId,
+            input,
+            approvalPolicy,
+            sandboxPolicy: toSandboxPolicy(sandboxPolicyType, typeof this.config.networkAccess === "boolean"
+                ? this.config.networkAccess
+                : preset.networkAccess),
+        };
+        if (this.config.model) {
+            params.model = this.config.model;
+        }
+        const thinkingOptionId = normalizeCodexThinkingOptionId(this.config.thinkingOptionId);
+        if (thinkingOptionId) {
+            params.effort = thinkingOptionId;
+        }
+        if (this.resolvedCollaborationMode) {
+            params.collaborationMode = {
+                mode: this.resolvedCollaborationMode.mode,
+                settings: this.resolvedCollaborationMode.settings,
             };
-            if (this.config.model) {
-                params.model = this.config.model;
-            }
-            const thinkingOptionId = normalizeCodexThinkingOptionId(this.config.thinkingOptionId);
-            if (thinkingOptionId) {
-                params.effort = thinkingOptionId;
-            }
-            if (this.resolvedCollaborationMode) {
-                params.collaborationMode = {
-                    mode: this.resolvedCollaborationMode.mode,
-                    settings: this.resolvedCollaborationMode.settings,
-                };
-            }
-            if (this.config.cwd) {
-                params.cwd = this.config.cwd;
-            }
-            if (options?.outputSchema) {
-                params.outputSchema = options.outputSchema;
-            }
-            if (this.config.systemPrompt?.trim()) {
-                params.developerInstructions = this.config.systemPrompt.trim();
-            }
-            const codexConfig = this.buildCodexInnerConfig();
-            if (codexConfig) {
-                params.config = codexConfig;
-            }
+        }
+        if (this.config.cwd) {
+            params.cwd = this.config.cwd;
+        }
+        if (options?.outputSchema) {
+            params.outputSchema = options.outputSchema;
+        }
+        if (this.config.systemPrompt?.trim()) {
+            params.developerInstructions = this.config.systemPrompt.trim();
+        }
+        const codexConfig = this.buildCodexInnerConfig();
+        if (codexConfig) {
+            params.config = codexConfig;
+        }
+        const turnId = this.createTurnId();
+        this.activeForegroundTurnId = turnId;
+        try {
             await this.client.request("turn/start", params, TURN_START_TIMEOUT_MS);
-            let sawTurnStarted = false;
-            for await (const event of queue) {
-                // Drop pre-start timeline noise that can leak from the previous turn.
-                // Keep permission events, which can legitimately arrive before turn_started.
-                if (!sawTurnStarted) {
-                    if (event.type === "permission_requested" || event.type === "permission_resolved") {
-                        yield event;
-                        continue;
-                    }
-                    if (event.type === "turn_started") {
-                        sawTurnStarted = true;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-                yield event;
-                if (event.type === "turn_completed" ||
-                    event.type === "turn_failed" ||
-                    event.type === "turn_canceled") {
-                    break;
-                }
-            }
         }
-        finally {
-            if (this.eventQueue === queue) {
-                this.eventQueue = null;
-            }
+        catch (error) {
+            this.activeForegroundTurnId = null;
+            throw error;
         }
+        return { turnId };
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
     }
     async *streamHistory() {
         if (!this.historyPending || this.persistedHistory.length === 0) {
@@ -2177,8 +2168,8 @@ class CodexAppServerAgentSession {
         this.pendingPermissionHandlers.clear();
         this.pendingPermissions.clear();
         this.resolvedPermissionRequests.clear();
-        this.eventQueue?.end();
-        this.eventQueue = null;
+        this.subscribers.clear();
+        this.activeForegroundTurnId = null;
         if (this.client) {
             await this.client.dispose();
         }
@@ -2285,7 +2276,22 @@ class CodexAppServerAgentSession {
                 this.pendingAgentMessages.clear();
             }
         }
-        this.eventQueue?.push(event);
+        this.notifySubscribers(event);
+    }
+    notifySubscribers(event) {
+        const turnId = this.activeForegroundTurnId;
+        const tagged = turnId ? { ...event, turnId } : event;
+        for (const callback of this.subscribers) {
+            try {
+                callback(tagged);
+            }
+            catch (error) {
+                this.logger.warn({ err: error }, "Subscriber callback threw");
+            }
+        }
+    }
+    createTurnId() {
+        return `codex-turn-${this.nextTurnOrdinal++}`;
     }
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
@@ -2328,6 +2334,7 @@ class CodexAppServerAgentSession {
                     usage: this.latestUsage,
                 });
             }
+            this.activeForegroundTurnId = null;
             this.emittedItemStartedIds.clear();
             this.emittedItemCompletedIds.clear();
             this.emittedExecCommandStartedCallIds.clear();
@@ -2422,11 +2429,15 @@ class CodexAppServerAgentSession {
             if (!this.shouldEmitTerminalInteractionKey(interactionKey)) {
                 return;
             }
+            const command = (parsed.processId ? this.terminalCommandByProcessId.get(parsed.processId) : undefined) ??
+                null;
+            if (!command && parsed.processId) {
+                this.pendingUnlabeledTerminalInteractions.add(parsed.processId);
+            }
             const timelineItem = mapCodexTerminalInteractionToToolCall({
                 processId: parsed.processId,
                 fallbackCallId: parsed.callId,
-                command: (parsed.processId ? this.terminalCommandByProcessId.get(parsed.processId) : undefined) ??
-                    null,
+                command,
             });
             this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
             return;
@@ -2611,6 +2622,18 @@ class CodexAppServerAgentSession {
             return;
         }
         this.terminalCommandByProcessId.set(processId, displayCommand);
+        if (!this.pendingUnlabeledTerminalInteractions.has(processId)) {
+            return;
+        }
+        this.pendingUnlabeledTerminalInteractions.delete(processId);
+        this.emitEvent({
+            type: "timeline",
+            provider: CODEX_PROVIDER,
+            item: mapCodexTerminalInteractionToToolCall({
+                processId,
+                command: displayCommand,
+            }),
+        });
     }
     shouldEmitTerminalInteractionKey(key) {
         if (this.emittedTerminalInteractionKeys.has(key)) {
@@ -2749,7 +2772,7 @@ export class CodexAppServerAgentClient {
         this.provider = CODEX_PROVIDER;
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
     }
-    spawnAppServer() {
+    spawnAppServer(launchEnv) {
         const launchPrefix = resolveCodexLaunchPrefix(this.runtimeSettings);
         this.logger.trace({
             launchPrefix,
@@ -2757,16 +2780,16 @@ export class CodexAppServerAgentClient {
         return spawn(launchPrefix.command, [...launchPrefix.args, "app-server"], {
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
-            env: applyProviderEnv(process.env, this.runtimeSettings),
+            env: buildCodexAppServerEnv(this.runtimeSettings, launchEnv),
         });
     }
-    async createSession(config) {
+    async createSession(config, launchContext) {
         const sessionConfig = { ...config, provider: CODEX_PROVIDER };
-        const session = new CodexAppServerAgentSession(sessionConfig, null, this.logger, () => this.spawnAppServer());
+        const session = new CodexAppServerAgentSession(sessionConfig, null, this.logger, () => this.spawnAppServer(launchContext?.env));
         await session.connect();
         return session;
     }
-    async resumeSession(handle, overrides) {
+    async resumeSession(handle, overrides, launchContext) {
         const storedConfig = (handle.metadata ?? {});
         const merged = {
             ...storedConfig,
@@ -2774,7 +2797,7 @@ export class CodexAppServerAgentClient {
             provider: CODEX_PROVIDER,
             cwd: overrides?.cwd ?? storedConfig.cwd ?? process.cwd(),
         };
-        const session = new CodexAppServerAgentSession(merged, handle, this.logger, () => this.spawnAppServer());
+        const session = new CodexAppServerAgentSession(merged, handle, this.logger, () => this.spawnAppServer(launchContext?.env));
         await session.connect();
         return session;
     }