hoomanjs 1.46.0 → 1.55.0

package/dist/acp/acp-agent.js

@@ -9,6 +9,8 @@ import { MODE_DEFINITIONS } from "../core/modes/definitions.js";
 import { DEFAULT_SESSION_MODE, isKnownSessionMode, } from "../core/modes/schema.js";
 import { getModeState, setSessionMode } from "../core/state/session-mode.js";
 import { isYoloEnabled, setYoloEnabled } from "../core/state/yolo.js";
+import { setLlmModality } from "../core/state/llm-modality.js";
+import { dropTurnBoundariesFrom, getTurnBoundary, recordTurnBoundary, } from "../core/state/turn-boundaries.js";
 import { ChatTurnSteeringController, createChatTurnSteeringIntervention, } from "../core/agent/turn-steering.js";
 import { getAgentConversationManager, getAgentSessionManager, } from "../core/agent/index.js";
 import { readBundledPrompt } from "../core/prompts/bundled.js";
@@ -17,10 +19,10 @@ import { subscribeModelDownloadProgress, } from "../core/utils/download-progress
 import { subscribeModelRetryProgress, } from "../core/agent/retry-progress.js";
 import { toAdditiveUsage } from "../core/utils/usage.js";
 import { computeUsageCostUsd, configuredLlmContext, contextTokensFromUsage, resolveLlmMetadata, } from "../core/utils/metadata.js";
-import { buildSessionConfigOptions, currentModelName, CONFIG_ID_EFFORT, CONFIG_ID_MODE, CONFIG_ID_MODEL, MODE_VALUE_YOLO, } from "./session-config.js";
+import { buildSessionConfigOptions, currentModelName, CONFIG_ID_EFFORT, CONFIG_ID_MODE, CONFIG_ID_MODEL, CONFIG_ID_YOLO, } from "./session-config.js";
 import { activeProviderName, parseReasoningEffortArg, withReasoningEffort, } from "../core/utils/reasoning-effort.js";
 import { ACP_SLASH_COMMANDS, parseAcpSlashCommand, } from "./commands.js";
-import { ENTER_PLAN_MODE_TOOL, EXIT_PLAN_MODE_TOOL, } from "../core/state/tool-approvals.js";
+import { SWITCH_MODE_TOOL } from "../core/state/tool-approvals.js";
 import { runWithCwd } from "../core/utils/cwd-context.js";
 import { runWithAgentMemoryScope } from "../core/memory/index.js";
 import { createSessionConfig, } from "../core/session-config.js";
@@ -32,12 +34,14 @@ import { takeFileToolDisplay } from "../core/state/file-tool-display.js";
 import { getTodoViewState } from "../core/state/todos.js";
 import { UPDATE_TODOS_TOOL_NAME } from "../core/tools/todo.js";
 import { setAskUserBackend } from "../core/tools/ask-user.js";
+import { setBrowserPreviewBackend } from "../core/utils/browser.js";
 import { setTextFsBackend } from "../core/tools/filesystem.js";
-import { setTerminalBackend, } from "../core/tools/shell.js";
+import { setTerminalBackend, clearShellJobManager, getShellJobManager, } from "../core/shell/index.js";
 import { createAcpToolApprovalIntervention } from "./approvals.js";
 import { createAcpAskUserBackend } from "./questions.js";
+import { createAcpBrowserPreviewBackend } from "./browser.js";
 import { extractAcpClientUserId } from "./meta/user-id.js";
-import { extractAcpVscodeFlag } from "./meta/vscode.js";
+import { isAcpVscodeHost } from "./meta/vscode.js";
 import { deriveSessionTitleFromEcho } from "./sessions/title.js";
 import { acpPromptEchoText, acpPromptToInvokeArgs } from "./prompt-invoke.js";
 import { normalizeAcpSessionMcpServers } from "./mcp-servers.js";
