@astralbeam/sdk 0.13.6 → 0.13.7

package/dist/{index-B3y8nySY.d.ts → index-CpLgwh4y.d.ts}

@@ -1,4 +1,4 @@
-import { f as CurrentUser } from "./api-ImuMGEar.js";
+import { f as CurrentUser } from "./api-B_IIYO7t.js";
 
 //#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. */
@@ -117,7 +117,7 @@ declare namespace StandardJSONSchemaV1 {
   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
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/interrupts.d.ts
 interface InterruptCorrelation {
   threadId: string;
   interruptedRunId: string;
@@ -198,7 +198,7 @@ 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
+//#region node_modules/.deno/@tanstack+ai-event-client@0.13.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 {
@@ -224,7 +224,7 @@ 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
+//#region node_modules/.deno/@tanstack+ai-event-client@0.13.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.
@@ -320,7 +320,7 @@ type ProviderUsageDetails = Record<string, NonNullable<unknown>>;
  * it defaults to {@link ProviderUsageDetails} (an open, serializable record) for
  * generic consumers.
  */
-interface TokenUsage<TProviderDetails = ProviderUsageDetails> {
+interface TokenUsage$1<TProviderDetails = ProviderUsageDetails> {
   /** Total input/prompt tokens */
   promptTokens: number;
   /** Total output/completion tokens */
@@ -363,143 +363,11 @@ interface TokenUsage<TProviderDetails = ProviderUsageDetails> {
   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
+//#region node_modules/.deno/@ag-ui+core@1.0.0/node_modules/@ag-ui/core/dist/version-DEKfpZNa.d.ts
+//#region src/generated/types.d.ts
+/**
+ * The discriminator carried by every event.
+ */
 declare enum EventType {
   TEXT_MESSAGE_START = "TEXT_MESSAGE_START",
   TEXT_MESSAGE_CONTENT = "TEXT_MESSAGE_CONTENT",
@@ -510,16 +378,6 @@ declare enum EventType {
   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",
@@ -538,149 +396,2453 @@ declare enum EventType {
   REASONING_MESSAGE_END = "REASONING_MESSAGE_END",
   REASONING_MESSAGE_CHUNK = "REASONING_MESSAGE_CHUNK",
   REASONING_END = "REASONING_END",
-  REASONING_ENCRYPTED_VALUE = "REASONING_ENCRYPTED_VALUE"
+  REASONING_ENCRYPTED_VALUE = "REASONING_ENCRYPTED_VALUE",
+  SUBAGENT_STARTED = "SUBAGENT_STARTED",
+  SUBAGENT_FINISHED = "SUBAGENT_FINISHED",
+  SUBAGENT_ERROR = "SUBAGENT_ERROR"
 }
+/**
+ * Extra information attached to an event, a message, a tool call, a tool, an
+ * interrupt or a resume entry. Open by key: any JSON value is allowed under a
+ * key, including null, because a null there is meaningful data. The object
+ * itself may be absent but is never null when present. The key ag-ui is
+ * reserved for the protocol's own use; reservation is by convention, since
+ * validating the shape of a key's value would contradict being open by key.
+ */
+type Metadata = Record<string, any>;
+/**
+ * An opaque handle for one subagent invocation, not a reusable name for a
+ * subagent definition: two invocations of the same subagent carry two
+ * different values. Named to mirror runId one level down, the way the
+ * subagent's name mirrors agentId.
+ */
+type SubagentRunId = string;
+/**
+ * The roles a streamed text message may take. Excludes tool, which is carried
+ * by TOOL_CALL_RESULT rather than streamed as text.
+ */
 type TextMessageRole = "developer" | "system" | "assistant" | "user";
-type ReasoningEncryptedValueSubtype = "tool-call" | "message";
-interface BaseEvent {
-  type: EventType;
+/**
+ * Opens a streamed text message. The content arrives as TEXT_MESSAGE_CONTENT
+ * events and the message closes with TEXT_MESSAGE_END.
+ */
+type TextMessageStartEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.TEXT_MESSAGE_START;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
   timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
   rawEvent?: any;
-  [k: string]: unknown;
-}
-interface TextMessageStartEvent$1 extends BaseEvent {
-  type: EventType.TEXT_MESSAGE_START;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message this stream builds, and ties the later content and
+   * end events to it.
+   */
   messageId: string;
-  role: TextMessageRole;
+  /**
+   * Who the message is from. An absent role means assistant; that meaning is
+   * normative and stated in the prose, because a validator treats a default as
+   * documentation rather than as behaviour.
+   * @default "assistant"
+   */
+  role?: TextMessageRole;
+  /**
+   * An optional display name for the author, for providers that distinguish
+   * several participants in one role.
+   */
   name?: string;
-}
-interface TextMessageContentEvent$1 extends BaseEvent {
+};
+/**
+ * Appends a fragment to a streamed text message.
+ */
+type TextMessageContentEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.TEXT_MESSAGE_CONTENT;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The message this fragment belongs to.
+   */
   messageId: string;
+  /**
+   * The fragment to append. May be the empty string: providers emit empty
+   * deltas as keep-alives and while a tool call is being decided, and
+   * rejecting them would kill runs that are working correctly.
+   */
   delta: string;
-}
-interface TextMessageEndEvent$1 extends BaseEvent {
+};
+/**
+ * Closes a streamed text message.
+ */
+type TextMessageEndEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.TEXT_MESSAGE_END;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The message being closed.
+   */
   messageId: string;
-}
-interface ToolCallStartEvent$1 extends BaseEvent {
+};
+/**
+ * A shorthand that stands in for a start, content and end sequence, for
+ * producers that cannot know in advance where a message begins. Every field is
+ * optional because a continuation chunk omits what has not changed; which
+ * message a field-less chunk continues is a sequence question the prose
+ * specification answers.
+ */
+type TextMessageChunkEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.TEXT_MESSAGE_CHUNK;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The message this chunk belongs to. Absent continues the message already
+   * open.
+   */
+  messageId?: string;
+  /**
+   * Who the message is from, on the chunk that opens it.
+   */
+  role?: TextMessageRole;
+  /**
+   * The fragment to append. May be the empty string.
+   */
+  delta?: string;
+  /**
+   * An optional display name for the author.
+   */
+  name?: string;
+};
+/**
+ * Opens a tool call. The arguments arrive as TOOL_CALL_ARGS events and the
+ * call closes with TOOL_CALL_END.
+ */
+type ToolCallStartEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.TOOL_CALL_START;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the call, and ties the later args, end and result events to it.
+   */
   toolCallId: string;
+  /**
+   * Which tool is being called.
+   */
   toolCallName: string;
+  /**
+   * The assistant message that holds this call. Absent means the producer did
+   * not attribute it to one.
+   */
   parentMessageId?: string;
-}
-interface ToolCallArgsEvent$1 extends BaseEvent {
+};
+/**
+ * Appends a fragment of a tool call's arguments.
+ */
+type ToolCallArgsEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.TOOL_CALL_ARGS;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The call these arguments belong to.
+   */
   toolCallId: string;
+  /**
+   * A fragment of the arguments, which concatenate into the call's argument
+   * text — conventionally a JSON document, though the protocol does not
+   * validate it (see FunctionCall.arguments). Deliberately a string rather
+   * than parsed JSON: a fragment is not itself a document. May be the empty
+   * string.
+   */
   delta: string;
-}
-interface ToolCallEndEvent$1 extends BaseEvent {
+};
+/**
+ * Closes a tool call, meaning its arguments are complete.
+ */
+type ToolCallEndEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.TOOL_CALL_END;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The call being closed.
+   */
   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 {
+};
+/**
+ * A shorthand that stands in for a tool call's start, args and end sequence.
+ * Every field is optional for the same reason as TEXT_MESSAGE_CHUNK.
+ */
+type ToolCallChunkEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.TOOL_CALL_CHUNK;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The call this chunk belongs to. Absent continues the call already open.
+   */
+  toolCallId?: string;
+  /**
+   * Which tool is being called, on the chunk that opens it.
+   */
+  toolCallName?: string;
+  /**
+   * The assistant message that holds this call.
+   */
+  parentMessageId?: string;
+  /**
+   * A fragment of the arguments. May be the empty string.
+   */
+  delta?: string;
+};
+/**
+ * A text part.
+ */
+type TextPart$2 = {
+  /**
+   * Discriminator.
+   */
+  type: "text";
+  /**
+   * Identifies this part within its message. Optional, and nothing reads it
+   * yet: reserved so that a streamed part can be matched to its entry in
+   * history once assistant messages carry parts too.
+   */
+  id?: string;
+  /**
+   * The text.
+   */
+  text: string;
+  /**
+   * Extra information about this part. Unconstrained, as on the media parts.
+   * This is where a text search hit carries its source and title, rather than
+   * the protocol modelling a search-result part of its own.
+   */
+  metadata?: any;
+};
+/**
+ * Bytes carried inline.
+ */
+type DataSource = {
+  /**
+   * Discriminator.
+   */
+  type: "data";
+  /**
+   * The bytes, base64-encoded. contentEncoding is an annotation rather than a
+   * constraint in 2020-12, so a malformed string still validates here;
+   * rejecting one is the decoder's job.
+   * @contentEncoding base64
+   */
+  value: string;
+  /**
+   * What the bytes are. Required here, unlike on a URL source, because nothing
+   * else can tell a consumer how to read them.
+   */
+  mimeType: string;
+};
+/**
+ * Bytes referenced by URL, fetched by whoever needs them.
+ */
+type UrlSource = {
+  /**
+   * Discriminator.
+   */
+  type: "url";
+  /**
+   * The URL. Deliberately not constrained to a URI format, so a scheme a
+   * producer already uses is not rejected here.
+   */
+  value: string;
+  /**
+   * What the resource is, when the producer knows. Optional, because the
+   * response can say.
+   */
+  mimeType?: string;
+};
+/**
+ * Bytes already at the provider, named by a handle the provider issued: an
+ * OpenAI or Anthropic file id, a Gemini file URI, a storage URL only that
+ * provider can read. No bytes travel and nothing is fetched. Only the provider
+ * that minted the handle can resolve it; a peer that cannot drops the part as
+ * it drops any part it cannot use.
+ */
+type FileSource = {
+  /**
+   * Discriminator.
+   */
+  type: "file";
+  /**
+   * The handle, exactly as the provider issued it. Opaque: a consumer MUST NOT
+   * fetch it, parse it or read a scheme out of it.
+   */
+  value: string;
+  /**
+   * Who issued the handle, when the producer knows. Optional: an agent already
+   * knows which provider it talks to. When present, SHOULD be the lowercase
+   * vendor id (openai, anthropic, google) that TokenUsage.provider uses, so a
+   * peer can tell before sending whether a handle is one it can use.
+   */
+  provider?: string;
+  /**
+   * What the file is, when the producer knows. Optional, because the provider
+   * that holds the bytes knows.
+   */
+  mimeType?: string;
+};
+/**
+ * Where a media part's bytes come from: carried inline, referenced by URL, or
+ * already at the provider under a handle it issued.
+ */
+type PartSource = DataSource | UrlSource | FileSource;
+/**
+ * An image part.
+ */
+type ImagePart$1 = {
+  /**
+   * Discriminator.
+   */
+  type: "image";
+  /**
+   * Identifies this part within its message. Optional, and nothing reads it
+   * yet: reserved as on the text part.
+   */
+  id?: string;
+  /**
+   * Where the image comes from.
+   */
+  source: PartSource;
+  /**
+   * Extra information about this part. Unconstrained rather than an object:
+   * inherited from the SDKs, which declare it unknown rather than a record;
+   * listed under known divergences in the README rather than resolved here.
+   */
+  metadata?: any;
+};
+/**
+ * An audio part.
+ */
+type AudioPart$1 = {
+  /**
+   * Discriminator.
+   */
+  type: "audio";
+  /**
+   * Identifies this part within its message. Optional, and nothing reads it
+   * yet: reserved as on the text part.
+   */
+  id?: string;
+  /**
+   * Where the audio comes from.
+   */
+  source: PartSource;
+  /**
+   * Extra information about this part. Unconstrained, as on the other media
+   * parts.
+   */
+  metadata?: any;
+};
+/**
+ * A video part.
+ */
+type VideoPart$1 = {
+  /**
+   * Discriminator.
+   */
+  type: "video";
+  /**
+   * Identifies this part within its message. Optional, and nothing reads it
+   * yet: reserved as on the text part.
+   */
+  id?: string;
+  /**
+   * Where the video comes from.
+   */
+  source: PartSource;
+  /**
+   * Extra information about this part. Unconstrained, as on the other media
+   * parts.
+   */
+  metadata?: any;
+};
+/**
+ * A document part.
+ */
+type DocumentPart$1 = {
+  /**
+   * Discriminator.
+   */
+  type: "document";
+  /**
+   * Identifies this part within its message. Optional, and nothing reads it
+   * yet: reserved as on the text part.
+   */
+  id?: string;
+  /**
+   * Where the document comes from.
+   */
+  source: PartSource;
+  /**
+   * Extra information about this part. Unconstrained, as on the other media
+   * parts.
+   */
+  metadata?: any;
+};
+/**
+ * One part of a message body: what a person sends in a user message, or what a
+ * tool returns in a tool message. Discriminated by type. Named by what the
+ * part is rather than by direction, because the same part travels into the
+ * model inside a user message and back out of the stream inside a tool result.
+ */
+type ContentPart$1 = TextPart$2 | ImagePart$1 | AudioPart$1 | VideoPart$1 | DocumentPart$1;
+/**
+ * Carries what a tool returned. Mints a tool message rather than appending to
+ * an existing one, which is why it has its own messageId.
+ */
+type ToolCallResultEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.TOOL_CALL_RESULT;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The tool message this result becomes.
+   */
+  messageId: string;
+  /**
+   * The call being answered.
+   */
+  toolCallId: string;
+  /**
+   * What the tool returned: either plain text, or an ordered list of parts,
+   * exactly as on the tool message this event mints. A tool returning
+   * structured data serialises it into text; media travel as parts of their
+   * own.
+   */
+  content: string | ContentPart$1[];
+  /**
+   * Present only for symmetry with the message it mints; the value is fixed,
+   * so a producer may leave it out.
+   */
+  role?: "tool";
+};
+/**
+ * Agent state. Any JSON value: the protocol carries state without interpreting
+ * it, so an object, an array, a string and a number are all valid.
+ */
+type State = any;
+/**
+ * Replaces the agent state wholesale. Sent when a delta cannot express the
+ * change, or to resynchronise a consumer.
+ */
+type StateSnapshotEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.STATE_SNAPSHOT;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The complete new state.
+   */
+  snapshot: State;
+};
+/**
+ * A JSON Pointer as defined by RFC 6901. Either the empty string, meaning the
+ * whole document, or a sequence of slash-prefixed reference tokens in which a
+ * tilde is escaped as ~0 and a slash as ~1. A value with no leading slash, or
+ * a tilde followed by anything other than 0 or 1, is not a JSON Pointer.
+ */
+type JsonPointer = string;
+/**
+ * Inserts value at path. RFC 6902 section 4.1.
+ */
+type AddOperation = {
+  /**
+   * Discriminator for the add operation.
+   */
+  op: "add";
+  /**
+   * Where to insert the value.
+   */
+  path: JsonPointer;
+  /**
+   * The value to insert. Any JSON value, including null, which is a legitimate
+   * thing to add.
+   */
+  value: any;
+};
+/**
+ * Removes the value at path. RFC 6902 section 4.2.
+ */
+type RemoveOperation = {
+  /**
+   * Discriminator for the remove operation.
+   */
+  op: "remove";
+  /**
+   * What to remove.
+   */
+  path: JsonPointer;
+};
+/**
+ * Replaces the value at path. RFC 6902 section 4.3.
+ */
+type ReplaceOperation = {
+  /**
+   * Discriminator for the replace operation.
+   */
+  op: "replace";
+  /**
+   * What to replace.
+   */
+  path: JsonPointer;
+  /**
+   * The replacement. Any JSON value, including null.
+   */
+  value: any;
+};
+/**
+ * Moves the value at from to path. RFC 6902 section 4.4.
+ */
+type MoveOperation = {
+  /**
+   * Discriminator for the move operation.
+   */
+  op: "move";
+  /**
+   * Where the value is moved from.
+   */
+  from: JsonPointer;
+  /**
+   * Where the value is moved to.
+   */
+  path: JsonPointer;
+};
+/**
+ * Copies the value at from to path. RFC 6902 section 4.5.
+ */
+type CopyOperation = {
+  /**
+   * Discriminator for the copy operation.
+   */
+  op: "copy";
+  /**
+   * Where the value is copied from.
+   */
+  from: JsonPointer;
+  /**
+   * Where the value is copied to.
+   */
+  path: JsonPointer;
+};
+/**
+ * Asserts that the value at path equals value. RFC 6902 section 4.6.
+ */
+type TestOperation = {
+  /**
+   * Discriminator for the test operation.
+   */
+  op: "test";
+  /**
+   * What to compare.
+   */
+  path: JsonPointer;
+  /**
+   * The value the target must equal. Any JSON value, including null.
+   */
+  value: any;
+};
+/**
+ * A single RFC 6902 operation. Exactly one of the operation shapes must match,
+ * discriminated by op. Unlike the protocol's own objects, the operations are
+ * open: RFC 6902 section 4 requires members an operation does not define to be
+ * ignored rather than rejected, so a remove carrying a leftover value is a
+ * valid patch. Two of the RFC's rules are relations between values rather than
+ * shapes, so no static schema can express them and neither is checked here: a
+ * move whose from is a proper prefix of its path (section 4.4), and any
+ * operation whose pointer does not resolve in the target document. Both are
+ * the applier's to reject.
+ */
+type JsonPatchOperation = AddOperation | RemoveOperation | ReplaceOperation | MoveOperation | CopyOperation | TestOperation;
+/**
+ * A JSON Patch document as defined by RFC 6902, referenced by
+ * STATE_DELTA.delta and ACTIVITY_DELTA.patch: an ordered sequence of
+ * operations applied to a target document. An empty array is a valid no-op
+ * patch. Whether the operations actually apply to the document they target is
+ * a runtime question RFC 6902 leaves to the applier; structural validity here
+ * says nothing about it.
+ */
+type JsonPatch = JsonPatchOperation[];
+/**
+ * Changes the agent state incrementally.
+ */
+type StateDeltaEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.STATE_DELTA;
-  delta: any[];
-}
-interface MessagesSnapshotEvent$1 extends BaseEvent {
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The change, as an RFC 6902 patch against the current state. Structural
+   * validity here does not mean the patch applies: a well-formed operation may
+   * point at a path that does not exist, which RFC 6902 leaves to the applier.
+   */
+  delta: JsonPatch;
+};
+/**
+ * Instructions from the application developer.
+ */
+type DeveloperMessage = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message within the conversation.
+   */
+  id: string;
+  /**
+   * Who the message is from. Each message definition narrows this to a single
+   * value.
+   */
+  role: "developer";
+  /**
+   * An optional display name for the author.
+   */
+  name?: string;
+  /**
+   * A provider's opaque artefact belonging to this message, stored by a
+   * consumer and returned on a later turn.
+   */
+  encryptedValue?: string;
+  /**
+   * Extra information attached to this message.
+   */
+  metadata?: Metadata;
+  /**
+   * The instructions. Required: a developer message with nothing in it says
+   * nothing.
+   */
+  content: string;
+};
+/**
+ * Instructions from the system.
+ */
+type SystemMessage = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message within the conversation.
+   */
+  id: string;
+  /**
+   * Who the message is from. Each message definition narrows this to a single
+   * value.
+   */
+  role: "system";
+  /**
+   * An optional display name for the author.
+   */
+  name?: string;
+  /**
+   * A provider's opaque artefact belonging to this message, stored by a
+   * consumer and returned on a later turn.
+   */
+  encryptedValue?: string;
+  /**
+   * Extra information attached to this message.
+   */
+  metadata?: Metadata;
+  /**
+   * The instructions. Required.
+   */
+  content: string;
+};
+/**
+ * The name and arguments of a tool call.
+ */
+type FunctionCall = {
+  /**
+   * Which tool is being called.
+   */
+  name: string;
+  /**
+   * The arguments as a JSON string, not as parsed JSON. Kept as written
+   * because a model can emit arguments that are not valid JSON, and losing
+   * them at the protocol boundary would hide the fault from the consumer that
+   * has to handle it.
+   */
+  arguments: string;
+};
+/**
+ * A call an assistant message made. Carries no subagent attribution of its own
+ * and inherits its containing message's, since several calls can share one
+ * parent.
+ */
+type ToolCall$1 = {
+  /**
+   * Identifies the call. The answering tool message carries this as its
+   * toolCallId.
+   */
+  id: string;
+  /**
+   * The only kind of call the protocol models.
+   */
+  type: "function";
+  /**
+   * What is being called, and with what.
+   */
+  function: FunctionCall;
+  /**
+   * A provider's opaque artefact belonging to this call.
+   */
+  encryptedValue?: string;
+  /**
+   * Extra information attached to this call. Carried here rather than folded
+   * into the containing message, because several calls can share one parent
+   * and merging them would make the result depend on their order.
+   */
+  metadata?: Metadata;
+};
+/**
+ * A message from the agent. Content is optional because a turn may consist
+ * only of tool calls.
+ */
+type AssistantMessage = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message within the conversation.
+   */
+  id: string;
+  /**
+   * Who the message is from. Each message definition narrows this to a single
+   * value.
+   */
+  role: "assistant";
+  /**
+   * An optional display name for the author.
+   */
+  name?: string;
+  /**
+   * A provider's opaque artefact belonging to this message, stored by a
+   * consumer and returned on a later turn.
+   */
+  encryptedValue?: string;
+  /**
+   * Extra information attached to this message.
+   */
+  metadata?: Metadata;
+  /**
+   * What the agent said, if it said anything.
+   */
+  content?: string;
+  /**
+   * The tool calls this turn made.
+   */
+  toolCalls?: ToolCall$1[];
+};
+/**
+ * A message from the person using the application.
+ */
+type UserMessage = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message within the conversation.
+   */
+  id: string;
+  /**
+   * Who the message is from. Each message definition narrows this to a single
+   * value.
+   */
+  role: "user";
+  /**
+   * An optional display name for the author.
+   */
+  name?: string;
+  /**
+   * A provider's opaque artefact belonging to this message, stored by a
+   * consumer and returned on a later turn.
+   */
+  encryptedValue?: string;
+  /**
+   * Extra information attached to this message.
+   */
+  metadata?: Metadata;
+  /**
+   * What the person sent: either plain text, or an ordered list of parts for a
+   * multimodal message.
+   */
+  content: string | ContentPart$1[];
+};
+/**
+ * What a tool returned, as a message in the conversation. Stands alone rather
+ * than composing BaseMessage, because it carries no name.
+ */
+type ToolMessage = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message.
+   */
+  id: string;
+  /**
+   * Fixed. Declared here rather than inherited, because this message does not
+   * compose BaseMessage.
+   */
+  role: "tool";
+  /**
+   * What the tool returned: either plain text, or an ordered list of parts. A
+   * tool returning structured data serialises it into text; media travel as
+   * parts of their own.
+   */
+  content: string | ContentPart$1[];
+  /**
+   * The call this answers.
+   */
+  toolCallId: string;
+  /**
+   * Why the tool failed, when it did. Present alongside content rather than
+   * instead of it, so a partial result survives a failure.
+   */
+  error?: string;
+  /**
+   * A provider's opaque artefact belonging to this message.
+   */
+  encryptedValue?: string;
+  /**
+   * Extra information attached to this message.
+   */
+  metadata?: Metadata;
+};
+/**
+ * Structured progress that is not conversation content, materialised as a
+ * message so it keeps its place in the sequence. Stands alone rather than
+ * composing BaseMessage, because its content is an object rather than a
+ * string.
+ */
+type ActivityMessage = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message.
+   */
+  id: string;
+  /**
+   * Fixed. Declared here rather than inherited, because this message does not
+   * compose BaseMessage.
+   */
+  role: "activity";
+  /**
+   * What kind of activity this is. An open string: the set is the producer's.
+   */
+  activityType: string;
+  /**
+   * The activity's payload, open by key.
+   */
+  content: Record<string, any>;
+  /**
+   * Extra information attached to this message.
+   */
+  metadata?: Metadata;
+};
+/**
+ * A span of the agent's reasoning, materialised as a message. Stands alone
+ * rather than composing BaseMessage, because it carries no name.
+ */
+type ReasoningMessage = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the message.
+   */
+  id: string;
+  /**
+   * Fixed. Declared here rather than inherited, because this message does not
+   * compose BaseMessage.
+   */
+  role: "reasoning";
+  /**
+   * The reasoning text.
+   */
+  content: string;
+  /**
+   * A provider's opaque reasoning artefact belonging to this message.
+   */
+  encryptedValue?: string;
+  /**
+   * Extra information attached to this message.
+   */
+  metadata?: Metadata;
+};
+/**
+ * Any message in a conversation. Discriminated by role.
+ */
+type Message = DeveloperMessage | SystemMessage | AssistantMessage | UserMessage | ToolMessage | ActivityMessage | ReasoningMessage;
+/**
+ * The complete set of messages the producer owns, in order. Conversation-wide
+ * rather than a plain overwrite: a consumer may keep messages of its own that
+ * no producer tracks, so exactly how a snapshot reconciles with those is
+ * behavioural and belongs in the prose. Being conversation-wide it cannot
+ * belong to a single subagent, so it carries no attribution; it does establish
+ * which subagent owns each message it contains, through the messages
+ * themselves.
+ */
+type MessagesSnapshotEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.MESSAGES_SNAPSHOT;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The messages the producer is declaring, in order.
+   */
   messages: Message[];
