@stll/chat 0.1.39 → 0.1.40

package/README.md

@@ -26,3 +26,12 @@ const runtime = createChatRuntime({ transport });
 Validate every explicit provider/model selection with
 `resolveChatModelSelection`. It rejects unknown, empty, duplicate, and
 unconfigured provider/model combinations with `ChatConfigurationError`.
+
+For TanStack hosts, `@stll/chat/durable-transport` exports
+`createDurableChatTransport`: pass its `connection` and `persistence` to
+`ChatClient`, call `attach()` while a viewer is mounted and `detach()` when it
+leaves. The host supplies authenticated probe/join URLs and transcript reload
+callbacks. Resume state comes from the server; this adapter stores no transcript
+on the device. Network retries rejoin the log with the last event cursor and
+jittered backoff, bounded to three minutes. Detaching keeps an accepted server
+turn running; the host must use the turn cancellation endpoint for Stop.

package/dist/.bun/install/cache/links/@tanstack_ai-event-client@0.13.1-c12313b8e0f930fe/node_modules/@tanstack/ai-event-client/dist/esm/envelope.d.ts

@@ -0,0 +1,5 @@
+//#region ../../../../../.bun/install/cache/links/@tanstack+ai-event-client@0.13.1-c12313b8e0f930fe/node_modules/@tanstack/ai-event-client/dist/esm/envelope.d.ts
+declare global {
+  var __TANSTACK_AI_DEVTOOLS_RUNTIME_ID__: string | undefined;
+}
+export {};

package/dist/.bun/install/cache/links/@tanstack_ai-event-client@0.13.1-c12313b8e0f930fe/node_modules/@tanstack/ai-event-client/dist/esm/index.d.ts

