@teaflask/assistant 0.3.0 → 0.6.0

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

@@ -26,18 +26,6 @@ export interface ComposerKeyEvent {
     preventDefault: () => void;
     stopPropagation: () => void;
 }
-/**
- * The composer's two keyboard verbs, bound as composerKeys on the textarea
- * and stopOnEscape on the stop button. Enter submits (Shift+Enter is a
- * newline). Escape while the assistant is answering is the stop shortcut,
- * claimed ONLY when stopTurn can actually act: the two windows
- * where it no-ops pass through unclaimed — the message POST (pendingSend,
- * the store's truth, not a component's sending mirror; no turn exists to
- * stop yet) and the "Stopping…" beat itself (the re-entry guard refuses a
- * second stop) — because a swallowed no-op Escape is how a palette,
- * drawer or pane gets wedged. Bound on the textarea and the stop button,
- * the two focus homes of a busy composer.
- */
 export declare function composerKeyHandlersOf(input: {
     busy: boolean;
     pendingSend: boolean;
@@ -48,4 +36,3 @@ export declare function composerKeyHandlersOf(input: {
     stopOnEscape: (event: ComposerKeyEvent) => void;
     composerKeys: (event: ComposerKeyEvent) => void;
 };
-//# sourceMappingURL=composer-policy.d.ts.map

package/dist/core/composer-policy.js

@@ -1,37 +1,15 @@
-// The composer's pure policy leaf, React-free and transport-free: the
-// members both composers — the package's slab and the dashboard
-// playground's — apply to a draft before anything is sent. One home
-// so the fork ledger has nothing to pin: the per-message
-// bounds are felt while typing, the cap slots count only drafts that
-// could still ride, the pick-time size check speaks the served kind's
-// cap, and Escape/Enter mean the same thing in every composer.
 import { ASSISTANT_MESSAGE_MAX_CHARS, } from "../contract/threads.js";
-// Show the countdown only once it starts to matter.
 export const CHARACTER_COUNT_VISIBLE_FROM = ASSISTANT_MESSAGE_MAX_CHARS - 400;
-// Chip ids are minted here, module-scoped, so they survive any composer
-// remount and never collide across the composers one page may mount.
 let nextDraftId = 1;
 export function mintAttachmentDraftId() {
     return nextDraftId++;
 }
-// The one reading of a draft's failed state: a refused pick or a failed
-// upload. Every surface asks this rather than comparing the word — the
-// dashboard's collapse-layer law keeps status literals out of its
-// components, and one predicate keeps the two composers agreeing on
-// what "failed" means.
 export function attachmentDraftFailed(item) {
     return item.status === "failed";
 }
-// What counts against the per-message cap: only drafts that could still
-// ride the message. A failed chip never sends, so it never spends a
-// slot — it holds visible ground until removed, nothing more.
 export function capSlotsSpentBy(attachments) {
     return attachments.filter((item) => !attachmentDraftFailed(item)).length;
 }
-// The pick-time size cap: the kind's own ceiling when the browser's
-// MIME type names one confidently and the caps serve that kind, else the
-// widest cap served — the pre-check must never be stricter than the
-// server's sniffed truth.
 export function pickCapOf(file, caps) {
     const type = file.type;
     if (type.startsWith("image/") && caps.image !== undefined) {
@@ -52,18 +30,6 @@ export function pickCapOf(file, caps) {
         label: "a file",
     };
 }
-/**
- * The composer's two keyboard verbs, bound as composerKeys on the textarea
- * and stopOnEscape on the stop button. Enter submits (Shift+Enter is a
- * newline). Escape while the assistant is answering is the stop shortcut,
- * claimed ONLY when stopTurn can actually act: the two windows
- * where it no-ops pass through unclaimed — the message POST (pendingSend,
- * the store's truth, not a component's sending mirror; no turn exists to
- * stop yet) and the "Stopping…" beat itself (the re-entry guard refuses a
- * second stop) — because a swallowed no-op Escape is how a palette,
- * drawer or pane gets wedged. Bound on the textarea and the stop button,
- * the two focus homes of a busy composer.
- */
 export function composerKeyHandlersOf(input) {
     const { busy, pendingSend, stopping, stopTurn, submit } = input;
     function submitOnEnter(event) {
@@ -88,4 +54,3 @@ export function composerKeyHandlersOf(input) {
         },
     };
 }
-//# sourceMappingURL=composer-policy.js.map

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

@@ -1,8 +1,4 @@
 import type { ConnectProjectionResponse, SubscriptionProvider } from "../generated/models/index.js";
-/** Why a connect gate is asking: the free preview ran out (a first
- *  connect) or a connected plan's credential died (a reconnect). The
- *  contract grows reasons additively; unknown values read as
- *  auth_bounced — the conservative ask. */
 type ConnectGateReason = "taster_exhausted" | "auth_bounced";
 export type ConversationGate = {
     kind: "none";
@@ -19,17 +15,7 @@ export type ConversationGate = {
     kind: "verifying";
 };
 export declare const NO_GATE: ConversationGate;
-/** Whether two gates say the same thing. The projection mints a fresh
- *  object every read, so the registry dedupes on substance before
- *  writing its cell — an unchanged gate must not notify (each notify
- *  re-renders every gate consumer, and a re-render storm under a
- *  4s re-read chain is how a bounded poll turns unbounded). */
 export declare function gatesEqual(a: ConversationGate, b: ConversationGate): boolean;
-/** The projection's gate, client-shaped. An unknown gate value reads as
- *  none — the contract's growth rule; the send door stays the truth. */
 export declare function gateOfProjection(connect: ConnectProjectionResponse | undefined): ConversationGate;
-/** A send refusal's gate, or null when the refusal is not a gate (a rate
- *  limit, a busy thread — the banner's story, not the composer's). */
 export declare function gateOfRefusal(error: unknown): ConversationGate | null;
 export {};
-//# sourceMappingURL=connect-gate.d.ts.map

package/dist/core/connect-gate.js

@@ -1,24 +1,10 @@
-// The conversation gate: what stands between this visitor
-// and their next send, as one client-side shape with two producers — the
-// assistant-config read's pre-flight projection (the gate is known before
-// anyone types) and a send refusal (the race window where the projection
-// was stale). ConversationView renders it in the composer's place; the
-// provider chip and the gate card are its readers.
 import { ServingApiError } from "../transport/serving-error.js";
 export const NO_GATE = { kind: "none" };
-/** Whether two gates say the same thing. The projection mints a fresh
- *  object every read, so the registry dedupes on substance before
- *  writing its cell — an unchanged gate must not notify (each notify
- *  re-renders every gate consumer, and a re-render storm under a
- *  4s re-read chain is how a bounded poll turns unbounded). */
 export function gatesEqual(a, b) {
     if (a.kind !== b.kind) {
         return false;
     }
     if (a.kind === "connect" && b.kind === "connect") {
-        // Joined, not compared elementwise: the provider union has one
-        // member today, and TS narrows an element comparison to
-        // always-true (the vocabulary grows additively).
         return (a.reason === b.reason && a.providers.join(" ") === b.providers.join(" "));
     }
     if (a.kind === "wait" && b.kind === "wait") {
@@ -26,8 +12,6 @@ export function gatesEqual(a, b) {
     }
     return true;
 }
-/** The projection's gate, client-shaped. An unknown gate value reads as
- *  none — the contract's growth rule; the send door stays the truth. */
 export function gateOfProjection(connect) {
     if (connect === undefined) {
         return NO_GATE;
@@ -49,8 +33,6 @@ export function gateOfProjection(connect) {
             return NO_GATE;
     }
 }
-/** A send refusal's gate, or null when the refusal is not a gate (a rate
- *  limit, a busy thread — the banner's story, not the composer's). */
 export function gateOfRefusal(error) {
     if (!(error instanceof ServingApiError)) {
         return null;
@@ -77,9 +59,6 @@ export function gateOfRefusal(error) {
     }
     return null;
 }
-/** The refusal envelope's structured half, read leniently: details is
- *  `unknown` on the wire by design, and a malformed shape must degrade
- *  to an empty ask, never throw under an error handler. */
 function _connectDetailsOf(error) {
     const details = error.details;
     if (typeof details !== "object" || details === null) {
@@ -104,4 +83,3 @@ function _retryAtMsOf(connect) {
     }
     return Date.now() + connect.retry_after_seconds * 1000;
 }
-//# sourceMappingURL=connect-gate.js.map

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

@@ -1,4 +1,3 @@
 import type { AssistantConversationStore } from "./conversation-store.js";
 export declare function turnHoldsAStream(store: AssistantConversationStore): boolean;
 export declare function syncConnection(store: AssistantConversationStore): void;
-//# sourceMappingURL=connection-driver.d.ts.map

package/dist/core/connection-driver.js

@@ -1,22 +1,7 @@
-// The connection driver: the store is the ONLY socket driver — the truth
-// table decides when one is held, an epoch connects ONCE, a background
-// attach remints the epoch, and the stream-end verdict tells a designed
-// stop from an attach or a death. Record: docs/connection-lifecycle.md.
 import { settlesFor } from "./conversation-refresh.js";
 import { publishStore, scheduleConnectionSync, } from "./conversation-publish.js";
-// The stream-end refresh's bound: how long _connectionEnded may
-// hold the connect gate for REST's verdict. This transport aborts nothing,
-// so the bound — never the GET — releases the gate. Equal to the
-// delivery-claim window on purpose; its own constant so it stays retunable.
 const CONNECTION_ENDED_REFRESH_BOUND_MS = 8_000;
-// The hard bound on store-initiated reconnects: an unattended reconnect
-// loop on a public embed is the one failure mode this feature must not
-// have. No-progress automatic reconnects stop here and surface
-// stream-trouble; a human retry, a mount, or a new turn resets the count.
 const MAX_AUTOMATIC_RECONNECTS = 5;
-// The connection truth table (docs/connection-lifecycle.md): a mounted
-// surface connects ONCE per epoch; headless, only queued|working holds a
-// socket — parked keeps the epoch armed but NO socket.
 export function turnHoldsAStream(store) {
     const status = store._newestTurn?.status;
     return status === "queued" || status === "working";
@@ -50,30 +35,16 @@ export function syncConnection(store) {
         .catch(() => undefined);
 }
 function _remintForBackgroundAttach(store) {
-    // A wanted connect on a USED epoch (a background-initiated turn
-    // landed after this epoch's stream closed). Connect-ONCE is the agent's
-    // frozen-cursor law, so remint on the BACKGROUND nonce — never
-    // _reconnectNonce, which would remount the visitor's subtree. Only
-    // _streamInterrupted resets here; the rest belong to other lifecycles.
     store._streamInterrupted = false;
     store._backgroundAttachNonce += 1;
     publishStore(store);
 }
-// The stream ended. REST is the authority on what that meant:
-// park/settle are designed stops (no reconnect — the human's POST
-// begins the next epoch); a turn the workflow still owns means the
-// connection died under us, and the store reconnects on a fresh epoch
-// under the automatic budget.
 async function _connectionEnded(store, epoch, turnBefore) {
     let refreshSettled = false;
     try {
         if (_connectionDecisionMoot(store, epoch)) {
             return;
         }
-        // Held through the refresh so its publishes cannot race a second
-        // connect — but BOUNDED BY THE TIMER, NEVER THE GET: the
-        // gate's release must not depend on a network promise settling; any
-        // settled rejection releases it through the finally below.
         refreshSettled = await Promise.race([
             store.refreshConversation().then(() => true),
             settlesFor(CONNECTION_ENDED_REFRESH_BOUND_MS).then(() => false),
@@ -81,8 +52,6 @@ async function _connectionEnded(store, epoch, turnBefore) {
     }
     finally {
         store._connectionRunning = false;
-        // A mooted decision (an epoch retired mid-connection) still owes the
-        // fresh epoch its connect decision, and nothing else re-triggers it.
         if (_connectionDecisionMoot(store, epoch)) {
             scheduleConnectionSync(store);
         }
@@ -97,22 +66,14 @@ async function _connectionEnded(store, epoch, turnBefore) {
     _judgeStreamEnd(store, turnBefore);
 }
 function _judgeBoundedOut(store) {
-    // BOUNDED OUT: REST never confirmed _newestTurn, so the arms
-    // below must not judge on it. Charge the automatic budget (the only
-    // thing bounding a remint loop on wedged REST) and reschedule the sync.
     store._automaticReconnects += 1;
     if (store._automaticReconnects >= MAX_AUTOMATIC_RECONNECTS) {
-        // EXHAUSTION MUST BE LOUD HERE TOO: with REST wedged, retryStream —
-        // reachable only through the banner — is the sole in-page reset, so a
-        // quiet return here would be a permanent, reload-only dead end.
         store._streamInterrupted = true;
         publishStore(store);
         return;
     }
     scheduleConnectionSync(store);
 }
-// The refresh landed: judge what the close meant on REST-confirmed truth
-// — a designed stop, a background attach, or a death under a live turn.
 function _judgeStreamEnd(store, turnBefore) {
     if (!turnHoldsAStream(store)) {
         store._automaticReconnects = 0;
@@ -120,47 +81,26 @@ function _judgeStreamEnd(store, turnBefore) {
         return;
     }
     if (store._newestTurn?.id !== turnBefore?.id) {
-        // THE ATTACH/DEATH DISCRIMINATOR: a changed newest-turn id is
-        // an ATTACH, not a death — turn ids are immutable, so a same-id live
-        // turn IS the watched one dying. Ride the background nonce (no
-        // remount), never the reconnect bump; the budget zeroed on adoption.
         publishStore(store);
         return;
     }
     _reconnectAfterDeath(store, turnBefore);
 }
-// The same turn is still live after the close: the connection died under
-// us. Count it against the automatic budget and reconnect by remount.
 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) {
-        // The bound, not just a stop condition: surface stream-trouble and
-        // wait for a human (retry, mount) or a new turn to reset it.
         store._streamInterrupted = true;
         publishStore(store);
         return;
     }
-    // THE DEATH ARM'S REMOUNT IS DELIBERATE: the bump moves the Transcript
-    // key (thread.id#reconnectNonce), resetting the subtree's UI state on a
-    // fresh epoch. It must NEVER eat unsaved input: the draft lives
-    // on the store's _composerInput cell, above the key; no reconnect clears it.
     store._reconnectNonce += 1;
-    // THE CARET: the remount tears down a focused textarea with no blur, so
-    // hand the caret back AT THE REMOUNT (the box stays live), and ONLY when
-    // the composer demonstrably owned focus. ORDERING: read synchronously
-    // BEFORE the publishStore() below, whose remount invalidates the record.
     if (store._composerFocusOwned !== null) {
         store._composerCaretReturnPending = store._composerFocusOwned;
     }
     publishStore(store);
 }
-// Disposal or an epoch swap takes the decision out of this connect's
-// hands — read fresh on every consult because both can move during the
-// awaits above. (Surface presence no longer moots anything: mounted or
-// not, the store is the driver.)
 function _connectionDecisionMoot(store, epoch) {
     return store._disposed || store._epoch !== epoch;
 }
-//# sourceMappingURL=connection-driver.js.map

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

@@ -14,72 +14,22 @@ 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 {
-    /** Resume anchors: message id → the run_resumed marker's raw payload
-     *  (null for payload-less legacy markers), kept as provenance for the
-     *  wire (round, attempt) the key was derived from. Presence
-     *  drives the severance scan (a prior attempt's open calls read as
-     *  interrupted); the divider row it used to drive went with the
-     *  meta-receipt rows. */
     resumeAnchors: ReadonlyMap<string, unknown>;
-    /** Failure-receipt anchors: message id → the receipts of a
-     *  turn that settled failed outside any single tool, rendered after
-     *  the failed run's last message — the failure's durable record. */
     turnFailedAnchors: ReadonlyMap<string, AnchoredTurnFailReceipts>;
-    /** Delivery-receipt anchors: message id → the settled
-     *  dispatches the machine-started delivery run pushed — the divider
-     *  naming them renders before that message. */
     subagentDeliveryAnchors: ReadonlyMap<string, DeliveredResult[]>;
-    /** Errored tool calls, toolCallId → the wire's error text. */
     toolErrorAnchors: ReadonlyMap<string, string>;
-    /** Cancelled tool calls (they never ran), by toolCallId. */
     toolCancelAnchors: ReadonlySet<string>;
-    /** Refused calls: tool call id → the door's refusal sentence,
-     *  shown as the declined row's reason. */
     toolRefusalAnchors: ReadonlyMap<string, string>;
-    /** Offloaded tool calls (the wire's content is the offloader's
-     *  model-facing replacement, not the tool's output), by toolCallId. */
     toolOffloadAnchors: ReadonlySet<string>;
-    /** Decision-bearing tool calls: an approval_requested or
-     *  member-answerable tool_execution_requested marker named this
-     *  toolCallId. The placement hold's durable arm — the card stores
-     *  prune at the result and the settle by design, while TVC-014's hold
-     *  window is the turn. OPTIONAL because the snapshot type ships on the
-     *  `./transcript` composition surface — a host-built
-     *  snapshot without the member reads as empty, never breaks. */
     toolDecisionAnchors?: ReadonlySet<string>;
-    /** Denied tool calls: the toolCallIds whose approval a
-     *  member declined — approval_resolved{approved:false} joined to its
-     *  approval_requested's tool_call_id in the resume store's ledger. The
-     *  state ladder's rung above `cancelled` (the stamp the wire gives a
-     *  denial). OPTIONAL for the same reason as toolDecisionAnchors: the
-     *  snapshot type ships on the `./transcript` composition surface, and
-     *  a host-built snapshot without the member reads as empty. */
     toolDenialAnchors?: ReadonlySet<string>;
-    /** Annotated tool calls, toolCallId → the wire's display copy. */
     toolCallDisplayAnchors: ReadonlyMap<string, ToolCallDisplay>;
-    /** Registered tool schemas, toolCallId → the wire's
-     *  argsSchema / resultSchema. Absent call = no schema declared (or an
-     *  older history) — the view's fields stay `undefined`. */
     toolSchemaAnchors: ReadonlyMap<string, ToolCallSchemas>;
-    /** Block timing: block id (messageId/toolCallId) → the
-     *  earliest/latest server timestamps observed for it. Absent block =
-     *  duration unknown, never zero. */
     blockTimingAnchors: ReadonlyMap<string, BlockTiming>;
-    /** Turn usage: turn id → the runtime's own token totals.
-     *  Absent turn = usage unknown; the number hides. */
     turnUsageAnchors: ReadonlyMap<string, TurnUsage>;
-    /** Memory provenance: durable memory id → the end-user-safe
-     *  write receipt, in stream order. */
     memoryProvenanceAnchors: ReadonlyMap<string, MemoryUpdated>;
-    /** Memory attribution: memory id → the assistant prose
-     *  message its footer renders under. A provenance record without an
-     *  attribution renders no footer — old histories degrade, never
-     *  synthesize. */
     memoryAttributionAnchors: ReadonlyMap<string, string>;
 }
-/** The anchors' single source of truth is the resume store (it outlives
- *  every epoch); the snapshot re-validates on derivation so a stale shape
- *  degrades to missing rows, never a crash. */
 export declare function markerAnchorsOf(resume: StreamResumeStore): MarkerAnchorsSnapshot;
 export interface ConnectionEpochDeps {
     epochId: number;
@@ -88,30 +38,13 @@ export interface ConnectionEpochDeps {
     streamThreadId: string;
     ledger: UserTurnLedger;
     resume: StreamResumeStore;
-    /** Read fresh at each execution pass — the host's capability wiring
-     *  changes identity with provider re-renders. */
     handlersOf: () => ReadonlyMap<string, ExecutionHandler>;
-    /** The thread-lived approval inbox: pending asks must survive
-     *  this epoch, so the conversation owns it and the epoch borrows it. */
     approvalInbox: ApprovalInbox;
     publishApprovalCards: (cards: readonly ApprovalCardModel[]) => void;
-    /** Every execution-entries snapshot — the store derives the
-     *  member-answerable elicitation cards from it. */
     publishExecutionEntries: (entries: readonly ExecutionEntryModel[]) => void;
-    /** The resume store moved — the store re-derives the anchors snapshot. */
     publishMarkerAnchors: () => void;
-    /** The agent's message list moved — a shallow snapshot per change. */
     publishMessages: (messages: readonly Message[]) => void;
-    /** A replayed or live interrupt_answer_consumed marker: a
-     *  resume already carried this pause's answer into the agent, so the
-     *  pending-decision-gap derivation subtracts the id instead of
-     *  alarming. Store-lived (keyed by run AND round — the row's identity
-     *  is (run_id, round, interrupt_id), and the store matches the round
-     *  against the turn's awaiting_round exactly as the server's
-     *  subtraction does) — the fold must survive epoch turnover. */
     noteInterruptAnswerConsumed: (runId: string, interruptId: string, round: number) => void;
-    /** A non-abort connection failure (transport death or a server
-     *  RUN_ERROR) — the interruption banner's wire. */
     onStreamError: (error: Error) => void;
     refreshLedger: () => Promise<void>;
     onUserMessageInjected: (messageId: string) => void;
@@ -126,11 +59,7 @@ export interface ConnectionEpoch {
     executionInbox: ExecutionInbox;
     threadId: string;
     streamThreadId: string;
-    /** The REST side's door into the inbox: a mutation that
-     *  answers "did visible state change" publishes through this epoch's
-     *  own publisher, which also pokes the driver. */
     withExecutionInbox: (mutate: (inbox: ExecutionInbox) => boolean) => void;
     dispose: () => void;
 }
 export declare function beginConnectionEpoch(deps: ConnectionEpochDeps): ConnectionEpoch;
-//# sourceMappingURL=connection-epoch.d.ts.map

package/dist/core/connection-epoch.js

@@ -20,9 +20,6 @@ import { turnFailedMarkerRecorder, wellFormedFailAnchorsOf, } from "./turn-faile
 import { turnUsageRecorder, wellFormedTurnUsageAnchorsOf, } from "./turn-usage-anchors.js";
 import { messagesRecorder, streamErrorRecorder } from "./messages-cell.js";
 import { userTurnInjector } from "./user-turn-ledger.js";
-/** The anchors' single source of truth is the resume store (it outlives
- *  every epoch); the snapshot re-validates on derivation so a stale shape
- *  degrades to missing rows, never a crash. */
 export function markerAnchorsOf(resume) {
     return {
         resumeAnchors: new Map(resume.resumeAnchors),
@@ -51,11 +48,6 @@ export function beginConnectionEpoch(deps) {
     });
     const approvalInbox = deps.approvalInbox;
     const executionInbox = new ExecutionInbox();
-    // Each published entries snapshot pokes the driver to (re)schedule a
-    // drain — the automatic execution loop — and reaches the store, which
-    // derives the member-answerable elicitation cards from it (the
-    // driver's eligibility filter skips those kinds; the member is their
-    // executor).
     const publishEntries = (entries) => {
         driver.noteEntriesChanged(entries);
         deps.publishExecutionEntries(entries);
@@ -69,8 +61,6 @@ export function beginConnectionEpoch(deps) {
         publishEntries,
         onWorkflowRestarted: deps.onWorkflowRestarted,
     });
-    // Subscription order is behaviour: @ag-ui/client dispatches every
-    // subscriber of an event in attach order.
     const subscriptions = [
         ..._runMarkerSubscriptionsOf(agent, deps),
         ..._toolMarkerSubscriptionsOf(agent, deps),
@@ -98,23 +88,13 @@ export function beginConnectionEpoch(deps) {
                 subscription.unsubscribe();
             }
             driver.dispose();
-            // The store-driven run needs an explicit stop on retire — detach finalizes without a terminal event, the wire
-            // shape every recorder already handles.
             void agent.detachActiveRun().catch(() => undefined);
         },
     };
 }
-/** The run-lifecycle markers: resumption, consumed interrupt answers,
- *  turn failure receipts and subagent delivery dividers. */
 function _runMarkerSubscriptionsOf(agent, deps) {
     return [
         agent.subscribe(resumeMarkerRecorder((runId, messageId, markerValue, markerTimestamp) => {
-            // The resume store arbitrates: one anchor per RESUMPTION, ever
-            // (run id + the payload's own (round, attempt); round-less
-            // legacy rows by their stamped timestamp — the
-            // failed/delivery siblings' posture) — a filtered re-delivery
-            // flushing under a drifted message id records nothing. The anchor
-            // drives severance only; its divider went with the meta-receipt rows.
             if (deps.resume.recordResumeAnchor(runId, messageId, markerValue, markerTimestamp)) {
                 deps.publishMarkerAnchors();
             }
@@ -123,23 +103,17 @@ function _runMarkerSubscriptionsOf(agent, deps) {
             deps.noteInterruptAnswerConsumed(runId, consumed.interruptId, consumed.round);
         })),
         agent.subscribe(turnFailedMarkerRecorder((failedRunId, messageId, position, receipts) => {
-            // The resume store arbitrates: one receipt row per failed run,
-            // ever — a re-delivery can flush under a drifted message id.
             if (deps.resume.recordTurnFailedReceipts(failedRunId, messageId, position, receipts)) {
                 deps.publishMarkerAnchors();
             }
         })),
         agent.subscribe(subagentDeliveryMarkerRecorder((deliveryRunId, messageId, results) => {
-            // The resume store arbitrates: one divider per delivery run,
-            // ever — a re-delivery can flush under a drifted message id.
             if (deps.resume.recordSubagentDelivery(deliveryRunId, messageId, results)) {
                 deps.publishMarkerAnchors();
             }
         })),
     ];
 }
-/** The per-tool-call markers: each records into the resume store and
- *  publishes only when the store's collection identity moved. */
 function _toolMarkerSubscriptionsOf(agent, deps) {
     return [
         agent.subscribe(toolErrorRecorder((toolCallId, errorText) => {
@@ -171,8 +145,6 @@ function _toolMarkerSubscriptionsOf(agent, deps) {
             }
         })),
         agent.subscribe(toolDenialRecorder((marker) => {
-            // Gated on the DENIED half's identity, not the ledger's: an ask
-            // changes nothing the snapshot shows, so it must not repaint.
             const before = deps.resume.toolDenialLedger.denied;
             deps.resume.recordToolDenialMarker(marker);
             if (deps.resume.toolDenialLedger.denied !== before) {
@@ -202,42 +174,10 @@ function _toolMarkerSubscriptionsOf(agent, deps) {
         })),
     ];
 }
-/** Block timing, turn usage and memory provenance/attribution. */
 function _timingAndMemoryMarkerSubscriptionsOf(agent, deps) {
-    // The block-timing recorder's publish coalescer — see its subscriber
-    // below. True while a snapshot publish is already queued behind the
-    // macrotask window, so a burst of boundary events costs one rebuild,
-    // not one per event (and not one per subscriber await — the reason
-    // the window is a timer, not a microtask).
     let timingPublishQueued = false;
     return [
-        agent.subscribe(
-        // Timing is the one recorder here whose trigger is NOT a rare
-        // CUSTOM marker: it fires on every block boundary (~2 per block),
-        // and each firing moves the map (START creates the pair, END
-        // widens it). Publishing per firing would rebuild the whole
-        // twelve-collection snapshot ~2N times over an N-block replay —
-        // quadratic in transcript length — so the STORE write stays
-        // synchronous (the resume store is always current for reconnect
-        // seeding) while the derived-snapshot publish coalesces behind a
-        // MACROTASK window (setTimeout 0). A microtask window does not
-        // work here and must not come back: @ag-ui/client's
-        // defaultApplyEvents dispatches subscribers with one `await` per
-        // subscriber per event, and every await drains the microtask
-        // queue — a queueMicrotask publish fires before the NEXT
-        // SUBSCRIBER of the same event, coalescing nothing. The whole
-        // apply chain for a delivered chunk runs on one macrotask
-        // (concatMap's awaits are all microtasks), so a timer queued at
-        // the first moved boundary absorbs every boundary the chunk
-        // carries. No consumer needs the anchors cell current sooner: the
-        // cell has exactly one subscriber-driven React consumer, and live
-        // elapsed time ticks off the client's own "now", never off
-        // publishes. Change detection is the store's REVISION counter —
-        // the timing map mutates in place (see block-timing-anchors), so
-        // identity cannot be the gate. A post-teardown timer firing is
-        // harmless: publishMarkerAnchors is epoch-guarded and re-seeded
-        // synchronously on epoch swap.
-        blockTimingRecorder((blockId, observedAtMs) => {
+        agent.subscribe(blockTimingRecorder((blockId, observedAtMs) => {
             const before = deps.resume.blockTimingRevision;
             deps.resume.recordBlockTiming(blockId, observedAtMs);
             if (deps.resume.blockTimingRevision === before || timingPublishQueued) {
@@ -264,11 +204,6 @@ function _timingAndMemoryMarkerSubscriptionsOf(agent, deps) {
                     deps.publishMarkerAnchors();
                 }
             },
-            // Attribution publishes synchronously like its provenance
-            // sibling — memory markers are rare (one per real insert), so
-            // the timing coalescer's macrotask window buys nothing here, and
-            // a post-settle arrival must repaint without waiting for another
-            // event (the footer engages on genuinely late markers).
             onMemoryAttributed: (memoryId, messageId) => {
                 const before = deps.resume.memoryAttributionAnchors;
                 deps.resume.recordMemoryAttribution(memoryId, messageId);
@@ -279,8 +214,6 @@ function _timingAndMemoryMarkerSubscriptionsOf(agent, deps) {
         })),
     ];
 }
-/** The stream's own state: the resume cursor, the user-turn ledger, both
- *  inboxes, the message list and stream errors. */
 function _streamStateSubscriptionsOf(agent, deps, inboxes) {
     return [
         agent.subscribe(resumeSnapshotRecorder(() => agent.resumeCursor, deps.resume)),
@@ -290,10 +223,6 @@ function _streamStateSubscriptionsOf(agent, deps, inboxes) {
             onRunSettled: deps.onRunSettled,
         })),
         agent.subscribe(approvalInboxRecorder(inboxes.approvalInbox, deps.publishApprovalCards, () => {
-            // The parked contract's only wire signal is the stream simply
-            // ending; the handler consults REST, and reading isRunning at
-            // that later moment (not now) is what lets it dismiss a
-            // connection that already reconnected.
             deps.onQuietClose(() => agent.isRunning);
         })),
         agent.subscribe(executionInboxRecorder(inboxes.executionInbox, inboxes.publishEntries)),
@@ -301,4 +230,3 @@ function _streamStateSubscriptionsOf(agent, deps, inboxes) {
         agent.subscribe(streamErrorRecorder(deps.onStreamError)),
     ];
 }
-//# sourceMappingURL=connection-epoch.js.map

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

@@ -3,24 +3,10 @@ export interface ConsumedInterrupt {
     interruptId: string;
     round: number;
 }
-/** The wire is distrusted by contract: a malformed value records
- *  nothing (the gap then alarms, never a crash). The
- *  payload's `family` is deliberately not read: the row-shape contract
- *  names it descriptive, not identity — (run_id, round, interrupt_id)
- *  is the whole fold key, and no client behavior branches on which
- *  signal family carried the answer. */
 export declare function interruptAnswerConsumedPayloadOf(value: unknown): ConsumedInterrupt | null;
-/**
- * Fires once per replayed or live consumption marker, named by the
- * server's own run id (the RUN_STARTED before it — the receipt-anchors
- * posture), so the store keys its consumed sets by run and a marker
- * from a superseded run can never subtract from the newest turn's gap.
- */
 export declare function consumedInterruptRecorder(onConsumed: (runId: string, consumed: ConsumedInterrupt) => void): AgentSubscriber;
 export declare class ConsumedInterruptFold {
     private readonly byRun;
-    /** Records one consumption; returns false when it was already known. */
     note(runId: string, interruptId: string, round: number): boolean;
     idsOf(runId: string | null | undefined, awaitingRound: number | null | undefined): ReadonlySet<string>;
 }
-//# sourceMappingURL=consumed-interrupts.d.ts.map