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

package/dist/schemas.js

@@ -1,160 +1,477 @@
-const require_events = require('./events-CMtdFXWl.js');
+const require_version = require('./version-BIes0ykB.js');
 let zod_v4 = require("zod/v4");
 
-//#region src/schemas.ts
-const EventTypeSchema = zod_v4.z.enum([
-	"TEXT_MESSAGE_START",
-	"TEXT_MESSAGE_CONTENT",
-	"TEXT_MESSAGE_END",
-	"TEXT_MESSAGE_CHUNK",
-	"TOOL_CALL_START",
-	"TOOL_CALL_ARGS",
-	"TOOL_CALL_END",
-	"TOOL_CALL_CHUNK",
-	"TOOL_CALL_RESULT",
-	"THINKING_START",
-	"THINKING_END",
-	"THINKING_TEXT_MESSAGE_START",
-	"THINKING_TEXT_MESSAGE_CONTENT",
-	"THINKING_TEXT_MESSAGE_END",
-	"STATE_SNAPSHOT",
-	"STATE_DELTA",
-	"MESSAGES_SNAPSHOT",
-	"ACTIVITY_SNAPSHOT",
-	"ACTIVITY_DELTA",
-	"RAW",
-	"CUSTOM",
-	"RUN_STARTED",
-	"RUN_FINISHED",
-	"RUN_ERROR",
-	"STEP_STARTED",
-	"STEP_FINISHED",
-	"REASONING_START",
-	"REASONING_MESSAGE_START",
-	"REASONING_MESSAGE_CONTENT",
-	"REASONING_MESSAGE_END",
-	"REASONING_MESSAGE_CHUNK",
-	"REASONING_END",
-	"REASONING_ENCRYPTED_VALUE"
+//#region src/generated/schemas.ts
+/**
+* The discriminator carried by every event.
+*/
+const EventTypeSchema = zod_v4.z.enum(require_version.EventType);
+/**
+* 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.
+*/
+const MetadataSchema = zod_v4.z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+/**
+* 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.
+*/
+const SubagentRunIdSchema = zod_v4.z.string();
+/**
+* The roles a streamed text message may take. Excludes tool, which is carried
+* by TOOL_CALL_RESULT rather than streamed as text.
+*/
+const TextMessageRoleSchema = zod_v4.z.enum([
+	"developer",
+	"system",
+	"assistant",
+	"user"
 ]);
-const FunctionCallSchema = zod_v4.z.object({
-	name: zod_v4.z.string(),
-	arguments: zod_v4.z.string()
+/**
+* Opens a streamed text message. The content arrives as TEXT_MESSAGE_CONTENT
+* events and the message closes with TEXT_MESSAGE_END.
+*/
+const TextMessageStartEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TEXT_MESSAGE_START),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	messageId: zod_v4.z.string(),
+	role: TextMessageRoleSchema.optional(),
+	name: zod_v4.z.string().optional()
 });
-const ToolCallSchema = zod_v4.z.object({
-	id: zod_v4.z.string(),
-	type: zod_v4.z.literal("function"),
-	function: FunctionCallSchema,
-	encryptedValue: zod_v4.z.string().optional()
+/**
+* Appends a fragment to a streamed text message.
+*/
+const TextMessageContentEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TEXT_MESSAGE_CONTENT),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	messageId: zod_v4.z.string(),
+	delta: zod_v4.z.string()
+});
+/**
+* Closes a streamed text message.
+*/
+const TextMessageEndEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TEXT_MESSAGE_END),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	messageId: zod_v4.z.string()
 });
-const TextInputContentSchema = zod_v4.z.object({
+/**
+* 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.
+*/
+const TextMessageChunkEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TEXT_MESSAGE_CHUNK),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	messageId: zod_v4.z.string().optional(),
+	role: TextMessageRoleSchema.optional(),
+	delta: zod_v4.z.string().optional(),
+	name: zod_v4.z.string().optional()
+});
+/**
+* Opens a tool call. The arguments arrive as TOOL_CALL_ARGS events and the
+* call closes with TOOL_CALL_END.
+*/
+const ToolCallStartEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TOOL_CALL_START),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	toolCallId: zod_v4.z.string(),
+	toolCallName: zod_v4.z.string(),
+	parentMessageId: zod_v4.z.string().optional()
+});
+/**
+* Appends a fragment of a tool call's arguments.
+*/
+const ToolCallArgsEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TOOL_CALL_ARGS),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	toolCallId: zod_v4.z.string(),
+	delta: zod_v4.z.string()
+});
+/**
+* Closes a tool call, meaning its arguments are complete.
+*/
+const ToolCallEndEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TOOL_CALL_END),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	toolCallId: zod_v4.z.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.
+*/
+const ToolCallChunkEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TOOL_CALL_CHUNK),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	toolCallId: zod_v4.z.string().optional(),
+	toolCallName: zod_v4.z.string().optional(),
+	parentMessageId: zod_v4.z.string().optional(),
+	delta: zod_v4.z.string().optional()
+});
+/**
+* A text part.
+*/
+const TextPartSchema = zod_v4.z.looseObject({
 	type: zod_v4.z.literal("text"),
-	text: zod_v4.z.string()
+	id: zod_v4.z.string().optional(),
+	text: zod_v4.z.string(),
+	metadata: zod_v4.z.any().refine((value) => value !== null).optional()
 });
