@teaflask/assistant 0.0.0 → 0.6.0

package/dist/transport/replay-stream-agent.js

@@ -0,0 +1,100 @@
+import { HttpAgent } from "@ag-ui/client";
+import { EventType } from "@ag-ui/core";
+import { filter } from "rxjs";
+import { liftToolOutcome } from "../core/tool-outcome.js";
+import { SseFrameIdScanner, StreamResumeStore, } from "./stream-resume.js";
+export class ServingReplayStreamAgent extends HttpAgent {
+    scanner;
+    seededSnapshot;
+    seededContentIds;
+    constructor({ streamUrl, streamThreadId, authorizedFetch, resume, }) {
+        const scanner = new SseFrameIdScanner();
+        const snapshot = resume?.snapshot ?? null;
+        super({
+            url: streamUrl,
+            threadId: streamThreadId,
+            fetch: scanner.wrap(authorizedFetch),
+            initialMessages: snapshot?.messages,
+        });
+        this.scanner = scanner;
+        this.seededSnapshot = snapshot;
+        this.seededContentIds =
+            snapshot === null ? new Set() : _contentIdsOf(snapshot.messages);
+        this._reseedWhenTheHostWipesTheList();
+    }
+    _reseedWhenTheHostWipesTheList() {
+        this.subscribe({
+            onRunInitialized: ({ messages }) => {
+                const snapshot = this.seededSnapshot;
+                if (snapshot !== null && messages.length === 0) {
+                    return { messages: structuredClone(snapshot.messages) };
+                }
+                return undefined;
+            },
+        });
+    }
+    get resumeCursor() {
+        return this.scanner.lastEventId;
+    }
+    get sawBodyBytes() {
+        return this.scanner.bodyBytesSeen;
+    }
+    run(input) {
+        return liftToolOutcome(super.run(input));
+    }
+    connect(input) {
+        this._replaceAbortControllerIfAborted();
+        const snapshot = this.seededSnapshot ?? null;
+        if (snapshot === null) {
+            return this.run(input);
+        }
+        return this.run(_resumedPast(input, snapshot.afterId)).pipe(filter((event) => !this._alreadySeeded(event)));
+    }
+    requestInit(input) {
+        return super.requestInit({ ...input, messages: [] });
+    }
+    _replaceAbortControllerIfAborted() {
+        if (this.abortController.signal.aborted) {
+            this.abortController = new AbortController();
+        }
+    }
+    _alreadySeeded(event) {
+        switch (event.type) {
+            case EventType.TEXT_MESSAGE_START:
+            case EventType.TEXT_MESSAGE_CONTENT:
+            case EventType.TEXT_MESSAGE_END:
+            case EventType.REASONING_START:
+            case EventType.REASONING_MESSAGE_START:
+            case EventType.REASONING_MESSAGE_CONTENT:
+            case EventType.REASONING_MESSAGE_END:
+            case EventType.REASONING_END:
+            case EventType.TOOL_CALL_RESULT:
+                return this.seededContentIds.has(event.messageId);
+            case EventType.TOOL_CALL_START:
+            case EventType.TOOL_CALL_ARGS:
+            case EventType.TOOL_CALL_END:
+                return this.seededContentIds.has(event.toolCallId);
+            default:
+                return false;
+        }
+    }
+}
+function _resumedPast(input, afterId) {
+    const forwardedProps = (input.forwardedProps ?? {});
+    return {
+        ...input,
+        forwardedProps: { ...forwardedProps, after_id: afterId },
+    };
+}
+function _contentIdsOf(messages) {
+    const ids = new Set();
+    for (const message of messages) {
+        ids.add(message.id);
+        if (message.role === "assistant") {
+            for (const toolCall of message.toolCalls ?? []) {
+                ids.add(toolCall.id);
+            }
+        }
+    }
+    return ids;
+}

package/dist/transport/serving-api.d.ts