@@ -338,6 +342,7 @@ export class HoomanAcpAgent {
         if (record) {
             this.#sessions.delete(params.sessionId);
             record.turnAbort?.abort();
+            await this.#teardownShellJobs(params.sessionId, record);
             await record.mcpDisconnect();
         }
         await deleteSessionEntry(this.#acpRoot, params.sessionId);
@@ -352,7 +357,7 @@ export class HoomanAcpAgent {
         const sessionId = crypto.randomUUID();
         const clientUserId = extractAcpClientUserId(params._meta) ?? null;
         const mcpServers = normalizeAcpSessionMcpServers(params.mcpServers);
-        const vscode = extractAcpVscodeFlag(params._meta);
+        const vscode = isAcpVscodeHost();
         const mode = DEFAULT_SESSION_MODE;
         const now = new Date().toISOString();
         const entry = {
@@ -369,6 +374,7 @@ export class HoomanAcpAgent {
         await writeSessionEntry(this.#acpRoot, entry);
         const record = await this.#bootstrapSession(sessionId, params.cwd, clientUserId ?? sessionId, mcpServers, mode, undefined, vscode);
         this.#sessions.set(sessionId, record);
+        this.#subscribeShellJobs(record.agent, this.#requireClient(), sessionId);
         await this.#advertiseCommands(this.#requireClient(), sessionId);
         return {
             sessionId,
@@ -402,7 +408,7 @@ export class HoomanAcpAgent {
         const mcpServers = params.mcpServers && params.mcpServers.length > 0
             ? normalizeAcpSessionMcpServers(params.mcpServers)
             : (sourceEntry.mcpServers ?? []);
-        const vscode = extractAcpVscodeFlag(params._meta) || sourceEntry.vscode === true;
+        const vscode = isAcpVscodeHost();
         const mode = resolveSessionMode(sourceEntry.sessionMode);
         const now = new Date().toISOString();
         const title = sourceEntry.title
@@ -449,6 +455,58 @@ export class HoomanAcpAgent {
             configOptions: buildSessionConfigOptions(forkConfig, mode, sourceEntry.yolo === true),
         };
     }
+    /**
+     * Turn revert (custom `_hoomanjs/rewind_session` method, not part
+     * of the ACP spec): splice `agent.messages` back to the message index
+     * bookmarked for `messageId` (see {@link recordTurnBoundary}), dropping
+     * that turn and every turn after it, then persist the trimmed history.
+     *
+     * Returns `reverted: false` instead of erroring when `messageId` has no
+     * recorded boundary — e.g. the session was reloaded since that turn ran,
+     * so its in-memory bookmark (and the client's matching file-edit
+     * baselines) no longer exist.
+     */
+    async rewindSession(params) {
+        const rec = this.#sessions.get(params.sessionId);
+        if (!rec) {
+            throw RequestError.invalidParams({ sessionId: params.sessionId });
+        }
+        if (this.#isTurnActive(rec)) {
+            throw RequestError.invalidParams({
+                sessionId: params.sessionId,
+                message: "Cannot rewind a session while a turn is still running.",
+            });
+        }
+        const boundary = getTurnBoundary(rec.agent, params.messageId);
+        if (boundary === undefined) {
+            return { reverted: false };
+        }
+        rec.agent.messages.length = boundary;
+        dropTurnBoundariesFrom(rec.agent, params.messageId);
+        await getAgentSessionManager(rec.agent)?.saveSnapshot({
+            target: rec.agent,
+            isLatest: true,
+        });
+        return { reverted: true };
+    }
+    /**
+     * Custom `_hoomanjs/stop_shell_job`: stop a background shell job by id.
+     * Routes through {@link ShellJobManager.stop}, which kills the host terminal
+     * (process group) and emits the completion notification the UI listens for.
+     */
+    async stopShellJob(params) {
+        const rec = this.#sessions.get(params.sessionId);
+        if (!rec) {
+            throw RequestError.invalidParams({ sessionId: params.sessionId });
+        }
+        const manager = getShellJobManager(rec.agent);
+        const existing = manager.get(params.jobId);
+        if (!existing) {
+            return { stopped: false };
+        }
+        await manager.stop(params.jobId);
+        return { stopped: true };
+    }
     async loadSession(params, client) {
         const { record, mode } = await this.#reactivateSession({
             sessionId: params.sessionId,
@@ -489,6 +547,7 @@ export class HoomanAcpAgent {
         if (record) {
             this.#sessions.delete(params.sessionId);
             record.turnAbort?.abort();
+            await this.#teardownShellJobs(params.sessionId, record);
             await record.mcpDisconnect();
         }
         return {};
@@ -512,7 +571,7 @@ export class HoomanAcpAgent {
         const mcpServers = params.mcpServers.length > 0
             ? normalizeAcpSessionMcpServers(params.mcpServers)
             : (existing.mcpServers ?? []);
-        const vscode = extractAcpVscodeFlag(params.meta) || existing.vscode === true;
+        const vscode = isAcpVscodeHost();
         const mode = resolveSessionMode(existing.sessionMode);
         // Bootstrapping restores the Strands snapshot (messages + appState) during
         // `agent.initialize()` — the snapshot is the conversation source of truth.
@@ -529,6 +588,7 @@ export class HoomanAcpAgent {
             await replayConversationHistory(client, params.sessionId, record.agent.messages);
         }
         this.#sessions.set(params.sessionId, record);
+        this.#subscribeShellJobs(record.agent, client, params.sessionId);
         await patchSessionEntry(this.#acpRoot, params.sessionId, {
             cwd: params.cwd,
             ...(fromRequest !== undefined ? { userId: fromRequest || null } : {}),
@@ -581,6 +641,27 @@ export class HoomanAcpAgent {
         if (!rec) {
             throw RequestError.invalidParams({ sessionId: params.sessionId });
         }
+        // Yolo is a boolean toggle (auto-approve all tool calls), so it carries a
+        // boolean value rather than a string one; handle it before the string
+        // guard below that the select-style options rely on.
+        if (params.configId === CONFIG_ID_YOLO) {
+            if (typeof params.value !== "boolean") {
+                throw RequestError.invalidParams({
+                    configId: params.configId,
+                    message: `Config option "${params.configId}" expects a boolean value`,
+                });
+            }
+            const enabled = params.value;
+            if (isYoloEnabled(rec.agent) !== enabled) {
+                setYoloEnabled(rec.agent, enabled);
+                await patchSessionEntry(this.#acpRoot, params.sessionId, {
+                    yolo: enabled,
+                });
+            }
+            return {
+                configOptions: buildSessionConfigOptions(rec.config, resolveSessionMode(getModeState(rec.agent).mode), isYoloEnabled(rec.agent)),
+            };
+        }
         if (typeof params.value !== "string") {
             throw RequestError.invalidParams({
                 configId: params.configId,
@@ -589,39 +670,16 @@ export class HoomanAcpAgent {
         }
         const value = params.value;
         if (params.configId === CONFIG_ID_MODE) {
-            if (value === MODE_VALUE_YOLO) {
-                // Yolo is agent mode with auto-approval on, not a distinct SessionMode.
-                if (this.#transitionMode(rec, "agent")) {
-                    // Keep the legacy `modes` surface in sync too (see Session Config
-                    // Options spec: "Agents SHOULD keep both in sync").
-                    await this.#syncCurrentMode(client, params.sessionId, rec);
-                }
-                if (!isYoloEnabled(rec.agent)) {
-                    setYoloEnabled(rec.agent, true);
-                    await patchSessionEntry(this.#acpRoot, params.sessionId, {
-                        yolo: true,
-                    });
-                }
+            if (!isKnownSessionMode(value)) {
+                throw RequestError.invalidParams({
+                    value,
+                    message: `Unknown mode "${value}"`,
+                });
             }
-            else {
-                if (!isKnownSessionMode(value)) {
-                    throw RequestError.invalidParams({
-                        value,
-                        message: `Unknown mode "${value}"`,
-                    });
-                }
-                if (this.#transitionMode(rec, value)) {
-                    // Keep the legacy `modes` surface in sync too (see Session Config
-                    // Options spec: "Agents SHOULD keep both in sync").
-                    await this.#syncCurrentMode(client, params.sessionId, rec);
-                }
-                // Selecting a plain mode always turns yolo back off.
-                if (isYoloEnabled(rec.agent)) {
-                    setYoloEnabled(rec.agent, false);
-                    await patchSessionEntry(this.#acpRoot, params.sessionId, {
-                        yolo: false,
-                    });
-                }
+            if (this.#transitionMode(rec, value)) {
+                // Keep the legacy `modes` surface in sync too (see Session Config
+                // Options spec: "Agents SHOULD keep both in sync").
+                await this.#syncCurrentMode(client, params.sessionId, rec);
             }
         }
         else if (params.configId === CONFIG_ID_MODEL) {
@@ -788,6 +846,7 @@ export class HoomanAcpAgent {
             const provider = await modelProviders[resolved.provider]();
             rec.agent.model = provider.create(resolved.providerOptions, resolved.llmOptions);
             rec.metadata = await resolveLlmMetadata(resolved.metadata, resolved.llmOptions.model, resolved.provider, configuredLlmContext(resolved)).catch(() => null);
+            setLlmModality(rec.agent, rec.metadata?.modality);
         }
         catch (error) {
             if (previous) {
@@ -937,11 +996,13 @@ export class HoomanAcpAgent {
         let stopReason = "end_turn";
         try {
             const echo = acpPromptEchoText(params.prompt);
+            let turnMessageId;
             if (echo.length > 0) {
+                turnMessageId = crypto.randomUUID();
                 await this.#sendUpdate(client, params.sessionId, {
                     sessionUpdate: "user_message_chunk",
                     content: { type: "text", text: echo },
-                    messageId: crypto.randomUUID(),
+                    messageId: turnMessageId,
                 });
                 await this.#maybeDeriveTitle(client, params.sessionId, echo);
             }
@@ -969,6 +1030,14 @@ export class HoomanAcpAgent {
                     },
                 ], rec.metadata)
                 : acpPromptToInvokeArgs(params.prompt, rec.metadata);
+            // The `messageId` we just generated for this turn's user_message_chunk
+            // echo (see the ACP MessageId RFD) doubles as a durable handle for
+            // Turn revert: bookmark where this turn's messages start,
+            // before `agent.stream(...)` appends them, so a later `rewindSession`
+            // can splice history back to exactly this point.
+            if (turnMessageId) {
+                recordTurnBoundary(rec.agent, turnMessageId, rec.agent.messages.length);
+            }
             const signals = [turnAbort.signal];
             if (this.#connectionSignal) {
                 signals.push(this.#connectionSignal);
@@ -1001,7 +1070,18 @@ export class HoomanAcpAgent {
                                 // live output with a JSON result blob. The structured result
                                 // still travels to the model via `rawOutput`.
                                 const terminalId = rec.terminalByToolCall.get(ev.toolUse.toolUseId);
-                                rec.terminalByToolCall.delete(ev.toolUse.toolUseId);
+                                // Keep terminalByToolCall for background jobs so live polling
+                                // can continue; only drop the mapping for foreground shells.
+                                const bgJob = extractBackgroundShellFromResult(ev.result);
+                                if (!bgJob) {
+                                    rec.terminalByToolCall.delete(ev.toolUse.toolUseId);
+                                }
+                                else if (terminalId) {
+                                    rec.shellJobs.set(bgJob.jobId, {
+                                        terminalId,
+                                        toolCallId: ev.toolUse.toolUseId,
+                                    });
+                                }
                                 const content = terminalId !== undefined
                                     ? [{ type: "terminal", terminalId }]
                                     : (diff ?? toolResultToAcpContent(ev.result));
@@ -1012,14 +1092,27 @@ export class HoomanAcpAgent {
                                     rawOutput: ev.result.toJSON(),
                                     content,
                                     ...(locations ? { locations } : {}),
+                                    ...(bgJob
+                                        ? {
+                                            _meta: {
+                                                "hoomanjs/shell_job": {
+                                                    event: "started",
+                                                    job_id: bgJob.jobId,
+                                                    description: bgJob.description,
+                                                    status: bgJob.jobStatus ?? "running",
+                                                    terminal_id: terminalId,
+                                                    tool_call_id: ev.toolUse.toolUseId,
+                                                },
+                                            },
+                                        }
+                                        : {}),
                                 });
                                 if (ev.toolUse.name === UPDATE_TODOS_TOOL_NAME &&
                                     ev.result.status === "success") {
                                     await this.#sendPlanUpdate(client, params.sessionId, rec);
                                 }
                                 if (ev.result.status === "success" &&
-                                    (ev.toolUse.name === ENTER_PLAN_MODE_TOOL ||
-                                        ev.toolUse.name === EXIT_PLAN_MODE_TOOL)) {
+                                    ev.toolUse.name === SWITCH_MODE_TOOL) {
                                     await this.#syncCurrentMode(client, params.sessionId, rec);
                                 }
                             }
@@ -1135,8 +1228,8 @@ export class HoomanAcpAgent {
         });
     }
     /**
-     * Reflect an agent-driven mode change (e.g. `enter_plan_mode` /
-     * `exit_plan_mode`) to the client via `current_mode_update` and persist it.
+     * Reflect an agent-driven mode change (`switch_mode`) to the client via
+     * `current_mode_update` and persist it.
      */
     async #syncCurrentMode(client, sessionId, rec) {
         const modeId = resolveSessionMode(getModeState(rec.agent).mode);
@@ -1379,8 +1472,10 @@ export class HoomanAcpAgent {
         this.#registerTextFsBackend(agent, client, sessionId);
         this.#registerTerminalBackend(agent, client, sessionId);
         setAskUserBackend(agent, createAcpAskUserBackend(client, sessionId));
+        setBrowserPreviewBackend(agent, createAcpBrowserPreviewBackend(client, sessionId));
         const activeLlm = config.llm;
         const metadata = await resolveLlmMetadata(activeLlm.metadata, activeLlm.llmOptions.model, activeLlm.provider, configuredLlmContext(activeLlm)).catch(() => null);
+        setLlmModality(agent, metadata?.modality);
         return {
             cwd,
             agent,
@@ -1393,6 +1488,8 @@ export class HoomanAcpAgent {
             streamingToolInputJson: new Map(),
             lastStreamToolUseId: null,
             terminalByToolCall: new Map(),
+            shellJobs: new Map(),
+            shellJobUnsub: null,
             currentAssistantMessageId: null,
             pendingModeReapply: false,
             pendingModelRebuild: false,
@@ -1447,7 +1544,134 @@ export class HoomanAcpAgent {
         }
         setTerminalBackend(agent, {
             run: (request) => this.#runClientTerminal(client, sessionId, request),
+            spawn: (request) => this.#spawnClientTerminal(client, sessionId, request),
+            readOutput: (terminalId) => this.#readClientTerminal(client, sessionId, terminalId),
+            kill: (terminalId) => this.#killClientTerminal(client, sessionId, terminalId),
+        });
+    }
+    /** Call after the SessionRecord is stored in `#sessions`. */
+    #subscribeShellJobs(agent, client, sessionId) {
+        const record = this.#sessions.get(sessionId);
+        if (!record) {
+            return;
+        }
+        record.shellJobUnsub?.();
+        const manager = getShellJobManager(agent);
+        record.shellJobUnsub = manager.on((event) => {
+            void this.#onShellJobEvent(client, sessionId, event);
+        });
+    }
+    async #onShellJobEvent(client, sessionId, event) {
+        if (event.type !== "completed" &&
+            event.type !== "stopped" &&
+            event.type !== "failed") {
+            return;
+        }
+        const job = event.job;
+        const meta = {
+            "hoomanjs/shell_job": {
+                event: event.type,
+                job_id: job.id,
+                description: job.description,
+                status: job.status,
+                ready: job.ready,
+                exit_code: job.exitCode,
+                signal: job.signal,
+                terminal_id: job.terminalId,
+                tool_call_id: job.toolUseId,
+            },
+        };
+        // Meta-only update for the jobs bar — empty text so nothing lands in the
+        // transcript. Fire-and-forget release: awaiting a nested terminal/* RPC
+        // from inside stop_shell_job deadlocks the ACP connection.
+        void this.#sendUpdate(client, sessionId, {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+                type: "text",
+                text: "",
+            },
+            _meta: meta,
+        }).catch(() => undefined);
+        const record = this.#sessions.get(sessionId);
+        const hosted = record?.shellJobs.get(job.id);
+        if (hosted) {
+            record?.shellJobs.delete(job.id);
+            void client
+                .request(methods.client.terminal.release, {
+                sessionId,
+                terminalId: hosted.terminalId,
+            })
+                .catch(() => undefined);
+        }
+    }
+    async #spawnClientTerminal(client, sessionId, request) {
+        const created = await client.request(methods.client.terminal.create, {
+            sessionId,
+            command: request.command,
+            args: request.args,
+            cwd: request.cwd,
+            ...(request.outputByteLimit !== undefined
+                ? { outputByteLimit: request.outputByteLimit }
+                : {}),
+        }, { cancellationSignal: request.cancelSignal });
+        const terminalId = created.terminalId;
+        const record = this.#sessions.get(sessionId);
+        if (request.jobId && record) {
+            record.shellJobs.set(request.jobId, {
+                terminalId,
+                toolCallId: request.toolUseId,
+            });
+        }
+        if (request.toolUseId) {
+            record?.terminalByToolCall.set(request.toolUseId, terminalId);
+            await this.#sendUpdate(client, sessionId, {
+                sessionUpdate: "tool_call_update",
+                toolCallId: request.toolUseId,
+                status: "in_progress",
+                content: [{ type: "terminal", terminalId }],
+            });
+        }
+        return { terminalId };
+    }
+    async #readClientTerminal(client, sessionId, terminalId) {
+        const output = await client.request(methods.client.terminal.output, {
+            sessionId,
+            terminalId,
         });
+        return {
+            output: output.output,
+            truncated: output.truncated,
+            exitCode: output.exitStatus?.exitCode ?? null,
+            signal: output.exitStatus?.signal ?? null,
+        };
+    }
+    async #killClientTerminal(client, sessionId, terminalId) {
+        await client
+            .request(methods.client.terminal.kill, { sessionId, terminalId })
+            .catch(() => undefined);
+    }
+    async #teardownShellJobs(sessionId, record) {
+        record.shellJobUnsub?.();
+        record.shellJobUnsub = null;
+        const client = this.#client;
+        for (const [jobId, hosted] of record.shellJobs) {
+            if (client) {
+                await client
+                    .request(methods.client.terminal.kill, {
+                    sessionId,
+                    terminalId: hosted.terminalId,
+                })
+                    .catch(() => undefined);
+                await client
+                    .request(methods.client.terminal.release, {
+                    sessionId,
+                    terminalId: hosted.terminalId,
+                })
+                    .catch(() => undefined);
+            }
+            record.shellJobs.delete(jobId);
+        }
+        await clearShellJobManager(record.agent).catch(() => undefined);
     }
     async #runClientTerminal(client, sessionId, request) {
         const created = await client.request(methods.client.terminal.create, {
@@ -1545,10 +1769,11 @@ export class HoomanAcpAgent {
         }
     }
     async #disposeAll() {
-        const records = [...this.#sessions.values()];
+        const entries = [...this.#sessions.entries()];
         this.#sessions.clear();
-        for (const record of records) {
+        for (const [sessionId, record] of entries) {
             record.turnAbort?.abort();
+            await this.#teardownShellJobs(sessionId, record);
             await record.mcpDisconnect();
         }
     }
@@ -1565,6 +1790,8 @@ export function createAcpApp(agent) {
         .onRequest(methods.agent.session.list, (ctx) => agent.listSessions(ctx.params))
         .onRequest(methods.agent.session.delete, (ctx) => agent.deleteSession(ctx.params))
         .onRequest(methods.agent.session.fork, (ctx) => agent.forkSession(ctx.params, ctx.client))
+        .onRequest("_hoomanjs/rewind_session", (params) => params, (ctx) => agent.rewindSession(ctx.params))
+        .onRequest("_hoomanjs/stop_shell_job", (params) => params, (ctx) => agent.stopShellJob(ctx.params))
         .onRequest(methods.agent.session.setMode, (ctx) => agent.setSessionMode(ctx.params, ctx.client))
         .onRequest(methods.agent.session.setConfigOption, (ctx) => agent.setSessionConfigOption(ctx.params, ctx.client))
         .onRequest(methods.agent.session.prompt, (ctx) => agent.prompt(ctx.params))
@@ -1577,4 +1804,66 @@ export async function runAcpStdio() {
     const connection = createAcpApp(new HoomanAcpAgent(identity)).connect(stream);
     await connection.closed;
 }
+/**
+ * Pull a background shell job payload out of a Strands tool result.
+ * The tool returns `{ status: "background", job_id, ... }` which the SDK wraps
+ * as a ToolResultBlock with a json content block.
+ */
+function extractBackgroundShellFromResult(result) {
+    const fromValue = (value) => {
+        if (!value || typeof value !== "object") {
+            return null;
+        }
+        const record = value;
+        if (record.status === "background" && typeof record.job_id === "string") {
+            return {
+                jobId: record.job_id,
+                description: typeof record.description === "string"
+                    ? record.description
+                    : undefined,
+                jobStatus: typeof record.job_status === "string" ? record.job_status : undefined,
+            };
+        }
+        return null;
+    };
+    if (Array.isArray(result.content)) {
+        for (const block of result.content) {
+            if (!block || typeof block !== "object") {
+                continue;
+            }
+            const json = block.json;
+            const nested = fromValue(json ?? block);
+            if (nested) {
+                return nested;
+            }
+        }
+    }
+    try {
+        const serialized = result.toJSON?.();
+        if (serialized && typeof serialized === "object") {
+            const wrapped = serialized;
+            const content = wrapped.toolResult?.content ?? wrapped.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (!block || typeof block !== "object") {
+                        continue;
+                    }
+                    const json = block.json;
+                    const nested = fromValue(json ?? block);
+                    if (nested) {
+                        return nested;
+                    }
+                }
+            }
+            const direct = fromValue(serialized);
+            if (direct) {
+                return direct;
+            }
+        }
+    }
+    catch {
+        // ignore serialization errors
+    }
+    return null;
+}
 //# sourceMappingURL=acp-agent.js.map