@ag-ui/core 0.1.1-canary.beta.0 → 1.0.0

package/dist/version-Dr0GiU8W.d.mts

@@ -0,0 +1,2935 @@
+//#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",
+  TEXT_MESSAGE_END = "TEXT_MESSAGE_END",
+  TEXT_MESSAGE_CHUNK = "TEXT_MESSAGE_CHUNK",
+  TOOL_CALL_START = "TOOL_CALL_START",
+  TOOL_CALL_ARGS = "TOOL_CALL_ARGS",
+  TOOL_CALL_END = "TOOL_CALL_END",
+  TOOL_CALL_CHUNK = "TOOL_CALL_CHUNK",
+  TOOL_CALL_RESULT = "TOOL_CALL_RESULT",
+  STATE_SNAPSHOT = "STATE_SNAPSHOT",
+  STATE_DELTA = "STATE_DELTA",
+  MESSAGES_SNAPSHOT = "MESSAGES_SNAPSHOT",
+  ACTIVITY_SNAPSHOT = "ACTIVITY_SNAPSHOT",
+  ACTIVITY_DELTA = "ACTIVITY_DELTA",
+  RAW = "RAW",
+  CUSTOM = "CUSTOM",
+  RUN_STARTED = "RUN_STARTED",
+  RUN_FINISHED = "RUN_FINISHED",
+  RUN_ERROR = "RUN_ERROR",
+  STEP_STARTED = "STEP_STARTED",
+  STEP_FINISHED = "STEP_FINISHED",
+  REASONING_START = "REASONING_START",
+  REASONING_MESSAGE_START = "REASONING_MESSAGE_START",
+  REASONING_MESSAGE_CONTENT = "REASONING_MESSAGE_CONTENT",
+  REASONING_MESSAGE_END = "REASONING_MESSAGE_END",
+  REASONING_MESSAGE_CHUNK = "REASONING_MESSAGE_CHUNK",
+  REASONING_END = "REASONING_END",
+  REASONING_ENCRYPTED_VALUE = "REASONING_ENCRYPTED_VALUE",
+  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";
+/**
+ * Opens a streamed text message. The content arrives as TEXT_MESSAGE_CONTENT
+ * events and the message closes with TEXT_MESSAGE_END.
+ */
+type TextMessageStartEvent = {
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+};
+/**
+ * Appends a fragment to a streamed text message.
+ */
+type TextMessageContentEvent = {
+  /**
+   * 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;
+};
+/**
+ * Closes a streamed text message.
+ */
+type TextMessageEndEvent = {
+  /**
+   * 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;
+};
+/**
+ * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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;
+};
+/**
+ * Appends a fragment of a tool call's arguments.
+ */
+type ToolCallArgsEvent = {
+  /**
+   * 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;
+};
+/**
+ * Closes a tool call, meaning its arguments are complete.
+ */
+type ToolCallEndEvent = {
+  /**
+   * 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;
+};
+/**
+ * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = TextPart | ImagePart | AudioPart | VideoPart | DocumentPart;
+/**
+ * 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 = {
+  /**
+   * 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[];
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType.STATE_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 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 = {
+  /**
+   * 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[];
+};
+/**
+ * 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[];
+};
+/**
+ * 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[];
+  /**
+   * 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 = {
+  /**
+   * 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[];
+};
+/**
+ * Reports structured progress that is not conversation content, such as a step
+ * a UI renders as its own widget.
+ */
+type ActivitySnapshotEvent = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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;
+  /**
+   * The payload. Any JSON value, and required.
+   */
+  value: any;
+};
+/**
+ * A tool the agent may call.
+ */
+type Tool = {
+  /**
+   * 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[];
+  /**
+   * 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 = {
+  /**
+   * 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;
+};
+/**
+ * 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";
+  /**
+   * 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 = {
+  /**
+   * 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[];
+};
+/**
+ * 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 = {
+  /**
+   * 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;
+  /**
+   * 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 = {
+  /**
+   * 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;
+  /**
+   * 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 = {
+  /**
+   * 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;
+};
+/**
+ * Closes a named step.
+ */
+type StepFinishedEvent = {
+  /**
+   * 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;
+};
+/**
+ * Opens a span of reasoning. A span may contain several reasoning messages.
+ */
+type ReasoningStartEvent = {
+  /**
+   * 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;
+};
+/**
+ * Opens a streamed reasoning message.
+ */
+type ReasoningMessageStartEvent = {
+  /**
+   * 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";
+};
+/**
+ * Appends a fragment to a streamed reasoning message.
+ */
+type ReasoningMessageContentEvent = {
+  /**
+   * 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;
+};
+/**
+ * Closes a streamed reasoning message.
+ */
+type ReasoningMessageEndEvent = {
+  /**
+   * 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;
+};
+/**
+ * A shorthand that stands in for a reasoning message's start, content and end
+ * sequence.
+ */
+type ReasoningMessageChunkEvent = {
+  /**
+   * 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 = {
+  /**
+   * 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;
+};
+/**
+ * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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 = {
+  /**
+   * 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.
+ */
+type Event = TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent | TextMessageChunkEvent | ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent | ToolCallChunkEvent | ToolCallResultEvent | StateSnapshotEvent | StateDeltaEvent | MessagesSnapshotEvent | ActivitySnapshotEvent | ActivityDeltaEvent | RawEvent | CustomEvent | RunStartedEvent | RunFinishedEvent | RunErrorEvent | StepStartedEvent | StepFinishedEvent | ReasoningStartEvent | ReasoningMessageStartEvent | ReasoningMessageContentEvent | ReasoningMessageEndEvent | ReasoningMessageChunkEvent | ReasoningEndEvent | ReasoningEncryptedValueEvent | SubagentStartedEvent | SubagentFinishedEvent | SubagentErrorEvent;
+/**
+ * Every role a materialised message may have.
+ */
+type Role = "developer" | "system" | "assistant" | "user" | "tool" | "activity" | "reasoning";
+/**
+ * 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.
+ */
+type IdentityCapabilities = {
+  /**
+   * Human-readable name shown in UIs and agent selectors.
+   */
+  name?: string;
+  /**
+   * The framework or platform powering this agent (e.g., "langgraph",
+   * "mastra", "crewai").
+   */
+  type?: string;
+  /**
+   * What this agent does — helps users and routing logic decide when to use
+   * it.
+   */
+  description?: string;
+  /**
+   * Semantic version of the agent (e.g., "1.2.0"). Useful for compatibility
+   * checks.
+   */
+  version?: string;
+  /**
+   * Organization or team that maintains this agent.
+   */
+  provider?: string;
+  /**
+   * URL to the agent's documentation or homepage.
+   */
+  documentationUrl?: string;
+  /**
+   * Arbitrary key-value pairs for integration-specific identity info.
+   */
+  metadata?: Metadata;
+};
+/**
+ * Declares which transport mechanisms the agent supports. Clients use this to
+ * pick the best connection strategy. Only set flags to true for transports
+ * your agent actually handles — omit or set false for unsupported ones.
+ */
+type TransportCapabilities = {
+  /**
+   * Set true if the agent streams responses via SSE. Most agents enable this.
+   */
+  streaming?: boolean;
+  /**
+   * Set true if the agent accepts persistent WebSocket connections.
+   */
+  websocket?: boolean;
+  /**
+   * Set true if the agent supports the AG-UI binary protocol (protobuf over
+   * HTTP).
+   */
+  httpBinary?: boolean;
+  /**
+   * Set true if the agent can send async updates via webhooks after a run
+   * finishes.
+   */
+  pushNotifications?: boolean;
+  /**
+   * Set true if the agent supports resuming interrupted streams via sequence
+   * numbers.
+   */
+  resumable?: boolean;
+};
+/**
+ * Tool calling capabilities. Distinguishes between tools the agent itself
+ * provides (listed in items) and tools the client passes at runtime via
+ * RunAgentInput.tools. Enable this when your agent can call functions, search
+ * the web, execute code, etc.
+ */
+type ToolsCapabilities = {
+  /**
+   * Set true if the agent can make tool calls at all. Set false to explicitly
+   * signal tool calling is disabled even if items are present.
+   */
+  supported?: boolean;
+  /**
+   * The tools this agent provides on its own (full JSON Schema definitions).
+   * These are distinct from client-provided tools passed in
+   * RunAgentInput.tools.
+   */
+  items?: Tool[];
+  /**
+   * Set true if the agent can invoke multiple tools concurrently within a
+   * single step.
+   */
+  parallelCalls?: boolean;
+  /**
+   * Set true if the agent accepts and uses tools provided by the client at
+   * runtime.
+   */
+  clientProvided?: boolean;
+};
+/**
+ * Output format support. Enable structuredOutput when your agent can return
+ * responses conforming to a JSON schema, which is useful for programmatic
+ * consumption.
+ */
+type OutputCapabilities = {
+  /**
+   * Set true if the agent can produce structured JSON output matching a
+   * provided schema.
+   */
+  structuredOutput?: boolean;
+  /**
+   * MIME types the agent can produce (e.g., ["text/plain",
+   * "application/json"]). Omit if the agent only produces plain text.
+   */
+  supportedMimeTypes?: string[];
+};
+/**
+ * State and memory management capabilities. These tell the client how the
+ * agent handles shared state and whether conversation context persists across
+ * runs.
+ */
+type StateCapabilities = {
+  /**
+   * Set true if the agent emits STATE_SNAPSHOT events (full state
+   * replacement).
+   */
+  snapshots?: boolean;
+  /**
+   * Set true if the agent emits STATE_DELTA events (JSON Patch incremental
+   * updates).
+   */
+  deltas?: boolean;
+  /**
+   * Set true if the agent has long-term memory beyond the current thread
+   * (e.g., vector store, knowledge base, or cross-session recall).
+   */
+  memory?: boolean;
+  /**
+   * Set true if state is preserved across multiple runs within the same
+   * thread. When false, state resets on each run.
+   */
+  persistentState?: boolean;
+};
+/**
+ * Multi-agent coordination capabilities. Enable these when your agent can
+ * orchestrate or hand off work to other agents.
+ */
+type MultiAgentCapabilities = {
+  /**
+   * Set true if the agent participates in any form of multi-agent
+   * coordination.
+   */
+  supported?: boolean;
+  /**
+   * Set true if the agent can delegate subtasks to other agents while
+   * retaining control.
+   */
+  delegation?: boolean;
+  /**
+   * Set true if the agent can transfer the conversation entirely to another
+   * agent.
+   */
+  handoffs?: boolean;
+  /**
+   * List of subagents this agent can invoke. Helps clients build agent
+   * selection UIs.
+   */
+  subagents?: SubagentInfo[];
+};
+/**
+ * Reasoning and thinking capabilities. Enable these when your agent exposes
+ * its internal thought process (e.g., chain-of-thought, extended thinking).
+ */
+type ReasoningCapabilities = {
+  /**
+   * Set true if the agent produces reasoning/thinking tokens visible to the
+   * client.
+   */
+  supported?: boolean;
+  /**
+   * Set true if reasoning tokens are streamed incrementally (vs. returned all
+   * at once).
+   */
+  streaming?: boolean;
+  /**
+   * Set true if reasoning content is encrypted (zero-data-retention mode).
+   * Clients should expect opaque encryptedValue fields instead of readable
+   * content.
+   */
+  encrypted?: boolean;
+};
+/**
+ * Modalities the agent can accept as input. Clients use this to show or hide
+ * file upload buttons, audio recorders, image pickers, etc.
+ */
+type MultimodalInputCapabilities = {
+  /**
+   * Set true if the agent can process image inputs (e.g., screenshots,
+   * photos).
+   */
+  image?: boolean;
+  /**
+   * Set true if the agent can process audio inputs (speech, recordings).
+   */
+  audio?: boolean;
+  /**
+   * Set true if the agent can process video inputs.
+   */
+  video?: boolean;
+  /**
+   * Set true if the agent can process PDF documents.
+   */
+  pdf?: boolean;
+  /**
+   * Set true if the agent can process arbitrary file uploads: files of a kind
+   * the image, audio, video and document parts do not cover. Says nothing
+   * about how a file arrives; a part's source (inline, URL or provider handle)
+   * is a separate question.
+   */
+  file?: boolean;
+};
+/**
+ * Modalities the agent can produce as output. Clients use this to anticipate
+ * rich content in the agent's response.
+ */
+type MultimodalOutputCapabilities = {
+  /**
+   * Set true if the agent can generate images as part of its response.
+   */
+  image?: boolean;
+  /**
+   * Set true if the agent can produce audio output (text-to-speech, audio
+   * files).
+   */
+  audio?: boolean;
+};
+/**
+ * Multimodal input and output support. Organized into input and output
+ * sub-objects so clients can independently query what the agent accepts versus
+ * what it produces.
+ */
+type MultimodalCapabilities = {
+  /**
+   * Modalities the agent can accept as input (images, audio, video, PDFs,
+   * files).
+   */
+  input?: MultimodalInputCapabilities;
+  /**
+   * Modalities the agent can produce as output (images, audio).
+   */
+  output?: MultimodalOutputCapabilities;
+};
+/**
+ * Execution control and limits. Declare these so clients can set expectations
+ * about how long or how many steps an agent run might take.
+ */
+type ExecutionCapabilities = {
+  /**
+   * Set true if the agent can execute code (e.g., Python, JavaScript) during a
+   * run.
+   */
+  codeExecution?: boolean;
+  /**
+   * Set true if code execution happens in a sandboxed or isolated environment.
+   * Only meaningful when codeExecution is true.
+   */
+  sandboxed?: boolean;
+  /**
+   * Maximum number of tool-call/reasoning iterations the agent will perform
+   * per run. Helps clients display progress or set timeout expectations.
+   */
+  maxIterations?: number;
+  /**
+   * Maximum wall-clock time (in milliseconds) the agent will run before timing
+   * out.
+   */
+  maxExecutionTime?: number;
+};
+/**
+ * Human-in-the-loop interaction support. Enable these when your agent can
+ * pause execution to request human input, approval, or feedback before
+ * continuing.
+ */
+type HumanInTheLoopCapabilities = {
+  /**
+   * Set true if the agent supports any form of human-in-the-loop interaction.
+   */
+  supported?: boolean;
+  /**
+   * Set true if the agent can pause and request explicit approval before
+   * performing sensitive actions (e.g., sending emails, deleting data).
+   */
+  approvals?: boolean;
+  /**
+   * Set true if the agent allows humans to intervene and modify its plan
+   * mid-execution.
+   */
+  interventions?: boolean;
+  /**
+   * Set true if the agent can incorporate user feedback (thumbs up/down,
+   * corrections) to improve its behavior within the current session.
+   */
+  feedback?: boolean;
+  /**
+   * Set true if the agent participates in the AG-UI interrupt protocol: it
+   * ends a run with RUN_FINISHED carrying an interrupt outcome, and accepts
+   * the answers back in RunAgentInput.resume.
+   */
+  interrupts?: boolean;
+  /**
+   * Set true if tool-call interrupts accept editedArgs in the resume payload.
+   * Only meaningful when interrupts is true.
+   */
+  approveWithEdits?: boolean;
+};
+/**
+ * A typed, categorized snapshot of an agent's current capabilities. All fields
+ * are optional — agents only declare what they support. An omitted field means
+ * the capability is not declared (unknown), not that it is unsupported. The
+ * custom field is an escape hatch for integration-specific capabilities that
+ * do not fit into the standard categories.
+ */
+type AgentCapabilities = {
+  /**
+   * Agent identity and metadata.
+   */
+  identity?: IdentityCapabilities;
+  /**
+   * Supported transport mechanisms (SSE, WebSocket, binary, etc.).
+   */
+  transport?: TransportCapabilities;
+  /**
+   * Tools the agent provides and tool calling configuration.
+   */
+  tools?: ToolsCapabilities;
+  /**
+   * Output format support (structured output, MIME types).
+   */
+  output?: OutputCapabilities;
+  /**
+   * State and memory management (snapshots, deltas, persistence).
+   */
+  state?: StateCapabilities;
+  /**
+   * Multi-agent coordination (delegation, handoffs, subagents).
+   */
+  multiAgent?: MultiAgentCapabilities;
+  /**
+   * Reasoning and thinking support (chain-of-thought, encrypted thinking).
+   */
+  reasoning?: ReasoningCapabilities;
+  /**
+   * Multimodal input/output support (images, audio, video, files).
+   */
+  multimodal?: MultimodalCapabilities;
+  /**
+   * Execution control and limits (code execution, timeouts, iteration caps).
+   */
+  execution?: ExecutionCapabilities;
+  /**
+   * Human-in-the-loop support (approvals, interventions, feedback).
+   */
+  humanInTheLoop?: HumanInTheLoopCapabilities;
+  /**
+   * Integration-specific capabilities not covered by the standard categories.
+   * Open by key: any JSON value is allowed under a key, because the categories
+   * above cannot anticipate what an integration declares.
+   */
+  custom?: Record<string, any>;
+};
+/**
+ * Composed into everything that can belong to a subagent's work: the events
+ * that describe content or progress, the message types, and each interrupt.
+ * Run-scoped events omit it — RUN_STARTED, RUN_FINISHED and RUN_ERROR describe
+ * the run itself and MESSAGES_SNAPSHOT is conversation-wide, so none of them
+ * can belong to one subagent. A tool call omits it too and inherits its
+ * containing message's attribution.
+ */
+type Attributable = {
+  /**
+   * The subagent invocation this belongs to. Absent means the parent agent
+   * produced it directly.
+   */
+  subagentRunId?: SubagentRunId;
+};
+/**
+ * The fields every event carries, whatever its type. Composed into each event
+ * definition rather than repeated, so a change here reaches every event at
+ * once.
+ */
+type BaseEvent = {
+  /**
+   * Which event this is. Each event definition narrows this to a single value.
+   */
+  type: EventType;
+  /**
+   * 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 fields shared by the developer, system, assistant and user messages.
+ * Deliberately excludes content, because a user message's content may be an
+ * array while the others are strings, and composition here intersects rather
+ * than overrides: a base that constrained content to a string would make an
+ * array content invalid. The tool, activity and reasoning messages do not
+ * compose this, because they carry no name.
+ */
+type BaseMessage = {
+  /**
+   * 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: string;
+  /**
+   * 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;
+};
+//#endregion
+//#region src/generated/version.d.ts
+/**
+ * The protocol version this code was generated from: the version segment of
+ * the schema's $id (https://ag-ui.com/spec/1.0/schema.json). Never typed by a
+ * human.
+ */
+declare const PROTOCOL_VERSION = "1.0";
+//#endregion
+export { ReplaceOperation as $, JsonPointer as A, TextMessageStartEvent as At, PartSource as B, ToolMessage as Bt, FunctionCall as C, SubagentStartedEvent as Ct, Interrupt as D, TextMessageContentEvent as Dt, ImagePart as E, TextMessageChunkEvent as Et, MultiAgentCapabilities as F, ToolCallArgsEvent as Ft, ReasoningEndEvent as G, VideoPart as Gt, ReasoningCapabilities as H, TransportCapabilities as Ht, MultimodalCapabilities as I, ToolCallChunkEvent as It, ReasoningMessageContentEvent as J, ReasoningMessage as K, MultimodalInputCapabilities as L, ToolCallEndEvent as Lt, MessagesSnapshotEvent as M, TokenUsage as Mt, Metadata as N, Tool as Nt, JsonPatch as O, TextMessageEndEvent as Ot, MoveOperation as P, ToolCall as Pt, RemoveOperation as Q, MultimodalOutputCapabilities as R, ToolCallResultEvent as Rt, FileSource as S, SubagentRunId as St, IdentityCapabilities as T, TestOperation as Tt, ReasoningEncryptedValueEvent as U, UrlSource as Ut, RawEvent as V, ToolsCapabilities as Vt, ReasoningEncryptedValueSubtype as W, UserMessage as Wt, ReasoningMessageStartEvent as X, ReasoningMessageEndEvent as Y, ReasoningStartEvent as Z, DeveloperMessage as _, SubagentFinishedEvent as _t, AddOperation as a, RunFinishedEvent as at, EventType as b, SubagentFinishedSuspendedOutcome as bt, Attributable as c, RunFinishedSuccessOutcome as ct, BaseMessage as d, StateCapabilities as dt, ResumeEntry as et, ContentPart as f, StateDeltaEvent as ft, DataSource as g, SubagentErrorEvent as gt, CustomEvent as h, StepStartedEvent as ht, ActivitySnapshotEvent as i, RunFinishedCancelledOutcome as it, Message as j, TextPart as jt, JsonPatchOperation as k, TextMessageRole as kt, AudioPart as l, RunStartedEvent as lt, CopyOperation as m, StepFinishedEvent as mt, ActivityDeltaEvent as n, RunAgentInput as nt, AgentCapabilities as o, RunFinishedInterruptOutcome as ot, Context as p, StateSnapshotEvent as pt, ReasoningMessageChunkEvent as q, ActivityMessage as r, RunErrorEvent as rt, AssistantMessage as s, RunFinishedOutcome as st, PROTOCOL_VERSION as t, Role as tt, BaseEvent as u, State as ut, DocumentPart as v, SubagentFinishedOutcome as vt, HumanInTheLoopCapabilities as w, SystemMessage as wt, ExecutionCapabilities as x, SubagentInfo as xt, Event as y, SubagentFinishedSuccessOutcome as yt, OutputCapabilities as z, ToolCallStartEvent as zt };
+//# sourceMappingURL=version-Dr0GiU8W.d.mts.map