-}
-interface CustomEvent$1 extends BaseEvent {
+};
+/**
+ * Reports structured progress that is not conversation content, such as a step
+ * a UI renders as its own widget.
+ */
+type ActivitySnapshotEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.ACTIVITY_SNAPSHOT;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The activity message this describes.
+   */
+  messageId: string;
+  /**
+   * What kind of activity this is. An open string: the set is the producer's,
+   * not the protocol's.
+   */
+  activityType: string;
+  /**
+   * The activity's payload, open by key.
+   */
+  content: Record<string, any>;
+  /**
+   * Whether this snapshot overwrites the activity's existing content. Absent
+   * means it does, and that meaning is normative; only an explicit false asks
+   * a consumer to leave what is already there. It does not ask for a merge —
+   * ACTIVITY_DELTA is how content is changed incrementally. What a consumer
+   * does with a non-overwriting snapshot is behavioural and belongs in the
+   * prose.
+   * @default true
+   */
+  replace?: boolean;
+};
+/**
+ * Changes an activity message's content incrementally.
+ */
+type ActivityDeltaEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.ACTIVITY_DELTA;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The activity message being changed.
+   */
+  messageId: string;
+  /**
+   * What kind of activity this is.
+   */
+  activityType: string;
+  /**
+   * The change, as an RFC 6902 patch against the activity's content.
+   */
+  patch: JsonPatch;
+};
+/**
+ * Passes a provider-native event through untranslated, for consumers that need
+ * detail the protocol does not model.
+ */
+type RawEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.RAW;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The provider's own event. Any JSON value, and required: an event whose
+   * only purpose is to carry this would say nothing without it.
+   */
+  event: any;
+  /**
+   * Which provider or framework the event came from.
+   */
+  source?: string;
+};
+/**
+ * The protocol's extension point for an application's own events. Anything a
+ * consumer does with one is outside the protocol.
+ */
+type CustomEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.CUSTOM;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * What this custom event is. Required: without it a consumer cannot route
+   * the value.
+   */
   name: string;
