@cargo-ai/cli 1.0.94 → 1.0.96

package/build/commands/ask/harness/turn.js

@@ -0,0 +1,676 @@
+import { DENIED_TOOL_REASON, isAlwaysDenied, isAutoApproved, } from "./approvals.js";
+import { ASK_USER_QUESTION_DENIED_REASON, ASK_USER_QUESTION_TOOL_NAME, formatAskUserQuestionAnswers, summarizeAskUserQuestion, } from "./askUserQuestion.js";
+import { addTurnUsage, createTurnAccumulator, } from "./usage.js";
+/**
+ * How many times one turn may suspend for approvals. Each round trip is a
+ * decision the user made, so this is only a stop for a harness that keeps
+ * re-asking for a tool it was already refused.
+ */
+const MAX_APPROVAL_ROUNDS = 64;
+/**
+ * How long a turn may produce nothing at all while no tool is running.
+ *
+ * Generous on purpose: this is a deadlock detector, not a latency budget. The
+ * clock only runs when nothing is in flight, so the wait is over a turn that
+ * is neither working nor talking.
+ *
+ * `CARGO_ASK_STALL_TIMEOUT_MS` shortens it for the end-to-end tests, which
+ * would otherwise have to sit out the real deadline to prove a hang is caught.
+ */
+const TURN_STALL_TIMEOUT_MS = readTimeoutEnv("CARGO_ASK_STALL_TIMEOUT_MS", 120_000);
+/**
+ * The same deadline, for a turn that has a tool executing.
+ *
+ * A tool at work is silent by design — a test run says nothing for as long as
+ * it takes — so this cannot be the deadline above. But it cannot be *no*
+ * deadline either, which is what it used to be: a tool the user approved and
+ * that never reported back left the turn waiting forever, spinner and all,
+ * with nothing to do but kill the terminal. That is the shape of every "it got
+ * stuck on the tool" report.
+ *
+ * Twelve minutes, from Claude Code's own ten-minute ceiling on a Bash tool.
+ * That is the bound for the common case, not for every case: the ceiling is
+ * configurable, and it does not apply to an MCP tool at all. A `mcp__cargo__*`
+ * call that genuinely runs longer than this is cut off with its work lost, so
+ * `CARGO_ASK_TOOL_STALL_TIMEOUT_MS` raises it for a workspace that does that
+ * routinely. The trade is deliberate: a deadline that covers every conceivable
+ * tool is indistinguishable from the hang it replaced.
+ *
+ * Recoverable either way — the session is replaced and the chat, its history
+ * and the working copy all survive.
+ */
+const TURN_TOOL_STALL_TIMEOUT_MS = readTimeoutEnv("CARGO_ASK_TOOL_STALL_TIMEOUT_MS", 12 * 60_000);
+function readTimeoutEnv(name, fallbackMs) {
+    const raw = process.env[name];
+    if (raw === undefined) {
+        return fallbackMs;
+    }
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallbackMs;
+}
+/**
+ * Run one turn to completion, answering approval requests along the way.
+ *
+ * A turn suspends whenever Claude Code wants a tool `permissionMode` does not
+ * cover: the stream ends with the approvals still pending, and the turn only
+ * finishes once decisions are fed back in. Exported for tests.
+ */
+export async function runPromptTurn(input) {
+    const handlers = input.handlers === undefined ? {} : input.handlers;
+    const onApproval = handlers.onApproval;
+    const accumulator = input.accumulator === undefined
+        ? createTurnAccumulator()
+        : input.accumulator;
+    const stallTimeoutMs = input.stallTimeoutMs === undefined
+        ? TURN_STALL_TIMEOUT_MS
+        : input.stallTimeoutMs;
+    const toolStallTimeoutMs = input.toolStallTimeoutMs === undefined
+        ? TURN_TOOL_STALL_TIMEOUT_MS
+        : input.toolStallTimeoutMs;
+    const assistantChunks = accumulator.chunks;
+    const toolCalls = new Map();
+    const turnState = {
+        toolRanSinceText: false,
+        announced: [],
+    };
+    let stream = await input.driver.start();
+    let round = 0;
+    for (;;) {
+        const approvals = await consumeTurn({
+            stream,
+            handlers,
+            assistantChunks,
+            toolCalls,
+            usage: accumulator.usage,
+            turnState,
+            stallTimeoutMs,
+            toolStallTimeoutMs,
+            onStall: input.onStall,
+        });
+        if (approvals.length === 0) {
+            break;
+        }
+        if (input.unanswered !== undefined) {
+            input.unanswered.push(...approvals);
+        }
+        round += 1;
+        if (round > MAX_APPROVAL_ROUNDS) {
+            throw new Error(`Local Claude Code asked for tool approval ${String(MAX_APPROVAL_ROUNDS)} times in one turn without finishing. Stopping the turn.`);
+        }
+        const continuations = [];
+        for (const approval of approvals) {
+            // Refused before the user is asked: not their call to make, and a
+            // prompt for it could not say what it was granting.
+            const denied = isAlwaysDenied(approval.toolName);
+            const question = approval.toolName === ASK_USER_QUESTION_TOOL_NAME
+                ? await settleAskUserQuestion(approval.input, handlers.onUserQuestion)
+                : undefined;
+            const approved = question !== undefined
+                ? false
+                : denied === true
+                    ? false
+                    : isAutoApproved(approval.toolName, {
+                        unattended: onApproval === undefined,
+                    }) === true
+                        ? true
+                        : onApproval === undefined
+                            ? false
+                            : await onApproval(approval);
+            // Recorded against the call so the retraction pass below knows it is
+            // settled: an approved one is running and must be left alone, a refused
+            // one is certainly not and needs no reprieve to find out. Absent when
+            // its result already arrived, which takes it off the list.
+            const announced = turnState.announced.find((call) => call.toolCallId === approval.toolCallId);
+            if (announced !== undefined) {
+                announced.status = approved === true ? "approved" : "refused";
+            }
+            // Answered, so the drain on a later turn must not deny it again.
+            if (input.unanswered !== undefined) {
+                const at = input.unanswered.indexOf(approval);
+                if (at !== -1) {
+                    input.unanswered.splice(at, 1);
+                }
+            }
+            continuations.push({
+                approvalResponse: {
+                    type: "tool-approval-response",
+                    approvalId: approval.approvalId,
+                    approved,
+                    // Told why, so it does something else rather than asking again
+                    // until the approval-round cap ends the turn.
+                    reason: question !== undefined
+                        ? question.reason
+                        : denied === true
+                            ? DENIED_TOOL_REASON
+                            : undefined,
+                },
+                toolCall: {
+                    type: "tool-call",
+                    toolCallId: approval.toolCallId,
+                    toolName: approval.toolName,
+                    input: approval.input,
+                },
+            });
+        }
+        retractAbandonedCalls(turnState.announced, handlers.onActivity);
+        stream = await input.driver.continueWithApprovals(continuations);
+    }
+    const streamed = assistantChunks.join("");
+    if (streamed.length > 0) {
+        return streamed;
+    }
+    const fallback = await stream.text;
+    if (typeof fallback !== "string" || fallback.length === 0) {
+        return "";
+    }
+    if (handlers.onTextDelta !== undefined) {
+        handlers.onTextDelta(fallback);
+    }
+    return fallback;
+}
+/**
+ * Retract the calls the caller was told about and will never hear the end of,
+ * at the boundary where the answers to this round's approvals are known.
+ *
+ * Left on screen instead, an abandoned call outlives the work: no result is
+ * coming, so no `end` event is either, and the caller keeps showing a tool
+ * that stopped existing.
+ *
+ * `"approved"` is kept, and `"running"` is the one case that cannot be judged
+ * yet — the reason this is not a plain sweep. It is either the sibling whose
+ * approval request the harness lost (it surfaces one per stream) or a tool
+ * Claude Code ran without asking, whose result has simply not arrived. Both
+ * look identical here, so it gets one more stream to prove itself: a live one
+ * reports its result and leaves this list on its own.
+ *
+ * Everything else is certain and retracted — `"streaming"` never finished
+ * arriving, `"refused"` was told no, and `"abandoning"` already had its
+ * stream and stayed silent. Refusals matter especially: a tool
+ * `isAlwaysDenied` refuses never reaches `onApproval`, so this is the caller's
+ * only notice.
+ *
+ * The reprieve is for the caller's benefit only — `"abandoning"` is not an
+ * executing status, so the stall watchdog keeps its short deadline throughout
+ * it. Extending the reprieve to the watchdog would deadlock the very hang it
+ * exists to prevent: a dropped sibling would hold the timer off, the stream
+ * would stay silent, and the next boundary, the thing that resolves the
+ * ambiguity, would never arrive.
+ */
+function retractAbandonedCalls(announced, onActivity) {
+    for (const call of [...announced]) {
+        if (call.status === "approved") {
+            continue;
+        }
+        if (call.status === "running") {
+            call.status = "abandoning";
+            continue;
+        }
+        announced.splice(announced.indexOf(call), 1);
+        if (onActivity !== undefined) {
+            onActivity({
+                kind: "dropped",
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+            });
+        }
+    }
+}
+/**
+ * The previous turn could not be wound down, so this session cannot take
+ * another prompt. Raised rather than pressed on with: the harness would either
+ * refuse the prompt itself or run it alongside the turn we failed to finish.
+ *
+ * The caller's recovery is to replace the session — nothing about a wedged
+ * runtime gets better by asking it again.
+ */
+export class HarnessTurnStuck extends Error {
+    constructor() {
+        super("The previous turn could not be wound down, so this coding session cannot take another question.");
+        this.name = "HarnessTurnStuck";
+    }
+}
+/**
+ * The turn produced nothing for `TURN_STALL_TIMEOUT_MS` while no tool was in
+ * flight. Common causes: a step that asked to run several confirmable tools at
+ * once (the harness only surfaces one approval), or the Claude Code bridge
+ * going silent. Recoverable — replace the session and ask again.
+ */
+export class HarnessTurnStalled extends Error {
+    constructor(timeoutMs, whileToolRunning = false) {
+        const seconds = String(Math.round(timeoutMs / 1000));
+        super(whileToolRunning === true
+            ? `A tool has been running for ${seconds}s without reporting anything back, which is longer than Claude Code lets any tool run. Treating it as never coming back rather than waiting on it.`
+            : `Local Claude Code went quiet for ${seconds}s with no tool running. Often this is a step that asked to run several confirmable tools at once (only the first can be answered), or the coding session itself stalled.`);
+        this.name = "HarnessTurnStalled";
+    }
+}
+/**
+ * The Claude Code bridge dropped mid-turn. Same recovery as a stall: the
+ * process behind the session is gone, so the next question needs a new one.
+ */
+export function isBridgeClosedError(error) {
+    return (error instanceof Error &&
+        error.message.includes("bridge closed before the turn finished") === true);
+}
+/**
+ * Fail a turn that has gone silent with no tool running, instead of hanging.
+ *
+ * `@ai-sdk/harness` surfaces one approval per stream and ends the stream
+ * there, so a step that asks to run two tools at once loses the second
+ * request: Claude Code keeps waiting for a decision that is never offered,
+ * while we keep waiting for output that never comes. Both sides wait forever.
+ * `LOCAL_WORKING_COPY_INSTRUCTIONS` asks for one confirmable tool per step to
+ * avoid it; this is the backstop for when the model does it anyway.
+ *
+ * Two deadlines rather than one, because a tool at work is silent by design
+ * and a ten-minute test run must not be cut off: `timeoutMs` for a stream with
+ * nothing executing, and the far longer `toolTimeoutMs` while a tool is. What
+ * there is never again is *no* deadline — a tool that never reports back used
+ * to leave the turn on the spinner forever.
+ */
+async function* withStallTimeout(stream, timeoutMs, toolTimeoutMs, isToolInFlight, onStall) {
+    if (Number.isFinite(timeoutMs) === false &&
+        Number.isFinite(toolTimeoutMs) === false) {
+        for await (const part of stream) {
+            yield part;
+        }
+        return;
+    }
+    const iterator = stream[Symbol.asyncIterator]();
+    for (;;) {
+        const next = iterator.next();
+        const running = isToolInFlight();
+        const budgetMs = running === true ? toolTimeoutMs : timeoutMs;
+        const result = await (Number.isFinite(budgetMs) === false
+            ? next
+            : rejectIfIdle(next, budgetMs, onStall, running));
+        if (result.done === true) {
+            return;
+        }
+        yield result.value;
+    }
+}
+/**
+ * Wait for `work`, but give up after `timeoutMs` rather than blocking a
+ * teardown forever. Resolves either way; the caller has already decided that
+ * an unfinished result is better than waiting.
+ *
+ * Exported for tests.
+ */
+export async function settleWithin(work, timeoutMs) {
+    let timer;
+    try {
+        await Promise.race([
+            work,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+}
+async function rejectIfIdle(next, timeoutMs, onStall, whileToolRunning) {
+    let timer;
+    try {
+        return await Promise.race([
+            next,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    // Reject first so Promise.race settles on HarnessTurnStalled, not
+                    // on an AbortError the interrupt below may race onto `next`.
+                    reject(new HarnessTurnStalled(timeoutMs, whileToolRunning));
+                    // Then stop the bridge so teardown is an intentional abort, not a
+                    // mysterious "bridge closed before the turn finished" after we
+                    // have already walked away from the stream.
+                    if (onStall !== undefined) {
+                        onStall();
+                    }
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        // On a stall we walk away from `next`; a later failure has no other
+        // handler and would come back as an unhandled rejection.
+        next.catch(() => undefined);
+    }
+}
+/** Tool inputs that name a file the turn is about to change. */
+const FILE_WRITING_TOOLS = new Set([
+    "write",
+    "edit",
+    "Write",
+    "Edit",
+    "NotebookEdit",
+]);
+/**
+ * Drain one turn: text deltas go to the caller, tool calls are remembered so
+ * an approval request can be matched back to its call, and pending approvals
+ * are returned so the caller can decide and continue the turn.
+ */
+async function consumeTurn(input) {
+    const approvals = [];
+    const { handlers } = input;
+    const pendingFiles = new Map();
+    const parts = withStallTimeout(input.stream.fullStream, input.stallTimeoutMs, input.toolStallTimeoutMs, () => input.turnState.announced.some((call) => call.status === "running" || call.status === "approved"), input.onStall);
+    for await (const rawPart of parts) {
+        if (typeof rawPart !== "object" || rawPart === null) {
+            continue;
+        }
+        const part = rawPart;
+        if (part["type"] === "error") {
+            const error = part["error"];
+            throw new Error(error instanceof Error
+                ? error.message
+                : typeof error === "string"
+                    ? error
+                    : "Local Claude Code turn failed.");
+        }
+        // Claude Code streams the tool name before the full call is assembled.
+        // Surface that early so the spinner is not stuck on "Asking…" while the
+        // input is still arriving — and so a later `tool-call` can fill in the
+        // summary without looking like a second tool.
+        if (part["type"] === "tool-input-start") {
+            const toolCallId = part["id"];
+            const toolName = part["toolName"];
+            if (typeof toolCallId === "string" && typeof toolName === "string") {
+                if (input.toolCalls.has(toolCallId) === false) {
+                    input.toolCalls.set(toolCallId, {
+                        toolName,
+                        input: undefined,
+                    });
+                    input.turnState.toolRanSinceText = true;
+                    // Announced, because the spinner is about to show this name and is
+                    // owed a retraction if the call never happens — but `"streaming"`,
+                    // not executing. The tool is not running yet, its input is still
+                    // being generated, and the deltas that carry it are output the
+                    // watchdog is entitled to expect; standing it down here would turn a
+                    // bridge that dies mid-input into a hang.
+                    input.turnState.announced.push({
+                        toolCallId,
+                        toolName,
+                        status: "streaming",
+                    });
+                    if (handlers.onActivity !== undefined) {
+                        handlers.onActivity({
+                            kind: "start",
+                            toolCallId,
+                            toolName,
+                            summary: "",
+                        });
+                    }
+                }
+            }
+            continue;
+        }
+        if (isToolCallPart(part) === true) {
+            const toolCallId = part["toolCallId"];
+            const toolName = part["toolName"];
+            if (typeof toolCallId === "string" && typeof toolName === "string") {
+                input.toolCalls.set(toolCallId, {
+                    toolName,
+                    input: part["input"],
+                });
+                input.turnState.toolRanSinceText = true;
+                // The full call is assembled, so something is executing it — that is
+                // what stands the stall watchdog down, and it deliberately waits until
+                // here rather than firing at `tool-input-start`.
+                const announced = input.turnState.announced.find((call) => call.toolCallId === toolCallId);
+                if (announced === undefined) {
+                    input.turnState.announced.push({
+                        toolCallId,
+                        toolName,
+                        status: "running",
+                    });
+                }
+                else {
+                    announced.status = "running";
+                }
+                // Re-emitted when `tool-input-start` already announced the name, so
+                // the spinner can pick up the input summary once it is known.
+                if (handlers.onActivity !== undefined) {
+                    handlers.onActivity({
+                        kind: "start",
+                        toolCallId,
+                        toolName,
+                        summary: summarizeToolInput(part["input"]),
+                    });
+                }
+                const touched = FILE_WRITING_TOOLS.has(toolName) === true
+                    ? readFilePath(part["input"])
+                    : undefined;
+                // Held until the result says the write happened: a denied or failed
+                // edit must not show up under "files changed".
+                if (touched !== undefined) {
+                    pendingFiles.set(toolCallId, touched);
+                }
+            }
+            continue;
+        }
+        if (isToolEndPart(part) === true) {
+            const toolCallId = part["toolCallId"];
+            const recorded = typeof toolCallId === "string"
+                ? input.toolCalls.get(toolCallId)
+                : undefined;
+            const isError = isToolErrorPart(part);
+            // A preliminary result is progress from a tool that is still running,
+            // so it must not clear the spinner or tell the stall watchdog the tool
+            // is done.
+            const preliminary = part["preliminary"] === true;
+            if (preliminary === false &&
+                typeof toolCallId === "string" &&
+                handlers.onActivity !== undefined) {
+                handlers.onActivity({
+                    kind: "end",
+                    toolCallId,
+                    toolName: recorded === undefined ? "tool" : recorded.toolName,
+                    isError,
+                });
+            }
+            if (typeof toolCallId === "string" && preliminary === false) {
+                // Off the list on the way out. The `end` above is the caller's
+                // retraction, so a later approval round must not announce a second
+                // one — and leaving under its own steam is how a tool that ran unasked
+                // proves it was alive rather than abandoned.
+                const at = input.turnState.announced.findIndex((call) => call.toolCallId === toolCallId);
+                if (at !== -1) {
+                    input.turnState.announced.splice(at, 1);
+                }
+                const touched = pendingFiles.get(toolCallId);
+                pendingFiles.delete(toolCallId);
+                if (touched !== undefined &&
+                    isError === false &&
+                    handlers.onFileTouched !== undefined) {
+                    handlers.onFileTouched(touched);
+                }
+            }
+            continue;
+        }
+        if (part["type"] === "finish") {
+            // One suspended turn is several streams, each ending with its own
+            // `finish` and its own totals — sum them. Per-step parts are ignored
+            // so the same tokens are not counted twice.
+            addTurnUsage(input.usage, part);
+            continue;
+        }
+        if (part["type"] === "tool-approval-request") {
+            const approval = readApprovalRequest(part, input.toolCalls);
+            if (approval !== undefined) {
+                approvals.push(approval);
+            }
+            continue;
+        }
+        if (part["type"] === "text-delta") {
+            const text = typeof part["text"] === "string"
+                ? part["text"]
+                : typeof part["delta"] === "string"
+                    ? part["delta"]
+                    : undefined;
+            if (text === undefined || text.length === 0) {
+                continue;
+            }
+            // Claude Code narrates, runs tools, then narrates again. Without a
+            // break the two sides of a tool call run into one another mid-sentence.
+            const previous = input.assistantChunks.join("");
+            if (input.turnState.toolRanSinceText === true &&
+                previous.length > 0 &&
+                previous.endsWith("\n") === false) {
+                input.assistantChunks.push("\n\n");
+                if (handlers.onTextDelta !== undefined) {
+                    handlers.onTextDelta("\n\n");
+                }
+            }
+            input.turnState.toolRanSinceText = false;
+            input.assistantChunks.push(text);
+            if (handlers.onTextDelta !== undefined) {
+                handlers.onTextDelta(text);
+            }
+        }
+    }
+    return approvals;
+}
+/**
+ * The AI SDK part nests the whole `toolCall`; the harness bridge part carries
+ * only `toolCallId`. Accept both and fall back to the recorded call.
+ */
+function readApprovalRequest(part, toolCalls) {
+    const approvalId = part["approvalId"];
+    if (typeof approvalId !== "string") {
+        return undefined;
+    }
+    const nested = part["toolCall"];
+    const toolCall = typeof nested === "object" && nested !== null
+        ? nested
+        : undefined;
+    const toolCallId = toolCall !== undefined && typeof toolCall["toolCallId"] === "string"
+        ? toolCall["toolCallId"]
+        : typeof part["toolCallId"] === "string"
+            ? part["toolCallId"]
+            : undefined;
+    if (toolCallId === undefined) {
+        return undefined;
+    }
+    const recorded = toolCalls.get(toolCallId);
+    const toolName = toolCall !== undefined && typeof toolCall["toolName"] === "string"
+        ? toolCall["toolName"]
+        : recorded !== undefined
+            ? recorded.toolName
+            : "tool";
+    const toolInput = toolCall !== undefined && "input" in toolCall
+        ? toolCall["input"]
+        : recorded !== undefined
+            ? recorded.input
+            : undefined;
+    return {
+        approvalId,
+        toolCallId,
+        toolName,
+        summary: summarizeToolInput(toolInput),
+        input: toolInput,
+    };
+}
+/** Fields worth showing first when asking to run a tool. */
+const TOOL_INPUT_PREVIEW_KEYS = [
+    "command",
+    "file_path",
+    "path",
+    "pattern",
+    "url",
+];
+const TOOL_SUMMARY_MAX_LENGTH = 160;
+/**
+ * The bridge sends tool input as a JSON string, while the AI SDK part carries
+ * the parsed object. Normalize to a record when the shape allows it.
+ */
+function readToolInputRecord(toolInput) {
+    if (typeof toolInput === "string") {
+        try {
+            const parsed = JSON.parse(toolInput);
+            return typeof parsed === "object" && parsed !== null
+                ? parsed
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return typeof toolInput === "object" && toolInput !== null
+        ? toolInput
+        : undefined;
+}
+function readFilePath(toolInput) {
+    const record = readToolInputRecord(toolInput);
+    if (record === undefined) {
+        return undefined;
+    }
+    const filePath = record["file_path"];
+    return typeof filePath === "string" && filePath.length > 0
+        ? filePath
+        : undefined;
+}
+function summarizeToolInput(toolInput) {
+    const record = readToolInputRecord(toolInput);
+    if (record === undefined) {
+        return typeof toolInput === "string" ? truncate(toolInput) : "";
+    }
+    for (const key of TOOL_INPUT_PREVIEW_KEYS) {
+        const value = record[key];
+        if (typeof value === "string" && value.length > 0) {
+            return truncate(value);
+        }
+    }
+    const question = summarizeAskUserQuestion(toolInput);
+    if (question !== undefined) {
+        return truncate(question);
+    }
+    return truncate(JSON.stringify(record));
+}
+async function settleAskUserQuestion(toolInput, onUserQuestion) {
+    if (onUserQuestion === undefined) {
+        return { reason: ASK_USER_QUESTION_DENIED_REASON };
+    }
+    const answers = await onUserQuestion(toolInput);
+    if (answers === undefined || Object.keys(answers).length === 0) {
+        return { reason: ASK_USER_QUESTION_DENIED_REASON };
+    }
+    return { reason: formatAskUserQuestionAnswers(answers) };
+}
+function truncate(value) {
+    const flat = value.replace(/\s+/g, " ").trim();
+    return flat.length > TOOL_SUMMARY_MAX_LENGTH
+        ? `${flat.slice(0, TOOL_SUMMARY_MAX_LENGTH - 1)}…`
+        : flat;
+}
+/**
+ * `fullStream` still uses `tool-call`. The UI message stream — and some
+ * harness adapters after AI SDK 7 — spell the assembled call
+ * `tool-input-available` instead. Treat them as the same moment: the tool
+ * is now executing.
+ */
+function isToolCallPart(part) {
+    return (part["type"] === "tool-call" || part["type"] === "tool-input-available");
+}
+/**
+ * Same split for the result. Missing the UI names left the tool "running"
+ * after it had already finished, which is the spinner-stuck-on-every-tool
+ * hang: the stall watchdog switched to its long deadline and waited there.
+ */
+function isToolEndPart(part) {
+    return (part["type"] === "tool-result" ||
+        part["type"] === "tool-error" ||
+        part["type"] === "tool-output-available" ||
+        part["type"] === "tool-output-error" ||
+        part["type"] === "tool-output-denied");
+}
+function isToolErrorPart(part) {
+    return (part["type"] === "tool-error" ||
+        part["type"] === "tool-output-error" ||
+        part["type"] === "tool-output-denied");
+}