@@ -0,0 +1,33 @@
+import type { GetServingAssistantThreadParams, ListServingAssistantThreadsParams, ServingAttachmentDownloadUrlResponse } from "../generated/models/index.js";
+import type { AssistantConfigResponse } from "../contract/assistant-config.js";
+import type { ThreadDispatch } from "../contract/dispatches.js";
+import type { AssistantThreadDetailResponse, AttachmentUploadIntent, ResolveTurnApprovalRequest, ResolveTurnApprovalResponse, ResolveTurnToolResultsRequest, ResolveTurnToolResultsResponse, SendAssistantMessageRequest, SendAssistantMessageResponse, ServingAssistantThread, ServingAttachment, StopTurnResponse } from "../contract/threads.js";
+import type { SubscriptionAuthorization, SubscriptionAuthorizationCompletion, SubscriptionAuthorizationCompletionRequest, SubscriptionProvider, SubscriptionStatus } from "../contract/subscriptions.js";
+import type { TokenSession } from "./token-session.js";
+export declare function sendAssistantMessage(session: TokenSession, request: SendAssistantMessageRequest): Promise<SendAssistantMessageResponse>;
+export declare function stopAssistantTurn(session: TokenSession, threadId: string): Promise<StopTurnResponse>;
+export declare function listAssistantThreads(session: TokenSession, params?: ListServingAssistantThreadsParams): Promise<ServingAssistantThread[]>;
+export declare function getAssistantThread(session: TokenSession, threadId: string, params?: GetServingAssistantThreadParams): Promise<AssistantThreadDetailResponse>;
+export declare function listThreadDispatches(session: TokenSession, threadId: string): Promise<ThreadDispatch[]>;
+export declare function getAssistantConfig(session: TokenSession): Promise<AssistantConfigResponse>;
+export declare function resolveTurnApproval(session: TokenSession, threadId: string, turnId: string, request: ResolveTurnApprovalRequest): Promise<ResolveTurnApprovalResponse>;
+export declare function resolveTurnToolResults(session: TokenSession, threadId: string, turnId: string, request: ResolveTurnToolResultsRequest): Promise<ResolveTurnToolResultsResponse>;
+export declare function createAttachmentUpload(session: TokenSession, request: {
+    filename: string;
+    byte_size: number;
+}): Promise<AttachmentUploadIntent>;
+export declare function finalizeAttachment(session: TokenSession, attachmentId: string): Promise<ServingAttachment>;
+export declare function getAttachmentDownloadUrl(session: TokenSession, attachmentId: string): Promise<ServingAttachmentDownloadUrlResponse>;
+export declare function listSubscriptions(session: TokenSession): Promise<SubscriptionStatus[]>;
+export declare function beginSubscriptionAuthorization(session: TokenSession, provider: SubscriptionProvider): Promise<SubscriptionAuthorization>;
+export declare function completeSubscriptionAuthorization(session: TokenSession, provider: SubscriptionProvider, request: SubscriptionAuthorizationCompletionRequest): Promise<SubscriptionAuthorizationCompletion>;
+export declare function disconnectSubscription(session: TokenSession, provider: SubscriptionProvider): Promise<void>;
+interface SubscriptionRecheckAnswer {
+    standing: SubscriptionStatus;
+    probeStarted: boolean;
+}
+export declare function recheckSubscription(session: TokenSession, provider: SubscriptionProvider): Promise<SubscriptionRecheckAnswer>;
+export declare function putFileToUploadUrl(uploadUrl: string, file: Blob): Promise<void>;
+export declare function streamUrlForThread(session: TokenSession, threadId: string): string;
+export declare function streamUrlForChild(session: TokenSession, threadId: string, childSessionId: string): string;
+export {};

package/dist/transport/serving-api.js