-const InputContentDataSourceSchema = zod_v4.z.object({
+/**
+* Bytes carried inline.
+*/
+const DataSourceSchema = zod_v4.z.looseObject({
 	type: zod_v4.z.literal("data"),
 	value: zod_v4.z.string(),
 	mimeType: zod_v4.z.string()
 });
-const InputContentUrlSourceSchema = zod_v4.z.object({
+/**
+* Bytes referenced by URL, fetched by whoever needs them.
+*/
+const UrlSourceSchema = zod_v4.z.looseObject({
 	type: zod_v4.z.literal("url"),
 	value: zod_v4.z.string(),
 	mimeType: zod_v4.z.string().optional()
 });
-const InputContentSourceSchema = zod_v4.z.discriminatedUnion("type", [InputContentDataSourceSchema, InputContentUrlSourceSchema]);
-const ImageInputContentSchema = zod_v4.z.object({
+/**
+* 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.
+*/
+const FileSourceSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal("file"),
+	value: zod_v4.z.string(),
+	provider: zod_v4.z.string().optional(),
+	mimeType: zod_v4.z.string().optional()
+});
+/**
+* Where a media part's bytes come from: carried inline, referenced by URL, or
+* already at the provider under a handle it issued.
+*/
+const PartSourceSchema = zod_v4.z.discriminatedUnion("type", [
+	DataSourceSchema,
+	UrlSourceSchema,
+	FileSourceSchema
+]);
+/**
+* An image part.
+*/
+const ImagePartSchema = zod_v4.z.looseObject({
 	type: zod_v4.z.literal("image"),
-	source: InputContentSourceSchema,
-	metadata: zod_v4.z.unknown().optional()
+	id: zod_v4.z.string().optional(),
+	source: PartSourceSchema,
+	metadata: zod_v4.z.any().refine((value) => value !== null).optional()
 });
-const AudioInputContentSchema = zod_v4.z.object({
+/**
+* An audio part.
+*/
+const AudioPartSchema = zod_v4.z.looseObject({
 	type: zod_v4.z.literal("audio"),
-	source: InputContentSourceSchema,
-	metadata: zod_v4.z.unknown().optional()
+	id: zod_v4.z.string().optional(),
+	source: PartSourceSchema,
+	metadata: zod_v4.z.any().refine((value) => value !== null).optional()
 });
-const VideoInputContentSchema = zod_v4.z.object({
+/**
+* A video part.
+*/
+const VideoPartSchema = zod_v4.z.looseObject({
 	type: zod_v4.z.literal("video"),
-	source: InputContentSourceSchema,
-	metadata: zod_v4.z.unknown().optional()
+	id: zod_v4.z.string().optional(),
+	source: PartSourceSchema,
+	metadata: zod_v4.z.any().refine((value) => value !== null).optional()
 });
-const DocumentInputContentSchema = zod_v4.z.object({
+/**
+* A document part.
+*/
+const DocumentPartSchema = zod_v4.z.looseObject({
 	type: zod_v4.z.literal("document"),
-	source: InputContentSourceSchema,
-	metadata: zod_v4.z.unknown().optional()
-});
-const ImageInputPartSchema = ImageInputContentSchema;
-const AudioInputPartSchema = AudioInputContentSchema;
-const VideoInputPartSchema = VideoInputContentSchema;
-const DocumentInputPartSchema = DocumentInputContentSchema;
-const BinaryInputContentSchema = zod_v4.z.object({
-	type: zod_v4.z.literal("binary"),
-	mimeType: zod_v4.z.string(),
 	id: zod_v4.z.string().optional(),
-	url: zod_v4.z.string().optional(),
-	data: zod_v4.z.string().optional(),
-	filename: zod_v4.z.string().optional()
-}).refine((value) => Boolean(value.id || value.url || value.data), { message: "BinaryInputContent requires at least one of id, url, or data." });
-const InputContentSchema = zod_v4.z.discriminatedUnion("type", [
-	TextInputContentSchema,
-	ImageInputContentSchema,
-	AudioInputContentSchema,
-	VideoInputContentSchema,
-	DocumentInputContentSchema,
-	zod_v4.z.object({
-		type: zod_v4.z.literal("binary"),
-		mimeType: zod_v4.z.string(),
-		id: zod_v4.z.string().optional(),
-		url: zod_v4.z.string().optional(),
-		data: zod_v4.z.string().optional(),
-		filename: zod_v4.z.string().optional()
-	})
-]).refine((value) => {
-	if (value.type === "binary") return Boolean(value.id || value.url || value.data);
-	return true;
-}, { message: "BinaryInputContent requires at least one of id, url, or data." });
-const InputContentPartSchema = InputContentSchema;
-const BaseMessageSchema = zod_v4.z.object({
-	id: zod_v4.z.string(),
-	name: zod_v4.z.string().optional(),
-	encryptedValue: zod_v4.z.string().optional()
+	source: PartSourceSchema,
+	metadata: zod_v4.z.any().refine((value) => value !== null).optional()
 });
-const DeveloperMessageSchema = BaseMessageSchema.extend({
+/**
+* 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.
+*/
+const ContentPartSchema = zod_v4.z.discriminatedUnion("type", [
+	TextPartSchema,
+	ImagePartSchema,
+	AudioPartSchema,
+	VideoPartSchema,
+	DocumentPartSchema
+]);
+/**
+* Carries what a tool returned. Mints a tool message rather than appending to
+* an existing one, which is why it has its own messageId.
+*/
+const ToolCallResultEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.TOOL_CALL_RESULT),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	messageId: zod_v4.z.string(),
+	toolCallId: zod_v4.z.string(),
+	content: zod_v4.z.union([zod_v4.z.string(), zod_v4.z.array(ContentPartSchema)]),
+	role: zod_v4.z.literal("tool").optional()
+});
+/**
+* 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.
+*/
+const StateSchema = zod_v4.z.any();
+/**
+* Replaces the agent state wholesale. Sent when a delta cannot express the
+* change, or to resynchronise a consumer.
+*/
+const StateSnapshotEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.STATE_SNAPSHOT),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	snapshot: StateSchema.refine((value) => value !== void 0)
+});
+/**
+* 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.
+*/
+const JsonPointerSchema = zod_v4.z.string().regex(/* @__PURE__ */ new RegExp("^(/([^/~]|~[01])*)*$"));
+/**
+* Inserts value at path. RFC 6902 section 4.1.
+*/
+const AddOperationSchema = zod_v4.z.looseObject({
+	op: zod_v4.z.literal("add"),
+	path: JsonPointerSchema,
+	value: zod_v4.z.any().refine((value) => value !== void 0)
+}).meta({ specOpen: true });
+/**
+* Removes the value at path. RFC 6902 section 4.2.
+*/
+const RemoveOperationSchema = zod_v4.z.looseObject({
+	op: zod_v4.z.literal("remove"),
+	path: JsonPointerSchema
+}).meta({ specOpen: true });
+/**
+* Replaces the value at path. RFC 6902 section 4.3.
+*/
+const ReplaceOperationSchema = zod_v4.z.looseObject({
+	op: zod_v4.z.literal("replace"),
+	path: JsonPointerSchema,
+	value: zod_v4.z.any().refine((value) => value !== void 0)
+}).meta({ specOpen: true });
+/**
+* Moves the value at from to path. RFC 6902 section 4.4.
+*/
+const MoveOperationSchema = zod_v4.z.looseObject({
+	op: zod_v4.z.literal("move"),
+	from: JsonPointerSchema,
+	path: JsonPointerSchema
+}).meta({ specOpen: true });
+/**
+* Copies the value at from to path. RFC 6902 section 4.5.
+*/
+const CopyOperationSchema = zod_v4.z.looseObject({
+	op: zod_v4.z.literal("copy"),
+	from: JsonPointerSchema,
+	path: JsonPointerSchema
+}).meta({ specOpen: true });
+/**
+* Asserts that the value at path equals value. RFC 6902 section 4.6.
+*/
+const TestOperationSchema = zod_v4.z.looseObject({
+	op: zod_v4.z.literal("test"),
+	path: JsonPointerSchema,
+	value: zod_v4.z.any().refine((value) => value !== void 0)
+}).meta({ specOpen: true });
+/**
+* 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.
+*/
+const JsonPatchOperationSchema = zod_v4.z.discriminatedUnion("op", [
+	AddOperationSchema,
+	RemoveOperationSchema,
+	ReplaceOperationSchema,
+	MoveOperationSchema,
+	CopyOperationSchema,
+	TestOperationSchema
+]);
+/**
+* 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.
+*/
+const JsonPatchSchema = zod_v4.z.array(JsonPatchOperationSchema);
+/**
+* Changes the agent state incrementally.
+*/
+const StateDeltaEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.STATE_DELTA),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	delta: JsonPatchSchema
+});
+/**
+* Instructions from the application developer.
+*/
+const DeveloperMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
+	id: zod_v4.z.string(),
 	role: zod_v4.z.literal("developer"),
+	name: zod_v4.z.string().optional(),
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional(),
 	content: zod_v4.z.string()
 });
-const SystemMessageSchema = BaseMessageSchema.extend({
+/**
+* Instructions from the system.
+*/
+const SystemMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
+	id: zod_v4.z.string(),
 	role: zod_v4.z.literal("system"),
+	name: zod_v4.z.string().optional(),
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional(),
 	content: zod_v4.z.string()
 });
-const AssistantMessageSchema = BaseMessageSchema.extend({
+/**
+* The name and arguments of a tool call.
+*/
+const FunctionCallSchema = zod_v4.z.looseObject({
+	name: zod_v4.z.string(),
+	arguments: zod_v4.z.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.
+*/
+const ToolCallSchema = zod_v4.z.looseObject({
+	id: zod_v4.z.string(),
+	type: zod_v4.z.literal("function"),
+	function: FunctionCallSchema,
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional()
+});
+/**
+* A message from the agent. Content is optional because a turn may consist
+* only of tool calls.
+*/
+const AssistantMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
+	id: zod_v4.z.string(),
 	role: zod_v4.z.literal("assistant"),
+	name: zod_v4.z.string().optional(),
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional(),
 	content: zod_v4.z.string().optional(),
 	toolCalls: zod_v4.z.array(ToolCallSchema).optional()
 });
-const UserMessageSchema = BaseMessageSchema.extend({
+/**
+* A message from the person using the application.
+*/
+const UserMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
+	id: zod_v4.z.string(),
 	role: zod_v4.z.literal("user"),
-	content: zod_v4.z.union([zod_v4.z.string(), zod_v4.z.array(InputContentSchema)])
+	name: zod_v4.z.string().optional(),
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional(),
+	content: zod_v4.z.union([zod_v4.z.string(), zod_v4.z.array(ContentPartSchema)])
 });
-const ToolMessageSchema = zod_v4.z.object({
+/**
+* What a tool returned, as a message in the conversation. Stands alone rather
+* than composing BaseMessage, because it carries no name.
+*/
+const ToolMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
 	id: zod_v4.z.string(),
-	content: zod_v4.z.string(),
 	role: zod_v4.z.literal("tool"),
+	content: zod_v4.z.union([zod_v4.z.string(), zod_v4.z.array(ContentPartSchema)]),
 	toolCallId: zod_v4.z.string(),
 	error: zod_v4.z.string().optional(),
-	encryptedValue: zod_v4.z.string().optional()
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional()
 });
-const ActivityMessageSchema = zod_v4.z.object({
+/**
+* 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.
+*/
+const ActivityMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
 	id: zod_v4.z.string(),
 	role: zod_v4.z.literal("activity"),
 	activityType: zod_v4.z.string(),
-	content: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.any())
+	content: zod_v4.z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value)),
+	metadata: MetadataSchema.optional()
 });