@@ -0,0 +1,141 @@
+import "../../../../../../@tanstack_devtools-event-client@0.4.4-93caf0d86e8c814b/node_modules/@tanstack/devtools-event-client/dist/esm/index.js";
+import "./envelope.js";
+//#region ../../../../../.bun/install/cache/links/@tanstack+ai-event-client@0.13.1-c12313b8e0f930fe/node_modules/@tanstack/ai-event-client/dist/esm/index.d.ts
+/**
+ * Detailed breakdown of prompt/input token usage.
+ * Fields are populated based on provider support.
+ */
+export interface PromptTokensDetails {
+  /** Tokens read from cache */
+  cachedTokens?: number;
+  /** Tokens written to cache */
+  cacheWriteTokens?: number;
+  /** Audio input tokens */
+  audioTokens?: number;
+  /** Video input tokens */
+  videoTokens?: number;
+  /** Image input tokens */
+  imageTokens?: number;
+  /** Text input tokens */
+  textTokens?: number;
+  /** Document input tokens (e.g. PDF inputs on Gemini) */
+  documentTokens?: number;
+}
+/**
+ * Detailed breakdown of completion/output token usage.
+ * Fields are populated based on provider support.
+ */
+export interface CompletionTokensDetails {
+  /** Reasoning/thinking tokens */
+  reasoningTokens?: number;
+  /** Audio output tokens */
+  audioTokens?: number;
+  /** Video output tokens */
+  videoTokens?: number;
+  /** Image output tokens */
+  imageTokens?: number;
+  /** Text output tokens */
+  textTokens?: number;
+  /** Document output tokens */
+  documentTokens?: number;
+}
+/**
+ * Provider-reported cost breakdown for a single request, normalized onto a
+ * canonical shape so consumer code is portable across gateways. Each adapter's
+ * extractor maps its provider-specific wire keys (e.g. OpenRouter's
+ * `upstream_inference_prompt_cost`, `upstream_inference_input_cost`) onto these
+ * fields at runtime.
+ */
+export interface UsageCostBreakdown {
+  /** Total cost the gateway paid the upstream provider. */
+  upstreamCost?: number;
+  /** Upstream cost for input (prompt) tokens. */
+  upstreamInputCost?: number;
+  /** Upstream cost for output (completion) tokens. */
+  upstreamOutputCost?: number;
+}
+/**
+ * Unit a billed quantity is counted in. The named members cover the units
+ * TanStack AI adapters bill in today; the `(string & {})` member keeps the
+ * union open for genuinely provider-specific units while preserving
+ * autocompletion for the common ones.
+ */
+export type BillingUnit = 'tokens' | 'seconds' | 'characters' | 'images' | 'videos' | 'megapixels' | 'requests' | 'units' | (string & {});
+/**
+ * A billed quantity paired with the unit it is counted in, so consumers can
+ * label and aggregate usage without out-of-band knowledge of the provider or
+ * activity. `unit: 'units'` marks an opaque provider-defined unit (e.g. fal's
+ * "fal units") whose price is only knowable from the provider's pricing page.
+ */
+export interface BilledUsage {
+  /** Number of units billed. */
+  quantity: number;
+  /** The unit `quantity` is counted in. */
+  unit: BillingUnit;
+}
+/**
+ * Default value type for {@link TokenUsage.providerUsageDetails} when an adapter
+ * does not supply a specific shape. Values are constrained to non-nullish
+ * (`NonNullable<unknown>`, i.e. `{}`) rather than `unknown` so that `TokenUsage`
+ * stays assignable across JSON-serialization boundaries — e.g. TanStack Start's
+ * server-fn return types model serializable values as `{}` and reject `unknown`,
+ * which permits `null`/`undefined`.
+ */
+export type ProviderUsageDetails = Record<string, NonNullable<unknown>>;
+/**
+ * Canonical token usage for a run, with optional detailed breakdowns and
+ * provider-reported cost. This is the single source of truth re-exported by
+ * `@tanstack/ai`.
+ *
+ * Core fields (`promptTokens`, `completionTokens`, `totalTokens`) are always
+ * present. Detail fields are provider-dependent and absent when not reported,
+ * so consumers must treat them as optional.
+ *
+ * `providerUsageDetails` is parameterized via `TProviderDetails` so adapters can
+ * surface a strongly-typed bag (e.g. `TokenUsage<AnthropicProviderUsageDetails>`);
+ * it defaults to {@link ProviderUsageDetails} (an open, serializable record) for
+ * generic consumers.
+ */
+export interface TokenUsage<TProviderDetails = ProviderUsageDetails> {
+  /** Total input/prompt tokens */
+  promptTokens: number;
+  /** Total output/completion tokens */
+  completionTokens: number;
+  /** Total tokens as reported by the provider; may exceed promptTokens +
+   * completionTokens when reasoning/cache/tool tokens are billed separately. */
+  totalTokens: number;
+  /** Detailed breakdown of prompt tokens by category */
+  promptTokensDetails?: PromptTokensDetails;
+  /** Detailed breakdown of completion tokens by category */
+  completionTokensDetails?: CompletionTokensDetails;
+  /**
+   * The primary non-token billed quantity, self-describing via its unit —
+   * e.g. `{ quantity: 8, unit: 'seconds' }` for a video generation or
+   * `{ quantity: 3, unit: 'units' }` for fal's opaque endpoint units. Absent
+   * when the activity bills purely in tokens (the token fields above are
+   * already self-describing). When a provider bills tokens *on top of* a media
+   * unit, the tokens stay in the token fields and `billed` carries the media
+   * unit. A quantity, distinct from the monetary `cost` / `costDetails`.
+   */
+  billed?: BilledUsage;
+  /**
+   * @deprecated Read {@link TokenUsage.billed} instead, which pairs the same
+   * duration with an explicit `unit: 'seconds'`. Still populated alongside
+   * `billed` for backward compatibility; will be removed in a future release.
+   */
+  durationSeconds?: number;
+  /**
+   * @deprecated Read {@link TokenUsage.billed} instead, which pairs the same
+   * count with the unit it is denominated in (`seconds`, `units`, …) — this
+   * bare count is ambiguous across providers. Still populated alongside
+   * `billed` for backward compatibility; will be removed in a future release.
+   */
+  unitsBilled?: number;
+  /** Provider-specific usage details not covered by standard fields */
+  providerUsageDetails?: TProviderDetails;
+  /** Provider-reported cost for the request, when available. */
+  cost?: number;
+  /** Provider-reported cost breakdown, when available. */
+  costDetails?: UsageCostBreakdown;
+}
+//#endregion

package/dist/.bun/install/cache/links/@tanstack_devtools-event-client@0.4.4-93caf0d86e8c814b/node_modules/@tanstack/devtools-event-client/dist/esm/index.d.ts

@@ -0,0 +1 @@
+import "./plugin.js";

package/dist/.bun/install/cache/links/@tanstack_devtools-event-client@0.4.4-93caf0d86e8c814b/node_modules/@tanstack/devtools-event-client/dist/esm/plugin.d.ts

