@teaflask/assistant 0.3.0 → 0.6.0

package/dist/core/approval-inbox.js

@@ -7,37 +7,18 @@ const ACTIONABLE = {
     kind: "actionable",
     errorSentence: null,
 };
-/** Every capability on — the serving door's shape. */
 export const SERVING_APPROVAL_CAPABILITIES = { anchoring: true, gate: true, trust: true };
 export class ApprovalInbox {
     currentRunId = null;
     seenToolCallIds = new Set();
     cardList = [];
-    // Every interrupt id whose card this inbox removed — closing evidence
-    // (tool result, RUN_ERROR, round supersession, settled turn) spends
-    // an id forever, and REST hydration must not resurrect it from a stale
-    // read. Interrupt ids name one pause instance of one tool
-    // call, and every legitimate re-presentation of a pause (park restart,
-    // reconnect replay, fallback resume) happens while the card is still
-    // held or was never delivered — never after closing evidence — so a
-    // closed id can never be wrongly suppressed. Thread-lived like the
-    // inbox itself; one short string per closed ask, no eviction needed.
     closedInterruptIds = new Set();
-    // The runs of turns the record reported settled — monotonic
-    // like a closed id: nothing opens under one, nothing survives under one.
     settledRunIds = new Set();
     capabilities;
     constructor(capabilities = {}) {
         this.capabilities = capabilities;
     }
-    // --- the stream side -------------------------------------------------
     noteRunStarted(runId) {
-        // A new run is NOT closing evidence for other runs' cards: a parked
-        // turn's restarted workflow streams under a fresh run id while the
-        // replayed pause still names the old one, and the workflow's wait
-        // condition keeps sibling asks individually answerable. Cards die on
-        // their own evidence (receipt, result, RUN_ERROR) or on the durable
-        // turn record's word — never on another run merely beginning.
         this.currentRunId = runId;
         return false;
     }
@@ -49,26 +30,17 @@ export class ApprovalInbox {
     }
     noteApprovalRequested(payload) {
         if (this.currentRunId === null) {
-            // A marker outside any run segment is unanchorable — ignore it.
             return false;
         }
         const runId = this.currentRunId;
         if (this.settledRunIds.has(runId)) {
-            // A marker under a settled turn's run is history, not an ask.
             return false;
         }
         const held = this.cardList.find((card) => card.interruptId === payload.interrupt_id);
         if (held !== undefined) {
             if (held.asker.kind === "coworker") {
-                // A coworker's coordinates are the snapshot's, never a marker's.
                 return false;
             }
-            // A replayed marker for a card we already hold: keep the card's status
-            // — replay must never resurrect buttons on an answered card — but
-            // re-stamp the stream coordinates, so the run this replay serves under
-            // is the one whose closing evidence governs the card. ANY moved
-            // coordinate is a visible change: the submit path reads runId off the
-            // published card, and placement reads toolCallId/anchored.
             const toolCallId = payload.tool_call_id ?? null;
             const anchored = this._anchoredOf(toolCallId);
             const changed = held.runId !== runId ||
@@ -83,11 +55,8 @@ export class ApprovalInbox {
         }
         const newestRound = this._newestRoundOf(runId);
         if (newestRound !== null && payload.round < newestRound) {
-            // A lower round replaying after a later pause is history, not an ask.
             return false;
         }
-        // A higher round supersedes the run's earlier cards (round
-        // namespacing: multi-pause turns re-emit cards and must not collide).
         if (newestRound !== null && payload.round > newestRound) {
             this._removeWhere((card) => card.asker.kind === "assistant" &&
                 card.runId === runId &&
@@ -97,11 +66,6 @@ export class ApprovalInbox {
         return true;
     }
     noteApprovalResolved(interruptId, approved) {
-        // The receipt is the stream saying "answered" — on a replay it lands
-        // right after the marker it answers, so the card flips to answered in
-        // the same burst and buttons never resurrect on an already-answered
-        // ask. The gated call's result (or the settled turn's word) still
-        // closes the card later, exactly like the live path.
         return this._transition(interruptId, ["actionable", "submitting"], {
             kind: "answered",
             approved,
@@ -109,33 +73,15 @@ export class ApprovalInbox {
         });
     }
     noteToolCallResult(toolCallId) {
-        // The gated call producing a result is the resume made visible.
         return this._removeWhere((card) => card.toolCallId === toolCallId);
     }
     noteRunFinished() {
-        // Closes nothing by itself. THE PREMISE: the thread streamer
-        // synthesizes a RUN_FINISHED for the LIVE run right before re-entering
-        // an old run's segment for a late row, re-emits none of the live pause
-        // on the way back, and the frame is indistinguishable from a real
-        // terminal. A real finish closes through the gated call's result,
-        // RUN_ERROR (never synthesized) or the settled turn's word.
         return false;
     }
     noteRunError() {
-        // RUN_ERROR carries no runId — the run being narrated is the one that
-        // errored. Scoped to it on purpose: a replayed historical run's error
-        // must not wipe a carried live card from a newer pause. The errored
-        // turn's settled truth reaches the survivors on the next REST read.
         return this._removeWhere((card) => card.asker.kind === "assistant" && card.runId === this.currentRunId);
     }
     noteStreamClosedWithoutTerminal() {
-        // The parked contract's only wire signal: the stream just ends, with
-        // no terminal event. The open asks stay answerable — a late answer is
-        // the designed restart path — but their cards learn the assistant
-        // stopped actively waiting. A dropped connection takes this same
-        // transition (the wire shapes are identical); the conversation layer's
-        // REST confirm decides which it was, and either way the cards must
-        // survive.
         let changed = false;
         for (const card of this.cardList) {
             if (card.asker.kind === "assistant" &&
@@ -147,7 +93,6 @@ export class ApprovalInbox {
         }
         return changed;
     }
-    // --- the submit side ---------------------------------------------------
     beginSubmit(interruptId) {
         return this._transition(interruptId, ["actionable"], {
             kind: "submitting",
@@ -167,38 +112,18 @@ export class ApprovalInbox {
         });
     }
     markPauseStale() {
-        // A 409 speaks for the whole pause — the turn no longer awaits ANY of
-        // these answers, whatever run each card is stamped with. Answered
-        // cards keep their honest note. A coworker's card is not the turn's
-        // pause: its 409 is its own (markCoworkerCardStale).
         return this._staleWhere((card) => card.asker.kind === "assistant");
     }
-    /** A 409 for a coworker's decision speaks for that card alone. */
     markCoworkerCardStale(interruptId) {
         return this._staleWhere((card) => card.asker.kind === "coworker" && card.interruptId === interruptId);
     }
-    /** The member's send voids every paused coworker of the thread. */
     markCoworkerCardsStale() {
         return this._staleWhere((card) => card.asker.kind === "coworker");
     }
-    // --- the durable turn record -----------------------------------------------
-    /**
-     * The REST recovery path: build cards from the turn record's
-     * pending_approvals snapshot — the same persisted markers the stream
-     * replays — so a failed stream fetch never strands a pending pause. Upsert
-     * only: a held card keeps its status and coordinates, nothing is removed
-     * (reconcile judges membership), the parked flag stays reconcile's job.
-     * Rounds below the run's newest are history, and a closed id never
-     * returns: a REST response that raced the stream's closing evidence would
-     * otherwise put live Approve/Deny on an ask that already executed.
-     * Independent of currentRunId: there may have been no stream at all.
-     */
     hydratePendingApprovals(turn) {
         if (turn === null ||
             (turn.status !== "awaiting_input" && turn.status !== "parked") ||
             turn.run_id === null ||
-            // A server predating the field sends no array at all — an old
-            // wire, never an empty pause.
             !Array.isArray(turn.pending_approvals)) {
             return false;
         }
@@ -224,16 +149,6 @@ export class ApprovalInbox {
         }
         return changed;
     }
-    /**
-     * The coworker approvals the turn snapshot lists, adopted: a
-     * card not held opens actionable, addressed to its dispatching turn; a
-     * held card re-reads its coworker's parked flag; a coworker card no turn
-     * lists anymore is gone (its row left paused). Bypasses the marker path's
-     * round arbitration — a coworker's round is its own — and remembers
-     * nothing it removes: "not in this window" is not monotonic evidence, so
-     * a later read may re-adopt (a re-POST after a real delist is the door's
-     * already_consumed receipt).
-     */
     adoptCoworkerApprovals(turns) {
         let changed = false;
         const listed = new Set();
@@ -274,38 +189,17 @@ export class ApprovalInbox {
         }
         return changed;
     }
-    /**
-     * Re-judge the cards against the turn record — the lifetime authority,
-     * called on every REST read of the thread. Terminal turns
-     * close everything (except an in-flight submit, which settles itself);
-     * live turns stamp the parked flag from status; and where the contract
-     * makes pending_interrupt_ids meaningful (awaiting_input or parked,
-     * with a run captured), an actionable card the turn no longer holds
-     * goes visibly stale — never a silent vanish. Under queued/working the
-     * set is contractually empty, so membership is deliberately NOT judged
-     * there: a stale read racing a live marker must not kill a fresh card
-     * (stale has no return transition); the stream's own evidence closes
-     * those. Same tolerance for a card whose round is newer than the
-     * record's awaiting_round: the read predates the card.
-     */
     reconcileWithTurn(turn) {
         if (turn === null) {
             return false;
         }
-        // A coworker's card is exempt from every judgement below: its lifetime
-        // is the snapshot's (adoptCoworkerApprovals), and its dispatching turn
-        // is normally settled while it still awaits the member.
         if (isTerminalTurnStatus(turn.status)) {
             return this._removeWhere((card) => card.asker.kind === "assistant" && card.status.kind !== "submitting");
         }
         const parked = turn.status === "parked";
-        // Null where the record makes membership meaningless (or where an
-        // older door sends no set at all — absent is never empty).
         const pendingIds = _membershipIsJudgeable(turn)
             ? turn.pending_interrupt_ids
             : null;
-        // An absent awaiting_round (older door) reads like the null the
-        // serving door sends between pauses: no round to shield behind.
         const awaitingRound = turn.awaiting_round ?? null;
         let changed = false;
         for (const card of this.cardList) {
@@ -327,15 +221,6 @@ export class ApprovalInbox {
         }
         return changed;
     }
-    /**
-     * The settled turns' word: the assistant's cards whose run
-     * belongs to a turn with a terminal status are gone, whatever row is
-     * newest — the close a synthesized terminal cannot fake. The removal
-     * reads the ACCUMULATED runs, so a stale read still showing the pause
-     * rebuilds nothing. THE PREMISE: a turn's run_id is captured once and a
-     * terminal status is final, so a settled run never carries a live card
-     * again. Submitting cards settle themselves; coworker cards are exempt.
-     */
     reconcileWithTurns(turns) {
         for (const turn of turns) {
             if (isTerminalTurnStatus(turn.status) && turn.run_id !== null) {
@@ -346,7 +231,6 @@ export class ApprovalInbox {
             card.status.kind !== "submitting" &&
             this.settledRunIds.has(card.runId));
     }
-    // --- reading -------------------------------------------------------------
     cards() {
         return this.cardList.map((card) => ({ ...card }));
     }
@@ -354,9 +238,6 @@ export class ApprovalInbox {
         return (this.cardList.find((card) => card.interruptId === interruptId)?.status
             .kind ?? null);
     }
-    // --- internals -------------------------------------------------------------
-    // The one card constructor, shared by the stream marker and the REST
-    // snapshot so the two paths cannot drift.
     _cardFrom(payload, runId, ask) {
         const toolCallId = payload.tool_call_id ?? null;
         return {
@@ -372,21 +253,15 @@ export class ApprovalInbox {
             runId,
             parked: ask?.parked ?? false,
             gated: this.capabilities.gate === true && payload.gated,
-            // Either asker's, off the wire: a coworker's grant lands
-            // in its own session, so its card may offer what the record says.
             trustAvailable: this.capabilities.trust === true && payload.trust_available,
             status: ACTIONABLE,
             asker: ask?.asker ?? { kind: "assistant" },
             turnId: ask?.turnId ?? null,
         };
     }
-    // Anchoring is a capability: without it the set stays empty, so this
-    // reads false for every card — the flat-block host never anchors.
     _anchoredOf(toolCallId) {
         return toolCallId !== null && this.seenToolCallIds.has(toolCallId);
     }
-    // Round arbitration is the ASSISTANT's alone: a coworker's card carries
-    // the dispatching turn's run id with the CHILD's segment round.
     _newestRoundOf(runId) {
         const rounds = this.cardList
             .filter((card) => card.asker.kind === "assistant" && card.runId === runId)
@@ -412,8 +287,6 @@ export class ApprovalInbox {
         }
         return changed;
     }
-    // Removal is closing evidence: the removed ids are remembered so a
-    // stale REST snapshot can never hydrate them back.
     _removeWhere(doomed) {
         const kept = [];
         let changed = false;
@@ -441,26 +314,12 @@ export class ApprovalInbox {
         return true;
     }
 }
-// The execution driver's tolerances, mirrored: membership is
-// only meaningful where the contract fills the set — a paused turn with a
-// captured run. A null run_id is a lost capture (the server hides the
-// cards, the set reads empty), and a server predating the field sends no
-// array at all — absent must never read as empty. A type predicate, so
-// the caller reads the set only where this says it may.
 function _membershipIsJudgeable(turn) {
     return ((turn.status === "awaiting_input" || turn.status === "parked") &&
         turn.run_id !== null &&
         Array.isArray(turn.pending_interrupt_ids));
 }
-// The submit path's own failure sentence — reached only when the caller
-// cannot name any turn to answer at all, which a live pause makes
-// near-impossible.
 export const ANSWER_NOT_SENT_SENTENCE = "That answer couldn't be sent. Please try again.";
-/** The turn holding the answerable pause, if any: the newest row when it
- *  pauses itself, else the newest answerable row behind it (a queued
- *  message can sit newer than the pause, and reading the queued row would
- *  silently miss the pause exactly when the member must answer to unblock
- *  the queue). Generic so each caller gets its own turn type back. */
 export function answerablePauseOf(turns) {
     for (let index = turns.length - 1; index >= 0; index -= 1) {
         const turn = turns[index];
@@ -470,45 +329,14 @@ export function answerablePauseOf(turns) {
     }
     return null;
 }
-/**
- * The durable turn record re-judges the pending approvals on every REST
- * read: hydration first — the record's pending_approvals snapshot rebuilds
- * any card the stream never delivered — then reconcile judges the whole
- * set, hydrated cards included. Two different rows on purpose: the pause
- * hydrates from the ANSWERABLE turn (a queued message can sit newer than
- * the pause), while reconcile keeps the NEWEST row (a terminal newest turn
- * is what removes the conversation's cards). The inbox's own guards absorb
- * what the read cannot know: closed ids never hydrate back, a round below
- * the run's newest is history, absent pause fields change nothing. The
- * settled-runs arm runs last over the whole window: a card
- * whose run belongs to any turn that settled is gone even while a newer
- * turn is live. Returns whether the visible cards changed.
- */
 export function reconcileApprovalsWithTurns(inbox, turns) {
     const newest = turns[turns.length - 1] ?? null;
     const hydrated = inbox.hydratePendingApprovals(answerablePauseOf(turns));
-    // The coworkers' cards ride the same read: every turn in the
-    // window may be some paused coworker's dispatching turn.
     const adopted = inbox.adoptCoworkerApprovals(turns);
     const reconciled = inbox.reconcileWithTurn(newest);
     const settled = inbox.reconcileWithTurns(turns);
     return hydrated || adopted || reconciled || settled;
 }
-/**
- * The subscriber that feeds the stream into the inbox: markers open cards,
- * receipts answer them, and the resume's own evidence or the settled turn's
- * word closes them — a RUN_FINISHED alone closes nothing. Only the
- * server-named run id from RUN_STARTED is trusted — the connect-run's
- * input.runId is the client's own and never names a recorded run.
- *
- * It also watches for the parked contract's quiet close, with the same
- * last-event-was-a-terminal flags as resumeSnapshotRecorder: lifecycle
- * events route to their dedicated handlers, everything else through
- * onEvent, and an errored or aborted pipeline routes through onRunFailed
- * before finalize — so a finalize where nothing failed and the last
- * applied event was not a terminal is a stream that simply ended. The
- * flags reset per run: one agent can be connected more than once.
- */
 export function approvalInboxRecorder(inbox, onCardsChanged, onStreamClosedWithoutTerminal) {
     let endedAtTerminal = false;
     let failed = false;
@@ -569,4 +397,3 @@ export function approvalInboxRecorder(inbox, onCardsChanged, onStreamClosedWitho
         },
     };
 }
-//# sourceMappingURL=approval-inbox.js.map

package/dist/core/approval-request-narrowing.d.ts

@@ -1,32 +1,15 @@
 import type { ApprovalRequestedPayload } from "../contract/events.js";
-/** One coworker approval as the turn snapshot lists it, narrowed. */
 export interface CoworkerApprovalRequest {
     ordinal: number;
     label: string;
     childSessionId: string;
-    /** The coworker's own waiting execution already exited (its answer
-     *  still counts — the entity restarts it); never the parent's state. */
     parked: boolean;
     card: ApprovalRequestedPayload;
 }
-/** The turn fields the coworker adoption reads — the serving and the
- *  dashboard turn shapes both satisfy it. A turn with no id has no door
- *  a coworker's decision could be posted to, so it lists nothing. */
 export interface CoworkerApprovalTurn {
     id?: string;
     run_id: string | null;
     pending_coworker_approvals?: readonly unknown[] | null;
 }
-/**
- * Narrow one pending_coworker_approvals item (any by contract): the
- * asker's identity plus the card in the marker's own shape, so the
- * marker narrowing below serves both askers. Malformed → null.
- */
 export declare function coworkerApprovalRequestOf(value: unknown): CoworkerApprovalRequest | null;
-/**
- * Narrow an approval_requested CUSTOM event's wire value (any by contract).
- * Malformed payloads return null and are ignored — the contract's "clients
- * MUST ignore events and fields they do not recognize".
- */
 export declare function approvalRequestedPayloadOf(value: unknown): ApprovalRequestedPayload | null;
-//# sourceMappingURL=approval-request-narrowing.d.ts.map

package/dist/core/approval-request-narrowing.js

@@ -1,15 +1,4 @@
-// The approval wire's narrowers: an approval_requested
-// marker's value and a turn snapshot's coworker approval item, both `any`
-// by contract. Malformed values return null and are ignored — the
-// contract's "clients MUST ignore events and fields they do not
-// recognize". A dependency-free leaf, the twin of
-// execution-request-narrowing.ts.
 import { withoutStepCaption } from "./step-caption.js";
-/**
- * Narrow one pending_coworker_approvals item (any by contract): the
- * asker's identity plus the card in the marker's own shape, so the
- * marker narrowing below serves both askers. Malformed → null.
- */
 export function coworkerApprovalRequestOf(value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -32,11 +21,6 @@ export function coworkerApprovalRequestOf(value) {
         card,
     };
 }
-/**
- * Narrow an approval_requested CUSTOM event's wire value (any by contract).
- * Malformed payloads return null and are ignored — the contract's "clients
- * MUST ignore events and fields they do not recognize".
- */
 export function approvalRequestedPayloadOf(value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -52,14 +36,11 @@ export function approvalRequestedPayloadOf(value) {
         interrupt_id: record.interrupt_id,
         prompt: record.prompt,
         tool_name: typeof record.tool_name === "string" ? record.tool_name : null,
-        // The model's caption is the row's label, never an argument.
         tool_args: withoutStepCaption(recordOrEmpty(record.tool_args)),
-        // Fail safe against an older wire: no schema means the generic card.
         tool_input_schema: recordOrNull(record.tool_input_schema),
         tool_output_schema: recordOrNull(record.tool_output_schema),
         tool_call_id: typeof record.tool_call_id === "string" ? record.tool_call_id : null,
         round: typeof record.round === "number" ? record.round : 0,
-        // Fail safe against an older wire: no flag means no trust affordance.
         gated: record.gated === true,
         trust_available: record.trust_available === true,
     };
@@ -76,4 +57,3 @@ function recordOrNull(value) {
     }
     return null;
 }
-//# sourceMappingURL=approval-request-narrowing.js.map

package/dist/core/approval-resolved.d.ts

@@ -2,8 +2,6 @@ export interface ApprovalResolved {
     interruptId: string;
     approved: boolean;
     feedback?: string;
-    /** A prefixed actor handle ("member:<uuid>" / "eu:<id>"); absent for anonymous visitors. */
     resolvedBy?: string;
 }
 export declare function approvalResolvedPayloadOf(value: unknown): ApprovalResolved | null;
-//# sourceMappingURL=approval-resolved.d.ts.map

package/dist/core/approval-resolved.js

@@ -1,21 +1,3 @@
-// The approval_resolved payload narrower, pure of React. THE PREMISE,
-// stated: the WIRE contract is unchanged — the server records and serves
-// approval_resolved markers carrying interrupt_id, approved, feedback,
-// and resolved_by. This module is the CLIENT-SIDE narrower, and a
-// narrower copies only the fields something renders or decides on.
-// The three consumers: the approval inbox (approvalInboxRecorder →
-// noteApprovalResolved) and the denial ledger (tool-denial-anchors.ts)
-// read exactly interruptId and approved; the dashboard's audit receipt
-// row, which imports this narrower through ./transcript, renders
-// feedback and resolvedBy too — so those ride as optional fields,
-// present only when the wire sent strings. Extra wire fields are
-// ignored by construction (the narrower
-// reads named keys off the payload); narrowing returns null only on a
-// missing/mistyped interrupt_id or approved, so a server sending a richer
-// payload can neither throw nor drop an event here. (The anchoring half
-// this module once carried — recorder, anchor maps, receipt sentences —
-// went with the deleted meta-receipt rows; the file lost the "-anchors"
-// name with it.)
 export function approvalResolvedPayloadOf(value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -28,10 +10,7 @@ export function approvalResolvedPayloadOf(value) {
     return {
         interruptId: payload.interrupt_id,
         approved: payload.approved,
-        // The optional fields may arrive as null or be absent entirely —
-        // the stored payload keeps whatever the marker model dumped.
         feedback: typeof payload.feedback === "string" ? payload.feedback : undefined,
         resolvedBy: typeof payload.resolved_by === "string" ? payload.resolved_by : undefined,
     };
 }
-//# sourceMappingURL=approval-resolved.js.map

package/dist/core/assistant-prose.d.ts

@@ -1,6 +1,2 @@
 import type { Message } from "@ag-ui/core";
-/** The newest assistant message with visible prose — the only row kind
- *  a memory footer may render under (tool results, tool-call-only
- *  messages, and reasoning never host one). */
 export declare function newestAssistantProseIdOf(messages: readonly Message[]): string | null;
-//# sourceMappingURL=assistant-prose.d.ts.map

package/dist/core/assistant-prose.js

@@ -1,17 +1,3 @@
-// The one "assistant prose" predicate.
-//
-// REQUIRED INVARIANT, not incidental sharing: memory attribution
-// (core/memory-provenance-anchors.ts) selects the message id a footer
-// anchors to with this predicate, and the projection
-// (core/transcript-rows.ts) emits the assistant-text row — the footer's
-// ONLY host — under the same predicate. If the two ever disagree (one
-// side trims whitespace, or starts handling array content), an
-// attributed id can fail to project and footers silently stop
-// rendering, with no test naming the cause. Any change to what counts
-// as prose must happen HERE, once, for both consumers.
-/** The newest assistant message with visible prose — the only row kind
- *  a memory footer may render under (tool results, tool-call-only
- *  messages, and reasoning never host one). */
 export function newestAssistantProseIdOf(messages) {
     for (let index = messages.length - 1; index >= 0; index -= 1) {
         const message = messages[index];
@@ -23,4 +9,3 @@ export function newestAssistantProseIdOf(messages) {
     }
     return null;
 }
-//# sourceMappingURL=assistant-prose.js.map

package/dist/core/assistant-session-registry.d.ts

@@ -1,6 +1,6 @@
 import type { ServedAttachmentPolicy, ServedModelChoice, ServedSuggestionsConfig } from "../contract/assistant-config.js";
 import type { VisitorTier } from "../contract/identity.js";
-import type { SubscriptionStatus } from "../contract/subscriptions.js";
+import type { SubscriptionProvider, SubscriptionStatus } from "../contract/subscriptions.js";
 import type { AssistantTelemetryEvent } from "../contract/telemetry.js";
 import type { ServingApiError } from "../transport/serving-error.js";
 import { TokenSession } from "../transport/token-session.js";
@@ -8,120 +8,44 @@ import { type ConversationGate } from "./connect-gate.js";
 import { AssistantConversationStore, type HostCapabilities } from "./conversation-store.js";
 import { type ReadonlyCell } from "./observable-cell.js";
 export declare const DEFAULT_BASE_URL = "https://api.teaflask.com";
-/** The session's identity inputs — and nothing else. The token itself is
- *  mutable session state (re-mints overwrite it in place), so identity is
- *  whether the host wired a resolver, never the token's value. */
 export interface AssistantSessionSpec {
     publishableKey: string;
     baseUrl?: string;
-    identityProvided: boolean;
+    userId?: string;
 }
-/** One provider's wiring, registered for the lifetime of its retain. */
 export interface AssistantSessionRegistrant {
-    /** Null on a provider whose host never wired getEndUserToken. */
     resolveEndUserToken: (() => string | null | Promise<string | null>) | null;
-    /** Read fresh at each execution pass, exactly like the provider's own
-     *  latest-value ref underneath it. */
     hostCapabilitiesOf: () => HostCapabilities;
     reportError: (error: Error) => void;
-    /** Null on a provider whose host never wired onTelemetry. Fanned out to
-     *  every wired registrant — observability, exactly like reportError. */
     onTelemetry: ((event: AssistantTelemetryEvent) => void) | null;
 }
 export interface AssistantSessionEntry {
     readonly session: TokenSession;
     readonly store: AssistantConversationStore;
-    /** Null until the first mint answers; late registrants read the cached
-     *  verdict instead of waiting for a mint that already happened. */
     readonly tier: ReadonlyCell<VisitorTier | null>;
-    /** A loud mint failure (bad key, origin, or end-user signer). Shared on
-     *  purpose: the key is broken for every same-identity surface at once. */
     readonly setupError: ReadonlyCell<ServingApiError | null>;
-    /** The served suggestion sets, null until ensureAssistantConfig()'s
-     *  fetch answers — and forever on a surface that never asks. */
     readonly assistantConfig: ReadonlyCell<ServedSuggestionsConfig | null>;
-    /** The served attachment policy from the same fetch: what the composer
-     *  may offer. Null until the fetch answers — and null AFTER it where
-     *  the environment has no attachment storage, which hides the
-     *  affordance entirely. */
     readonly attachmentPolicy: ReadonlyCell<ServedAttachmentPolicy | null>;
-    /** The served model picker menu from the same fetch. Null
-     *  until the fetch answers — and null AFTER it when the agent's
-     *  operator has not enabled user model choice, which hides the picker
-     *  chip entirely (the provider chip keeps the shelf). */
     readonly modelChoice: ReadonlyCell<ServedModelChoice | null>;
-    /** Whether the config fetch has SETTLED (success or failure) — the
-     *  signal the nullable cells above cannot carry, because null means
-     *  both "not answered yet" and "answered: none". The composer shelf
-     *  reads it to hold the slot blank through the fetch window and then
-     *  fall back honestly on failure (the provider chip renders off the
-     *  separate subscriptions read). */
     readonly configAnswered: ReadonlyCell<boolean>;
-    /** Kicks the config fetch, single-flight: a success sticks for the
-     *  session, a failure leaves the cell null and lets a later mount retry.
-     *  Never an error surface — served suggestions are decoration, and a
-     *  surface without them still converses. Only ever called from a mount
-     *  effect; entry construction stays side-effect-free. */
     readonly ensureAssistantConfig: () => void;
-    /** Forces a config re-read — the gate's refresh moments: a settled
-     *  turn (the taster may have just crossed), a landed connect or
-     *  disconnect, a tier flip. The refreshSubscriptions superseding-flight
-     *  shape. */
     readonly refreshAssistantConfig: () => void;
-    /** What stands between this visitor and their next send — seeded by
-     *  the config read's pre-flight projection, corrected by send refusals
-     *  (the race window), re-read at every refresh moment above.
-     *  ConversationView renders it in the composer's place. */
     readonly conversationGate: ReadonlyCell<ConversationGate>;
-    /** Every provider's connect standing for this visitor, null
-     *  until ensureSubscriptions()'s fetch answers. Identified sessions
-     *  only — the GET 403s an anonymous bearer, so callers gate the kick
-     *  on the identified tier. */
     readonly subscriptions: ReadonlyCell<SubscriptionStatus[] | null>;
-    /** Kicks the subscriptions fetch, single-flight and self-evicting on
-     *  failure — the ensureAssistantConfig shape. Only ever called from a
-     *  mount effect, and only on an identified session. */
     readonly ensureSubscriptions: () => void;
-    /** Forces a re-fetch — the moment after a connect completes or a
-     *  disconnect lands, when the stored standing just changed. */
     readonly refreshSubscriptions: () => void;
-    /** A parked ask to open the provider chip's menu — set by
-     *  requestSubscriptionConnect, cleared only when a surface consumes it
-     *  (acknowledgeSubscriptionConnect). Lives on the entry, not in any
-     *  component: the minimized companion unmounts its chrome, and a ring
-     *  while minimized must be honored on the next expand, never dropped.
-     *  Send refusals no longer ring it — a gate refusal renders as the
-     *  composer's takeover card (conversationGate above); this ask remains
-     *  for the bench and for hosts that want to spotlight the chip. */
     readonly connectOpenRequested: ReadonlyCell<boolean>;
     readonly requestSubscriptionConnect: () => void;
     readonly acknowledgeSubscriptionConnect: () => void;
+    readonly planNoticeDue: ReadonlyCell<SubscriptionProvider | null>;
+    readonly notePlanSignedIn: (provider: SubscriptionProvider) => void;
+    readonly acknowledgePlanNotice: () => void;
 }
 export declare class AssistantSessionRegistry {
     private readonly entries;
-    /**
-     * Get-or-create, render-safe: both constructors are side-effect-free
-     * (no network, no timers, no listeners), so a discarded render leaves
-     * only an inert map entry that the next same-identity resolve reuses.
-     */
-    entryFor(spec: AssistantSessionSpec): AssistantSessionEntry;
-    /**
-     * Registers the provider's wiring and boots the store on the first
-     * retain (or revives it — `bootstrap()` resets a disposed store by
-     * design, so retain-after-sweep works). Returns the release; calling
-     * it twice is a no-op. The last release sweeps on a microtask, so
-     * StrictMode's synchronous release-then-retain never tears anything
-     * down, and only the sweep disposes the store and session.
-     */
+    entryFor(requested: AssistantSessionSpec): AssistantSessionEntry;
     retain(entry: AssistantSessionEntry, registrant: AssistantSessionRegistrant): () => void;
-    /** A retain that lands after the sweep emptied the map re-inserts the
-     *  entry, so the next entryFor resolves it again. If a successor entry
-     *  already took the key (a cross-root race through the microtask gap),
-     *  the stale entry simply runs unshared for its lifetime — benign. */
     private _reviveIfSwept;
     private _sweepIfStillUnretained;
 }
-/** The one instance every provider resolves through — the module scope
- *  shared by all React roots on the page is the whole mechanism. */
 export declare const assistantSessionRegistry: AssistantSessionRegistry;
-//# sourceMappingURL=assistant-session-registry.d.ts.map