-const ReasoningMessageSchema = zod_v4.z.object({
+/**
+* A span of the agent's reasoning, materialised as a message. Stands alone
+* rather than composing BaseMessage, because it carries no name.
+*/
+const ReasoningMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
 	id: zod_v4.z.string(),
 	role: zod_v4.z.literal("reasoning"),
 	content: zod_v4.z.string(),
-	encryptedValue: zod_v4.z.string().optional()
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional()
 });
+/**
+* Any message in a conversation. Discriminated by role.
+*/
 const MessageSchema = zod_v4.z.discriminatedUnion("role", [
 	DeveloperMessageSchema,
 	SystemMessageSchema,
@@ -164,255 +481,421 @@ const MessageSchema = zod_v4.z.discriminatedUnion("role", [
 	ActivityMessageSchema,
 	ReasoningMessageSchema
 ]);
-const RoleSchema = zod_v4.z.union([
-	zod_v4.z.literal("developer"),
-	zod_v4.z.literal("system"),
-	zod_v4.z.literal("assistant"),
-	zod_v4.z.literal("user"),
-	zod_v4.z.literal("tool"),
-	zod_v4.z.literal("activity"),
-	zod_v4.z.literal("reasoning")
-]);
-const ContextSchema = zod_v4.z.object({
-	description: zod_v4.z.string(),
-	value: zod_v4.z.string()
+/**
+* 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.
+*/
+const MessagesSnapshotEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.MESSAGES_SNAPSHOT),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	messages: zod_v4.z.array(MessageSchema)
+});
+/**
+* Reports structured progress that is not conversation content, such as a step
+* a UI renders as its own widget.
+*/
+const ActivitySnapshotEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.ACTIVITY_SNAPSHOT),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	messageId: zod_v4.z.string(),
+	activityType: zod_v4.z.string(),
+	content: zod_v4.z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value)),
+	replace: zod_v4.z.boolean().optional()
+});
+/**
+* Changes an activity message's content incrementally.
+*/
+const ActivityDeltaEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.ACTIVITY_DELTA),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	messageId: zod_v4.z.string(),
+	activityType: zod_v4.z.string(),
+	patch: JsonPatchSchema
+});
+/**
+* Passes a provider-native event through untranslated, for consumers that need
+* detail the protocol does not model.
+*/
+const RawEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.RAW),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	event: zod_v4.z.any().refine((value) => value !== void 0),
+	source: zod_v4.z.string().optional()
 });
-const ToolSchema = zod_v4.z.object({
+/**
+* The protocol's extension point for an application's own events. Anything a
+* consumer does with one is outside the protocol.
+*/
+const CustomEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.CUSTOM),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
+	name: zod_v4.z.string(),
+	value: zod_v4.z.any().refine((value) => value !== void 0)
+});
+/**
+* A tool the agent may call.
+*/
+const ToolSchema = zod_v4.z.looseObject({
 	name: zod_v4.z.string(),
 	description: zod_v4.z.string(),
-	parameters: zod_v4.z.any().optional(),
-	metadata: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.any()).optional()
+	parameters: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional()
 });
-const InterruptSchema = zod_v4.z.object({
-	id: zod_v4.z.string(),
-	reason: zod_v4.z.string(),
-	message: zod_v4.z.string().optional(),
-	toolCallId: zod_v4.z.string().optional(),
-	responseSchema: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.any()).optional(),
-	expiresAt: zod_v4.z.string().optional(),
-	metadata: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.any()).optional()
+/**
+* A named piece of ambient information given to the agent for the run,
+* distinct from the conversation.
+*/
+const ContextSchema = zod_v4.z.looseObject({
+	description: zod_v4.z.string(),
+	value: zod_v4.z.string()
 });
-const ResumeEntrySchema = zod_v4.z.object({
+/**
+* An answer to one interrupt, sent on the run that continues from it.
+*/
+const ResumeEntrySchema = zod_v4.z.looseObject({
 	interruptId: zod_v4.z.string(),
 	status: zod_v4.z.enum(["resolved", "cancelled"]),
-	payload: zod_v4.z.any().optional()
+	payload: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional()
 });
-const RunAgentInputSchema = zod_v4.z.object({
+/**
+* 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.
+*/
+const RunAgentInputSchema = zod_v4.z.looseObject({
 	threadId: zod_v4.z.string(),
 	runId: zod_v4.z.string(),
+	protocolVersion: zod_v4.z.string().optional(),
 	parentRunId: zod_v4.z.string().optional(),
-	state: zod_v4.z.any().optional(),
+	state: StateSchema.refine((value) => value !== null).nullable().transform((value) => value ?? void 0).optional(),
 	messages: zod_v4.z.array(MessageSchema),
-	tools: zod_v4.z.array(ToolSchema),
-	context: zod_v4.z.array(ContextSchema),
-	forwardedProps: zod_v4.z.any().optional(),
+	tools: zod_v4.z.array(ToolSchema).default(() => []),
+	context: zod_v4.z.array(ContextSchema).default(() => []),
+	forwardedProps: zod_v4.z.any().refine((value) => value !== null).optional(),
 	resume: zod_v4.z.array(ResumeEntrySchema).optional()
 });
-const StateSchema = zod_v4.z.any();
-const TextMessageRoleSchema = zod_v4.z.union([
-	zod_v4.z.literal("developer"),
-	zod_v4.z.literal("system"),
-	zod_v4.z.literal("assistant"),
-	zod_v4.z.literal("user")
-]);
-const BaseEventSchema = zod_v4.z.object({
-	type: EventTypeSchema,
-	timestamp: zod_v4.z.number().optional(),
-	rawEvent: zod_v4.z.any().optional()
-}).passthrough();
-const TextMessageStartEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TEXT_MESSAGE_START),
-	messageId: zod_v4.z.string(),
-	role: TextMessageRoleSchema.default("assistant"),
-	name: zod_v4.z.string().optional()
-});
-const TextMessageContentEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TEXT_MESSAGE_CONTENT),
-	messageId: zod_v4.z.string(),
-	delta: zod_v4.z.string()
-});
-const TextMessageEndEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TEXT_MESSAGE_END),
-	messageId: zod_v4.z.string()
-});
-const TextMessageChunkEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TEXT_MESSAGE_CHUNK),
-	messageId: zod_v4.z.string().optional(),
-	role: TextMessageRoleSchema.optional(),
-	delta: zod_v4.z.string().optional(),
-	name: zod_v4.z.string().optional()
-});
 /**
-* @deprecated Use ReasoningTextMessageStartEventSchema instead. Will be removed in 1.0.0.
+* Opens a run. Run-scoped, so it carries no subagent attribution.
 */
-const ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({ type: zod_v4.z.literal(require_events.EventType.THINKING_TEXT_MESSAGE_START) });
+const RunStartedEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.RUN_STARTED),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	threadId: zod_v4.z.string(),
+	runId: zod_v4.z.string(),
+	protocolVersion: zod_v4.z.string().optional(),
+	parentRunId: zod_v4.z.string().optional(),
+	input: RunAgentInputSchema.optional()
+});
 /**
-* @deprecated Use ReasoningMessageContentEventSchema instead. Will be removed in 1.0.0.
+* 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.
 */
-const ThinkingTextMessageContentEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.THINKING_TEXT_MESSAGE_CONTENT),
-	delta: zod_v4.z.string()
+const RunFinishedSuccessOutcomeSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal("success"),
+	pendingToolCallIds: zod_v4.z.array(zod_v4.z.string()).optional()
 });
 /**
-* @deprecated Use ReasoningMessageEndEventSchema instead. Will be removed in 1.0.0.
+* Something a run needs from outside before it can continue, such as an
+* approval or a missing value.
 */
-const ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({ type: zod_v4.z.literal(require_events.EventType.THINKING_TEXT_MESSAGE_END) });
-const ToolCallStartEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TOOL_CALL_START),
-	toolCallId: zod_v4.z.string(),
-	toolCallName: zod_v4.z.string(),
-	parentMessageId: zod_v4.z.string().nullable().optional().transform((v) => v ?? void 0)
-});
-const ToolCallArgsEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TOOL_CALL_ARGS),
-	toolCallId: zod_v4.z.string(),
-	delta: zod_v4.z.string()
-});
-const ToolCallEndEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TOOL_CALL_END),
-	toolCallId: zod_v4.z.string()
-});
-const ToolCallResultEventSchema = BaseEventSchema.extend({
-	messageId: zod_v4.z.string(),
-	type: zod_v4.z.literal(require_events.EventType.TOOL_CALL_RESULT),
-	toolCallId: zod_v4.z.string(),
-	content: zod_v4.z.string(),
-	role: zod_v4.z.literal("tool").optional()
-});
-const ToolCallChunkEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.TOOL_CALL_CHUNK),
+const InterruptSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
+	id: zod_v4.z.string(),
+	reason: zod_v4.z.string(),
+	message: zod_v4.z.string().optional(),
 	toolCallId: zod_v4.z.string().optional(),