@@ -0,0 +1,5 @@
+//#region ../../../../../.bun/install/cache/links/@tanstack+devtools-event-client@0.4.4-93caf0d86e8c814b/node_modules/@tanstack/devtools-event-client/dist/esm/plugin.d.ts
+declare global {
+  var __TANSTACK_EVENT_TARGET__: EventTarget | null;
+}
+export {};

package/dist/durable-transport.d.ts

@@ -0,0 +1,68 @@
+import { AGUIEvent, ActivityDeltaEvent as ActivityDeltaEvent$1, ActivitySnapshotEvent as ActivitySnapshotEvent$1, ContentPart, CustomEvent as CustomEvent$1, MessagesSnapshotEvent as MessagesSnapshotEvent$1, ModelMessage, RawEvent as RawEvent$1, ReasoningEncryptedValueEvent as ReasoningEncryptedValueEvent$1, ReasoningEndEvent as ReasoningEndEvent$1, ReasoningMessageChunkEvent as ReasoningMessageChunkEvent$1, ReasoningMessageContentEvent as ReasoningMessageContentEvent$1, ReasoningMessageEndEvent as ReasoningMessageEndEvent$1, ReasoningMessageStartEvent as ReasoningMessageStartEvent$1, ReasoningStartEvent as ReasoningStartEvent$1, RunErrorEvent as RunErrorEvent$1, RunFinishedEvent as RunFinishedEvent$1, RunStartedEvent as RunStartedEvent$1, StateDeltaEvent as StateDeltaEvent$1, StateSnapshotEvent as StateSnapshotEvent$1, StepFinishedEvent as StepFinishedEvent$1, StepStartedEvent as StepStartedEvent$1, SubagentErrorEvent as SubagentErrorEvent$1, SubagentFinishedEvent as SubagentFinishedEvent$1, SubagentStartedEvent as SubagentStartedEvent$1, TextMessageChunkEvent as TextMessageChunkEvent$1, TextMessageContentEvent as TextMessageContentEvent$1, TextMessageEndEvent as TextMessageEndEvent$1, TextMessageStartEvent as TextMessageStartEvent$1, ToolCallArgsEvent as ToolCallArgsEvent$1, ToolCallChunkEvent as ToolCallChunkEvent$1, ToolCallEndEvent as ToolCallEndEvent$1, ToolCallResultEvent as ToolCallResultEvent$1, ToolCallStartEvent as ToolCallStartEvent$1, UIMessage as UIMessage$1 } from "./work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/types.js";
+import "./work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/index.js";
+import { ChatTurnResumeProbe } from "./resume-contract.js";
+import { EventType } from "@ag-ui/core";
+import { UIMessage } from "@tanstack/ai-client";
+//#region src/durable-transport.d.ts
+declare const ChatReconnectError_base: import("better-result").TaggedErrorClass<"ChatReconnectError">;
+export declare class ChatReconnectError extends ChatReconnectError_base<{
+  cause?: unknown;
+  code?: "invalid-response" | "refused";
+  message: string;
+}> {}
+export type ChatResumeProbe = ChatTurnResumeProbe;
+declare const waitForReconnect: (delay: number, signal: AbortSignal | null | undefined) => Promise<void>;
+type ChatLoadedTurn = {
+  type: "active";
+} | {
+  type: "parked";
+  runId: string;
+} | {
+  type: "settled";
+};
+type DurableChatTransportOptions<TMessages extends UIMessage[]> = {
+  initialMessages: TMessages;
+  initialTurn: ChatLoadedTurn;
+  threadId: string;
+  /** Server truth is checked on mount and before every read-only retry. */
+  probe: (signal?: AbortSignal | null) => Promise<ChatResumeProbe>;
+  joinUrl: () => string;
+  sendUrl: string;
+  fetchClient: typeof fetch;
+  onReconnectChange: (reconnecting: boolean) => void;
+  onTranscript: () => void;
+  onError: (error: ChatReconnectError) => void;
+  random?: () => number;
+  now?: () => number;
+  wait?: typeof waitForReconnect;
+};
+/** Shared by hosts: cache no legal text or run pointer on the device. The
+ * SDK's persistence contract restores its run from the authenticated server. */
+export declare const createDurableChatTransport: <TMessages extends UIMessage[]>({ initialMessages, initialTurn, threadId, probe, joinUrl, sendUrl, fetchClient, onReconnectChange, onTranscript, onError, random, now, wait }: DurableChatTransportOptions<TMessages>) => {
+  connection: {
+    connect(messages: UIMessage$1<unknown>[] | ModelMessage<string | ContentPart<unknown, unknown, unknown, unknown, unknown>[] | null>[], data?: Record<string, any> | undefined, abortSignal?: AbortSignal | undefined, runContext?: import("@tanstack/ai-client").RunAgentInputContext | undefined): AsyncGenerator<AGUIEvent, void, unknown>;
+    joinRun(runId: string, signal?: AbortSignal): AsyncGenerator<ActivitySnapshotEvent$1 | ActivityDeltaEvent$1 | RawEvent$1 | TextMessageChunkEvent$1 | ToolCallChunkEvent$1 | ReasoningMessageChunkEvent$1 | RunStartedEvent$1 | RunFinishedEvent$1 | RunErrorEvent$1 | TextMessageStartEvent$1 | TextMessageContentEvent$1 | TextMessageEndEvent$1 | ToolCallStartEvent$1 | ToolCallArgsEvent$1 | ToolCallEndEvent$1 | ToolCallResultEvent$1 | StepStartedEvent$1 | StepFinishedEvent$1 | MessagesSnapshotEvent$1 | StateSnapshotEvent$1 | StateDeltaEvent$1 | CustomEvent$1 | ReasoningStartEvent$1 | ReasoningMessageStartEvent$1 | ReasoningMessageContentEvent$1 | ReasoningMessageEndEvent$1 | ReasoningEndEvent$1 | ReasoningEncryptedValueEvent$1 | SubagentStartedEvent$1 | SubagentFinishedEvent$1 | SubagentErrorEvent$1 | {
+      readonly type: EventType.CUSTOM;
+      readonly name: "stella.chat.rejoin-attached";
+      readonly value: {
+        readonly runId: string;
+        readonly threadId: string;
+      };
+    }, void, unknown>;
+  };
+  persistence: {
+    getItem: (resumedThreadId: string) => Promise<{
+      resume?: {
+        resumeState: {
+          threadId: string;
+          runId: string;
+        };
+        pendingInterrupts?: import("@ag-ui/core").Interrupt[];
+      };
+      messages: TMessages;
+    } | undefined>;
+    setItem: () => undefined;
+    removeItem: () => undefined;
+  };
+};
+//#endregion

