@getpaseo/server 0.1.100 → 0.1.102-beta.2

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

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
+import { homedir } from "node:os";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
 import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
@@ -10,6 +11,8 @@ import { checkProviderLaunchAvailable, createProviderEnvSpec, resolveProviderLau
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
 import { platformShell, spawnProcess } from "../../../utils/spawn.js";
+import { toDiagnosticErrorMessage, truncateForDiagnostic, } from "./diagnostic-utils.js";
+import { withTimeout } from "../../../utils/promise-timeout.js";
 function assertChildWithPipes(child) {
     if (!child.stdin || !child.stdout || !child.stderr) {
         throw new Error("Child process did not expose stdio pipes");
@@ -70,6 +73,19 @@ function resolveTerminalCommand(command, args) {
     const shell = platformShell();
     return { command: shell.command, args: [...shell.flag, command] };
 }
+function formatDurationMs(startedAt) {
+    return `${Math.max(0, Date.now() - startedAt)}ms`;
+}
+function pushACPStderrRow(rows, stderrChunks) {
+    const stderr = stderrChunks.join("").trim();
+    if (!stderr) {
+        return;
+    }
+    rows.push({
+        label: "ACP stderr",
+        value: truncateForDiagnostic(stderr),
+    });
+}
 export const DEFAULT_ACP_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -96,6 +112,8 @@ const ACP_CLIENT_CAPABILITIES = {
 // sign-in URL in the browser) when probing an ACP agent for models/modes.
 // NO_BROWSER is honored by Gemini CLI; other ACP agents ignore it.
 const PROBE_ENV = { NO_BROWSER: "true" };
+const ACP_CATALOG_TIMEOUT_MS = 60000;
+const ACP_DIAGNOSTIC_PHASE_TIMEOUT_MS = 20000;
 function summarizeMalformedACPStdoutError(error) {
     return {
         type: error instanceof Error ? error.name : typeof error,
@@ -368,23 +386,36 @@ export class ACPAgentClient {
         return session;
     }
     async fetchCatalog(options) {
-        const { cwd } = options;
-        const probe = await this.spawnProcess(PROBE_ENV);
+        const cwd = options.scope === "global" ? homedir() : options.cwd;
+        const timeoutMs = options.timeoutMs ?? ACP_CATALOG_TIMEOUT_MS;
+        let probe = null;
         try {
-            const response = await this.runACPRequest(() => probe.connection.newSession({
-                cwd,
-                mcpServers: [],
-            }));
-            const transformed = this.transformSessionResponse(response);
-            const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
-            const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
-            return {
-                models: this.modelTransformer ? this.modelTransformer(models) : models,
-                modes: modeInfo.modes,
-            };
+            const catalogProbe = (async () => {
+                const initializedProbe = await this.spawnProcess(PROBE_ENV, {
+                    initializeTimeoutMs: timeoutMs,
+                    onSpawned: (spawned) => {
+                        probe = spawned;
+                    },
+                });
+                probe = initializedProbe;
+                const response = await this.runACPRequest(() => initializedProbe.connection.newSession({
+                    cwd,
+                    mcpServers: [],
+                }));
+                const transformed = this.transformSessionResponse(response);
+                const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
+                const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+                return {
+                    models: this.modelTransformer ? this.modelTransformer(models) : models,
+                    modes: modeInfo.modes,
+                };
+            })();
+            return await withTimeout(catalogProbe, timeoutMs, `ACP catalog probe timed out after ${timeoutMs}ms`);
         }
         finally {
-            await this.closeProbe(probe);
+            if (probe) {
+                await this.closeProbe(probe);
+            }
         }
     }
     async listFeatures(config) {
@@ -461,6 +492,28 @@ export class ACPAgentClient {
         }
     }
     async spawnProcess(launchEnv, options) {
+        const transport = await this.spawnTransport(launchEnv);
+        const probe = {
+            child: transport.child,
+            connection: transport.connection,
+            stderrChunks: transport.stderrChunks,
+        };
+        options?.onSpawned?.(probe);
+        try {
+            const initialize = await this.initializeTransport(transport, options?.initializeTimeoutMs);
+            const initializedProbe = {
+                ...probe,
+                initialize,
+            };
+            probe.initialize = initialize;
+            return initializedProbe;
+        }
+        catch (error) {
+            await terminateChildProcess(transport.child, 2000, this.terminateProcess);
+            throw error;
+        }
+    }
+    async spawnTransport(launchEnv) {
         const { command, args } = await this.resolveLaunchCommand();
         const child = spawnProcess(command, args, {
             cwd: process.cwd(),
@@ -481,38 +534,46 @@ export class ACPAgentClient {
                 reject(new Error(stderr ? `${String(error)}\n${stderr}` : String(error)));
             });
         });
+        const spawnReadyPromise = new Promise((resolve) => {
+            child.once("spawn", () => {
+                resolve();
+            });
+        });
         const stream = createLoggedNdJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout), { logger: this.logger, provider: this.provider });
         const connection = new ClientSideConnection(() => this.buildProbeClient(), stream);
+        return {
+            child,
+            connection,
+            stderrChunks,
+            spawnReady: spawnReadyPromise,
+            spawnError: spawnErrorPromise,
+        };
+    }
+    async initializeTransport(transport, initializeTimeoutMs) {
         let timeout = null;
-        const initializeTimeoutPromise = options?.initializeTimeoutMs
+        const initializeTimeoutPromise = initializeTimeoutMs
             ? new Promise((_, reject) => {
                 timeout = setTimeout(() => {
-                    reject(new Error(`ACP initialize timed out after ${options.initializeTimeoutMs}ms`));
-                }, options.initializeTimeoutMs);
+                    reject(new Error(`ACP initialize timed out after ${initializeTimeoutMs}ms`));
+                }, initializeTimeoutMs);
             })
             : null;
-        let initialize;
         try {
-            initialize = await this.runACPRequest(() => Promise.race([
-                connection.initialize({
+            return await this.runACPRequest(() => Promise.race([
+                transport.connection.initialize({
                     protocolVersion: PROTOCOL_VERSION,
                     clientCapabilities: ACP_CLIENT_CAPABILITIES,
                     clientInfo: { name: "Paseo", version: "dev" },
                 }),
-                spawnErrorPromise,
+                transport.spawnError,
                 ...(initializeTimeoutPromise ? [initializeTimeoutPromise] : []),
             ]));
         }
-        catch (error) {
-            await terminateChildProcess(child, 2000, this.terminateProcess);
-            throw error;
-        }
         finally {
             if (timeout) {
                 clearTimeout(timeout);
             }
         }
-        return { child, connection, initialize };
     }
     buildProbeClient() {
         return {
@@ -536,7 +597,7 @@ export class ACPAgentClient {
     }
     async closeProbe(probe) {
         try {
-            if (probe.initialize.agentCapabilities?.sessionCapabilities?.close) {
+            if (probe.initialize?.agentCapabilities?.sessionCapabilities?.close) {
                 // No active session to close here; ignore capability.
             }
         }
@@ -552,6 +613,89 @@ export class ACPAgentClient {
             throw toACPRequestError(error);
         }
     }
+    async buildACPProbeDiagnosticRows(options = {}) {
+        const rows = [];
+        const phaseTimeoutMs = options.phaseTimeoutMs ?? ACP_DIAGNOSTIC_PHASE_TIMEOUT_MS;
+        const cwd = options.cwd ?? homedir();
+        let transport = null;
+        try {
+            const spawnStartedAt = Date.now();
+            try {
+                transport = await this.spawnTransport(PROBE_ENV);
+                await withTimeout(Promise.race([transport.spawnReady, transport.spawnError]), phaseTimeoutMs, `ACP spawn timed out after ${phaseTimeoutMs}ms`);
+                rows.push({
+                    label: "ACP spawn",
+                    value: `ok (${formatDurationMs(spawnStartedAt)})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP spawn",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                return rows;
+            }
+            const activeTransport = transport;
+            const initializeStartedAt = Date.now();
+            try {
+                await this.initializeTransport(activeTransport, phaseTimeoutMs);
+                rows.push({
+                    label: "ACP initialize",
+                    value: `ok (${formatDurationMs(initializeStartedAt)})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP initialize",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                pushACPStderrRow(rows, activeTransport.stderrChunks);
+                return rows;
+            }
+            const sessionStartedAt = Date.now();
+            try {
+                const response = await withTimeout(this.runACPRequest(() => activeTransport.connection.newSession({
+                    cwd,
+                    mcpServers: [],
+                })), phaseTimeoutMs, `ACP session/new timed out after ${phaseTimeoutMs}ms`);
+                const transformed = this.transformSessionResponse(response);
+                const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
+                const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+                rows.push({
+                    label: "ACP session/new",
+                    value: `ok (${formatDurationMs(sessionStartedAt)}; models=${models.length}; modes=${modeInfo.modes.length})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP session/new",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                pushACPStderrRow(rows, activeTransport.stderrChunks);
+                return rows;
+            }
+            pushACPStderrRow(rows, activeTransport.stderrChunks);
+            return rows;
+        }
+        finally {
+            if (transport) {
+                const cleanupStartedAt = Date.now();
+                try {
+                    await terminateChildProcess(transport.child, 2000, this.terminateProcess);
+                    rows.push({
+                        label: "ACP cleanup",
+                        value: `ok (${formatDurationMs(cleanupStartedAt)})`,
+                    });
+                }
+                catch (error) {
+                    rows.push({
+                        label: "ACP cleanup",
+                        value: `error: ${toDiagnosticErrorMessage(error)}`,
+                    });
+                }
+            }
+        }
+    }
     async resolveLaunchCommand() {
         const prefix = await resolveProviderLaunch({
             commandConfig: this.runtimeSettings?.command,
@@ -658,6 +802,13 @@ export class ACPAgentSession {
         this.applySessionState(response);
         await this.applyConfiguredOverrides();
     }
+    /**
+     * IMPORTANT: Some ACP providers (e.g., Devin CLI) require all three params
+     * (sessionId, cwd, mcpServers) to be present in session/load or
+     * unstable_resumeSession — even when mcpServers is an empty array — and
+     * return "Invalid params" if any are omitted. Never drop cwd or mcpServers
+     * from these calls regardless of capabilities.
+     */
     async initializeResumedSession() {
         const handle = this.initialHandle;
         if (!handle) {

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

@@ -17,10 +17,12 @@ import { realClaudeRewindSdk, revertClaudeConversation, revertClaudeFiles } from
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
 import { claudeProjectDirSync } from "./project-dir.js";
 import { SETTING_APPLIES_NEXT_TURN_NOTICE } from "../../provider-notices.js";
+import { isProviderImageMarkdown, materializeProviderImage, renderProviderImageOutputAsAssistantMarkdown, } from "../provider-image-output.js";
 import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { withTimeout } from "../../../../utils/promise-timeout.js";
+import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
 import { execCommand } from "../../../../utils/spawn.js";
 import { composeSystemPromptParts } from "../../system-prompt.js";
 const fsPromises = promises;
@@ -370,6 +372,39 @@ function coerceToolResultContentToString(content) {
     }
     return deterministicStringify(content);
 }
+function toBase64ImageOutput(block) {
+    const record = toObjectRecord(block);
+    if (!record || record.type !== "image") {
+        return null;
+    }
+    const source = toObjectRecord(record.source);
+    if (!source || source.type !== "base64" || typeof source.data !== "string") {
+        return null;
+    }
+    return {
+        data: source.data,
+        mimeType: typeof source.media_type === "string" ? source.media_type : null,
+    };
+}
+// Claude returns images inside tool_result content as base64 Anthropic blocks. Left in place they
+// reach coerceToolResultContentToString, which JSON.stringifies the whole array — dumping base64
+// into the tool output. We pull those blocks out to render them as image markdown and leave a
+// "[image]" placeholder so image-only results still produce non-empty output.
+function splitClaudeToolResultImages(content) {
+    if (!Array.isArray(content)) {
+        return { images: [], text: content };
+    }
+    const images = [];
+    const text = content.map((block) => {
+        const image = toBase64ImageOutput(block);
+        if (image) {
+            images.push(image);
+            return { type: "text", text: "[image]" };
+        }
+        return block;
+    });
+    return { images, text };
+}
 function normalizeClaudeTranscriptText(value) {
     if (typeof value !== "string") {
         return null;
@@ -1255,6 +1290,13 @@ function readLegacyResultUsageTokens(usage) {
 function isClaudeSubagentToolName(name) {
     return name === "Task" || name === "Agent";
 }
+function readClaudeParentToolUseId(message) {
+    if (!("parent_tool_use_id" in message)) {
+        return null;
+    }
+    const parentToolUseId = message.parent_tool_use_id;
+    return typeof parentToolUseId === "string" && parentToolUseId.length > 0 ? parentToolUseId : null;
+}
 class ClaudeContextUsageState {
     constructor(initialContextWindowMaxTokens) {
         this.completedResultTurns = 0;
@@ -1380,6 +1422,7 @@ class ClaudeAgentSession {
         this.provider = "claude";
         this.capabilities = CLAUDE_CAPABILITIES;
         this.query = null;
+        this.childProcess = null;
         this.input = null;
         this.planResumeMode = null;
         this.availableModes = DEFAULT_MODES;
@@ -1853,6 +1896,19 @@ class ClaudeAgentSession {
         await this.awaitWithTimeout(this.query?.return?.(), "close query return");
         this.query = null;
         this.input = null;
+        // Terminate the entire process tree (claude + MCP children) to prevent
+        // orphan accumulation. The SDK's internal cleanup may only kill the
+        // direct child process.
+        if (this.childProcess) {
+            const result = await terminateWithTreeKill(this.childProcess, {
+                gracefulTimeoutMs: 2000,
+                forceTimeoutMs: 2000,
+            });
+            if (result === "kill-timeout") {
+                this.logger.warn({ pid: this.childProcess.pid, agentId: this.agentId }, "Claude process tree did not report exit after SIGKILL");
+            }
+            this.childProcess = null;
+        }
         if (this.persistSession === false && this.claudeSessionId) {
             // Claude Code currently ignores --no-session-persistence outside --print mode
             // (see `claude --help`), so the SDK's persistSession=false is silently dropped
@@ -2191,6 +2247,18 @@ class ClaudeAgentSession {
             catch {
                 /* ignore */
             }
+            // Tree-kill the old process tree now that the SDK has cleaned up.
+            // If we skip this, MCP children of the previous claude process can
+            // survive as orphans when the session spawns a replacement query.
+            if (this.childProcess) {
+                await terminateWithTreeKill(this.childProcess, {
+                    gracefulTimeoutMs: 2000,
+                    forceTimeoutMs: 2000,
+                }).catch(() => {
+                    /* process may already be dead */
+                });
+                this.childProcess = null;
+            }
         }
         // Preserve claudeSessionId across query recreation so buildOptions() passes
         // resume: sessionId and the new query continues the existing conversation.
@@ -2203,6 +2271,9 @@ class ClaudeAgentSession {
             runtimeSettings: this.runtimeSettings,
             launchEnv: this.launchEnv,
             queryFactory: this.queryFactory,
+            onChildProcess: (child) => {
+                this.childProcess = child;
+            },
         });
         const fastMode = this.resolveFastModeSetting();
         if (fastMode !== null) {
@@ -2775,17 +2846,19 @@ class ClaudeAgentSession {
             suppressAssistantText: true,
             suppressReasoning: true,
         });
-        const assistantTimelineEvents = this.timelineAssembler
-            .consume({
-            message,
-            runId: turnId,
-            messageIdHint,
-        })
-            .map((item) => ({
-            type: "timeline",
-            item,
-            provider: "claude",
-        }));
+        const assistantTimelineEvents = readClaudeParentToolUseId(message)
+            ? []
+            : this.timelineAssembler
+                .consume({
+                message,
+                runId: turnId,
+                messageIdHint,
+            })
+                .map((item) => ({
+                type: "timeline",
+                item,
+                provider: "claude",
+            }));
         return [...messageEvents, ...assistantTimelineEvents];
     }
     async handleMissingResumedConversation(message, activeQuery) {
@@ -2833,9 +2906,7 @@ class ClaudeAgentSession {
         }
     }
     translateMessageToEvents(message, options) {
-        const parentToolUseId = "parent_tool_use_id" in message
-            ? message.parent_tool_use_id
-            : null;
+        const parentToolUseId = readClaudeParentToolUseId(message);
         if (parentToolUseId) {
             return this.sidechainTracker.handleMessage(message, parentToolUseId);
         }
@@ -3472,15 +3543,17 @@ class ClaudeAgentSession {
         const callId = typeof block.tool_use_id === "string" && block.tool_use_id.length > 0
             ? block.tool_use_id
             : (entry?.id ?? null);
-        // Extract output from block.content (SDK always returns content in string form)
-        const output = this.buildToolOutput(block, entry);
+        // Pull image blocks out of the result so base64 never reaches the tool output, and render each
+        // one as an assistant_message markdown image after the tool_call (matching how Codex emits).
+        const { images, text } = splitClaudeToolResultImages(block.content);
+        const output = this.buildToolOutput(text, block, entry);
         if (block.is_error) {
             this.pushToolCall(mapClaudeFailedToolCall({
                 name: toolName,
                 callId,
                 input: entry?.input ?? null,
                 output: output ?? null,
-                error: block,
+                error: { ...block, content: text },
             }), items);
         }
         else {
@@ -3491,12 +3564,20 @@ class ClaudeAgentSession {
                 output: output ?? null,
             }), items);
         }
+        for (const image of images) {
+            const imageItem = renderProviderImageOutputAsAssistantMarkdown(image, {
+                materialize: materializeProviderImage,
+            });
+            if (imageItem) {
+                items.push(imageItem);
+            }
+        }
         if (typeof block.tool_use_id === "string") {
             this.toolUseCache.delete(block.tool_use_id);
             this.sidechainTracker.delete(block.tool_use_id);
         }
     }
-    buildToolOutput(block, entry) {
+    buildToolOutput(content, block, entry) {
         if (block.is_error) {
             return undefined;
         }
@@ -3504,23 +3585,23 @@ class ClaudeAgentSession {
         const blockToolName = typeof block.tool_name === "string" ? block.tool_name : undefined;
         const server = entry?.server ?? blockServer ?? "tool";
         const tool = entry?.name ?? blockToolName ?? "tool";
-        const content = coerceToolResultContentToString(block.content);
+        const coercedContent = coerceToolResultContentToString(content);
         const input = entry?.input;
         // Build structured result based on tool type
-        const structured = this.buildStructuredToolResult(server, tool, content, input);
+        const structured = this.buildStructuredToolResult(server, tool, coercedContent, input);
         if (structured) {
             return structured;
         }
         // Fallback format - try to parse JSON first
         const result = {};
-        if (content.length > 0) {
+        if (coercedContent.length > 0) {
             try {
                 // If content is a JSON string, parse it
-                result.output = JSON.parse(content);
+                result.output = JSON.parse(coercedContent);
             }
             catch {
                 // If not JSON, return unchanged (no extra wrapping)
-                result.output = content;
+                result.output = coercedContent;
             }
         }
         // Preserve file changes tracked during tool execution
@@ -3945,6 +4026,9 @@ function convertClaudeHistoryEntryPreamble(entry) {
     }
     return { proceed: { content } };
 }
+function isProviderImageMessage(item) {
+    return item.type === "assistant_message" && isProviderImageMarkdown(item.text);
+}
 export function convertClaudeHistoryEntry(entry, mapBlocks) {
     const preamble = convertClaudeHistoryEntryPreamble(entry);
     if ("shortCircuit" in preamble) {
@@ -3980,7 +4064,10 @@ export function convertClaudeHistoryEntry(entry, mapBlocks) {
     if (hasToolBlock && normalizedBlocks) {
         const mapped = mapBlocks(normalizedBlocks);
         if (entry.type === "user") {
-            const toolItems = mapped.filter((item) => item.type === "tool_call");
+            // tool_result handling (handleToolResult) emits image markdown as an assistant_message
+            // alongside the tool_call. User-entry text blocks also map to assistant_message in this path
+            // and must stay suppressed, so keep tool_calls plus only the image assistant_messages.
+            const toolItems = mapped.filter((item) => item.type === "tool_call" || isProviderImageMessage(item));
             return timeline.length ? [...timeline, ...toolItems] : toolItems;
         }
         return mapped;

package/dist/server/server/agent/providers/claude/query.d.ts

@@ -1,3 +1,4 @@
+import { type ChildProcess } from "node:child_process";
 import { query, type Options, type Query } from "@anthropic-ai/claude-agent-sdk";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export type ClaudeOptions = Options;
@@ -9,6 +10,8 @@ export interface ClaudeQueryContext {
     runtimeSettings?: ProviderRuntimeSettings;
     launchEnv?: Record<string, string>;
     queryFactory?: ClaudeQueryFactory;
+    /** Called with the spawned child process so the caller can tree-kill it on close. */
+    onChildProcess?: (child: ChildProcess) => void;
 }
 export declare function claudeQuery(input: ClaudeQueryInput, context?: ClaudeQueryContext): Query;
 //# sourceMappingURL=query.d.ts.map

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

@@ -24,7 +24,8 @@ function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
         args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
     };
 }
-function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv) {
+function applyRuntimeSettingsToClaudeOptions(options, context) {
+    const { runtimeSettings, launchEnv, onChildProcess } = context;
     return {
         ...options,
         spawnClaudeCodeProcess: (spawnOptions) => {
@@ -62,6 +63,7 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv
                 // The command is always a resolved binary path, so shell routing is unnecessary.
                 shell: false,
             });
+            onChildProcess?.(child);
             if (typeof options.stderr === "function") {
                 child.stderr?.on("data", (chunk) => {
                     options.stderr?.(chunk.toString());
@@ -78,7 +80,7 @@ export function claudeQuery(input, context = {}) {
     const launchQuery = context.queryFactory ?? query;
     return launchQuery({
         ...input,
-        options: applyRuntimeSettingsToClaudeOptions(input.options, context.runtimeSettings, context.launchEnv),
+        options: applyRuntimeSettingsToClaudeOptions(input.options, context),
     });
 }
 //# sourceMappingURL=query.js.map