@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/composer-input-state.js

@@ -0,0 +1,40 @@
+import { publishStore } from "./conversation-publish.js";
+export function setModelPickFromStore(store, pick) {
+    store._modelPick = pick;
+    store._modelPickDirty = true;
+    publishStore(store);
+}
+export function setComposerDraftFromStore(store, next) {
+    const current = store._composerInput.get();
+    store._composerInput.set({
+        ...current,
+        draft: typeof next === "function" ? next(current.draft) : next,
+    });
+}
+export function setComposerAttachmentsFromStore(store, next) {
+    const current = store._composerInput.get();
+    store._composerInput.set({
+        ...current,
+        attachments: typeof next === "function" ? next(current.attachments) : next,
+    });
+}
+export function resetComposerInput(store, threadId) {
+    store._composerCaretReturnPending = null;
+    store._composerInput.set({
+        scope: threadId !== null
+            ? `t:${threadId}`
+            : `u:${String(store._nextUnboundScope++)}`,
+        draft: "",
+        attachments: [],
+    });
+}
+export function noteComposerFocusFromStore(store, owner) {
+    store._composerFocusOwned = owner;
+}
+export function takeComposerCaretReturnFromStore(store, surface) {
+    if (store._composerCaretReturnPending !== surface) {
+        return false;
+    }
+    store._composerCaretReturnPending = null;
+    return true;
+}

package/dist/core/composer-policy.d.ts

@@ -0,0 +1,38 @@
+import { type ServingAttachment } from "../contract/threads.js";
+import type { AttachmentKind } from "../generated/models/index.js";
+export declare const CHARACTER_COUNT_VISIBLE_FROM: number;
+export interface AttachmentDraft<A = ServingAttachment> {
+    localId: number;
+    filename: string;
+    byteSize: number;
+    status: "uploading" | "ready" | "failed";
+    attachment?: A;
+    error?: string;
+}
+export declare function mintAttachmentDraftId(): number;
+export declare function attachmentDraftFailed(item: {
+    status: AttachmentDraft["status"];
+}): boolean;
+export declare function capSlotsSpentBy(attachments: readonly {
+    status: AttachmentDraft["status"];
+}[]): number;
+export declare function pickCapOf(file: File, caps: Readonly<Partial<Record<AttachmentKind, number>>>): {
+    bytes: number;
+    label: string;
+};
+export interface ComposerKeyEvent {
+    key: string;
+    shiftKey: boolean;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+}
+export declare function composerKeyHandlersOf(input: {
+    busy: boolean;
+    pendingSend: boolean;
+    stopping: boolean;
+    stopTurn: () => void | Promise<void>;
+    submit: () => void | Promise<void>;
+}): {
+    stopOnEscape: (event: ComposerKeyEvent) => void;
+    composerKeys: (event: ComposerKeyEvent) => void;
+};

package/dist/core/composer-policy.js

@@ -0,0 +1,56 @@
+import { ASSISTANT_MESSAGE_MAX_CHARS, } from "../contract/threads.js";
+export const CHARACTER_COUNT_VISIBLE_FROM = ASSISTANT_MESSAGE_MAX_CHARS - 400;
+let nextDraftId = 1;
+export function mintAttachmentDraftId() {
+    return nextDraftId++;
+}
+export function attachmentDraftFailed(item) {
+    return item.status === "failed";
+}
+export function capSlotsSpentBy(attachments) {
+    return attachments.filter((item) => !attachmentDraftFailed(item)).length;
+}
+export function pickCapOf(file, caps) {
+    const type = file.type;
+    if (type.startsWith("image/") && caps.image !== undefined) {
+        return { bytes: caps.image, label: "an image" };
+    }
+    if ((type === "application/pdf" || type.startsWith("text/")) &&
+        caps.document !== undefined) {
+        return { bytes: caps.document, label: "a document" };
+    }
+    if (type.startsWith("video/") && caps.video !== undefined) {
+        return { bytes: caps.video, label: "a video" };
+    }
+    if (type.startsWith("audio/") && caps.audio !== undefined) {
+        return { bytes: caps.audio, label: "an audio file" };
+    }
+    return {
+        bytes: Math.max(...Object.values(caps)),
+        label: "a file",
+    };
+}
+export function composerKeyHandlersOf(input) {
+    const { busy, pendingSend, stopping, stopTurn, submit } = input;
+    function submitOnEnter(event) {
+        if (event.key === "Enter" && !event.shiftKey) {
+            event.preventDefault();
+            void submit();
+        }
+    }
+    function stopOnEscape(event) {
+        if (event.key !== "Escape" || !busy || pendingSend || stopping) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        void stopTurn();
+    }
+    return {
+        stopOnEscape,
+        composerKeys(event) {
+            stopOnEscape(event);
+            submitOnEnter(event);
+        },
+    };
+}