-	toolCallName: zod_v4.z.string().optional(),
-	parentMessageId: zod_v4.z.string().nullable().optional().transform((v) => v ?? void 0),
-	delta: zod_v4.z.string().optional()
+	responseSchema: zod_v4.z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value)).optional(),
+	expiresAt: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional()
 });
 /**
-* @deprecated Use ReasoningStartEventSchema instead. Will be removed in 1.0.0.
+* The run is paused, waiting for something outside it. Resuming means starting
+* a new run whose resume entries answer these interrupts.
 */
-const ThinkingStartEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.THINKING_START),
-	title: zod_v4.z.string().optional()
+const RunFinishedInterruptOutcomeSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal("interrupt"),
+	interrupts: zod_v4.z.array(InterruptSchema).min(1)
 });
 /**
-* @deprecated Use ReasoningEndEventSchema instead. Will be removed in 1.0.0.
+* 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.
 */
-const ThinkingEndEventSchema = BaseEventSchema.extend({ type: zod_v4.z.literal(require_events.EventType.THINKING_END) });
-const StateSnapshotEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.STATE_SNAPSHOT),
-	snapshot: StateSchema.optional()
-});
-const StateDeltaEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.STATE_DELTA),
-	delta: zod_v4.z.array(zod_v4.z.any())
-});
-const MessagesSnapshotEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.MESSAGES_SNAPSHOT),
-	messages: zod_v4.z.array(MessageSchema)
-});
-const ActivitySnapshotEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.ACTIVITY_SNAPSHOT),
-	messageId: zod_v4.z.string(),
-	activityType: zod_v4.z.string(),
-	content: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.any()),
-	replace: zod_v4.z.boolean().optional().default(true)
-});
-const ActivityDeltaEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.ACTIVITY_DELTA),
-	messageId: zod_v4.z.string(),
-	activityType: zod_v4.z.string(),
-	patch: zod_v4.z.array(zod_v4.z.any())
-});
-const RawEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.RAW),
-	event: zod_v4.z.any().optional(),
-	source: zod_v4.z.string().optional()
-});
-const CustomEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.CUSTOM),
-	name: zod_v4.z.string(),
-	value: zod_v4.z.any().optional()
-});
-const RunStartedEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.RUN_STARTED),
-	threadId: zod_v4.z.string(),
-	runId: zod_v4.z.string(),
-	parentRunId: zod_v4.z.string().optional(),
-	input: RunAgentInputSchema.optional()
+const RunFinishedCancelledOutcomeSchema = zod_v4.z.looseObject({ type: zod_v4.z.literal("cancelled") });
+/**
+* Why a run ended.
+*/
+const RunFinishedOutcomeSchema = zod_v4.z.discriminatedUnion("type", [
+	RunFinishedSuccessOutcomeSchema,
+	RunFinishedInterruptOutcomeSchema,
+	RunFinishedCancelledOutcomeSchema
+]);
+/**
+* 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.
+*/
+const TokenUsageSchema = zod_v4.z.looseObject({
+	provider: zod_v4.z.string().optional(),
+	model: zod_v4.z.string().optional(),
+	inputTokens: zod_v4.z.int().min(0).max(9007199254740991).optional(),
+	outputTokens: zod_v4.z.int().min(0).max(9007199254740991).optional(),
+	totalTokens: zod_v4.z.int().min(0).max(9007199254740991).optional(),
+	reasoningTokens: zod_v4.z.int().min(0).max(9007199254740991).optional(),
+	cachedInputTokens: zod_v4.z.int().min(0).max(9007199254740991).optional(),
+	cacheWriteInputTokens: zod_v4.z.int().min(0).max(9007199254740991).optional()
 });
-const RunFinishedSuccessOutcomeSchema = zod_v4.z.object({ type: zod_v4.z.literal("success") }).strict();
-const RunFinishedInterruptOutcomeSchema = zod_v4.z.object({
-	type: zod_v4.z.literal("interrupt"),
-	interrupts: zod_v4.z.array(InterruptSchema).min(1)
-}).strict();
-const RunFinishedOutcomeSchema = zod_v4.z.discriminatedUnion("type", [RunFinishedSuccessOutcomeSchema, RunFinishedInterruptOutcomeSchema]);
-const RunFinishedEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.RUN_FINISHED),
+/**
+* Closes a run that did not fail. Run-scoped, so it carries no subagent
+* attribution.
+*/
+const RunFinishedEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.RUN_FINISHED),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
 	threadId: zod_v4.z.string(),
 	runId: zod_v4.z.string(),
-	result: zod_v4.z.any().optional(),
-	outcome: RunFinishedOutcomeSchema.nullable().optional().transform((v) => v ?? void 0)
+	result: zod_v4.z.any().refine((value) => value !== null).optional(),
+	outcome: RunFinishedOutcomeSchema.optional(),
+	usage: zod_v4.z.array(TokenUsageSchema).optional()
 });
-const RunErrorEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.RUN_ERROR),
+/**
+* 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.
+*/
+const RunErrorEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.RUN_ERROR),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
 	message: zod_v4.z.string(),
-	code: zod_v4.z.string().optional()
+	code: zod_v4.z.string().optional(),
+	usage: zod_v4.z.array(TokenUsageSchema).optional()
 });
-const StepStartedEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.STEP_STARTED),
+/**
+* Opens a named step within a run, for producers whose frameworks have a step
+* concept worth surfacing.
+*/
+const StepStartedEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.STEP_STARTED),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	stepName: zod_v4.z.string()
 });
-const StepFinishedEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.STEP_FINISHED),
+/**
+* Closes a named step.
+*/
+const StepFinishedEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.STEP_FINISHED),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	stepName: zod_v4.z.string()
 });
-const ReasoningEncryptedValueSubtypeSchema = zod_v4.z.union([zod_v4.z.literal("tool-call"), zod_v4.z.literal("message")]);
-const ReasoningStartEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.REASONING_START),
+/**
+* Opens a span of reasoning. A span may contain several reasoning messages.
+*/
+const ReasoningStartEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.REASONING_START),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	messageId: zod_v4.z.string()
 });
-const ReasoningMessageStartEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.REASONING_MESSAGE_START),
+/**
+* Opens a streamed reasoning message.
+*/
+const ReasoningMessageStartEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.REASONING_MESSAGE_START),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	messageId: zod_v4.z.string(),
 	role: zod_v4.z.literal("reasoning")
 });
-const ReasoningMessageContentEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.REASONING_MESSAGE_CONTENT),
+/**
+* Appends a fragment to a streamed reasoning message.
+*/
+const ReasoningMessageContentEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.REASONING_MESSAGE_CONTENT),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	messageId: zod_v4.z.string(),
 	delta: zod_v4.z.string()
 });
-const ReasoningMessageEndEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.REASONING_MESSAGE_END),
+/**
+* Closes a streamed reasoning message.
+*/
+const ReasoningMessageEndEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.REASONING_MESSAGE_END),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	messageId: zod_v4.z.string()
 });
-const ReasoningMessageChunkEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.REASONING_MESSAGE_CHUNK),
+/**
+* A shorthand that stands in for a reasoning message's start, content and end
+* sequence.
+*/
+const ReasoningMessageChunkEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.REASONING_MESSAGE_CHUNK),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	messageId: zod_v4.z.string().optional(),
 	delta: zod_v4.z.string().optional()
 });
-const ReasoningEndEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.REASONING_END),
+/**
+* Closes a span of reasoning.
+*/
+const ReasoningEndEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.REASONING_END),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	messageId: zod_v4.z.string()
 });
