@getpaseo/server 0.1.83 → 0.1.84

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

@@ -4,10 +4,9 @@ import path from "node:path";
 import { Readable, Writable } from "node:stream";
 import { ClientSideConnection, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
-import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import { checkProviderLaunchAvailable, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
-import { findExecutable } from "../../../utils/executable.js";
 import { platformShell, spawnProcess } from "../../../utils/spawn.js";
 function assertChildWithPipes(child) {
     if (!child.stdin || !child.stdout || !child.stderr) {
@@ -483,13 +482,14 @@ export class ACPAgentClient {
         }
     }
     async resolveLaunchCommand() {
-        const resolved = await findExecutable(this.defaultCommand[0]);
-        const prefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
-            if (!resolved) {
-                throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
-            }
-            return resolved;
+        const prefix = await resolveProviderLaunch({
+            commandConfig: this.runtimeSettings?.command,
+            defaultBinary: this.defaultCommand[0],
         });
+        const availability = await checkProviderLaunchAvailable(prefix);
+        if (!availability.available) {
+            throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
+        }
         return {
             command: prefix.command,
             args: [...prefix.args, ...this.defaultCommand.slice(1)],
@@ -1244,13 +1244,14 @@ export class ACPAgentSession {
         return {};
     }
     async spawnProcess() {
-        const resolved = await findExecutable(this.defaultCommand[0]);
-        const prefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, () => {
-            if (!resolved) {
-                throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
-            }
-            return resolved;
+        const prefix = await resolveProviderLaunch({
+            commandConfig: this.runtimeSettings?.command,
+            defaultBinary: this.defaultCommand[0],
         });
+        const availability = await checkProviderLaunchAvailable(prefix);
+        if (!availability.available) {
+            throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
+        }
         const command = prefix.command;
         const args = [...prefix.args, ...this.defaultCommand.slice(1)];
         const child = spawnProcess(command, args, {

package/dist/server/server/agent/providers/claude/agent.js

@@ -8,15 +8,14 @@ import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserConte
 import { getClaudeModelsWithSettings, normalizeClaudeRuntimeModelId } from "./models.js";
 import { parsePartialJsonObject } from "./partial-json.js";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "../provider-runner.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { claudeQuery } from "./query.js";
 import { realClaudeRewindSdk, revertClaudeConversation, revertClaudeFiles } from "./rewind.js";
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
 import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
-import { createProviderEnv, createProviderEnvSpec, } from "../../provider-launch-config.js";
-import { findExecutable, isCommandAvailable } from "../../../../utils/executable.js";
+import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { withTimeout } from "../../../../utils/promise-timeout.js";
 import { execCommand } from "../../../../utils/spawn.js";
 import { composeSystemPromptParts } from "../../system-prompt.js";
@@ -966,18 +965,24 @@ export class ClaudeAgentClient {
             .slice(0, limit);
     }
     async isAvailable() {
-        const command = this.runtimeSettings?.command;
-        if (command?.mode === "replace") {
-            return await isCommandAvailable(command.argv[0]);
-        }
-        return await isCommandAvailable("claude");
+        const launch = await resolveProviderLaunch({
+            commandConfig: this.runtimeSettings?.command,
+            defaultBinary: "claude",
+        });
+        const availability = await checkProviderLaunchAvailable(launch);
+        return availability.available;
     }
     async getDiagnostic() {
         try {
-            const resolvedBinary = (await findExecutable("claude")) ?? "not found";
-            const available = await this.isAvailable();
-            const version = await resolveClaudeVersion(this.runtimeSettings);
-            const auth = available ? await resolveClaudeAuth(this.runtimeSettings) : null;
+            const launch = await resolveProviderLaunch({
+                commandConfig: this.runtimeSettings?.command,
+                defaultBinary: "claude",
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            const available = availability.available;
+            const auth = available
+                ? await resolveClaudeAuth(launch, availability, this.runtimeSettings)
+                : null;
             let modelsValue = "Not checked";
             let status = formatDiagnosticStatus(available);
             if (available) {
@@ -998,8 +1003,7 @@ export class ClaudeAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("Claude Code", [
-                    { label: "Binary", value: resolvedBinary },
-                    ...(version ? [{ label: "Version", value: version }] : []),
+                    ...(await buildBinaryDiagnosticRows(launch, availability)),
                     ...(auth ? [{ label: "Auth", value: auth }] : []),
                     { label: "Models", value: modelsValue },
                     { label: "Status", value: status },
@@ -1020,43 +1024,17 @@ export class ClaudeAgentClient {
     }
 }
 async function resolveClaudeBinary(runtimeSettings) {
-    const command = runtimeSettings?.command;
-    if (command?.mode === "replace") {
-        const foundOverride = await findExecutable(command.argv[0]);
-        if (foundOverride) {
-            return foundOverride;
-        }
-    }
-    const found = await findExecutable("claude");
-    if (found) {
-        return found;
+    const launch = await resolveProviderLaunch({
+        commandConfig: runtimeSettings?.command,
+        defaultBinary: "claude",
+    });
+    const availability = await checkProviderLaunchAvailable(launch);
+    if (availability.available) {
+        return availability.resolvedPath ?? launch.command;
     }
     throw new Error("Claude binary not found. Install Claude Code (https://github.com/anthropics/claude-code) and ensure it is available in your shell PATH.");
 }
-async function resolveClaudeVersion(runtimeSettings) {
-    const command = runtimeSettings?.command;
-    const envSpec = createProviderEnvSpec({ runtimeSettings });
-    try {
-        if (command?.mode === "replace") {
-            const { stdout } = await execCommand(command.argv[0], [...command.argv.slice(1), "--version"], { ...envSpec, timeout: 5000 });
-            return stdout.trim() || null;
-        }
-        const executable = await findExecutable("claude");
-        if (!executable) {
-            return null;
-        }
-        const { stdout } = await execCommand(executable, ["--version"], {
-            ...envSpec,
-            timeout: 5000,
-        });
-        return stdout.trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-async function resolveClaudeAuth(runtimeSettings) {
-    const command = runtimeSettings?.command;
+async function resolveClaudeAuth(launch, availability, runtimeSettings) {
     const run = async (executable, args) => {
         try {
             return await execCommand(executable, args, {
@@ -1073,17 +1051,8 @@ async function resolveClaudeAuth(runtimeSettings) {
         }
     };
     try {
-        let result;
-        if (command?.mode === "replace") {
-            result = await run(command.argv[0], [...command.argv.slice(1), "auth", "status"]);
-        }
-        else {
-            const executable = await findExecutable("claude");
-            if (!executable) {
-                return null;
-            }
-            result = await run(executable, ["auth", "status"]);
-        }
+        const executable = availability.resolvedPath ?? launch.command;
+        const result = await run(executable, [...launch.args, "auth", "status"]);
         const combined = [result.stdout, result.stderr]
             .map((s) => s.trim())
             .filter((s) => s.length > 0)

package/dist/server/server/agent/providers/claude/sidechain-tracker.js

@@ -1,5 +1,5 @@
 import { mapClaudeRunningToolCall } from "./tool-call-mapper.js";
-import { buildToolCallDisplayModel } from "../../../../shared/tool-call-display.js";
+import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 const MAX_SUB_AGENT_LOG_ENTRIES = 200;
 const MAX_SUB_AGENT_SUMMARY_CHARS = 160;
 function readTrimmedString(value) {

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

@@ -9,16 +9,16 @@ declare const TaskNotificationEnvelopeSchema: z.ZodObject<{
     rawText: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     status: string | null;
-    summary: string | null;
     messageId: string | null;
     taskId: string | null;
+    summary: string | null;
     outputFile: string | null;
     rawText: string | null;
 }, {
     status: string | null;
-    summary: string | null;
     messageId: string | null;
     taskId: string | null;
+    summary: string | null;
     outputFile: string | null;
     rawText: string | null;
 }>;

package/dist/server/server/agent/providers/claude/tool-call-mapper.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { isSpeakToolName } from "../../tool-name-normalization.js";
+import { isSpeakToolName } from "@getpaseo/protocol/tool-name-normalization";
 import { deriveClaudeToolDetail } from "./tool-call-detail-parser.js";
 const ClaudeToolCallStatusSchema = z.enum(["running", "completed", "failed", "canceled"]);
 const ClaudeRawToolCallSchema = z

package/dist/server/server/agent/providers/codex/tool-call-detail-parser.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { stripCwdPrefix } from "../../../../shared/path-utils.js";
+import { stripCwdPrefix } from "@getpaseo/protocol/path-utils";
 import { ToolEditInputSchema, ToolEditOutputSchema, ToolReadInputSchema, ToolReadOutputWithPathSchema, ToolSearchInputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, toolDetailBranchByNameWithCwd, } from "../tool-call-detail-primitives.js";
 const CodexToolEnvelopeSchema = z
     .object({

package/dist/server/server/agent/providers/codex/tool-call-mapper.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { extractCodexShellOutput, normalizeToolCallStatus, truncateDiffText, } from "../tool-call-mapper-utils.js";
 import { deriveCodexToolDetail, normalizeCodexFilePath } from "./tool-call-detail-parser.js";
-import { isSpeakToolName } from "../../tool-name-normalization.js";
+import { isSpeakToolName } from "@getpaseo/protocol/tool-name-normalization";
 const CodexCommandValueSchema = z.union([z.string(), z.array(z.string())]);
 const CodexToolCallStatusSchema = z.enum(["running", "completed", "failed", "canceled"]);
 const CodexToolCallEnvelopeParamsSchema = z

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

@@ -10,8 +10,8 @@ import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
 import { curateAgentActivity } from "../activity-curator.js";
 import { mapCodexToolCallEnvelope, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
-import { createProviderEnv, createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
-import { findExecutable, isCommandAvailable, probeExecutable } from "../../../utils/executable.js";
+import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
+import { findExecutable, probeExecutable } from "../../../utils/executable.js";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
@@ -20,7 +20,7 @@ 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, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 function assertChildWithPipes(child) {
     if (!child.stdin || !child.stdout || !child.stderr) {
@@ -267,15 +267,31 @@ export async function findCodexMicrosoftStoreBinary() {
 export async function findDefaultCodexBinary() {
     return (await findExecutable("codex")) ?? (await findCodexMicrosoftStoreBinary());
 }
-async function resolveCodexBinary() {
-    const found = await findDefaultCodexBinary();
-    if (found) {
-        return found;
+async function resolveCodexLaunchPrefix(runtimeSettings) {
+    const launch = await resolveCodexLaunch(runtimeSettings);
+    const availability = await checkCodexLaunchAvailable(launch);
+    if (!availability.available) {
+        throw new Error("Codex binary not found. Install the Codex CLI (https://github.com/openai/codex) and ensure it is available in your shell PATH.");
     }
-    throw new Error("Codex binary not found. Install the Codex CLI (https://github.com/openai/codex) and ensure it is available in your shell PATH.");
+    return {
+        command: launch.source === "override" ? launch.command : (availability.resolvedPath ?? launch.command),
+        args: launch.args,
+    };
 }
-async function resolveCodexLaunchPrefix(runtimeSettings) {
-    return resolveProviderCommandPrefix(runtimeSettings?.command, resolveCodexBinary);
+async function resolveCodexLaunch(runtimeSettings) {
+    return resolveProviderLaunch({
+        commandConfig: runtimeSettings?.command,
+        defaultBinary: {
+            command: "codex",
+            resolvePath: findDefaultCodexBinary,
+        },
+    });
+}
+async function checkCodexLaunchAvailable(launch) {
+    return checkProviderLaunchAvailable(launch, {
+        command: "codex",
+        resolvePath: findDefaultCodexBinary,
+    });
 }
 function resolveCodexHomeDir() {
     return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
@@ -4394,25 +4410,17 @@ export class CodexAppServerAgentClient {
         }
     }
     async isAvailable() {
-        const command = this.runtimeSettings?.command;
-        if (command?.mode === "replace") {
-            return await isCommandAvailable(command.argv[0]);
-        }
-        return (await findDefaultCodexBinary()) !== null;
+        const launch = await resolveCodexLaunch(this.runtimeSettings);
+        const availability = await checkCodexLaunchAvailable(launch);
+        return availability.available;
     }
     async getDiagnostic() {
         try {
-            const available = await this.isAvailable();
-            const resolvedBinary = await findDefaultCodexBinary();
+            const launch = await resolveCodexLaunch(this.runtimeSettings);
+            const availability = await checkCodexLaunchAvailable(launch);
+            const available = availability.available;
             const entries = [
-                {
-                    label: "Binary",
-                    value: resolvedBinary ?? "not found",
-                },
-                {
-                    label: "Version",
-                    value: resolvedBinary ? await resolveBinaryVersion(resolvedBinary) : "unknown",
-                },
+                ...(await buildBinaryDiagnosticRows(launch, availability)),
             ];
             let status = formatDiagnosticStatus(available);
             if (!available) {

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

@@ -1,7 +1,7 @@
 import type { Logger } from "pino";
 import type { SessionConfigOption } from "@agentclientprotocol/sdk";
 import type { AgentMode } from "../agent-sdk-types.js";
-import type { ProviderRuntimeSettings } from "../provider-launch-config.js";
+import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { ACPAgentClient, type ACPBeforeModeWriteResult, type ACPProviderModeWriteResult, type ACPProviderModeWriterContext, type SessionStateResponse } from "./acp-agent.js";
 export declare const COPILOT_ALLOW_ALL_MODE_ID = "allow-all";
 export declare const COPILOT_MODES: AgentMode[];

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

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
-import { findExecutable } from "../../../utils/executable.js";
+import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { ACPAgentClient, } from "./acp-agent.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 const COPILOT_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -58,8 +58,12 @@ export class CopilotACPAgentClient extends ACPAgentClient {
     }
     async getDiagnostic() {
         try {
-            const available = await this.isAvailable();
-            const resolvedBinary = await findExecutable("copilot");
+            const launch = await resolveProviderLaunch({
+                commandConfig: this.runtimeSettings?.command,
+                defaultBinary: "copilot",
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            const available = availability.available;
             let modelsValue = "Not checked";
             let status = formatDiagnosticStatus(available);
             if (available) {
@@ -88,14 +92,7 @@ export class CopilotACPAgentClient extends ACPAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("Copilot", [
-                    {
-                        label: "Binary",
-                        value: resolvedBinary ?? "not found",
-                    },
-                    {
-                        label: "Version",
-                        value: resolvedBinary ? await resolveBinaryVersion(resolvedBinary) : "unknown",
-                    },
+                    ...(await buildBinaryDiagnosticRows(launch, availability)),
                     { label: "Models", value: modelsValue },
                     { label: "Status", value: status },
                 ]),

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

@@ -1,5 +1,5 @@
-import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
-interface DiagnosticEntry {
+import { type ProviderLaunchAvailability, type ProviderRuntimeSettings, type ResolvedProviderLaunch } from "../provider-launch-config.js";
+export interface DiagnosticEntry {
     label: string;
     value: string;
 }
@@ -12,6 +12,15 @@ export declare function formatDiagnosticStatus(available: boolean, error?: {
 }): string;
 export declare function toDiagnosticErrorMessage(error: unknown): string;
 export declare function resolveBinaryVersion(binaryPath: string): Promise<string>;
+export interface BinaryDiagnosticVersionCommand {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface BinaryDiagnosticRowsOptions {
+    binaryLabel?: string;
+    versionCommand?: BinaryDiagnosticVersionCommand;
+}
+export declare function buildBinaryDiagnosticRows(launch: ResolvedProviderLaunch, availability: ProviderLaunchAvailability, options?: BinaryDiagnosticRowsOptions): Promise<DiagnosticEntry[]>;
 export declare function formatConfiguredCommand(defaultArgv: readonly string[], runtimeSettings?: ProviderRuntimeSettings): string;
-export {};
 //# sourceMappingURL=diagnostic-utils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { createProviderEnvSpec } from "../provider-launch-config.js";
+import { createProviderEnvSpec, } from "../provider-launch-config.js";
 import { execCommand } from "../../../utils/spawn.js";
 export function formatProviderDiagnostic(providerName, entries) {
     return [providerName, ...entries.map((entry) => `  ${entry.label}: ${entry.value}`)].join("\n");
@@ -114,6 +114,46 @@ export async function resolveBinaryVersion(binaryPath) {
         return `error: ${toDiagnosticErrorMessage(error)}`;
     }
 }
+async function resolveCommandVersion(invocation) {
+    try {
+        const { stdout, stderr } = await execCommand(invocation.command, invocation.args, {
+            ...createProviderEnvSpec({ runtimeSettings: { env: invocation.env } }),
+            timeout: 5000,
+        });
+        return stdout.trim() || stderr.trim() || "unknown";
+    }
+    catch (error) {
+        return `error: ${toDiagnosticErrorMessage(error)}`;
+    }
+}
+export async function buildBinaryDiagnosticRows(launch, availability, options = {}) {
+    const defaultBinaryLabel = launch.source === "override" ? "Binary (override)" : "Binary";
+    const binaryLabel = options.binaryLabel ?? defaultBinaryLabel;
+    let version = "unknown";
+    if (options.versionCommand && availability.available) {
+        version = await resolveCommandVersion(options.versionCommand);
+    }
+    else if (availability.available) {
+        version = await resolveCommandVersion({
+            command: availability.resolvedPath ?? launch.command,
+            args: [...launch.args, "--version"],
+        });
+    }
+    return [
+        {
+            label: binaryLabel,
+            value: launch.command,
+        },
+        {
+            label: "Resolved path",
+            value: availability.resolvedPath ?? "not found",
+        },
+        {
+            label: "Version",
+            value: version,
+        },
+    ];
+}
 export function formatConfiguredCommand(defaultArgv, runtimeSettings) {
     const command = runtimeSettings?.command;
     if (!command || command.mode === "default") {

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

@@ -22,6 +22,7 @@ export declare class GenericACPAgentClient extends ACPAgentClient {
     getDiagnostic(): Promise<{
         diagnostic: string;
     }>;
+    private resolveConfiguredLaunch;
     private runDiagnosticACPProbe;
 }
 export interface CommandInvocation {

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

@@ -1,9 +1,7 @@
 import { homedir } from "node:os";
-import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
-import { execCommand } from "../../../utils/spawn.js";
-import { createProviderEnvSpec } from "../provider-launch-config.js";
+import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
 import { ACPAgentClient, deriveModelDefinitionsFromACP, deriveModesFromACP, } from "./acp-agent.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "./diagnostic-utils.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;
 export class GenericACPAgentClient extends ACPAgentClient {
@@ -29,13 +27,16 @@ export class GenericACPAgentClient extends ACPAgentClient {
         };
     }
     async isAvailable() {
-        return isCommandAvailable(this.command[0]);
+        const launch = await this.resolveConfiguredLaunch();
+        const availability = await checkProviderLaunchAvailable(launch);
+        return availability.available;
     }
     async getDiagnostic() {
         const providerName = formatProviderName(this.label, this.providerId);
         try {
-            const resolvedBinary = await findExecutable(this.command[0]);
-            const available = resolvedBinary !== null;
+            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()
@@ -50,17 +51,18 @@ export class GenericACPAgentClient extends ACPAgentClient {
                 diagnostic: formatProviderDiagnostic(providerName, [
                     { label: "Provider ID", value: this.providerId ?? "unknown" },
                     { label: "Configured command", value: this.command.join(" ") },
-                    { label: "Launcher binary", value: resolvedBinary ?? "not found" },
+                    ...(await buildBinaryDiagnosticRows(launch, availability, {
+                        binaryLabel: "Launcher binary",
+                        versionCommand: {
+                            command: versionProbe.command,
+                            args: versionProbe.args,
+                            env: this.runtimeSettings?.env,
+                        },
+                    })),
                     {
                         label: "Version command",
                         value: formatCommand(versionProbe.command, versionProbe.args),
                     },
-                    {
-                        label: "Version",
-                        value: resolvedBinary
-                            ? await resolveCommandVersion(versionProbe, this.runtimeSettings?.env)
-                            : "unknown",
-                    },
                     { label: "ACP initialize", value: probeResult.initialize },
                     { label: "ACP session/new", value: probeResult.session },
                     { label: "Models", value: probeResult.models },
@@ -75,6 +77,12 @@ export class GenericACPAgentClient extends ACPAgentClient {
             };
         }
     }
+    async resolveConfiguredLaunch() {
+        return resolveProviderLaunch({
+            commandConfig: { mode: "replace", argv: this.command },
+            defaultBinary: this.command[0],
+        });
+    }
     async runDiagnosticACPProbe() {
         let initializeValue = "Not checked";
         let sessionValue = "Not checked";
@@ -201,18 +209,6 @@ function formatProbeError(currentValue, error) {
     }
     return `Error - ${toDiagnosticErrorMessage(error)}`;
 }
-async function resolveCommandVersion(invocation, env) {
-    try {
-        const { stdout, stderr } = await execCommand(invocation.command, invocation.args, {
-            ...createProviderEnvSpec({ runtimeSettings: { env } }),
-            timeout: 5000,
-        });
-        return stdout.trim() || stderr.trim() || "unknown";
-    }
-    catch (error) {
-        return `error: ${toDiagnosticErrorMessage(error)}`;
-    }
-}
 async function withTimeout(promise, timeoutMs, label) {
     let timeout = null;
     try {

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

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { getAgentProviderDefinition } from "../provider-manifest.js";
+import { getAgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 export const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
 export const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
 const MOCK_LOAD_TEST_MODE_ID = "load-test";

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

@@ -0,0 +1,16 @@
+import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, ListModelsOptions, ListModesOptions, ListPersistedAgentsOptions, PersistedAgentDescriptor } 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[]>;
+    listPersistedAgents(_options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+    createSession(_config: AgentSessionConfig, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    resumeSession(_handle: AgentPersistenceHandle, _overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+}
+//# sourceMappingURL=mock-slow-provider.d.ts.map

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

@@ -0,0 +1,45 @@
+export const MOCK_SLOW_PROVIDER_ID = "mock-slow";
+const CAPABILITIES = {
+    supportsStreaming: false,
+    supportsSessionPersistence: false,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: false,
+    supportsToolInvocations: false,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+function neverResolves() {
+    return new Promise(() => { });
+}
+export class MockSlowProviderClient {
+    constructor() {
+        this.provider = MOCK_SLOW_PROVIDER_ID;
+        this.capabilities = CAPABILITIES;
+    }
+    async isAvailable() {
+        return true;
+    }
+    listModels(_options) {
+        return neverResolves();
+    }
+    listModes(_options) {
+        return neverResolves();
+    }
+    async listPersistedAgents(_options) {
+        return [];
+    }
+    async getDiagnostic() {
+        return {
+            diagnostic: "Mock slow provider: dev-only. listModels() never resolves so the snapshot manager will time out.",
+        };
+    }
+    createSession(_config, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+    resumeSession(_handle, _overrides, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+}
+//# sourceMappingURL=mock-slow-provider.js.map