package/dist/durable-transport.js

@@ -0,0 +1,239 @@
+import { chatTurnResumeProbeSchema } from "./resume-contract.js";
+import { Result, TaggedError, panic } from "better-result";
+import { EventType } from "@ag-ui/core";
+import { fetchServerSentEvents } from "@tanstack/ai-client";
+import * as v from "valibot";
+//#region src/durable-transport.ts
+var ChatReconnectError = class extends TaggedError("ChatReconnectError") {};
+const RECONNECT_WINDOW_MS = 18e4;
+const MAX_RECONNECT_DELAY_MS = 15e3;
+const REJOIN_ATTACHED_EVENT = "stella.chat.rejoin-attached";
+const reconnectDelay = ({ attempt, jitter }) => Math.min(MAX_RECONNECT_DELAY_MS, 500 * 2 ** Math.min(attempt, 8)) * (.5 + jitter * .5);
+const waitForReconnect = async (delay, signal) => await new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(new ChatReconnectError({
+			message: "Chat reconnect aborted.",
+			cause: signal.reason
+		}));
+		return;
+	}
+	const abort = () => {
+		clearTimeout(timer);
+		reject(new ChatReconnectError({
+			message: "Chat reconnect aborted.",
+			cause: signal?.reason
+		}));
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", abort);
+		resolve();
+	}, delay);
+	signal?.addEventListener("abort", abort, { once: true });
+});
+const loadedTurnNeedsRefresh = (loaded, transcript) => {
+	switch (loaded.type) {
+		case "active": return true;
+		case "parked": return transcript.resumeSnapshot?.resumeState.runId !== loaded.runId;
+		case "settled": return false;
+		default: return panic(loaded);
+	}
+};
+const terminalChatResponse = ({ runId, resume, onTranscript, onReconnectChange }) => {
+	onTranscript();
+	onReconnectChange(false);
+	return new Response(`data: ${JSON.stringify({
+		type: "RUN_FINISHED",
+		runId,
+		...resume?.pendingInterrupts === void 0 ? {} : { outcome: {
+			type: "interrupt",
+			interrupts: resume.pendingInterrupts
+		} }
+	})}\n\n`, { headers: { "Content-Type": "text/event-stream" } });
+};
+const createChatResumePersistence = ({ initialMessages, initialTurn, probe, onReconnectChange, onTranscript, onError, random, now, wait }) => {
+	let initialTurnState = initialTurn;
+	return {
+		getItem: async (resumedThreadId) => {
+			const began = now();
+			let retries = 0;
+			while (now() - began < RECONNECT_WINDOW_MS) {
+				const result = await Result.tryPromise(async () => await probe());
+				if (Result.isError(result) && result.error.cause instanceof ChatReconnectError && result.error.cause.code !== void 0) {
+					onReconnectChange(false);
+					onError(result.error.cause);
+					return;
+				}
+				if (Result.isOk(result)) switch (result.value.type) {
+					case "running": return {
+						messages: initialMessages,
+						resume: { resumeState: {
+							threadId: resumedThreadId,
+							runId: result.value.runId
+						} }
+					};
+					case "transcript":
+						if (loadedTurnNeedsRefresh(initialTurnState, result.value)) {
+							initialTurnState = { type: "settled" };
+							onTranscript();
+						}
+						onReconnectChange(false);
+						return {
+							messages: initialMessages,
+							...result.value.resumeSnapshot === void 0 ? {} : { resume: result.value.resumeSnapshot }
+						};
+					case "preparing": break;
+					default: return panic(result.value);
+				}
+				onReconnectChange(true);
+				await wait(reconnectDelay({
+					attempt: retries,
+					jitter: random()
+				}), void 0);
+				retries += 1;
+			}
+			onReconnectChange(false);
+			onError(new ChatReconnectError({ message: "Chat resume timed out." }));
+		},
+		setItem: () => void 0,
+		removeItem: () => void 0
+	};
+};
+/** Shared by hosts: cache no legal text or run pointer on the device. The
+* SDK's persistence contract restores its run from the authenticated server. */
+const createDurableChatTransport = ({ initialMessages, initialTurn, threadId, probe, joinUrl, sendUrl, fetchClient, onReconnectChange, onTranscript, onError, random = Math.random, now = () => performance.now(), wait = waitForReconnect }) => {
+	let reconnectStartedAt;
+	let attempt = 0;
+	const resumableFetch = Object.assign(async (input, init) => {
+		const headers = new Headers(init?.headers);
+		if (!(init?.method === "GET" || headers.has("Last-Event-ID"))) {
+			reconnectStartedAt = void 0;
+			attempt = 0;
+			return await fetchClient(input, init);
+		}
+		const source = new URL(input instanceof Request ? input.url : String(input));
+		const runId = source.searchParams.get("runId") ?? headers.get("X-Run-Id") ?? "";
+		onReconnectChange(true);
+		reconnectStartedAt ??= now();
+		while (!init?.signal?.aborted) {
+			if (now() - reconnectStartedAt >= RECONNECT_WINDOW_MS) throw new ChatReconnectError({ message: "Chat reconnection timed out." });
+			if (attempt > 0) await wait(reconnectDelay({
+				attempt: attempt - 1,
+				jitter: random()
+			}), init?.signal);
+			attempt += 1;
+			const result = await Result.tryPromise(async () => {
+				const state = await probe(init?.signal);
+				switch (state.type) {
+					case "transcript": return terminalChatResponse({
+						runId,
+						resume: state.resumeSnapshot,
+						onTranscript,
+						onReconnectChange
+					});
+					case "preparing": return;
+					case "running":
+						if (state.runId !== runId) return terminalChatResponse({
+							runId,
+							onTranscript,
+							onReconnectChange
+						});
+						break;
+					default: return panic(state);
+				}
+				const target = new URL(joinUrl());
+				target.searchParams.set("runId", runId);
+				target.searchParams.set("lastEventId", source.searchParams.get("offset") ?? "-1");
+				const response = await fetchClient(target, {
+					...init,
+					method: "GET",
+					body: null
+				});
+				if (!response.ok) {
+					const message = `Chat rejoin failed (${response.status}).`;
+					throw response.status === 401 || response.status === 403 || response.status === 404 ? new ChatReconnectError({
+						code: "refused",
+						message
+					}) : new ChatReconnectError({ message });
+				}
+				if (response.headers.get("Content-Type")?.includes("application/json")) {
+					const body = await response.json();
+					const parsed = v.safeParse(chatTurnResumeProbeSchema, body);
+					if (!parsed.success || parsed.output.type === "running") throw new ChatReconnectError({
+						code: "invalid-response",
+						message: "Invalid chat rejoin response."
+					});
+					switch (parsed.output.type) {
+						case "preparing": return;
+						case "transcript": return terminalChatResponse({
+							runId,
+							resume: parsed.output.resumeSnapshot,
+							onTranscript,
+							onReconnectChange
+						});
+						default: return panic(parsed.output);
+					}
+				}
+				onReconnectChange(false);
+				return response;
+			});
+			if (Result.isOk(result) && result.value !== void 0) return result.value;
+			if (Result.isError(result) && result.error.cause instanceof ChatReconnectError && result.error.cause.code !== void 0) {
+				onError(result.error.cause);
+				return new Response(null, { status: 502 });
+			}
+			if (init?.signal?.aborted) throw init.signal.reason;
+		}
+		throw init.signal.reason;
+	}, { preconnect: () => void 0 });
+	const persistence = createChatResumePersistence({
+		initialMessages,
+		initialTurn,
+		probe,
+		onReconnectChange,
+		onTranscript,
+		onError,
+		random,
+		now,
+		wait
+	});
+	const upstream = fetchServerSentEvents(sendUrl, {
+		credentials: "include",
+		headers: { "Content-Type": "application/json" },
+		fetchClient: resumableFetch,
+		reconnect: {
+			delayMs: 0,
+			maxAttempts: 100
+		}
+	});
+	const progress = () => {
+		reconnectStartedAt = void 0;
+		attempt = 0;
+	};
+	return {
+		connection: {
+			async *connect(...args) {
+				for await (const chunk of upstream.connect(...args)) {
+					progress();
+					yield chunk;
+				}
+			},
+			async *joinRun(runId, signal) {
+				yield {
+					type: EventType.CUSTOM,
+					name: REJOIN_ATTACHED_EVENT,
+					value: {
+						runId,
+						threadId
+					}
+				};
+				for await (const chunk of upstream.joinRun(runId, signal)) {
+					progress();
+					yield chunk;
+				}
+			}
+		},
+		persistence
+	};
+};
+//#endregion
+export { ChatReconnectError, createDurableChatTransport };