-const ReasoningEncryptedValueEventSchema = BaseEventSchema.extend({
-	type: zod_v4.z.literal(require_events.EventType.REASONING_ENCRYPTED_VALUE),
+/**
+* Whether a REASONING_ENCRYPTED_VALUE belongs to a message or to a tool call.
+*/
+const ReasoningEncryptedValueSubtypeSchema = zod_v4.z.enum(["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.
+*/
+const ReasoningEncryptedValueEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.REASONING_ENCRYPTED_VALUE),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema.optional(),
 	subtype: ReasoningEncryptedValueSubtypeSchema,
 	entityId: zod_v4.z.string(),
 	encryptedValue: zod_v4.z.string()
 });
 /**
-* Discriminated union of all AG-UI event schemas. Suitable for validating
-* untrusted event payloads from the wire.
+* 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.
 */
-const EventSchemas = zod_v4.z.discriminatedUnion("type", [
+const SubagentStartedEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.SUBAGENT_STARTED),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema,
+	name: zod_v4.z.string(),
+	description: zod_v4.z.string().optional(),
+	parentSubagentRunId: SubagentRunIdSchema.optional(),
+	parentToolCallId: zod_v4.z.string().optional(),
+	parentMessageId: zod_v4.z.string().optional()
+});
+/**
+* The subagent completed its work. Equivalent to an absent outcome.
+*/
+const SubagentFinishedSuccessOutcomeSchema = zod_v4.z.looseObject({ type: zod_v4.z.literal("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.
+*/
+const SubagentFinishedSuspendedOutcomeSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal("suspended"),
+	interruptIds: zod_v4.z.array(zod_v4.z.string()).optional()
+});
+/**
+* Why a subagent's segment of a run ended. Mirrors RunFinishedOutcome one
+* level down.
+*/
+const SubagentFinishedOutcomeSchema = zod_v4.z.discriminatedUnion("type", [SubagentFinishedSuccessOutcomeSchema, SubagentFinishedSuspendedOutcomeSchema]);
+/**
+* Ends a subagent invocation's segment of this run, either because the work
+* completed or because it is suspended awaiting outside input.
+*/
+const SubagentFinishedEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.SUBAGENT_FINISHED),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema,
+	result: zod_v4.z.any().refine((value) => value !== null).optional(),
+	outcome: SubagentFinishedOutcomeSchema.optional()
+});
+/**
+* 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.
+*/
+const SubagentErrorEventSchema = zod_v4.z.looseObject({
+	type: zod_v4.z.literal(require_version.EventType.SUBAGENT_ERROR),
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional(),
+	subagentRunId: SubagentRunIdSchema,
+	message: zod_v4.z.string(),
+	code: zod_v4.z.string().optional()
+});
+/**
+* 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.
+*/
+const EventSchema = zod_v4.z.discriminatedUnion("type", [
 	TextMessageStartEventSchema,
 	TextMessageContentEventSchema,
 	TextMessageEndEventSchema,
 	TextMessageChunkEventSchema,
-	ThinkingStartEventSchema,
-	ThinkingEndEventSchema,
-	ThinkingTextMessageStartEventSchema,
-	ThinkingTextMessageContentEventSchema,
-	ThinkingTextMessageEndEventSchema,
 	ToolCallStartEventSchema,
 	ToolCallArgsEventSchema,
 	ToolCallEndEventSchema,
@@ -436,30 +919,51 @@ const EventSchemas = zod_v4.z.discriminatedUnion("type", [
 	ReasoningMessageEndEventSchema,
 	ReasoningMessageChunkEventSchema,
 	ReasoningEndEventSchema,
-	ReasoningEncryptedValueEventSchema
+	ReasoningEncryptedValueEventSchema,
+	SubagentStartedEventSchema,
+	SubagentFinishedEventSchema,
+	SubagentErrorEventSchema
 ]);
-/** Describes a sub-agent that can be invoked by a parent agent. */
-const SubAgentInfoSchema = zod_v4.z.object({
+/**
+* Every role a materialised message may have.
+*/
+const RoleSchema = zod_v4.z.enum([
+	"developer",
+	"system",
+	"assistant",
+	"user",
+	"tool",
+	"activity",
+	"reasoning"
+]);
+/**
+* Describes a subagent that can be invoked by a parent agent.
+*/
+const SubagentInfoSchema = zod_v4.z.looseObject({
 	name: zod_v4.z.string(),
 	description: zod_v4.z.string().optional()
 });
 /**
-* Basic metadata about the agent. Useful for discovery UIs, agent marketplaces,
-* and debugging.
+* 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.
 */
-const IdentityCapabilitiesSchema = zod_v4.z.object({
+const IdentityCapabilitiesSchema = zod_v4.z.looseObject({
 	name: zod_v4.z.string().optional(),
 	type: zod_v4.z.string().optional(),
 	description: zod_v4.z.string().optional(),
 	version: zod_v4.z.string().optional(),
 	provider: zod_v4.z.string().optional(),
 	documentationUrl: zod_v4.z.string().optional(),
-	metadata: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional()
+	metadata: MetadataSchema.optional()
 });
 /**
-* Declares which transport mechanisms the agent supports.
+* 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.
 */
-const TransportCapabilitiesSchema = zod_v4.z.object({
+const TransportCapabilitiesSchema = zod_v4.z.looseObject({
 	streaming: zod_v4.z.boolean().optional(),
 	websocket: zod_v4.z.boolean().optional(),
 	httpBinary: zod_v4.z.boolean().optional(),
@@ -467,51 +971,61 @@ const TransportCapabilitiesSchema = zod_v4.z.object({
 	resumable: zod_v4.z.boolean().optional()
 });
 /**
-* Tool calling capabilities.
+* 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.
 */
-const ToolsCapabilitiesSchema = zod_v4.z.object({
+const ToolsCapabilitiesSchema = zod_v4.z.looseObject({
 	supported: zod_v4.z.boolean().optional(),
 	items: zod_v4.z.array(ToolSchema).optional(),
 	parallelCalls: zod_v4.z.boolean().optional(),
 	clientProvided: zod_v4.z.boolean().optional()
 });
 /**
-* Output format support.
+* Output format support. Enable structuredOutput when your agent can return
+* responses conforming to a JSON schema, which is useful for programmatic
+* consumption.
 */
-const OutputCapabilitiesSchema = zod_v4.z.object({
+const OutputCapabilitiesSchema = zod_v4.z.looseObject({
 	structuredOutput: zod_v4.z.boolean().optional(),
 	supportedMimeTypes: zod_v4.z.array(zod_v4.z.string()).optional()
 });
 /**
-* State and memory management capabilities.
+* State and memory management capabilities. These tell the client how the
+* agent handles shared state and whether conversation context persists across
+* runs.
 */
-const StateCapabilitiesSchema = zod_v4.z.object({
+const StateCapabilitiesSchema = zod_v4.z.looseObject({
 	snapshots: zod_v4.z.boolean().optional(),
 	deltas: zod_v4.z.boolean().optional(),
 	memory: zod_v4.z.boolean().optional(),
 	persistentState: zod_v4.z.boolean().optional()
 });
 /**
-* Multi-agent coordination capabilities.
+* Multi-agent coordination capabilities. Enable these when your agent can
+* orchestrate or hand off work to other agents.
 */
-const MultiAgentCapabilitiesSchema = zod_v4.z.object({
+const MultiAgentCapabilitiesSchema = zod_v4.z.looseObject({
 	supported: zod_v4.z.boolean().optional(),
 	delegation: zod_v4.z.boolean().optional(),
 	handoffs: zod_v4.z.boolean().optional(),
-	subAgents: zod_v4.z.array(SubAgentInfoSchema).optional()
+	subagents: zod_v4.z.array(SubagentInfoSchema).optional()
 });
 /**
-* Reasoning and thinking capabilities.
+* Reasoning and thinking capabilities. Enable these when your agent exposes
+* its internal thought process (e.g., chain-of-thought, extended thinking).
 */
-const ReasoningCapabilitiesSchema = zod_v4.z.object({
+const ReasoningCapabilitiesSchema = zod_v4.z.looseObject({
 	supported: zod_v4.z.boolean().optional(),
 	streaming: zod_v4.z.boolean().optional(),
 	encrypted: zod_v4.z.boolean().optional()
 });
 /**
-* Modalities the agent can accept as input.
+* Modalities the agent can accept as input. Clients use this to show or hide
+* file upload buttons, audio recorders, image pickers, etc.
 */
-const MultimodalInputCapabilitiesSchema = zod_v4.z.object({
+const MultimodalInputCapabilitiesSchema = zod_v4.z.looseObject({
 	image: zod_v4.z.boolean().optional(),
 	audio: zod_v4.z.boolean().optional(),
 	video: zod_v4.z.boolean().optional(),
@@ -519,32 +1033,38 @@ const MultimodalInputCapabilitiesSchema = zod_v4.z.object({
 	file: zod_v4.z.boolean().optional()
 });
 /**
-* Modalities the agent can produce as output.
+* Modalities the agent can produce as output. Clients use this to anticipate
+* rich content in the agent's response.
 */
-const MultimodalOutputCapabilitiesSchema = zod_v4.z.object({
+const MultimodalOutputCapabilitiesSchema = zod_v4.z.looseObject({
 	image: zod_v4.z.boolean().optional(),
 	audio: zod_v4.z.boolean().optional()
 });
 /**
-* Multimodal input and output support.
+* 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.
 */
-const MultimodalCapabilitiesSchema = zod_v4.z.object({
+const MultimodalCapabilitiesSchema = zod_v4.z.looseObject({
 	input: MultimodalInputCapabilitiesSchema.optional(),
 	output: MultimodalOutputCapabilitiesSchema.optional()
 });
 /**
-* Execution control and limits.
+* Execution control and limits. Declare these so clients can set expectations
+* about how long or how many steps an agent run might take.
 */
-const ExecutionCapabilitiesSchema = zod_v4.z.object({
+const ExecutionCapabilitiesSchema = zod_v4.z.looseObject({
 	codeExecution: zod_v4.z.boolean().optional(),
 	sandboxed: zod_v4.z.boolean().optional(),
-	maxIterations: zod_v4.z.number().optional(),
-	maxExecutionTime: zod_v4.z.number().optional()
+	maxIterations: zod_v4.z.int().min(0).max(9007199254740991).optional(),
+	maxExecutionTime: zod_v4.z.int().min(0).max(9007199254740991).optional()
 });
 /**
-* Human-in-the-loop interaction support.
+* Human-in-the-loop interaction support. Enable these when your agent can
+* pause execution to request human input, approval, or feedback before
+* continuing.
 */
-const HumanInTheLoopCapabilitiesSchema = zod_v4.z.object({
+const HumanInTheLoopCapabilitiesSchema = zod_v4.z.looseObject({
 	supported: zod_v4.z.boolean().optional(),
 	approvals: zod_v4.z.boolean().optional(),
 	interventions: zod_v4.z.boolean().optional(),
@@ -553,10 +1073,13 @@ const HumanInTheLoopCapabilitiesSchema = zod_v4.z.object({
 	approveWithEdits: zod_v4.z.boolean().optional()
 });
 /**
-* A typed, categorized snapshot of an agent's current capabilities.
-* Returned by `getCapabilities()` on `AbstractAgent`.
+* 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.
 */
-const AgentCapabilitiesSchema = zod_v4.z.object({
+const AgentCapabilitiesSchema = zod_v4.z.looseObject({
 	identity: IdentityCapabilitiesSchema.optional(),
 	transport: TransportCapabilitiesSchema.optional(),
 	tools: ToolsCapabilitiesSchema.optional(),
@@ -567,144 +1090,121 @@ const AgentCapabilitiesSchema = zod_v4.z.object({
 	multimodal: MultimodalCapabilitiesSchema.optional(),
 	execution: ExecutionCapabilitiesSchema.optional(),
 	humanInTheLoop: HumanInTheLoopCapabilitiesSchema.optional(),
-	custom: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional()
+	custom: zod_v4.z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value)).optional()
+});
+/**
+* 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.
+*/
+const AttributableSchema = zod_v4.z.looseObject({ subagentRunId: SubagentRunIdSchema.optional() });
+/**
+* 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.
+*/
+const BaseEventSchema = zod_v4.z.looseObject({
+	type: EventTypeSchema,
+	timestamp: zod_v4.z.int().min(-9007199254740991).max(9007199254740991).optional(),
+	rawEvent: zod_v4.z.any().refine((value) => value !== null).optional(),
+	metadata: MetadataSchema.optional()
+});
+/**
+* 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.
+*/
+const BaseMessageSchema = zod_v4.z.looseObject({
+	subagentRunId: SubagentRunIdSchema.optional(),
+	id: zod_v4.z.string(),
+	role: zod_v4.z.string(),
+	name: zod_v4.z.string().optional(),
+	encryptedValue: zod_v4.z.string().optional(),
+	metadata: MetadataSchema.optional()
 });
 
 //#endregion
-//#region src/event-factories.ts
-const buildEvent = (eventType, schema, props) => schema.parse({
-	...props,
-	type: eventType
-});
-/** Creates a TEXT_MESSAGE_START event. `role` defaults to `"assistant"` when omitted. */
-const createTextMessageStartEvent = (props) => buildEvent(require_events.EventType.TEXT_MESSAGE_START, TextMessageStartEventSchema, props);
-/** Creates a TEXT_MESSAGE_CONTENT event. */
-const createTextMessageContentEvent = (props) => buildEvent(require_events.EventType.TEXT_MESSAGE_CONTENT, TextMessageContentEventSchema, props);
-/** Creates a TEXT_MESSAGE_END event. */
-const createTextMessageEndEvent = (props) => buildEvent(require_events.EventType.TEXT_MESSAGE_END, TextMessageEndEventSchema, props);
-/** Creates a TEXT_MESSAGE_CHUNK event. */
-const createTextMessageChunkEvent = (props) => buildEvent(require_events.EventType.TEXT_MESSAGE_CHUNK, TextMessageChunkEventSchema, props);
-/** @deprecated Use `createReasoningMessageStartEvent` instead. Will be removed in 1.0.0. */
-const createThinkingTextMessageStartEvent = (props) => buildEvent(require_events.EventType.THINKING_TEXT_MESSAGE_START, ThinkingTextMessageStartEventSchema, props);
-/** @deprecated Use `createReasoningMessageContentEvent` instead. Will be removed in 1.0.0. */
-const createThinkingTextMessageContentEvent = (props) => buildEvent(require_events.EventType.THINKING_TEXT_MESSAGE_CONTENT, ThinkingTextMessageContentEventSchema, props);
-/** @deprecated Use `createReasoningMessageEndEvent` instead. Will be removed in 1.0.0. */
-const createThinkingTextMessageEndEvent = (props) => buildEvent(require_events.EventType.THINKING_TEXT_MESSAGE_END, ThinkingTextMessageEndEventSchema, props);
-/** Creates a TOOL_CALL_START event. */
-const createToolCallStartEvent = (props) => buildEvent(require_events.EventType.TOOL_CALL_START, ToolCallStartEventSchema, props);
-/** Creates a TOOL_CALL_ARGS event. */
-const createToolCallArgsEvent = (props) => buildEvent(require_events.EventType.TOOL_CALL_ARGS, ToolCallArgsEventSchema, props);
-/** Creates a TOOL_CALL_END event. */
-const createToolCallEndEvent = (props) => buildEvent(require_events.EventType.TOOL_CALL_END, ToolCallEndEventSchema, props);
-/** Creates a TOOL_CALL_CHUNK event. */
-const createToolCallChunkEvent = (props) => buildEvent(require_events.EventType.TOOL_CALL_CHUNK, ToolCallChunkEventSchema, props);
-/** Creates a TOOL_CALL_RESULT event. */
-const createToolCallResultEvent = (props) => buildEvent(require_events.EventType.TOOL_CALL_RESULT, ToolCallResultEventSchema, props);
-/** @deprecated Use `createReasoningStartEvent` instead. Will be removed in 1.0.0. */
-const createThinkingStartEvent = (props) => buildEvent(require_events.EventType.THINKING_START, ThinkingStartEventSchema, props);
-/** @deprecated Use `createReasoningEndEvent` instead. Will be removed in 1.0.0. */
-const createThinkingEndEvent = (props) => buildEvent(require_events.EventType.THINKING_END, ThinkingEndEventSchema, props);
-/** Creates a STATE_SNAPSHOT event. */
-const createStateSnapshotEvent = (props) => buildEvent(require_events.EventType.STATE_SNAPSHOT, StateSnapshotEventSchema, props);
-/** Creates a STATE_DELTA event. */
-const createStateDeltaEvent = (props) => buildEvent(require_events.EventType.STATE_DELTA, StateDeltaEventSchema, props);
-/** Creates a MESSAGES_SNAPSHOT event. */
-const createMessagesSnapshotEvent = (props) => buildEvent(require_events.EventType.MESSAGES_SNAPSHOT, MessagesSnapshotEventSchema, props);
-/** Creates an ACTIVITY_SNAPSHOT event. `replace` defaults to `true` when omitted. */
-const createActivitySnapshotEvent = (props) => buildEvent(require_events.EventType.ACTIVITY_SNAPSHOT, ActivitySnapshotEventSchema, props);
-/** Creates an ACTIVITY_DELTA event. */
-const createActivityDeltaEvent = (props) => buildEvent(require_events.EventType.ACTIVITY_DELTA, ActivityDeltaEventSchema, props);
-/** Creates a RAW event. */
-const createRawEvent = (props) => buildEvent(require_events.EventType.RAW, RawEventSchema, props);
-/** Creates a CUSTOM event. */
-const createCustomEvent = (props) => buildEvent(require_events.EventType.CUSTOM, CustomEventSchema, props);
-/** Creates a RUN_STARTED event. */
-const createRunStartedEvent = (props) => buildEvent(require_events.EventType.RUN_STARTED, RunStartedEventSchema, props);
-/**
-* Creates a RUN_FINISHED event.
+//#region src/schemas.ts
+/**
+* How metadata is declared on events and messages.
+*
+* The object itself is absent or an object, never `null` — and parsing enforces
+* that invariant rather than coercing a `null` to absent. The schema pinning it
+* now lives in the generated source (MetadataSchema in
+* src/generated/schemas.ts); this comment survives as the recorded reasoning.
 *
-* `outcome` is optional. Omit it for legacy/back-compat behavior, or set it
-* explicitly to `{ type: "success" }` or `{ type: "interrupt", interrupts }` —
-* see `createRunFinishedSuccessEvent` and `createRunFinishedInterruptEvent` for
-* convenience helpers. `outcome: null` is normalized to `outcome` being omitted.
-*/
-const createRunFinishedEvent = (props) => buildEvent(require_events.EventType.RUN_FINISHED, RunFinishedEventSchema, props);
-/** Creates a RUN_FINISHED event with `outcome: { type: "success" }`. */
-const createRunFinishedSuccessEvent = (props) => buildEvent(require_events.EventType.RUN_FINISHED, RunFinishedEventSchema, {
-	...props,
-	outcome: { type: "success" }
-});
-/**
-* Creates a RUN_FINISHED event with `outcome: { type: "interrupt", interrupts }`.
-* Throws if `interrupts` is empty (the schema requires at least one entry).
-*/
-const createRunFinishedInterruptEvent = (props) => {
-	const { interrupts, ...rest } = props;
-	return buildEvent(require_events.EventType.RUN_FINISHED, RunFinishedEventSchema, {
-		...rest,
-		outcome: {
-			type: "interrupt",
-			interrupts
-		}
-	});
-};
-/** Creates a RUN_ERROR event. */
-const createRunErrorEvent = (props) => buildEvent(require_events.EventType.RUN_ERROR, RunErrorEventSchema, props);
-/** Creates a STEP_STARTED event. */
-const createStepStartedEvent = (props) => buildEvent(require_events.EventType.STEP_STARTED, StepStartedEventSchema, props);
-/** Creates a STEP_FINISHED event. */
-const createStepFinishedEvent = (props) => buildEvent(require_events.EventType.STEP_FINISHED, StepFinishedEventSchema, props);
-/** Creates a REASONING_START event. */
-const createReasoningStartEvent = (props) => buildEvent(require_events.EventType.REASONING_START, ReasoningStartEventSchema, props);
-/** Creates a REASONING_MESSAGE_START event. */
-const createReasoningMessageStartEvent = (props) => buildEvent(require_events.EventType.REASONING_MESSAGE_START, ReasoningMessageStartEventSchema, props);
-/** Creates a REASONING_MESSAGE_CONTENT event. */
-const createReasoningMessageContentEvent = (props) => buildEvent(require_events.EventType.REASONING_MESSAGE_CONTENT, ReasoningMessageContentEventSchema, props);
-/** Creates a REASONING_MESSAGE_END event. */
-const createReasoningMessageEndEvent = (props) => buildEvent(require_events.EventType.REASONING_MESSAGE_END, ReasoningMessageEndEventSchema, props);
-/** Creates a REASONING_MESSAGE_CHUNK event. */
-const createReasoningMessageChunkEvent = (props) => buildEvent(require_events.EventType.REASONING_MESSAGE_CHUNK, ReasoningMessageChunkEventSchema, props);
-/** Creates a REASONING_END event. */
-const createReasoningEndEvent = (props) => buildEvent(require_events.EventType.REASONING_END, ReasoningEndEventSchema, props);
-/** Creates a REASONING_ENCRYPTED_VALUE event. */
-const createReasoningEncryptedValueEvent = (props) => buildEvent(require_events.EventType.REASONING_ENCRYPTED_VALUE, ReasoningEncryptedValueEventSchema, props);
+* Historically tolerated whole optional nulls are translated to absence in
+* the client's compatibility boundary before validation. That includes the
+* legacy `parentMessageId` and `outcome` cases and optional JSON fields such as
+* `rawEvent`, `result`, and media content-part `metadata`; see the repo-root
+* DEPRECATIONS.md for the exact list. Event and message metadata already
+* rejected a whole `null`, so their restriction remains. Compatibility for
+* media content-part metadata does not broaden this shared metadata schema.
+*
+* A `null` *value under a key* is meaningful data and is preserved. Only a
+* `null` in place of the whole object is a contract violation.
+*/
+const OptionalMetadataSchema = MetadataSchema.optional();
 
 //#endregion
 exports.ActivityDeltaEventSchema = ActivityDeltaEventSchema;
 exports.ActivityMessageSchema = ActivityMessageSchema;
 exports.ActivitySnapshotEventSchema = ActivitySnapshotEventSchema;
+exports.AddOperationSchema = AddOperationSchema;
 exports.AgentCapabilitiesSchema = AgentCapabilitiesSchema;
 exports.AssistantMessageSchema = AssistantMessageSchema;
-exports.AudioInputContentSchema = AudioInputContentSchema;
-exports.AudioInputPartSchema = AudioInputPartSchema;
+exports.AttributableSchema = AttributableSchema;
+exports.AudioInputContentSchema = AudioPartSchema;
+exports.AudioInputPartSchema = AudioPartSchema;
+exports.AudioPartSchema = AudioPartSchema;
 exports.BaseEventSchema = BaseEventSchema;
-exports.BinaryInputContentSchema = BinaryInputContentSchema;
+exports.BaseMessageSchema = BaseMessageSchema;
+exports.ContentPartSchema = ContentPartSchema;
 exports.ContextSchema = ContextSchema;
+exports.CopyOperationSchema = CopyOperationSchema;
 exports.CustomEventSchema = CustomEventSchema;
+exports.DataSourceSchema = DataSourceSchema;
 exports.DeveloperMessageSchema = DeveloperMessageSchema;
-exports.DocumentInputContentSchema = DocumentInputContentSchema;
-exports.DocumentInputPartSchema = DocumentInputPartSchema;
-exports.EventSchemas = EventSchemas;
+exports.DocumentInputContentSchema = DocumentPartSchema;
+exports.DocumentInputPartSchema = DocumentPartSchema;
+exports.DocumentPartSchema = DocumentPartSchema;
+exports.EventSchema = EventSchema;
+exports.EventSchemas = EventSchema;
 exports.EventTypeSchema = EventTypeSchema;
 exports.ExecutionCapabilitiesSchema = ExecutionCapabilitiesSchema;
+exports.FileSourceSchema = FileSourceSchema;
 exports.FunctionCallSchema = FunctionCallSchema;
 exports.HumanInTheLoopCapabilitiesSchema = HumanInTheLoopCapabilitiesSchema;
 exports.IdentityCapabilitiesSchema = IdentityCapabilitiesSchema;
-exports.ImageInputContentSchema = ImageInputContentSchema;
-exports.ImageInputPartSchema = ImageInputPartSchema;
-exports.InputContentDataSourceSchema = InputContentDataSourceSchema;
-exports.InputContentPartSchema = InputContentPartSchema;
-exports.InputContentSchema = InputContentSchema;
-exports.InputContentSourceSchema = InputContentSourceSchema;
-exports.InputContentUrlSourceSchema = InputContentUrlSourceSchema;
+exports.ImageInputContentSchema = ImagePartSchema;
+exports.ImageInputPartSchema = ImagePartSchema;
+exports.ImagePartSchema = ImagePartSchema;
+exports.InputContentDataSourceSchema = DataSourceSchema;
+exports.InputContentSchema = ContentPartSchema;
+exports.InputContentSourceSchema = PartSourceSchema;
+exports.InputContentUrlSourceSchema = UrlSourceSchema;
 exports.InterruptSchema = InterruptSchema;
+exports.JsonPatchOperationSchema = JsonPatchOperationSchema;
+exports.JsonPatchSchema = JsonPatchSchema;
+exports.JsonPointerSchema = JsonPointerSchema;
 exports.MessageSchema = MessageSchema;
 exports.MessagesSnapshotEventSchema = MessagesSnapshotEventSchema;
+exports.MetadataSchema = MetadataSchema;
+exports.MoveOperationSchema = MoveOperationSchema;
 exports.MultiAgentCapabilitiesSchema = MultiAgentCapabilitiesSchema;
 exports.MultimodalCapabilitiesSchema = MultimodalCapabilitiesSchema;
 exports.MultimodalInputCapabilitiesSchema = MultimodalInputCapabilitiesSchema;
 exports.MultimodalOutputCapabilitiesSchema = MultimodalOutputCapabilitiesSchema;
+exports.OptionalMetadataSchema = OptionalMetadataSchema;
 exports.OutputCapabilitiesSchema = OutputCapabilitiesSchema;
+exports.PROTOCOL_VERSION = require_version.PROTOCOL_VERSION;
+exports.PartSourceSchema = PartSourceSchema;
 exports.RawEventSchema = RawEventSchema;
 exports.ReasoningCapabilitiesSchema = ReasoningCapabilitiesSchema;
 exports.ReasoningEncryptedValueEventSchema = ReasoningEncryptedValueEventSchema;
@@ -716,10 +1216,13 @@ exports.ReasoningMessageEndEventSchema = ReasoningMessageEndEventSchema;
 exports.ReasoningMessageSchema = ReasoningMessageSchema;
 exports.ReasoningMessageStartEventSchema = ReasoningMessageStartEventSchema;
 exports.ReasoningStartEventSchema = ReasoningStartEventSchema;
+exports.RemoveOperationSchema = RemoveOperationSchema;
+exports.ReplaceOperationSchema = ReplaceOperationSchema;
 exports.ResumeEntrySchema = ResumeEntrySchema;
 exports.RoleSchema = RoleSchema;
 exports.RunAgentInputSchema = RunAgentInputSchema;
 exports.RunErrorEventSchema = RunErrorEventSchema;
+exports.RunFinishedCancelledOutcomeSchema = RunFinishedCancelledOutcomeSchema;
 exports.RunFinishedEventSchema = RunFinishedEventSchema;
 exports.RunFinishedInterruptOutcomeSchema = RunFinishedInterruptOutcomeSchema;
 exports.RunFinishedOutcomeSchema = RunFinishedOutcomeSchema;
@@ -731,18 +1234,24 @@ exports.StateSchema = StateSchema;
 exports.StateSnapshotEventSchema = StateSnapshotEventSchema;
 exports.StepFinishedEventSchema = StepFinishedEventSchema;
 exports.StepStartedEventSchema = StepStartedEventSchema;
-exports.SubAgentInfoSchema = SubAgentInfoSchema;
+exports.SubagentErrorEventSchema = SubagentErrorEventSchema;
+exports.SubagentFinishedEventSchema = SubagentFinishedEventSchema;
+exports.SubagentFinishedOutcomeSchema = SubagentFinishedOutcomeSchema;
+exports.SubagentFinishedSuccessOutcomeSchema = SubagentFinishedSuccessOutcomeSchema;
+exports.SubagentFinishedSuspendedOutcomeSchema = SubagentFinishedSuspendedOutcomeSchema;
+exports.SubagentInfoSchema = SubagentInfoSchema;
+exports.SubagentRunIdSchema = SubagentRunIdSchema;
+exports.SubagentStartedEventSchema = SubagentStartedEventSchema;
 exports.SystemMessageSchema = SystemMessageSchema;
-exports.TextInputContentSchema = TextInputContentSchema;
+exports.TestOperationSchema = TestOperationSchema;
+exports.TextInputContentSchema = TextPartSchema;
 exports.TextMessageChunkEventSchema = TextMessageChunkEventSchema;
 exports.TextMessageContentEventSchema = TextMessageContentEventSchema;
 exports.TextMessageEndEventSchema = TextMessageEndEventSchema;
+exports.TextMessageRoleSchema = TextMessageRoleSchema;
 exports.TextMessageStartEventSchema = TextMessageStartEventSchema;
-exports.ThinkingEndEventSchema = ThinkingEndEventSchema;
-exports.ThinkingStartEventSchema = ThinkingStartEventSchema;
-exports.ThinkingTextMessageContentEventSchema = ThinkingTextMessageContentEventSchema;
-exports.ThinkingTextMessageEndEventSchema = ThinkingTextMessageEndEventSchema;
-exports.ThinkingTextMessageStartEventSchema = ThinkingTextMessageStartEventSchema;
+exports.TextPartSchema = TextPartSchema;
+exports.TokenUsageSchema = TokenUsageSchema;
 exports.ToolCallArgsEventSchema = ToolCallArgsEventSchema;
 exports.ToolCallChunkEventSchema = ToolCallChunkEventSchema;
 exports.ToolCallEndEventSchema = ToolCallEndEventSchema;
@@ -753,42 +1262,9 @@ exports.ToolMessageSchema = ToolMessageSchema;
 exports.ToolSchema = ToolSchema;
 exports.ToolsCapabilitiesSchema = ToolsCapabilitiesSchema;
 exports.TransportCapabilitiesSchema = TransportCapabilitiesSchema;
+exports.UrlSourceSchema = UrlSourceSchema;
 exports.UserMessageSchema = UserMessageSchema;
-exports.VideoInputContentSchema = VideoInputContentSchema;
-exports.VideoInputPartSchema = VideoInputPartSchema;
-exports.createActivityDeltaEvent = createActivityDeltaEvent;
-exports.createActivitySnapshotEvent = createActivitySnapshotEvent;
-exports.createCustomEvent = createCustomEvent;
-exports.createMessagesSnapshotEvent = createMessagesSnapshotEvent;
-exports.createRawEvent = createRawEvent;
-exports.createReasoningEncryptedValueEvent = createReasoningEncryptedValueEvent;
-exports.createReasoningEndEvent = createReasoningEndEvent;
-exports.createReasoningMessageChunkEvent = createReasoningMessageChunkEvent;
-exports.createReasoningMessageContentEvent = createReasoningMessageContentEvent;
-exports.createReasoningMessageEndEvent = createReasoningMessageEndEvent;
-exports.createReasoningMessageStartEvent = createReasoningMessageStartEvent;
-exports.createReasoningStartEvent = createReasoningStartEvent;
-exports.createRunErrorEvent = createRunErrorEvent;
-exports.createRunFinishedEvent = createRunFinishedEvent;
-exports.createRunFinishedInterruptEvent = createRunFinishedInterruptEvent;
-exports.createRunFinishedSuccessEvent = createRunFinishedSuccessEvent;
-exports.createRunStartedEvent = createRunStartedEvent;
-exports.createStateDeltaEvent = createStateDeltaEvent;
-exports.createStateSnapshotEvent = createStateSnapshotEvent;
-exports.createStepFinishedEvent = createStepFinishedEvent;
-exports.createStepStartedEvent = createStepStartedEvent;
-exports.createTextMessageChunkEvent = createTextMessageChunkEvent;
-exports.createTextMessageContentEvent = createTextMessageContentEvent;
-exports.createTextMessageEndEvent = createTextMessageEndEvent;
-exports.createTextMessageStartEvent = createTextMessageStartEvent;
-exports.createThinkingEndEvent = createThinkingEndEvent;
-exports.createThinkingStartEvent = createThinkingStartEvent;
-exports.createThinkingTextMessageContentEvent = createThinkingTextMessageContentEvent;
-exports.createThinkingTextMessageEndEvent = createThinkingTextMessageEndEvent;
-exports.createThinkingTextMessageStartEvent = createThinkingTextMessageStartEvent;
-exports.createToolCallArgsEvent = createToolCallArgsEvent;
-exports.createToolCallChunkEvent = createToolCallChunkEvent;
-exports.createToolCallEndEvent = createToolCallEndEvent;
-exports.createToolCallResultEvent = createToolCallResultEvent;
-exports.createToolCallStartEvent = createToolCallStartEvent;
+exports.VideoInputContentSchema = VideoPartSchema;
+exports.VideoInputPartSchema = VideoPartSchema;
+exports.VideoPartSchema = VideoPartSchema;
 //# sourceMappingURL=schemas.js.map