@getpaseo/server 0.1.100 → 0.1.101

package/dist/server/server/agent/prompt-attachments.js

@@ -67,14 +67,18 @@ export function buildAgentBranchNameSeed(firstAgentContext) {
     const parts = [];
     const prompt = firstAgentContext.prompt?.trim();
     if (prompt) {
-        parts.push(prompt);
+        parts.push(["<user-prompt>", prompt, "</user-prompt>"].join("\n"));
     }
+    const renderedAttachments = [];
     for (const attachment of firstAgentContext.attachments ?? []) {
         const rendered = renderPromptAttachmentAsText(attachment).trim();
         if (rendered) {
-            parts.push(rendered);
+            renderedAttachments.push(rendered);
         }
     }
+    if (renderedAttachments.length > 0) {
+        parts.push(["<attachments>", renderedAttachments.join("\n\n"), "</attachments>"].join("\n"));
+    }
     return parts.length > 0 ? parts.join("\n\n") : undefined;
 }
 //# sourceMappingURL=prompt-attachments.js.map

package/dist/server/server/agent/provider-snapshot-manager.d.ts

@@ -15,6 +15,7 @@ export interface ProviderSnapshotManagerOptions {
     isDev?: boolean;
     extraClients?: Partial<Record<AgentProvider, AgentClient>>;
     refreshTimeoutMs?: number;
+    diagnosticTimeoutMs?: number;
 }
 interface ProviderSnapshotRefreshOptions {
     cwd: string;
@@ -64,6 +65,7 @@ export declare class ProviderSnapshotManager {
     private readonly events;
     private destroyed;
     private readonly refreshTimeoutMs;
+    private readonly diagnosticTimeoutMs;
     private readonly logger;
     private readonly workspaceGitService?;
     private readonly managedProcesses?;
@@ -101,6 +103,8 @@ export declare class ProviderSnapshotManager {
     private resolveParent;
     private getReadyProvider;
     private requireProvider;
+    private refreshDiagnosticSnapshotEntry;
+    private getBaseProviderDiagnostic;
     private createLoadingEntries;
     private reconcileSnapshotForRegistry;
     private warmUp;

package/dist/server/server/agent/provider-snapshot-manager.js

@@ -5,8 +5,9 @@ import { expandTilde } from "../../utils/path.js";
 import { withTimeout } from "../../utils/promise-timeout.js";
 import { buildProviderRegistry, shutdownAgentClients, } from "./provider-registry.js";
 import { applyMutableProviderConfigToOverrides } from "../daemon-config-store.js";
-import { formatProviderDiagnostic } from "./providers/diagnostic-utils.js";
-const DEFAULT_REFRESH_TIMEOUT_MS = 30000;
+import { formatProviderDiagnostic, formatProviderDiagnosticError, } from "./providers/diagnostic-utils.js";
+const DEFAULT_REFRESH_TIMEOUT_MS = 60000;
+const DEFAULT_DIAGNOSTIC_TIMEOUT_MS = 120000;
 const REFRESH_TIMEOUT_ENV_VAR = "PASEO_PROVIDER_REFRESH_TIMEOUT_MS";
 // Provider refresh probes can be slow on cold starts (e.g. Copilot's first
 // `copilot --acp` invocation, OpenCode workspace probes with many MCP servers).
@@ -25,6 +26,12 @@ function resolveRefreshTimeoutMs(option) {
     }
     return DEFAULT_REFRESH_TIMEOUT_MS;
 }
+function resolveDiagnosticTimeoutMs(option, refreshTimeoutMs) {
+    if (typeof option === "number" && Number.isFinite(option) && option > 0) {
+        return option;
+    }
+    return Math.max(refreshTimeoutMs, DEFAULT_DIAGNOSTIC_TIMEOUT_MS);
+}
 export class ProviderSnapshotManager {
     constructor(options) {
         this.snapshots = new Map();
@@ -40,6 +47,7 @@ export class ProviderSnapshotManager {
         this.providerOverrides = options.providerOverrides;
         this.baseProviderOverrides = options.providerOverrides;
         this.refreshTimeoutMs = resolveRefreshTimeoutMs(options.refreshTimeoutMs);
+        this.diagnosticTimeoutMs = resolveDiagnosticTimeoutMs(options.diagnosticTimeoutMs, this.refreshTimeoutMs);
         this.providerRegistry = this.buildRegistry();
         this.providerClients = { ...this.extraClients };
     }
@@ -180,18 +188,23 @@ export class ProviderSnapshotManager {
         });
     }
     async getProviderDiagnostic(provider) {
-        const definition = this.requireProvider(provider);
-        const client = this.ensureClient(provider, definition);
-        // Force-refresh the snapshot so Models/Status come from the single catalog authority.
-        await this.refreshSnapshotForCwd({ cwd: homedir(), providers: [provider] });
-        const entry = await this.getProvider({ cwd: homedir(), provider, wait: true });
+        const definition = this.providerRegistry[provider];
+        if (!definition) {
+            return {
+                provider,
+                diagnostic: formatProviderDiagnostic(provider, [
+                    { label: "Error", value: `Provider ${provider} is not configured` },
+                ]),
+            };
+        }
+        const baseDiagnosticPromise = this.getBaseProviderDiagnostic(provider, definition);
+        const snapshotEntryPromise = this.refreshDiagnosticSnapshotEntry(provider, definition);
+        const [baseDiagnostic, entry] = await Promise.all([
+            baseDiagnosticPromise,
+            snapshotEntryPromise,
+        ]);
         const modelCount = entry.status === "ready" ? String(entry.models?.length ?? 0) : "—";
         const status = formatProviderStatus(entry);
-        const baseDiagnostic = client.getDiagnostic
-            ? (await client.getDiagnostic()).diagnostic
-            : formatProviderDiagnostic(definition.label ?? provider, [
-                { label: "Diagnostic", value: "No diagnostic available" },
-            ]);
         const diagnostic = `${baseDiagnostic}\n  Models: ${modelCount}\n  Status: ${status}`;
         return { provider, diagnostic };
     }
@@ -283,6 +296,38 @@ export class ProviderSnapshotManager {
         }
         return definition;
     }
+    async refreshDiagnosticSnapshotEntry(provider, definition) {
+        try {
+            const cwd = resolveSnapshotCwd();
+            await this.refreshSnapshotForCwd({ cwd, providers: [provider] });
+            return await this.getProvider({ cwd, provider, wait: false });
+        }
+        catch (error) {
+            return {
+                provider,
+                status: "error",
+                enabled: definition.enabled,
+                label: definition.label,
+                description: definition.description,
+                defaultModeId: definition.defaultModeId,
+                error: toErrorMessage(error),
+            };
+        }
+    }
+    async getBaseProviderDiagnostic(provider, definition) {
+        try {
+            const client = this.ensureClient(provider, definition);
+            if (client.getDiagnostic) {
+                return (await withTimeout(client.getDiagnostic(), this.diagnosticTimeoutMs, `Timed out collecting ${definition.label ?? provider} diagnostic after ${this.diagnosticTimeoutMs}ms`)).diagnostic;
+            }
+            return formatProviderDiagnostic(definition.label ?? provider, [
+                { label: "Diagnostic", value: "No diagnostic available" },
+            ]);
+        }
+        catch (error) {
+            return formatProviderDiagnosticError(definition.label ?? provider, error);
+        }
+    }
     createLoadingEntries() {
         const entries = new Map();
         for (const provider of this.getProviderIds()) {
@@ -454,7 +499,7 @@ export class ProviderSnapshotManager {
                 setEntry({ ...base, status: "unavailable", enabled: true });
                 return;
             }
-            const catalog = await withTimeout(definition.fetchCatalog({ cwd, force }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
+            const catalog = await withTimeout(definition.fetchCatalog({ cwd, force, timeoutMs: this.refreshTimeoutMs }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
             setEntry({
                 ...base,
                 status: "ready",

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

@@ -5,6 +5,7 @@ import { ClientSideConnection, type Client as ACPClient, type CreateTerminalRequ
 import type { Logger } from "pino";
 import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
+import { type DiagnosticEntry } from "./diagnostic-utils.js";
 export declare function summarizeACPRequestError(error: unknown): {
     message: string;
     code?: string;
@@ -62,6 +63,17 @@ export interface SpawnedACPProcess {
     child: ChildProcessWithoutNullStreams;
     connection: ClientSideConnection;
     initialize: InitializeResponse;
+    stderrChunks?: string[];
+}
+type UninitializedACPProcess = Omit<SpawnedACPProcess, "initialize"> & {
+    initialize?: InitializeResponse;
+};
+interface ACPProcessTransport {
+    child: ChildProcessWithoutNullStreams;
+    connection: ClientSideConnection;
+    stderrChunks: string[];
+    spawnReady: Promise<void>;
+    spawnError: Promise<never>;
 }
 export interface ACPToolSnapshot {
     toolCallId: string;
@@ -176,10 +188,17 @@ export declare class ACPAgentClient implements AgentClient {
     isAvailable(): Promise<boolean>;
     protected spawnProcess(launchEnv?: Record<string, string>, options?: {
         initializeTimeoutMs?: number;
+        onSpawned?: (probe: UninitializedACPProcess) => void;
     }): Promise<SpawnedACPProcess>;
+    protected spawnTransport(launchEnv?: Record<string, string>): Promise<ACPProcessTransport>;
+    protected initializeTransport(transport: ACPProcessTransport, initializeTimeoutMs?: number): Promise<InitializeResponse>;
     protected buildProbeClient(): ACPClient;
-    protected closeProbe(probe: SpawnedACPProcess): Promise<void>;
+    protected closeProbe(probe: UninitializedACPProcess): Promise<void>;
     protected runACPRequest<T>(request: () => Promise<T>): Promise<T>;
+    protected buildACPProbeDiagnosticRows(options?: {
+        cwd?: string;
+        phaseTimeoutMs?: number;
+    }): Promise<DiagnosticEntry[]>;
     protected resolveLaunchCommand(): Promise<{
         command: string;
         args: string[];

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,
@@ -369,22 +387,35 @@ export class ACPAgentClient {
     }
     async fetchCatalog(options) {
         const { cwd } = options;
-        const probe = await this.spawnProcess(PROBE_ENV);
+        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,

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

@@ -17,6 +17,7 @@ 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";
@@ -370,6 +371,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;
@@ -3472,15 +3506,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 +3527,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 +3548,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 +3989,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 +4027,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;