-  value?: any;
-}
-interface RunStartedEvent$1 extends BaseEvent {
+  /**
+   * The payload. Any JSON value, and required.
+   */
+  value: any;
+};
+/**
+ * A tool the agent may call.
+ */
+type Tool$2 = {
+  /**
+   * The tool's name, as the agent will call it.
+   */
+  name: string;
+  /**
+   * What the tool does, for the agent to decide when to use it.
+   */
+  description: string;
+  /**
+   * A JSON Schema describing the tool's arguments. Carried opaquely: the
+   * protocol does not constrain or validate it. Optional, because all three
+   * SDKs already treat it that way and a tool that takes no arguments has
+   * nothing to declare; an absent schema and an empty one mean the same thing
+   * to an agent.
+   */
+  parameters?: any;
+  /**
+   * Extra information about the tool, for consumers that attach their own
+   * rendering or routing information to it.
+   */
+  metadata?: Metadata;
+};
+/**
+ * A named piece of ambient information given to the agent for the run,
+ * distinct from the conversation.
+ */
+type Context = {
+  /**
+   * What this context is, for the agent to interpret.
+   */
+  description: string;
+  /**
+   * The context itself.
+   */
+  value: string;
+};
+/**
+ * An answer to one interrupt, sent on the run that continues from it.
+ */
+type ResumeEntry = {
+  /**
+   * The interrupt being answered.
+   */
+  interruptId: string;
+  /**
+   * Whether the interrupt was answered or abandoned.
+   */
+  status: "resolved" | "cancelled";
+  /**
+   * The answer the agent asked for and will act on. Any JSON value.
+   */
+  payload?: any;
+  /**
+   * Envelope information about the response, such as signatures or routing
+   * keys, as opposed to payload, which is the answer itself.
+   */
+  metadata?: Metadata;
+};
+/**
+ * A request to run an agent. Also echoed back as RUN_STARTED.input. Only
+ * threadId, runId and messages are required: those are the three the SDKs
+ * already agree on, and for tools and context an absent key and an empty array
+ * mean the same thing, so requiring them would catch nothing a producer could
+ * get wrong. Requiredness above describes the wire; this TypeScript type
+ * additionally requires every field the SDK materialises.
+ */
+type RunAgentInput = {
+  /**
+   * The conversation this run belongs to.
+   */
+  threadId: string;
+  /**
+   * Identifies this run.
+   */
+  runId: string;
+  /**
+   * The protocol version this consumer speaks, such as "1.0". Absent means the
+   * input was produced before the protocol carried a version — the versioning
+   * rules in the prose govern what each side does with that. Sent in-band
+   * rather than by the transport, so a recorded exchange stays
+   * self-describing.
+   */
+  protocolVersion?: string;
+  /**
+   * The run that spawned this one.
+   */
+  parentRunId?: string;
+  /**
+   * The state the run starts from.
+   */
+  state?: State;
+  /**
+   * The conversation so far, in order.
+   */
+  messages: Message[];
+  /**
+   * The tools the agent may call. Absent means none. Optional on the wire; the
+   * TypeScript SDK materialises an absent one as an empty list, so this type
+   * requires it.
+   */
+  tools: Tool$2[];
+  /**
+   * Ambient information for the run. Absent means none. Optional on the wire;
+   * the TypeScript SDK materialises an absent one as an empty list, so this
+   * type requires it.
+   */
+  context: Context[];
+  /**
+   * Application-specific values passed through to the agent untouched. Any
+   * JSON value.
+   */
+  forwardedProps?: any;
+  /**
+   * Answers to the interrupts that ended a previous run, when this run
+   * continues from one.
+   */
+  resume?: ResumeEntry[];
+};
+/**
+ * Opens a run. Run-scoped, so it carries no subagent attribution.
+ */
+type RunStartedEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.RUN_STARTED;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The conversation this run belongs to.
+   */
   threadId: string;