@@ -0,0 +1,67 @@
+import { beginSubscriptionAuthorization as beginSubscriptionAuthorizationOperation, completeSubscriptionAuthorization as completeSubscriptionAuthorizationOperation, createServingAttachmentUpload as createServingAttachmentUploadOperation, disconnectSubscription as disconnectSubscriptionOperation, getRecheckSubscriptionUrl, finalizeServingAttachment as finalizeServingAttachmentOperation, getServingAttachmentDownloadUrl as getServingAttachmentDownloadUrlOperation, getServingAssistantThread as getServingAssistantThreadOperation, listServingAssistantThreadDispatches as listServingAssistantThreadDispatchesOperation, listServingAssistantThreads as listServingAssistantThreadsOperation, listServingSubscriptions as listServingSubscriptionsOperation, readAssistantConfig as readAssistantConfigOperation, resolveServingAssistantTurnApproval as resolveServingAssistantTurnApprovalOperation, resolveServingAssistantTurnToolResults as resolveServingAssistantTurnToolResultsOperation, sendServingAssistantMessage as sendServingAssistantMessageOperation, stopServingAssistantTurn as stopServingAssistantTurnOperation, } from "../generated/serving.js";
+import { servingFetchResponse, } from "./serving-fetch.js";
+export async function sendAssistantMessage(session, request) {
+    return sendServingAssistantMessageOperation(request, _withSession(session));
+}
+export async function stopAssistantTurn(session, threadId) {
+    return stopServingAssistantTurnOperation(threadId, _withSession(session));
+}
+export async function listAssistantThreads(session, params) {
+    return listServingAssistantThreadsOperation(params, _withSession(session));
+}
+export async function getAssistantThread(session, threadId, params) {
+    return getServingAssistantThreadOperation(threadId, params, _withSession(session));
+}
+export async function listThreadDispatches(session, threadId) {
+    return listServingAssistantThreadDispatchesOperation(threadId, _withSession(session));
+}
+export async function getAssistantConfig(session) {
+    return readAssistantConfigOperation(_withSession(session));
+}
+export async function resolveTurnApproval(session, threadId, turnId, request) {
+    return resolveServingAssistantTurnApprovalOperation(threadId, turnId, request, _withSession(session));
+}
+export async function resolveTurnToolResults(session, threadId, turnId, request) {
+    return resolveServingAssistantTurnToolResultsOperation(threadId, turnId, request, _withSession(session));
+}
+export async function createAttachmentUpload(session, request) {
+    return createServingAttachmentUploadOperation(request, _withSession(session));
+}
+export async function finalizeAttachment(session, attachmentId) {
+    return finalizeServingAttachmentOperation(attachmentId, _withSession(session));
+}
+export async function getAttachmentDownloadUrl(session, attachmentId) {
+    return getServingAttachmentDownloadUrlOperation(attachmentId, _withSession(session));
+}
+export async function listSubscriptions(session) {
+    const response = await listServingSubscriptionsOperation(_withSession(session));
+    return response.subscriptions;
+}
+export async function beginSubscriptionAuthorization(session, provider) {
+    return beginSubscriptionAuthorizationOperation(provider, _withSession(session));
+}
+export async function completeSubscriptionAuthorization(session, provider, request) {
+    return completeSubscriptionAuthorizationOperation(provider, request, _withSession(session));
+}
+export async function disconnectSubscription(session, provider) {
+    await disconnectSubscriptionOperation(provider, _withSession(session));
+}
+export async function recheckSubscription(session, provider) {
+    const { body, status } = await servingFetchResponse(getRecheckSubscriptionUrl(provider), { ..._withSession(session), method: "POST" });
+    return { standing: body, probeStarted: status === 202 };
+}
+export async function putFileToUploadUrl(uploadUrl, file) {
+    const response = await fetch(uploadUrl, { method: "PUT", body: file });
+    if (!response.ok) {
+        throw new Error(`The file upload failed (${String(response.status)}).`);
+    }
+}
+export function streamUrlForThread(session, threadId) {
+    return `${session.baseUrl}/serving/v1/assistant-threads/${threadId}/stream`;
+}
+export function streamUrlForChild(session, threadId, childSessionId) {
+    return `${session.baseUrl}/serving/v1/assistant-threads/${threadId}/dispatches/${childSessionId}/stream`;
+}
+function _withSession(session) {
+    return { session };
+}

package/dist/transport/serving-error.d.ts

@@ -0,0 +1,15 @@
+import type { ServingErrorCodeOnTheWire } from "../contract/errors.js";
+export declare class ServingApiError extends Error {
+    readonly code: ServingErrorCodeOnTheWire;
+    readonly status: number;
+    readonly retryAfterSeconds: number | null;
+    readonly details: unknown;
+    constructor(options: {
+        code: ServingErrorCodeOnTheWire;
+        status: number;
+        message: string;
+        retryAfterSeconds: number | null;
+        details?: unknown;
+    });
+}
+export declare function parseServingError(response: Response): Promise<ServingApiError>;