package/dist/core/connect-gate.d.ts

@@ -0,0 +1,21 @@
+import type { ConnectProjectionResponse, SubscriptionProvider } from "../generated/models/index.js";
+type ConnectGateReason = "taster_exhausted" | "auth_bounced";
+export type ConversationGate = {
+    kind: "none";
+} | {
+    kind: "sign_in";
+} | {
+    kind: "connect";
+    reason: ConnectGateReason;
+    providers: SubscriptionProvider[];
+} | {
+    kind: "wait";
+    retryAtMs: number | null;
+} | {
+    kind: "verifying";
+};
+export declare const NO_GATE: ConversationGate;
+export declare function gatesEqual(a: ConversationGate, b: ConversationGate): boolean;
+export declare function gateOfProjection(connect: ConnectProjectionResponse | undefined): ConversationGate;
+export declare function gateOfRefusal(error: unknown): ConversationGate | null;
+export {};

package/dist/core/connect-gate.js

@@ -0,0 +1,85 @@
+import { ServingApiError } from "../transport/serving-error.js";
+export const NO_GATE = { kind: "none" };
+export function gatesEqual(a, b) {
+    if (a.kind !== b.kind) {
+        return false;
+    }
+    if (a.kind === "connect" && b.kind === "connect") {
+        return (a.reason === b.reason && a.providers.join(" ") === b.providers.join(" "));
+    }
+    if (a.kind === "wait" && b.kind === "wait") {
+        return a.retryAtMs === b.retryAtMs;
+    }
+    return true;
+}
+export function gateOfProjection(connect) {
+    if (connect === undefined) {
+        return NO_GATE;
+    }
+    switch (connect.gate) {
+        case "sign_in":
+            return { kind: "sign_in" };
+        case "connect":
+            return {
+                kind: "connect",
+                reason: _reasonOf(connect.reason),
+                providers: connect.providers,
+            };
+        case "wait":
+            return { kind: "wait", retryAtMs: _retryAtMsOf(connect) };
+        case "verifying":
+            return { kind: "verifying" };
+        default:
+            return NO_GATE;
+    }
+}
+export function gateOfRefusal(error) {
+    if (!(error instanceof ServingApiError)) {
+        return null;
+    }
+    if (error.code === "ASSISTANT_SIGN_IN_REQUIRED") {
+        return { kind: "sign_in" };
+    }
+    if (error.code === "SUBSCRIPTION_CONNECT_REQUIRED") {
+        const details = _connectDetailsOf(error);
+        return {
+            kind: "connect",
+            reason: _reasonOf(details.reason),
+            providers: details.providers,
+        };
+    }
+    if (error.code === "SUBSCRIPTION_CANNOT_PAY") {
+        if (error.retryAfterSeconds !== null) {
+            return {
+                kind: "wait",
+                retryAtMs: Date.now() + error.retryAfterSeconds * 1000,
+            };
+        }
+        return { kind: "verifying" };
+    }
+    return null;
+}
+function _connectDetailsOf(error) {
+    const details = error.details;
+    if (typeof details !== "object" || details === null) {
+        return { reason: null, providers: [] };
+    }
+    const reason = "reason" in details ? details.reason : null;
+    const named = "providers" in details ? details.providers : null;
+    const providers = Array.isArray(named)
+        ? named.filter((value) => _isAKnownProvider(value))
+        : [];
+    return { reason: typeof reason === "string" ? reason : null, providers };
+}
+function _isAKnownProvider(value) {
+    return value === "openai_chatgpt";
+}
+function _reasonOf(reason) {
+    return reason === "taster_exhausted" ? "taster_exhausted" : "auth_bounced";
+}
+function _retryAtMsOf(connect) {
+    if (connect.retry_after_seconds === null) {
+        return null;
+    }
+    return Date.now() + connect.retry_after_seconds * 1000;
+}