+  /**
+   * Identifies this run.
+   */
   runId: string;
+  /**
+   * The protocol version this producer speaks, such as "1.0" — the producer's
+   * own version, not an echo of the input's, which is what makes the pair a
+   * negotiation: each side declares itself and the consumer sees a downgrade
+   * the moment it happens. Absent means a producer from before the protocol
+   * carried a version.
+   */
+  protocolVersion?: string;
+  /**
+   * The run that spawned this one, when an agent invokes another agent as a
+   * separate run rather than as a subagent within one.
+   */
   parentRunId?: string;
+  /**
+   * The request this run was started from, echoed back so a consumer that did
+   * not make the request can still see what the agent was asked.
+   */
   input?: RunAgentInput;
-}
-interface RunFinishedSuccessOutcome {
+};
+/**
+ * The run completed. Equivalent to an absent outcome. Closed like every other
+ * object, which is also what keeps it from carrying the suspended sibling's
+ * interrupts — a success with an interrupt still pending would be a
+ * contradiction, not an extension. A completed run may still have left
+ * frontend tool calls for the application to answer; pendingToolCallIds names
+ * them.
+ */
+type RunFinishedSuccessOutcome = {
+  /**
+   * Discriminator.
+   */
   type: "success";
-}
-interface RunFinishedInterruptOutcome {
+  /**
+   * The tool calls this run started and left unanswered — no TOOL_CALL_RESULT
+   * in the run — for the application to answer in the next input's messages,
+   * in the order they were made. Absent or empty means the producer named
+   * none, and a consumer derives the list from the stream; otherwise it is the
+   * list, and it agrees with the stream. On the success outcome rather than
+   * the event because a run that stopped on a frontend tool call is a
+   * completed run: whether the application continues the thread is its own
+   * decision, so the producer reports what it knows and no more. Each item: A
+   * tool call id, as carried by TOOL_CALL_START.
+   */
+  pendingToolCallIds?: string[];
+};
+/**
+ * Something a run needs from outside before it can continue, such as an
+ * approval or a missing value.
+ */
+type Interrupt$1 = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * Identifies the interrupt. A resume entry answers it by this id.
+   */
+  id: string;
+  /**
+   * Why the run stopped. An open string rather than an enumeration: the
+   * protocol does not attempt to classify every reason an agent might need
+   * input.
+   */
+  reason: string;
+  /**
+   * A human-readable prompt for whoever answers.
+   */
+  message?: string;
+  /**
+   * The tool call this interrupt concerns, when it is a tool approval.
+   */
+  toolCallId?: string;
+  /**
+   * A JSON Schema describing the answer this interrupt expects, so a consumer
+   * can build a form for it. Carried opaquely: the protocol does not constrain
+   * or validate it. Restricted to an object because TypeScript and Python both
+   * declare it that way; .NET holds it as any JSON, and the ticket that
+   * commissioned this schema lists it among the arbitrary-JSON fields.
+   * Following the two that constrain it keeps the schema from accepting
+   * documents the reference client rejects, at the cost of rejecting the
+   * boolean schemas JSON Schema also permits — a bare true for "any answer".
+   * Recorded as a known divergence rather than settled.
+   */
+  responseSchema?: Record<string, any>;
+  /**
+   * When the interrupt stops being answerable. Deliberately unconstrained
+   * rather than a date-time format, because producers already disagree about
+   * the representation and tightening it here would reject streams that work
+   * today. The documented convention is ISO 8601, and a consumer comparing
+   * this value will parse it as a date, so a value that is not one leaves the
+   * interrupt looking permanently unexpired.
+   */
+  expiresAt?: string;
+  /**
+   * Extra information attached to this interrupt.
+   */
+  metadata?: Metadata;
+};
+/**
+ * The run is paused, waiting for something outside it. Resuming means starting
+ * a new run whose resume entries answer these interrupts.
+ */
+type RunFinishedInterruptOutcome = {
+  /**
+   * Discriminator.
+   */
   type: "interrupt";
+  /**
+   * What the run is waiting for. At least one: an interrupt outcome with
+   * nothing to answer would leave a consumer with nothing to do.
+   */
   interrupts: Interrupt$1[];
-}
-type RunFinishedOutcome = RunFinishedSuccessOutcome | RunFinishedInterruptOutcome;
-interface RunFinishedEvent$1 extends BaseEvent {
+};
+/**
+ * The run was stopped before it completed, by whoever was running it, and did
+ * not fail. Neither success nor interrupt: nothing was produced as a result,
+ * and nothing is waited for, so the next run on the thread is an ordinary new
+ * run rather than a resume. Closed like its siblings: a cancelled run has no
+ * interrupts to carry. Named in the schema before 1.0 because an outcome a
+ * consumer does not recognise is stripped and read as success — a cancellation
+ * added later would reach every 1.0 consumer as a completed run.
+ */
+type RunFinishedCancelledOutcome = {
+  /**
+   * Discriminator.
+   */
+  type: "cancelled";
+};
+/**
+ * Why a run ended.
+ */
+type RunFinishedOutcome = RunFinishedSuccessOutcome | RunFinishedInterruptOutcome | RunFinishedCancelledOutcome;
+/**
+ * Token counts for one provider and model, in the protocol's own accounting:
+ * every count is either a total or a named part of one, so entries from
+ * different providers add up without double-counting. inputTokens and
+ * outputTokens are the totals; reasoningTokens, cachedInputTokens and
+ * cacheWriteInputTokens are parts of them, never additions to them;
+ * totalTokens is the two totals summed. Every field is a label or a number —
+ * nothing content-bearing or identifying, no prompts, completions, messages,
+ * or thread, run and user identifiers.
+ */
+type TokenUsage = {
+  /**
+   * Which provider served the request.
+   */
+  provider?: string;
+  /**
+   * Which model served the request.
+   */
+  model?: string;
+  /**
+   * Every prompt token the call was charged for: tokens read from a provider
+   * cache, tokens written to one, and audio or other non-text input all count
+   * here. cachedInputTokens and cacheWriteInputTokens break this number down
+   * and are never added to it — a provider that reports its cache counts
+   * beside a smaller input count has them added in by the producer before the
+   * entry leaves. Bounded like timestamp and for the same reason: a count
+   * above the JSON safe-integer range does not survive a round trip, so a
+   * consumer would silently read a different number than the producer wrote.
+   */
+  inputTokens?: number;
+  /**
+   * Every generated token, reasoning included where the provider distinguishes
+   * it. reasoningTokens breaks this number down and is never added to it — a
+   * provider that reports reasoning tokens beside a smaller completion count
+   * has them added in by the producer.
+   */
+  outputTokens?: number;
+  /**
+   * inputTokens plus outputTokens, under the accounting above. A producer MAY
+   * compute it rather than copy a provider's total, and copies a provider's
+   * total only when that total counts the same way, so a consumer can read
+   * this field as the sum of the other two.
+   */
+  totalTokens?: number;
+  /**
+   * Output tokens spent on reasoning, where the provider distinguishes them.
+   * Part of outputTokens, not in addition to it.
+   */
+  reasoningTokens?: number;
+  /**
+   * Input tokens read from a provider cache. Part of inputTokens, not in
+   * addition to it, and disjoint from cacheWriteInputTokens.
+   */
+  cachedInputTokens?: number;
+  /**
+   * Input tokens written to a provider cache on this call, where the provider
+   * distinguishes them. Part of inputTokens, not in addition to it, and
+   * disjoint from cachedInputTokens. Its own field because providers price a
+   * cache write differently from a cache read, so a consumer computing cost
+   * cannot do without it.
+   */
+  cacheWriteInputTokens?: number;
+};
+/**
+ * Closes a run that did not fail. Run-scoped, so it carries no subagent
+ * attribution.
+ */
+type RunFinishedEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.RUN_FINISHED;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The conversation this run belongs to.
+   */
   threadId: string;
+  /**
+   * The run being closed.
+   */
   runId: string;
+  /**
+   * The run's return value, if it has one. Any JSON value.
+   */
   result?: any;
+  /**
+   * Why the run ended. Absent means success, so every producer written before
+   * outcomes existed is already conformant.
+   */
   outcome?: RunFinishedOutcome;
-}
-interface RunErrorEvent$1 extends BaseEvent {
+  /**
+   * Token usage for the run, one entry per provider and model, so a run that
+   * invoked several models keeps them separate. A consumer that only wants
+   * totals sums across the entries. The run is the accounting boundary: usage
+   * covers every model call made within the run, calls made by its subagents
+   * included; an agent invoked as a separate run under parentRunId reports its
+   * own usage on its own terminal event; and a run that resumes an interrupted
+   * one reports only the calls it made itself, not the interrupted run's.
+   */
+  usage?: TokenUsage[];
+};
+/**
+ * Ends a run that failed. Run-scoped, so it carries no subagent attribution; a
+ * subagent that fails without ending the run reports SUBAGENT_ERROR instead.
+ */
+type RunErrorEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.RUN_ERROR;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * What went wrong, for a person to read.
+   */
   message: string;
+  /**
+   * A machine-readable error code. An open string: the protocol defines no
+   * vocabulary.
+   */
   code?: string;
-}
-interface StepStartedEvent$1 extends BaseEvent {
+  /**
+   * Token usage accrued before the failure, for a run that completed one or
+   * more model calls before dying. Scoped as on RUN_FINISHED: the run's own
+   * calls, subagents included.
+   */
+  usage?: TokenUsage[];
+};
+/**
+ * Opens a named step within a run, for producers whose frameworks have a step
+ * concept worth surfacing.
+ */
+type StepStartedEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.STEP_STARTED;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The step's name. Identifies it: the matching STEP_FINISHED carries the
+   * same name.
+   */
   stepName: string;
-}
-interface StepFinishedEvent$1 extends BaseEvent {
+};
+/**
+ * Closes a named step.
+ */
+type StepFinishedEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.STEP_FINISHED;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The step being closed.
+   */
   stepName: string;
-}
-interface ReasoningStartEvent$1 extends BaseEvent {
+};
+/**
+ * Opens a span of reasoning. A span may contain several reasoning messages.
+ */
+type ReasoningStartEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.REASONING_START;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The span being opened.
+   */
   messageId: string;
-}
-interface ReasoningMessageStartEvent$1 extends BaseEvent {
+};
+/**
+ * Opens a streamed reasoning message.
+ */
+type ReasoningMessageStartEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.REASONING_MESSAGE_START;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The reasoning message this stream builds.
+   */
   messageId: string;
