@superdurable/dex-agents 0.0.0-stage → 0.2.0

package/dist/src/ui-stream/agent-ui-message-stream.js

@@ -0,0 +1,681 @@
+// Copyright (c) 2026 Super Durable, Inc.
+//
+// Licensed under the Sustainable Use License 1.0.
+// You may not use this file except in compliance with the License.
+// See the LICENSE file in the repository root.
+//
+// SPDX-License-Identifier: LicenseRef-Sustainable-Use-1.0
+import { describeToolCallOutcome, outcomeUnknownToolResult, } from "../agent-session-values.js";
+import { findAgentEventResumeTokenBeforeTurn, parseTurnNumber, probeAgentEventResumeToken, readNextAgentEvent, readStepType, requireAgentEventPollTimeoutMs, resumeTokenProbeTimeoutMs, } from "./agent-event-stream-positions.js";
+import { convertAgentEventToJson } from "./agent-event-json.js";
+import { AgentSessionRecordReader } from "./agent-session-record-reader.js";
+import { agentAssistantUIMessageId, agentEventDataPartType, agentResumeTokenDataPartType, } from "./agent-ui-message-types.js";
+import { cloneAgentUIStreamCursor, createAgentUIStreamCursor, decodeAgentUIStreamCursor, encodeAgentUIStreamCursor, } from "./agent-ui-stream-cursor.js";
+const modelCallStepType = "RunModel";
+const failedToolCallText = "The tool call failed.";
+/**
+ * Translates one agent turn from the session's `AgentEvents` Stream into AI SDK UI message stream parts.
+ *
+ * The parts follow one turn. Without a resume token they replay the session's active turn from its start.
+ * With one they replay the token's turn, or continue it exactly with `continueAfterResumeToken`. The
+ * generator returns after the turn completes (`finish` with `stop`), fails (`error`, then `finish` with
+ * `error`), ends through steering or `cancel_turn` (the `turn_steered` or `turn_cancelled` event data part, then
+ * `finish` with `other`), or waits only for tool approvals (`finish` with `tool-calls`). It also returns when the turn
+ * ended without its end event on the Stream, or the session Flow closed (`finish` with `other`); the
+ * session's committed state decides this, so the stream ends even when the Stream lost every event. On
+ * `other`, reload the stored messages with {@link readAgentSessionUIMessages}.
+ *
+ * Every `RunModel` Step execution is one AI SDK step. When a new attempt of the same Step execution starts,
+ * for example after a Worker crash, the generator emits `reset-step`, so the browser drops the partial
+ * text of the interrupted attempt. Tool calls become dynamic tool parts. A tool call that needs approval
+ * gets a `tool-approval-request` whose `approvalId` is the `interrupt_id` for `resolve_interrupt`. A
+ * `question` interrupt is not an approval: its `interrupt_raised` and `interrupt_resolved` events arrive as
+ * agent event data parts, and the browser answers it with `answer_question`. A
+ * transient `data-agent-resume-token` part follows every part; send the latest one back to resume.
+ *
+ * The generator reads tool arguments and results from the committed `AgentToolCalls` records, waiting up
+ * to 3 seconds for the commit that follows each event, and from the stored messages once the turn deleted
+ * its records. It also waits up to 3 seconds for a turn's end to commit before it finishes. Events are
+ * best effort: a part whose event the Stream lost or trimmed is missing until the stored messages replace
+ * the streamed message.
+ *
+ * Stop in the browser only closes the HTTP response, and the turn keeps running in Dex. To stop the turn
+ * durably, the application's stop route calls the session's `cancel_turn` RPC.
+ *
+ * @example
+ * ```ts
+ * import { createUIMessageStreamResponse } from "ai";
+ * import { streamAgentUIMessageChunks } from "@superdurable/dex-agents/ui-stream";
+ *
+ * export async function GET(request: Request, sessionId: string): Promise<Response> {
+ *   const chunks = streamAgentUIMessageChunks({
+ *     client, flow, flowId: sessionId,
+ *     resumeToken: request.headers.get("x-agent-resume-token") ?? undefined, signal: request.signal,
+ *   });
+ *   return createUIMessageStreamResponse({ stream: ReadableStream.from(chunks) });
+ * }
+ * ```
+ * @param options - Session, start position, and polling.
+ * @returns An async generator of UI message stream parts. It yields nothing when the token's turn already
+ * finished, or when the stream would replay a turn that is not active or not on the Stream.
+ * @throws {TypeError} When `resumeToken` is not a UI stream resume token.
+ * @throws {RangeError} When `pollTimeoutMs` is not a positive whole number of seconds.
+ * @throws {DexServiceError} When a Stream read, Attribute read, or RPC fails.
+ */
+export async function* streamAgentUIMessageChunks(options) {
+    const pollTimeoutMs = requireAgentEventPollTimeoutMs(options.pollTimeoutMs);
+    const start = await prepareAgentUIStreamStart(options);
+    if (start === undefined) {
+        return;
+    }
+    for await (const chunks of readAgentUIMessageChunkBatches(options, start, pollTimeoutMs)) {
+        if (chunks !== undefined) {
+            yield* chunks;
+        }
+    }
+}
+/**
+ * Resolves where a stream starts and checks the Dex resume token with one short read.
+ *
+ * A token that Dex rejects, such as a forged one, restarts the stream from the turn's first retained
+ * event, which the Server lists itself.
+ * @returns The start, or `undefined` when there is nothing to stream.
+ * @throws {TypeError} When the resume token is invalid.
+ */
+export async function prepareAgentUIStreamStart(options) {
+    const cursor = await resolveAgentUIStreamStartCursor(options);
+    if (cursor === undefined) {
+        return undefined;
+    }
+    return probeAgentUIStreamStart(options.client, options.flow, options.flowId, cursor);
+}
+/** Checks a cursor's Dex resume token, replacing a rejected one with the turn's listed start. */
+export async function probeAgentUIStreamStart(client, flow, flowId, cursor) {
+    const probe = await probeAgentEventResumeToken(client, flow, flowId, cursor.eventResumeToken);
+    if (probe.isAccepted) {
+        return { cursor, firstMessage: probe.firstMessage };
+    }
+    if (cursor.turnId === null) {
+        return undefined;
+    }
+    const replayCursor = await createTurnReplayCursor(client, flow, flowId, cursor.turnId, null);
+    if (replayCursor === undefined) {
+        return undefined;
+    }
+    const replayProbe = await probeAgentEventResumeToken(client, flow, flowId, replayCursor.eventResumeToken);
+    return replayProbe.isAccepted ? { cursor: replayCursor, firstMessage: replayProbe.firstMessage } : undefined;
+}
+/**
+ * Returns the cursor where a stream starts, or `undefined` when there is nothing to stream.
+ * @throws {TypeError} When the resume token is invalid.
+ */
+export async function resolveAgentUIStreamStartCursor(options) {
+    const { client, flow, flowId } = options;
+    if (options.resumeToken !== undefined) {
+        const cursor = decodeAgentUIStreamCursor(options.resumeToken);
+        if (cursor.isTurnFinished) {
+            return undefined;
+        }
+        if (options.continueAfterResumeToken === true || cursor.turnId === null) {
+            return cursor;
+        }
+        // The browser may hold any part of the turn, so replay it and let the start part reset the message.
+        return ((await createTurnReplayCursor(client, flow, flowId, cursor.turnId, cursor.turnStartResumeToken)) ??
+            restartTurnAtCursor(cursor));
+    }
+    const [state] = await client.getAttributes(flowId, flow.agentState);
+    const activeTurnId = state?.activeTurnId ?? null;
+    return activeTurnId === null
+        ? undefined
+        : createTurnReplayCursor(client, flow, flowId, activeTurnId, null);
+}
+/**
+ * Returns a cursor that replays a turn from its first retained event, or `undefined` when none is retained.
+ * @param knownTurnStartResumeToken - The turn's start position recorded in a cursor, or `null` to search.
+ */
+export async function createTurnReplayCursor(client, flow, flowId, turnId, knownTurnStartResumeToken) {
+    const eventResumeToken = knownTurnStartResumeToken ?? (await findAgentEventResumeTokenBeforeTurn(client, flow, flowId, turnId));
+    if (eventResumeToken === undefined) {
+        return undefined;
+    }
+    const cursor = createAgentUIStreamCursor(eventResumeToken, turnId, false);
+    cursor.turnStartResumeToken = eventResumeToken;
+    return cursor;
+}
+/** Restarts the message at the cursor's position when the turn's start is no longer on the Stream. */
+function restartTurnAtCursor(cursor) {
+    const restarted = createAgentUIStreamCursor(cursor.eventResumeToken, cursor.turnId, false);
+    restarted.skippedChunkCount = 0;
+    return restarted;
+}
+/**
+ * Reads events from the cursor and yields the parts of each one.
+ * Yields `undefined` after an empty long poll, so a response can send a keep-alive comment.
+ */
+export async function* readAgentUIMessageChunkBatches(options, start, pollTimeoutMs) {
+    const { client, flow, flowId } = options;
+    const cursor = start.cursor;
+    const translator = new AgentUIMessageChunkTranslator(new AgentSessionRecordReader(client, flow, flowId), cursor, options.finishWhenAwaitingApproval ?? true);
+    let pendingMessage = start.firstMessage;
+    while (!translator.isComplete && options.signal?.aborted !== true) {
+        const message = pendingMessage ??
+            (await readNextAgentEvent(client, flow, flowId, cursor.eventResumeToken, pollTimeoutMs));
+        pendingMessage = undefined;
+        if (message !== undefined) {
+            yield await translator.translateEvent(message);
+            continue;
+        }
+        const idleDecision = await translator.decideAfterIdle();
+        if (idleDecision !== "wait") {
+            // Events reach the Stream before their commit; read once more before ending on committed state.
+            pendingMessage = await readNextAgentEvent(client, flow, flowId, cursor.eventResumeToken, resumeTokenProbeTimeoutMs);
+            if (pendingMessage !== undefined) {
+                continue;
+            }
+        }
+        const chunks = translator.applyIdleDecision(idleDecision);
+        yield chunks.length > 0 ? chunks : undefined;
+    }
+}
+/** Marks where the final resume token goes, before the `error` and `finish` parts. */
+const finalResumeTokenMarker = Symbol("final resume token");
+/** Translates the events of the followed turn into parts, keeping the cursor in step with the browser. */
+class AgentUIMessageChunkTranslator {
+    records;
+    cursor;
+    isFinishedWhenAwaitingApproval;
+    chunks = [];
+    isStreamEnded = false;
+    constructor(records, cursor, isFinishedWhenAwaitingApproval) {
+        this.records = records;
+        this.cursor = cursor;
+        this.isFinishedWhenAwaitingApproval = isFinishedWhenAwaitingApproval;
+    }
+    get isComplete() {
+        return this.isStreamEnded || this.cursor.isTurnFinished;
+    }
+    async translateEvent(message) {
+        const skippedChunkCount = this.cursor.skippedChunkCount;
+        this.cursor.skippedChunkCount = 0;
+        const cursorBeforeEvent = cloneAgentUIStreamCursor(this.cursor);
+        this.cursor.eventResumeToken = message.resumeToken;
+        const event = message.value;
+        if (this.isFollowedTurnEvent(event, cursorBeforeEvent.eventResumeToken)) {
+            this.startMessage();
+            await this.translateFollowedTurnEvent(event);
+            if (!this.isComplete &&
+                this.isFinishedWhenAwaitingApproval &&
+                this.cursor.modelStep?.isUsageRecorded === true &&
+                (await this.isConfirmedWaitingOnlyForApprovals())) {
+                this.endStream("tool-calls");
+            }
+        }
+        return this.takeChunks(cursorBeforeEvent, skippedChunkCount);
+    }
+    /** Decides from committed state what an empty long poll means; it may start following a turn. */
+    async decideAfterIdle() {
+        const turnId = this.cursor.turnId;
+        const state = await this.records.readAgentState();
+        if (turnId === null) {
+            const afterTurnNumber = this.cursor.afterTurnNumber;
+            const activeTurnNumber = state?.activeTurnId == null ? undefined : parseTurnNumber(state.activeTurnId);
+            if (state?.activeTurnId != null &&
+                activeTurnNumber !== undefined &&
+                (afterTurnNumber === null || activeTurnNumber > afterTurnNumber)) {
+                // The turn started, but its turn_started event never reached this stream.
+                this.cursor.turnId = state.activeTurnId;
+                return "wait";
+            }
+            if (afterTurnNumber !== null && state !== undefined && state.turnCount > afterTurnNumber) {
+                return "end";
+            }
+            return (await this.records.isFlowRunning()) ? "wait" : "end";
+        }
+        if (state?.activeTurnId !== turnId || !(await this.records.isFlowRunning())) {
+            return "end";
+        }
+        return this.isFinishedWhenAwaitingApproval && (await this.isConfirmedWaitingOnlyForApprovals())
+            ? "pause"
+            : "wait";
+    }
+    applyIdleDecision(idleDecision) {
+        if (idleDecision === "end") {
+            this.endStream("other");
+        }
+        else if (idleDecision === "pause") {
+            this.endStream("tool-calls");
+        }
+        return this.takeChunks(undefined, 0);
+    }
+    isFollowedTurnEvent(event, eventResumeTokenBefore) {
+        if (this.cursor.turnId !== null) {
+            return event.turnId === this.cursor.turnId;
+        }
+        // A cursor without a turn follows the next turn that starts after its position.
+        if (event.type !== "turn_started" || event.turnId === null) {
+            return false;
+        }
+        const turnNumber = parseTurnNumber(event.turnId);
+        const afterTurnNumber = this.cursor.afterTurnNumber;
+        if (afterTurnNumber !== null && (turnNumber === undefined || turnNumber <= afterTurnNumber)) {
+            return false;
+        }
+        this.cursor.turnId = event.turnId;
+        this.cursor.turnStartResumeToken = eventResumeTokenBefore;
+        return true;
+    }
+    startMessage() {
+        if (this.cursor.isMessageStarted || this.cursor.turnId === null) {
+            return;
+        }
+        this.chunks.push({ type: "start", messageId: agentAssistantUIMessageId(this.cursor.turnId) });
+        this.cursor.isMessageStarted = true;
+    }
+    async translateFollowedTurnEvent(event) {
+        const payload = parseEventPayload(event.payload);
+        if (payload === undefined) {
+            this.pushAgentEventData(event);
+            return;
+        }
+        switch (event.type) {
+            case "turn_started":
+                return;
+            case "text_delta":
+            case "reasoning_delta": {
+                const text = readPayloadString(payload, "text");
+                // Text from a tool Step belongs to no model call, so it travels as event data.
+                if (text === undefined || !isModelCallStepType(readStepType(event.stepExecutionId))) {
+                    this.pushAgentEventData(event);
+                    return;
+                }
+                if (this.enterModelStep(event)) {
+                    this.appendDelta(event.type === "text_delta" ? "text" : "reasoning", text);
+                }
+                return;
+            }
+            case "tool_call_deferred": {
+                const toolCallId = readPayloadString(payload, "tool_call_id");
+                const toolName = readPayloadString(payload, "tool_name");
+                if (toolCallId === undefined || toolName === undefined) {
+                    this.pushAgentEventData(event);
+                    return;
+                }
+                if (this.enterModelStep(event)) {
+                    await this.introduceToolCall(toolCallId, toolName);
+                }
+                return;
+            }
+            case "interrupt_raised": {
+                const interruptId = readPayloadString(payload, "interrupt_id");
+                const toolCallId = readPayloadString(payload, "tool_call_id");
+                // A question is answered with answer_question, not approved, so it stays an event data part.
+                if (interruptId === undefined || toolCallId === undefined || payload["kind"] === "question") {
+                    this.pushAgentEventData(event);
+                    return;
+                }
+                if (this.enterModelStep(event)) {
+                    await this.requestToolApproval(toolCallId, readPayloadString(payload, "tool_name"), interruptId);
+                }
+                return;
+            }
+            case "usage_recorded":
+                // A CompactContext summary call is no step of the assistant message; its usage is only event data.
+                if (isModelCallStepType(readStepType(event.stepExecutionId)) &&
+                    this.enterModelStep(event) &&
+                    this.cursor.modelStep !== null) {
+                    this.cursor.modelStep.isUsageRecorded = true;
+                }
+                this.pushAgentEventData(event);
+                return;
+            case "tool_call_started": {
+                const toolCallId = readPayloadString(payload, "tool_call_id");
+                if (toolCallId !== undefined) {
+                    await this.introduceToolCall(toolCallId, readPayloadString(payload, "tool_name"));
+                }
+                this.pushAgentEventData(event);
+                return;
+            }
+            case "interrupt_resolved": {
+                const interruptId = readPayloadString(payload, "interrupt_id");
+                const isApproved = payload["approved"];
+                if (interruptId === undefined || typeof isApproved !== "boolean" || payload["kind"] === "question") {
+                    this.pushAgentEventData(event);
+                    return;
+                }
+                await this.recordToolApproval(interruptId, isApproved, readPayloadString(payload, "rejection_message"));
+                return;
+            }
+            case "tool_call_finished": {
+                const toolCallId = readPayloadString(payload, "tool_call_id");
+                const status = readPayloadString(payload, "status");
+                if (toolCallId === undefined || status === undefined) {
+                    this.pushAgentEventData(event);
+                    return;
+                }
+                await this.finishToolCall(toolCallId, readPayloadString(payload, "tool_name"), status, event);
+                return;
+            }
+            case "turn_completed":
+                if (this.enterModelStep(event) && (await this.records.waitForTurnToEnd(this.requireTurnId()))) {
+                    this.endStream("stop");
+                }
+                return;
+            case "turn_failed":
+                if (await this.records.waitForTurnToEnd(this.requireTurnId())) {
+                    this.endStream("error", readPayloadString(payload, "error") ?? "the agent turn failed");
+                }
+                return;
+            case "turn_steered":
+            case "turn_cancelled":
+                // The turn ended without an answer; the browser reloads its stored messages on `other`.
+                this.pushAgentEventData(event);
+                if (await this.records.waitForTurnToEnd(this.requireTurnId())) {
+                    this.endStream("other");
+                }
+                return;
+            default:
+                this.pushAgentEventData(event);
+        }
+    }
+    /**
+     * Moves to the event's model call, opening a new step or resetting an interrupted attempt.
+     * @returns `false` for an event of an attempt older than the one the browser shows, which is dropped.
+     */
+    enterModelStep(event) {
+        const modelStep = this.cursor.modelStep;
+        if (modelStep === null || modelStep.stepExecutionId !== event.stepExecutionId) {
+            this.closeOpenPart();
+            if (modelStep !== null) {
+                this.chunks.push({ type: "finish-step" });
+            }
+            this.chunks.push({ type: "start-step" });
+            this.cursor.modelStep = {
+                stepExecutionId: event.stepExecutionId,
+                attempt: event.attempt,
+                openedPartCount: 0,
+                isUsageRecorded: false,
+            };
+            // Every tool call of the previous model call finished before this one started.
+            this.cursor.toolCalls.clear();
+            return true;
+        }
+        if (event.attempt < modelStep.attempt) {
+            return false;
+        }
+        if (event.attempt > modelStep.attempt) {
+            // The browser removes every part of the current step, open parts included.
+            this.chunks.push({ type: "reset-step" });
+            this.cursor.openPart = null;
+            this.cursor.toolCalls.clear();
+            modelStep.attempt = event.attempt;
+            modelStep.openedPartCount = 0;
+            modelStep.isUsageRecorded = false;
+        }
+        return true;
+    }
+    appendDelta(kind, text) {
+        const modelStep = this.cursor.modelStep;
+        if (text === "" || modelStep === null) {
+            return;
+        }
+        let openPart = this.cursor.openPart;
+        if (openPart !== null && openPart.kind !== kind) {
+            this.closeOpenPart();
+            openPart = null;
+        }
+        if (openPart === null) {
+            const id = `${modelStep.stepExecutionId}.${modelStep.attempt}.${modelStep.openedPartCount}`;
+            modelStep.openedPartCount += 1;
+            openPart = { kind, id };
+            this.cursor.openPart = openPart;
+            this.chunks.push(kind === "text" ? { type: "text-start", id } : { type: "reasoning-start", id });
+        }
+        this.chunks.push(kind === "text"
+            ? { type: "text-delta", id: openPart.id, delta: text }
+            : { type: "reasoning-delta", id: openPart.id, delta: text });
+    }
+    closeOpenPart() {
+        const openPart = this.cursor.openPart;
+        if (openPart === null) {
+            return;
+        }
+        this.chunks.push(openPart.kind === "text"
+            ? { type: "text-end", id: openPart.id }
+            : { type: "reasoning-end", id: openPart.id });
+        this.cursor.openPart = null;
+    }
+    /**
+     * Adds the dynamic tool part of a tool call the browser does not show yet.
+     * @returns Whether the browser shows the tool call's part afterwards.
+     */
+    async introduceToolCall(toolCallId, toolName) {
+        if (this.cursor.toolCalls.has(toolCallId)) {
+            return true;
+        }
+        const details = await this.records.readToolCallDetails(this.requireTurnId(), toolCallId, () => true);
+        const resolvedToolName = toolName ?? details.toolName;
+        if (resolvedToolName === undefined) {
+            return false;
+        }
+        this.closeOpenPart();
+        this.chunks.push({
+            type: "tool-input-available",
+            toolCallId,
+            toolName: resolvedToolName,
+            // JSON drops undefined, and the AI SDK requires the field.
+            input: parseToolArguments(details.toolArguments) ?? null,
+            dynamic: true,
+        });
+        this.cursor.toolCalls.set(toolCallId, "input");
+        return true;
+    }
+    async requestToolApproval(toolCallId, toolName, interruptId) {
+        if (!(await this.introduceToolCall(toolCallId, toolName))) {
+            return;
+        }
+        if (this.cursor.toolCalls.get(toolCallId) !== "input") {
+            return;
+        }
+        this.chunks.push({ type: "tool-approval-request", approvalId: interruptId, toolCallId });
+        this.cursor.toolCalls.set(toolCallId, "approval_requested");
+    }
+    async recordToolApproval(interruptId, isApproved, rejectionMessage) {
+        // A tool approval's interrupt ID is its tool call ID.
+        const toolCallId = interruptId;
+        await this.requestToolApproval(toolCallId, undefined, interruptId);
+        if (this.cursor.toolCalls.get(toolCallId) !== "approval_requested") {
+            return;
+        }
+        this.chunks.push({
+            type: "tool-approval-response",
+            approvalId: interruptId,
+            approved: isApproved,
+            ...(rejectionMessage === undefined ? {} : { reason: rejectionMessage }),
+        });
+        this.cursor.toolCalls.set(toolCallId, "approval_resolved");
+    }
+    async finishToolCall(toolCallId, toolName, status, event) {
+        if (status === "rejected") {
+            await this.recordToolApproval(toolCallId, false, undefined);
+            if (this.cursor.toolCalls.has(toolCallId)) {
+                this.chunks.push({ type: "tool-output-denied", toolCallId });
+                this.cursor.toolCalls.set(toolCallId, "finished");
+            }
+            return;
+        }
+        if (status !== "succeeded" && status !== "failed" && status !== "outcome_unknown") {
+            this.pushAgentEventData(event);
+            return;
+        }
+        if (!(await this.introduceToolCall(toolCallId, toolName))) {
+            return;
+        }
+        if (status === "outcome_unknown") {
+            this.chunks.push({ type: "tool-output-error", toolCallId, errorText: outcomeUnknownToolResult, dynamic: true });
+        }
+        else {
+            const details = await this.records.readToolCallDetails(this.requireTurnId(), toolCallId, (toolCall) => toolCall.status === status);
+            const record = details.record?.status === status ? details.record : undefined;
+            if (status === "succeeded") {
+                this.chunks.push({
+                    type: "tool-output-available",
+                    toolCallId,
+                    output: record?.output ?? details.storedToolOutput ?? null,
+                    dynamic: true,
+                });
+            }
+            else {
+                this.chunks.push({
+                    type: "tool-output-error",
+                    toolCallId,
+                    errorText: record === undefined
+                        ? (details.storedToolOutput ?? failedToolCallText)
+                        : describeToolCallOutcome(record),
+                    dynamic: true,
+                });
+            }
+        }
+        this.cursor.toolCalls.set(toolCallId, "finished");
+    }
+    /**
+     * Reports whether the turn waits only for approvals, judged by the committed records and
+     * `PendingInterrupts`: a replay reaches an approval request before the events that answered it.
+     */
+    async isConfirmedWaitingOnlyForApprovals() {
+        if (!this.isWaitingOnlyForApprovals()) {
+            return false;
+        }
+        const requestedApprovalToolCallIds = [];
+        for (const [toolCallId, state] of this.cursor.toolCalls) {
+            if (state !== "approval_requested") {
+                continue;
+            }
+            const record = await this.records.readCommittedToolCall(this.requireTurnId(), toolCallId);
+            if (record?.status !== "awaiting_approval") {
+                return false;
+            }
+            requestedApprovalToolCallIds.push(toolCallId);
+        }
+        // resolve_interrupt removes the interrupt before the approval Step commits the record.
+        const pendingApprovalToolCallIds = await this.records.readPendingApprovalToolCallIds();
+        return requestedApprovalToolCallIds.every((toolCallId) => pendingApprovalToolCallIds.has(toolCallId));
+    }
+    isWaitingOnlyForApprovals() {
+        let hasRequestedApproval = false;
+        for (const state of this.cursor.toolCalls.values()) {
+            if (state === "approval_requested") {
+                hasRequestedApproval = true;
+            }
+            else if (state !== "finished") {
+                return false;
+            }
+        }
+        return hasRequestedApproval;
+    }
+    endStream(finishReason, errorText) {
+        this.closeOpenPart();
+        if (finishReason === "tool-calls") {
+            this.isStreamEnded = true;
+        }
+        else {
+            if (this.cursor.modelStep !== null) {
+                this.chunks.push({ type: "finish-step" });
+            }
+            this.cursor.isTurnFinished = true;
+        }
+        this.chunks.push(finalResumeTokenMarker);
+        if (errorText !== undefined) {
+            this.chunks.push({ type: "error", errorText });
+        }
+        this.chunks.push({ type: "finish", finishReason });
+    }
+    pushAgentEventData(event) {
+        this.chunks.push({ type: agentEventDataPartType, data: convertAgentEventToJson(event), transient: true });
+    }
+    /**
+     * Returns the event's parts after the ones the browser already holds, each followed by a resume token.
+     * A token inside the event names the state before it plus the parts already sent, so a cut between
+     * two parts of one event resumes without repeating either. Parts of no event, `cursorBeforeEvent`
+     * `undefined`, get only the final token.
+     */
+    takeChunks(cursorBeforeEvent, skippedChunkCount) {
+        const chunks = this.chunks;
+        this.chunks = [];
+        let lastChunkIndex = chunks.length - 1;
+        while (lastChunkIndex >= 0 && chunks[lastChunkIndex] === finalResumeTokenMarker) {
+            lastChunkIndex -= 1;
+        }
+        const markerIndex = chunks.indexOf(finalResumeTokenMarker);
+        const translatedChunks = [];
+        let chunkCount = 0;
+        for (const [index, chunk] of chunks.entries()) {
+            if (chunk === finalResumeTokenMarker) {
+                translatedChunks.push(this.createResumeTokenChunk(this.cursor));
+                continue;
+            }
+            chunkCount += 1;
+            if (chunkCount <= skippedChunkCount) {
+                continue;
+            }
+            translatedChunks.push(chunk);
+            if (markerIndex >= 0 && index > markerIndex) {
+                continue;
+            }
+            if (index === lastChunkIndex || index + 1 === markerIndex) {
+                if (markerIndex < 0) {
+                    translatedChunks.push(this.createResumeTokenChunk(this.cursor));
+                }
+                continue;
+            }
+            if (cursorBeforeEvent !== undefined) {
+                translatedChunks.push(this.createResumeTokenChunk({ ...cursorBeforeEvent, skippedChunkCount: chunkCount }));
+            }
+        }
+        return translatedChunks;
+    }
+    createResumeTokenChunk(cursor) {
+        return {
+            type: agentResumeTokenDataPartType,
+            data: encodeAgentUIStreamCursor(cursor),
+            transient: true,
+        };
+    }
+    requireTurnId() {
+        if (this.cursor.turnId === null) {
+            throw new Error("the agent UI stream translated an event before it followed a turn");
+        }
+        return this.cursor.turnId;
+    }
+}
+function parseEventPayload(payload) {
+    try {
+        const value = JSON.parse(payload);
+        return typeof value === "object" && value !== null && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readPayloadString(payload, key) {
+    const value = payload[key];
+    return typeof value === "string" ? value : undefined;
+}
+/** Parses tool arguments JSON text; text that is not JSON stays a string. */
+export function parseToolArguments(toolArguments) {
+    if (toolArguments === null || toolArguments === undefined) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(toolArguments);
+    }
+    catch {
+        return toolArguments;
+    }
+}
+/** Reports whether events of this Step type belong to a model call: `RunModel`, or unknown for old events. */
+function isModelCallStepType(stepType) {
+    return stepType === modelCallStepType || stepType === "";
+}
+//# sourceMappingURL=agent-ui-message-stream.js.map