package/dist/core/connection-driver.d.ts

@@ -0,0 +1,3 @@
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function turnHoldsAStream(store: AssistantConversationStore): boolean;
+export declare function syncConnection(store: AssistantConversationStore): void;

package/dist/core/connection-driver.js

@@ -0,0 +1,106 @@
+import { settlesFor } from "./conversation-refresh.js";
+import { publishStore, scheduleConnectionSync, } from "./conversation-publish.js";
+const CONNECTION_ENDED_REFRESH_BOUND_MS = 8_000;
+const MAX_AUTOMATIC_RECONNECTS = 5;
+export function turnHoldsAStream(store) {
+    const status = store._newestTurn?.status;
+    return status === "queued" || status === "working";
+}
+function _connectWanted(store) {
+    if (store._leaseHolders.length > 0) {
+        return !store._epochConnectedOnce || turnHoldsAStream(store);
+    }
+    return turnHoldsAStream(store);
+}
+export function syncConnection(store) {
+    if (store._disposed ||
+        store._connectionRunning ||
+        store._epoch === null ||
+        !_connectWanted(store) ||
+        store._automaticReconnects >= MAX_AUTOMATIC_RECONNECTS) {
+        return;
+    }
+    if (store._epochConnectedOnce) {
+        _remintForBackgroundAttach(store);
+        return;
+    }
+    const epoch = store._epoch;
+    const turnBefore = store._newestTurn;
+    store._connectionRunning = true;
+    store._epochConnectedOnce = true;
+    epoch.agent
+        .connectAgent()
+        .catch(() => undefined)
+        .then(() => _connectionEnded(store, epoch, turnBefore))
+        .catch(() => undefined);
+}
+function _remintForBackgroundAttach(store) {
+    store._streamInterrupted = false;
+    store._backgroundAttachNonce += 1;
+    publishStore(store);
+}
+async function _connectionEnded(store, epoch, turnBefore) {
+    let refreshSettled = false;
+    try {
+        if (_connectionDecisionMoot(store, epoch)) {
+            return;
+        }
+        refreshSettled = await Promise.race([
+            store.refreshConversation().then(() => true),
+            settlesFor(CONNECTION_ENDED_REFRESH_BOUND_MS).then(() => false),
+        ]);
+    }
+    finally {
+        store._connectionRunning = false;
+        if (_connectionDecisionMoot(store, epoch)) {
+            scheduleConnectionSync(store);
+        }
+    }
+    if (_connectionDecisionMoot(store, epoch)) {
+        return;
+    }
+    if (!refreshSettled) {
+        _judgeBoundedOut(store);
+        return;
+    }
+    _judgeStreamEnd(store, turnBefore);
+}
+function _judgeBoundedOut(store) {
+    store._automaticReconnects += 1;
+    if (store._automaticReconnects >= MAX_AUTOMATIC_RECONNECTS) {
+        store._streamInterrupted = true;
+        publishStore(store);
+        return;
+    }
+    scheduleConnectionSync(store);
+}
+function _judgeStreamEnd(store, turnBefore) {
+    if (!turnHoldsAStream(store)) {
+        store._automaticReconnects = 0;
+        publishStore(store);
+        return;
+    }
+    if (store._newestTurn?.id !== turnBefore?.id) {
+        publishStore(store);
+        return;
+    }
+    _reconnectAfterDeath(store, turnBefore);
+}
+function _reconnectAfterDeath(store, turnBefore) {
+    const progressed = store._newestTurn?.updated_at !== turnBefore?.updated_at ||
+        store._newestTurn?.status !== turnBefore?.status;
+    store._automaticReconnects = progressed ? 1 : store._automaticReconnects + 1;
+    if (store._automaticReconnects >= MAX_AUTOMATIC_RECONNECTS) {
+        store._streamInterrupted = true;
+        publishStore(store);
+        return;
+    }
+    store._reconnectNonce += 1;
+    if (store._composerFocusOwned !== null) {
+        store._composerCaretReturnPending = store._composerFocusOwned;
+    }
+    publishStore(store);
+}
+function _connectionDecisionMoot(store, epoch) {
+    return store._disposed || store._epoch !== epoch;
+}