+  /**
+   * Fixed, and required rather than defaulted. The requirement is inherited
+   * from the SDKs rather than chosen.
+   */
   role: "reasoning";
-}
-interface ReasoningMessageContentEvent$1 extends BaseEvent {
+};
+/**
+ * Appends a fragment to a streamed reasoning message.
+ */
+type ReasoningMessageContentEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.REASONING_MESSAGE_CONTENT;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The reasoning message this fragment belongs to.
+   */
   messageId: string;
+  /**
+   * The fragment to append. May be the empty string.
+   */
   delta: string;
-}
-interface ReasoningMessageEndEvent$1 extends BaseEvent {
+};
+/**
+ * Closes a streamed reasoning message.
+ */
+type ReasoningMessageEndEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.REASONING_MESSAGE_END;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The reasoning message being closed.
+   */
   messageId: string;
-}
-interface ReasoningEndEvent$1 extends BaseEvent {
+};
+/**
+ * A shorthand that stands in for a reasoning message's start, content and end
+ * sequence.
+ */
+type ReasoningMessageChunkEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.REASONING_MESSAGE_CHUNK;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The reasoning message this chunk belongs to. Absent continues the one
+   * already open.
+   */
+  messageId?: string;
+  /**
+   * The fragment to append. May be the empty string.
+   */
+  delta?: string;
+};
+/**
+ * Closes a span of reasoning.
+ */
+type ReasoningEndEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.REASONING_END;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * The span being closed.
+   */
   messageId: string;
-}
-interface ReasoningEncryptedValueEvent$1 extends BaseEvent {
+};
+/**
+ * Whether a REASONING_ENCRYPTED_VALUE belongs to a message or to a tool call.
+ */
+type ReasoningEncryptedValueSubtype = "tool-call" | "message";
+/**
+ * Carries a provider's opaque, encrypted reasoning artefact, which a consumer
+ * stores and returns on a later turn without being able to read it.
+ */
+type ReasoningEncryptedValueEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
   type: EventType.REASONING_ENCRYPTED_VALUE;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+  /**
+   * What kind of thing entityId names, which decides where the value is
+   * stored.
+   */
   subtype: ReasoningEncryptedValueSubtype;
+  /**
+   * What the value belongs to: a message id or a tool call id, according to
+   * subtype.
+   */
   entityId: string;
+  /**
+   * The provider's opaque artefact.
+   */
   encryptedValue: string;
-}
+};
+/**
+ * Announces that a subagent invocation has begun. Everything the subagent
+ * produces afterwards is attributed by carrying its subagentRunId, so a
+ * consumer can group the work without replaying the stream. Composed from
+ * BaseEvent alone rather than Attributable, because here subagentRunId
+ * identifies the subagent rather than attributing the event to one;
+ * attribution to an enclosing subagent is parentSubagentRunId.
+ */
+type SubagentStartedEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.SUBAGENT_STARTED;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The invocation being announced.
+   */
+  subagentRunId: SubagentRunId;
+  /**
+   * The subagent's name, which is reusable across invocations, unlike
+   * subagentRunId.
+   */
+  name: string;
+  /**
+   * What this subagent is for, for a consumer to display.
+   */
+  description?: string;
+  /**
+   * The subagent invocation that spawned this one, for nested delegation.
+   * Absent means the parent agent spawned it directly.
+   */
+  parentSubagentRunId?: SubagentRunId;
+  /**
+   * The tool call that spawned this subagent, for the pattern where agents are
+   * exposed to a model as tools. Lets a consumer tie the subagent to the call
+   * without reading rawEvent.
+   */
+  parentToolCallId?: string;
+  /**
+   * The message that held the spawning tool call.
+   */
+  parentMessageId?: string;
+};
+/**
+ * The subagent completed its work. Equivalent to an absent outcome.
+ */
+type SubagentFinishedSuccessOutcome = {
+  /**
+   * Discriminator.
+   */
+  type: "success";
+};
+/**
+ * The subagent is paused awaiting outside input. Terminal for this stream, not
+ * for the subagent: a later run may continue the same invocation once the
+ * interrupts are answered.
+ */
+type SubagentFinishedSuspendedOutcome = {
+  /**
+   * Discriminator.
+   */
+  type: "suspended";
+  /**
+   * The run-level interrupts this subagent raised itself. May be empty or
+   * absent: a subagent suspended because a descendant interrupted owns no
+   * interrupt of its own. Each item: An Interrupt.id.
+   */
+  interruptIds?: string[];
+};
+/**
+ * Why a subagent's segment of a run ended. Mirrors RunFinishedOutcome one
+ * level down.
+ */
+type SubagentFinishedOutcome = SubagentFinishedSuccessOutcome | SubagentFinishedSuspendedOutcome;
+/**
+ * Ends a subagent invocation's segment of this run, either because the work
+ * completed or because it is suspended awaiting outside input.
+ */
+type SubagentFinishedEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.SUBAGENT_FINISHED;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The invocation being closed.
+   */
+  subagentRunId: SubagentRunId;
+  /**
+   * The subagent's return value, if it has one. Any JSON value, mirroring
+   * RUN_FINISHED.result.
+   */
+  result?: any;
+  /**
+   * Why the segment ended. Absent means success. A suspended subagent is
+   * neither a success nor a failure, which is why saying so needs its own
+   * value rather than being inferred from a later interrupt.
+   */
+  outcome?: SubagentFinishedOutcome;
+};
+/**
+ * Reports that a subagent invocation failed. The run may continue: a parent
+ * agent is free to handle a failed subagent, which is why this is not
+ * RUN_ERROR.
+ */
+type SubagentErrorEvent$1 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.SUBAGENT_ERROR;
+  /**
+   * When the event was created. Bounded to the range JSON numbers survive a
+   * round trip in, so the value a consumer reads is the value the producer
+   * wrote. Deliberately not a float. The unit is not constrained here, because
+   * it never has been stated normatively; every SDK that sets it in practice
+   * uses milliseconds since the Unix epoch, and a producer choosing another
+   * unit will be misread by consumers even though it validates. Nothing in the
+   * protocol computes with this value.
+   */
+  timestamp?: number;
+  /**
+   * The provider-native event this one was translated from, carried verbatim
+   * for debugging and for consumers that need detail the protocol does not
+   * model. Any JSON value.
+   */
+  rawEvent?: any;
+  /**
+   * Extra information attached to this event.
+   */
+  metadata?: Metadata;
+  /**
+   * The invocation that failed.
+   */
+  subagentRunId: SubagentRunId;
+  /**
+   * What went wrong, for a person to read.
+   */
+  message: string;
+  /**
+   * A machine-readable error code. An open string.
+   */
+  code?: string;
+};
+/**
+ * Any AG-UI event. Every member is normative: there is no optional tier and no
+ * event a consumer may decline to implement. Discriminated by the type
+ * property.
+ */
+/**
+ * Describes a subagent that can be invoked by a parent agent.
+ */
+type SubagentInfo = {
+  /**
+   * Unique name or identifier of the subagent.
+   */
+  name: string;
+  /**
+   * What this subagent specializes in. Helps clients build agent selection
+   * UIs.
+   */
+  description?: string;
+};
+/**
+ * Basic metadata about the agent. Useful for discovery UIs, agent
+ * marketplaces, and debugging. Set these when you want clients to display
+ * agent information or when multiple agents are available and users need to
+ * pick one.
+ */
 //#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;
-}
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.d.ts
 /** TokenUsage fields that have no AG-UI `usage[]` equivalent. */
-type TokenUsageLeftover = Omit<TokenUsage, 'promptTokens' | 'completionTokens' | 'totalTokens'>;
+type TokenUsageLeftover = Omit<TokenUsage$1, 'promptTokens' | 'completionTokens' | 'totalTokens'>;
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/types.d.ts
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/types.d.ts
 /**
  * Tool call states - track the lifecycle of a tool call
  */
@@ -689,6 +2851,8 @@ type ToolCallState$1 = 'awaiting-input' | 'input-streaming' | 'input-complete' |
  * Tool result states - track the lifecycle of a tool result
  */
 type ToolResultState$1 = 'streaming' | 'complete' | 'error';
+/** Why a tool result ended without executing successfully. */
+type ToolResultOutcome = 'cancelled' | 'denied';
 type ToolOutputState = 'output-available' | 'output-error';
 /**
  * JSON Schema type for defining tool input/output schemas as raw JSON Schema objects.
@@ -761,103 +2925,42 @@ type SchemaInput = StandardJSONSchemaV1<any, any> | StandardSchemaV1$1<any, any>
  * 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;
-  };
+/** AG-UI `ToolCall` with typed metadata. `function.arguments` is a JSON string. */
+interface ToolCall<TMetadata = unknown> extends Omit<ToolCall$1, 'metadata'> {
   /** 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.
+ * Image content part for multimodal messages. AG-UI `ImagePart` with typed metadata.
  * @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;
+interface ImagePart<TMetadata = unknown> extends ImagePart$1 {
   /** Provider-specific metadata (e.g., OpenAI's detail: 'auto' | 'low' | 'high') */
   metadata?: TMetadata;
 }
 /**
- * Audio content part for multimodal messages.
+ * Audio content part for multimodal messages. AG-UI `AudioPart` with typed metadata.
  * @template TMetadata - Provider-specific metadata type
  */
-interface AudioPart<TMetadata = unknown> {
-  type: 'audio';
-  /** Source of the audio content */
-  source: ContentPartSource;
+interface AudioPart<TMetadata = unknown> extends AudioPart$1 {
   /** Provider-specific metadata (e.g., format, sample rate) */
   metadata?: TMetadata;
 }
 /**
- * Video content part for multimodal messages.
+ * Video content part for multimodal messages. AG-UI `VideoPart` with typed metadata.
  * @template TMetadata - Provider-specific metadata type
  */
-interface VideoPart<TMetadata = unknown> {
-  type: 'video';
-  /** Source of the video content */
-  source: ContentPartSource;
+interface VideoPart<TMetadata = unknown> extends VideoPart$1 {
   /** Provider-specific metadata (e.g., duration, resolution) */
   metadata?: TMetadata;
 }
 /**
- * Document content part for multimodal messages (e.g., PDFs).
+ * Document content part for multimodal messages (e.g., PDFs). AG-UI `DocumentPart` with typed metadata.
  * @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;
+interface DocumentPart<TMetadata = unknown> extends DocumentPart$1 {
   /** Provider-specific metadata (e.g., media_type for PDFs) */
   metadata?: TMetadata;
 }
@@ -879,6 +2982,10 @@ interface ModelMessage<TContent extends string | null | Array<ContentPart> = str
     content: string;
     signature?: string;
   }>;
