@teaflask/assistant 0.3.0 → 0.7.0

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

@@ -1,13 +1,29 @@
 import type { ServingErrorCodeOnTheWire } from "../contract/errors.js";
 /**
- * A non-2xx answer from a /serving/v1 surface, decoded from the contract's
- * error envelope. `message` is the server's human sentence; the package
- * substitutes its own copy for the codes it knows (see error-copy.ts).
+ * Error for a non-2xx answer from the Teaflask API, passed to the provider's
+ * onError callback among others. Its message is the server's human-readable
+ * sentence, safe to show to the user.
  */
 export declare class ServingApiError extends Error {
+    /**
+     * The error code from the response, usually a ServingErrorCode. It is
+     * "UNKNOWN" when the response had no readable error body, and
+     * "END_USER_ID_MISMATCH" when the user the server verified is not the
+     * userId your page passed.
+     */
     readonly code: ServingErrorCodeOnTheWire;
+    /** The HTTP status code of the failed response. */
     readonly status: number;
+    /**
+     * Seconds to wait before retrying, read from the Retry-After header (for
+     * example on RATE_LIMITED); null when the server sent none.
+     */
     readonly retryAfterSeconds: number | null;
+    /**
+     * Extra structured data some codes carry, such as the providers list on
+     * SUBSCRIPTION_CONNECT_REQUIRED or the field errors on VALIDATION_ERROR;
+     * undefined when the server sent none.
+     */
     readonly details: unknown;
     constructor(options: {
         code: ServingErrorCodeOnTheWire;
@@ -18,4 +34,3 @@ export declare class ServingApiError extends Error {
     });
 }
 export declare function parseServingError(response: Response): Promise<ServingApiError>;
-//# sourceMappingURL=serving-error.d.ts.map

package/dist/transport/serving-error.js

@@ -1,19 +1,7 @@
-/**
- * A non-2xx answer from a /serving/v1 surface, decoded from the contract's
- * error envelope. `message` is the server's human sentence; the package
- * substitutes its own copy for the codes it knows (see error-copy.ts).
- */
 export class ServingApiError extends Error {
     code;
     status;
-    // From the Retry-After header when the server sent one (RATE_LIMITED
-    // and SUBSCRIPTION_CANNOT_PAY do; ASSISTANT_UNFUNDED deliberately does
-    // not — money, not time, changes that answer).
     retryAfterSeconds;
-    // The envelope's structured half, when the server sent one — e.g.
-    // SUBSCRIPTION_CONNECT_REQUIRED's `providers` list. Its reader is the
-    // connect gate (connect-gate.ts), which projects it for the connect
-    // panel, so that surface touches no transport code.
     details;
     constructor(options) {
         super(options.message);
@@ -43,8 +31,6 @@ async function _readEnvelopeIfPresent(response) {
         }
     }
     catch {
-        // A non-JSON error body (a proxy page, an empty response) still needs
-        // a usable error — the fallback envelope covers it.
     }
     return null;
 }
@@ -66,4 +52,3 @@ function _retryAfterSecondsOf(response) {
     const seconds = Number.parseInt(header, 10);
     return Number.isNaN(seconds) ? null : seconds;
 }
-//# sourceMappingURL=serving-error.js.map

package/dist/transport/serving-fetch.js

@@ -1,9 +1,9 @@
-// The Orval mutator behind every generated /serving/v1 call. Sessions are
-// per-provider (never module state), so each call carries its TokenSession
-// in the options — Orval propagates this type onto the generated functions'
-// options parameter.
 import { parseServingError } from "./serving-error.js";
 export async function servingFetch(url, init) {
+    const { body } = await servingFetchResponse(url, init);
+    return body;
+}
+export async function servingFetchResponse(url, init) {
     const { session, ...requestInit } = init;
     if (session === undefined) {
         throw new Error("This serving call has no TokenSession. Call it through the " +
@@ -13,11 +13,8 @@ export async function servingFetch(url, init) {
     if (!response.ok) {
         throw await parseServingError(response);
     }
-    // 204 carries no body by definition (the disconnect door answers it);
-    // .json() on the empty body would throw and turn a success into an error.
     if (response.status === 204) {
-        return undefined;
+        return { body: undefined, status: response.status };
     }
-    return (await response.json());
+    return { body: (await response.json()), status: response.status };
 }
-//# sourceMappingURL=serving-fetch.js.map

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

@@ -12,22 +12,6 @@ export interface ResumeSnapshot {
     afterId: string;
     messages: Message[];
 }
-/**
- * A conversation's resume state, held above the Transcript remount
- * boundary: reconnect works by remounting a fresh agent, so anything the
- * next connection needs must outlive the current one.
- *
- * A snapshot is a consistent pair — the applied message list and the
- * cursor of the newest received frame — recorded at any BLOCK-COMPLETE,
- * non-failed close that committed a cursor: a settled terminal, or the
- * parked contract's quiet close (a background attach seeds its
- * fresh agent from this pair, and a parked page whose close recorded
- * nothing would re-seed an EMPTY transcript). A snapshot is never proof
- * the run settled — only that the pair is consistent. A mid-BLOCK
- * interruption keeps the previous pair; the server re-delivers the
- * unsettled run in full from its boundary, and the seeded agent de-dupes
- * by the contract's stable ids.
- */
 export declare class StreamResumeStore {
     snapshot: ResumeSnapshot | null;
     readonly resumeAnchors: Map<string, unknown>;
@@ -50,13 +34,8 @@ export declare class StreamResumeStore {
     private readonly anchoredResumptions;
     private readonly anchoredFailedRuns;
     private readonly anchoredDeliveryRuns;
-    /** Returns false when this resumption already anchored. Keyed by run id
-     *  plus the payload's own (round, attempt) — a round-less legacy row by the
-     *  marker's stamped timestamp; premises: docs/stream-resume.md. */
     recordResumeAnchor(runId: string | null, messageId: string, markerValue: unknown, markerTimestamp: number | null): boolean;
-    /** Returns false when this failed run's receipt already anchored. */
     recordTurnFailedReceipts(failedRunId: string, messageId: string, position: keyof AnchoredTurnFailReceipts, receipts: string[]): boolean;
-    /** Returns false when this delivery run's receipt already anchored. */
     recordSubagentDelivery(deliveryRunId: string, messageId: string, results: DeliveredResult[]): boolean;
     recordToolError(toolCallId: string, errorText: string): void;
     recordToolRefusal(toolCallId: string, sentence: string): void;
@@ -70,47 +49,11 @@ export declare class StreamResumeStore {
     recordTurnUsage(usage: TurnUsage): void;
     recordMemoryUpdate(update: MemoryUpdated): void;
     recordMemoryAttribution(memoryId: string, messageId: string): void;
-    /** Records the resume pair. Named for what it records — a consistent
-     *  (messages, cursor) PAIR, at any block-complete close, terminal or
-     *  quiet — never an assertion that the run settled (the recording
-     *  rule lives at resumeSnapshotRecorder). */
     recordPair(afterId: string, messages: readonly Readonly<Message>[]): void;
 }
-/**
- * A run_resumed CUSTOM event never becomes a message, so it cannot be
- * read from the message list alone. This subscriber anchors each marker
- * to the first message that appears after it; the transcript's
- * severance scan reads the anchor to mark the prior attempt's
- * open calls as interrupted.
- */
 export declare function resumeMarkerRecorder(onResumeAnchored: (runId: string | null, messageId: string, markerValue: unknown, markerTimestamp: number | null) => void): AgentSubscriber;
-/**
- * The subscriber that records a resume pair: at any close that is
- * BLOCK-COMPLETE (every block START this connection applied has its END),
- * non-failed, and committed a cursor — terminal or quiet. The
- * premises, and what breaks if the gate is wrong: docs/stream-resume.md.
- *
- * A resumed stream that closed silently applied nothing and committed
- * no cursor — the cursor guard keeps the previous pair. The state
- * resets per run: one agent can be connected more than once, and a
- * stale failure must not veto (or stale completeness approve) a later
- * run's recording.
- *
- * Subscribe this through the component tree, never on a bare agent: only
- * the mounted agent's message list carries the injector's spliced user
- * messages, and an orphaned connection recording its bare list would
- * poison the store.
- */
 export declare function resumeSnapshotRecorder(cursorOf: () => string | null, store: StreamResumeStore): AgentSubscriber;
 type AuthorizedFetch = (url: string, requestInit: RequestInit) => Promise<Response>;
-/**
- * Reads the SSE `id:` lines off the raw response bytes. `@ag-ui/client`'s
- * parser surfaces only `data:` lines, so the cursor is captured by teeing
- * the body through a pass-through transform — bytes reach the parser
- * untouched. An id is committed only at its frame's terminating blank
- * line: an `id:` whose frame never completed was never dispatched by the
- * parser either, and must not advance the cursor.
- */
 export declare class SseFrameIdScanner {
     lastEventId: string | null;
     bodyBytesSeen: boolean;
@@ -125,4 +68,3 @@ export declare class SseFrameIdScanner {
     private _scanLine;
 }
 export {};
-//# sourceMappingURL=stream-resume.d.ts.map

package/dist/transport/stream-resume.js

@@ -13,129 +13,30 @@ import { EMPTY_TOOL_REFUSAL_ANCHORS, withToolRefusalAnchored, } from "../core/to
 import { EMPTY_TOOL_OFFLOAD_ANCHORS, withToolOffloadAnchored, } from "../core/tool-offload-anchors.js";
 import { EMPTY_SUBAGENT_DELIVERY_ANCHORS, withSubagentDeliveryAnchored, } from "../core/subagent-delivery-anchors.js";
 import { EMPTY_TURN_FAILED_ANCHORS, withTurnFailedAnchored, } from "../core/turn-failed-anchors.js";
-/**
- * A conversation's resume state, held above the Transcript remount
- * boundary: reconnect works by remounting a fresh agent, so anything the
- * next connection needs must outlive the current one.
- *
- * A snapshot is a consistent pair — the applied message list and the
- * cursor of the newest received frame — recorded at any BLOCK-COMPLETE,
- * non-failed close that committed a cursor: a settled terminal, or the
- * parked contract's quiet close (a background attach seeds its
- * fresh agent from this pair, and a parked page whose close recorded
- * nothing would re-seed an EMPTY transcript). A snapshot is never proof
- * the run settled — only that the pair is consistent. A mid-BLOCK
- * interruption keeps the previous pair; the server re-delivers the
- * unsettled run in full from its boundary, and the seeded agent de-dupes
- * by the contract's stable ids.
- */
 export class StreamResumeStore {
     snapshot = null;
-    // Resume anchors survive remounts here: a resumed stream never replays
-    // the historical run_resumed markers the severance scan reads.
-    // Each anchor keeps its marker's raw payload as provenance — the wire
-    // (round, attempt) the arbitration key was derived from.
     resumeAnchors = new Map();
-    // Failure-receipt anchors survive remounts for a sharper reason than
-    // their siblings: a failed run's recorded RUN_ERROR demotes to
-    // RUN_FINISHED on replay, but the turn_failed marker replays verbatim,
-    // so a reconnect re-anchors it idempotently. Same degrade seam.
     turnFailedAnchors = EMPTY_TURN_FAILED_ANCHORS;
-    // The four tool-outcome anchor families below survive remounts for the
-    // same reason: the transport lifts the wire's TOOL_CALL_RESULT extras
-    // into event metadata (core/tool-outcome.ts) and the 1.0 client carries
-    // that metadata onto the tool message it mints, but a snapshot-seeded
-    // reconnect replays only past the cursor — so these maps and sets are
-    // what re-anchors historical calls, and the read path the projection
-    // consults for every call.
     toolErrorAnchors = EMPTY_TOOL_ERROR_ANCHORS;
     toolRefusalAnchors = EMPTY_TOOL_REFUSAL_ANCHORS;
     toolCancelAnchors = EMPTY_TOOL_CANCEL_ANCHORS;
     toolOffloadAnchors = EMPTY_TOOL_OFFLOAD_ANCHORS;
-    // Tool-decision anchors: the durable "a member decision rode
-    // this call" record the placement hold reads. The card stores prune at
-    // the gated call's result and the turn's settle by design, and a
-    // snapshot-seeded reconnect replays only past the cursor, so this set
-    // is the decision-bearing calls' only durable home.
     toolDecisionAnchors = EMPTY_TOOL_DECISION_ANCHORS;
-    // The tool-denial ledger: the durable "a member declined this
-    // call's approval" record the state ladder reads, joined from the two
-    // approval markers. The inbox card that knew the same fact dies to the
-    // gated call's cancelled result by design, and a snapshot-seeded
-    // reconnect replays only past the cursor — so this ledger is the
-    // denied calls' only durable home, and its ask map is what lets a
-    // resolution streamed after the cursor still find its call.
     toolDenialLedger = EMPTY_TOOL_DENIAL_LEDGER;
-    // Display anchors survive remounts for the same reason: the
-    // tool_call_annotated marker never becomes a message, and a
-    // snapshot-seeded reconnect replays only past the cursor, so this map
-    // is historical rows' only source of backend-authored copy.
     toolCallDisplayAnchors = EMPTY_TOOL_CALL_DISPLAY_ANCHORS;
-    // Schema anchors survive remounts for the same reason: the
-    // schemas ride the same marker's siblings (and the approval card's
-    // fields), never a message, so this map is the calls' only client home
-    // for argsSchema / resultSchema.
     toolSchemaAnchors = EMPTY_TOOL_SCHEMA_ANCHORS;
-    // Delivery-receipt anchors survive remounts for the same reason: a
-    // snapshot-seeded reconnect replays only past the cursor, so the
-    // historical subagent_results_delivered markers the dividers were
-    // derived from never re-arrive on the wire. Same degrade seam: the
-    // transcript re-validates on seed, so a malformed entry becomes a
-    // missing row, never a wedged resume.
     subagentDeliveryAnchors = EMPTY_SUBAGENT_DELIVERY_ANCHORS;
-    // Block-timing anchors survive remounts for the same reason:
-    // the client carries no per-event server timestamp onto the messages it
-    // builds, and a snapshot-seeded reconnect replays only past the cursor,
-    // so this map is historical blocks' only timing home.
-    // Unlike every sibling anchor, the backing map MUTATES: timing moves
-    // on every block boundary, and a copy-per-write would cost O(N) per
-    // event — O(N²) over an N-block replay — so blockTimingRevision, not
-    // map identity, is the change signal (entries stay immutable; the
-    // snapshot derivation copies before publishing).
     blockTimingRevision = 0;
     _blockTimingAnchors = new Map();
     get blockTimingAnchors() {
         return this._blockTimingAnchors;
     }
-    // Turn-usage anchors survive remounts for the same reason:
-    // the turn_usage_recorded marker never becomes a message. Absence
-    // means usage unknown — the number hides, never estimates.
     turnUsageAnchors = EMPTY_TURN_USAGE_ANCHORS;
-    // Memory-provenance anchors survive remounts for the same
-    // reason: the memory_updated marker never becomes a message. Keyed by
-    // the durable memory id, so re-deliveries reconcile, never duplicate.
     memoryProvenanceAnchors = EMPTY_MEMORY_PROVENANCE_ANCHORS;
-    // Memory-attribution anchors: memory id → the assistant
-    // prose message its footer renders under. Survives remounts with its
-    // provenance sibling; first attribution wins (the anchor family's
-    // drifted-message arbitration), so a re-delivery never moves a footer.
     memoryAttributionAnchors = EMPTY_MEMORY_ATTRIBUTION_ANCHORS;
-    // One anchor per RESUMPTION, ever: the parked snapshot's
-    // cursor sits inside an unsettled run, so a background attach's
-    // boundary-snap re-delivers that run in full — content filtered,
-    // CUSTOM markers passed by design — and an unarbitrated run_resumed
-    // would flush under a drifted message id (the first post-attach
-    // message). Keyed by run id plus the payload's own (round, attempt)
-    // — round-less legacy rows by their event's stamped timestamp — wire
-    // data either way, no client-side counting; the premise
-    // lives at recordResumeAnchor.
     anchoredResumptions = new Set();
-    // One receipt row per failed run, ever: re-deliveries (StrictMode's
-    // double connection, every reconnect's replay) flush against whatever
-    // the message list holds at that moment, so the same receipt can try
-    // to anchor under a different message id. First anchor wins.
     anchoredFailedRuns = new Set();
-    // One divider per delivery run, ever: a re-delivery flushes against
-    // whatever the message list holds at that moment, so the same divider
-    // can try to anchor under a drifted message id — the run's own id
-    // arbitrates, first anchor wins.
     anchoredDeliveryRuns = new Set();
-    /** Returns false when this resumption already anchored. Keyed by run id
-     *  plus the payload's own (round, attempt) — a round-less legacy row by the
-     *  marker's stamped timestamp; premises: docs/stream-resume.md. */
-    // markerTimestamp is REQUIRED, not defaulted: the untimed collapse
-    // branch is a documented degradation, and a caller must say null out
-    // loud to land on it — never arrive there by omitting an argument.
     recordResumeAnchor(runId, messageId, markerValue, markerTimestamp) {
         const attempt = _wireCounterOf(markerValue, "attempt");
         const carriesRound = typeof markerValue === "object" &&
@@ -148,12 +49,9 @@ export class StreamResumeStore {
             return false;
         }
         this.anchoredResumptions.add(key);
-        // Null, never undefined: consumers read presence with .get(), and a
-        // payload-less legacy marker must still read as anchored.
         this.resumeAnchors.set(messageId, markerValue ?? null);
         return true;
     }
-    /** Returns false when this failed run's receipt already anchored. */
     recordTurnFailedReceipts(failedRunId, messageId, position, receipts) {
         if (this.anchoredFailedRuns.has(failedRunId)) {
             return false;
@@ -162,7 +60,6 @@ export class StreamResumeStore {
         this.turnFailedAnchors = withTurnFailedAnchored(this.turnFailedAnchors, messageId, position, receipts);
         return true;
     }
-    /** Returns false when this delivery run's receipt already anchored. */
     recordSubagentDelivery(deliveryRunId, messageId, results) {
         if (this.anchoredDeliveryRuns.has(deliveryRunId)) {
             return false;
@@ -209,19 +106,10 @@ export class StreamResumeStore {
     recordMemoryAttribution(memoryId, messageId) {
         this.memoryAttributionAnchors = withMemoryAttributed(this.memoryAttributionAnchors, memoryId, messageId);
     }
-    /** Records the resume pair. Named for what it records — a consistent
-     *  (messages, cursor) PAIR, at any block-complete close, terminal or
-     *  quiet — never an assertion that the run settled (the recording
-     *  rule lives at resumeSnapshotRecorder). */
     recordPair(afterId, messages) {
         this.snapshot = { afterId, messages: structuredClone([...messages]) };
     }
 }
-/** The tolerant wire read behind the resume arbitration key (the
- *  approval-inbox idiom): legacy markers may carry no payload at all,
- *  so a missing or non-numeric field reads as 0. Round-less rows never
- *  reach the round read — the key's legacy branch uses the event's
- *  stamped timestamp instead (see recordResumeAnchor). */
 function _wireCounterOf(payload, field) {
     if (typeof payload !== "object" || payload === null) {
         return 0;
@@ -229,21 +117,7 @@ function _wireCounterOf(payload, field) {
     const value = payload[field];
     return typeof value === "number" ? value : 0;
 }
-/**
- * A run_resumed CUSTOM event never becomes a message, so it cannot be
- * read from the message list alone. This subscriber anchors each marker
- * to the first message that appears after it; the transcript's
- * severance scan reads the anchor to mark the prior attempt's
- * open calls as interrupted.
- */
 export function resumeMarkerRecorder(onResumeAnchored) {
-    // Null (never undefined) doubles as both "no marker pending" reset and
-    // a payload-less legacy marker; pendingMarker tracks presence itself.
-    // The marker remembers the run it rode in on, plus the event's own
-    // stamped timestamp (read off the raw event, because the apply pipeline
-    // drops it); the store derives the arbitration key from the run id and the
-    // payload's own (round, attempt), falling back to the timestamp for
-    // round-less legacy rows — no ordinal is counted here.
     let pendingMarker = null;
     let currentRunId = null;
     return {
@@ -270,23 +144,6 @@ export function resumeMarkerRecorder(onResumeAnchored) {
         },
     };
 }
-/**
- * The subscriber that records a resume pair: at any close that is
- * BLOCK-COMPLETE (every block START this connection applied has its END),
- * non-failed, and committed a cursor — terminal or quiet. The
- * premises, and what breaks if the gate is wrong: docs/stream-resume.md.
- *
- * A resumed stream that closed silently applied nothing and committed
- * no cursor — the cursor guard keeps the previous pair. The state
- * resets per run: one agent can be connected more than once, and a
- * stale failure must not veto (or stale completeness approve) a later
- * run's recording.
- *
- * Subscribe this through the component tree, never on a bare agent: only
- * the mounted agent's message list carries the injector's spliced user
- * messages, and an orphaned connection recording its bare list would
- * poison the store.
- */
 export function resumeSnapshotRecorder(cursorOf, store) {
     let failed = false;
     const openBlocks = new Set();
@@ -295,9 +152,6 @@ export function resumeSnapshotRecorder(cursorOf, store) {
             failed = false;
             openBlocks.clear();
         },
-        // The pipeline routes run lifecycle to the dedicated handlers and
-        // everything else (content, markers) through onEvent — where the
-        // block ledger tracks every START against its END.
         onEvent({ event }) {
             const edge = _blockEdgeOf(event);
             if (edge === null) {
@@ -314,8 +168,6 @@ export function resumeSnapshotRecorder(cursorOf, store) {
             failed = true;
         },
         onRunFinalized({ messages }) {
-            // By finalize the scanner has seen every byte the parser
-            // dispatched, so the cursor and the applied messages agree.
             const cursor = cursorOf();
             if (!failed && openBlocks.size === 0 && cursor !== null) {
                 store.recordPair(cursor, messages);
@@ -323,10 +175,6 @@ export function resumeSnapshotRecorder(cursorOf, store) {
         },
     };
 }
-/** The block ledger's edges: which events open a content block and which
- *  close it, keyed so unrelated block families cannot cancel each other.
- *  Atomic events (TOOL_CALL_RESULT, markers, lifecycle) hold no open
- *  state and return null. */
 function _blockEdgeOf(event) {
     const messageKey = () => `message:${event.messageId}`;
     const toolKey = () => `tool:${event.toolCallId}`;
@@ -351,26 +199,9 @@ function _blockEdgeOf(event) {
             return null;
     }
 }
-// The id: line carries a decimal integer by contract; anything else on
-// the wire is not a cursor and must not be echoed back.
 const DECIMAL_ID = /^\d+$/;
-/**
- * Reads the SSE `id:` lines off the raw response bytes. `@ag-ui/client`'s
- * parser surfaces only `data:` lines, so the cursor is captured by teeing
- * the body through a pass-through transform — bytes reach the parser
- * untouched. An id is committed only at its frame's terminating blank
- * line: an `id:` whose frame never completed was never dispatched by the
- * parser either, and must not advance the cursor.
- */
 export class SseFrameIdScanner {
     lastEventId = null;
-    // Whether THIS connection's SSE body has delivered any bytes at all —
-    // keepalive comment frames included, since they never commit a cursor
-    // but do prove the wire was alive past the headers. The liveness fact
-    // for failure classification, kept apart from lastEventId on
-    // purpose: the replay cursor answers "what do we replay past", not
-    // "did bytes flow", and overloading it misread keepalive-only
-    // connections as never-responded.
     bodyBytesSeen = false;
     buffer = "";
     pendingId = null;
@@ -390,9 +221,6 @@ export class SseFrameIdScanner {
             });
         };
     }
-    // A hand-rolled pump instead of pipeThrough(TransformStream): the pipe's
-    // internal promise surfaces source errors as unhandled rejections (Node),
-    // while a rejecting pull() errors the stream through a handled path.
     _scannedCopyOf(body) {
         const reader = body.getReader();
         return new ReadableStream({
@@ -405,14 +233,9 @@ export class SseFrameIdScanner {
                 this._scan(value);
                 controller.enqueue(value);
             },
-            // Cancelling an already-errored source rejects; the stream is being
-            // abandoned either way, so that rejection must not escape.
             cancel: (reason) => reader.cancel(reason).catch(() => undefined),
         });
     }
-    // A retried connection must not inherit the previous body's partial
-    // line or frame — nor its liveness fact; the committed cursor survives
-    // on purpose.
     _resetConnectionState() {
         this.buffer = "";
         this.pendingId = null;
@@ -451,4 +274,3 @@ function _isEventStream(response) {
     const contentType = response.headers.get("content-type") ?? "";
     return contentType.startsWith("text/event-stream");
 }
-//# sourceMappingURL=stream-resume.js.map

package/dist/transport/token-session.d.ts

@@ -1,29 +1,23 @@
 import type { MintVisitorTokenResponse } from "../contract/identity.js";
 import { ServingApiError } from "./serving-error.js";
+export declare const END_USER_ID_MISMATCH = "END_USER_ID_MISMATCH";
 export interface TokenSessionConfig {
     publishableKey: string;
     baseUrl: string;
     getEndUserToken?: () => string | null | Promise<string | null>;
+    expectedEndUserId?: string;
     claimThreadId?: () => string | null;
     onMinted?: (response: MintVisitorTokenResponse) => void;
     onMintFailed?: (error: ServingApiError) => void;
 }
-/**
- * The visitor-token lifecycle in one place: mint on first need, re-mint
- * proactively before expiry, retry any 401 exactly once after a forced
- * re-mint, and retry the sign-in-required 403 exactly once when the
- * forced re-mint comes back identified (the visitor signed in after the
- * cached token was minted; without this the widget would keep serving
- * the stale anonymous token until the proactive re-mint). Every other
- * transport call goes through `authorizedFetch`, so streams and REST
- * calls share the same lifecycle.
- */
 export declare class TokenSession {
     readonly baseUrl: string;
     private readonly config;
     private visitorToken;
     private mintInFlight;
     private remintTimer;
+    private transientFailureReported;
+    private _generation;
     constructor(config: TokenSessionConfig);
     readonly authorizedFetch: (url: string, requestInit?: RequestInit) => Promise<Response>;
     dispose(): void;
@@ -31,8 +25,9 @@ export declare class TokenSession {
     private _remintAfterRejection;
     private _mintSingleFlight;
     private _mint;
+    private _reportMintFailure;
     private _buildMintRequest;
     private _scheduleProactiveRemint;
+    private _armRemint;
     private _clearRemintTimer;
 }
-//# sourceMappingURL=token-session.d.ts.map