package/dist/transport/serving-error.js

@@ -0,0 +1,54 @@
+export class ServingApiError extends Error {
+    code;
+    status;
+    retryAfterSeconds;
+    details;
+    constructor(options) {
+        super(options.message);
+        this.name = "ServingApiError";
+        this.code = options.code;
+        this.status = options.status;
+        this.retryAfterSeconds = options.retryAfterSeconds;
+        this.details = options.details;
+    }
+}
+export async function parseServingError(response) {
+    const envelope = await _readEnvelopeIfPresent(response);
+    return new ServingApiError({
+        code: envelope?.error.code ?? "UNKNOWN",
+        status: response.status,
+        message: envelope?.error.message ??
+            "The assistant service answered unexpectedly. Please try again.",
+        retryAfterSeconds: _retryAfterSecondsOf(response),
+        details: envelope?.error.details,
+    });
+}
+async function _readEnvelopeIfPresent(response) {
+    try {
+        const body = await response.json();
+        if (_looksLikeErrorEnvelope(body)) {
+            return body;
+        }
+    }
+    catch {
+    }
+    return null;
+}
+function _looksLikeErrorEnvelope(body) {
+    if (typeof body !== "object" || body === null || !("error" in body)) {
+        return false;
+    }
+    const error = body.error;
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        "message" in error);
+}
+function _retryAfterSecondsOf(response) {
+    const header = response.headers.get("Retry-After");
+    if (header === null) {
+        return null;
+    }
+    const seconds = Number.parseInt(header, 10);
+    return Number.isNaN(seconds) ? null : seconds;
+}

package/dist/transport/serving-fetch.d.ts

@@ -0,0 +1,11 @@
+import type { TokenSession } from "./token-session.js";
+export type ServingRequestInit = RequestInit & {
+    session?: TokenSession;
+};
+export declare function servingFetch<Body>(url: string, init: ServingRequestInit): Promise<Body>;
+interface ServingResponse<Body> {
+    body: Body;
+    status: number;
+}
+export declare function servingFetchResponse<Body>(url: string, init: ServingRequestInit): Promise<ServingResponse<Body>>;
+export {};

package/dist/transport/serving-fetch.js

@@ -0,0 +1,20 @@
+import { parseServingError } from "./serving-error.js";
+export async function servingFetch(url, init) {
+    const { body } = await servingFetchResponse(url, init);
+    return body;
+}
+export async function servingFetchResponse(url, init) {
+    const { session, ...requestInit } = init;
+    if (session === undefined) {
+        throw new Error("This serving call has no TokenSession. Call it through the " +
+            "serving-api wrappers, which thread the session into options.");
+    }
+    const response = await session.authorizedFetch(`${session.baseUrl}${url}`, requestInit);
+    if (!response.ok) {
+        throw await parseServingError(response);
+    }
+    if (response.status === 204) {
+        return { body: undefined, status: response.status };
+    }
+    return { body: (await response.json()), status: response.status };
+}

package/dist/transport/stream-resume.d.ts

