@getpaseo/server 0.1.99 → 0.1.101

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;
@@ -1252,23 +1286,6 @@ function readLegacyResultUsageTokens(usage) {
     const usageRecord = toObjectRecord(usage);
     return usageRecord ? readUsageTokenTotal(usageRecord) : undefined;
 }
-function readCurrentContextUsage(value) {
-    const record = toObjectRecord(value);
-    if (!record) {
-        return undefined;
-    }
-    const totalTokens = record.totalTokens;
-    if (typeof totalTokens !== "number" || !Number.isFinite(totalTokens) || totalTokens < 0) {
-        return undefined;
-    }
-    const maxTokens = record.maxTokens;
-    return {
-        totalTokens,
-        ...(typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0
-            ? { maxTokens }
-            : {}),
-    };
-}
 function isClaudeSubagentToolName(name) {
     return name === "Task" || name === "Agent";
 }
@@ -1280,6 +1297,7 @@ class ClaudeContextUsageState {
     beginTurn() {
         this.streamRequestInputTokens = undefined;
         this.streamRequestOutputTokens = undefined;
+        this.compactedContextWindowUsedTokens = undefined;
     }
     setInitialContextWindowMaxTokens(contextWindowMaxTokens) {
         this.contextWindowMaxTokens = contextWindowMaxTokens;
@@ -1291,11 +1309,6 @@ class ClaudeContextUsageState {
         }
         return this.contextWindowMaxTokens;
     }
-    recordCurrentContextUsage(usage) {
-        if (usage?.maxTokens !== undefined) {
-            this.contextWindowMaxTokens = usage.maxTokens;
-        }
-    }
     buildStreamUsageEvent(event) {
         const streamEvent = toObjectRecord(event);
         if (!streamEvent) {
@@ -1326,7 +1339,7 @@ class ClaudeContextUsageState {
         }
         return this.createUsageUpdatedEvent(usedTokens);
     }
-    buildResultUsage(message, modelUsage, currentContextUsage) {
+    buildResultUsage(message, modelUsage) {
         try {
             if (!message.usage) {
                 return undefined;
@@ -1338,7 +1351,6 @@ class ClaudeContextUsageState {
                 totalCostUsd: message.total_cost_usd,
             };
             const modelContextWindowMaxTokens = this.recordModelUsage(modelUsage ?? message.modelUsage);
-            this.recordCurrentContextUsage(currentContextUsage);
             if (this.contextWindowMaxTokens !== undefined) {
                 usage.contextWindowMaxTokens = this.contextWindowMaxTokens;
             }
@@ -1347,13 +1359,14 @@ class ClaudeContextUsageState {
             }
             const activeResultUsageTokens = readActiveUsageTokens(message.usage) ??
                 (this.completedResultTurns === 0 ? readLegacyResultUsageTokens(message.usage) : undefined);
-            const usedTokens = currentContextUsage?.totalTokens ?? this.streamUsedTokens() ?? activeResultUsageTokens;
+            const usedTokens = this.streamUsedTokens() ?? activeResultUsageTokens ?? this.compactedContextWindowUsedTokens;
             if (usedTokens !== undefined) {
                 usage.contextWindowUsedTokens = usedTokens;
             }
             return usage;
         }
         finally {
+            this.compactedContextWindowUsedTokens = undefined;
             this.completedResultTurns += 1;
         }
     }
@@ -1362,7 +1375,8 @@ class ClaudeContextUsageState {
             typeof this.streamRequestOutputTokens !== "number") {
             return undefined;
         }
-        return this.streamRequestInputTokens + this.streamRequestOutputTokens;
+        const usedTokens = this.streamRequestInputTokens + this.streamRequestOutputTokens;
+        return usedTokens > 0 ? usedTokens : undefined;
     }
     createUsageUpdatedEvent(contextWindowUsedTokens) {
         const usage = {
@@ -1377,6 +1391,23 @@ class ClaudeContextUsageState {
             usage,
         };
     }
+    buildCompactionUsageEvent(postTokens) {
+        this.streamRequestInputTokens = undefined;
+        this.streamRequestOutputTokens = undefined;
+        this.compactedContextWindowUsedTokens = postTokens;
+        const usage = {};
+        if (this.contextWindowMaxTokens !== undefined) {
+            usage.contextWindowMaxTokens = this.contextWindowMaxTokens;
+        }
+        if (postTokens !== undefined) {
+            usage.contextWindowUsedTokens = postTokens;
+        }
+        return {
+            type: "usage_updated",
+            provider: "claude",
+            usage,
+        };
+    }
 }
 class ClaudeAgentSession {
     constructor(config, options) {
@@ -2659,7 +2690,7 @@ class ClaudeAgentSession {
             if (await this.handleMissingResumedConversation(message, activeQuery)) {
                 return true;
             }
-            await this.routeSdkMessageFromPump(message, activeQuery);
+            await this.routeSdkMessageFromPump(message);
             return false;
         };
         const drainActiveQuery = async () => {
@@ -2727,7 +2758,7 @@ class ClaudeAgentSession {
             message.type === "tool_progress" ||
             (message.type === "system" && message.subtype === "task_notification"));
     }
-    async routeSdkMessageFromPump(message, activeQuery) {
+    async routeSdkMessageFromPump(message) {
         if (this.shouldSuppressStaleResult(message)) {
             return;
         }
@@ -2750,7 +2781,7 @@ class ClaudeAgentSession {
             identifiers,
             rawEvent: message,
         }, "provider.claude.parsed_event");
-        const events = await this.buildPumpedMessageEvents(message, activeQuery, identifiers.messageId, turnId);
+        const events = await this.buildPumpedMessageEvents(message, identifiers.messageId, turnId);
         if (events.length === 0) {
             return;
         }
@@ -2773,14 +2804,10 @@ class ClaudeAgentSession {
         }
         this.dispatchEvents(events);
     }
-    async buildPumpedMessageEvents(message, activeQuery, messageIdHint, turnId) {
-        const currentContextUsage = message.type === "result" && message.subtype === "success"
-            ? await this.queryCurrentContextUsage(activeQuery)
-            : undefined;
+    async buildPumpedMessageEvents(message, messageIdHint, turnId) {
         const messageEvents = this.translateMessageToEvents(message, {
             suppressAssistantText: true,
             suppressReasoning: true,
-            currentContextUsage,
         });
         const assistantTimelineEvents = this.timelineAssembler
             .consume({
@@ -2795,16 +2822,6 @@ class ClaudeAgentSession {
         }));
         return [...messageEvents, ...assistantTimelineEvents];
     }
-    async queryCurrentContextUsage(activeQuery) {
-        try {
-            const usage = await withTimeout(activeQuery.getContextUsage(), 3000, "timeout");
-            return readCurrentContextUsage(usage);
-        }
-        catch (error) {
-            this.logger.debug({ err: error }, "Claude context usage query failed");
-            return undefined;
-        }
-    }
     async handleMissingResumedConversation(message, activeQuery) {
         const staleResumeError = this.readMissingResumedConversationError(message);
         if (!staleResumeError) {
@@ -2895,9 +2912,7 @@ class ClaudeAgentSession {
                 this.appendStreamEventEvents(message, events, options);
                 break;
             case "result":
-                this.appendResultEvents(message, events, {
-                    currentContextUsage: options?.currentContextUsage,
-                });
+                this.appendResultEvents(message, events);
                 break;
             default:
                 break;
@@ -2963,6 +2978,7 @@ class ClaudeAgentSession {
                 },
                 provider: "claude",
             });
+            events.push(this.contextUsage.buildCompactionUsageEvent(compactMetadata?.postTokens));
             return;
         }
         if (message.subtype === "task_notification") {
@@ -3067,8 +3083,8 @@ class ClaudeAgentSession {
             events.push({ type: "timeline", item, provider: "claude" });
         }
     }
-    appendResultEvents(message, events, options) {
-        const usage = this.convertUsage(message, message.modelUsage, options?.currentContextUsage);
+    appendResultEvents(message, events) {
+        const usage = this.convertUsage(message, message.modelUsage);
         if (message.subtype === "success") {
             // Built-in slash commands (e.g. /voice, /usage, "Unknown command: …")
             // run client-side in the Claude CLI with no model turn — output_tokens
@@ -3212,8 +3228,8 @@ class ClaudeAgentSession {
         }
         return null;
     }
-    convertUsage(message, modelUsage, currentContextUsage) {
-        return this.contextUsage.buildResultUsage(message, modelUsage, currentContextUsage);
+    convertUsage(message, modelUsage) {
+        return this.contextUsage.buildResultUsage(message, modelUsage);
     }
     enqueueTimeline(item) {
         this.pushEvent({ type: "timeline", item, provider: "claude" });
@@ -3490,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 {
@@ -3509,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;
         }
@@ -3522,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
@@ -3899,7 +3925,9 @@ function readCompactionMetadata(source) {
         const trigger = typeof metadata.trigger === "string" ? metadata.trigger : undefined;
         const preTokensRaw = metadata.preTokens ?? metadata.pre_tokens;
         const preTokens = typeof preTokensRaw === "number" ? preTokensRaw : undefined;
-        return { trigger, preTokens };
+        const postTokensRaw = metadata.postTokens ?? metadata.post_tokens;
+        const postTokens = typeof postTokensRaw === "number" ? postTokensRaw : undefined;
+        return { trigger, preTokens, postTokens };
     }
     return null;
 }
@@ -3961,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) {
@@ -3996,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;

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

@@ -1,7 +1,6 @@
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../provider-session-import.js";
 import { randomUUID } from "node:crypto";
-import * as fsSync from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -18,7 +17,7 @@ import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mappe
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
 import { CodexAppServerClient, parseCodexThreadForkResponse, parseCodexThreadRollbackResponse, } from "./codex/app-server-transport.js";
 import { revertCodexConversation } from "./codex/rewind.js";
-import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
+import { materializeProviderImage, renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
 import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, resolveBinaryVersion, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
@@ -38,7 +37,6 @@ function isCodexAlreadyUnarchivedError(error, threadId) {
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
 const CODEX_PROVIDER = "codex";
-const CODEX_IMAGE_ATTACHMENT_DIR = "paseo-attachments";
 // Codex treats most app-server client names as the model-request originator.
 // This reserved Codex name is non-originating, so requests keep Codex's default
 // CLI identity instead of showing up as Paseo in provider usage logs.
@@ -1220,21 +1218,6 @@ function codexImageOutputFromResult(result) {
         mimeType: firstStringField(resultRecord, ["mimeType", "mime_type"]),
     };
 }
-function writeImageAttachmentSync(mimeType, data) {
-    const attachmentsDir = path.join(os.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
-    fsSync.mkdirSync(attachmentsDir, { recursive: true });
-    const normalized = normalizeImageData(mimeType, data);
-    const extension = getImageExtension(normalized.mimeType);
-    const filename = `${randomUUID()}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    fsSync.writeFileSync(filePath, Buffer.from(normalized.data, "base64"));
-    return filePath;
-}
-function materializeCodexImageOutput(image) {
-    return {
-        path: writeImageAttachmentSync(image.mimeType ?? "image/png", image.data),
-    };
-}
 function mapCodexThreadImageItem(normalizedType, normalizedItem) {
     if (normalizedType === "imageView") {
         return renderProviderImageOutputAsAssistantMarkdown({
@@ -1248,7 +1231,7 @@ function mapCodexThreadImageItem(normalizedType, normalizedItem) {
         url: result?.url ?? null,
         data: result?.data ?? null,
         mimeType: result?.mimeType ?? null,
-    }, { materialize: materializeCodexImageOutput });
+    }, { materialize: materializeProviderImage });
 }
 export function threadItemToTimeline(item, options) {
     const itemRecord = toObjectRecord(item);
@@ -1357,33 +1340,6 @@ function toSandboxPolicy(type, networkAccess) {
             return { type: "workspaceWrite", networkAccess: networkAccess ?? false };
     }
 }
-function getImageExtension(mimeType) {
-    switch (mimeType) {
-        case "image/jpeg":
-            return "jpg";
-        case "image/png":
-            return "png";
-        case "image/webp":
-            return "webp";
-        case "image/gif":
-            return "gif";
-        case "image/bmp":
-            return "bmp";
-        case "image/tiff":
-            return "tiff";
-        default:
-            return "bin";
-    }
-}
-function normalizeImageData(mimeType, data) {
-    if (data.startsWith("data:")) {
-        const match = data.match(/^data:([^;]+);base64,(.*)$/);
-        if (match) {
-            return { mimeType: match[1], data: match[2] };
-        }
-    }
-    return { mimeType, data };
-}
 const ThreadStartedNotificationSchema = z
     .object({
     thread: z.object({ id: z.string() }).passthrough(),
@@ -2008,16 +1964,6 @@ const CodexNotificationSchema = z.union([
         .object({ method: z.string(), params: z.unknown() })
         .transform(({ method, params }) => ({ kind: "unknown_method", method, params })),
 ]);
-async function writeImageAttachment(mimeType, data) {
-    const attachmentsDir = path.join(os.tmpdir(), CODEX_IMAGE_ATTACHMENT_DIR);
-    await fs.mkdir(attachmentsDir, { recursive: true });
-    const normalized = normalizeImageData(mimeType, data);
-    const extension = getImageExtension(normalized.mimeType);
-    const filename = `${randomUUID()}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    await fs.writeFile(filePath, Buffer.from(normalized.data, "base64"));
-    return filePath;
-}
 async function readCodexConfiguredDefaults(client, logger) {
     let savedConfigDefaults = {};
     try {
@@ -2071,7 +2017,10 @@ export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
         }
         if (block.type === "image") {
             try {
-                const filePath = await writeImageAttachment(block.mimeType, block.data);
+                const filePath = materializeProviderImage({
+                    data: block.data,
+                    mimeType: block.mimeType,
+                }).path;
                 output.push({ type: "localImage", path: filePath });
             }
             catch (error) {

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

@@ -2,8 +2,9 @@ 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 { ACPAgentClient, type ACPBeforeModeWriteResult, type ACPProviderModeWriteResult, type ACPProviderModeWriterContext, type SessionStateResponse } from "./acp-agent.js";
+import { ACPAgentClient, type ACPConfigFeatureOption, 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_AGENT_FEATURE_OPTION: ACPConfigFeatureOption;
 export declare const COPILOT_MODES: AgentMode[];
 interface CopilotACPAgentClientOptions {
     logger: Logger;

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

@@ -20,6 +20,15 @@ export const COPILOT_ALLOW_ALL_MODE_ID = "allow-all";
 const COPILOT_ALLOW_ALL_CONFIG_ID = "allow_all";
 const COPILOT_ALLOW_ALL_ON = "on";
 const COPILOT_ALLOW_ALL_OFF = "off";
+export const COPILOT_AGENT_FEATURE_OPTION = {
+    id: "agent",
+    configId: "agent",
+    category: "_agent",
+    label: "Agent",
+    description: "Use a Copilot custom agent profile",
+    tooltip: "Select Copilot agent",
+    emptyOptionLabel: "Default",
+};
 export const COPILOT_MODES = [
     {
         id: COPILOT_AGENT_MODE_ID,
@@ -47,6 +56,7 @@ export class CopilotACPAgentClient extends ACPAgentClient {
             defaultModes: COPILOT_MODES,
             sessionResponseTransformer: transformCopilotSessionResponse,
             configOptionsTransformer: transformCopilotConfigOptions,
+            configFeatureOptions: [COPILOT_AGENT_FEATURE_OPTION],
             modeIdTransformer: transformCopilotModeId,
             providerModeWriter: writeCopilotProviderMode,
             beforeModeWriter: beforeCopilotModeWriter,

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

@@ -10,6 +10,7 @@ export declare function formatDiagnosticStatus(available: boolean, error?: {
     source: string;
     cause: unknown;
 }): string;
+export declare function truncateForDiagnostic(value: string): string;
 export declare function toDiagnosticErrorMessage(error: unknown): string;
 export declare function resolveBinaryVersion(binaryPath: string): Promise<string>;
 export interface BinaryDiagnosticVersionCommand {

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

@@ -24,7 +24,7 @@ export function formatDiagnosticStatus(available, error) {
     return formatAvailabilityStatus(available);
 }
 const DIAGNOSTIC_OUTPUT_CAP = 4096;
-function truncateForDiagnostic(value) {
+export function truncateForDiagnostic(value) {
     const trimmed = value.trim();
     if (trimmed.length <= DIAGNOSTIC_OUTPUT_CAP) {
         return trimmed;

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

@@ -13,11 +13,13 @@ interface GenericACPAgentClientOptions {
     providerParams?: unknown;
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
+    diagnosticPhaseTimeoutMs?: number;
 }
 export declare class GenericACPAgentClient extends ACPAgentClient {
     private readonly command;
     private readonly providerId?;
     private readonly label?;
+    private readonly diagnosticPhaseTimeoutMs?;
     constructor(options: GenericACPAgentClientOptions);
     protected resolveLaunchCommand(): Promise<{
         command: string;
@@ -28,6 +30,7 @@ export declare class GenericACPAgentClient extends ACPAgentClient {
         diagnostic: string;
     }>;
     private resolveConfiguredLaunch;
+    private getACPProbeRowsForDiagnostic;
 }
 export interface CommandInvocation {
     command: string;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
 import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES } from "./acp-agent.js";
-import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, } from "./diagnostic-utils.js";
+import { buildBinaryDiagnosticRows, formatProviderDiagnostic, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 export const GenericACPProviderParamsSchema = z
     .object({
     supportsMcpServers: z.boolean().optional(),
@@ -23,6 +23,7 @@ export class GenericACPAgentClient extends ACPAgentClient {
         this.command = options.command;
         this.providerId = options.providerId;
         this.label = options.label;
+        this.diagnosticPhaseTimeoutMs = options.diagnosticPhaseTimeoutMs;
     }
     async resolveLaunchCommand() {
         return {
@@ -37,34 +38,36 @@ export class GenericACPAgentClient extends ACPAgentClient {
     }
     async getDiagnostic() {
         const providerName = formatProviderName(this.label, this.providerId);
+        const entries = [
+            { label: "Provider ID", value: this.providerId ?? "unknown" },
+            { label: "Configured command", value: this.command.join(" ") },
+        ];
+        const versionProbe = buildVersionProbeCommand(this.command);
         try {
             const launch = await this.resolveConfiguredLaunch();
             const availability = await checkProviderLaunchAvailable(launch);
-            const versionProbe = buildVersionProbeCommand(this.command);
-            return {
-                diagnostic: formatProviderDiagnostic(providerName, [
-                    { label: "Provider ID", value: this.providerId ?? "unknown" },
-                    { label: "Configured command", value: this.command.join(" ") },
-                    ...(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),
-                    },
-                ]),
-            };
+            entries.push(...(await buildBinaryDiagnosticRows(launch, availability, {
+                binaryLabel: "Launcher binary",
+                versionCommand: {
+                    command: versionProbe.command,
+                    args: versionProbe.args,
+                    env: this.runtimeSettings?.env,
+                },
+            })));
         }
         catch (error) {
-            return {
-                diagnostic: formatProviderDiagnosticError(providerName, error),
-            };
+            entries.push({
+                label: "Launcher binary",
+                value: `error: ${toDiagnosticErrorMessage(error)}`,
+            });
         }
+        entries.push({
+            label: "Version command",
+            value: formatCommand(versionProbe.command, versionProbe.args),
+        }, ...(await this.getACPProbeRowsForDiagnostic()));
+        return {
+            diagnostic: formatProviderDiagnostic(providerName, entries),
+        };
     }
     async resolveConfiguredLaunch() {
         return resolveProviderLaunch({
@@ -72,6 +75,21 @@ export class GenericACPAgentClient extends ACPAgentClient {
             defaultBinary: this.command[0],
         });
     }
+    async getACPProbeRowsForDiagnostic() {
+        try {
+            return await this.buildACPProbeDiagnosticRows({
+                phaseTimeoutMs: this.diagnosticPhaseTimeoutMs,
+            });
+        }
+        catch (error) {
+            return [
+                {
+                    label: "ACP probe",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                },
+            ];
+        }
+    }
 }
 function buildGenericACPCapabilities(options) {
     const params = parseGenericACPProviderParams(options.providerParams);

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

@@ -167,7 +167,7 @@ function parseAgentStreamStressPrompt(prompt) {
 }
 function parseStructuredBranchNamePrompt(prompt) {
     const text = promptToText(prompt);
-    const hasBranchNamePrompt = text.includes("Generate a git branch name for a coding agent") &&
+    const hasBranchNamePrompt = text.includes("Generate a title and a git branch name for a coding agent") &&
         (text.includes("Return JSON only with fields 'title' and 'branch'.") ||
             text.includes('"title"') ||
             text.includes('"branch"'));
@@ -177,7 +177,9 @@ function parseStructuredBranchNamePrompt(prompt) {
             text.includes('"branch"'))) {
         return null;
     }
-    const seed = text.split("User context:\n").at(-1)?.trim() ?? "";
+    const seed = text.match(/<user-prompt>\n([\s\S]*?)\n<\/user-prompt>/)?.[1]?.trim() ??
+        text.match(/<attachments>\n([\s\S]*?)\n<\/attachments>/)?.[1]?.trim() ??
+        "";
     const firstLine = seed
         .split("\n")
         .find((line) => line.trim().length > 0)