@getpaseo/server 0.1.97 → 0.1.99

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

@@ -1,4 +1,4 @@
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentProviderNotice, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
 import type { Logger } from "pino";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
@@ -196,9 +196,9 @@ export declare class CodexAppServerAgentSession implements AgentSession {
     getRuntimeInfo(): Promise<AgentRuntimeInfo>;
     getAvailableModes(): Promise<AgentMode[]>;
     getCurrentMode(): Promise<string | null>;
-    setMode(modeId: string): Promise<void>;
+    setMode(modeId: string): Promise<void | AgentProviderNotice>;
     setModel(modelId: string | null): Promise<void>;
-    setThinkingOption(thinkingOptionId: string | null): Promise<void>;
+    setThinkingOption(thinkingOptionId: string | null): Promise<void | AgentProviderNotice>;
     setFeature(featureId: string, value: unknown): Promise<void>;
     getPendingPermissions(): AgentPermissionRequest[];
     respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<AgentPermissionResult | void>;
@@ -295,8 +295,10 @@ export declare class CodexAppServerAgentClient implements AgentClient {
     }, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
-    listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
+    fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    private fetchModelsFromAppServer;
     archiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
+    unarchiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{
         diagnostic: string;

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

@@ -1,6 +1,5 @@
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../provider-session-import.js";
-import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
 import fs from "node:fs/promises";
@@ -21,8 +20,9 @@ import { CodexAppServerClient, parseCodexThreadForkResponse, parseCodexThreadRol
 import { revertCodexConversation } from "./codex/rewind.js";
 import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
+import { SETTING_APPLIES_NEXT_TURN_NOTICE } from "../provider-notices.js";
 function assertChildWithPipes(child) {
     if (!child.stdin || !child.stdout || !child.stderr) {
         throw new Error("Child process did not expose stdio pipes");
@@ -31,6 +31,10 @@ function assertChildWithPipes(child) {
 function isRecord(value) {
     return value != null && typeof value === "object" && !Array.isArray(value);
 }
+function isCodexAlreadyUnarchivedError(error, threadId) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes(`no archived rollout found for thread id ${threadId}`);
+}
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
 const CODEX_PROVIDER = "codex";
@@ -2759,6 +2763,9 @@ export class CodexAppServerAgentSession {
         validateCodexMode(modeId);
         this.currentMode = modeId;
         this.cachedRuntimeInfo = null;
+        if (this.activeForegroundTurnId) {
+            return SETTING_APPLIES_NEXT_TURN_NOTICE;
+        }
     }
     async setModel(modelId) {
         this.config.model = modelId ?? undefined;
@@ -2772,6 +2779,9 @@ export class CodexAppServerAgentSession {
         this.config.thinkingOptionId = normalizeCodexThinkingOptionId(thinkingOptionId);
         this.refreshResolvedCollaborationMode();
         this.cachedRuntimeInfo = null;
+        if (this.activeForegroundTurnId) {
+            return SETTING_APPLIES_NEXT_TURN_NOTICE;
+        }
     }
     async setFeature(featureId, value) {
         if (featureId === "fast_mode") {
@@ -4365,7 +4375,11 @@ export class CodexAppServerAgentClient {
             resumeSession: this.resumeSession.bind(this),
         });
     }
-    async listModels(_options) {
+    async fetchCatalog(_options) {
+        const models = await this.fetchModelsFromAppServer();
+        return { models, modes: CODEX_MODES };
+    }
+    async fetchModelsFromAppServer() {
         // Codex model/list is global to the app server in this flow; cwd/force are intentionally ignored.
         const child = await this.spawnAppServer();
         const client = new CodexAppServerClient(child, this.logger);
@@ -4406,6 +4420,34 @@ export class CodexAppServerAgentClient {
             await client.dispose();
         }
     }
+    async unarchiveNativeSession(handle) {
+        const threadId = handle.nativeHandle ?? handle.sessionId;
+        if (!threadId)
+            return;
+        const child = await this.spawnAppServer();
+        const client = new CodexAppServerClient(child, this.logger);
+        try {
+            await client.request("initialize", buildCodexAppServerInitializeParams());
+            client.notify("initialized", {});
+            try {
+                await client.request("thread/unarchive", { threadId });
+            }
+            catch (error) {
+                if (!isCodexAlreadyUnarchivedError(error, threadId)) {
+                    throw error;
+                }
+                try {
+                    await client.request("thread/read", { threadId });
+                }
+                catch {
+                    throw error;
+                }
+            }
+        }
+        finally {
+            await client.dispose();
+        }
+    }
     async isAvailable() {
         const launch = await resolveCodexLaunch(this.runtimeSettings);
         const availability = await checkCodexLaunchAvailable(launch);
@@ -4415,31 +4457,12 @@ export class CodexAppServerAgentClient {
         try {
             const launch = await resolveCodexLaunch(this.runtimeSettings);
             const availability = await checkCodexLaunchAvailable(launch);
-            const available = availability.available;
             const entries = [
+                ...(await buildCommandResolutionDiagnosticRows(launch, {
+                    knownBinaryNames: ["codex"],
+                })),
                 ...(await buildBinaryDiagnosticRows(launch, availability)),
             ];
-            let status = formatDiagnosticStatus(available);
-            if (!available) {
-                entries.push({ label: "Models", value: "Not checked" });
-            }
-            else {
-                try {
-                    const models = await this.listModels({ cwd: homedir(), force: false });
-                    entries.push({ label: "Models", value: String(models.length) });
-                }
-                catch (error) {
-                    entries.push({
-                        label: "Models",
-                        value: `Error - ${toDiagnosticErrorMessage(error)}`,
-                    });
-                    status = formatDiagnosticStatus(available, {
-                        source: "model fetch",
-                        cause: error,
-                    });
-                }
-            }
-            entries.push({ label: "Status", value: status });
             return {
                 diagnostic: formatProviderDiagnostic("Codex", entries),
             };

package/dist/server/server/agent/providers/copilot-acp-agent.js

@@ -1,7 +1,6 @@
-import { homedir } from "node:os";
 import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { ACPAgentClient, } from "./acp-agent.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, } from "./diagnostic-utils.js";
 const COPILOT_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -64,38 +63,12 @@ export class CopilotACPAgentClient extends ACPAgentClient {
                 defaultBinary: "copilot",
             });
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
-            let modelsValue = "Not checked";
-            let status = formatDiagnosticStatus(available);
-            if (available) {
-                try {
-                    const models = await this.listModels({ cwd: homedir(), force: false });
-                    modelsValue = String(models.length);
-                }
-                catch (error) {
-                    modelsValue = `Error - ${toDiagnosticErrorMessage(error)}`;
-                    status = formatDiagnosticStatus(available, {
-                        source: "model fetch",
-                        cause: error,
-                    });
-                }
-                if (!modelsValue.startsWith("Error -")) {
-                    try {
-                        await this.listModes({ cwd: homedir(), force: false });
-                    }
-                    catch (error) {
-                        status = formatDiagnosticStatus(available, {
-                            source: "mode fetch",
-                            cause: error,
-                        });
-                    }
-                }
-            }
             return {
                 diagnostic: formatProviderDiagnostic("Copilot", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["copilot"],
+                    })),
                     ...(await buildBinaryDiagnosticRows(launch, availability)),
-                    { label: "Models", value: modelsValue },
-                    { label: "Status", value: status },
                 ]),
             };
         }

package/dist/server/server/agent/providers/diagnostic-utils.d.ts

@@ -21,6 +21,15 @@ export interface BinaryDiagnosticRowsOptions {
     binaryLabel?: string;
     versionCommand?: BinaryDiagnosticVersionCommand;
 }
+export interface CommandResolutionDiagnosticRowsOptions {
+    knownBinaryNames: readonly string[];
+    includeCommandProbes?: boolean;
+    pathValue?: string;
+    pathext?: string;
+    platform?: NodeJS.Platform;
+    shell?: string;
+}
+export declare function buildCommandResolutionDiagnosticRows(launch: ResolvedProviderLaunch, options: CommandResolutionDiagnosticRowsOptions): Promise<DiagnosticEntry[]>;
 export declare function buildBinaryDiagnosticRows(launch: ResolvedProviderLaunch, availability: ProviderLaunchAvailability, options?: BinaryDiagnosticRowsOptions): Promise<DiagnosticEntry[]>;
 export declare function formatConfiguredCommand(defaultArgv: readonly string[], runtimeSettings?: ProviderRuntimeSettings): string;
 //# sourceMappingURL=diagnostic-utils.d.ts.map

package/dist/server/server/agent/providers/diagnostic-utils.js

@@ -1,3 +1,6 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import path from "node:path";
 import { createProviderEnvSpec, } from "../provider-launch-config.js";
 import { execCommand } from "../../../utils/spawn.js";
 export function formatProviderDiagnostic(providerName, entries) {
@@ -114,6 +117,191 @@ export async function resolveBinaryVersion(binaryPath) {
         return `error: ${toDiagnosticErrorMessage(error)}`;
     }
 }
+const COMMAND_PROBE_TIMEOUT_MS = 3000;
+const COMMAND_PROBE_MAX_BUFFER = 32 * 1024;
+function resolvePlatform(options) {
+    return options?.platform ?? process.platform;
+}
+function resolvePathValue(options) {
+    return options?.pathValue ?? process.env["PATH"] ?? process.env["Path"] ?? "";
+}
+function resolveShellValue(options) {
+    if (options?.shell) {
+        return options.shell;
+    }
+    if (resolvePlatform(options) === "win32") {
+        return process.env["ComSpec"] ?? "cmd.exe";
+    }
+    return process.env["SHELL"] ?? "/bin/sh";
+}
+async function isExecutableFile(filePath, platform) {
+    try {
+        const candidate = await stat(filePath);
+        if (!candidate.isFile()) {
+            return false;
+        }
+        if (platform === "win32") {
+            return true;
+        }
+        await access(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveSearchableNames(binaryNames) {
+    return binaryNames.filter((binaryName) => binaryName.trim().length > 0 && !binaryName.includes("/") && !binaryName.includes("\\"));
+}
+function resolveWindowsPathExt(options) {
+    const value = options.pathext ?? process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
+    return value
+        .split(";")
+        .map((extension) => extension.trim())
+        .filter(Boolean)
+        .map((extension) => (extension.startsWith(".") ? extension : `.${extension}`));
+}
+function resolveBinaryCandidateNames(binaryName, options) {
+    if (resolvePlatform(options) !== "win32" || path.win32.extname(binaryName)) {
+        return [binaryName];
+    }
+    return [binaryName, ...resolveWindowsPathExt(options).map((extension) => binaryName + extension)];
+}
+async function formatPathMatches(options) {
+    const binaryNames = options.knownBinaryNames;
+    const searchableNames = resolveSearchableNames(binaryNames);
+    if (searchableNames.length === 0) {
+        return "not checked";
+    }
+    const pathDelimiter = resolvePlatform(options) === "win32" ? ";" : path.delimiter;
+    const pathEntries = resolvePathValue(options).split(pathDelimiter).filter(Boolean);
+    const matches = [];
+    const seen = new Set();
+    const platform = resolvePlatform(options);
+    for (const directory of pathEntries) {
+        for (const binaryName of searchableNames) {
+            for (const candidateName of resolveBinaryCandidateNames(binaryName, options)) {
+                const candidate = path.join(directory, candidateName);
+                if (seen.has(candidate)) {
+                    continue;
+                }
+                seen.add(candidate);
+                if (await isExecutableFile(candidate, platform)) {
+                    matches.push(candidate);
+                }
+            }
+        }
+    }
+    return matches.length > 0 ? matches.join("\n    ") : "none";
+}
+function shellToken(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function formatCommandProbeOutput(stdout, stderr) {
+    const sections = [];
+    const trimmedStdout = truncateForDiagnostic(stdout);
+    const trimmedStderr = truncateForDiagnostic(stderr);
+    if (trimmedStdout.length > 0) {
+        sections.push(trimmedStdout);
+    }
+    if (trimmedStderr.length > 0) {
+        sections.push(`stderr: ${trimmedStderr}`);
+    }
+    return sections.length > 0 ? sections.join("\n") : "(no output)";
+}
+function formatCommandProbeError(error) {
+    return toDiagnosticErrorMessage(error);
+}
+async function runCommandProbe(command, args) {
+    try {
+        const { stdout, stderr } = await execCommand(command, args, {
+            timeout: COMMAND_PROBE_TIMEOUT_MS,
+            killSignal: "SIGKILL",
+            maxBuffer: COMMAND_PROBE_MAX_BUFFER,
+        });
+        return formatCommandProbeOutput(stdout, stderr);
+    }
+    catch (error) {
+        return formatCommandProbeError(error);
+    }
+}
+async function buildPosixCommandProbeRows(binaryName) {
+    const shell = resolveShellValue();
+    const typeCommand = `type -a ${shellToken(binaryName)}`;
+    return [
+        {
+            label: `which -a ${binaryName}`,
+            value: await runCommandProbe("/usr/bin/which", ["-a", binaryName]),
+        },
+        {
+            label: `${path.basename(shell)} -lc type -a ${binaryName}`,
+            value: await runCommandProbe(shell, ["-lc", typeCommand]),
+        },
+    ];
+}
+async function buildWindowsCommandProbeRows(binaryName) {
+    const powershellCommand = [
+        "$ErrorActionPreference = 'Continue';",
+        `Get-Command -All ${JSON.stringify(binaryName)} |`,
+        "Select-Object CommandType,Source,Name,Definition |",
+        "Format-List",
+    ].join(" ");
+    return [
+        {
+            label: `where.exe ${binaryName}`,
+            value: await runCommandProbe("where.exe", [binaryName]),
+        },
+        {
+            label: `powershell Get-Command -All ${binaryName}`,
+            value: await runCommandProbe("powershell.exe", [
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                powershellCommand,
+            ]),
+        },
+    ];
+}
+async function buildCommandProbeRows(binaryNames) {
+    const searchableNames = resolveSearchableNames(binaryNames);
+    if (searchableNames.length === 0) {
+        return [];
+    }
+    const rows = [];
+    for (const binaryName of searchableNames) {
+        rows.push(...(process.platform === "win32"
+            ? await buildWindowsCommandProbeRows(binaryName)
+            : await buildPosixCommandProbeRows(binaryName)));
+    }
+    return rows;
+}
+export async function buildCommandResolutionDiagnosticRows(launch, options) {
+    const includeCommandProbes = options.includeCommandProbes ?? true;
+    return [
+        {
+            label: "Command source",
+            value: launch.source,
+        },
+        {
+            label: "Configured command",
+            value: [launch.command, ...launch.args].join(" "),
+        },
+        {
+            label: "Daemon PATH",
+            value: truncateForDiagnostic(resolvePathValue(options)) || "(empty)",
+        },
+        {
+            label: "Daemon shell",
+            value: resolveShellValue(options),
+        },
+        {
+            label: "PATH matches",
+            value: await formatPathMatches(options),
+        },
+        ...(includeCommandProbes ? await buildCommandProbeRows(options.knownBinaryNames) : []),
+    ];
+}
 async function resolveCommandVersion(invocation) {
     try {
         const { stdout, stderr } = await execCommand(invocation.command, invocation.args, {

package/dist/server/server/agent/providers/generic-acp-agent.d.ts

@@ -28,7 +28,6 @@ export declare class GenericACPAgentClient extends ACPAgentClient {
         diagnostic: string;
     }>;
     private resolveConfiguredLaunch;
-    private runDiagnosticACPProbe;
 }
 export interface CommandInvocation {
     command: string;

package/dist/server/server/agent/providers/generic-acp-agent.js

@@ -1,10 +1,7 @@
-import { homedir } from "node:os";
 import { z } from "zod";
 import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
-import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES, deriveModelDefinitionsFromACP, deriveModesFromACP, } from "./acp-agent.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
-const ACP_DIAGNOSTIC_INITIALIZE_TIMEOUT_MS = 8000;
-const ACP_DIAGNOSTIC_SESSION_TIMEOUT_MS = 8000;
+import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES } from "./acp-agent.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, } from "./diagnostic-utils.js";
 export const GenericACPProviderParamsSchema = z
     .object({
     supportsMcpServers: z.boolean().optional(),
@@ -43,17 +40,7 @@ export class GenericACPAgentClient extends ACPAgentClient {
         try {
             const launch = await this.resolveConfiguredLaunch();
             const availability = await checkProviderLaunchAvailable(launch);
-            const available = availability.available;
             const versionProbe = buildVersionProbeCommand(this.command);
-            const probeResult = available
-                ? await this.runDiagnosticACPProbe()
-                : {
-                    status: formatDiagnosticStatus(false),
-                    initialize: "Not checked",
-                    session: "Not checked",
-                    models: "Not checked",
-                    modes: "Not checked",
-                };
             return {
                 diagnostic: formatProviderDiagnostic(providerName, [
                     { label: "Provider ID", value: this.providerId ?? "unknown" },
@@ -70,11 +57,6 @@ export class GenericACPAgentClient extends ACPAgentClient {
                         label: "Version command",
                         value: formatCommand(versionProbe.command, versionProbe.args),
                     },
-                    { label: "ACP initialize", value: probeResult.initialize },
-                    { label: "ACP session/new", value: probeResult.session },
-                    { label: "Models", value: probeResult.models },
-                    { label: "Modes", value: probeResult.modes },
-                    { label: "Status", value: probeResult.status },
                 ]),
             };
         }
@@ -90,50 +72,6 @@ export class GenericACPAgentClient extends ACPAgentClient {
             defaultBinary: this.command[0],
         });
     }
-    async runDiagnosticACPProbe() {
-        let initializeValue = "Not checked";
-        let sessionValue = "Not checked";
-        try {
-            const probe = await this.spawnProcess({
-                NO_BROWSER: "true",
-                NO_OPEN_BROWSER: "1",
-                GEMINI_CLI_NO_BROWSER: "true",
-                CI: "1",
-            }, {
-                initializeTimeoutMs: ACP_DIAGNOSTIC_INITIALIZE_TIMEOUT_MS,
-            });
-            try {
-                initializeValue = formatInitializeResult(probe.initialize);
-                const response = await withTimeout(probe.connection.newSession({
-                    cwd: homedir(),
-                    mcpServers: [],
-                }), ACP_DIAGNOSTIC_SESSION_TIMEOUT_MS, "ACP session/new");
-                sessionValue = response.sessionId ? `ok (${response.sessionId})` : "ok";
-                const transformed = this.transformSessionResponse(response);
-                return {
-                    status: formatDiagnosticStatus(true),
-                    initialize: initializeValue,
-                    session: sessionValue,
-                    ...summarizeSessionState(this.provider, transformed),
-                };
-            }
-            finally {
-                await this.closeProbe(probe);
-            }
-        }
-        catch (error) {
-            return {
-                status: formatDiagnosticStatus(true, {
-                    source: "ACP probe",
-                    cause: error,
-                }),
-                initialize: formatProbeError(initializeValue, error),
-                session: initializeValue === "Not checked" ? "Not checked" : formatProbeError(sessionValue, error),
-                models: "Not checked",
-                modes: "Not checked",
-            };
-        }
-    }
 }
 function buildGenericACPCapabilities(options) {
     const params = parseGenericACPProviderParams(options.providerParams);
@@ -200,48 +138,4 @@ function takePackageSpecPrefix(args) {
     }
     return prefix;
 }
-function formatInitializeResult(initialize) {
-    const agentInfo = isAgentInfo(initialize.agentInfo)
-        ? `${initialize.agentInfo.name}${initialize.agentInfo.version ? ` ${initialize.agentInfo.version}` : ""}`
-        : "ok";
-    return `ok (protocol ${initialize.protocolVersion}, ${agentInfo})`;
-}
-function isAgentInfo(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "name" in value &&
-        typeof Reflect.get(value, "name") === "string");
-}
-function summarizeSessionState(provider, response) {
-    const models = deriveModelDefinitionsFromACP(provider, response.models, response.configOptions);
-    const { modes } = deriveModesFromACP([], response.modes, response.configOptions);
-    return {
-        models: `${models.length}`,
-        modes: modes.length > 0 ? modes.map((mode) => mode.label || mode.id).join(", ") : "none reported",
-    };
-}
-function formatProbeError(currentValue, error) {
-    if (currentValue !== "Not checked") {
-        return currentValue;
-    }
-    return `Error - ${toDiagnosticErrorMessage(error)}`;
-}
-async function withTimeout(promise, timeoutMs, label) {
-    let timeout = null;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                timeout = setTimeout(() => {
-                    reject(new Error(`${label} timed out after ${timeoutMs}ms`));
-                }, timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timeout) {
-            clearTimeout(timeout);
-        }
-    }
-}
 //# sourceMappingURL=generic-acp-agent.js.map

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "pino";
-import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, ImportableProviderSession, ImportProviderSessionContext, ImportProviderSessionInput, ListModesOptions, ListModelsOptions } from "../agent-sdk-types.js";
+import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, FetchCatalogOptions, ImportableProviderSession, ImportProviderSessionContext, ImportProviderSessionInput, ProviderCatalog } from "../agent-sdk-types.js";
 export declare const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
 export declare const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
 export declare class MockLoadTestAgentClient implements AgentClient {
@@ -9,8 +9,7 @@ export declare class MockLoadTestAgentClient implements AgentClient {
     constructor(logger?: Logger | undefined);
     createSession(config: AgentSessionConfig, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
-    listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    listModes(_options: ListModesOptions): Promise<AgentMode[]>;
+    fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
     listImportableSessions(): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -379,11 +379,11 @@ export class MockLoadTestAgentClient {
             logger: this.logger,
         });
     }
-    async listModels(_options) {
-        return MODELS;
-    }
-    async listModes(_options) {
-        return getAgentProviderDefinition(MOCK_LOAD_TEST_PROVIDER_ID).modes;
+    async fetchCatalog(_options) {
+        return {
+            models: MODELS,
+            modes: getAgentProviderDefinition(MOCK_LOAD_TEST_PROVIDER_ID).modes,
+        };
     }
     async listImportableSessions() {
         return [];

package/dist/server/server/agent/providers/mock-slow-provider.d.ts

@@ -1,11 +1,10 @@
-import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, ListModelsOptions, ListModesOptions } from "../agent-sdk-types.js";
+import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, FetchCatalogOptions, ProviderCatalog } from "../agent-sdk-types.js";
 export declare const MOCK_SLOW_PROVIDER_ID = "mock-slow";
 export declare class MockSlowProviderClient implements AgentClient {
     readonly provider: AgentProvider;
     readonly capabilities: AgentCapabilityFlags;
     isAvailable(): Promise<boolean>;
-    listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    listModes(_options: ListModesOptions): Promise<AgentMode[]>;
+    fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
     getDiagnostic(): Promise<{
         diagnostic: string;
     }>;

package/dist/server/server/agent/providers/mock-slow-provider.js

@@ -19,17 +19,14 @@ export class MockSlowProviderClient {
         this.capabilities = CAPABILITIES;
     }
     async isAvailable() {
-        return true;
+        return process.env.PASEO_ENABLE_MOCK_SLOW === "true";
     }
-    listModels(_options) {
-        return neverResolves();
-    }
-    listModes(_options) {
+    async fetchCatalog(_options) {
         return neverResolves();
     }
     async getDiagnostic() {
         return {
-            diagnostic: "Mock slow provider: dev-only. listModels() never resolves so the snapshot manager will time out.",
+            diagnostic: "Mock slow provider: dev-only. fetchCatalog() never resolves so the snapshot manager will time out.",
         };
     }
     createSession(_config, _launchContext) {