@@ -0,0 +1,70 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+import type { Message } from "@ag-ui/core";
+import { type MemoryUpdated } from "../core/memory-provenance-anchors.js";
+import type { BlockTiming } from "../core/segment-timing.js";
+import { type TurnUsage } from "../core/turn-usage-anchors.js";
+import type { ToolCallDisplay } from "../core/tool-call-display.js";
+import type { ToolCallSchemas } from "../core/tool-schema-anchors.js";
+import { type ToolDenialLedger, type ToolDenialMarker } from "../core/tool-denial-anchors.js";
+import { type DeliveredResult } from "../core/subagent-delivery-anchors.js";
+import { type AnchoredTurnFailReceipts } from "../core/turn-failed-anchors.js";
+export interface ResumeSnapshot {
+    afterId: string;
+    messages: Message[];
+}
+export declare class StreamResumeStore {
+    snapshot: ResumeSnapshot | null;
+    readonly resumeAnchors: Map<string, unknown>;
+    turnFailedAnchors: ReadonlyMap<string, AnchoredTurnFailReceipts>;
+    toolErrorAnchors: ReadonlyMap<string, string>;
+    toolRefusalAnchors: ReadonlyMap<string, string>;
+    toolCancelAnchors: ReadonlySet<string>;
+    toolOffloadAnchors: ReadonlySet<string>;
+    toolDecisionAnchors: ReadonlySet<string>;
+    toolDenialLedger: ToolDenialLedger;
+    toolCallDisplayAnchors: ReadonlyMap<string, ToolCallDisplay>;
+    toolSchemaAnchors: ReadonlyMap<string, ToolCallSchemas>;
+    subagentDeliveryAnchors: ReadonlyMap<string, DeliveredResult[]>;
+    blockTimingRevision: number;
+    private readonly _blockTimingAnchors;
+    get blockTimingAnchors(): ReadonlyMap<string, BlockTiming>;
+    turnUsageAnchors: ReadonlyMap<string, TurnUsage>;
+    memoryProvenanceAnchors: ReadonlyMap<string, MemoryUpdated>;
+    memoryAttributionAnchors: ReadonlyMap<string, string>;
+    private readonly anchoredResumptions;
+    private readonly anchoredFailedRuns;
+    private readonly anchoredDeliveryRuns;
+    recordResumeAnchor(runId: string | null, messageId: string, markerValue: unknown, markerTimestamp: number | null): boolean;
+    recordTurnFailedReceipts(failedRunId: string, messageId: string, position: keyof AnchoredTurnFailReceipts, receipts: string[]): boolean;
+    recordSubagentDelivery(deliveryRunId: string, messageId: string, results: DeliveredResult[]): boolean;
+    recordToolError(toolCallId: string, errorText: string): void;
+    recordToolRefusal(toolCallId: string, sentence: string): void;
+    recordToolCancel(toolCallId: string): void;
+    recordToolDecision(toolCallId: string): void;
+    recordToolDenialMarker(marker: ToolDenialMarker): void;
+    recordToolOffload(toolCallId: string): void;
+    recordToolCallDisplay(toolCallId: string, display: ToolCallDisplay): void;
+    recordToolSchemas(toolCallId: string, schemas: ToolCallSchemas): void;
+    recordBlockTiming(blockId: string, observedAtMs: number): void;
+    recordTurnUsage(usage: TurnUsage): void;
+    recordMemoryUpdate(update: MemoryUpdated): void;
+    recordMemoryAttribution(memoryId: string, messageId: string): void;
+    recordPair(afterId: string, messages: readonly Readonly<Message>[]): void;
+}
+export declare function resumeMarkerRecorder(onResumeAnchored: (runId: string | null, messageId: string, markerValue: unknown, markerTimestamp: number | null) => void): AgentSubscriber;
+export declare function resumeSnapshotRecorder(cursorOf: () => string | null, store: StreamResumeStore): AgentSubscriber;
+type AuthorizedFetch = (url: string, requestInit: RequestInit) => Promise<Response>;
+export declare class SseFrameIdScanner {
+    lastEventId: string | null;
+    bodyBytesSeen: boolean;
+    private buffer;
+    private pendingId;
+    private frameHasData;
+    private decoder;
+    wrap(fetchFn: AuthorizedFetch): AuthorizedFetch;
+    private _scannedCopyOf;
+    private _resetConnectionState;
+    private _scan;
+    private _scanLine;
+}
+export {};

package/dist/transport/stream-resume.js