package/dist/core/connection-epoch.d.ts

@@ -0,0 +1,65 @@
+import type { Message } from "@ag-ui/core";
+import { ServingReplayStreamAgent } from "../transport/replay-stream-agent.js";
+import { type StreamResumeStore } from "../transport/stream-resume.js";
+import type { TokenSession } from "../transport/token-session.js";
+import { type ApprovalInbox, type ApprovalCardModel } from "./approval-inbox.js";
+import type { ExecutionHandler } from "./execution-handlers.js";
+import { ExecutionInbox, type ExecutionEntryModel } from "./execution-inbox.js";
+import { type MemoryUpdated } from "./memory-provenance-anchors.js";
+import type { BlockTiming } from "./segment-timing.js";
+import { type DeliveredResult } from "./subagent-delivery-anchors.js";
+import type { ToolCallDisplay } from "./tool-call-display.js";
+import { type ToolCallSchemas } from "./tool-schema-anchors.js";
+import { type AnchoredTurnFailReceipts } from "./turn-failed-anchors.js";
+import { type TurnUsage } from "./turn-usage-anchors.js";
+import { type UserTurnLedger } from "./user-turn-ledger.js";
+export interface MarkerAnchorsSnapshot {
+    resumeAnchors: ReadonlyMap<string, unknown>;
+    turnFailedAnchors: ReadonlyMap<string, AnchoredTurnFailReceipts>;
+    subagentDeliveryAnchors: ReadonlyMap<string, DeliveredResult[]>;
+    toolErrorAnchors: ReadonlyMap<string, string>;
+    toolCancelAnchors: ReadonlySet<string>;
+    toolRefusalAnchors: ReadonlyMap<string, string>;
+    toolOffloadAnchors: ReadonlySet<string>;
+    toolDecisionAnchors?: ReadonlySet<string>;
+    toolDenialAnchors?: ReadonlySet<string>;
+    toolCallDisplayAnchors: ReadonlyMap<string, ToolCallDisplay>;
+    toolSchemaAnchors: ReadonlyMap<string, ToolCallSchemas>;
+    blockTimingAnchors: ReadonlyMap<string, BlockTiming>;
+    turnUsageAnchors: ReadonlyMap<string, TurnUsage>;
+    memoryProvenanceAnchors: ReadonlyMap<string, MemoryUpdated>;
+    memoryAttributionAnchors: ReadonlyMap<string, string>;
+}
+export declare function markerAnchorsOf(resume: StreamResumeStore): MarkerAnchorsSnapshot;
+export interface ConnectionEpochDeps {
+    epochId: number;
+    session: TokenSession;
+    threadId: string;
+    streamThreadId: string;
+    ledger: UserTurnLedger;
+    resume: StreamResumeStore;
+    handlersOf: () => ReadonlyMap<string, ExecutionHandler>;
+    approvalInbox: ApprovalInbox;
+    publishApprovalCards: (cards: readonly ApprovalCardModel[]) => void;
+    publishExecutionEntries: (entries: readonly ExecutionEntryModel[]) => void;
+    publishMarkerAnchors: () => void;
+    publishMessages: (messages: readonly Message[]) => void;
+    noteInterruptAnswerConsumed: (runId: string, interruptId: string, round: number) => void;
+    onStreamError: (error: Error) => void;
+    refreshLedger: () => Promise<void>;
+    onUserMessageInjected: (messageId: string) => void;
+    onRunSettled: () => void;
+    onQuietClose: (stillStreaming: () => boolean) => void;
+    onWorkflowRestarted: () => void;
+}
+export interface ConnectionEpoch {
+    epochId: number;
+    agent: ServingReplayStreamAgent;
+    approvalInbox: ApprovalInbox;
+    executionInbox: ExecutionInbox;
+    threadId: string;
+    streamThreadId: string;
+    withExecutionInbox: (mutate: (inbox: ExecutionInbox) => boolean) => void;
+    dispose: () => void;
+}
+export declare function beginConnectionEpoch(deps: ConnectionEpochDeps): ConnectionEpoch;

