@getpaseo/server 0.1.97-beta.3 → 0.1.98

package/dist/server/server/agent/providers/claude/task-notification-tool-call.d.ts

@@ -7,31 +7,11 @@ declare const TaskNotificationEnvelopeSchema: z.ZodObject<{
     summary: z.ZodNullable<z.ZodString>;
     outputFile: z.ZodNullable<z.ZodString>;
     rawText: z.ZodNullable<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    status: string | null;
-    messageId: string | null;
-    summary: string | null;
-    taskId: string | null;
-    outputFile: string | null;
-    rawText: string | null;
-}, {
-    status: string | null;
-    messageId: string | null;
-    summary: string | null;
-    taskId: string | null;
-    outputFile: string | null;
-    rawText: string | null;
-}>;
+}, z.core.$strip>;
 declare const MapTaskNotificationUserContentToToolCallInputSchema: z.ZodObject<{
     content: z.ZodUnknown;
     messageId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    content?: unknown;
-    messageId?: string | null | undefined;
-}, {
-    content?: unknown;
-    messageId?: string | null | undefined;
-}>;
+}, z.core.$strip>;
 export type TaskNotificationEnvelope = z.infer<typeof TaskNotificationEnvelopeSchema>;
 export type MapTaskNotificationUserContentToToolCallInput = z.infer<typeof MapTaskNotificationUserContentToToolCallInputSchema>;
 export interface TaskNotificationSystemMessageLike {

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

@@ -28,86 +28,20 @@ declare const CodexThreadForkResponseSchema: z.ZodObject<{
         id: z.ZodString;
         sessionId: z.ZodOptional<z.ZodString>;
         forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">>;
-    model: z.ZodString;
-    modelProvider: z.ZodString;
-    serviceTier: z.ZodNullable<z.ZodString>;
-    cwd: z.ZodString;
-    runtimeWorkspaceRoots: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    instructionSources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    approvalPolicy: z.ZodUnknown;
-    approvalsReviewer: z.ZodUnknown;
-    sandbox: z.ZodUnknown;
-    activePermissionProfile: z.ZodOptional<z.ZodUnknown>;
-    reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    thread: z.ZodObject<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">>;
-    model: z.ZodString;
-    modelProvider: z.ZodString;
-    serviceTier: z.ZodNullable<z.ZodString>;
-    cwd: z.ZodString;
-    runtimeWorkspaceRoots: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    instructionSources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    approvalPolicy: z.ZodUnknown;
-    approvalsReviewer: z.ZodUnknown;
-    sandbox: z.ZodUnknown;
-    activePermissionProfile: z.ZodOptional<z.ZodUnknown>;
-    reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    thread: z.ZodObject<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">>;
+        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>;
     model: z.ZodString;
     modelProvider: z.ZodString;
     serviceTier: z.ZodNullable<z.ZodString>;
     cwd: z.ZodString;
-    runtimeWorkspaceRoots: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-    instructionSources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    runtimeWorkspaceRoots: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    instructionSources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     approvalPolicy: z.ZodUnknown;
     approvalsReviewer: z.ZodUnknown;
     sandbox: z.ZodUnknown;
     activePermissionProfile: z.ZodOptional<z.ZodUnknown>;
     reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.ZodTypeAny, "passthrough">>;
+}, z.core.$loose>;
 export type CodexThreadForkResponse = z.infer<typeof CodexThreadForkResponseSchema>;
 export declare function parseCodexThreadForkResponse(response: unknown): CodexThreadForkResponse;
 export interface CodexThreadRollbackParams {
@@ -119,53 +53,9 @@ declare const CodexThreadRollbackResponseSchema: z.ZodObject<{
         id: z.ZodString;
         sessionId: z.ZodOptional<z.ZodString>;
         forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    thread: z.ZodObject<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    thread: z.ZodObject<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        id: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
-    }, z.ZodTypeAny, "passthrough">>;
-}, z.ZodTypeAny, "passthrough">>;
+        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
 export type CodexThreadRollbackResponse = z.infer<typeof CodexThreadRollbackResponseSchema>;
 export declare function parseCodexThreadRollbackResponse(response: unknown): CodexThreadRollbackResponse;
 export interface CodexAppServerTraceContext {

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 AgentModelDefinition, 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 ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions } 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>;
@@ -297,6 +297,7 @@ export declare class CodexAppServerAgentClient implements AgentClient {
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     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

@@ -21,8 +21,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 { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, toDiagnosticErrorMessage, } 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 +32,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 +2764,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 +2780,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") {
@@ -4406,6 +4417,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);
@@ -4417,6 +4456,9 @@ export class CodexAppServerAgentClient {
             const availability = await checkCodexLaunchAvailable(launch);
             const available = availability.available;
             const entries = [
+                ...(await buildCommandResolutionDiagnosticRows(launch, {
+                    knownBinaryNames: ["codex"],
+                })),
                 ...(await buildBinaryDiagnosticRows(launch, availability)),
             ];
             let status = formatDiagnosticStatus(available);

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

@@ -1,7 +1,7 @@
 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 { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 const COPILOT_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -93,6 +93,9 @@ export class CopilotACPAgentClient extends ACPAgentClient {
             }
             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

@@ -3,11 +3,7 @@ import { z } from "zod";
 import { ACPAgentClient } from "./acp-agent.js";
 export declare const GenericACPProviderParamsSchema: z.ZodObject<{
     supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
-}, z.ZodTypeAny, "passthrough">>;
+}, z.core.$loose>;
 interface GenericACPAgentClientOptions {
     logger: Logger;
     command: [string, ...string[]];

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

@@ -19,7 +19,7 @@ export class MockSlowProviderClient {
         this.capabilities = CAPABILITIES;
     }
     async isAvailable() {
-        return true;
+        return process.env.PASEO_ENABLE_MOCK_SLOW === "true";
     }
     listModels(_options) {
         return neverResolves();

package/dist/server/server/agent/providers/opencode/server-manager.d.ts

@@ -1,5 +1,8 @@
 import type { ChildProcess } from "node:child_process";
 import type { Logger } from "pino";
+import { type SpawnProcessOptions } from "../../../../utils/spawn.js";
+import { type ProcessTerminator } from "../../../../utils/tree-kill.js";
+import type { ManagedProcessRegistry } from "../../../managed-processes/managed-processes.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export interface OpenCodeServerAcquisition {
     server: {
@@ -24,6 +27,22 @@ export interface OpenCodeServerGeneration {
     url: string;
     refCount: number;
     retired: boolean;
+    managedProcessId?: string;
+}
+export type OpenCodePortAllocator = () => Promise<number>;
+export type OpenCodeCommandPrefixResolver = () => Promise<{
+    command: string;
+    args: string[];
+}>;
+export type OpenCodeServerProcessSpawner = (command: string, args: string[], options: SpawnProcessOptions) => ChildProcess;
+export interface OpenCodeServerManagerOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+    managedProcesses?: ManagedProcessRegistry;
+    terminateProcess?: ProcessTerminator;
+    portAllocator?: OpenCodePortAllocator;
+    resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    spawnServerProcess?: OpenCodeServerProcessSpawner;
 }
 export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
     private static instance;
@@ -35,8 +54,13 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly runtimeSettingsKey;
-    private constructor();
-    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings): OpenCodeServerManager;
+    private readonly managedProcesses?;
+    private readonly terminateProcess;
+    private readonly portAllocator;
+    private readonly resolveCommandPrefix;
+    private readonly spawnServerProcess;
+    constructor(options: OpenCodeServerManagerOptions);
+    static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, options?: Omit<OpenCodeServerManagerOptions, "logger" | "runtimeSettings">): OpenCodeServerManager;
     private static registerExitHandler;
     ensureRunning(): Promise<{
         port: number;
@@ -55,5 +79,8 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     shutdown(): Promise<void>;
     private cleanupRetiredServers;
     private killServer;
+    private recordManagedServerProcess;
+    private removeManagedProcessRecordWhenResolved;
+    private removeManagedProcessId;
 }
 //# sourceMappingURL=server-manager.d.ts.map