@astralbeam/sdk 0.0.6 → 0.2.0

package/dist/index-DtIS-V14.d.ts

@@ -0,0 +1,3706 @@
+//#region node_modules/.deno/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1$1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1$1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1$1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: StandardJSONSchemaV1.Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /**
+   * The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/interrupts.d.ts
+interface InterruptCorrelation {
+  threadId: string;
+  interruptedRunId: string;
+  generation: number;
+  submissionId?: string;
+  continuationRunId?: string;
+}
+type ItemInterruptErrorCode = 'invalid-payload' | 'invalid-edited-args' | 'invalid-tool-output' | 'invalid-response-schema' | 'unknown-interrupt' | 'expired' | 'stale' | 'conflict' | 'legacy-unsupported';
+type BatchInterruptErrorCode = 'incomplete-batch' | 'item-validation-failed' | 'unsupported-bulk-operation' | 'async-resolver' | 'inactive-transaction' | 'mixed-provenance' | 'transport' | 'server' | 'protocol' | 'invalid-response-schema' | 'expired' | 'stale' | 'conflict' | 'legacy-submit-failed';
+interface ItemInterruptError extends InterruptCorrelation {
+  scope: 'item';
+  interruptId: string;
+  code: ItemInterruptErrorCode;
+  message: string;
+  path?: ReadonlyArray<string | number>;
+  source: 'client' | 'server';
+  retryable: boolean;
+}
+interface BatchInterruptError extends InterruptCorrelation {
+  scope: 'batch';
+  code: BatchInterruptErrorCode;
+  message: string;
+  source: 'client' | 'server' | 'transport';
+  retryable: boolean;
+  interruptIds: ReadonlyArray<string>;
+}
+type InterruptSubmissionError = ItemInterruptError | BatchInterruptError;
+/**
+ * Wire version of {@link InterruptBinding}.
+ *
+ * The binding is the only part of an AG-UI `Interrupt` that this package
+ * claims — it rides in `metadata` under
+ * {@link INTERRUPT_BINDING_METADATA_KEY} and tells the resume path how to
+ * correlate an answer back to a paused run. Producers stamp `v`; readers
+ * reject any version they don't understand rather than duck-typing the fields.
+ *
+ * That matters because an AG-UI `Interrupt` is a shared envelope. Another
+ * producer — a workflow engine projecting a durable approval, a third-party
+ * agent — can legitimately put its own binding in the same envelope. Versioning
+ * makes "not mine" a clean rejection instead of a partial match that resumes
+ * against the wrong owner.
+ */
+declare const INTERRUPT_BINDING_VERSION: 1;
+interface InterruptBindingBase {
+  /** @see INTERRUPT_BINDING_VERSION */
+  v: typeof INTERRUPT_BINDING_VERSION;
+  interruptId: string;
+  interruptedRunId: string;
+  generation: number;
+  expiresAt?: string;
+}
+interface ResponseSchemaInterruptBindingBase extends InterruptBindingBase {
+  responseSchemaHash: string;
+}
+type InterruptBinding = (ResponseSchemaInterruptBindingBase & {
+  kind: 'tool-approval';
+  toolName: string;
+  toolCallId: string;
+  originalArgs: unknown;
+  inputSchemaHash: string;
+  approvalSchemaHash: string;
+}) | (ResponseSchemaInterruptBindingBase & {
+  kind: 'client-tool-execution';
+  toolName: string;
+  toolCallId: string;
+  outputSchemaHash: string;
+}) | (InterruptBindingBase & {
+  kind: 'generic'; /** Omitted when the generic interrupt accepts an unvalidated response. */
+  responseSchemaHash?: string; /** Present only for a first-party generic interrupt. */
+  definitionId?: string;
+  key?: string;
+  batchIndex?: number;
+  payloadSchemaHash?: string;
+});
+//#endregion
+//#region node_modules/.deno/@tanstack+devtools-event-client@0.4.4/node_modules/@tanstack/devtools-event-client/dist/esm/plugin.d.ts
+declare global {
+  var __TANSTACK_EVENT_TARGET__: EventTarget | null;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-event-client@0.10.0/node_modules/@tanstack/ai-event-client/dist/esm/envelope.d.ts
+type AIDevtoolsEventSource = 'client' | 'server' | 'devtools';
+type AIDevtoolsEventVisibility = 'user-visible' | 'client-state' | 'server-internal' | 'devtools-action';
+interface AIDevtoolsEventEnvelope {
+  eventId: string;
+  eventType: string;
+  timestamp: number;
+  source: AIDevtoolsEventSource;
+  visibility: AIDevtoolsEventVisibility;
+  runtimeId?: string;
+  clientId?: string;
+  requestId?: string;
+  streamId?: string;
+  hookId?: string;
+  threadId?: string;
+  runId?: string;
+  messageId?: string;
+  toolCallId?: string;
+  sequence?: number;
+  correlationId?: string;
+  relatedEventId?: string;
+}
+declare global {
+  var __TANSTACK_AI_DEVTOOLS_RUNTIME_ID__: string | undefined;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-event-client@0.10.0/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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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`.
+ */
+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.
+ */
+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
+//#region node_modules/.deno/@ag-ui+core@0.1.1-canary.beta.0/node_modules/@ag-ui/core/dist/events-JPFRVbr9.d.ts
+//#region src/types.d.ts
+interface FunctionCall {
+  name: string;
+  arguments: string;
+}
+interface ToolCall$1 {
+  id: string;
+  type: "function";
+  function: FunctionCall;
+  encryptedValue?: string;
+}
+interface TextInputContent {
+  type: "text";
+  text: string;
+}
+interface InputContentDataSource {
+  type: "data";
+  value: string;
+  mimeType: string;
+}
+interface InputContentUrlSource {
+  type: "url";
+  value: string;
+  mimeType?: string;
+}
+type InputContentSource = InputContentDataSource | InputContentUrlSource;
+interface ImageInputContent {
+  type: "image";
+  source: InputContentSource;
+  metadata?: unknown;
+}
+interface AudioInputContent {
+  type: "audio";
+  source: InputContentSource;
+  metadata?: unknown;
+}
+interface VideoInputContent {
+  type: "video";
+  source: InputContentSource;
+  metadata?: unknown;
+}
+interface DocumentInputContent {
+  type: "document";
+  source: InputContentSource;
+  metadata?: unknown;
+}
+interface BinaryInputContent {
+  type: "binary";
+  mimeType: string;
+  id?: string;
+  url?: string;
+  data?: string;
+  filename?: string;
+}
+type InputContent = TextInputContent | ImageInputContent | AudioInputContent | VideoInputContent | DocumentInputContent | BinaryInputContent;
+interface BaseMessageFields {
+  id: string;
+  name?: string;
+  encryptedValue?: string;
+}
+interface DeveloperMessage extends BaseMessageFields {
+  role: "developer";
+  content: string;
+}
+interface SystemMessage extends BaseMessageFields {
+  role: "system";
+  content: string;
+}
+interface AssistantMessage extends BaseMessageFields {
+  role: "assistant";
+  content?: string;
+  toolCalls?: ToolCall$1[];
+}
+interface UserMessage extends BaseMessageFields {
+  role: "user";
+  content: string | InputContent[];
+}
+interface ToolMessage {
+  id: string;
+  content: string;
+  role: "tool";
+  toolCallId: string;
+  error?: string;
+  encryptedValue?: string;
+}
+interface ActivityMessage {
+  id: string;
+  role: "activity";
+  activityType: string;
+  content: Record<string, any>;
+}
+interface ReasoningMessage {
+  id: string;
+  role: "reasoning";
+  content: string;
+  encryptedValue?: string;
+}
+type Message = DeveloperMessage | SystemMessage | AssistantMessage | UserMessage | ToolMessage | ActivityMessage | ReasoningMessage;
+interface Context {
+  description: string;
+  value: string;
+}
+interface Tool$2 {
+  name: string;
+  description: string;
+  parameters?: any;
+  metadata?: Record<string, any>;
+}
+interface Interrupt$1 {
+  id: string;
+  reason: string;
+  message?: string;
+  toolCallId?: string;
+  responseSchema?: Record<string, any>;
+  expiresAt?: string;
+  metadata?: Record<string, any>;
+}
+type ResumeStatus = "resolved" | "cancelled";
+interface ResumeEntry {
+  interruptId: string;
+  status: ResumeStatus;
+  payload?: any;
+}
+interface RunAgentInput {
+  threadId: string;
+  runId: string;
+  parentRunId?: string;
+  state?: any;
+  messages: Message[];
+  tools: Tool$2[];
+  context: Context[];
+  forwardedProps?: any;
+  resume?: ResumeEntry[];
+}
+//#endregion
+//#region src/events.d.ts
+declare enum EventType {
+  TEXT_MESSAGE_START = "TEXT_MESSAGE_START",
+  TEXT_MESSAGE_CONTENT = "TEXT_MESSAGE_CONTENT",
+  TEXT_MESSAGE_END = "TEXT_MESSAGE_END",
+  TEXT_MESSAGE_CHUNK = "TEXT_MESSAGE_CHUNK",
+  TOOL_CALL_START = "TOOL_CALL_START",
+  TOOL_CALL_ARGS = "TOOL_CALL_ARGS",
+  TOOL_CALL_END = "TOOL_CALL_END",
+  TOOL_CALL_CHUNK = "TOOL_CALL_CHUNK",
+  TOOL_CALL_RESULT = "TOOL_CALL_RESULT",
+  /** @deprecated Use REASONING_START instead. Will be removed in 1.0.0. */
+  THINKING_START = "THINKING_START",
+  /** @deprecated Use REASONING_END instead. Will be removed in 1.0.0. */
+  THINKING_END = "THINKING_END",
+  /** @deprecated Use REASONING_MESSAGE_START instead. Will be removed in 1.0.0. */
+  THINKING_TEXT_MESSAGE_START = "THINKING_TEXT_MESSAGE_START",
+  /** @deprecated Use REASONING_MESSAGE_CONTENT instead. Will be removed in 1.0.0. */
+  THINKING_TEXT_MESSAGE_CONTENT = "THINKING_TEXT_MESSAGE_CONTENT",
+  /** @deprecated Use REASONING_MESSAGE_END instead. Will be removed in 1.0.0. */
+  THINKING_TEXT_MESSAGE_END = "THINKING_TEXT_MESSAGE_END",
+  STATE_SNAPSHOT = "STATE_SNAPSHOT",
+  STATE_DELTA = "STATE_DELTA",
+  MESSAGES_SNAPSHOT = "MESSAGES_SNAPSHOT",
+  ACTIVITY_SNAPSHOT = "ACTIVITY_SNAPSHOT",
+  ACTIVITY_DELTA = "ACTIVITY_DELTA",
+  RAW = "RAW",
+  CUSTOM = "CUSTOM",
+  RUN_STARTED = "RUN_STARTED",
+  RUN_FINISHED = "RUN_FINISHED",
+  RUN_ERROR = "RUN_ERROR",
+  STEP_STARTED = "STEP_STARTED",
+  STEP_FINISHED = "STEP_FINISHED",
+  REASONING_START = "REASONING_START",
+  REASONING_MESSAGE_START = "REASONING_MESSAGE_START",
+  REASONING_MESSAGE_CONTENT = "REASONING_MESSAGE_CONTENT",
+  REASONING_MESSAGE_END = "REASONING_MESSAGE_END",
+  REASONING_MESSAGE_CHUNK = "REASONING_MESSAGE_CHUNK",
+  REASONING_END = "REASONING_END",
+  REASONING_ENCRYPTED_VALUE = "REASONING_ENCRYPTED_VALUE"
+}
+type TextMessageRole = "developer" | "system" | "assistant" | "user";
+type ReasoningEncryptedValueSubtype = "tool-call" | "message";
+interface BaseEvent {
+  type: EventType;
+  timestamp?: number;
+  rawEvent?: any;
+  [k: string]: unknown;
+}
+interface TextMessageStartEvent$1 extends BaseEvent {
+  type: EventType.TEXT_MESSAGE_START;
+  messageId: string;
+  role: TextMessageRole;
+  name?: string;
+}
+interface TextMessageContentEvent$1 extends BaseEvent {
+  type: EventType.TEXT_MESSAGE_CONTENT;
+  messageId: string;
+  delta: string;
+}
+interface TextMessageEndEvent$1 extends BaseEvent {
+  type: EventType.TEXT_MESSAGE_END;
+  messageId: string;
+}
+interface ToolCallStartEvent$1 extends BaseEvent {
+  type: EventType.TOOL_CALL_START;
+  toolCallId: string;
+  toolCallName: string;
+  parentMessageId?: string;
+}
+interface ToolCallArgsEvent$1 extends BaseEvent {
+  type: EventType.TOOL_CALL_ARGS;
+  toolCallId: string;
+  delta: string;
+}
+interface ToolCallEndEvent$1 extends BaseEvent {
+  type: EventType.TOOL_CALL_END;
+  toolCallId: string;
+}
+interface ToolCallResultEvent$1 extends BaseEvent {
+  messageId: string;
+  type: EventType.TOOL_CALL_RESULT;
+  toolCallId: string;
+  content: string;
+  role?: "tool";
+}
+interface StateSnapshotEvent$1 extends BaseEvent {
+  type: EventType.STATE_SNAPSHOT;
+  snapshot?: any;
+}
+interface StateDeltaEvent$1 extends BaseEvent {
+  type: EventType.STATE_DELTA;
+  delta: any[];
+}
+interface MessagesSnapshotEvent$1 extends BaseEvent {
+  type: EventType.MESSAGES_SNAPSHOT;
+  messages: Message[];
+}
+interface CustomEvent$1 extends BaseEvent {
+  type: EventType.CUSTOM;
+  name: string;
+  value?: any;
+}
+interface RunStartedEvent$1 extends BaseEvent {
+  type: EventType.RUN_STARTED;
+  threadId: string;
+  runId: string;
+  parentRunId?: string;
+  input?: RunAgentInput;
+}
+interface RunFinishedSuccessOutcome {
+  type: "success";
+}
+interface RunFinishedInterruptOutcome {
+  type: "interrupt";
+  interrupts: Interrupt$1[];
+}
+type RunFinishedOutcome = RunFinishedSuccessOutcome | RunFinishedInterruptOutcome;
+interface RunFinishedEvent$1 extends BaseEvent {
+  type: EventType.RUN_FINISHED;
+  threadId: string;
+  runId: string;
+  result?: any;
+  outcome?: RunFinishedOutcome;
+}
+interface RunErrorEvent$1 extends BaseEvent {
+  type: EventType.RUN_ERROR;
+  message: string;
+  code?: string;
+}
+interface StepStartedEvent$1 extends BaseEvent {
+  type: EventType.STEP_STARTED;
+  stepName: string;
+}
+interface StepFinishedEvent$1 extends BaseEvent {
+  type: EventType.STEP_FINISHED;
+  stepName: string;
+}
+interface ReasoningStartEvent$1 extends BaseEvent {
+  type: EventType.REASONING_START;
+  messageId: string;
+}
+interface ReasoningMessageStartEvent$1 extends BaseEvent {
+  type: EventType.REASONING_MESSAGE_START;
+  messageId: string;
+  role: "reasoning";
+}
+interface ReasoningMessageContentEvent$1 extends BaseEvent {
+  type: EventType.REASONING_MESSAGE_CONTENT;
+  messageId: string;
+  delta: string;
+}
+interface ReasoningMessageEndEvent$1 extends BaseEvent {
+  type: EventType.REASONING_MESSAGE_END;
+  messageId: string;
+}
+interface ReasoningEndEvent$1 extends BaseEvent {
+  type: EventType.REASONING_END;
+  messageId: string;
+}
+interface ReasoningEncryptedValueEvent$1 extends BaseEvent {
+  type: EventType.REASONING_ENCRYPTED_VALUE;
+  subtype: ReasoningEncryptedValueSubtype;
+  entityId: string;
+  encryptedValue: string;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.d.ts
+/** AG-UI spec `usage[]` item (provider/model labels + token counts only). */
+interface SpecTokenUsage {
+  provider?: string;
+  model?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  reasoningTokens?: number;
+  cachedInputTokens?: number;
+}
+/** TokenUsage fields that have no AG-UI `usage[]` equivalent. */
+type TokenUsageLeftover = Omit<TokenUsage, 'promptTokens' | 'completionTokens' | 'totalTokens'>;
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/types.d.ts
+/**
+ * Tool call states - track the lifecycle of a tool call
+ */
+type ToolCallState$1 = 'awaiting-input' | 'input-streaming' | 'input-complete' | 'approval-requested' | 'approval-responded' | 'complete' | 'error';
+/**
+ * Tool result states - track the lifecycle of a tool result
+ */
+type ToolResultState$1 = 'streaming' | 'complete' | 'error';
+type ToolOutputState = 'output-available' | 'output-error';
+/**
+ * JSON Schema type for defining tool input/output schemas as raw JSON Schema objects.
+ * This allows tools to be defined without schema libraries when you have JSON Schema definitions available.
+ */
+interface JSONSchema {
+  type?: string | Array<string>;
+  properties?: Record<string, JSONSchema>;
+  items?: JSONSchema | Array<JSONSchema>;
+  required?: Array<string>;
+  enum?: Array<unknown>;
+  const?: unknown;
+  description?: string;
+  default?: unknown;
+  $ref?: string;
+  $defs?: Record<string, JSONSchema>;
+  definitions?: Record<string, JSONSchema>;
+  allOf?: Array<JSONSchema>;
+  anyOf?: Array<JSONSchema>;
+  oneOf?: Array<JSONSchema>;
+  not?: JSONSchema;
+  if?: JSONSchema;
+  then?: JSONSchema;
+  else?: JSONSchema;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  additionalProperties?: boolean | JSONSchema;
+  additionalItems?: boolean | JSONSchema;
+  patternProperties?: Record<string, JSONSchema>;
+  propertyNames?: JSONSchema;
+  minProperties?: number;
+  maxProperties?: number;
+  title?: string;
+  examples?: Array<unknown>;
+  [key: string]: any;
+}
+/**
+ * Union type for schema input - can be any Standard Schema compliant validator,
+ * any Standard JSON Schema compliant schema, or a plain JSONSchema object.
+ *
+ * Standard JSON Schema compliant libraries (carry the JSON-schema converter):
+ * - Zod v4.2+ (natively supports StandardJSONSchemaV1)
+ * - ArkType v2.1.28+ (natively supports StandardJSONSchemaV1)
+ * - Valibot v1.2+ (via `toStandardJsonSchema()` from `@valibot/to-json-schema`)
+ *
+ * StandardSchemaV1 covers libraries whose published types only expose the
+ * validator surface — Zod's core `$ZodType['~standard']` is currently typed
+ * as `StandardSchemaV1.Props` even though the runtime attaches the
+ * `jsonSchema` converter, so this branch is what makes `InferSchemaType`
+ * recover the inferred type for callers using `z.ZodType<T>`.
+ *
+ * @see https://standardschema.dev/json-schema
+ */
+type SchemaInput = StandardJSONSchemaV1<any, any> | StandardSchemaV1$1<any, any> | JSONSchema;
+/**
+ * Infer the TypeScript type from a schema.
+ * For Standard JSON Schema compliant schemas, extracts the input type.
+ * For Standard Schema validators (e.g. Zod's `~standard` surface), extracts
+ * the input type from the `StandardSchemaV1` shape.
+ * For plain JSONSchema, returns `unknown` since we can't infer types from
+ * JSON Schema at compile time.
+ */
+type InferSchemaType<T> = T extends StandardJSONSchemaV1<infer TInput, unknown> ? TInput : T extends StandardSchemaV1$1<infer TInput, unknown> ? TInput : unknown;
+interface ToolCall<TMetadata = unknown> {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+  /** Provider-specific metadata to carry through the tool call lifecycle.
+   * Typed per-adapter via `TToolCallMetadata`. For example,
+   * `@tanstack/ai-gemini` sets this to `{ thoughtSignature?: string }`. */
+  metadata?: TMetadata;
+}
+/**
+ * Source specification for inline data content (base64).
+ * Requires a mimeType to ensure providers receive proper content type information.
+ */
+interface ContentPartDataSource {
+  /**
+   * Indicates this is inline data content.
+   */
+  type: 'data';
+  /**
+   * The base64-encoded content value.
+   */
+  value: string;
+  /**
+   * The MIME type of the content (e.g., 'image/png', 'audio/wav').
+   * Required for data sources to ensure proper handling by providers.
+   */
+  mimeType: string;
+}
+/**
+ * Source specification for URL-based content.
+ * mimeType is optional as it can often be inferred from the URL or response headers.
+ */
+interface ContentPartUrlSource {
+  /**
+   * Indicates this is URL-referenced content.
+   */
+  type: 'url';
+  /**
+   * HTTP(S) URL or data URI pointing to the content.
+   */
+  value: string;
+  /**
+   * Optional MIME type hint for cases where providers can't infer it from the URL.
+   */
+  mimeType?: string;
+}
+/**
+ * Source specification for multimodal content.
+ * Discriminated union supporting both inline data (base64) and URL-based content.
+ * - For 'data' sources: mimeType is required
+ * - For 'url' sources: mimeType is optional
+ */
+type ContentPartSource = ContentPartDataSource | ContentPartUrlSource;
+/**
+ * Image content part for multimodal messages.
+ * @template TMetadata - Provider-specific metadata type (e.g., OpenAI's detail level)
+ */
+interface ImagePart<TMetadata = unknown> {
+  type: 'image';
+  /** Source of the image content */
+  source: ContentPartSource;
+  /** Provider-specific metadata (e.g., OpenAI's detail: 'auto' | 'low' | 'high') */
+  metadata?: TMetadata;
+}
+/**
+ * Audio content part for multimodal messages.
+ * @template TMetadata - Provider-specific metadata type
+ */
+interface AudioPart<TMetadata = unknown> {
+  type: 'audio';
+  /** Source of the audio content */
+  source: ContentPartSource;
+  /** Provider-specific metadata (e.g., format, sample rate) */
+  metadata?: TMetadata;
+}
+/**
+ * Video content part for multimodal messages.
+ * @template TMetadata - Provider-specific metadata type
+ */
+interface VideoPart<TMetadata = unknown> {
+  type: 'video';
+  /** Source of the video content */
+  source: ContentPartSource;
+  /** Provider-specific metadata (e.g., duration, resolution) */
+  metadata?: TMetadata;
+}
+/**
+ * Document content part for multimodal messages (e.g., PDFs).
+ * @template TMetadata - Provider-specific metadata type (e.g., Anthropic's media_type)
+ */
+interface DocumentPart<TMetadata = unknown> {
+  type: 'document';
+  /** Source of the document content */
+  source: ContentPartSource;
+  /** Provider-specific metadata (e.g., media_type for PDFs) */
+  metadata?: TMetadata;
+}
+/**
+ * Union type for all multimodal content parts.
+ * @template TImageMeta - Provider-specific image metadata type
+ * @template TAudioMeta - Provider-specific audio metadata type
+ * @template TVideoMeta - Provider-specific video metadata type
+ * @template TDocumentMeta - Provider-specific document metadata type
+ */
+type ContentPart<TTextMeta = unknown, TImageMeta = unknown, TAudioMeta = unknown, TVideoMeta = unknown, TDocumentMeta = unknown> = TextPart$1<TTextMeta> | ImagePart<TImageMeta> | AudioPart<TAudioMeta> | VideoPart<TVideoMeta> | DocumentPart<TDocumentMeta>;
+interface ModelMessage<TContent extends string | null | Array<ContentPart> = string | null | Array<ContentPart>> {
+  role: 'user' | 'assistant' | 'tool';
+  content: TContent;
+  name?: string;
+  toolCalls?: Array<ToolCall>;
+  toolCallId?: string;
+  thinking?: Array<{
+    content: string;
+    signature?: string;
+  }>;
+  /**
+   * Completed structured output represented by this assistant message.
+   * `content` remains the provider-facing JSON text; this field preserves the
+   * typed UI part across persistence and message conversion.
+   */
+  structuredOutput?: StructuredOutputPart;
+  /**
+   * Optional stable message id. Providers ignore it; it exists so a persisted
+   * transcript can retain the streaming `messageId` and survive the
+   * persist → hydrate round-trip. When present, `modelMessagesToUIMessages`
+   * reuses it instead of generating a fresh id, so a hydrated message keeps the
+   * same identity as its live stream — which is what lets a mid-stream reload
+   * resume the SAME message bubble in place (see `@tanstack/ai-persistence`).
+   */
+  id?: string;
+  /**
+   * Optional message creation timestamp. When present, message converters
+   * preserve it across persist → hydrate round-trips.
+   */
+  createdAt?: Date;
+}
+/**
+ * Message parts - building blocks of UIMessage
+ */
+interface TextPart$1<TMetadata = unknown> {
+  type: 'text';
+  content: string;
+  metadata?: TMetadata;
+}
+interface ToolCallPart$2<TMetadata = unknown> {
+  type: 'tool-call';
+  id: string;
+  name: string;
+  arguments: string;
+  /**
+   * Parsed tool input. Set from the parsed arguments once they are complete
+   * (`state: 'input-complete'` and later). `undefined` while the raw
+   * `arguments` string is still streaming, and may stay `undefined` for a call
+   * that terminates in an error state — the raw `arguments` string is always
+   * available as a fallback. Typed per-tool on the client `ToolCallPart` (see
+   * `@tanstack/ai-client`); `unknown` on this base type.
+   */
+  input?: unknown;
+  state: ToolCallState$1;
+  /** Approval metadata if tool requires user approval */
+  approval?: {
+    id: string;
+    needsApproval: boolean;
+    approved?: boolean;
+  };
+  /** Tool execution output (for client tools or after approval) */
+  output?: any;
+  /** Provider-specific metadata that round-trips with the tool call.
+   * Typed per-adapter via `TToolCallMetadata`. May follow the
+   * {@link ProviderExecutedToolMetadata} convention to mark provider-executed
+   * server tools (e.g. Anthropic `web_search`). */
+  metadata?: TMetadata;
+}
+interface ToolResultPart$1 {
+  type: 'tool-result';
+  toolCallId: string;
+  content: string | Array<ContentPart>;
+  state: ToolResultState$1;
+  error?: string;
+}
+interface ThinkingPart$1 {
+  type: 'thinking';
+  content: string;
+  stepId?: string;
+  signature?: string;
+}
+/**
+ * Recursive `Partial` — every nested field becomes optional. Used as the
+ * `partial` type on a streaming structured-output part since the progressive
+ * JSON parse hands back objects whose fields are only filled in as bytes
+ * arrive. Defaulted in `DeepPartial<unknown>` → `unknown` so untyped parts
+ * keep their existing shape.
+ */
+type DeepPartial<T> = T extends ReadonlyArray<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+/**
+ * StructuredOutputPart — a typed structured response attached to the assistant
+ * message that produced it. Generic over the schema-inferred data type so
+ * consumers can thread `useChat({ outputSchema })`'s schema all the way down
+ * to `messages[i].parts[j].data`. Defaults to `unknown` so untyped consumers
+ * (e.g. internal codepaths that don't know about TSchema) keep working.
+ */
+interface StructuredOutputPart<TData = unknown> {
+  type: 'structured-output';
+  status: 'streaming' | 'complete' | 'error';
+  /** Progressive parse of `raw` via parsePartialJSON — populated while streaming and after complete. */
+  partial?: DeepPartial<TData>;
+  /** Validated final object — only set when `status === 'complete'`. */
+  data?: TData;
+  /** Accumulating JSON buffer. Source of truth for wire round-trip. */
+  raw: string;
+  /** Optional chain-of-thought surfaced by reasoning models alongside the structured output. */
+  reasoning?: string;
+  /** Populated when `status === 'error'`. */
+  errorMessage?: string;
+}
+interface UIResourcePart {
+  type: 'ui-resource';
+  /** The ui:// resource object in MCP-native shape — fed straight to the renderer. */
+  resource: {
+    uri: string;
+    mimeType: string;
+    text?: string;
+    blob?: string;
+  };
+  /** Pool prefix / config key — routes interactive calls to the right MCP server. */
+  serverId?: string;
+  /** Links the widget to the originating tool call — correlates it with the
+   *  sibling ToolCallPart/ToolResultPart in the same message. */
+  toolCallId: string;
+  /** Server-native (unprefixed) MCP tool name whose UI this resource renders.
+   *  Required by the renderer (`@mcp-ui/client`'s `AppRenderer` `toolName` prop). */
+  toolName: string;
+  /** Reserved for future passthrough of the resource/tool `_meta.ui` (e.g. frame-size hints).
+   *  Currently always `undefined` — nothing populates this field yet. */
+  meta?: Record<string, unknown>;
+}
+type MessagePart$1<TData = unknown> = TextPart$1 | ImagePart | AudioPart | VideoPart | DocumentPart | ToolCallPart$2 | ToolResultPart$1 | ThinkingPart$1 | StructuredOutputPart<TData> | UIResourcePart;
+/**
+ * Shape of `metadata.tanstack` on run events.
+ */
+interface TanStackRunMetadata {
+  model?: string;
+  finishReason?: 'stop' | 'length' | 'content_filter' | 'tool_calls' | null;
+  /** TokenUsage fields that have no AG-UI `usage[]` equivalent. */
+  usage?: TokenUsageLeftover;
+  interruptErrors?: ReadonlyArray<InterruptSubmissionError>;
+  threadId?: string;
+  runId?: string;
+  sessionId?: string;
+  index?: number;
+  state?: ToolOutputState;
+  /** Parsed `TOOL_CALL_END` input. Spec `TOOL_CALL_END` has no top-level `input`. */
+  input?: unknown;
+}
+/**
+ * UIMessage - Domain-specific message format optimized for building chat UIs
+ * Contains parts that can be text, tool calls, or tool results. Generic over
+ * the structured-output data type so `useChat({ outputSchema })`'s schema
+ * narrows `parts.find(p => p.type === 'structured-output').data` on the
+ * consumer side without manual casts.
+ */
+interface UIMessage$1<TData = unknown> {
+  id: string;
+  role: 'system' | 'user' | 'assistant';
+  parts: Array<MessagePart$1<TData>>;
+  createdAt?: Date;
+  /**
+   * Optional AG-UI metadata bag. TanStack writes the `tanstack` key.
+   * User keys stay at the top.
+   */
+  metadata?: Record<string, any>;
+}
+type IsUnknown$1<T> = unknown extends T ? [T] extends [unknown] ? true : false : false;
+type RuntimeContextField<TContext> = IsUnknown$1<TContext> extends true ? {
+  /**
+   * Runtime context provided by the caller.
+   *
+   * This is request-local application state for tool and middleware
+   * implementations, not the AG-UI `Context[]` protocol field.
+   */
+  context?: TContext;
+} : {
+  /**
+   * Runtime context provided by the caller.
+   *
+   * This is request-local application state for tool and middleware
+   * implementations, not the AG-UI `Context[]` protocol field.
+   */
+  context: TContext;
+};
+/**
+ * Context passed to tool execute functions, providing capabilities like
+ * emitting custom events during execution.
+ */
+type ToolExecutionContext<TContext = unknown> = RuntimeContextField<TContext> & {
+  /** The ID of the tool call being executed */toolCallId?: string;
+  /**
+   * Abort signal for the current chat run. Aborts when the run's
+   * `abortController` fires (or middleware aborts). Long-running tools —
+   * e.g. MCP `callTool` — should forward this to cancel in-flight work.
+   */
+  abortSignal?: AbortSignal;
+  /**
+   * Emit a custom event during tool execution.
+   * Events are streamed to the client in real-time as AG-UI CUSTOM events.
+   *
+   * @param eventName - Name of the custom event
+   * @param value - Event payload value
+   *
+   * @example
+   * ```ts
+   * const tool = toolDefinition({ ... }).server(async (args, context) => {
+   *   context?.emitCustomEvent('progress', { step: 1, total: 3 })
+   *   // ... do work ...
+   *   context?.emitCustomEvent('progress', { step: 2, total: 3 })
+   *   // ... do more work ...
+   *   return result
+   * })
+   * ```
+   */
+  emitCustomEvent: (eventName: string, value: Record<string, any>) => void;
+};
+type ToolExecuteFunction<TInput extends SchemaInput | undefined = SchemaInput, TOutput extends SchemaInput | undefined = SchemaInput, TContext = unknown> = undefined extends TContext ? (args: InferSchemaType<TInput>, context?: ToolExecutionContext<TContext>) => Promise<InferSchemaType<TOutput>> | InferSchemaType<TOutput> : (args: InferSchemaType<TInput>, context: ToolExecutionContext<TContext>) => Promise<InferSchemaType<TOutput>> | InferSchemaType<TOutput>;
+/**
+ * Tool/Function definition for function calling.
+ *
+ * Tools allow the model to interact with external systems, APIs, or perform computations.
+ * The model will decide when to call tools based on the user's request and the tool descriptions.
+ *
+ * Tools can use any Standard JSON Schema compliant library (Zod, ArkType, Valibot, etc.)
+ * or plain JSON Schema objects for runtime validation and type safety.
+ *
+ * @see https://platform.openai.com/docs/guides/function-calling
+ * @see https://docs.anthropic.com/claude/docs/tool-use
+ * @see https://standardschema.dev/json-schema
+ */
+interface Tool$1<TInput extends SchemaInput | undefined = SchemaInput, TOutput extends SchemaInput | undefined = SchemaInput, TName extends string = string, TContext = unknown> {
+  /**
+   * Unique name of the tool (used by the model to call it).
+   *
+   * Should be descriptive and follow naming conventions (e.g., snake_case or camelCase).
+   * Must be unique within the tools array.
+   *
+   * @example "get_weather", "search_database", "sendEmail"
+   */
+  name: TName;
+  /**
+   * Clear description of what the tool does.
+   *
+   * This is crucial - the model uses this to decide when to call the tool.
+   * Be specific about what the tool does, what parameters it needs, and what it returns.
+   *
+   * @example "Get the current weather in a given location. Returns temperature, conditions, and forecast."
+   */
+  description: string;
+  /**
+   * Schema describing the tool's input parameters.
+   *
+   * Can be any Standard JSON Schema compliant schema (Zod, ArkType, Valibot, etc.) or a plain JSON Schema object.
+   * Defines the structure and types of arguments the tool accepts.
+   * The model will generate arguments matching this schema.
+   * Standard JSON Schema compliant schemas are converted to JSON Schema for LLM providers.
+   *
+   * @see https://standardschema.dev/json-schema
+   * @see https://json-schema.org/
+   *
+   * @example
+   * // Using Zod v4+ schema (natively supports Standard JSON Schema)
+   * import { z } from 'zod';
+   * z.object({
+   *   location: z.string().describe("City name or coordinates"),
+   *   unit: z.enum(["celsius", "fahrenheit"]).optional()
+   * })
+   *
+   * @example
+   * // Using ArkType (natively supports Standard JSON Schema)
+   * import { type } from 'arktype';
+   * type({
+   *   location: 'string',
+   *   unit: "'celsius' | 'fahrenheit'"
+   * })
+   *
+   * @example
+   * // Using plain JSON Schema
+   * {
+   *   type: 'object',
+   *   properties: {
+   *     location: { type: 'string', description: 'City name or coordinates' },
+   *     unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+   *   },
+   *   required: ['location']
+   * }
+   */
+  inputSchema?: TInput;
+  /**
+   * Optional schema for validating tool output.
+   *
+   * Can be any Standard JSON Schema compliant schema or a plain JSON Schema object.
+   * If provided with a Standard Schema compliant schema, tool results will be validated
+   * against this schema before being sent back to the model. This catches bugs in tool
+   * implementations and ensures consistent output formatting.
+   *
+   * Note: This is client-side validation only - not sent to LLM providers.
+   * Note: Plain JSON Schema output validation is not performed at runtime.
+   *
+   * @example
+   * // Using Zod
+   * z.object({
+   *   temperature: z.number(),
+   *   conditions: z.string(),
+   *   forecast: z.array(z.string()).optional()
+   * })
+   */
+  outputSchema?: TOutput;
+  /**
+   * Optional function to execute when the model calls this tool.
+   *
+   * If provided, the SDK will automatically execute the function with the model's arguments
+   * and feed the result back to the model. This enables autonomous tool use loops.
+   *
+   * Can return any value - will be automatically stringified if needed.
+   *
+   * @param args - The arguments parsed from the model's tool call (validated against inputSchema)
+   * @returns Result to send back to the model (validated against outputSchema if provided)
+   *
+   * @example
+   * execute: async (args) => {
+   *   const weather = await fetchWeather(args.location);
+   *   return weather; // Can return object or string
+   * }
+   */
+  execute?: ToolExecuteFunction<TInput, TOutput, TContext> | undefined;
+  /** If true, tool execution requires user approval before running. Works with both server and client tools. */
+  needsApproval?: boolean;
+  /** If true, this tool is lazy and will only be sent to the LLM after being discovered via the lazy tool discovery mechanism. Works with both chat() (the synthetic discovery tool) and Code Mode (kept out of the system prompt and revealed via discover_tools). */
+  lazy?: boolean;
+  /** Additional metadata for adapters or custom extensions */
+  metadata?: Record<string, any> | undefined;
+}
+/**
+ * Emitted when a run starts.
+ * This is the first event in any streaming response.
+ *
+ * @ag-ui/core provides: `threadId`, `runId`, `parentRunId?`, `input?`
+ */
+interface RunStartedEvent extends RunStartedEvent$1 {}
+type Interrupt = Interrupt$1;
+type RunAgentResumeItem = ResumeEntry & {
+  /** AG-UI resume metadata. First-party generic requests ride here. */metadata?: Record<string, unknown>;
+};
+/**
+ * Emitted when a run completes successfully.
+ *
+ * @ag-ui/core provides: `threadId`, `runId`, `result?`, `outcome?`
+ * Spec `usage[]` is provider/model token counts. TanStack leftovers live in
+ * `metadata.tanstack`.
+ */
+interface RunFinishedEvent extends Pick<RunFinishedEvent$1, 'threadId' | 'runId' | 'result' | 'outcome' | 'timestamp' | 'rawEvent'> {
+  type: EventType.RUN_FINISHED;
+  usage?: Array<SpecTokenUsage> | TokenUsage;
+  /** Restored on the client from `metadata.tanstack`. */
+  model?: string;
+  /** Restored on the client from `metadata.tanstack`. */
+  finishReason?: 'stop' | 'length' | 'content_filter' | 'tool_calls' | null;
+  metadata?: {
+    tanstack?: TanStackRunMetadata;
+  } & Record<string, any>;
+}
+/**
+ * Emitted when an error occurs during a run.
+ *
+ * @ag-ui/core provides: `message`, `code?`
+ * Spec `usage[]` is provider/model token counts. Interrupt errors live in
+ * `metadata.tanstack.interruptErrors`.
+ */
+interface RunErrorEvent extends Pick<RunErrorEvent$1, 'message' | 'code' | 'timestamp' | 'rawEvent'> {
+  type: EventType.RUN_ERROR;
+  usage?: Array<SpecTokenUsage> | TokenUsage;
+  /** Restored on the client from `metadata.tanstack`. */
+  threadId?: string;
+  /** Restored on the client from `metadata.tanstack`. */
+  runId?: string;
+  /** Restored on the client from `metadata.tanstack`. */
+  model?: string;
+  /** Nested payload kept for in-process / durability consumers. */
+  error?: {
+    message: string;
+    code?: string;
+  };
+  metadata?: {
+    tanstack?: TanStackRunMetadata;
+  } & Record<string, any>;
+}
+/**
+ * Emitted when a text message starts.
+ *
+ * @ag-ui/core provides: `messageId`, `role?`, `name?`
+ */
+interface TextMessageStartEvent extends TextMessageStartEvent$1 {}
+/**
+ * Emitted when text content is generated (streaming tokens).
+ *
+ * @ag-ui/core provides: `messageId`, `delta`
+ */
+interface TextMessageContentEvent extends TextMessageContentEvent$1 {}
+/**
+ * Emitted when a text message completes.
+ *
+ * @ag-ui/core provides: `messageId`
+ */
+interface TextMessageEndEvent extends TextMessageEndEvent$1 {}
+/**
+ * Emitted when a tool call starts.
+ *
+ * @ag-ui/core provides: `toolCallId`, `toolCallName`, `parentMessageId?`
+ *
+ * Field shapes are taken from AG-UI via `Pick` (not `extends`) so Zod
+ * `.passthrough()` index signatures do not pollute the StreamChunk
+ * discriminated union — required for {@link KnownCustomEvent} narrowing.
+ */
+interface ToolCallStartEvent extends Pick<ToolCallStartEvent$1, 'toolCallId' | 'toolCallName' | 'parentMessageId' | 'timestamp' | 'rawEvent'> {
+  type: 'TOOL_CALL_START';
+  /** Alias of `toolCallName`. Kept so existing stream readers still compile. */
+  toolName?: string;
+  /** Provider-specific metadata to carry into the ToolCall. */
+  metadata?: Record<string, any>;
+}
+/**
+ * Emitted when tool call arguments are streaming.
+ *
+ * @ag-ui/core provides: `toolCallId`, `delta`
+ */
+interface ToolCallArgsEvent extends ToolCallArgsEvent$1 {}
+/**
+ * Emitted when a tool call completes.
+ *
+ * @ag-ui/core provides: `toolCallId`
+ *
+ * Same `Pick` (not `extends`) rationale as {@link ToolCallStartEvent}.
+ */
+interface ToolCallEndEvent extends Pick<ToolCallEndEvent$1, 'toolCallId' | 'timestamp' | 'rawEvent'> {
+  type: 'TOOL_CALL_END';
+  /** Parsed tool arguments when the adapter already parsed them. */
+  input?: unknown;
+  metadata?: Record<string, any>;
+}
+/**
+ * Emitted when a tool call result is available.
+ *
+ * @ag-ui/core provides: `messageId`, `toolCallId`, `content`, `role?`
+ */
+interface ToolCallResultEvent extends ToolCallResultEvent$1 {}
+/**
+ * Emitted when a thinking/reasoning step starts.
+ *
+ * @ag-ui/core provides: `stepName`
+ */
+interface StepStartedEvent extends StepStartedEvent$1 {}
+/**
+ * Emitted when a thinking/reasoning step finishes.
+ *
+ * @ag-ui/core provides: `stepName`
+ */
+interface StepFinishedEvent extends StepFinishedEvent$1 {}
+/**
+ * Emitted to provide a snapshot of all messages in a conversation.
+ *
+ * Unlike StateSnapshot (which carries arbitrary application state),
+ * MessagesSnapshot specifically delivers the conversation transcript.
+ *
+ * @ag-ui/core provides: `messages` (as @ag-ui/core Message[])
+ *
+ * Note: The `messages` field uses the @ag-ui/core Message type.
+ * Use converters to transform to/from TanStack UIMessage format.
+ */
+interface MessagesSnapshotEvent extends MessagesSnapshotEvent$1 {}
+/**
+ * Emitted to provide a full state snapshot.
+ *
+ * @ag-ui/core provides: `snapshot` (any)
+ */
+interface StateSnapshotEvent extends StateSnapshotEvent$1 {}
+/**
+ * Emitted to provide an incremental state update.
+ *
+ * @ag-ui/core provides: `delta` (any[] - JSON Patch RFC 6902)
+ */
+interface StateDeltaEvent extends StateDeltaEvent$1 {}
+/**
+ * Custom event for extensibility.
+ *
+ * @ag-ui/core provides: `name`, `value`
+ *
+ * Uses `Pick` (not `extends`) so the Zod passthrough index signature does not
+ * erase discriminant property access on {@link KnownCustomEvent} unions.
+ */
+interface CustomEvent extends Pick<CustomEvent$1, 'name' | 'value' | 'timestamp' | 'rawEvent'> {
+  type: 'CUSTOM';
+  metadata?: Record<string, any>;
+}
+/**
+ * Emitted when reasoning starts for a message.
+ *
+ * @ag-ui/core provides: `messageId`
+ */
+interface ReasoningStartEvent extends ReasoningStartEvent$1 {}
+/**
+ * Emitted when a reasoning message starts.
+ *
+ * @ag-ui/core provides: `messageId`, `role` ("reasoning")
+ */
+interface ReasoningMessageStartEvent extends ReasoningMessageStartEvent$1 {}
+/**
+ * Emitted when reasoning message content is generated.
+ *
+ * @ag-ui/core provides: `messageId`, `delta`
+ */
+interface ReasoningMessageContentEvent extends ReasoningMessageContentEvent$1 {}
+/**
+ * Emitted when a reasoning message ends.
+ *
+ * @ag-ui/core provides: `messageId`
+ */
+interface ReasoningMessageEndEvent extends ReasoningMessageEndEvent$1 {}
+/**
+ * Emitted when reasoning ends for a message.
+ *
+ * @ag-ui/core provides: `messageId`
+ */
+interface ReasoningEndEvent extends ReasoningEndEvent$1 {}
+/**
+ * Emitted for encrypted reasoning values.
+ *
+ * @ag-ui/core provides: `subtype`, `entityId`, `encryptedValue`
+ */
+interface ReasoningEncryptedValueEvent extends ReasoningEncryptedValueEvent$1 {}
+/**
+ * Union of all AG-UI events.
+ */
+type AGUIEvent = RunStartedEvent | RunFinishedEvent | RunErrorEvent | TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent | ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent | ToolCallResultEvent | StepStartedEvent | StepFinishedEvent | MessagesSnapshotEvent | StateSnapshotEvent | StateDeltaEvent | CustomEvent | ReasoningStartEvent | ReasoningMessageStartEvent | ReasoningMessageContentEvent | ReasoningMessageEndEvent | ReasoningEndEvent | ReasoningEncryptedValueEvent;
+/**
+ * Chunk returned by the SDK during streaming chat completions.
+ * Uses the AG-UI protocol event format.
+ */
+type StreamChunk = AGUIEvent;
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/tool-definition.d.ts
+/**
+ * Type-level brand key for {@link ToolApprovalCapabilityMarker}. Only ever used
+ * in type positions, but it must stay exported: a `unique symbol` referenced by
+ * an exported interface has to be nameable in the emitted declarations.
+ *
+ * @public
+ */
+declare const toolApprovalCapability: unique symbol;
+interface ToolApprovalCapabilityMarker<TNeedsApproval extends boolean, TApprovalSchema> {
+  readonly [toolApprovalCapability]?: {
+    needsApproval: TNeedsApproval;
+    approvalSchema: TApprovalSchema;
+  };
+}
+type ApprovalSchemaConfig = SchemaInput | {
+  approve: SchemaInput;
+  reject?: SchemaInput;
+} | {
+  approve?: SchemaInput;
+  reject: SchemaInput;
+};
+type ApprovalCapabilityOf<TTool> = TTool extends ToolApprovalCapabilityMarker<infer TNeeds, unknown> ? TNeeds : false;
+type ApprovalSchemaOf<TTool> = TTool extends ToolApprovalCapabilityMarker<boolean, infer TSchema> ? TSchema : undefined;
+declare const noSchema: unique symbol;
+type NoSchema = typeof noSchema;
+type InputSchemaOf<TTool> = TTool extends {
+  inputSchema: infer TInput;
+} ? TInput extends undefined ? NoSchema : TInput : NoSchema;
+/**
+ * Marker type for client-side tools
+ */
+interface ClientTool<TInput extends SchemaInput | undefined = undefined, TOutput extends SchemaInput | undefined = undefined, TName extends string = string, TContext = unknown, TNeedsApproval extends boolean = false, TApprovalSchema extends ApprovalSchemaConfig | undefined = undefined> extends ToolApprovalCapabilityMarker<TNeedsApproval, TApprovalSchema> {
+  __toolSide: 'client';
+  name: TName;
+  description: string;
+  inputSchema?: TInput;
+  outputSchema?: TOutput;
+  needsApproval?: TNeedsApproval;
+  approvalSchema?: TApprovalSchema;
+  lazy?: boolean;
+  metadata?: Record<string, unknown>;
+  execute?: ToolExecuteFunction<TInput, TOutput, TContext>;
+}
+/**
+ * Tool definition that can be used directly or instantiated for server/client
+ */
+interface ToolDefinitionInstance<TInput extends SchemaInput | undefined = undefined, TOutput extends SchemaInput | undefined = undefined, TName extends string = string, TContext = unknown, TNeedsApproval extends boolean = false, TApprovalSchema extends ApprovalSchemaConfig | undefined = undefined> extends Tool$1<TInput, TOutput, TName, TContext> {
+  __toolSide: 'definition';
+  inputSchema: TInput;
+  outputSchema: TOutput;
+  needsApproval?: TNeedsApproval;
+  approvalSchema: TApprovalSchema;
+  readonly [toolApprovalCapability]?: {
+    needsApproval: TNeedsApproval;
+    approvalSchema: TApprovalSchema;
+  };
+}
+/**
+ * Union type for any kind of client-side tool (client tool or definition)
+ */
+type AnyClientTool = (Omit<ClientTool<any, any, string, any, boolean, any>, 'execute'> & {
+  execute?: ((args: any, context?: any) => any) | undefined;
+}) | (Omit<ToolDefinitionInstance<any, any, string, any, boolean, any>, 'execute'> & {
+  execute?: ((args: any, context?: any) => any) | undefined;
+});
+/**
+ * Extract the input type from a tool (inferred from Standard JSON Schema, or `unknown` for plain JSONSchema)
+ */
+type InferToolInput<T> = T extends {
+  inputSchema?: infer TInput;
+} ? TInput extends JSONSchema ? unknown : InferSchemaType<TInput> : unknown;
+/**
+ * Extract the output type from a tool (inferred from Standard JSON Schema, or `unknown` for plain JSONSchema)
+ */
+type InferToolOutput<T> = T extends {
+  outputSchema?: infer TOutput;
+} ? TOutput extends StandardJSONSchemaV1<any, any> ? InferSchemaType<TOutput> : TOutput extends StandardSchemaV1$1<any, any> ? InferSchemaType<TOutput> : TOutput extends JSONSchema ? unknown : InferSchemaType<TOutput> : unknown;
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/types.d.ts
+/**
+ * Strategy for determining when to emit text updates
+ */
+interface ChunkStrategy {
+  /**
+   * Called for each text chunk received
+   * @param chunk - The new chunk of text (delta)
+   * @param accumulated - All text accumulated so far
+   * @returns true if an update should be emitted now
+   */
+  shouldEmit: (chunk: string, accumulated: string) => boolean;
+  /**
+   * Optional: Reset strategy state (called when streaming starts)
+   */
+  reset?: () => void;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/interrupt-definition.d.ts
+type PortableSchema = StandardJSONSchemaV1<any, any> | StandardSchemaV1$1<any, any>;
+type InterruptInput<TPayloadSchema extends PortableSchema | undefined, TPayload = unknown> = {
+  key: string;
+  reason: string;
+  message: string;
+  expiresAt?: string;
+} & ([TPayloadSchema] extends [undefined] ? {} : {
+  payload?: TPayload;
+});
+type GenericInterruptRequestBase<TDefinition extends InterruptDefinition<any, any, any, any>> = {
+  readonly definition: TDefinition;
+  readonly key: string;
+  readonly reason: string;
+  readonly message: string;
+  readonly expiresAt?: string;
+};
+type GenericInterruptRequestFor<TDefinition extends InterruptDefinition<any, any, any, any>, TPayloadSchema extends PortableSchema | undefined, TPayload> = GenericInterruptRequestBase<TDefinition> & ([TPayloadSchema] extends [undefined] ? {} : {
+  readonly payload: TPayload | undefined;
+});
+type InterruptInputKey = 'key' | 'reason' | 'message' | 'expiresAt' | 'payload';
+type RejectUnexpectedInputKeys<TInput> = Exclude<keyof TInput, InterruptInputKey> extends never ? unknown : { [K in Exclude<keyof TInput, InterruptInputKey>]: never };
+type RejectUnexpectedPayload<TInput> = 'payload' extends keyof TInput ? {
+  payload: never;
+} : unknown;
+type ValidInterruptInput<TInput, TPayloadSchema extends PortableSchema | undefined, TPayload = unknown> = TInput extends InterruptInput<TPayloadSchema, TPayload> ? RejectUnexpectedInputKeys<TInput> & ([TPayloadSchema] extends [undefined] ? RejectUnexpectedPayload<TInput> : unknown) : never;
+/**
+ * Extracting a class method preserves the intentional bivariant assignment
+ * behavior of the public `interrupt` callback without exposing a method
+ * signature in an interface.
+ */
+declare abstract class InterruptRequestMethodSignature<TId extends string, TPayloadSchema extends PortableSchema | undefined, TResponseSchema extends PortableSchema | undefined, TPayload, TPayloadInput> {
+  abstract call<TInput>(input: TInput & ValidInterruptInput<TInput, TPayloadSchema, TPayloadInput>): GenericInterruptRequestFor<InterruptDefinition<TId, TPayloadSchema, TResponseSchema, TPayload, TPayloadInput>, TPayloadSchema, TPayload>;
+}
+type InterruptRequestMethod<TId extends string, TPayloadSchema extends PortableSchema | undefined, TResponseSchema extends PortableSchema | undefined, TPayload, TPayloadInput> = InterruptRequestMethodSignature<TId, TPayloadSchema, TResponseSchema, TPayload, TPayloadInput>['call'];
+interface InterruptDefinition<TId extends string, TPayloadSchema extends PortableSchema | undefined, TResponseSchema extends PortableSchema | undefined, TPayload = unknown, TPayloadInput = TPayload> {
+  readonly id: TId;
+  readonly payloadSchema: TPayloadSchema;
+  readonly responseSchema: TResponseSchema;
+  interrupt: InterruptRequestMethod<TId, TPayloadSchema, TResponseSchema, TPayload, TPayloadInput>;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/byok/providers.d.ts
+/**
+ * Provider ids are open slugs, not a closed catalog. `@tanstack/ai` does not
+ * list adapters. Any matching string is a valid id and becomes `x-byok-<id>`.
+ */
+type ProviderId = string;
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/byok/storage.d.ts
+type Keyring = Partial<Record<ProviderId, string>>;
+type KeyPreview = Partial<Record<ProviderId, string>>;
+interface KeyringStorage {
+  readonly id: string;
+  readonly label: string;
+  readonly persistent: boolean;
+  readonly unlockable?: boolean;
+  readonly warning?: string;
+  peek?: () => KeyPreview | Promise<KeyPreview>;
+  load: () => Keyring | Promise<Keyring>;
+  save: (keys: Keyring) => void | Promise<void>;
+  clear: () => void | Promise<void>;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/byok/client.d.ts
+type KeyStatus = {
+  state: 'empty';
+} | {
+  state: 'set';
+  masked: string;
+} | {
+  state: 'locked';
+  masked: string;
+} | {
+  state: 'error';
+  masked: string;
+  message: string;
+};
+type ByokPrompt = {
+  provider: ProviderId;
+  reason: 'missing' | 'locked';
+};
+type ByokSnapshot = {
+  status: Partial<Record<string, KeyStatus>>;
+  locked: boolean;
+  prompt: ByokPrompt | null;
+  storageError: string | null;
+};
+interface DefineByokOptions {
+  storage?: KeyringStorage;
+}
+declare class ByokClient {
+  #private;
+  readonly storage: KeyringStorage;
+  constructor(options?: DefineByokOptions);
+  /** Resolves when constructor hydration (peek/load) finishes. */
+  ready: () => Promise<void>;
+  subscribe: (listener: () => void) => (() => void);
+  getSnapshot: () => ByokSnapshot;
+  keys(): Keyring;
+  request(provider: ProviderId, reason: ByokPrompt['reason']): void;
+  /**
+   * `true` — the server can fill any slug from env.
+   * `false` — no env coverage.
+   * A record merges per-id flags and clears the all/none boolean.
+   */
+  setServerCoverage(flags: boolean | Readonly<Record<string, boolean>>): void;
+  headers(provider?: ProviderId): Record<string, string>;
+  prepare(provider?: ProviderId): Promise<void>;
+  update(providerOrKey: ProviderId | string, key?: string): Promise<void>;
+  clear(provider?: ProviderId): Promise<void>;
+  unlock(): Promise<void>;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/events.d.ts
+interface ChatClientRunEventContext {
+  threadId: string;
+  runId: string;
+  toolCallId?: string;
+}
+interface ChatClientEventContext {
+  threadId?: string;
+  runId?: string;
+  toolCallId?: string;
+}
+interface ChatClientToolFixtureAppliedEvent {
+  hookId: string;
+  threadId: string;
+  toolName: string;
+  input: unknown;
+  output: unknown;
+  execute?: boolean;
+  message?: {
+    id: string;
+    role: 'system' | 'user' | 'assistant';
+    parts: Array<unknown>;
+    createdAt?: number | string;
+  };
+  messageId: string;
+  toolCallId: string;
+  runId?: string;
+  errorText?: string;
+}
+interface ChatClientStructuredOutputEvent {
+  status: 'streaming' | 'complete' | 'error';
+  raw?: string;
+  partial?: unknown;
+  data?: unknown;
+  reasoning?: string;
+  errorMessage?: string;
+  delta?: string;
+}
+type ChatClientStructuredOutputEventName = 'structured-output:started' | 'structured-output:updated' | 'structured-output:completed' | 'structured-output:errored';
+/**
+ * Abstract base class for ChatClient event emission
+ */
+declare abstract class ChatClientEventEmitter {
+  protected clientId: string;
+  constructor(clientId: string);
+  /**
+   * Protected abstract method for emitting events
+   * Implementations should handle adding clientId and timestamp
+   */
+  protected abstract emitEvent(eventName: string, data?: Record<string, unknown>): void;
+  /**
+   * Emit client created event
+   */
+  clientCreated(initialMessageCount: number): void;
+  /**
+   * Emit loading state changed event
+   */
+  loadingChanged(isLoading: boolean): void;
+  /**
+   * Emit error state changed event
+   */
+  errorChanged(error: string | null): void;
+  /**
+   * Emit text update events (combines processor and client events)
+   */
+  textUpdated(streamId: string, messageId: string, content: string, context?: ChatClientRunEventContext): void;
+  /**
+   * Emit tool call state change events (combines processor and client events)
+   */
+  toolCallStateChanged(streamId: string, messageId: string, toolCallId: string, toolName: string, state: string, args: string, context?: ChatClientRunEventContext): void;
+  /**
+   * Emit tool result state change event
+   */
+  /**
+   * Emit thinking update event
+   */
+  thinkingUpdated(streamId: string, messageId: string, content: string, delta?: string, context?: ChatClientRunEventContext): void;
+  structuredOutputChanged(eventName: ChatClientStructuredOutputEventName, streamId: string, messageId: string, output: ChatClientStructuredOutputEvent, context?: ChatClientRunEventContext): void;
+  /**
+   * Emit approval requested event
+   */
+  approvalRequested(streamId: string, messageId: string, toolCallId: string, toolName: string, input: unknown, approvalId: string, context?: ChatClientRunEventContext): void;
+  /**
+   * Emit message appended event
+   */
+  messageAppended(uiMessage: UIMessage, streamId?: string, context?: ChatClientEventContext): void;
+  /**
+   * Emit message sent event.
+   * Supports both simple string content and multimodal content arrays.
+   *
+   * @param messageId - The ID of the sent message
+   * @param content - The message content (string or array of ContentPart for multimodal)
+   */
+  messageSent(messageId: string, content: string | Array<ContentPart>): void;
+  /**
+   * Emit reloaded event
+   */
+  reloaded(fromMessageIndex: number): void;
+  /**
+   * Emit stopped event
+   */
+  stopped(): void;
+  /**
+   * Emit messages cleared event
+   */
+  messagesCleared(): void;
+  /**
+   * Emit tool result added event
+   */
+  toolResultAdded(toolCallId: string, toolName: string, output: unknown, state: string, context?: ChatClientEventContext): void;
+  /**
+   * Emit tool approval responded event
+   */
+  toolApprovalResponded(approvalId: string, toolCallId: string, approved: boolean, context?: ChatClientRunEventContext): void;
+  /**
+   * Emit tool fixture applied event.
+   */
+  toolFixtureApplied(fixture: ChatClientToolFixtureAppliedEvent): void;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/devtools.d.ts
+interface AIDevtoolsDisplayOptions {
+  name?: string;
+}
+interface AIDevtoolsClientMetadata extends AIDevtoolsDisplayOptions {
+  framework?: string;
+  hookName: string;
+  outputKind?: 'chat' | 'text' | 'structured' | 'image' | 'video' | 'audio';
+}
+interface AIDevtoolsChatSnapshot {
+  [key: string]: unknown;
+  messages: Array<UIMessage>;
+  status: ChatClientState;
+  isLoading: boolean;
+  isSubscribed: boolean;
+  connectionStatus: ConnectionStatus;
+  sessionGenerating: boolean;
+  activeRunIds: Array<string>;
+  queue?: Array<QueuedMessage>;
+  error?: string;
+}
+interface AIDevtoolsToolFixture {
+  fixtureId?: string;
+  hookId?: string;
+  threadId?: string;
+  runId?: string;
+  toolName: string;
+  input: unknown;
+  output: unknown;
+  execute?: boolean;
+  message?: {
+    id: string;
+    role: UIMessage['role'];
+    parts: Array<unknown>;
+    createdAt?: number | string;
+  };
+  toolCallId?: string;
+  messageId?: string;
+  errorText?: string;
+}
+type AIDevtoolsRunEventType = 'run:created' | 'run:started' | 'run:updated' | 'run:completed' | 'run:errored' | 'run:cancelled';
+type AIDevtoolsRunStatus = 'created' | 'started' | 'updated' | 'completed' | 'errored' | 'cancelled';
+interface AIDevtoolsBridgeOptions<TSnapshot extends object> {
+  hookId: string;
+  threadId?: string;
+  clientId: string;
+  metadata: AIDevtoolsClientMetadata;
+  getSnapshot: () => TSnapshot;
+  getTools?: () => Iterable<AnyClientTool>;
+  applyToolFixture?: (fixture: AIDevtoolsToolFixture) => void | Promise<void>;
+}
+declare class ClientDevtoolsBridge<TSnapshot extends object> {
+  protected readonly options: AIDevtoolsBridgeOptions<TSnapshot>;
+  private readonly unsubscribers;
+  private disposed;
+  private superseded;
+  private registered;
+  constructor(options: AIDevtoolsBridgeOptions<TSnapshot>);
+  emitRegistered(): void;
+  emitUpdated(): void;
+  emitSnapshot(): void;
+  emitToolsRegistered(): void;
+  emitRunLifecycle(eventType: AIDevtoolsRunEventType, runId: string, status: AIDevtoolsRunStatus, options?: {
+    error?: string;
+  }): void;
+  deactivate(): void;
+  supersede(): void;
+  dispose(): void;
+  private prepareForEmit;
+  private prepareForMountEmit;
+  private activate;
+  private handleRequestState;
+  /**
+   * Extension hook for subclasses to replay any additional cached state on a
+   * `devtools:request-state` (i.e. when a panel opens). Called only after the
+   * base guards (disposed/superseded/targetHookId) pass. No-op by default.
+   */
+  protected onReplayState(): void;
+  private handleToolFixtureApply;
+  private matchesFixtureTarget;
+  protected createEnvelope(eventType: 'hook:registered' | 'hook:updated' | 'hook:unregistered' | 'hook:state-snapshot' | 'tools:registered' | 'memory:retrieve:started' | 'memory:retrieve:completed' | 'memory:snapshot' | AIDevtoolsRunEventType, visibility?: AIDevtoolsEventVisibility, context?: {
+    runId?: string;
+  }): AIDevtoolsEventEnvelope;
+  private createMetadataPayload;
+}
+interface ChatDevtoolsBridgeOptions extends AIDevtoolsBridgeOptions<AIDevtoolsChatSnapshot> {
+  getMessages: () => Array<UIMessage>;
+  setMessages: (messages: Array<UIMessage>) => void;
+  addToolResult: (toolCallId: string, output: unknown, errorText?: string) => void;
+  generateId: (prefix: string) => string;
+}
+declare class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnapshot> {
+  readonly events: ChatClientEventEmitter;
+  private readonly chatOptions;
+  private currentRunId;
+  private currentRunThreadId;
+  private currentStreamId;
+  private lastStreamId;
+  private lastRunEventContext;
+  /** Last transported `memory:state` value, replayed when a panel opens. */
+  private lastMemoryStateValue;
+  constructor(options: ChatDevtoolsBridgeOptions);
+  setCurrentStreamId(streamId: string | null): void;
+  /**
+   * Called by the auto-attaching emitter every time it sees a non-empty
+   * streamId pass through. Lets devtools track the latest stream id
+   * without the chat client wiring it up explicitly.
+   */
+  recordStreamId(streamId: string): void;
+  mountWithTools(initialMessageCount: number): void;
+  notifyToolsChanged(): void;
+  getCurrentStreamId(): string | null;
+  getLastStreamId(): string | null;
+  resolveStreamId(): string;
+  beginRun(runId: string, threadId: string): void;
+  observeChunk(chunk: StreamChunk): void;
+  /**
+   * Record a transported `memory:state` value (the server memory middleware's
+   * per-turn recall metrics + store snapshot). Called from the chat client's
+   * `onCustomEvent` handler — the designated path for CUSTOM stream events —
+   * NOT from `observeChunk`. Re-emits the browser `memory:*` events the devtools
+   * store consumes, and caches the value so a panel opened later can replay it
+   * (see {@link onReplayState}). Symmetric with the generation bridge's
+   * `recordResultChange` / `recordProgressChange`.
+   */
+  recordMemoryState(rawValue: unknown): void;
+  /**
+   * Re-emit the browser-side `memory:*` events from a transported
+   * `memory:state` value. The devtools store consumes these to render the
+   * Memory tab (operations timeline + live contents). The recall pair mirrors
+   * the server middleware's own emits; the snapshot is included only when the
+   * adapter supports introspection.
+   */
+  private emitMemoryState;
+  protected onReplayState(): void;
+  getCurrentRunEventContext(): ChatClientRunEventContext | undefined;
+  getCurrentOrLastRunEventContext(): ChatClientRunEventContext | undefined;
+  findToolCallContext(toolCallId: string): ChatClientEventContext;
+  /**
+   * Entry point invoked when the devtools panel emits
+   * `devtools:tool-fixture:apply`. The chat client never calls this
+   * directly; it is wired through the base bridge's fixture subscription.
+   */
+  applyFixture(fixture: AIDevtoolsToolFixture): Promise<void>;
+  private executeFixture;
+  private addToolResultForFixture;
+  private createReplayMessageFromFixture;
+  private cloneFixtureSourceMessage;
+  private createFixtureToolCallIdMap;
+  private resolveFixtureMessageId;
+  private resolveFixtureToolCallId;
+  private findClientTool;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.d.ts
+type ChatDevtoolsBridgeFactory = (options: ChatDevtoolsBridgeOptions) => ChatDevtoolsBridge;
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/types.d.ts
+interface ChatResumeState {
+  threadId: string;
+  runId: string;
+}
+type ChatPendingInterrupt = Interrupt;
+/**
+ * The durable pointer a chat keeps for the run it may need to rejoin, plus any
+ * interrupt that run is waiting on.
+ *
+ * @internal
+ */
+interface ChatResumeSnapshot {
+  resumeState: ChatResumeState;
+  pendingInterrupts?: Array<ChatPendingInterrupt>;
+}
+type InterruptItemStatus = 'pending' | 'validating' | 'staged' | 'submitting' | 'error';
+interface BoundInterruptBase {
+  readonly id: string;
+  readonly interruptId: string;
+  readonly reason: string;
+  readonly message?: string;
+  readonly responseSchema?: Readonly<Record<string, unknown>>;
+  readonly expiresAt?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  readonly threadId: string;
+  readonly interruptedRunId: string;
+  readonly generation: number;
+  readonly status: InterruptItemStatus;
+  readonly errors: ReadonlyArray<ItemInterruptError>;
+  /** @deprecated Use `errors[0]`. */
+  readonly error?: ItemInterruptError;
+  /**
+   * Whether the binding/schema allows resolution at hydrate time.
+   * Does not flip on submit/expiry — gate UI on `status`, `resuming`, and
+   * `errors` for those lifecycle states.
+   */
+  readonly canResolve: boolean;
+  cancel: () => void;
+  clearResolution: () => void;
+}
+interface GenericAGUIInterrupt extends BoundInterruptBase {
+  readonly kind: 'generic';
+  readonly binding: Readonly<Extract<InterruptBinding, {
+    kind: 'generic';
+  }>>;
+  resolveInterrupt: (payload: unknown) => void;
+}
+type InterruptResponseInput<TDefinition> = TDefinition extends InterruptDefinition<any, any, infer TResponseSchema, any> ? InferSchemaType<TResponseSchema> : never;
+type RegisteredGenericInterruptFor<TDefinition extends InterruptDefinition<any, any, any, any>> = TDefinition extends InterruptDefinition<infer TDefinitionId, any, any, infer TPayload> ? BoundInterruptBase & {
+  readonly kind: 'generic';
+  readonly definitionId: TDefinitionId;
+  readonly key: string;
+  readonly payload: TPayload | undefined;
+  readonly binding: Readonly<Extract<InterruptBinding, {
+    kind: 'generic';
+  }> & {
+    definitionId: TDefinitionId;
+    key: string;
+    batchIndex: number;
+  }>;
+  resolveInterrupt: (response: InterruptResponseInput<TDefinition>) => void;
+} : never;
+type RegisteredGenericInterrupt<TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>>> = TInterrupts[number] extends infer TDefinition ? TDefinition extends InterruptDefinition<any, any, any, any> ? RegisteredGenericInterruptFor<TDefinition> : never : never;
+/**
+ * An interrupt that arrived on the stream carrying no resume binding this
+ * client understands — no `tanstack:interruptBinding`, or one written at a
+ * protocol version we don't recognise.
+ *
+ * These are surfaced rather than hidden so a UI can show that the run is
+ * paused, but they are never resolvable here: something else owns them. A
+ * workflow engine's durable approval projected into the same AG-UI stream
+ * lands in this bucket, and resolving it through the chat resume path would
+ * send an answer no one is waiting for. Render it, or route it to whatever
+ * actually owns the pause.
+ */
+interface UnboundInterrupt extends Omit<BoundInterruptBase, 'cancel' | 'clearResolution'> {
+  readonly kind: 'unbound';
+  readonly binding?: undefined;
+  readonly canResolve: false;
+}
+type ApprovalBranchSchema<TTool, TBranch extends 'approve' | 'reject'> = ApprovalSchemaOf<TTool> extends infer TApproval ? TApproval extends {
+  approve?: SchemaInput;
+  reject?: SchemaInput;
+} ? Exclude<TApproval[TBranch], undefined> : TApproval extends SchemaInput ? TApproval : never : never;
+type ApprovalEdits<TTool> = InputSchemaOf<TTool> extends NoSchema ? {
+  editedArgs?: never;
+} : {
+  editedArgs?: InferToolInput<TTool>;
+};
+type ApprovalPayload<TSchema> = [TSchema] extends [never] ? {
+  payload?: never;
+} : TSchema extends SchemaInput ? {
+  payload: InferSchemaType<TSchema>;
+} : {
+  payload?: never;
+};
+type ApproveArguments<TTool> = [ApprovalBranchSchema<TTool, 'approve'>] extends [never] ? InputSchemaOf<TTool> extends NoSchema ? [options?: never] : [options?: ApprovalEdits<TTool> & {
+  payload?: never;
+}] : [options: ApprovalEdits<TTool> & ApprovalPayload<ApprovalBranchSchema<TTool, 'approve'>>];
+type RejectArguments<TTool> = [ApprovalBranchSchema<TTool, 'reject'>] extends [never] ? [options?: never] : [options: {
+  editedArgs?: never;
+} & ApprovalPayload<ApprovalBranchSchema<TTool, 'reject'>>];
+type ToolApprovalInterrupt<TTool extends AnyClientTool = AnyClientTool> = TTool extends AnyClientTool ? BoundInterruptBase & {
+  readonly kind: 'tool-approval';
+  readonly binding: Readonly<Extract<InterruptBinding, {
+    kind: 'tool-approval';
+  }>>;
+  readonly toolName: TTool['name'];
+  readonly toolCallId: string;
+  readonly originalArgs: InferToolInput<TTool>;
+  resolveInterrupt: <TApproved extends boolean>(approved: TApproved, ...args: TApproved extends true ? ApproveArguments<TTool> : RejectArguments<TTool>) => void;
+} : never;
+type ApprovalInterrupts<TTools extends ReadonlyArray<AnyClientTool>> = TTools[number] extends infer TTool ? TTool extends AnyClientTool ? ApprovalCapabilityOf<TTool> extends true ? ToolApprovalInterrupt<TTool> : never : never : never;
+type ChatInterrupt<TTools extends ReadonlyArray<AnyClientTool> = ReadonlyArray<AnyClientTool>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = GenericAGUIInterrupt | RegisteredGenericInterrupt<TInterrupts> | UnboundInterrupt | ApprovalInterrupts<TTools>;
+type ResolvableChatInterrupt<TTools extends ReadonlyArray<AnyClientTool> = ReadonlyArray<AnyClientTool>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = GenericAGUIInterrupt | RegisteredGenericInterrupt<TInterrupts> | ApprovalInterrupts<TTools>;
+type BoundInterrupts<TTools extends ReadonlyArray<AnyClientTool> = ReadonlyArray<AnyClientTool>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = ReadonlyArray<ChatInterrupt<TTools, TInterrupts>>;
+interface ChatInterruptState<TTools extends ReadonlyArray<AnyClientTool> = ReadonlyArray<AnyClientTool>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> {
+  readonly interrupts: BoundInterrupts<TTools, TInterrupts>;
+  /** @deprecated Use `interrupts`. Same snapshot today. */
+  readonly pendingInterrupts: BoundInterrupts<TTools, TInterrupts>;
+  readonly interruptErrors: ReadonlyArray<BatchInterruptError>;
+  readonly resuming: boolean;
+}
+/**
+ * `messages` is the full UIMessage history (not a delta). `data` is the
+ * merged body — `ChatClientOptions.body` plus any per-call data passed to
+ * `sendMessage(...)`. `threadId` / `runId` are the AG-UI correlation ids
+ * the chat client uses to track this turn — forward them to your server
+ * if it needs to correlate requests.
+ */
+interface ChatFetcherInput {
+  messages: Array<UIMessage>;
+  data?: Record<string, unknown>;
+  threadId: string;
+  runId: string;
+  parentRunId?: string;
+  resume?: Array<RunAgentResumeItem>;
+}
+interface ChatFetcherOptions {
+  /** Fires when `stop()` is called or the request is superseded. */
+  signal: AbortSignal;
+  /** Extra request headers for this run (e.g. BYOK keys). */
+  headers?: Record<string, string>;
+}
+/**
+ * Direct function that performs a chat request. Mirrors
+ * `GenerationFetcher`. Returns either a `Response` (SSE body parsed by the
+ * chat client) or an `AsyncIterable<StreamChunk>` (yielded directly). May
+ * return the value synchronously, as a `Promise`, or as an async generator
+ * (`async function*`) — the chat client awaits whichever shape is returned.
+ *
+ * @example
+ * ```ts
+ * useChat({
+ *   fetcher: ({ messages }, { signal }) =>
+ *     chatFn({ data: { messages }, signal }),
+ * })
+ * ```
+ */
+type ChatFetcher = (input: ChatFetcherInput, options: ChatFetcherOptions) => Response | AsyncIterable<StreamChunk> | Promise<Response | AsyncIterable<StreamChunk>>;
+/**
+ * Distributive `Omit` — applies `Omit<O, K>` per branch of a union so
+ * discriminated unions survive omission. Plain `Omit` collapses unions
+ * into a single object shape, which would erase the `ChatTransport` XOR
+ * when framework hooks omit React-managed callbacks from
+ * `ChatClientOptions`.
+ */
+type DistributedOmit<TObject, TKeys extends keyof any> = TObject extends unknown ? Omit<TObject, TKeys> : never;
+/**
+ * Discriminated union enforcing that exactly one of `connection` or
+ * `fetcher` is provided. Mirrors `GenerationTransport`.
+ */
+type ChatTransport = {
+  connection: ConnectionAdapter;
+  fetcher?: never;
+} | {
+  fetcher: ChatFetcher;
+  connection?: never;
+};
+/**
+ * Tool call states - track the lifecycle of a tool call
+ */
+type ToolCallState = 'awaiting-input' | 'input-streaming' | 'input-complete' | 'approval-requested' | 'approval-responded' | 'complete' | 'error';
+/**
+ * Tool result states - track the lifecycle of a tool result
+ */
+type ToolResultState = 'streaming' | 'complete' | 'error';
+/**
+ * ChatClient state - track the lifecycle of a chat
+ */
+type ChatClientState = 'ready' | 'submitted' | 'streaming' | 'error';
+/**
+ * Connection lifecycle state for the subscription loop.
+ */
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+/**
+ * Multimodal content input for sending messages with rich media.
+ * Allows sending text, images, audio, video, and documents to the LLM.
+ *
+ * @example
+ * ```ts
+ * // Send an image with a question
+ * client.sendMessage({
+ *   content: [
+ *     { type: 'text', content: 'What is in this image?' },
+ *     { type: 'image', source: { type: 'url', value: 'https://example.com/photo.jpg' } }
+ *   ],
+ *   id: 'custom-message-id' // optional
+ * })
+ * ```
+ */
+interface MultimodalContent {
+  /**
+   * The content of the message.
+   * Can be a simple string or an array of content parts for multimodal messages.
+   */
+  content: string | Array<ContentPart>;
+  /**
+   * Optional custom ID for the message.
+   * If not provided, a unique ID will be generated.
+   */
+  id?: string;
+  /**
+   * Optional AG-UI metadata bag copied onto the resulting UIMessage.
+   *
+   * @example
+   * ```ts
+   * await client.sendMessage({
+   *   content: 'Show me failed logins',
+   *   metadata: { author: { id: 'user-42', name: 'Dana' } },
+   * })
+   * ```
+   */
+  metadata?: Record<string, any>;
+}
+/**
+ * Action taken when `sendMessage` is called while the client is busy
+ * (streaming, claiming a send, or draining the queue).
+ * - `queue`: hold the message; it auto-sends when the current run settles
+ *   **successfully**.
+ * - `drop`: ignore the send (promise still resolves; does not throw).
+ * - `interrupt`: abort the current stream and send immediately. Unlike
+ *   `stop()`, does **not** flush already-queued messages — they still drain
+ *   after the interrupting send settles successfully.
+ */
+type WhenBusy = 'queue' | 'drop' | 'interrupt';
+/**
+ * Why the client is busy when a {@link QueueStrategy} runs.
+ * - `streaming` — an LLM stream is active (`isLoading`).
+ * - `sendInFlight` — a send has claimed the client but is not yet loading.
+ * - `draining` — the queue drain loop is delivering pending messages.
+ */
+type QueueBusyReason = 'streaming' | 'sendInFlight' | 'draining';
+/**
+ * A user message held in the send queue while a stream is active.
+ * Rendered separately from `messages`; cancellable via `cancelQueued(id)`
+ * until it drains.
+ */
+interface QueuedMessage {
+  id: string;
+  content: string | MultimodalContent;
+  createdAt: number;
+}
+/**
+ * Declarative queue policy.
+ */
+interface QueueConfig {
+  /**
+   * Action when the client is busy (streaming, claiming a send, or draining).
+   * Default `'queue'`.
+   */
+  whenBusy?: WhenBusy;
+  /**
+   * How queued items leave the queue.
+   * - `'fifo'`: one at a time, in order (default).
+   * - `'batch'`: merge all queued items into one send when the run settles
+   *   successfully.
+   */
+  drain?: 'fifo' | 'batch';
+  /** Max queued items. Unlimited when omitted. `0` means never queue. */
+  maxSize?: number;
+  /**
+   * Behavior when `maxSize` is reached. Default `'reject'`.
+   * `'reject'` silently discards the new send (does not throw);
+   * `'drop-oldest'` evicts the oldest queued item to make room.
+   * Only meaningful when `maxSize` is set.
+   */
+  onOverflow?: 'reject' | 'drop-oldest';
+}
+/**
+ * Escape hatch: decide the action for a single send. Drain stays FIFO for the
+ * function form (no `batch` via function). Per-call `sendOptions.whenBusy`
+ * overrides the strategy for that send.
+ *
+ * Actions match {@link WhenBusy}. Concurrent streams are not supported.
+ * `pending.id` is the id that will be stored if the action is `'queue'`
+ * (safe to pass to `cancelQueued`).
+ */
+type QueueStrategy = (ctx: {
+  pending: QueuedMessage;
+  busyReason: QueueBusyReason;
+  queued: ReadonlyArray<QueuedMessage>;
+}) => {
+  action: WhenBusy;
+};
+/** A `WhenBusy` shorthand, a full config, or a strategy function. */
+type QueueOption = WhenBusy | QueueConfig | QueueStrategy;
+/** Per-call overrides for `sendMessage`. */
+interface SendMessageOptions {
+  /** Overrides the configured `whenBusy` for this one send. */
+  whenBusy?: WhenBusy;
+  /**
+   * Extra JSON merged into this request's wire `forwardedProps`.
+   * Shallow merge: `{ ...chatBody, ...positionalBody, ...body }`.
+   * This field wins on key collisions.
+   *
+   * Framework hooks (`useChat`, `injectChat`, `createChat`) expose
+   * `sendMessage(content, options)` with no positional body, so this field
+   * is the per-call body channel on those surfaces.
+   */
+  body?: Record<string, any>;
+}
+/**
+ * Message parts - building blocks of UIMessage
+ */
+interface TextPart {
+  type: 'text';
+  content: string;
+}
+/**
+ * Helper type that creates a tool-call part for a specific tool.
+ * This is a conditional type to enable proper distribution over union types,
+ * creating a discriminated union where `name` is the discriminant.
+ */
+type ToolCallPartForTool<T> = T extends AnyClientTool ? {
+  type: 'tool-call';
+  id: string;
+  name: T['name'];
+  arguments: string; /** Parsed tool input (typed from inputSchema) */
+  input?: InferToolInput<T>;
+  state: ToolCallState; /** Tool execution output (for client tools or after approval) */
+  output?: InferToolOutput<T>;
+} & (NonNullable<T['needsApproval']> extends true ? {
+  /**
+   * Approval metadata — present only on tools defined with
+   * `needsApproval: true`. Populated once the call reaches
+   * `state: 'approval-requested'`. `needsApproval` is an optional
+   * property on the tool, so we index into it (rather than
+   * `T extends { needsApproval: true }`, which an optional property
+   * never satisfies) and strip `undefined` before comparing to `true`.
+   */
+  approval?: {
+    id: string;
+    needsApproval: boolean;
+    approved?: boolean;
+  };
+} : unknown) : never;
+/**
+ * Fallback tool-call part type when tools are not typed
+ */
+type UntypedToolCallPart = {
+  type: 'tool-call';
+  id: string;
+  name: string;
+  arguments: string;
+  input?: any;
+  state: ToolCallState;
+  approval?: {
+    id: string;
+    needsApproval: boolean;
+    approved?: boolean;
+  };
+  output?: any;
+};
+/**
+ * Tool call part that creates a proper discriminated union.
+ * When TTools is typed, checking `part.name === 'toolName'` will narrow
+ * `part.output` to the correct type for that tool.
+ *
+ * The discriminant is `name`, so code like:
+ * ```ts
+ * if (part.name === 'recommendGuitar') {
+ *   // part.output is now typed to the recommendGuitar tool's output
+ * }
+ * ```
+ */
+type ToolCallPart$1<TTools extends ReadonlyArray<AnyClientTool> = any> = [TTools] extends [never] ? UntypedToolCallPart : unknown extends TTools ? UntypedToolCallPart : TTools extends ReadonlyArray<infer Tool> ? Tool extends AnyClientTool ? ToolCallPartForTool<Tool> : UntypedToolCallPart : UntypedToolCallPart;
+interface ToolResultPart {
+  type: 'tool-result';
+  toolCallId: string;
+  content: string | Array<ContentPart>;
+  state: ToolResultState;
+  error?: string;
+}
+interface ThinkingPart {
+  type: 'thinking';
+  content: string;
+}
+type MessagePart<TTools extends ReadonlyArray<AnyClientTool> = any, TData = unknown> = TextPart | ImagePart | AudioPart | VideoPart | DocumentPart | ToolCallPart$1<TTools> | ToolResultPart | ThinkingPart | StructuredOutputPart<TData> | UIResourcePart;
+/**
+ * UIMessage - Domain-specific message format optimized for building chat UIs
+ * Contains parts that can be text, tool calls, or tool results.
+ *
+ * `TTools` narrows the tool-call/result part types based on the registered
+ * tools. `TData` is the schema-inferred type for any `structured-output` part
+ * on the message — defaulted to `unknown` so untyped consumers (the core
+ * stream processor, the wire converter) don't need to thread a schema generic
+ * everywhere; the hook layer (`useChat({ outputSchema })`) substitutes it on
+ * the public return so `m.parts.find(p => p.type === 'structured-output').data`
+ * is typed without manual casts.
+ */
+interface UIMessage<TTools extends ReadonlyArray<AnyClientTool> = any, TData = unknown> {
+  id: string;
+  role: 'system' | 'user' | 'assistant';
+  parts: Array<MessagePart<TTools, TData>>;
+  createdAt?: Date;
+  /**
+   * Optional AG-UI metadata bag. TanStack writes the `tanstack` key.
+   * User keys stay at the top.
+   */
+  metadata?: Record<string, any>;
+}
+/**
+ * The single record a `ChatClientPersistence` adapter stores per chat. It folds
+ * the two things that must survive a full page reload into one blob under one
+ * key: the message transcript and the optional resume snapshot (which run to
+ * rejoin / which interrupts to rehydrate). One adapter, one key — see
+ * {@link ChatClientPersistence}.
+ */
+interface ChatPersistedState<TTools extends ReadonlyArray<AnyClientTool> = any> {
+  messages: Array<UIMessage<TTools>>;
+  /** Present while a run is in flight or paused on an interrupt; absent otherwise. */
+  resume?: ChatResumeSnapshot;
+}
+/**
+ * Storage adapter for durable chat state. A single adapter persists both the
+ * message transcript and the resume snapshot as one {@link ChatPersistedState}
+ * record, so a full page reload restores the conversation AND can rejoin an
+ * in-flight run / rehydrate pending interrupts.
+ *
+ * For backward compatibility `getItem` may also return a bare `UIMessage[]`
+ * (the legacy messages-only format); the client normalizes it to
+ * `{ messages }`. `setItem` always writes the combined record.
+ */
+interface ChatClientPersistence<TTools extends ReadonlyArray<AnyClientTool> = any> {
+  getItem: (id: string) => ChatPersistedState<TTools> | Array<UIMessage<TTools>> | null | undefined | Promise<ChatPersistedState<TTools> | Array<UIMessage<TTools>> | null | undefined>;
+  setItem: (id: string, state: ChatPersistedState<TTools>) => void | Promise<void>;
+  removeItem: (id: string) => void | Promise<void>;
+}
+/**
+ * The `persistence` / `threadId` pairing for `ChatClient` and the chat hooks.
+ *
+ * Persistence that is on (`true` or a storage adapter) requires a `threadId`.
+ * A minted id changes every reload, so nothing would restore. The compiler
+ * asks for the conversation id instead.
+ *
+ * Omit `persistence`, or set it to `false`, and `threadId` stays optional.
+ * The client then mints one after mount for the wire and DevTools.
+ *
+ * Intersect this onto `ChatClientOptions`. Do not apply a later plain `Omit`
+ * to that type: it collapses the union and the requirement disappears. Use
+ * {@link DistributedOmit}.
+ */
+type ChatPersistenceOptions<TTools extends ReadonlyArray<AnyClientTool> = any> = {
+  persistence: true;
+  threadId: string;
+} | {
+  persistence: ChatClientPersistence<TTools>;
+  threadId: string;
+} | {
+  persistence?: false | undefined;
+  threadId?: string;
+};
+type IsUnknown<T> = unknown extends T ? [T] extends [unknown] ? true : false : false;
+type KnownContext<T> = IsUnknown<T> extends true ? never : T;
+type MergeContext<TLeft, TRight> = [TLeft] extends [never] ? TRight : [TRight] extends [never] ? TLeft : TLeft & TRight;
+type UnionToIntersection<T> = [T] extends [never] ? never : (T extends unknown ? (value: T) => void : never) extends ((value: infer TIntersection) => void) ? TIntersection : never;
+type DefinedContext<T> = Exclude<T, undefined>;
+type ContextFromExecute<T> = T extends ((...args: any) => any) ? NonNullable<Parameters<T>[1]> extends {
+  context: infer TContext;
+} ? KnownContext<TContext> : never : never;
+type ContextFromClientTool<T> = T extends AnyClientTool ? T extends {
+  execute?: infer TExecute;
+} ? ContextFromExecute<TExecute> : never : never;
+type RequiredContextFromClientToolUnion<T> = T extends unknown ? undefined extends ContextFromClientTool<T> ? never : ContextFromClientTool<T> : never;
+type ContextFromClientToolUnion<T> = [UnionToIntersection<DefinedContext<ContextFromClientTool<T>>>] extends [never] ? never : [RequiredContextFromClientToolUnion<T>] extends [never] ? UnionToIntersection<DefinedContext<ContextFromClientTool<T>>> | undefined : UnionToIntersection<DefinedContext<ContextFromClientTool<T>>>;
+type ContextFromClientTools<TTools> = IsUnknown<TTools> extends true ? never : TTools extends readonly [infer THead, ...infer TTail] ? MergeContext<ContextFromClientTool<THead>, ContextFromClientTools<TTail>> : TTools extends ReadonlyArray<infer TItem> ? ContextFromClientToolUnion<TItem> : never;
+type InferredClientContext<TTools> = [ContextFromClientTools<TTools>] extends [never] ? unknown : ContextFromClientTools<TTools>;
+type ClientContextOptionFromTools<TTools, TContext> = [ContextFromClientTools<TTools>] extends [never] ? {
+  context?: TContext;
+} : undefined extends ContextFromClientTools<TTools> ? {
+  context?: TContext & ContextFromClientTools<TTools>;
+} : {
+  context: TContext & ContextFromClientTools<TTools>;
+};
+/**
+ * Base options for `ChatClient`, excluding the transport (`connection` or
+ * `fetcher`) which is supplied separately via `ChatTransport` so the XOR
+ * is preserved when composing the final `ChatClientOptions` type.
+ */
+interface ChatClientBaseOptions<TTools extends ReadonlyArray<AnyClientTool> = any, TContext = unknown, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> {
+  /**
+   * Initial messages to populate the chat
+   */
+  initialMessages?: Array<UIMessage<TTools>>;
+  /**
+   * Initial resumable run state, useful when rehydrating a persisted client
+   * after a full page reload. This restores the client-side interrupt
+   * descriptors needed to send AG-UI resume entries.
+   */
+  initialResumeSnapshot?: ChatResumeSnapshot;
+  /**
+   * Arbitrary client-controlled JSON forwarded to the server in the
+   * AG-UI `RunAgentInput.forwardedProps` field. Use this for per-session
+   * options like provider/model selection or feature flags that the
+   * server endpoint should read.
+   *
+   * Replaces the legacy `body` option. If both are provided,
+   * `forwardedProps` wins on key collision.
+   */
+  forwardedProps?: Record<string, any>;
+  /**
+   * @deprecated Use `forwardedProps` instead. `body` continues to work
+   * unchanged — its values are merged into the AG-UI
+   * `RunAgentInput.forwardedProps` field on the wire and are also
+   * mirrored under the legacy `data` field for servers that have not
+   * migrated yet. Will be removed in a future major release.
+   */
+  body?: Record<string, any>;
+  /**
+   * Optional BYOK keyring. On each send the client prepares the resolved
+   * provider and stamps `x-byok-*` request headers. Keys never go in the body.
+   */
+  byok?: ByokClient;
+  /**
+   * Optional provider id for this chat. If it returns a provider slug,
+   * only that key is prepared and sent. Otherwise the merged `provider`
+   * from `forwardedProps`, `body`, and per-call `sendMessage` `body` is
+   * used. Later sources win. If no slug resolves, the send throws
+   * instead of attaching every stored key.
+   */
+  byokProvider?: () => string | undefined;
+  /**
+   * Client-local runtime context passed to client tool implementations.
+   *
+   * This value is not serialized to the server. Use `forwardedProps` for
+   * explicit client-to-server handoff of serializable values.
+   */
+  context?: TContext;
+  /**
+   * Callback when a response is received
+   */
+  onResponse?: (response?: Response) => void | Promise<void>;
+  /**
+   * Callback when a stream chunk is received
+   */
+  onChunk?: (chunk: StreamChunk) => void;
+  /**
+   * Callback when the response is finished
+   */
+  onFinish?: (message: UIMessage<TTools>) => void;
+  /**
+   * Callback when an error occurs
+   */
+  onError?: (error: Error) => void;
+  /**
+   * Callback when messages change
+   */
+  onMessagesChange?: (messages: Array<UIMessage<TTools>>) => void;
+  /**
+   * Callback when loading state changes
+   */
+  onLoadingChange?: (isLoading: boolean) => void;
+  /**
+   * Callback when error state changes
+   */
+  onErrorChange?: (error: Error | undefined) => void;
+  /**
+   * Callback when chat status changes
+   */
+  onStatusChange?: (status: ChatClientState) => void;
+  /**
+   * Callback when subscription lifecycle changes.
+   * This is independent from request lifecycle (`isLoading`, `status`).
+   */
+  onSubscriptionChange?: (isSubscribed: boolean) => void;
+  /**
+   * Callback when connection lifecycle changes.
+   */
+  onConnectionStatusChange?: (status: ConnectionStatus) => void;
+  /**
+   * Callback when session generation activity changes.
+   * Derived from stream run events (RUN_STARTED / RUN_FINISHED / RUN_ERROR).
+   * Unlike `onLoadingChange` (request-local), this reflects shared generation
+   * activity visible to all subscribers (e.g. across tabs/devices).
+   */
+  onSessionGeneratingChange?: (isGenerating: boolean) => void;
+  /**
+   * Policy for messages sent while the client is busy (streaming, claiming
+   * a send, or draining the queue). Accepts a `WhenBusy` string, a
+   * `QueueConfig`, or a `QueueStrategy` function.
+   * Default: `{ whenBusy: 'queue', drain: 'fifo' }`.
+   * Queued items auto-send only after a **successful** settle; they are
+   * discarded on error/abort, `stop()`, `clear()`, `unsubscribe()`, and
+   * `reload()`.
+   */
+  queue?: QueueOption;
+  /**
+   * Callback when the pending send queue changes (enqueue, cancel, drain,
+   * or flush).
+   */
+  onQueueChange?: (queue: Array<QueuedMessage>) => void;
+  /**
+   * Callback when resumable run state or pending interrupts change.
+   */
+  onResumeStateChange?: (resumeState: ChatResumeState | null, pendingInterrupts: BoundInterrupts<TTools, TInterrupts>) => void;
+  /**
+   * Callback when the id of the run this client has in flight changes: the new
+   * id when a run starts (a send, or a `joinRun` rejoin), `null` when it settles.
+   */
+  onRunIdChange?: (runId: string | null) => void;
+  /**
+   * Callback when the immutable interrupt state snapshot changes.
+   * Snapshot restoration passes `{ source: 'hydrate' }`; streamed and
+   * client-initiated updates pass `{ source: 'live' }`.
+   */
+  onInterruptStateChange?: (state: ChatInterruptState<TTools, TInterrupts>, context: {
+    source: 'hydrate' | 'live';
+  }) => void;
+  /**
+   * Callback when a custom event is received from a server-side tool.
+   * Custom events are emitted by tools using `context.emitCustomEvent()` during execution.
+   *
+   * @param eventType - The name of the custom event
+   * @param data - The event payload data
+   * @param context - Additional context including the toolCallId that emitted the event
+   */
+  onCustomEvent?: (eventType: string, data: unknown, context: {
+    toolCallId?: string;
+  }) => void;
+  /**
+   * Client-side tools with execution logic
+   * When provided, tools with execute functions will be called automatically
+   */
+  tools?: TTools;
+  /** First-party generic interrupts this client can type and resolve. */
+  interrupts?: TInterrupts;
+  /**
+   * Devtools hook metadata for this client instance.
+   */
+  devtools?: Partial<AIDevtoolsClientMetadata>;
+  /**
+   * Factory that constructs the devtools bridge. Default is a no-op
+   * factory, which keeps `@tanstack/ai-client/devtools` (the heavy
+   * bridge implementation) out of the main entry's bundle. Frameworks
+   * that need live devtools should pass the real factory from
+   * `@tanstack/ai-client/devtools`.
+   */
+  devtoolsBridgeFactory?: ChatDevtoolsBridgeFactory;
+  /**
+   * Stream processing options (optional)
+   * Configure chunking strategy
+   */
+  streamProcessor?: {
+    /**
+     * Strategy for when to emit text updates
+     * Defaults to ImmediateStrategy (every chunk)
+     */
+    chunkStrategy?: ChunkStrategy;
+  };
+}
+/**
+ * Options for `ChatClient`. Exactly one of `connection` or `fetcher` must be
+ * provided — the type-level XOR is enforced via `ChatTransport`. Persistence
+ * that is on requires a `threadId` via {@link ChatPersistenceOptions}.
+ */
+type ChatClientOptions<TTools extends ReadonlyArray<AnyClientTool> = any, TContext = InferredClientContext<TTools>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = DistributedOmit<ChatClientBaseOptions<TTools, TContext, TInterrupts>, 'context'> & ClientContextOptionFromTools<TTools, TContext> & ChatTransport & ChatPersistenceOptions<TTools>;
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/connection-adapters.d.ts
+/**
+ * Per-send context provided by the chat client to the connection adapter.
+ * The adapter combines this with serialized messages to build a full
+ * AG-UI `RunAgentInput` payload.
+ */
+interface RunAgentInputContext {
+  threadId: string;
+  runId: string;
+  parentRunId?: string;
+  /** AG-UI interrupt resume entries returned to the server on a follow-up run. */
+  resume?: Array<RunAgentResumeItem>;
+  /** Client-declared tools to advertise in the request payload. */
+  clientTools?: Array<{
+    name: string;
+    description: string;
+    parameters: unknown;
+  }>;
+  /** Arbitrary user-controlled passthrough data. */
+  forwardedProps?: Record<string, unknown>;
+  /** Extra request headers for this run (e.g. BYOK keys). POST only. */
+  headers?: Record<string, string>;
+}
+interface ConnectConnectionAdapter {
+  /**
+   * Connect and return an async iterable of StreamChunks.
+   */
+  connect: (messages: Array<UIMessage$1> | Array<ModelMessage>, data?: Record<string, any>, abortSignal?: AbortSignal, runContext?: RunAgentInputContext) => AsyncIterable<StreamChunk>;
+  /**
+   * Fetch server-driven hydration for a generation `threadId`: the last
+   * generation's resume snapshot, plus a cursor to a run still generating if
+   * one exists. The generation client calls this itself on mount when
+   * `persistence: true` (no loader/prop) and repaints the snapshot — it never
+   * auto-starts a run. Read-only JSON GET (`?threadId`), so it is
+   * transport-agnostic. Optional and feature-detected exactly like the chat
+   * `hydrate` handler.
+   */
+  hydrateGeneration?: (threadId: string) => Promise<GenerationHydrationResult>;
+  /**
+   * Re-attach to a run that is still generating and replay it from the start
+   * (read-only `?offset=-1&runId` against the delivery-durability log). The
+   * generation client tails this on mount when hydration reports a run still in
+   * flight, so a dropped connection or a full reload finishes the generation in
+   * place — the same durability replay the chat client uses. Optional and
+   * feature-detected; present on `fetchServerSentEvents` / `fetchHttpStream`.
+   */
+  joinRun?: (runId: string, abortSignal?: AbortSignal) => AsyncIterable<StreamChunk>;
+  /**
+   * Fetch server-driven hydration for a chat `threadId`: the stored transcript
+   * plus a cursor to an in-flight run and any pending interrupts. The chat
+   * client calls this itself on mount when `persistence: true` (no loader/prop)
+   * and repaints it — it never auto-sends. Read-only JSON GET (`?threadId`), so
+   * it is transport-agnostic. Optional and feature-detected; present on
+   * `fetchServerSentEvents` / `fetchHttpStream`, and on `stream()` /
+   * `rpcStream()` when supplied via {@link StreamConnectionHandlers}.
+   */
+  hydrate?: (threadId: string) => Promise<ChatHydrationResult>;
+}
+/**
+ * Server-resolved hydration for a generation thread. `resumeSnapshot` is the
+ * last generation's lightweight snapshot (validated client-side before it is
+ * adopted); `activeRun` is a cursor to a run still generating for the thread
+ * (or `null`).
+ *
+ * Field-for-field compatible with `@tanstack/ai-persistence`'s
+ * `ReconstructedGeneration` (the body `reconstructGeneration` returns) — the
+ * client never imports that package, so this is a structural contract, not a
+ * shared type. Two deliberate widenings on this side: `schemaVersion` is
+ * optional (the server always writes `1`, but a hand-written fixture need not),
+ * and `status` also admits `'idle'`, which the server's mapper never emits.
+ * Only a client-local snapshot reaches it, when `stop()` retires a cancelled
+ * run.
+ */
+interface GenerationHydrationResult {
+  resumeSnapshot: {
+    schemaVersion?: 1;
+    resumeState: {
+      threadId: string;
+      runId: string;
+    } | null;
+    status: 'idle' | 'running' | 'complete' | 'error';
+    result?: unknown;
+    error?: {
+      message: string;
+      code?: string;
+    };
+    activity?: string;
+  } | null;
+  activeRun: {
+    runId: string;
+  } | null;
+}
+/**
+ * Server-resolved hydration for a thread. `messages` is the stored transcript;
+ * `activeRun` is a cursor to a run still generating for the thread (or `null`).
+ * Keyed on the STABLE thread id — the client never handles a run id, so a turn
+ * that spans several runs (interrupt/tool continuations) reconnects correctly.
+ */
+interface ChatHydrationResult {
+  messages: Array<UIMessage$1>;
+  activeRun: {
+    runId: string;
+  } | null;
+  /**
+   * Pending human-in-the-loop interrupts for the thread and the run they paused,
+   * so a reload (or another device) re-prompts the approval from the server. The
+   * client restores them exactly as a persisted resume snapshot would.
+   */
+  interrupts: {
+    runId: string;
+    pending: Array<ChatPendingInterrupt>;
+  } | null;
+}
+interface SubscribeConnectionAdapter {
+  /**
+   * Subscribe to stream chunks.
+   */
+  subscribe: (abortSignal?: AbortSignal) => AsyncIterable<StreamChunk>;
+  /**
+   * Send a request; chunks arrive through subscribe().
+   */
+  send: (messages: Array<UIMessage$1> | Array<ModelMessage>, data?: Record<string, any>, abortSignal?: AbortSignal, runContext?: RunAgentInputContext) => Promise<void>;
+  /**
+   * Re-attach to an existing run by id, replaying its stream from the start off
+   * the server's delivery-durability sink. Present only when the underlying
+   * connection is resumable (a `ResumableConnectConnectionAdapter`). Used to
+   * rejoin an in-flight run after a full page reload.
+   */
+  joinRun?: (runId: string, abortSignal?: AbortSignal) => AsyncIterable<StreamChunk>;
+  /**
+   * Server-authoritative hydration for a thread (transcript + in-flight-run
+   * cursor). Present only when the underlying connection supports it. The client
+   * calls it on mount to re-hydrate without any app-side loader or prop.
+   */
+  hydrate?: (threadId: string) => Promise<ChatHydrationResult>;
+}
+/**
+ * Connection adapter union.
+ * Provide either `connect`, or `subscribe` + `send`.
+ */
+type ConnectionAdapter = ConnectConnectionAdapter | SubscribeConnectionAdapter;
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/chat-client.d.ts
+type ChatClientUpdateOptionsWithoutContext<TTools extends ReadonlyArray<AnyClientTool>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = {
+  connection?: ConnectionAdapter;
+  fetcher?: ChatFetcher; /** @deprecated Use `forwardedProps` instead. */
+  body?: Record<string, any>;
+  forwardedProps?: Record<string, any>;
+  byok?: ByokClient;
+  byokProvider?: () => string | undefined;
+  tools?: TTools;
+  interrupts?: TInterrupts;
+  queue?: QueueOption;
+  onResponse?: (response?: Response) => void | Promise<void>;
+  onChunk?: (chunk: StreamChunk) => void;
+  onFinish?: (message: UIMessage) => void;
+  onError?: (error: Error) => void;
+  onSubscriptionChange?: (isSubscribed: boolean) => void;
+  onConnectionStatusChange?: (status: ConnectionStatus) => void;
+  onSessionGeneratingChange?: (isGenerating: boolean) => void;
+  onQueueChange?: (queue: Array<QueuedMessage>) => void;
+  onResumeStateChange?: (resumeState: ChatResumeState | null, pendingInterrupts: BoundInterrupts<TTools, TInterrupts>) => void;
+  /**
+   * Fires whenever the id of the run in flight changes: the new id when a run
+   * starts (including a rejoin), `null` when it settles.
+   */
+  onRunIdChange?: (runId: string | null) => void;
+  onInterruptStateChange?: (state: ChatInterruptState<TTools, TInterrupts>, context: {
+    source: 'hydrate' | 'live';
+  }) => void;
+  onCustomEvent?: (eventType: string, data: unknown, context: {
+    toolCallId?: string;
+  }) => void;
+};
+type ClientToolResult = {
+  toolCallId: string;
+  tool: string;
+  output: any;
+  state?: 'output-available' | 'output-error';
+  errorText?: string;
+};
+declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TContext = unknown, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = any> {
+  private readonly processor;
+  private connection;
+  private uniqueId;
+  private threadId;
+  private readonly persistor?;
+  private readonly clearedStreamTracker;
+  private currentRunId;
+  private lastResume;
+  private rejoinedRunId;
+  private readonly interruptManager;
+  private activeInterruptSubmission;
+  private interruptSubmissionFailure;
+  private readonly joinedRunWaiters;
+  private pendingResumeParentRunId;
+  private pendingResumeThreadId;
+  private pendingResumeItems;
+  private activeResumeThreadId;
+  private activeResumeRunId;
+  private bodyOption;
+  private forwardedPropsOption;
+  private byok;
+  private byokProvider;
+  private context;
+  private pendingMessageBody;
+  private queueConfig;
+  private messageQueue;
+  /**
+   * True from the moment `sendMessage` claims the client until its
+   * `streamResponse` settles. Closes the race where concurrent callers both
+   * see `isLoading === false`, both append a user message, and only one stream
+   * actually runs (leaving stranded user messages with no reply).
+   */
+  private sendInFlight;
+  /**
+   * True while `drainQueue` is delivering queued messages. Concurrent
+   * `sendMessage` calls during a drain are treated as busy and follow
+   * `whenBusy` (default: queue).
+   */
+  private messageQueueDraining;
+  /**
+   * Set by `whenBusy: 'interrupt'` so an in-progress FIFO drain loop stops
+   * before starting the next queued item (the interrupting send owns the client).
+   */
+  private stopMessageQueueDrain;
+  /**
+   * Sync claim held for the duration of `deliverMessage` so concurrent
+   * deliverers cannot both append a user message before only one stream runs.
+   */
+  private deliverClaim;
+  private isLoading;
+  private isSubscribed;
+  private error;
+  private status;
+  private connectionStatus;
+  private abortController;
+  private readonly clientToolsRef;
+  private readonly devtoolsBridge;
+  /**
+   * Alias for `this.events`. The bridge installs an
+   * emitter that auto-attaches run/thread context and auto-emits a
+   * snapshot after every event, so chat-client only ever calls
+   * `this.events.X(...)` exactly like it did before devtools landed.
+   */
+  private readonly events;
+  private currentStreamId;
+  private currentMessageId;
+  private readonly postStreamActions;
+  private readonly pendingToolExecutions;
+  private activeClientTools;
+  private activeContext;
+  private continuationPending;
+  private subscriptionAbortController;
+  private processingResolve;
+  private errorReportedGeneration;
+  private streamGeneration;
+  private continuationSkipped;
+  private draining;
+  private sessionGenerating;
+  private readonly activeRunIds;
+  /** Latched by `dispose()`; stops any late async callback starting new work. */
+  private disposed;
+  /** Whether a view is currently watching. See `attach` / `detach`. */
+  private tailing;
+  /** Constructor inputs `attach()` needs on every re-attach, not just the first. */
+  private readonly rejoinRunId;
+  private readonly cachesMessages;
+  private devtoolsMounted;
+  private readonly callbacksRef;
+  constructor(options: ChatClientOptions<TTools, TContext, TInterrupts>);
+  /**
+   * START TAILING: re-attach to an in-flight run so its chunks arrive here.
+   *
+   * Called by the constructor, and again by a UI wrapper every time its view
+   * mounts. Idempotent — attaching while already attached does nothing — so the
+   * constructor call and a wrapper's first mount cost one attach between them.
+   *
+   * Pairs with {@link detach}. The pair exists because tailing used to begin ONLY
+   * in the constructor, which meant a view could never stop tailing and then
+   * resume: unmount had to either keep the connection open or lose it for good.
+   * Keeping it open is what starved the page — a browser allows ~6 connections per
+   * origin, and one long-lived stream per view reaches that after a handful of
+   * views, after which every other request queues (measured: an in-page fetch took
+   * over two minutes while the same request from outside the browser took 17ms).
+   */
+  attach(): void;
+  /**
+   * STOP TAILING: drop the connection, keep everything else.
+   *
+   * Called by a UI wrapper when its view unmounts. The transcript, the resume
+   * pointer and the run id all stay, so a later {@link attach} repaints instantly
+   * and re-tails from the durable log — nothing is lost, because the run keeps
+   * going server-side and its log holds every chunk.
+   *
+   * Deliberately NOT `dispose()`: this client is expected back. And deliberately
+   * not `stop()`, which means "the user ended this run" — detaching says only that
+   * nobody is watching right now.
+   *
+   * `rejoinedRunId` is cleared so the next `attach` can re-join the same run;
+   * without that reset the guard in {@link maybeRejoinInFlight} would treat the
+   * run as already joined and the view would come back silent.
+   */
+  detach(): void;
+  private applyResumeSnapshot;
+  /**
+   * Apply a resume snapshot read from durable storage. Restores interrupt state,
+   * and for a bare in-flight run (no pending interrupts) also rejoins it. This is
+   * the async-store counterpart to the synchronous rejoin in the constructor:
+   * `applyResumeSnapshot` alone only handles interrupts, so an async store
+   * (`indexedDBPersistence`) would otherwise never rejoin a mid-stream run.
+   */
+  private applyPersistedResume;
+  /**
+   * Rejoin a persisted in-flight run, guarded so it fires at most once and never
+   * while another run is already active. Skipped when the connection is not
+   * resumable (`joinRun` absent), so a non-durable transport is a no-op.
+   */
+  private maybeRejoinInFlight;
+  /**
+   * Server-authoritative mount hydration (`persistence: true`). The client holds
+   * no transcript and no run pointer; on mount it asks the server — keyed by the
+   * stable threadId — for the stored transcript and whether a run is still
+   * generating. The transcript repaints immediately; an in-flight run is tailed
+   * through the same durability rejoin as a reload. Best-effort and
+   * non-blocking: a failure leaves the client empty rather than throwing, and a
+   * send that starts first owns the client (hydration then backs off).
+   */
+  private hydrateFromServer;
+  mountDevtools(): void;
+  private ensureThreadId;
+  /**
+   * Drain a runId-less RUN_ERROR that belongs to a cleared run the client is
+   * still tracking. The persistor owns the cleared-run bookkeeping; the client
+   * owns the active-run / session / processing state.
+   */
+  private drainIgnoredRunlessChunk;
+  private retireIgnoredClearedTerminalChunk;
+  private updateRunLifecycle;
+  /**
+   * Track interrupt state off the stream's terminal events. A RUN_FINISHED with
+   * an interrupt outcome records the pending interrupts + the run/thread to
+   * resume; any other terminal event for the tracked/current run clears that
+   * state. This is interrupt (state) resume — there is no delivery cursor.
+   */
+  private observeInterruptState;
+  /**
+   * The interrupt-resume state for the active/interrupted run (its run/thread
+   * ids), or null when there is nothing to resume. Apps can persist this to
+   * resume interrupts across a full reload.
+   */
+  getResumeState(): ChatResumeState | null;
+  /**
+   * The id of the run this client has in flight — one it started via a send or
+   * rejoined via `joinRun` — or null when there is none. Unlike
+   * {@link getResumeState}, this tracks ordinary runs too, not only one that is
+   * interrupted or being resumed. A run another client started and that arrives
+   * over a live subscription is not this client's run and is not reported here.
+   */
+  getCurrentRunId(): string | null;
+  private setCurrentRunId;
+  getInterruptState(): ChatInterruptState<TTools, TInterrupts>;
+  getInterrupts(): BoundInterrupts<TTools, TInterrupts>;
+  /** @deprecated Use getInterrupts(). */
+  getPendingInterrupts(): BoundInterrupts<TTools, TInterrupts>;
+  resolveInterrupts(approved: boolean): void;
+  resolveInterrupts(resolver: (interrupt: ResolvableChatInterrupt<TTools, TInterrupts>) => undefined): void;
+  cancelInterrupts(): void;
+  retryInterrupts(): void;
+  /** Unsafe low-level resume escape hatch. Prefer bound interrupt methods. */
+  resumeInterruptsUnsafe(resume: Array<RunAgentResumeItem>, state?: ChatResumeState): Promise<boolean>;
+  /** @deprecated Use bound interrupt methods or resumeInterruptsUnsafe(). */
+  resumeInterrupts(resume: Array<RunAgentResumeItem>, state?: ChatResumeState): Promise<boolean>;
+  private submitInterruptBatch;
+  private takeInterruptSubmissionFailure;
+  private interruptGeneration;
+  private generateUniqueId;
+  private setIsLoading;
+  private setStatus;
+  private setIsSubscribed;
+  private setConnectionStatus;
+  private setSessionGenerating;
+  private notifyResumeStateChange;
+  /**
+   * Build the durable resume snapshot from the current resume state + pending
+   * interrupt descriptors and hand it to the persistor (null clears it).
+   */
+  private persistResumeSnapshot;
+  private resetSessionGenerating;
+  private setError;
+  private buildDevtoolsBridgeOptions;
+  private getDevtoolsSnapshot;
+  private findMessageIdForToolCall;
+  private abortSubscriptionLoop;
+  private resolveProcessing;
+  private cancelInFlightStream;
+  private reportStreamError;
+  /**
+   * Start the background subscription loop.
+   */
+  private startSubscription;
+  /**
+   * Consume chunks from the connection subscription.
+   */
+  private consumeSubscription;
+  /**
+   * Re-attach to an in-flight run after a full page reload, replaying its stream
+   * from the server's delivery-durability log via `joinRun` (which returns the
+   * whole run so far, then tails live to completion).
+   *
+   * The log is the single source of truth for the run, so we rebuild the
+   * in-flight assistant bubble from it rather than trying to reconcile the
+   * server-hydrated partial with the replay: on the first chunk that actually
+   * (re)builds a message we drop the hydrated in-flight assistant, and the
+   * replay reconstructs one clean bubble. Dropping only on real content (not on
+   * `RUN_STARTED`) means a rejoin that connects but delivers nothing can never
+   * leave an empty bubble behind.
+   *
+   * Bounded connect: a durable backend keeps a from-start join open waiting for
+   * a producer, so a stale pointer to an unknown/evicted run would otherwise pin
+   * the UI in a loading state for the backend's full first-chunk deadline. We
+   * give up after {@link REJOIN_CONNECT_DEADLINE_MS} if no chunk arrives and
+   * clear the dead pointer so it does not retry on the next load.
+   *
+   * Replay chunks are processed WITHOUT the per-chunk yield the live path uses,
+   * so the buffered prefix snaps in and only the genuinely-live tail streams at
+   * network speed — a reload looks like the run continued, not like it re-typed.
+   */
+  private resumeInFlightRun;
+  /**
+   * Drop a hydrated, still-in-flight assistant turn so a resume replay can
+   * rebuild it cleanly. Only touches a trailing assistant message (the shape a
+   * reload-mid-stream leaves); a thread whose last turn is a user message (run
+   * never produced, or already settled) is left untouched.
+   */
+  private dropTrailingInFlightAssistant;
+  private processIncomingChunk;
+  private isActiveInterruptSubmissionFailure;
+  private resolveJoinedRun;
+  /**
+   * Ensure subscription loop is running, starting it if needed.
+   */
+  private ensureSubscription;
+  /**
+   * Create a promise that resolves when onStreamEnd fires.
+   * Used by streamResponse to await processing completion.
+   */
+  private waitForProcessing;
+  /**
+   * Send a message and stream the response.
+   * Supports both simple string content and multimodal content (images, audio, video, documents).
+   *
+   * @param content - The message content. Can be:
+   *   - A simple string for text-only messages
+   *   - A MultimodalContent object with content array and optional custom ID
+   * @param body - Optional body parameters to merge with the client's base body for this request.
+   *               Uses shallow merge with per-message body taking priority.
+   * @param sendOptions - Per-call overrides. `{ whenBusy }` overrides the
+   *                      queue policy for this one send. `{ body }`
+   *                      shallow-merges with `body` and with the chat-level
+   *                      `body` / `forwardedProps`. `sendOptions.body` wins
+   *                      on key collisions. Framework hooks forward this
+   *                      object as their second argument.
+   *
+   * @example
+   * ```ts
+   * // Simple text message
+   * await client.sendMessage('Hello!')
+   *
+   * // Text message with custom body params
+   * await client.sendMessage('Hello!', { temperature: 0.7 })
+   *
+   * // Per-call whenBusy override
+   * await client.sendMessage('Urgent', undefined, { whenBusy: 'interrupt' })
+   *
+   * // Per-call body via options. Same effect as the positional arg.
+   * // This is the shape the framework hooks (`useChat`, `injectChat`) forward.
+   * await client.sendMessage('Hello!', undefined, { body: { temperature: 0.7 } })
+   *
+   * // Multimodal message with image
+   * await client.sendMessage({
+   *   content: [
+   *     { type: 'text', content: 'What is in this image?' },
+   *     { type: 'image', source: { type: 'url', value: 'https://example.com/photo.jpg' } }
+   *   ]
+   * })
+   *
+   * // Multimodal message with custom ID and body params
+   * await client.sendMessage(
+   *   {
+   *     content: [
+   *       { type: 'text', content: 'Describe this audio' },
+   *       { type: 'audio', source: { type: 'data', value: 'base64...' } }
+   *     ],
+   *     id: 'custom-message-id'
+   *   },
+   *   { model: 'gpt-5.5' }
+   * )
+   * ```
+   */
+  sendMessage(content: string | MultimodalContent, body?: Record<string, any>, sendOptions?: SendMessageOptions): Promise<void>;
+  /** True while interrupt descriptors still own continuation. */
+  private hasPendingInterrupts;
+  /** True while an interrupt batch owns the next user turn. */
+  private hasBlockingInterrupts;
+  /** True while a stream is active, a send is claiming the client, or the queue is draining. */
+  private isSendBusy;
+  private resolveBusyReason;
+  /**
+   * Append a user message and run the stream. Used by both direct sends and
+   * queue drains — callers are responsible for busy/queue policy.
+   *
+   * Claims delivery synchronously before appending so concurrent callers
+   * cannot both add a user message when only one stream can run.
+   */
+  private deliverMessage;
+  /**
+   * Resolve the effective action for a send that arrives while busy.
+   * The returned `id` is the id that will be stored if the action is `queue`.
+   */
+  private decideWhenBusy;
+  private enqueueMessage;
+  /**
+   * Normalize the message input to extract content, optional id, and
+   * optional metadata. String form has no metadata. Trims string content.
+   */
+  private normalizeMessageInput;
+  /**
+   * Append a message and stream the response
+   */
+  append(message: UIMessage | ModelMessage): Promise<void>;
+  /**
+   * Stream a response from the LLM.
+   * Returns true if the stream completed successfully, false on abort or error.
+   */
+  private streamResponse;
+  /**
+   * Start the client subscription loop.
+   * This controls the connection lifecycle independently from request lifecycle.
+   */
+  subscribe(options?: {
+    restart?: boolean;
+  }): void;
+  /**
+   * Unsubscribe and fully tear down live behavior.
+   * This aborts an in-flight request and the subscription loop.
+   */
+  unsubscribe(): void;
+  /**
+   * Reload the last assistant message
+   */
+  reload(): Promise<void>;
+  /**
+   * Stop the current stream
+   */
+  stop(): void;
+  /**
+   * Clear all messages
+   */
+  clear(): void;
+  /**
+   * Add the result of a client-side tool execution
+   */
+  addToolResult(result: ClientToolResult): Promise<void>;
+  private addToolResultForClientTool;
+  private validateClientToolOutput;
+  /**
+   * Respond to a tool approval request
+   */
+  addToolApprovalResponse(response: {
+    id: string;
+    approved: boolean;
+  }): Promise<void>;
+  /**
+   * Queue an action to be executed after the current stream ends
+   */
+  private queuePostStreamAction;
+  /**
+   * Drain and execute all queued post-stream actions
+   */
+  private drainPostStreamActions;
+  /**
+   * Check if we should continue the flow and do so if needed
+   */
+  private checkForContinuation;
+  /**
+   * Check if all tool calls are complete and we should auto-send.
+   * Requires that there is at least one tool call in the last assistant message;
+   * a text-only response has nothing to auto-send.
+   */
+  private shouldAutoSend;
+  /**
+   * Get current messages
+   */
+  getMessages(): Array<UIMessage<TTools>>;
+  /**
+   * True when an interrupt (or another direct send) claimed the client during
+   * a drain. Read via a method so cross-await mutations are not constant-folded
+   * by control-flow analysis.
+   */
+  private shouldAbortMessageQueueDrain;
+  /**
+   * Deliver queued messages after a successful settle.
+   * - `batch`: merge everything currently queued into one send, looping so
+   *   messages enqueued during that batch stream are not stranded.
+   * - `fifo`: walk the queue in a loop, one stream at a time, until empty
+   *   (or until another send claims the client via interrupt).
+   *
+   * Uses `deliverMessage` directly so drains do not re-enter `sendMessage`'s
+   * busy/queue policy (which would re-queue items and strand the rest).
+   */
+  private drainQueue;
+  /**
+   * Drop any in-flight send claim and discard pending queued messages
+   * (stop / error / clear / unsubscribe / reload).
+   */
+  private discardPendingSends;
+  /**
+   * Get the current send queue (messages held while a stream was in flight).
+   */
+  getQueue(): Array<QueuedMessage>;
+  private emitQueueChange;
+  /**
+   * Remove a queued message by id before it drains.
+   */
+  cancelQueued(id: string): void;
+  /**
+   * Discard all pending queued messages (stop / error / clear / unsubscribe /
+   * reload). Does not send them. Emits `onQueueChange([])` when anything was
+   * removed.
+   */
+  private flushQueue;
+  /**
+   * Get loading state
+   */
+  getIsLoading(): boolean;
+  /**
+   * Get current status
+   */
+  getStatus(): ChatClientState;
+  /**
+   * Get whether the subscription loop is active
+   */
+  getIsSubscribed(): boolean;
+  /**
+   * Get current connection lifecycle status
+   */
+  getConnectionStatus(): ConnectionStatus;
+  /**
+   * Whether the shared session is actively generating.
+   * Derived from stream run events (RUN_STARTED / RUN_FINISHED / RUN_ERROR).
+   * Unlike `isLoading` (request-local), this reflects shared generation
+   * activity visible to all subscribers (e.g. across tabs/devices).
+   */
+  getSessionGenerating(): boolean;
+  /**
+   * Get current error
+   */
+  getError(): Error | undefined;
+  /**
+   * Manually set messages
+   */
+  setMessagesManually(messages: Array<UIMessage<TTools>>): void;
+  /**
+   * Update options refs (for use in React hooks to avoid recreating client)
+   */
+  updateOptions(options: ChatClientUpdateOptionsWithoutContext<TTools>): void;
+  updateOptions(options: ChatClientUpdateOptionsWithoutContext<TTools> & Pick<ChatClientOptions<TTools, TContext>, 'context'>): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/lib/types.d.ts
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => unknown; /** Type-level only; the spec keeps it undefined at runtime. */
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    } | undefined;
+  };
+}
+/**
+ * Input type `defineTool`/`defineWidget` derive from a `parameters` schema: a Standard Schema's
+ * validated output, or untyped props for a plain JSON Schema, which nothing validates in the browser.
+ */
+type InferParameters<S extends ParametersSchema> = S extends StandardSchemaV1<any, infer O> ? O : Record<string, unknown>;
+/** A plain JSON Schema object, the same shape tool definitions use for their parameters. */
+interface JsonSchemaObject {
+  type: "object";
+  properties?: Record<string, unknown>;
+  required?: string[];
+  [keyword: string]: unknown;
+}
+/** Schema of the input the agent supplies to a widget or tool, like a tool definition's parameters. */
+type ParametersSchema = StandardSchemaV1 | JsonSchemaObject;
+interface WidgetDefinition {
+  /** Tells the agent what the widget shows so it can decide when to render it. */
+  description: string;
+  /**
+   * Forwarded to the agent as JSON Schema. Only a Standard Schema also validates the
+   * props before `render` runs; with a plain JSON Schema, treat the props as untrusted.
+   */
+  parameters?: ParametersSchema;
+  /**
+   * Draws the widget with the agent-chosen props into `container`, a light-DOM child of
+   * the mount target. May return a cleanup, called before a re-render and on unmount.
+   */
+  render: (props: Record<string, unknown>, container: HTMLElement) => (() => void) | void;
+}
+interface ToolDefinition {
+  /** Tells the agent what the tool does so it can decide when to call it. */
+  description: string;
+  /**
+   * Forwarded verbatim as the tool definition's metadata. A string `title` labels the tool's
+   * transcript entry instead of its registry name (`refresh_invoices` reads as "Refresh invoices").
+   */
+  metadata?: Record<string, unknown> | undefined;
+  /**
+   * Forwarded to the agent as JSON Schema. Only a Standard Schema also validates the
+   * input before `execute` runs; with a plain JSON Schema, treat the input as untrusted.
+   */
+  parameters?: ParametersSchema;
+  /**
+   * Runs in the host page with the agent-chosen input. The resolved value is returned
+   * to the agent as the tool result; a thrown error is returned as a tool error.
+   */
+  execute: (input: Record<string, unknown>) => unknown | Promise<unknown>;
+}
+//#endregion
+//#region src/lib/debug.d.ts
+declare const CATEGORY_COLORS: {
+  readonly mount: "#7c3aed";
+  readonly auth: "#be185d";
+  readonly theme: "#8b5cf6";
+  readonly send: "#2563eb";
+  readonly run: "#0891b2";
+  readonly stream: "#0e7490";
+  readonly text: "#16a34a";
+  readonly reasoning: "#64748b";
+  readonly tool: "#d97706";
+  readonly widget: "#db2777";
+  readonly attachment: "#0d9488";
+  readonly sandbox: "#0369a1";
+  readonly questionnaire: "#9333ea";
+  readonly status: "#475569";
+  readonly error: "#dc2626";
+};
+/** Category of a debug line, each with its own badge color; a typo fails the typecheck. */
+type DebugCategory = keyof typeof CATEGORY_COLORS;
+/** Logs one debug line: a colored category badge, a summary, and the full data. */
+type DebugLogger = (category: DebugCategory, summary: string, data?: unknown) => void;
+//#endregion
+//#region src/core/types.d.ts
+interface RenderWidgetInput {
+  /** Key into the `widgets` object passed at mount. */
+  widget: string;
+  props?: Record<string, unknown>;
+}
+/** Sandbox provisioning progress, as the endpoint's CUSTOM status event reports it. */
+type SandboxStatus = "starting" | "ready" | "error";
+/** One file the agent wrote into the sandbox, read back out of its own tool call. */
+interface SandboxFileWrite {
+  toolCallId: string;
+  /** Absolute path in the sandbox, which is also what one file is identified by. */
+  path: string;
+  /** The same path as a row should show it: workspace-relative when the endpoint said so. */
+  label: string;
+  content: string;
+  lines: number;
+  /** False while the content is still streaming, or if the write was refused. */
+  written: boolean;
+}
+/** One command the agent ran in the sandbox, with whatever of its result has arrived. */
+interface SandboxCommandRun {
+  toolCallId: string;
+  command: string;
+  cwd?: string | undefined;
+  /** Absent while the command is still running, and when it timed out. */
+  exitCode?: number | undefined;
+  /** Combined output on providers whose blocking exec has no separate stderr channel. */
+  stdout: string;
+  stderr: string;
+  durationMs?: number | undefined;
+  timedOut: boolean;
+  /** The endpoint elided the middle of the output to keep the run bounded. */
+  truncated: boolean;
+  finished: boolean;
+}
+/** One file the agent published for the user, with the ticket its download is authorized by. */
+interface SandboxArtifact {
+  toolCallId: string;
+  path: string;
+  label: string;
+  mimeType: string | undefined;
+  size: number | undefined;
+  /** Capability the files endpoint accepts in its query; the whole download authorization. */
+  ticket: string | undefined;
+  published: boolean;
+}
+/** Everything the sandbox did in this conversation, derived from the transcript. */
+interface SandboxActivity {
+  /** Latest write per path, in the order the paths were first written. */
+  files: SandboxFileWrite[];
+  commands: SandboxCommandRun[];
+}
+//#endregion
+//#region src/core/agent-tools.d.ts
+type RenderWidget = (input: RenderWidgetInput, toolCallId: string) => Promise<{
+  widget: string;
+  rendered: boolean;
+}>;
+/** What declaring a widget to the agent needs; `render` stays with whoever draws it. */
+type WidgetDeclaration = Pick<WidgetDefinition, "description" | "parameters">;
+/** The full tool set declared to the agent; `render_widget` only when widgets are registered. */
+declare function buildAgentTools(widgets: Record<string, WidgetDeclaration>, hostTools: Record<string, ToolDefinition>, renderWidget: RenderWidget, debug?: DebugLogger): ((ClientTool<{
+  type: "object";
+  properties: {
+    widget: {
+      type: string;
+      enum: string[];
+      description: string;
+    };
+    props: {
+      type: string;
+      description: string;
+    };
+  };
+  required: string[];
+}, undefined, "render_widget", unknown, false, undefined> & {
+  inputSchema: {
+    type: "object";
+    properties: {
+      widget: {
+        type: string;
+        enum: string[];
+        description: string;
+      };
+      props: {
+        type: string;
+        description: string;
+      };
+    };
+    required: string[];
+  };
+  outputSchema: undefined;
+  approvalSchema: undefined;
+}) | (ClientTool<{
+  type: "object";
+  properties: {
+    items: {
+      type: string;
+      minItems: number;
+      description: string;
+      items: {
+        type: string;
+        properties: {
+          name: {
+            type: string;
+            description: string;
+          };
+          title: {
+            type: string;
+            description: string;
+          };
+          description: {
+            type: string;
+            description: string;
+          };
+          required: {
+            type: string;
+            description: string;
+          };
+          multiple: {
+            type: string;
+            description: string;
+          };
+          choices: {
+            type: string;
+            minItems: number;
+            items: {
+              type: string;
+              properties: {
+                value: {
+                  type: string;
+                };
+                label: {
+                  type: string;
+                };
+                description: {
+                  type: string;
+                };
+              };
+              required: string[];
+            };
+          };
+          input: {
+            type: string;
+            description: string;
+            properties: {
+              label: {
+                type: string;
+              };
+              placeholder: {
+                type: string;
+              };
+            };
+            required: string[];
+          };
+        };
+        required: string[];
+      };
+    };
+  };
+  required: string[];
+}, undefined, "ask_questionnaire", unknown, false, undefined> & {
+  inputSchema: {
+    type: "object";
+    properties: {
+      items: {
+        type: string;
+        minItems: number;
+        description: string;
+        items: {
+          type: string;
+          properties: {
+            name: {
+              type: string;
+              description: string;
+            };
+            title: {
+              type: string;
+              description: string;
+            };
+            description: {
+              type: string;
+              description: string;
+            };
+            required: {
+              type: string;
+              description: string;
+            };
+            multiple: {
+              type: string;
+              description: string;
+            };
+            choices: {
+              type: string;
+              minItems: number;
+              items: {
+                type: string;
+                properties: {
+                  value: {
+                    type: string;
+                  };
+                  label: {
+                    type: string;
+                  };
+                  description: {
+                    type: string;
+                  };
+                };
+                required: string[];
+              };
+            };
+            input: {
+              type: string;
+              description: string;
+              properties: {
+                label: {
+                  type: string;
+                };
+                placeholder: {
+                  type: string;
+                };
+              };
+              required: string[];
+            };
+          };
+          required: string[];
+        };
+      };
+    };
+    required: string[];
+  };
+  outputSchema: undefined;
+  approvalSchema: undefined;
+}) | (ClientTool<SchemaInput, undefined, string, unknown, false, undefined> & {
+  inputSchema: SchemaInput;
+  outputSchema: undefined;
+  approvalSchema: undefined;
+}))[];
+//#endregion
+//#region src/core/auth.d.ts
+type ChatAuthenticationState = {
+  status: "loading";
+} | {
+  status: "ready";
+} | {
+  status: "error";
+  error: Error;
+};
+//#endregion
+//#region src/core/session.d.ts
+/** A widget render the agent requested, handed to the host's `onRenderWidget`. */
+interface WidgetRenderRequest {
+  widget: string;
+  props: Record<string, unknown>;
+  /** Keys the render: a repeat of the same call replaces its own render, not another's. */
+  toolCallId: string;
+}
+interface AstralBeamChatCoreOptions {
+  /** Public ID of the organization-owned agent; omitted, the organization's default answers. */
+  agentId?: string | undefined;
+  /** Base URL of the AstralBeam API; `/chat` hangs off it. Default the hosted cloud. */
+  apiUrl?: string | undefined;
+  /** The application endpoint that mints short-lived chat JWTs. Default `/api/astralbeam/token`. */
+  authTokenUrl?: string | undefined;
+  /** Host tools the agent can call; `execute` runs wherever this session lives. */
+  tools?: Record<string, ToolDefinition> | undefined;
+  /** Widgets declared to the agent; `onRenderWidget` is asked to draw them. */
+  widgets?: Record<string, WidgetDeclaration> | undefined;
+  /** Draws an agent-requested widget however the host wants; may return a cleanup. */
+  onRenderWidget?: ((request: WidgetRenderRequest) => (() => void) | void) | undefined;
+  /** Logs every action to the console and asks the endpoint to log its side too. */
+  debug?: boolean | undefined;
+}
+interface AstralBeamChatState {
+  messages: UIMessage[];
+  /** The underlying chat client status: "ready", "submitted", "streaming", or "error". */
+  status: ChatClientState;
+  error: Error | undefined;
+  auth: ChatAuthenticationState;
+  /** What the resolved agent grants; the UI should render only that. */
+  capabilities: {
+    attachments: boolean;
+  };
+  sandboxStatus: SandboxStatus | undefined;
+  sandbox: SandboxActivity;
+}
+interface AstralBeamChatCore {
+  getState: () => AstralBeamChatState;
+  /** Notifies on every state change; returns the unsubscribe. */
+  subscribe: (listener: () => void) => () => void;
+  /** Sends a message, first settling any dangling tool calls so the run can proceed. */
+  sendMessage: (content: string | MultimodalContent) => Promise<void>;
+  /** Resolves a client tool call the host executed itself (a questionnaire, an approval). */
+  addToolResult: ChatClient["addToolResult"];
+  /** Stops the in-flight generation; the transcript keeps what already streamed. */
+  stop: () => void;
+  /** Re-runs the last exchange. */
+  reload: () => Promise<void>;
+  /** Clears the conversation and disposes live widget renders. */
+  reset: () => void;
+  /** Tears the session down: the connection, authentication, and widget renders. */
+  dispose: () => void;
+}
+/**
+ * The headless AstralBeam chat session: authentication, transport, the tool protocol, and
+ * transcript state, with no markup. The drop-in widget is one consumer; a host that owns its
+ * whole UI is another.
+ */
+declare function createAstralBeamChat(options: AstralBeamChatCoreOptions): AstralBeamChatCore;
+//#endregion
+//#region src/core/messages.d.ts
+declare function isSettledToolCall(part: {
+  state: string;
+  output?: unknown;
+}): boolean;
+declare function lastPartInProgress(messages: UIMessage[]): boolean;
+declare function hasPendingToolRun(messages: UIMessage[], toolNames: ReadonlySet<string>): boolean;
+//#endregion
+//#region src/core/sandbox.d.ts
+/**
+ * Everything the widget knows about the sandbox is read back out of the transcript: a
+ * `sandbox_write_file` call carries the file in its own input, a `sandbox_run_command` call the log
+ * in its output. One source of truth, so a reset clears it and a re-render cannot double-count.
+ * Tool input is partially parsed JSON while it streams, so every field is checked before it is read.
+ */
+type ToolCallPart = Extract<MessagePart, {
+  type: "tool-call";
+}>;
+declare function isSandboxTool(name: string): boolean;
+/** The agent asked for something the endpoint would not do; its reason is the only useful output. */
+declare function sandboxRefusal(part: ToolCallPart): string | undefined;
+/** A `sandbox_write_file` call, readable while its content is still streaming in. */
+declare function readSandboxFileWrite(part: ToolCallPart): SandboxFileWrite | undefined;
+/** A `sandbox_publish_artifact` call whose output carries the download ticket. */
+declare function readSandboxArtifact(part: ToolCallPart): SandboxArtifact | undefined;
+/** A `sandbox_run_command` call. `stdout` holds combined output on providers with no stderr. */
+declare function readSandboxCommandRun(part: ToolCallPart): SandboxCommandRun | undefined;
+/**
+ * The whole conversation's sandbox work, for the panel. A path written more than once appears
+ * once, holding its latest content, because the panel answers "what is in the sandbox now".
+ */
+declare function collectSandboxActivity(messages: UIMessage[]): SandboxActivity;
+/** The one-line summary a finished command carries, in its row's label and under its log. */
+declare function describeSandboxCommandRun(run: SandboxCommandRun): string;
+//#endregion
+//#region src/core/protocol.d.ts
+declare const RENDER_WIDGET_TOOL = "render_widget";
+declare const ASK_QUESTIONNAIRE_TOOL = "ask_questionnaire";
+declare const SANDBOX_WRITE_FILE_TOOL = "sandbox_write_file";
+declare const SANDBOX_PUBLISH_ARTIFACT_TOOL = "sandbox_publish_artifact";
+declare const SANDBOX_READ_FILE_TOOL = "sandbox_read_file";
+declare const SANDBOX_LIST_FILES_TOOL = "sandbox_list_files";
+declare const SANDBOX_RUN_COMMAND_TOOL = "sandbox_run_command";
+/** CUSTOM stream event carrying sandbox provisioning progress, which no tool result can report. */
+declare const SANDBOX_STATUS_EVENT = "astralbeam.sandbox.status";
+//#endregion
+//#region src/lib/define.d.ts
+interface TypedToolDefinition<S extends ParametersSchema = JsonSchemaObject> {
+  description: string;
+  metadata?: Record<string, unknown> | undefined;
+  parameters?: S;
+  execute: (input: InferParameters<S>) => unknown | Promise<unknown>;
+}
+interface TypedWidgetDefinition<S extends ParametersSchema = JsonSchemaObject> {
+  description: string;
+  parameters?: S;
+  render: (props: InferParameters<S>, container: HTMLElement) => (() => void) | void;
+}
+/** Declares a host tool; a Standard Schema `parameters` types (and validates) `execute`'s input. */
+declare function defineTool<const S extends ParametersSchema = JsonSchemaObject>(tool: TypedToolDefinition<S>): ToolDefinition;
+/** Declares a host widget; a Standard Schema `parameters` types (and validates) `render`'s props. */
+declare function defineWidget<const S extends ParametersSchema = JsonSchemaObject>(widget: TypedWidgetDefinition<S>): WidgetDefinition;
+//#endregion
+export { SandboxActivity as A, AstralBeamChatState as C, WidgetDeclaration as D, ChatAuthenticationState as E, InferParameters as F, JsonSchemaObject as I, ParametersSchema as L, SandboxCommandRun as M, SandboxFileWrite as N, buildAgentTools as O, SandboxStatus as P, StandardSchemaV1 as R, AstralBeamChatCoreOptions as S, createAstralBeamChat as T, sandboxRefusal as _, SANDBOX_LIST_FILES_TOOL as a, lastPartInProgress as b, SANDBOX_RUN_COMMAND_TOOL as c, collectSandboxActivity as d, describeSandboxCommandRun as f, readSandboxFileWrite as g, readSandboxCommandRun as h, RENDER_WIDGET_TOOL as i, SandboxArtifact as j, RenderWidgetInput as k, SANDBOX_STATUS_EVENT as l, readSandboxArtifact as m, defineWidget as n, SANDBOX_PUBLISH_ARTIFACT_TOOL as o, isSandboxTool as p, ASK_QUESTIONNAIRE_TOOL as r, SANDBOX_READ_FILE_TOOL as s, defineTool as t, SANDBOX_WRITE_FILE_TOOL as u, hasPendingToolRun as v, WidgetRenderRequest as w, AstralBeamChatCore as x, isSettledToolCall as y, ToolDefinition as z };