package/dist/resume-contract.d.ts

@@ -0,0 +1,32 @@
+import { Interrupt } from "@ag-ui/core";
+import * as v from "valibot";
+//#region src/resume-contract.d.ts
+/** Keep native interrupt validation tied to the protocol's owning schema. */
+export declare const chatResumeSnapshotSchema: v.ObjectSchema<{
+  readonly resumeState: v.ObjectSchema<{
+    readonly threadId: v.StringSchema<undefined>;
+    readonly runId: v.StringSchema<undefined>;
+  }, undefined>;
+  readonly pendingInterrupts: v.ExactOptionalSchema<v.ArraySchema<v.CustomSchema<Interrupt, undefined>, undefined>, undefined>;
+}, undefined>;
+/** Server truth for reconnecting readers; no local pointer establishes ownership. */
+export declare const chatTurnResumeProbeSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"preparing", undefined>;
+  readonly turnId: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"running", undefined>;
+  readonly turnId: v.StringSchema<undefined>;
+  readonly runId: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"transcript", undefined>;
+  readonly turnId: v.StringSchema<undefined>;
+  readonly resumeSnapshot: v.ExactOptionalSchema<v.ObjectSchema<{
+    readonly resumeState: v.ObjectSchema<{
+      readonly threadId: v.StringSchema<undefined>;
+      readonly runId: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly pendingInterrupts: v.ExactOptionalSchema<v.ArraySchema<v.CustomSchema<Interrupt, undefined>, undefined>, undefined>;
+  }, undefined>, undefined>;
+}, undefined>], undefined>;
+export type ChatTurnResumeProbe = v.InferOutput<typeof chatTurnResumeProbeSchema>;
+//#endregion