@@ -0,0 +1,276 @@
+import { EventType } from "@ag-ui/core";
+import { RUN_RESUMED_EVENT_NAME } from "../contract/events.js";
+import { foldBlockTimingObserved } from "../core/block-timing-anchors.js";
+import { EMPTY_MEMORY_ATTRIBUTION_ANCHORS, EMPTY_MEMORY_PROVENANCE_ANCHORS, withMemoryAttributed, withMemoryUpdateAnchored, } from "../core/memory-provenance-anchors.js";
+import { EMPTY_TURN_USAGE_ANCHORS, withTurnUsageAnchored, } from "../core/turn-usage-anchors.js";
+import { EMPTY_TOOL_SCHEMA_ANCHORS, withToolSchemasAnchored, } from "../core/tool-schema-anchors.js";
+import { EMPTY_TOOL_CALL_DISPLAY_ANCHORS, withToolCallDisplayAnchored, } from "../core/tool-call-display-anchors.js";
+import { EMPTY_TOOL_CANCEL_ANCHORS, withToolCancelAnchored, } from "../core/tool-cancel-anchors.js";
+import { EMPTY_TOOL_DECISION_ANCHORS, withToolDecisionAnchored, } from "../core/tool-decision-anchors.js";
+import { EMPTY_TOOL_DENIAL_LEDGER, withToolDenialMarkerFolded, } from "../core/tool-denial-anchors.js";
+import { EMPTY_TOOL_ERROR_ANCHORS, withToolErrorAnchored, } from "../core/tool-error-anchors.js";
+import { EMPTY_TOOL_REFUSAL_ANCHORS, withToolRefusalAnchored, } from "../core/tool-refusal-anchors.js";
+import { EMPTY_TOOL_OFFLOAD_ANCHORS, withToolOffloadAnchored, } from "../core/tool-offload-anchors.js";
+import { EMPTY_SUBAGENT_DELIVERY_ANCHORS, withSubagentDeliveryAnchored, } from "../core/subagent-delivery-anchors.js";
+import { EMPTY_TURN_FAILED_ANCHORS, withTurnFailedAnchored, } from "../core/turn-failed-anchors.js";
+export class StreamResumeStore {
+    snapshot = null;
+    resumeAnchors = new Map();
+    turnFailedAnchors = EMPTY_TURN_FAILED_ANCHORS;
+    toolErrorAnchors = EMPTY_TOOL_ERROR_ANCHORS;
+    toolRefusalAnchors = EMPTY_TOOL_REFUSAL_ANCHORS;
+    toolCancelAnchors = EMPTY_TOOL_CANCEL_ANCHORS;
+    toolOffloadAnchors = EMPTY_TOOL_OFFLOAD_ANCHORS;
+    toolDecisionAnchors = EMPTY_TOOL_DECISION_ANCHORS;
+    toolDenialLedger = EMPTY_TOOL_DENIAL_LEDGER;
+    toolCallDisplayAnchors = EMPTY_TOOL_CALL_DISPLAY_ANCHORS;
+    toolSchemaAnchors = EMPTY_TOOL_SCHEMA_ANCHORS;
+    subagentDeliveryAnchors = EMPTY_SUBAGENT_DELIVERY_ANCHORS;
+    blockTimingRevision = 0;
+    _blockTimingAnchors = new Map();
+    get blockTimingAnchors() {
+        return this._blockTimingAnchors;
+    }
+    turnUsageAnchors = EMPTY_TURN_USAGE_ANCHORS;
+    memoryProvenanceAnchors = EMPTY_MEMORY_PROVENANCE_ANCHORS;
+    memoryAttributionAnchors = EMPTY_MEMORY_ATTRIBUTION_ANCHORS;
+    anchoredResumptions = new Set();
+    anchoredFailedRuns = new Set();
+    anchoredDeliveryRuns = new Set();
+    recordResumeAnchor(runId, messageId, markerValue, markerTimestamp) {
+        const attempt = _wireCounterOf(markerValue, "attempt");
+        const carriesRound = typeof markerValue === "object" &&
+            markerValue !== null &&
+            typeof markerValue.round === "number";
+        const key = carriesRound
+            ? `${runId ?? "unknown-run"}#${String(_wireCounterOf(markerValue, "round"))}#${String(attempt)}`
+            : `${runId ?? "unknown-run"}#legacy:${markerTimestamp === null ? "untimed" : String(markerTimestamp)}#${String(attempt)}`;
+        if (this.anchoredResumptions.has(key)) {
+            return false;
+        }
+        this.anchoredResumptions.add(key);
+        this.resumeAnchors.set(messageId, markerValue ?? null);
+        return true;
+    }
+    recordTurnFailedReceipts(failedRunId, messageId, position, receipts) {
+        if (this.anchoredFailedRuns.has(failedRunId)) {
+            return false;
+        }
+        this.anchoredFailedRuns.add(failedRunId);
+        this.turnFailedAnchors = withTurnFailedAnchored(this.turnFailedAnchors, messageId, position, receipts);
+        return true;
+    }
+    recordSubagentDelivery(deliveryRunId, messageId, results) {
+        if (this.anchoredDeliveryRuns.has(deliveryRunId)) {
+            return false;
+        }
+        this.anchoredDeliveryRuns.add(deliveryRunId);
+        this.subagentDeliveryAnchors = withSubagentDeliveryAnchored(this.subagentDeliveryAnchors, messageId, results);
+        return true;
+    }
+    recordToolError(toolCallId, errorText) {
+        this.toolErrorAnchors = withToolErrorAnchored(this.toolErrorAnchors, toolCallId, errorText);
+    }
+    recordToolRefusal(toolCallId, sentence) {
+        this.toolRefusalAnchors = withToolRefusalAnchored(this.toolRefusalAnchors, toolCallId, sentence);
+    }
+    recordToolCancel(toolCallId) {
+        this.toolCancelAnchors = withToolCancelAnchored(this.toolCancelAnchors, toolCallId);
+    }
+    recordToolDecision(toolCallId) {
+        this.toolDecisionAnchors = withToolDecisionAnchored(this.toolDecisionAnchors, toolCallId);
+    }
+    recordToolDenialMarker(marker) {
+        this.toolDenialLedger = withToolDenialMarkerFolded(this.toolDenialLedger, marker);
+    }
+    recordToolOffload(toolCallId) {
+        this.toolOffloadAnchors = withToolOffloadAnchored(this.toolOffloadAnchors, toolCallId);
+    }
+    recordToolCallDisplay(toolCallId, display) {
+        this.toolCallDisplayAnchors = withToolCallDisplayAnchored(this.toolCallDisplayAnchors, toolCallId, display);
+    }
+    recordToolSchemas(toolCallId, schemas) {
+        this.toolSchemaAnchors = withToolSchemasAnchored(this.toolSchemaAnchors, toolCallId, schemas);
+    }
+    recordBlockTiming(blockId, observedAtMs) {
+        if (foldBlockTimingObserved(this._blockTimingAnchors, blockId, observedAtMs)) {
+            this.blockTimingRevision += 1;
+        }
+    }
+    recordTurnUsage(usage) {
+        this.turnUsageAnchors = withTurnUsageAnchored(this.turnUsageAnchors, usage);
+    }
+    recordMemoryUpdate(update) {
+        this.memoryProvenanceAnchors = withMemoryUpdateAnchored(this.memoryProvenanceAnchors, update);
+    }
+    recordMemoryAttribution(memoryId, messageId) {
+        this.memoryAttributionAnchors = withMemoryAttributed(this.memoryAttributionAnchors, memoryId, messageId);
+    }
+    recordPair(afterId, messages) {
+        this.snapshot = { afterId, messages: structuredClone([...messages]) };
+    }
+}
+function _wireCounterOf(payload, field) {
+    if (typeof payload !== "object" || payload === null) {
+        return 0;
+    }
+    const value = payload[field];
+    return typeof value === "number" ? value : 0;
+}
+export function resumeMarkerRecorder(onResumeAnchored) {
+    let pendingMarker = null;
+    let currentRunId = null;
+    return {
+        onRunStartedEvent({ event }) {
+            currentRunId = event.runId;
+        },
+        onCustomEvent({ event }) {
+            if (event.name === RUN_RESUMED_EVENT_NAME) {
+                pendingMarker = {
+                    runId: currentRunId,
+                    value: event.value,
+                    timestamp: typeof event.timestamp === "number" ? event.timestamp : null,
+                };
+            }
+        },
+        onMessagesChanged({ messages }) {
+            const newestMessage = messages.at(-1);
+            if (pendingMarker === null || newestMessage === undefined) {
+                return;
+            }
+            const marker = pendingMarker;
+            pendingMarker = null;
+            onResumeAnchored(marker.runId, newestMessage.id, marker.value, marker.timestamp);
+        },
+    };
+}
+export function resumeSnapshotRecorder(cursorOf, store) {
+    let failed = false;
+    const openBlocks = new Set();
+    return {
+        onRunInitialized() {
+            failed = false;
+            openBlocks.clear();
+        },
+        onEvent({ event }) {
+            const edge = _blockEdgeOf(event);
+            if (edge === null) {
+                return;
+            }
+            if (edge.opens) {
+                openBlocks.add(edge.key);
+            }
+            else {
+                openBlocks.delete(edge.key);
+            }
+        },
+        onRunFailed() {
+            failed = true;
+        },
+        onRunFinalized({ messages }) {
+            const cursor = cursorOf();
+            if (!failed && openBlocks.size === 0 && cursor !== null) {
+                store.recordPair(cursor, messages);
+            }
+        },
+    };
+}
+function _blockEdgeOf(event) {
+    const messageKey = () => `message:${event.messageId}`;
+    const toolKey = () => `tool:${event.toolCallId}`;
+    switch (event.type) {
+        case EventType.TEXT_MESSAGE_START:
+            return { key: messageKey(), opens: true };
+        case EventType.TEXT_MESSAGE_END:
+            return { key: messageKey(), opens: false };
+        case EventType.TOOL_CALL_START:
+            return { key: toolKey(), opens: true };
+        case EventType.TOOL_CALL_END:
+            return { key: toolKey(), opens: false };
+        case EventType.REASONING_START:
+            return { key: `reasoning:${messageKey()}`, opens: true };
+        case EventType.REASONING_END:
+            return { key: `reasoning:${messageKey()}`, opens: false };
+        case EventType.REASONING_MESSAGE_START:
+            return { key: `reasoning-message:${messageKey()}`, opens: true };
+        case EventType.REASONING_MESSAGE_END:
+            return { key: `reasoning-message:${messageKey()}`, opens: false };
+        default:
+            return null;
+    }
+}
+const DECIMAL_ID = /^\d+$/;
+export class SseFrameIdScanner {
+    lastEventId = null;
+    bodyBytesSeen = false;
+    buffer = "";
+    pendingId = null;
+    frameHasData = false;
+    decoder = new TextDecoder();
+    wrap(fetchFn) {
+        return async (url, requestInit) => {
+            const response = await fetchFn(url, requestInit);
+            if (!response.ok || response.body === null || !_isEventStream(response)) {
+                return response;
+            }
+            this._resetConnectionState();
+            return new Response(this._scannedCopyOf(response.body), {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
+        };
+    }
+    _scannedCopyOf(body) {
+        const reader = body.getReader();
+        return new ReadableStream({
+            pull: async (controller) => {
+                const { done, value } = await reader.read();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                this._scan(value);
+                controller.enqueue(value);
+            },
+            cancel: (reason) => reader.cancel(reason).catch(() => undefined),
+        });
+    }
+    _resetConnectionState() {
+        this.buffer = "";
+        this.pendingId = null;
+        this.frameHasData = false;
+        this.bodyBytesSeen = false;
+        this.decoder = new TextDecoder();
+    }
+    _scan(chunk) {
+        this.bodyBytesSeen = true;
+        this.buffer += this.decoder.decode(chunk, { stream: true });
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            this._scanLine(line);
+        }
+    }
+    _scanLine(line) {
+        if (line === "") {
+            if (this.pendingId !== null && this.frameHasData) {
+                this.lastEventId = this.pendingId;
+            }
+            this.pendingId = null;
+            this.frameHasData = false;
+            return;
+        }
+        if (line.startsWith("id:")) {
+            const value = line.slice("id:".length).replace(/^ /, "");
+            this.pendingId = DECIMAL_ID.test(value) ? value : null;
+        }
+        else if (line.startsWith("data:")) {
+            this.frameHasData = true;
+        }
+    }
+}
+function _isEventStream(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    return contentType.startsWith("text/event-stream");
+}