package/dist/core/connection-epoch.js

@@ -0,0 +1,232 @@
+import { ServingReplayStreamAgent } from "../transport/replay-stream-agent.js";
+import { getAssistantThread, resolveTurnToolResults, streamUrlForThread, } from "../transport/serving-api.js";
+import { resumeMarkerRecorder, resumeSnapshotRecorder, } from "../transport/stream-resume.js";
+import { approvalInboxRecorder, } from "./approval-inbox.js";
+import { blockTimingRecorder, wellFormedBlockTimingAnchorsOf, } from "./block-timing-anchors.js";
+import { consumedInterruptRecorder } from "./consumed-interrupts.js";
+import { ExecutionDriver } from "./execution-driver.js";
+import { executionInboxRecorder, ExecutionInbox, } from "./execution-inbox.js";
+import { memoryUpdatedRecorder, wellFormedMemoryAttributionAnchorsOf, wellFormedMemoryProvenanceAnchorsOf, } from "./memory-provenance-anchors.js";
+import { subagentDeliveryMarkerRecorder, wellFormedDeliveryAnchorsOf, } from "./subagent-delivery-anchors.js";
+import { toolCallDisplayRecorder, wellFormedToolCallDisplayAnchorsOf, } from "./tool-call-display-anchors.js";
+import { toolSchemaRecorder, wellFormedToolSchemaAnchorsOf, } from "./tool-schema-anchors.js";
+import { toolCancelRecorder, wellFormedToolCancelAnchorsOf, } from "./tool-cancel-anchors.js";
+import { toolErrorRecorder, wellFormedToolErrorAnchorsOf, } from "./tool-error-anchors.js";
+import { toolDecisionRecorder, wellFormedToolDecisionAnchorsOf, } from "./tool-decision-anchors.js";
+import { toolDenialRecorder, wellFormedToolDenialAnchorsOf, } from "./tool-denial-anchors.js";
+import { toolOffloadRecorder, wellFormedToolOffloadAnchorsOf, } from "./tool-offload-anchors.js";
+import { toolRefusalRecorder, wellFormedToolRefusalAnchorsOf, } from "./tool-refusal-anchors.js";
+import { turnFailedMarkerRecorder, wellFormedFailAnchorsOf, } from "./turn-failed-anchors.js";
+import { turnUsageRecorder, wellFormedTurnUsageAnchorsOf, } from "./turn-usage-anchors.js";
+import { messagesRecorder, streamErrorRecorder } from "./messages-cell.js";
+import { userTurnInjector } from "./user-turn-ledger.js";
+export function markerAnchorsOf(resume) {
+    return {
+        resumeAnchors: new Map(resume.resumeAnchors),
+        turnFailedAnchors: wellFormedFailAnchorsOf(resume.turnFailedAnchors),
+        subagentDeliveryAnchors: wellFormedDeliveryAnchorsOf(resume.subagentDeliveryAnchors),
+        toolErrorAnchors: wellFormedToolErrorAnchorsOf(resume.toolErrorAnchors),
+        toolCancelAnchors: wellFormedToolCancelAnchorsOf(resume.toolCancelAnchors),
+        toolRefusalAnchors: wellFormedToolRefusalAnchorsOf(resume.toolRefusalAnchors),
+        toolOffloadAnchors: wellFormedToolOffloadAnchorsOf(resume.toolOffloadAnchors),
+        toolDecisionAnchors: wellFormedToolDecisionAnchorsOf(resume.toolDecisionAnchors),
+        toolDenialAnchors: wellFormedToolDenialAnchorsOf(resume.toolDenialLedger.denied),
+        toolCallDisplayAnchors: wellFormedToolCallDisplayAnchorsOf(resume.toolCallDisplayAnchors),
+        toolSchemaAnchors: wellFormedToolSchemaAnchorsOf(resume.toolSchemaAnchors),
+        blockTimingAnchors: wellFormedBlockTimingAnchorsOf(resume.blockTimingAnchors),
+        turnUsageAnchors: wellFormedTurnUsageAnchorsOf(resume.turnUsageAnchors),
+        memoryProvenanceAnchors: wellFormedMemoryProvenanceAnchorsOf(resume.memoryProvenanceAnchors),
+        memoryAttributionAnchors: wellFormedMemoryAttributionAnchorsOf(resume.memoryAttributionAnchors),
+    };
+}
+export function beginConnectionEpoch(deps) {
+    const agent = new ServingReplayStreamAgent({
+        streamUrl: streamUrlForThread(deps.session, deps.threadId),
+        streamThreadId: deps.streamThreadId,
+        authorizedFetch: deps.session.authorizedFetch,
+        resume: deps.resume,
+    });
+    const approvalInbox = deps.approvalInbox;
+    const executionInbox = new ExecutionInbox();
+    const publishEntries = (entries) => {
+        driver.noteEntriesChanged(entries);
+        deps.publishExecutionEntries(entries);
+    };
+    const driver = new ExecutionDriver({
+        inbox: executionInbox,
+        threadId: deps.threadId,
+        handlersOf: deps.handlersOf,
+        fetchThreadDetail: () => getAssistantThread(deps.session, deps.threadId),
+        postResults: (turnId, request) => resolveTurnToolResults(deps.session, deps.threadId, turnId, request),
+        publishEntries,
+        onWorkflowRestarted: deps.onWorkflowRestarted,
+    });
+    const subscriptions = [
+        ..._runMarkerSubscriptionsOf(agent, deps),
+        ..._toolMarkerSubscriptionsOf(agent, deps),
+        ..._timingAndMemoryMarkerSubscriptionsOf(agent, deps),
+        ..._streamStateSubscriptionsOf(agent, deps, {
+            approvalInbox,
+            executionInbox,
+            publishEntries,
+        }),
+    ];
+    return {
+        epochId: deps.epochId,
+        agent,
+        approvalInbox,
+        executionInbox,
+        threadId: deps.threadId,
+        streamThreadId: deps.streamThreadId,
+        withExecutionInbox: (mutate) => {
+            if (mutate(executionInbox)) {
+                publishEntries(executionInbox.entries());
+            }
+        },
+        dispose: () => {
+            for (const subscription of subscriptions) {
+                subscription.unsubscribe();
+            }
+            driver.dispose();
+            void agent.detachActiveRun().catch(() => undefined);
+        },
+    };
+}
+function _runMarkerSubscriptionsOf(agent, deps) {
+    return [
+        agent.subscribe(resumeMarkerRecorder((runId, messageId, markerValue, markerTimestamp) => {
+            if (deps.resume.recordResumeAnchor(runId, messageId, markerValue, markerTimestamp)) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(consumedInterruptRecorder((runId, consumed) => {
+            deps.noteInterruptAnswerConsumed(runId, consumed.interruptId, consumed.round);
+        })),
+        agent.subscribe(turnFailedMarkerRecorder((failedRunId, messageId, position, receipts) => {
+            if (deps.resume.recordTurnFailedReceipts(failedRunId, messageId, position, receipts)) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(subagentDeliveryMarkerRecorder((deliveryRunId, messageId, results) => {
+            if (deps.resume.recordSubagentDelivery(deliveryRunId, messageId, results)) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+    ];
+}
+function _toolMarkerSubscriptionsOf(agent, deps) {
+    return [
+        agent.subscribe(toolErrorRecorder((toolCallId, errorText) => {
+            const before = deps.resume.toolErrorAnchors;
+            deps.resume.recordToolError(toolCallId, errorText);
+            if (deps.resume.toolErrorAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(toolRefusalRecorder((toolCallId, sentence) => {
+            const before = deps.resume.toolRefusalAnchors;
+            deps.resume.recordToolRefusal(toolCallId, sentence);
+            if (deps.resume.toolRefusalAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(toolCancelRecorder((toolCallId) => {
+            const before = deps.resume.toolCancelAnchors;
+            deps.resume.recordToolCancel(toolCallId);
+            if (deps.resume.toolCancelAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(toolDecisionRecorder((toolCallId) => {
+            const before = deps.resume.toolDecisionAnchors;
+            deps.resume.recordToolDecision(toolCallId);
+            if (deps.resume.toolDecisionAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(toolDenialRecorder((marker) => {
+            const before = deps.resume.toolDenialLedger.denied;
+            deps.resume.recordToolDenialMarker(marker);
+            if (deps.resume.toolDenialLedger.denied !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(toolOffloadRecorder((toolCallId) => {
+            const before = deps.resume.toolOffloadAnchors;
+            deps.resume.recordToolOffload(toolCallId);
+            if (deps.resume.toolOffloadAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(toolCallDisplayRecorder((toolCallId, display) => {
+            const before = deps.resume.toolCallDisplayAnchors;
+            deps.resume.recordToolCallDisplay(toolCallId, display);
+            if (deps.resume.toolCallDisplayAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(toolSchemaRecorder((toolCallId, schemas) => {
+            const before = deps.resume.toolSchemaAnchors;
+            deps.resume.recordToolSchemas(toolCallId, schemas);
+            if (deps.resume.toolSchemaAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+    ];
+}
+function _timingAndMemoryMarkerSubscriptionsOf(agent, deps) {
+    let timingPublishQueued = false;
+    return [
+        agent.subscribe(blockTimingRecorder((blockId, observedAtMs) => {
+            const before = deps.resume.blockTimingRevision;
+            deps.resume.recordBlockTiming(blockId, observedAtMs);
+            if (deps.resume.blockTimingRevision === before || timingPublishQueued) {
+                return;
+            }
+            timingPublishQueued = true;
+            setTimeout(() => {
+                timingPublishQueued = false;
+                deps.publishMarkerAnchors();
+            }, 0);
+        })),
+        agent.subscribe(turnUsageRecorder((usage) => {
+            const before = deps.resume.turnUsageAnchors;
+            deps.resume.recordTurnUsage(usage);
+            if (deps.resume.turnUsageAnchors !== before) {
+                deps.publishMarkerAnchors();
+            }
+        })),
+        agent.subscribe(memoryUpdatedRecorder({
+            onMemoryAnchored: (update) => {
+                const before = deps.resume.memoryProvenanceAnchors;
+                deps.resume.recordMemoryUpdate(update);
+                if (deps.resume.memoryProvenanceAnchors !== before) {
+                    deps.publishMarkerAnchors();
+                }
+            },
+            onMemoryAttributed: (memoryId, messageId) => {
+                const before = deps.resume.memoryAttributionAnchors;
+                deps.resume.recordMemoryAttribution(memoryId, messageId);
+                if (deps.resume.memoryAttributionAnchors !== before) {
+                    deps.publishMarkerAnchors();
+                }
+            },
+        })),
+    ];
+}
+function _streamStateSubscriptionsOf(agent, deps, inboxes) {
+    return [
+        agent.subscribe(resumeSnapshotRecorder(() => agent.resumeCursor, deps.resume)),
+        agent.subscribe(userTurnInjector(deps.ledger, {
+            refreshLedger: deps.refreshLedger,
+            onUserMessageInjected: deps.onUserMessageInjected,
+            onRunSettled: deps.onRunSettled,
+        })),
+        agent.subscribe(approvalInboxRecorder(inboxes.approvalInbox, deps.publishApprovalCards, () => {
+            deps.onQuietClose(() => agent.isRunning);
+        })),
+        agent.subscribe(executionInboxRecorder(inboxes.executionInbox, inboxes.publishEntries)),
+        agent.subscribe(messagesRecorder(deps.publishMessages)),
+        agent.subscribe(streamErrorRecorder(deps.onStreamError)),
+    ];
+}

package/dist/core/consumed-interrupts.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+export interface ConsumedInterrupt {
+    interruptId: string;
+    round: number;
+}
+export declare function interruptAnswerConsumedPayloadOf(value: unknown): ConsumedInterrupt | null;
+export declare function consumedInterruptRecorder(onConsumed: (runId: string, consumed: ConsumedInterrupt) => void): AgentSubscriber;
+export declare class ConsumedInterruptFold {
+    private readonly byRun;
+    note(runId: string, interruptId: string, round: number): boolean;
+    idsOf(runId: string | null | undefined, awaitingRound: number | null | undefined): ReadonlySet<string>;
+}