package/dist/resume-contract.js

@@ -0,0 +1,30 @@
+import * as v from "valibot";
+import { InterruptSchema } from "@ag-ui/core/schemas";
+//#region src/resume-contract.ts
+/** Keep native interrupt validation tied to the protocol's owning schema. */
+const chatResumeSnapshotSchema = v.object({
+	resumeState: v.object({
+		threadId: v.string(),
+		runId: v.string()
+	}),
+	pendingInterrupts: v.exactOptional(v.array(v.custom((value) => InterruptSchema.safeParse(value).success)))
+});
+/** Server truth for reconnecting readers; no local pointer establishes ownership. */
+const chatTurnResumeProbeSchema = v.variant("type", [
+	v.object({
+		type: v.literal("preparing"),
+		turnId: v.string()
+	}),
+	v.object({
+		type: v.literal("running"),
+		turnId: v.string(),
+		runId: v.string()
+	}),
+	v.object({
+		type: v.literal("transcript"),
+		turnId: v.string(),
+		resumeSnapshot: v.exactOptional(chatResumeSnapshotSchema)
+	})
+]);
+//#endregion
+export { chatResumeSnapshotSchema, chatTurnResumeProbeSchema };

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/activity-records.d.ts

@@ -0,0 +1 @@
+import "../../types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/adapter.d.ts

