@getpaseo/server 0.1.74 → 0.1.75

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

@@ -1,3 +1,4 @@
+import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
@@ -13,7 +14,7 @@ import { findExecutable, isCommandAvailable } from "../../../utils/executable.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, } from "./codex/app-server-transport.js";
 import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
@@ -1911,13 +1912,53 @@ function buildCodexAppServerInitializeParams() {
         },
     };
 }
+function normalizeOpenAICompatibleBaseUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const withoutTrailingSlashes = trimmed.replace(/\/+$/u, "");
+    if (withoutTrailingSlashes.endsWith("/v1")) {
+        return withoutTrailingSlashes;
+    }
+    return `${withoutTrailingSlashes}/v1`;
+}
+function buildCodexCustomProviderConfig(runtimeSettings, customProvider) {
+    if (customProvider?.extends !== CODEX_PROVIDER) {
+        return null;
+    }
+    const baseUrl = runtimeSettings?.env?.OPENAI_BASE_URL;
+    if (typeof baseUrl !== "string") {
+        return null;
+    }
+    const normalizedBaseUrl = normalizeOpenAICompatibleBaseUrl(baseUrl);
+    if (!normalizedBaseUrl) {
+        return null;
+    }
+    const providerConfig = {
+        name: customProvider.label,
+        base_url: normalizedBaseUrl,
+        wire_api: "responses",
+    };
+    if (runtimeSettings?.env?.OPENAI_API_KEY?.trim()) {
+        providerConfig.env_key = "OPENAI_API_KEY";
+        providerConfig.requires_openai_auth = false;
+    }
+    return {
+        model_provider: customProvider.id,
+        model_providers: {
+            [customProvider.id]: providerConfig,
+        },
+    };
+}
 class CodexAppServerAgentSession {
-    constructor(config, resumeHandle, logger, spawnAppServer, deps = {}, ephemeral = false, goalsEnabled = false) {
+    constructor(config, resumeHandle, logger, spawnAppServer, deps = {}, ephemeral = false, goalsEnabled = false, agentId) {
         this.resumeHandle = resumeHandle;
         this.spawnAppServer = spawnAppServer;
         this.deps = deps;
         this.ephemeral = ephemeral;
         this.goalsEnabled = goalsEnabled;
+        this.agentId = agentId;
         this.provider = CODEX_PROVIDER;
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
         this.currentThreadId = null;
@@ -1956,7 +1997,11 @@ class CodexAppServerAgentSession {
         this.collaborationModes = [];
         this.resolvedCollaborationMode = null;
         this.cachedSkills = [];
-        this.logger = logger.child({ module: "agent", provider: CODEX_PROVIDER });
+        this.logger = logger.child({
+            module: "agent",
+            provider: CODEX_PROVIDER,
+            agentId: this.agentId,
+        });
         if (config.modeId === undefined) {
             throw new Error("Codex agent requires modeId to be specified");
         }
@@ -1990,7 +2035,7 @@ class CodexAppServerAgentSession {
         if (this.connected)
             return;
         const child = await this.spawnAppServer();
-        this.client = new CodexAppServerClient(child, this.logger);
+        this.client = new CodexAppServerClient(child, this.logger, () => this.traceContext());
         this.client.setNotificationHandler((method, params) => this.handleNotification(method, params));
         this.registerRequestHandlers();
         await this.client.request("initialize", buildCodexAppServerInitializeParams());
@@ -2003,6 +2048,13 @@ class CodexAppServerAgentSession {
         }
         this.connected = true;
     }
+    traceContext() {
+        return {
+            agentId: this.agentId,
+            sessionId: this.currentThreadId ?? undefined,
+            turnId: this.activeForegroundTurnId ?? undefined,
+        };
+    }
     async loadCollaborationModes() {
         if (!this.client)
             return;
@@ -2023,7 +2075,13 @@ class CodexAppServerAgentSession {
             });
         }
         catch (error) {
-            this.logger.trace({ error }, "Failed to load collaboration modes");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: CODEX_PROVIDER,
+                sessionId: this.currentThreadId,
+                turnId: this.activeForegroundTurnId ?? undefined,
+                error,
+            }, "provider.codex.metadata.collaboration_modes_failed");
             this.collaborationModes = [];
         }
         this.refreshResolvedCollaborationMode();
@@ -2054,7 +2112,13 @@ class CodexAppServerAgentSession {
             this.cachedSkills = skills;
         }
         catch (error) {
-            this.logger.trace({ error }, "Failed to load skills list");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: CODEX_PROVIDER,
+                sessionId: this.currentThreadId,
+                turnId: this.activeForegroundTurnId ?? undefined,
+                error,
+            }, "provider.codex.metadata.skills_failed");
             this.cachedSkills = [];
         }
     }