+  /** Error reported by an AG-UI tool message. */
+  error?: string;
+  /** Optional AG-UI message metadata. TanStack-owned fields live under `tanstack`. */
+  metadata?: Record<string, any>;
   /**
    * Completed structured output represented by this assistant message.
    * `content` remains the provider-facing JSON text; this field preserves the
@@ -939,10 +3046,16 @@ interface ToolCallPart$2<TMetadata = unknown> {
 }
 interface ToolResultPart$1 {
   type: 'tool-result';
+  id?: string;
+  name?: string;
   toolCallId: string;
   content: string | Array<ContentPart>;
   state: ToolResultState$1;
+  /** Set when the user or middleware cancelled or denied the tool call; state remains `error`. */
+  outcome?: ToolResultOutcome;
   error?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
 }
 interface ThinkingPart$1 {
   type: 'thinking';
@@ -979,6 +3092,28 @@ interface StructuredOutputPart<TData = unknown> {
   /** Populated when `status === 'error'`. */
   errorMessage?: string;
 }
+type SubagentStatus = 'running' | 'finished' | 'error' | 'suspended';
+/**
+ * One child invocation as the client sees it. AG-UI `SubagentInfo` names the
+ * child; the other AG-UI fields come from its `SUBAGENT_STARTED`,
+ * `SUBAGENT_FINISHED` and `SUBAGENT_ERROR` events. `id` is the AG-UI
+ * `subagentRunId`. `status`, `parentRunId` and `messages` are client state the
+ * spec does not model.
+ */
+interface SubagentHandleData extends SubagentInfo, Pick<SubagentStartedEvent$1, 'parentSubagentRunId' | 'parentToolCallId' | 'metadata'> {
+  id: SubagentRunId;
+  status: SubagentStatus;
+  /** The parent chat run that started this child. */
+  parentRunId?: string;
+  /** Interrupts this child raised, while `status` is `'suspended'`. */
+  interruptIds?: SubagentFinishedSuspendedOutcome['interruptIds'];
+  messages: Array<UIMessage$1>;
+  error?: Pick<SubagentErrorEvent$1, 'message' | 'code'>;
+}
+interface SubagentPart$1 {
+  type: 'subagent';
+  subagent: SubagentHandleData;
+}
 interface UIResourcePart {
   type: 'ui-resource';
   /** The ui:// resource object in MCP-native shape — fed straight to the renderer. */
@@ -1000,7 +3135,7 @@ interface UIResourcePart {
    *  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;
+type MessagePart$1<TData = unknown> = TextPart$1 | ImagePart | AudioPart | VideoPart | DocumentPart | ToolCallPart$2 | ToolResultPart$1 | ThinkingPart$1 | StructuredOutputPart<TData> | UIResourcePart | SubagentPart$1;
 /**
  * Shape of `metadata.tanstack` on run events.
  */
@@ -1030,6 +3165,8 @@ interface UIMessage$1<TData = unknown> {
   role: 'system' | 'user' | 'assistant';
   parts: Array<MessagePart$1<TData>>;
   createdAt?: Date;
+  /** Optional AG-UI sender name. Converters preserve it across wire and persist. */
+  name?: string;
   /**
    * Optional AG-UI metadata bag. TanStack writes the `tanstack` key.
    * User keys stay at the top.
@@ -1054,6 +3191,32 @@ type RuntimeContextField<TContext> = IsUnknown$1<TContext> extends true ? {
    */
   context: TContext;
 };
+/**
+ * Options for a single `emitCustomEvent` call, on both the tool-execution and
+ * middleware contexts.
+ */
+interface EmitCustomEventOptions {
+  /**
+   * Keep this event in the durability batch with later chunks.
+   * CUSTOM events flush as soon as they are emitted, so a progress
+   * indicator can render at emit time. Pass `{ batch: true }` for a
+   * high-volume stream that should share appends with later output.
+   * `process.stdout`, `process.stderr`, `sandbox.file`, and
+   * `sandbox.file.diff` already batch.
+   */
+  batch?: boolean;
+}
+/**
+ * The user's answer to an `mcp_input` interrupt.
+ * `resolved` carries the `payload` from `resolveInterrupt`.
+ * `cancelled` means the user called `cancel()`.
+ */
+type ToolInputResponse = {
+  status: 'resolved';
+  payload: unknown;
+} | {
+  status: 'cancelled';
+};
 /**
  * Context passed to tool execute functions, providing capabilities like
  * emitting custom events during execution.
@@ -1066,12 +3229,20 @@ type ToolExecutionContext<TContext = unknown> = RuntimeContextField<TContext> &
    * e.g. MCP `callTool` — should forward this to cancel in-flight work.
    */
   abortSignal?: AbortSignal;
+  /**
+   * The answer to the input request that this tool call raised in the
+   * previous run. It is set only when the run resumes an `mcp_input`
+   * interrupt for this tool call.
+   */
+  inputResponse?: ToolInputResponse;
   /**
    * 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
+   * @param options - Pass `{ batch: true }` to keep this event in the
+   *   durability batch instead of flushing it immediately
    *
    * @example
    * ```ts
@@ -1084,7 +3255,7 @@ type ToolExecutionContext<TContext = unknown> = RuntimeContextField<TContext> &
    * })
    * ```
    */
-  emitCustomEvent: (eventName: string, value: Record<string, any>) => void;
+  emitCustomEvent: (eventName: string, value: Record<string, any>, options?: EmitCustomEventOptions) => 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>;
 /**
@@ -1223,7 +3394,7 @@ type RunAgentResumeItem = ResumeEntry & {
  */
 interface RunFinishedEvent extends Pick<RunFinishedEvent$1, 'threadId' | 'runId' | 'result' | 'outcome' | 'timestamp' | 'rawEvent'> {
   type: EventType.RUN_FINISHED;
-  usage?: Array<SpecTokenUsage> | TokenUsage;
+  usage?: Array<TokenUsage> | TokenUsage$1;
   /** Restored on the client from `metadata.tanstack`. */
   model?: string;
   /** Restored on the client from `metadata.tanstack`. */
@@ -1241,7 +3412,7 @@ interface RunFinishedEvent extends Pick<RunFinishedEvent$1, 'threadId' | 'runId'
  */
 interface RunErrorEvent extends Pick<RunErrorEvent$1, 'message' | 'code' | 'timestamp' | 'rawEvent'> {
   type: EventType.RUN_ERROR;
-  usage?: Array<SpecTokenUsage> | TokenUsage;
+  usage?: Array<TokenUsage> | TokenUsage$1;
   /** Restored on the client from `metadata.tanstack`. */
   threadId?: string;
   /** Restored on the client from `metadata.tanstack`. */
@@ -1278,13 +3449,10 @@ 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.
+ * @ag-ui/core provides: `toolCallId`, `toolCallName`, `parentMessageId?`,
+ * `subagentRunId?`
  */
-interface ToolCallStartEvent extends Pick<ToolCallStartEvent$1, 'toolCallId' | 'toolCallName' | 'parentMessageId' | 'timestamp' | 'rawEvent'> {
+interface ToolCallStartEvent extends Omit<ToolCallStartEvent$1, 'type'> {
   type: 'TOOL_CALL_START';
   /** Alias of `toolCallName`. Kept so existing stream readers still compile. */
   toolName?: string;
@@ -1300,11 +3468,9 @@ interface ToolCallArgsEvent extends ToolCallArgsEvent$1 {}
 /**
  * Emitted when a tool call completes.
  *
- * @ag-ui/core provides: `toolCallId`
- *
- * Same `Pick` (not `extends`) rationale as {@link ToolCallStartEvent}.
+ * @ag-ui/core provides: `toolCallId`, `subagentRunId?`
  */
-interface ToolCallEndEvent extends Pick<ToolCallEndEvent$1, 'toolCallId' | 'timestamp' | 'rawEvent'> {
+interface ToolCallEndEvent extends Omit<ToolCallEndEvent$1, 'type'> {
   type: 'TOOL_CALL_END';
   /** Parsed tool arguments when the adapter already parsed them. */
   input?: unknown;
@@ -1355,12 +3521,9 @@ 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.
+ * @ag-ui/core provides: `name`, `value`, `subagentRunId?`
  */
-interface CustomEvent extends Pick<CustomEvent$1, 'name' | 'value' | 'timestamp' | 'rawEvent'> {
+interface CustomEvent extends Omit<CustomEvent$1, 'type'> {
   type: 'CUSTOM';
   metadata?: Record<string, any>;
 }
@@ -1400,17 +3563,91 @@ interface ReasoningEndEvent extends ReasoningEndEvent$1 {}
  * @ag-ui/core provides: `subtype`, `entityId`, `encryptedValue`
  */
 interface ReasoningEncryptedValueEvent extends ReasoningEncryptedValueEvent$1 {}
+/** AG-UI 1.0 ActivitySnapshotEvent shape. */
+interface ActivitySnapshotEvent extends ActivitySnapshotEvent$1 {}
+/** AG-UI 1.0 ActivityDeltaEvent shape. */
+interface ActivityDeltaEvent extends ActivityDeltaEvent$1 {}
+/** AG-UI 1.0 RawEvent shape. */
+interface RawEvent extends RawEvent$1 {}
+/** AG-UI 1.0 TextMessageChunkEvent shape. */
+interface TextMessageChunkEvent extends TextMessageChunkEvent$1 {}
+/** AG-UI 1.0 ToolCallChunkEvent shape. */
+interface ToolCallChunkEvent extends ToolCallChunkEvent$1 {}
+/** AG-UI 1.0 ReasoningMessageChunkEvent shape. */
+interface ReasoningMessageChunkEvent extends ReasoningMessageChunkEvent$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;
+type AGUIEvent = ActivitySnapshotEvent | ActivityDeltaEvent | RawEvent | TextMessageChunkEvent | ToolCallChunkEvent | ReasoningMessageChunkEvent | RunStartedEvent | RunFinishedEvent | RunErrorEvent | TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent | ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent | ToolCallResultEvent | StepStartedEvent | StepFinishedEvent | MessagesSnapshotEvent | StateSnapshotEvent | StateDeltaEvent | CustomEvent | ReasoningStartEvent | ReasoningMessageStartEvent | ReasoningMessageContentEvent | ReasoningMessageEndEvent | ReasoningEndEvent | ReasoningEncryptedValueEvent | SubagentStartedEvent | SubagentFinishedEvent | SubagentErrorEvent;
+/**
+ * A child agent started. The later chunks for that child carry the same
+ * `subagentRunId`.
+ *
+ * @ag-ui/core provides: `subagentRunId`, `name`, `description?`,
+ * `parentSubagentRunId?`, `parentToolCallId?`, `parentMessageId?`, `metadata?`
+ */
+interface SubagentStartedEvent extends SubagentStartedEvent$1 {}
+/**
+ * A child agent's segment of this run ended.
+ *
+ * @ag-ui/core provides: `subagentRunId`, `result?`, `outcome?`
+ */
+interface SubagentFinishedEvent extends SubagentFinishedEvent$1 {}
+/**
+ * A child agent failed. The parent run can continue.
+ *
+ * @ag-ui/core provides: `subagentRunId`, `message`, `code?`
+ */
+interface SubagentErrorEvent extends SubagentErrorEvent$1 {}
 /**
  * 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
+//#region node_modules/.deno/@tanstack+ai@0.63.0/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.63.0/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
@@ -1450,6 +3687,7 @@ interface ClientTool<TInput extends SchemaInput | undefined = undefined, TOutput
   outputSchema?: TOutput;
   needsApproval?: TNeedsApproval;
   approvalSchema?: TApprovalSchema;
+  execution?: 'task';
   lazy?: boolean;
   metadata?: Record<string, unknown>;
   execute?: ToolExecuteFunction<TInput, TOutput, TContext>;
@@ -1463,6 +3701,7 @@ interface ToolDefinitionInstance<TInput extends SchemaInput | undefined = undefi
   outputSchema: TOutput;
   needsApproval?: TNeedsApproval;
   approvalSchema: TApprovalSchema;
+  execution?: 'task';
   readonly [toolApprovalCapability]?: {
     needsApproval: TNeedsApproval;
     approvalSchema: TApprovalSchema;
@@ -1489,7 +3728,7 @@ 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
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/types.d.ts
 /**
  * Strategy for determining when to emit text updates
  */
@@ -1507,56 +3746,34 @@ interface ChunkStrategy {
   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
+//#region node_modules/.deno/@tanstack+ai@0.63.0/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
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/byok/define-provider.d.ts
+/**
+ * A BYOK provider declared by an adapter. `id` is the `x-byok-<id>` slug and
+ * is required — `{ id?: string }` is not a {@link ByokProvider}.
+ */
+interface ByokProvider<TId extends string = string> {
+  readonly id: TId;
+  readonly label: string;
+  /**
+   * Env var names the relay may read. Names only — never put `process.env`
+   * values here. This object is imported on the client.
+   */
+  readonly env?: ReadonlyArray<string>;
+  /**
+   * Other descriptors this credential needs. A send for this provider also
+   * carries their headers and prompts for each one that is missing.
+   */
+  readonly with?: ReadonlyArray<ByokProvider>;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.36.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 {
@@ -1571,7 +3788,7 @@ interface KeyringStorage {
   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
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/byok/client.d.ts
 type KeyStatus = {
   state: 'empty';
 } | {
@@ -1597,6 +3814,11 @@ type ByokSnapshot = {
 };
 interface DefineByokOptions {
   storage?: KeyringStorage;
+  /**
+   * Descriptors whose `with` companions the store expands: `headers()` and
+   * `prepare()` for such a provider cover its companions too.
+   */
+  providers?: ReadonlyArray<ByokProvider>;
 }
 declare class ByokClient {
   #private;
@@ -1621,7 +3843,7 @@ declare class ByokClient {
   unlock(): Promise<void>;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/events.d.ts
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/events.d.ts
 interface ChatClientRunEventContext {
   threadId: string;
   runId: string;
@@ -1741,7 +3963,7 @@ declare abstract class ChatClientEventEmitter {
   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
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/devtools.d.ts
 interface AIDevtoolsDisplayOptions {
   name?: string;
 }
@@ -1821,7 +4043,7 @@ declare class ClientDevtoolsBridge<TSnapshot extends object> {
   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?: {
+  protected createEnvelope(eventType: 'hook:registered' | 'hook:updated' | 'hook:unregistered' | 'hook:state-snapshot' | 'tools:registered' | 'memory:retrieve:started' | 'memory:retrieve:completed' | 'memory:snapshot' | 'compaction:started' | 'compaction:state' | 'compaction:ended' | 'skills:snapshot' | AIDevtoolsRunEventType, visibility?: AIDevtoolsEventVisibility, context?: {
     runId?: string;
   }): AIDevtoolsEventEnvelope;
   private createMetadataPayload;
@@ -1842,6 +4064,10 @@ declare class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnap
   private lastRunEventContext;
   /** Last transported `memory:state` value, replayed when a panel opens. */
   private lastMemoryStateValue;
+  /** Transported compaction CUSTOM events, replayed when a panel opens. */
+  private readonly lastCompactionEvents;
+  /** Last transported `skills:state` value, replayed when a panel opens. */
+  private lastSkillsStateValue;
   constructor(options: ChatDevtoolsBridgeOptions);
   setCurrentStreamId(streamId: string | null): void;
   /**
@@ -1867,6 +4093,7 @@ declare class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnap
    * `recordResultChange` / `recordProgressChange`.
    */
   recordMemoryState(rawValue: unknown): void;
+  recordSkillsState(rawValue: unknown): void;
   /**
    * Re-emit the browser-side `memory:*` events from a transported
    * `memory:state` value. The devtools store consumes these to render the
@@ -1875,6 +4102,15 @@ declare class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnap
    * adapter supports introspection.
    */
   private emitMemoryState;
+  /**
+   * Record a transported compaction CUSTOM event. Called from the chat
+   * client's `onCustomEvent` handler so server-side compaction reaches the
+   * browser DevTools panel.
+   */
+  recordCompactionEvent(eventType: string, rawValue: unknown): void;
+  recordCompactionState(rawValue: unknown): void;
+  private emitCompactionEvent;
+  private emitSkillsState;
   protected onReplayState(): void;
   getCurrentRunEventContext(): ChatClientRunEventContext | undefined;
   getCurrentOrLastRunEventContext(): ChatClientRunEventContext | undefined;
@@ -1895,10 +4131,10 @@ declare class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnap
   private findClientTool;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.d.ts
+//#region node_modules/.deno/@tanstack+ai-client@0.36.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
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/types.d.ts
 interface ChatResumeState {
   threadId: string;
   runId: string;
@@ -2228,6 +4464,21 @@ interface TextPart {
   type: 'text';
   content: string;
 }
+/**
+ * Tool-call part for a bare `{ name }` tool, such as a server tool
+ * definition a subagent carries. No `approval` field.
+ */
+type ToolCallPartForNamedTool<T extends {
+  name: string;
+}> = {
+  type: 'tool-call';
+  id: string;
+  name: T['name'];
+  arguments: string;
+  input?: InferToolInput<T>;
+  state: ToolCallState;
+  output?: InferToolOutput<T>;
+};
 /**
  * Helper type that creates a tool-call part for a specific tool.
  * This is a conditional type to enable proper distribution over union types,
@@ -2255,7 +4506,9 @@ type ToolCallPartForTool<T> = T extends AnyClientTool ? {
     needsApproval: boolean;
     approved?: boolean;
   };
-} : unknown) : never;
+} : unknown) : T extends {
+  name: string;
+} ? ToolCallPartForNamedTool<T> : never;
 /**
  * Fallback tool-call part type when tools are not typed
  */
@@ -2285,19 +4538,75 @@ type UntypedToolCallPart = {
  * }
  * ```
  */
-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;
+type ToolCallPart$1<TTools extends ReadonlyArray<{
+  name: string;
+}> = any> = [TTools] extends [never] ? UntypedToolCallPart : unknown extends TTools ? UntypedToolCallPart : TTools extends ReadonlyArray<infer Tool> ? Tool extends {
+  name: string;
+} ? ToolCallPartForTool<Tool> : UntypedToolCallPart : UntypedToolCallPart;
 interface ToolResultPart {
   type: 'tool-result';
+  id?: string;
+  name?: string;
   toolCallId: string;
   content: string | Array<ContentPart>;
   state: ToolResultState;
+  /** Set when the user or middleware cancelled or denied the tool call; state remains `error`. */
+  outcome?: ToolResultOutcome;
   error?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
 }
 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;
+interface SubagentHandle extends SubagentHandleData {
+  /**
+   * Set by ChatClient on every card it holds, streamed, restored, or initial,
+   * nested cards included. Calling it marks the card `error` (`Stopped`),
+   * ignores that child's later chunks until the same child starts again, and
+   * aborts the local request, parent stream included. A durable server run
+   * keeps going.
+   */
+  stop?: () => void;
+}
+interface SubagentPart {
+  type: 'subagent';
+  subagent: SubagentHandle;
+}
+/**
+ * The slice of a server `defineAgent` result that the client reads for types.
+ * The client does not call `run`. Put tool definitions (from
+ * `toolDefinition`) in `tools` to type the child's tool calls and approvals.
+ */
+type SubagentClientAgent = {
+  name: string;
+  description?: string;
+  tools?: ReadonlyArray<{
+    name: string;
+  }>;
+  interrupts?: ReadonlyArray<InterruptDefinition<any, any, any, any>>;
+  outputSchema?: SchemaInput;
+};
+type AgentToolList<TAgent> = TAgent extends {
+  tools?: infer TTools;
+} ? [undefined] extends [TTools] ? [TTools] extends [undefined] ? any : Exclude<TTools, undefined> extends ReadonlyArray<infer TTool> ? [TTool] extends [never] ? any : Exclude<TTools, undefined> : any : TTools extends ReadonlyArray<infer TTool> ? [TTool] extends [never] ? any : TTools : any : any;
+type AgentOutputData<TAgent> = TAgent extends {
+  outputSchema?: infer TSchema;
+} ? Exclude<TSchema, undefined> extends SchemaInput ? [Exclude<TSchema, undefined>] extends [never] ? unknown : InferSchemaType<Exclude<TSchema, undefined>> : unknown : unknown;
+/** One child handle. `name` is the discriminant. */
+type SubagentHandleOf<TAgent extends SubagentClientAgent> = Omit<SubagentHandle, 'name' | 'messages'> & {
+  name: TAgent['name'];
+  messages: Array<UIMessage<AgentToolList<TAgent>, AgentOutputData<TAgent>>>;
+};
+type SubagentHandles<TAgents extends ReadonlyArray<SubagentClientAgent> | undefined> = [TAgents] extends [undefined] ? SubagentHandle : unknown extends TAgents ? SubagentHandle : TAgents extends ReadonlyArray<infer TAgent> ? TAgent extends SubagentClientAgent ? SubagentHandleOf<TAgent> : SubagentHandle : SubagentHandle;
+type SubagentPartOf<TAgents extends ReadonlyArray<SubagentClientAgent> | undefined> = [TAgents] extends [undefined] ? SubagentPart : unknown extends TAgents ? SubagentPart : {
+  type: 'subagent';
+  subagent: SubagentHandles<TAgents>;
+};
+type MessagePart<TTools extends ReadonlyArray<{
+  name: string;
+}> = any, TData = unknown, TSubagents extends ReadonlyArray<SubagentClientAgent> | undefined = undefined> = TextPart | ImagePart | AudioPart | VideoPart | DocumentPart | ToolCallPart$1<TTools> | ToolResultPart | ThinkingPart | StructuredOutputPart<TData> | UIResourcePart | SubagentPartOf<TSubagents>;
 /**
  * UIMessage - Domain-specific message format optimized for building chat UIs
  * Contains parts that can be text, tool calls, or tool results.
@@ -2310,10 +4619,13 @@ type MessagePart<TTools extends ReadonlyArray<AnyClientTool> = any, TData = unkn
  * 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> {
+interface UIMessage<TTools extends ReadonlyArray<{
+  name: string;
+}> = any, TData = unknown, TSubagents extends ReadonlyArray<SubagentClientAgent> | undefined = undefined> {
   id: string;
   role: 'system' | 'user' | 'assistant';
-  parts: Array<MessagePart<TTools, TData>>;
+  name?: string;
+  parts: Array<MessagePart<TTools, TData, TSubagents>>;
   createdAt?: Date;
   /**
    * Optional AG-UI metadata bag. TanStack writes the `tanstack` key.
@@ -2365,12 +4677,21 @@ interface ChatClientPersistence<TTools extends ReadonlyArray<AnyClientTool> = an
 type ChatPersistenceOptions<TTools extends ReadonlyArray<AnyClientTool> = any> = {
   persistence: true;
   threadId: string;
+  /**
+   * Newest-window size for server hydrate. Only with `persistence: true`.
+   * Without this, hydrate still loads the full thread.
+   */
+  history?: {
+    pageSize: number;
+  };
 } | {
   persistence: ChatClientPersistence<TTools>;
   threadId: string;
+  history?: never;
 } | {
   persistence?: false | undefined;
   threadId?: string;
+  history?: never;
 };
 type IsUnknown<T> = unknown extends T ? [T] extends [unknown] ? true : false : false;
 type KnownContext<T> = IsUnknown<T> extends true ? never : T;
@@ -2433,6 +4754,13 @@ interface ChatClientBaseOptions<TTools extends ReadonlyArray<AnyClientTool> = an
    * provider and stamps `x-byok-*` request headers. Keys never go in the body.
    */
   byok?: ByokClient;
+  /**
+   * The agents you pass to `chat({ subagents: { agents } })`, for types only.
+   * The client does not call `run`. `createChatHook` from
+   * `@tanstack/ai-react/ui` requires a `subagentsComponents` entry for every
+   * agent name.
+   */
+  subagents?: ReadonlyArray<SubagentClientAgent>;
   /**
    * Optional provider id for this chat. If it returns a provider slug,
    * only that key is prepared and sent. Otherwise the merged `provider`
@@ -2577,7 +4905,7 @@ interface ChatClientBaseOptions<TTools extends ReadonlyArray<AnyClientTool> = an
  */
 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
+//#region node_modules/.deno/@tanstack+ai-client@0.36.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
@@ -2633,7 +4961,7 @@ interface ConnectConnectionAdapter {
    * `fetchServerSentEvents` / `fetchHttpStream`, and on `stream()` /
    * `rpcStream()` when supplied via {@link StreamConnectionHandlers}.
    */
-  hydrate?: (threadId: string) => Promise<ChatHydrationResult>;
+  hydrate?: (threadId: string, options?: ChatHydrateOptions) => Promise<ChatHydrationResult>;
 }
 /**
  * Server-resolved hydration for a generation thread. `resumeSnapshot` is the
@@ -2669,11 +4997,22 @@ interface GenerationHydrationResult {
     runId: string;
   } | null;
 }
+/**
+ * Optional paging for a chat hydrate GET.
+ * Omit both fields to load the full thread.
+ */
+interface ChatHydrateOptions {
+  limit?: number;
+  before?: string;
+}
 /**
  * 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.
+ *
+ * `page` is additive. Old servers omit it; treat that as a full list
+ * (`truncated: false`).
  */
 interface ChatHydrationResult {
   messages: Array<UIMessage$1>;
@@ -2689,6 +5028,16 @@ interface ChatHydrationResult {
     runId: string;
     pending: Array<ChatPendingInterrupt>;
   } | null;
+  /**
+   * Whether this window is a slice of a longer thread.
+   * `cursor` is set when `truncated` is true and is sent back as `before`.
+   */
+  page?: {
+    truncated: false;
+  } | {
+    truncated: true;
+    cursor: string;
+  };
 }
 interface SubscribeConnectionAdapter {
   /**
@@ -2711,7 +5060,7 @@ interface SubscribeConnectionAdapter {
    * 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>;
+  hydrate?: (threadId: string, options?: ChatHydrateOptions) => Promise<ChatHydrationResult>;
 }
 /**
  * Connection adapter union.
@@ -2719,7 +5068,7 @@ interface SubscribeConnectionAdapter {
  */
 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
+//#region node_modules/.deno/@tanstack+ai-client@0.36.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. */
@@ -2760,6 +5109,8 @@ type ClientToolResult = {
 };
 declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TContext = unknown, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = any> {
   private readonly processor;
+  private readonly subagentHandles;
+  private readonly stoppedSubagentIds;
   private connection;
   private uniqueId;
   private threadId;
@@ -2767,6 +5118,8 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
   private readonly clearedStreamTracker;
   private currentRunId;
   private lastResume;
+  private readonly runParents;
+  private readonly supersededInterruptRunIds;
   private rejoinedRunId;
   private readonly interruptManager;
   private activeInterruptSubmission;
@@ -2832,19 +5185,39 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
   private continuationPending;
   private subscriptionAbortController;
   private processingResolve;
+  /**
+   * `connect()` adapters push the full HTTP body into the subscribe queue, then
+   * wait until that queue is idle. After `send()` returns, every chunk from this
+   * request has been processed. Subscribe/send sockets do not drain that way.
+   */
+  private connectionDrainsOnSend;
   private errorReportedGeneration;
   private streamGeneration;
+  private continuationGeneration;
+  private streamContinuationGeneration;
   private continuationSkipped;
   private draining;
   private sessionGenerating;
   private readonly activeRunIds;
   /** Latched by `dispose()`; stops any late async callback starting new work. */
   private disposed;
+  /** The error a failed mount hydration set, cleared by the next successful one. */
+  private hydrationError;
   /** 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;
+  /**
+   * Newest-window size from `history.pageSize`. Only set when
+   * `persistence === true`.
+   */
+  private readonly historyPageSize;
+  private hasOlderMessages;
+  private olderMessagesCursor;
+  private readonly knownServerMessageIds;
+  private loadOlderMessagesInFlight;
+  private historyGeneration;
   private devtoolsMounted;
   private readonly callbacksRef;
   constructor(options: ChatClientOptions<TTools, TContext, TInterrupts>);
@@ -2906,6 +5279,19 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
    * send that starts first owns the client (hydration then backs off).
    */
   private hydrateFromServer;
+  /**
+   * Surface a mount-hydration failure (`persistence: true`) on the observable
+   * fields, mirroring `GenerationClient.failHydration`, so "this thread failed
+   * to load" is distinguishable from "this thread has no messages" and the app
+   * can show an error / offer a retry. A genuine miss — the server having no
+   * record for a fresh thread — resolves normally and never reaches here; only a
+   * thrown transport / authorize-gate error does.
+   *
+   * Skipped when the view unmounted (`!tailing`) or a `sendMessage` took
+   * ownership while the hydrate GET was in flight, so a live run's state always
+   * wins over a stale mount-time failure — same guard as the success path above.
+   */
+  private failHydration;
   mountDevtools(): void;
   private ensureThreadId;
   /**
@@ -2923,6 +5309,8 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
    * state. This is interrupt (state) resume — there is no delivery cursor.
    */
   private observeInterruptState;
+  /** Walk parentRunId links and mark this run plus its ancestors as answered. */
+  private markLineageAnswered;
   /**
    * 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
@@ -2948,6 +5336,7 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
   retryInterrupts(): void;
   /** Unsafe low-level resume escape hatch. Prefer bound interrupt methods. */
   resumeInterruptsUnsafe(resume: Array<RunAgentResumeItem>, state?: ChatResumeState): Promise<boolean>;
+  private resumeInterruptsUnsafeForGeneration;
   /** @deprecated Use bound interrupt methods or resumeInterruptsUnsafe(). */
   resumeInterrupts(resume: Array<RunAgentResumeItem>, state?: ChatResumeState): Promise<boolean>;
   private submitInterruptBatch;
@@ -2979,7 +5368,8 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
    */
   private startSubscription;
   /**
-   * Consume chunks from the connection subscription.
+   * Consume chunks from the connection subscription. Chunks are processed in
+   * order; the loop yields to the host after each processing budget.
    */
   private consumeSubscription;
   /**
@@ -3001,7 +5391,7 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
    * 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,
+   * Replay chunks are processed WITHOUT the time-slice 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.
    */
@@ -3080,8 +5470,6 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
   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;
@@ -3172,6 +5560,29 @@ declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TCon
    * Get current messages
    */
   getMessages(): Array<UIMessage<TTools>>;
+  getSubagents(): SubagentHandle[];
+  private devtoolsSnapshotQueued;
+  /** One devtools snapshot per microtask, however many chunks arrive. */
+  private queueDevtoolsSnapshot;
+  private syncSubagentHandles;
+  private stopSubagent;
+  /**
+   * True when the last hydrate or older-page response said more messages exist.
+   */
+  getHasOlderMessages(): boolean;
+  /**
+   * Fetch the next older window and put it in front of the painted messages.
+   *
+   * No-op when there is no older page, no cursor, or a page load is already
+   * running. A network failure rejects and leaves the painted messages as they
+   * are; {@link getHasOlderMessages} stays true.
+   */
+  loadOlderMessages(): Promise<void>;
+  private resetHistoryPaging;
+  private applyHydrationPage;
+  private rememberServerMessageIds;
+  private rememberProcessorMessageIds;
+  private messagesForSend;
   /**
    * 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