@teaflask/assistant 0.3.0 → 0.6.0

package/dist/transport/door-budget.js

@@ -1,19 +1,3 @@
-// The tool-results door refuses results whose serialized JSON passes 20k
-// chars — measured server-side with ensure_ascii escaping and spaced
-// separators — and a refused POST would strand the turn until it parks.
-// Every client-side size bound on a deliverable payload must therefore be
-// taken against a CEILING of the door's own metric, never against raw JS
-// string length: non-ASCII re-escapes into 6-char \uXXXX sequences and a
-// truncated-text payload re-escapes its quotes, either of which can
-// inflate a "small" payload past the cap. Shared by whichever producer
-// ships text through the door (action responses, page reads).
-/**
- * A ceiling on the length the tool-results door will measure for a
- * client-serialized JSON text: the door re-serializes with ensure_ascii
- * (every non-ASCII UTF-16 unit becomes a 6-char \uXXXX) and spaced
- * separators (every comma and colon may gain a space). In-string commas
- * are over-counted — a ceiling never needs to be exact, only never under.
- */
 export function doorLengthCeilingOf(serialized) {
     let length = 0;
     for (let index = 0; index < serialized.length; index += 1) {
@@ -21,7 +5,7 @@ export function doorLengthCeilingOf(serialized) {
         if (code > 0x7f) {
             length += 6;
         }
-        else if (code === 0x2c /* , */ || code === 0x3a /* : */) {
+        else if (code === 0x2c || code === 0x3a) {
             length += 2;
         }
         else {
@@ -30,12 +14,6 @@ export function doorLengthCeilingOf(serialized) {
     }
     return length;
 }
-/**
- * Truncate by what each unit will cost once this text rides as a JSON
- * string through the door's ensure_ascii serializer, at worst case — a
- * raw-length cut could still blow the cap on re-escaping. Never splits a
- * surrogate pair.
- */
 export function boundedTextOf(text, maxEscapedChars) {
     let budget = maxEscapedChars;
     let end = 0;
@@ -48,11 +26,10 @@ export function boundedTextOf(text, maxEscapedChars) {
         end += 1;
     }
     if (end > 0 && _isHighSurrogate(text.charCodeAt(end - 1))) {
-        end -= 1; // never cut a surrogate pair in half
+        end -= 1;
     }
     return text.slice(0, end);
 }
-/** The worst-case door footprint of a whole text inside a JSON string. */
 export function doorCostOfText(text) {
     let cost = 0;
     for (let index = 0; index < text.length; index += 1) {
@@ -60,12 +37,11 @@ export function doorCostOfText(text) {
     }
     return cost;
 }
-/** The worst-case door footprint of one UTF-16 unit inside a JSON string. */
 export function escapedCostOf(code) {
     if (code > 0x7f || code < 0x20) {
         return 6;
     }
-    if (code === 0x22 /* " */ || code === 0x5c /* \ */) {
+    if (code === 0x22 || code === 0x5c) {
         return 2;
     }
     return 1;
@@ -73,4 +49,3 @@ export function escapedCostOf(code) {
 function _isHighSurrogate(code) {
     return code >= 0xd800 && code <= 0xdbff;
 }
-//# sourceMappingURL=door-budget.js.map

package/dist/transport/replay-stream-agent.d.ts

@@ -8,14 +8,6 @@ export interface ServingReplayStreamAgentConfig {
     authorizedFetch: (url: string, requestInit: RequestInit) => Promise<Response>;
     resume?: StreamResumeStore;
 }
-/**
- * AG-UI client for the serving thread stream. The endpoint is watch-only
- * and treats attach and run identically — every connection replays the
- * recorded log and then tails it — so connecting is just running. With a
- * resume snapshot the replay is asked to start past the cursor instead of
- * from the beginning; the transcript is byte-equivalent either way, which
- * is what keeps full replay the always-correct fallback.
- */
 export declare class ServingReplayStreamAgent extends HttpAgent {
     private readonly scanner;
     private readonly seededSnapshot;
@@ -30,4 +22,3 @@ export declare class ServingReplayStreamAgent extends HttpAgent {
     private _replaceAbortControllerIfAborted;
     private _alreadySeeded;
 }
-//# sourceMappingURL=replay-stream-agent.d.ts.map

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

@@ -1,20 +1,8 @@
 import { HttpAgent } from "@ag-ui/client";
 import { EventType } from "@ag-ui/core";
-// A compatible range (^7.8.0) so host resolvers dedupe onto
-// @ag-ui/client's exact rxjs pin rather than installing a second copy —
-// rxjs is only named so the emitted declaration can type connect()'s
-// Observable and the overlap filter can ride the returned pipeline.
 import { filter } from "rxjs";
 import { liftToolOutcome } from "../core/tool-outcome.js";
 import { SseFrameIdScanner, StreamResumeStore, } from "./stream-resume.js";
-/**
- * AG-UI client for the serving thread stream. The endpoint is watch-only
- * and treats attach and run identically — every connection replays the
- * recorded log and then tails it — so connecting is just running. With a
- * resume snapshot the replay is asked to start past the cursor instead of
- * from the beginning; the transcript is byte-equivalent either way, which
- * is what keeps full replay the always-correct fallback.
- */
 export class ServingReplayStreamAgent extends HttpAgent {
     scanner;
     seededSnapshot;
@@ -34,13 +22,6 @@ export class ServingReplayStreamAgent extends HttpAgent {
             snapshot === null ? new Set() : _contentIdsOf(snapshot.messages);
         this._reseedWhenTheHostWipesTheList();
     }
-    // CopilotKit's chat clears a non-empty agent message list when it
-    // mounts (its first thread sync sees an unknown thread), which erases
-    // the constructor's initialMessages seeding. onRunInitialized runs
-    // inside connectAgent AFTER that wipe and BEFORE the apply pipeline
-    // captures its message baseline, so re-seeding here is what actually
-    // sticks; on an agent whose list survived (bare transports, tests) the
-    // non-empty guard makes this a no-op.
     _reseedWhenTheHostWipesTheList() {
         this.subscribe({
             onRunInitialized: ({ messages }) => {
@@ -52,21 +33,12 @@ export class ServingReplayStreamAgent extends HttpAgent {
             },
         });
     }
-    // The newest cursor received on this agent's connection — what the
-    // resume-snapshot recorder pairs with the applied messages at settle.
     get resumeCursor() {
         return this.scanner.lastEventId;
     }
-    // Whether this agent's connection delivered any SSE body bytes at all,
-    // keepalive pings included — the liveness fact failure classification
-    // needs, deliberately not inferred from the replay cursor
-    // (a live-but-idle stream commits no frame).
     get sawBodyBytes() {
         return this.scanner.bodyBytesSeen;
     }
-    // Every path in — connect() below and the client's own runAgent() — funnels
-    // through run(), ahead of the client's schema enforcement: the one seam
-    // where the wire's tool-outcome extras can still be lifted into metadata.
     run(input) {
         return liftToolOutcome(super.run(input));
     }
@@ -76,22 +48,11 @@ export class ServingReplayStreamAgent extends HttpAgent {
         if (snapshot === null) {
             return this.run(input);
         }
-        // The filter de-dupes re-delivered content by the contract's stable
-        // ids before the verifier sees it: the boundary snap re-delivers an
-        // interrupted run in full, and a server that ignores the cursor full-
-        // replays onto the seeded list — where @ag-ui/client would duplicate
-        // tool calls (TOOL_CALL_START pushes unconditionally).
         return this.run(_resumedPast(input, snapshot.afterId)).pipe(filter((event) => !this._alreadySeeded(event)));
     }
-    // The endpoint is watch-only by contract: a seeded agent must not
-    // upload its whole transcript in the RunAgentInput body on every
-    // reconnect (prepareRunAgentInput serializes this.messages).
     requestInit(input) {
         return super.requestInit({ ...input, messages: [] });
     }
-    // abortRun() aborts the controller and never replaces it; without this a
-    // remounted surface (React StrictMode, back-navigation) would reconnect
-    // with an already-aborted signal and die instantly.
     _replaceAbortControllerIfAborted() {
         if (this.abortController.signal.aborted) {
             this.abortController = new AbortController();
@@ -114,9 +75,6 @@ export class ServingReplayStreamAgent extends HttpAgent {
             case EventType.TOOL_CALL_END:
                 return this.seededContentIds.has(event.toolCallId);
             default:
-                // Lifecycle framing and markers pass: RUN_STARTED re-delivery is
-                // idempotent downstream (the injector guards by message id), and
-                // dropping a terminal would leave the run unclosed.
                 return false;
         }
     }
@@ -128,9 +86,6 @@ function _resumedPast(input, afterId) {
         forwardedProps: { ...forwardedProps, after_id: afterId },
     };
 }
-// Every id the stream can re-deliver content under: message ids of all
-// roles (tool results dedupe by their tool message's id) plus the tool
-// call ids inside assistant messages.
 function _contentIdsOf(messages) {
     const ids = new Set();
     for (const message of messages) {
@@ -143,4 +98,3 @@ function _contentIdsOf(messages) {
     }
     return ids;
 }
-//# sourceMappingURL=replay-stream-agent.js.map

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

@@ -2,13 +2,9 @@ import type { GetServingAssistantThreadParams, ListServingAssistantThreadsParams
 import type { AssistantConfigResponse } from "../contract/assistant-config.js";
 import type { ThreadDispatch } from "../contract/dispatches.js";
 import type { AssistantThreadDetailResponse, AttachmentUploadIntent, ResolveTurnApprovalRequest, ResolveTurnApprovalResponse, ResolveTurnToolResultsRequest, ResolveTurnToolResultsResponse, SendAssistantMessageRequest, SendAssistantMessageResponse, ServingAssistantThread, ServingAttachment, StopTurnResponse } from "../contract/threads.js";
-import type { SubscriptionDeviceAuthorization, SubscriptionDeviceAuthorizationPoll, SubscriptionProvider, SubscriptionStatus } from "../contract/subscriptions.js";
+import type { SubscriptionAuthorization, SubscriptionAuthorizationCompletion, SubscriptionAuthorizationCompletionRequest, SubscriptionProvider, SubscriptionStatus } from "../contract/subscriptions.js";
 import type { TokenSession } from "./token-session.js";
 export declare function sendAssistantMessage(session: TokenSession, request: SendAssistantMessageRequest): Promise<SendAssistantMessageResponse>;
-/** The stop door: thread-scoped on purpose — the server's
- *  thread pointer names the live turn (liveness, never recency), so the
- *  caller never picks one. Every answer is a receipt, including
- *  already_settled: the button races the answer by nature. */
 export declare function stopAssistantTurn(session: TokenSession, threadId: string): Promise<StopTurnResponse>;
 export declare function listAssistantThreads(session: TokenSession, params?: ListServingAssistantThreadsParams): Promise<ServingAssistantThread[]>;
 export declare function getAssistantThread(session: TokenSession, threadId: string, params?: GetServingAssistantThreadParams): Promise<AssistantThreadDetailResponse>;
@@ -23,18 +19,15 @@ export declare function createAttachmentUpload(session: TokenSession, request: {
 export declare function finalizeAttachment(session: TokenSession, attachmentId: string): Promise<ServingAttachment>;
 export declare function getAttachmentDownloadUrl(session: TokenSession, attachmentId: string): Promise<ServingAttachmentDownloadUrlResponse>;
 export declare function listSubscriptions(session: TokenSession): Promise<SubscriptionStatus[]>;
-export declare function beginSubscriptionDeviceAuthorization(session: TokenSession, provider: SubscriptionProvider): Promise<SubscriptionDeviceAuthorization>;
-export declare function pollSubscriptionDeviceAuthorization(session: TokenSession, provider: SubscriptionProvider, sealedAuthorization: string): Promise<SubscriptionDeviceAuthorizationPoll>;
+export declare function beginSubscriptionAuthorization(session: TokenSession, provider: SubscriptionProvider): Promise<SubscriptionAuthorization>;
+export declare function completeSubscriptionAuthorization(session: TokenSession, provider: SubscriptionProvider, request: SubscriptionAuthorizationCompletionRequest): Promise<SubscriptionAuthorizationCompletion>;
 export declare function disconnectSubscription(session: TokenSession, provider: SubscriptionProvider): Promise<void>;
-/**
- * The direct-to-storage PUT: a plain fetch against the presigned URL —
- * no auth header (the signature is the credential), no Content-Type (the
- * server sniffs the stored bytes; the signature pins only the length).
- */
+interface SubscriptionRecheckAnswer {
+    standing: SubscriptionStatus;
+    probeStarted: boolean;
+}
+export declare function recheckSubscription(session: TokenSession, provider: SubscriptionProvider): Promise<SubscriptionRecheckAnswer>;
 export declare function putFileToUploadUrl(uploadUrl: string, file: Blob): Promise<void>;
 export declare function streamUrlForThread(session: TokenSession, threadId: string): string;
-/** The child transcript stream: one dispatched subagent's own
- *  replay-then-tail, addressed by the thread and the child session id —
- *  the only child handle on the serving wire. */
 export declare function streamUrlForChild(session: TokenSession, threadId: string, childSessionId: string): string;
-//# sourceMappingURL=serving-api.d.ts.map
+export {};

package/dist/transport/serving-api.js

@@ -1,15 +1,8 @@
-// The session-scoped face over the generated /serving/v1 client: every
-// call threads its TokenSession into the mutator, so streams and REST
-// calls share one token lifecycle. Signatures stay the package's own —
-// components never see the generated layer.
-import { createDeviceAuthorization as createDeviceAuthorizationOperation, createServingAttachmentUpload as createServingAttachmentUploadOperation, disconnectSubscription as disconnectSubscriptionOperation, finalizeServingAttachment as finalizeServingAttachmentOperation, getServingAttachmentDownloadUrl as getServingAttachmentDownloadUrlOperation, getServingAssistantThread as getServingAssistantThreadOperation, listServingAssistantThreadDispatches as listServingAssistantThreadDispatchesOperation, listServingAssistantThreads as listServingAssistantThreadsOperation, listServingSubscriptions as listServingSubscriptionsOperation, pollDeviceAuthorization as pollDeviceAuthorizationOperation, readAssistantConfig as readAssistantConfigOperation, resolveServingAssistantTurnApproval as resolveServingAssistantTurnApprovalOperation, resolveServingAssistantTurnToolResults as resolveServingAssistantTurnToolResultsOperation, sendServingAssistantMessage as sendServingAssistantMessageOperation, stopServingAssistantTurn as stopServingAssistantTurnOperation, } from "../generated/serving.js";
+import { beginSubscriptionAuthorization as beginSubscriptionAuthorizationOperation, completeSubscriptionAuthorization as completeSubscriptionAuthorizationOperation, createServingAttachmentUpload as createServingAttachmentUploadOperation, disconnectSubscription as disconnectSubscriptionOperation, getRecheckSubscriptionUrl, finalizeServingAttachment as finalizeServingAttachmentOperation, getServingAttachmentDownloadUrl as getServingAttachmentDownloadUrlOperation, getServingAssistantThread as getServingAssistantThreadOperation, listServingAssistantThreadDispatches as listServingAssistantThreadDispatchesOperation, listServingAssistantThreads as listServingAssistantThreadsOperation, listServingSubscriptions as listServingSubscriptionsOperation, readAssistantConfig as readAssistantConfigOperation, resolveServingAssistantTurnApproval as resolveServingAssistantTurnApprovalOperation, resolveServingAssistantTurnToolResults as resolveServingAssistantTurnToolResultsOperation, sendServingAssistantMessage as sendServingAssistantMessageOperation, stopServingAssistantTurn as stopServingAssistantTurnOperation, } from "../generated/serving.js";
+import { servingFetchResponse, } from "./serving-fetch.js";
 export async function sendAssistantMessage(session, request) {
     return sendServingAssistantMessageOperation(request, _withSession(session));
 }
-/** The stop door: thread-scoped on purpose — the server's
- *  thread pointer names the live turn (liveness, never recency), so the
- *  caller never picks one. Every answer is a receipt, including
- *  already_settled: the button races the answer by nature. */
 export async function stopAssistantTurn(session, threadId) {
     return stopServingAssistantTurnOperation(threadId, _withSession(session));
 }
@@ -44,39 +37,31 @@ export async function listSubscriptions(session) {
     const response = await listServingSubscriptionsOperation(_withSession(session));
     return response.subscriptions;
 }
-export async function beginSubscriptionDeviceAuthorization(session, provider) {
-    return createDeviceAuthorizationOperation(provider, _withSession(session));
+export async function beginSubscriptionAuthorization(session, provider) {
+    return beginSubscriptionAuthorizationOperation(provider, _withSession(session));
 }
-export async function pollSubscriptionDeviceAuthorization(session, provider, sealedAuthorization) {
-    return pollDeviceAuthorizationOperation(provider, { sealed_authorization: sealedAuthorization }, _withSession(session));
+export async function completeSubscriptionAuthorization(session, provider, request) {
+    return completeSubscriptionAuthorizationOperation(provider, request, _withSession(session));
 }
 export async function disconnectSubscription(session, provider) {
     await disconnectSubscriptionOperation(provider, _withSession(session));
 }
-/**
- * The direct-to-storage PUT: a plain fetch against the presigned URL —
- * no auth header (the signature is the credential), no Content-Type (the
- * server sniffs the stored bytes; the signature pins only the length).
- */
+export async function recheckSubscription(session, provider) {
+    const { body, status } = await servingFetchResponse(getRecheckSubscriptionUrl(provider), { ..._withSession(session), method: "POST" });
+    return { standing: body, probeStarted: status === 202 };
+}
 export async function putFileToUploadUrl(uploadUrl, file) {
     const response = await fetch(uploadUrl, { method: "PUT", body: file });
     if (!response.ok) {
         throw new Error(`The file upload failed (${String(response.status)}).`);
     }
 }
-// The stream endpoints are deliberately absent from the generated client
-// (they speak SSE through replay-stream-agent, not JSON); their paths are
-// pinned to serving-openapi.json by tests/contract-parity.
 export function streamUrlForThread(session, threadId) {
     return `${session.baseUrl}/serving/v1/assistant-threads/${threadId}/stream`;
 }
-/** The child transcript stream: one dispatched subagent's own
- *  replay-then-tail, addressed by the thread and the child session id —
- *  the only child handle on the serving wire. */
 export function streamUrlForChild(session, threadId, childSessionId) {
     return `${session.baseUrl}/serving/v1/assistant-threads/${threadId}/dispatches/${childSessionId}/stream`;
 }
 function _withSession(session) {
     return { session };
 }
-//# sourceMappingURL=serving-api.js.map

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

@@ -1,9 +1,4 @@
 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).
- */
 export declare class ServingApiError extends Error {
     readonly code: ServingErrorCodeOnTheWire;
     readonly status: number;
@@ -18,4 +13,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.d.ts

@@ -3,4 +3,9 @@ export type ServingRequestInit = RequestInit & {
     session?: TokenSession;
 };
 export declare function servingFetch<Body>(url: string, init: ServingRequestInit): Promise<Body>;
-//# sourceMappingURL=serving-fetch.d.ts.map
+interface ServingResponse<Body> {
+    body: Body;
+    status: number;
+}
+export declare function servingFetchResponse<Body>(url: string, init: ServingRequestInit): Promise<ServingResponse<Body>>;
+export {};

package/dist/transport/serving-fetch.js

@@ -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