@@ -2212,9 +2276,10 @@ class CodexAppServerAgentSession {
             await this.client.request("thread/resume", params);
         }
         catch (error) {
-            this.logger.warn({ error }, "Failed to resume Codex thread, starting new thread");
-            this.currentThreadId = null;
-            await this.ensureThread();
+            const threadId = this.currentThreadId;
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ error, threadId }, "Failed to resume persisted Codex thread");
+            throw new Error(`Failed to resume Codex thread ${threadId}: ${message}`, { cause: error });
         }
     }
     parseSlashCommandInput(text) {
@@ -2807,6 +2872,9 @@ class CodexAppServerAgentSession {
         if (this.config.extra?.codex) {
             Object.assign(innerConfig, this.config.extra.codex);
         }
+        if (this.deps.customCodexConfig) {
+            Object.assign(innerConfig, this.deps.customCodexConfig);
+        }
         return Object.keys(innerConfig).length > 0 ? innerConfig : null;
     }
     async buildUserInput(prompt) {
@@ -2821,6 +2889,13 @@ class CodexAppServerAgentSession {
     notifySubscribers(event) {
         const turnId = this.activeForegroundTurnId;
         const tagged = turnId ? { ...event, turnId } : event;
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: CODEX_PROVIDER,
+            sessionId: this.currentThreadId,
+            turnId: getAgentStreamEventTurnId(tagged),
+            event: tagged,
+        }, "provider.codex.event_emit");
         for (const callback of this.subscribers) {
             try {
                 callback(tagged);
@@ -2835,6 +2910,7 @@ class CodexAppServerAgentSession {
     }
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
+        this.traceParsedNotification(method, params, parsed);
         switch (parsed.kind) {
             case "thread_started":
                 this.handleThreadStartedNotification(parsed);
@@ -2890,6 +2966,17 @@ class CodexAppServerAgentSession {
                 this.warnUnknownNotificationMethod(parsed.method, parsed.params);
         }
     }
+    traceParsedNotification(method, params, parsed) {
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: CODEX_PROVIDER,
+            sessionId: this.currentThreadId,
+            turnId: this.activeForegroundTurnId ?? undefined,
+            method,
+            params,
+            parsed,
+        }, "provider.codex.parsed_event");
+    }
     getSubAgentCallIdForThread(threadId) {
         if (!threadId || threadId === this.currentThreadId) {
             return null;
@@ -3385,7 +3472,14 @@ class CodexAppServerAgentSession {
             return;
         }
         this.warnedUnknownNotificationMethods.add(method);
-        this.logger.trace({ method, params }, "Unhandled Codex app-server notification method");
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: CODEX_PROVIDER,
+            sessionId: this.currentThreadId,
+            turnId: this.activeForegroundTurnId ?? undefined,
+            method,
+            params,
+        }, "provider.codex.event_unhandled");
     }
     warnInvalidNotificationPayload(method, params) {
         const key = method;
@@ -3618,6 +3712,12 @@ export class CodexAppServerAgentClient {
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
         this.goalsEnabledPromise = null;
     }
+    sessionDeps() {
+        return {
+            ...this.deps,
+            customCodexConfig: buildCodexCustomProviderConfig(this.runtimeSettings, this.deps.customProvider),
+        };
+    }
     resolveGoalsEnabled() {
         if (!this.goalsEnabledPromise) {
             this.goalsEnabledPromise = (async () => {
@@ -3625,7 +3725,11 @@ export class CodexAppServerAgentClient {
                     const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
                     const versionOutput = await resolveBinaryVersion(launchPrefix.command);
                     const enabled = codexVersionAtLeast(versionOutput, CODEX_GOALS_MIN_VERSION);
-                    this.logger.trace({ versionOutput, enabled }, "Resolved codex goals feature gate");
+                    this.logger.trace({
+                        provider: CODEX_PROVIDER,
+                        versionOutput,
+                        enabled,
+                    }, "provider.codex.config.goals_resolved");
                     return enabled;
                 }
                 catch (error) {
@@ -3643,9 +3747,11 @@ export class CodexAppServerAgentClient {
             args.push("--enable", "goals");
         }
         this.logger.trace({
+            agentId: options?.agentId,
+            provider: CODEX_PROVIDER,
             launchPrefix,
             goalsEnabled: options?.goalsEnabled === true,
-        }, "Spawning Codex app server");
+        }, "provider.codex.spawn");
         const child = spawnProcess(launchPrefix.command, args, {
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
@@ -3665,7 +3771,7 @@ export class CodexAppServerAgentClient {
         }
         const sessionConfig = { ...config, provider: CODEX_PROVIDER };
         const goalsEnabled = await this.resolveGoalsEnabled();
-        const session = new CodexAppServerAgentSession(sessionConfig, null, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled }), this.deps, options?.persistSession === false, goalsEnabled);
+        const session = new CodexAppServerAgentSession(sessionConfig, null, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled, agentId: launchContext?.agentId }), this.sessionDeps(), options?.persistSession === false, goalsEnabled, launchContext?.agentId);
         await session.connect();
         return session;
     }
@@ -3678,13 +3784,13 @@ export class CodexAppServerAgentClient {
             cwd: overrides?.cwd ?? storedConfig.cwd ?? process.cwd(),
         };
         const goalsEnabled = await this.resolveGoalsEnabled();
-        const session = new CodexAppServerAgentSession(merged, handle, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled }), this.deps, false, goalsEnabled);
+        const session = new CodexAppServerAgentSession(merged, handle, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled, agentId: launchContext?.agentId }), this.sessionDeps(), false, goalsEnabled, launchContext?.agentId);
         await session.connect();
         return session;
     }
     async listPersistedAgents(options) {
         const child = await this.spawnAppServer();
-        const client = this.deps._createCodexClient?.(child, this.logger) ??
+        const client = this.deps._createCodexClient?.(child, this.logger, () => ({})) ??
             new CodexAppServerClient(child, this.logger);
         try {
             await client.request("initialize", buildCodexAppServerInitializeParams());