@@ -0,0 +1,2 @@
+import "../../types.js";
+import "../../utilities/adapter-yield-chunk.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/agent-loop-strategies.d.ts

@@ -0,0 +1 @@
+import "../../types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/agents/define-agent.d.ts

@@ -0,0 +1,4 @@
+import "../../../types.js";
+import "../../../interrupt-definition.js";
+import "../tools/tool-definition.js";
+import { SubagentInfo } from "@ag-ui/core";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/agents/route.d.ts

@@ -0,0 +1,3 @@
+import "./define-agent.js";
+import "./spawn.js";
+import "../../evaluate/index.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/agents/spawn.d.ts

@@ -0,0 +1,6 @@
+import "../../../utilities/ag-ui-usage.js";
+import "../../../types.js";
+import "./define-agent.js";
+import "../middleware/types.js";
+import "./turn.js";
+import "../../../index.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/agents/turn.d.ts

@@ -0,0 +1 @@
+import "../../../types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/cancel.d.ts

@@ -0,0 +1 @@
+import "./middleware/run-store.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/index.d.ts

@@ -0,0 +1,9 @@
+import "../../types.js";
+import "./adapter.js";
+import "../../interrupt-definition.js";
+import "./agents/define-agent.js";
+import "./middleware/types.js";
+import "./agents/spawn.js";
+import "./middleware/builder.js";
+import "./runtime-context-types.js";
+import "./mcp/types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/mcp/manager.d.ts

@@ -0,0 +1,2 @@
+import "../tools/tool-definition.js";
+import "./types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/mcp/types.d.ts

@@ -0,0 +1 @@
+import "../tools/tool-definition.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.d.ts

@@ -0,0 +1,2 @@
+import "../../types.js";
+import "@ag-ui/core";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/builder.d.ts

@@ -0,0 +1,3 @@
+import "../../../interrupt-definition.js";
+import "./types.js";
+import "./define.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/compose.d.ts

@@ -0,0 +1,3 @@
+import "../../../types.js";
+import "../../../interrupt-definition.js";
+import "./types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/define.d.ts

@@ -0,0 +1,2 @@
+import "../../../interrupt-definition.js";
+import "./types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/generic-interrupts.d.ts

@@ -0,0 +1 @@
+import "../../../interrupt-definition.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/index.d.ts

@@ -0,0 +1,8 @@
+import "./types.js";
+import "./define.js";
+import "./builder.js";
+import "./locks.js";
+import "./run-store.js";
+import "./generic-interrupts.js";
+import "./compose.js";
+import "./validate.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/locks.d.ts

@@ -0,0 +1 @@
+import "./types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/run-store.d.ts

@@ -0,0 +1 @@
+import "../../../types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/types.d.ts

@@ -0,0 +1,3 @@
+import "../../../interrupts.js";
+import "../../../types.js";
+import "../../../interrupt-definition.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/middleware/validate.d.ts

@@ -0,0 +1 @@
+import "./types.js";

package/dist/work/stella/stella/node_modules/.bun/@tanstack_ai@0.65.1_9c170ad6cb10badb/node_modules/@tanstack/ai/dist/esm/activities/chat/runtime-context-types.d.ts

@@ -0,0 +1 @@
+import "./middleware/types.js";