@ag-ui/core 0.0.59 → 1.0.0-canary.1789569879.0

package/dist/index.mjs

@@ -1,5 +1,786 @@
-import { z } from "zod";
+import { n as EventType, t as PROTOCOL_VERSION } from "./version-DQ7V2LqS.mjs";
 
+//#region src/generated/serialization.ts
+const shapes = {
+	TextMessageStartEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"role",
+			"name"
+		],
+		fields: {}
+	},
+	TextMessageContentEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	TextMessageEndEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	TextMessageChunkEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"messageId",
+			"role",
+			"delta",
+			"name"
+		],
+		fields: {}
+	},
+	ToolCallStartEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"parentMessageId"
+		],
+		fields: {}
+	},
+	ToolCallArgsEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ToolCallEndEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ToolCallChunkEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"toolCallId",
+			"toolCallName",
+			"parentMessageId",
+			"delta"
+		],
+		fields: {}
+	},
+	TextPart: {
+		optional: ["id", "metadata"],
+		fields: {}
+	},
+	DataSource: {
+		optional: [],
+		fields: {}
+	},
+	UrlSource: {
+		optional: ["mimeType"],
+		fields: {}
+	},
+	FileSource: {
+		optional: ["provider", "mimeType"],
+		fields: {}
+	},
+	PartSource: {
+		discriminator: "type",
+		variants: {
+			data: "DataSource",
+			url: "UrlSource",
+			file: "FileSource"
+		}
+	},
+	ImagePart: {
+		optional: ["id", "metadata"],
+		fields: { source: "PartSource" }
+	},
+	AudioPart: {
+		optional: ["id", "metadata"],
+		fields: { source: "PartSource" }
+	},
+	VideoPart: {
+		optional: ["id", "metadata"],
+		fields: { source: "PartSource" }
+	},
+	DocumentPart: {
+		optional: ["id", "metadata"],
+		fields: { source: "PartSource" }
+	},
+	ContentPart: {
+		discriminator: "type",
+		variants: {
+			text: "TextPart",
+			image: "ImagePart",
+			audio: "AudioPart",
+			video: "VideoPart",
+			document: "DocumentPart"
+		}
+	},
+	ToolCallResultEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"role"
+		],
+		fields: { content: { array: "ContentPart" } }
+	},
+	StateSnapshotEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	AddOperation: {
+		optional: [],
+		fields: {}
+	},
+	RemoveOperation: {
+		optional: [],
+		fields: {}
+	},
+	ReplaceOperation: {
+		optional: [],
+		fields: {}
+	},
+	MoveOperation: {
+		optional: [],
+		fields: {}
+	},
+	CopyOperation: {
+		optional: [],
+		fields: {}
+	},
+	TestOperation: {
+		optional: [],
+		fields: {}
+	},
+	JsonPatchOperation: {
+		discriminator: "op",
+		variants: {
+			add: "AddOperation",
+			remove: "RemoveOperation",
+			replace: "ReplaceOperation",
+			move: "MoveOperation",
+			copy: "CopyOperation",
+			test: "TestOperation"
+		}
+	},
+	StateDeltaEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: { delta: { array: "JsonPatchOperation" } }
+	},
+	DeveloperMessage: {
+		optional: [
+			"subagentRunId",
+			"name",
+			"encryptedValue",
+			"metadata"
+		],
+		fields: {}
+	},
+	SystemMessage: {
+		optional: [
+			"subagentRunId",
+			"name",
+			"encryptedValue",
+			"metadata"
+		],
+		fields: {}
+	},
+	FunctionCall: {
+		optional: [],
+		fields: {}
+	},
+	ToolCall: {
+		optional: ["encryptedValue", "metadata"],
+		fields: { function: "FunctionCall" }
+	},
+	AssistantMessage: {
+		optional: [
+			"subagentRunId",
+			"name",
+			"encryptedValue",
+			"metadata",
+			"content",
+			"toolCalls"
+		],
+		fields: { toolCalls: { array: "ToolCall" } }
+	},
+	UserMessage: {
+		optional: [
+			"subagentRunId",
+			"name",
+			"encryptedValue",
+			"metadata"
+		],
+		fields: { content: { array: "ContentPart" } }
+	},
+	ToolMessage: {
+		optional: [
+			"subagentRunId",
+			"error",
+			"encryptedValue",
+			"metadata"
+		],
+		fields: { content: { array: "ContentPart" } }
+	},
+	ActivityMessage: {
+		optional: ["subagentRunId", "metadata"],
+		fields: {}
+	},
+	ReasoningMessage: {
+		optional: [
+			"subagentRunId",
+			"encryptedValue",
+			"metadata"
+		],
+		fields: {}
+	},
+	Message: {
+		discriminator: "role",
+		variants: {
+			developer: "DeveloperMessage",
+			system: "SystemMessage",
+			assistant: "AssistantMessage",
+			user: "UserMessage",
+			tool: "ToolMessage",
+			activity: "ActivityMessage",
+			reasoning: "ReasoningMessage"
+		}
+	},
+	MessagesSnapshotEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata"
+		],
+		fields: { messages: { array: "Message" } }
+	},
+	ActivitySnapshotEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"replace"
+		],
+		fields: {}
+	},
+	ActivityDeltaEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: { patch: { array: "JsonPatchOperation" } }
+	},
+	RawEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"source"
+		],
+		fields: {}
+	},
+	CustomEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	Tool: {
+		optional: ["parameters", "metadata"],
+		fields: {}
+	},
+	Context: {
+		optional: [],
+		fields: {}
+	},
+	ResumeEntry: {
+		optional: ["payload", "metadata"],
+		fields: {}
+	},
+	RunAgentInput: {
+		optional: [
+			"protocolVersion",
+			"parentRunId",
+			"state",
+			"tools",
+			"context",
+			"forwardedProps",
+			"resume"
+		],
+		fields: {
+			messages: { array: "Message" },
+			tools: { array: "Tool" },
+			context: { array: "Context" },
+			resume: { array: "ResumeEntry" }
+		}
+	},
+	RunStartedEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"protocolVersion",
+			"parentRunId",
+			"input"
+		],
+		fields: { input: "RunAgentInput" }
+	},
+	RunFinishedSuccessOutcome: {
+		optional: ["pendingToolCallIds"],
+		fields: {}
+	},
+	Interrupt: {
+		optional: [
+			"subagentRunId",
+			"message",
+			"toolCallId",
+			"responseSchema",
+			"expiresAt",
+			"metadata"
+		],
+		fields: {}
+	},
+	RunFinishedInterruptOutcome: {
+		optional: [],
+		fields: { interrupts: { array: "Interrupt" } }
+	},
+	RunFinishedCancelledOutcome: {
+		optional: [],
+		fields: {}
+	},
+	RunFinishedOutcome: {
+		discriminator: "type",
+		variants: {
+			success: "RunFinishedSuccessOutcome",
+			interrupt: "RunFinishedInterruptOutcome",
+			cancelled: "RunFinishedCancelledOutcome"
+		}
+	},
+	TokenUsage: {
+		optional: [
+			"provider",
+			"model",
+			"inputTokens",
+			"outputTokens",
+			"totalTokens",
+			"reasoningTokens",
+			"cachedInputTokens",
+			"cacheWriteInputTokens"
+		],
+		fields: {}
+	},
+	RunFinishedEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"result",
+			"outcome",
+			"usage"
+		],
+		fields: {
+			outcome: "RunFinishedOutcome",
+			usage: { array: "TokenUsage" }
+		}
+	},
+	RunErrorEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"code",
+			"usage"
+		],
+		fields: { usage: { array: "TokenUsage" } }
+	},
+	StepStartedEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	StepFinishedEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ReasoningStartEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ReasoningMessageStartEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ReasoningMessageContentEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ReasoningMessageEndEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ReasoningMessageChunkEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId",
+			"messageId",
+			"delta"
+		],
+		fields: {}
+	},
+	ReasoningEndEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	ReasoningEncryptedValueEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"subagentRunId"
+		],
+		fields: {}
+	},
+	SubagentStartedEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"description",
+			"parentSubagentRunId",
+			"parentToolCallId",
+			"parentMessageId"
+		],
+		fields: {}
+	},
+	SubagentFinishedSuccessOutcome: {
+		optional: [],
+		fields: {}
+	},
+	SubagentFinishedSuspendedOutcome: {
+		optional: ["interruptIds"],
+		fields: {}
+	},
+	SubagentFinishedOutcome: {
+		discriminator: "type",
+		variants: {
+			success: "SubagentFinishedSuccessOutcome",
+			suspended: "SubagentFinishedSuspendedOutcome"
+		}
+	},
+	SubagentFinishedEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"result",
+			"outcome"
+		],
+		fields: { outcome: "SubagentFinishedOutcome" }
+	},
+	SubagentErrorEvent: {
+		optional: [
+			"timestamp",
+			"rawEvent",
+			"metadata",
+			"code"
+		],
+		fields: {}
+	},
+	Event: {
+		discriminator: "type",
+		variants: {
+			TEXT_MESSAGE_START: "TextMessageStartEvent",
+			TEXT_MESSAGE_CONTENT: "TextMessageContentEvent",
+			TEXT_MESSAGE_END: "TextMessageEndEvent",
+			TEXT_MESSAGE_CHUNK: "TextMessageChunkEvent",
+			TOOL_CALL_START: "ToolCallStartEvent",
+			TOOL_CALL_ARGS: "ToolCallArgsEvent",
+			TOOL_CALL_END: "ToolCallEndEvent",
+			TOOL_CALL_CHUNK: "ToolCallChunkEvent",
+			TOOL_CALL_RESULT: "ToolCallResultEvent",
+			STATE_SNAPSHOT: "StateSnapshotEvent",
+			STATE_DELTA: "StateDeltaEvent",
+			MESSAGES_SNAPSHOT: "MessagesSnapshotEvent",
+			ACTIVITY_SNAPSHOT: "ActivitySnapshotEvent",
+			ACTIVITY_DELTA: "ActivityDeltaEvent",
+			RAW: "RawEvent",
+			CUSTOM: "CustomEvent",
+			RUN_STARTED: "RunStartedEvent",
+			RUN_FINISHED: "RunFinishedEvent",
+			RUN_ERROR: "RunErrorEvent",
+			STEP_STARTED: "StepStartedEvent",
+			STEP_FINISHED: "StepFinishedEvent",
+			REASONING_START: "ReasoningStartEvent",
+			REASONING_MESSAGE_START: "ReasoningMessageStartEvent",
+			REASONING_MESSAGE_CONTENT: "ReasoningMessageContentEvent",
+			REASONING_MESSAGE_END: "ReasoningMessageEndEvent",
+			REASONING_MESSAGE_CHUNK: "ReasoningMessageChunkEvent",
+			REASONING_END: "ReasoningEndEvent",
+			REASONING_ENCRYPTED_VALUE: "ReasoningEncryptedValueEvent",
+			SUBAGENT_STARTED: "SubagentStartedEvent",
+			SUBAGENT_FINISHED: "SubagentFinishedEvent",
+			SUBAGENT_ERROR: "SubagentErrorEvent"
+		}
+	},
+	SubagentInfo: {
+		optional: ["description"],
+		fields: {}
+	},
+	IdentityCapabilities: {
+		optional: [
+			"name",
+			"type",
+			"description",
+			"version",
+			"provider",
+			"documentationUrl",
+			"metadata"
+		],
+		fields: {}
+	},
+	TransportCapabilities: {
+		optional: [
+			"streaming",
+			"websocket",
+			"httpBinary",
+			"pushNotifications",
+			"resumable"
+		],
+		fields: {}
+	},
+	ToolsCapabilities: {
+		optional: [
+			"supported",
+			"items",
+			"parallelCalls",
+			"clientProvided"
+		],
+		fields: { items: { array: "Tool" } }
+	},
+	OutputCapabilities: {
+		optional: ["structuredOutput", "supportedMimeTypes"],
+		fields: {}
+	},
+	StateCapabilities: {
+		optional: [
+			"snapshots",
+			"deltas",
+			"memory",
+			"persistentState"
+		],
+		fields: {}
+	},
+	MultiAgentCapabilities: {
+		optional: [
+			"supported",
+			"delegation",
+			"handoffs",
+			"subagents"
+		],
+		fields: { subagents: { array: "SubagentInfo" } }
+	},
+	ReasoningCapabilities: {
+		optional: [
+			"supported",
+			"streaming",
+			"encrypted"
+		],
+		fields: {}
+	},
+	MultimodalInputCapabilities: {
+		optional: [
+			"image",
+			"audio",
+			"video",
+			"pdf",
+			"file"
+		],
+		fields: {}
+	},
+	MultimodalOutputCapabilities: {
+		optional: ["image", "audio"],
+		fields: {}
+	},
+	MultimodalCapabilities: {
+		optional: ["input", "output"],
+		fields: {
+			input: "MultimodalInputCapabilities",
+			output: "MultimodalOutputCapabilities"
+		}
+	},
+	ExecutionCapabilities: {
+		optional: [
+			"codeExecution",
+			"sandboxed",
+			"maxIterations",
+			"maxExecutionTime"
+		],
+		fields: {}
+	},
+	HumanInTheLoopCapabilities: {
+		optional: [
+			"supported",
+			"approvals",
+			"interventions",
+			"feedback",
+			"interrupts",
+			"approveWithEdits"
+		],
+		fields: {}
+	},
+	AgentCapabilities: {
+		optional: [
+			"identity",
+			"transport",
+			"tools",
+			"output",
+			"state",
+			"multiAgent",
+			"reasoning",
+			"multimodal",
+			"execution",
+			"humanInTheLoop",
+			"custom"
+		],
+		fields: {
+			identity: "IdentityCapabilities",
+			transport: "TransportCapabilities",
+			tools: "ToolsCapabilities",
+			output: "OutputCapabilities",
+			state: "StateCapabilities",
+			multiAgent: "MultiAgentCapabilities",
+			reasoning: "ReasoningCapabilities",
+			multimodal: "MultimodalCapabilities",
+			execution: "ExecutionCapabilities",
+			humanInTheLoop: "HumanInTheLoopCapabilities"
+		}
+	}
+};
+function omit(value, shape) {
+	if (typeof shape === "string") return omit(value, shapes[shape]);
+	if ("array" in shape) {
+		if (!Array.isArray(value)) return value;
+		const result = value.map((item) => omit(item, shape.array));
+		return result.every((item, index) => item === value[index]) ? value : result;
+	}
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+	const object = value;
+	if ("discriminator" in shape) {
+		const tag = object[shape.discriminator];
+		return typeof tag === "string" && Object.prototype.hasOwnProperty.call(shape.variants, tag) ? omit(value, shape.variants[tag]) : value;
+	}
+	let result = object;
+	for (const key of shape.optional) if (Object.prototype.hasOwnProperty.call(object, key) && object[key] === null) {
+		if (result === object) result = { ...object };
+		delete result[key];
+	}
+	for (const [key, child] of Object.entries(shape.fields)) {
+		if (!Object.prototype.hasOwnProperty.call(result, key)) continue;
+		const next = omit(result[key], child);
+		if (next !== result[key]) {
+			if (result === object) result = { ...object };
+			result[key] = next;
+		}
+	}
+	return result;
+}
+/**
+* Omits whole optional null fields before transmission. Does not validate,
+* mutate the input, or traverse arbitrary application JSON or unknown fields.
+* Required null payloads and null values inside opaque data remain intact.
+*/
+function omitOptionalNulls(value, root) {
+	return omit(value, root);
+}
+
+//#endregion
+//#region src/compat.ts
+var AGUIError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
+var AGUIConnectNotImplementedError = class extends AGUIError {
+	constructor() {
+		super("Connect not implemented. This method is not supported by the current agent.");
+	}
+};
+
+//#endregion
 //#region src/metadata.ts
 /**
 * The key reserved for AG-UI's own use inside a metadata object. Every other
@@ -24,32 +805,15 @@ const AGUI_METADATA_KEY = "ag-ui";
 * every value on every event, on the streaming hot path, to catch a mistake
 * (a function, a bigint) that already fails loudly at encode time.
 *
-* One consequence worth knowing: `z.record` drops an own `__proto__` key, which
-* is its prototype-pollution guard. Preserving it would need null-prototype
-* objects throughout parsing and protobuf conversion, handing every consumer
-* objects where `hasOwnProperty` throws — a real cost for a key that is
-* essentially only ever an attack probe. Python keeps it; TypeScript does not.
+* The schema itself now lives in the generated source (MetadataSchema in
+* src/generated/schemas.ts); this comment survives as the recorded reasoning.
 */
-const MetadataSchema = z.record(z.any());
 /**
-* 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.
-*
-* This is deliberately NOT the treatment `parentMessageId` and `outcome`
-* receive in `events.ts`. Those tolerate `null` because released producers
-* emitted it before the producer-side omission fix, and rejecting it would
-* break agents already in the wild. Metadata has no such history: it postdates
-* the fix that makes every official producer omit fields with no value, and no
-* released Python or .NET package has ever emitted `"metadata": null`. Adding
-* a tolerance here would grandfather in a fourth exception with nobody to
-* protect; enforcing from day one means there is never anything to retire.
-*
-* 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.
+* How metadata is declared on events and messages: the object is absent or an
+* object, never `null`. The validator pinning that invariant is
+* `OptionalMetadataSchema`, which lives in src/schemas.ts along with every
+* other runtime validator this package ships.
 */
-const OptionalMetadataSchema = MetadataSchema.optional();
 /**
 * Folds `incoming` metadata into `existing`, key by key, with the last write
 * winning.
@@ -76,712 +840,31 @@ function mergeMetadata(existing, incoming) {
 }
 
 //#endregion
-//#region src/types.ts
-const FunctionCallSchema = z.object({
-	name: z.string(),
-	arguments: z.string()
-});
-const ToolCallSchema = z.object({
-	id: z.string(),
-	type: z.literal("function"),
-	function: FunctionCallSchema,
-	encryptedValue: z.string().optional(),
-	metadata: OptionalMetadataSchema
-});
-const BaseMessageSchema = z.object({
-	id: z.string(),
-	role: z.string(),
-	content: z.string().optional(),
-	name: z.string().optional(),
-	encryptedValue: z.string().optional(),
-	subagentRunId: z.string().optional(),
-	metadata: OptionalMetadataSchema
-});
-const TextInputContentSchema = z.object({
-	type: z.literal("text"),
-	text: z.string()
-});
-const InputContentDataSourceSchema = z.object({
-	type: z.literal("data"),
-	value: z.string(),
-	mimeType: z.string()
-});
-const InputContentUrlSourceSchema = z.object({
-	type: z.literal("url"),
-	value: z.string(),
-	mimeType: z.string().optional()
-});
-const InputContentSourceSchema = z.discriminatedUnion("type", [InputContentDataSourceSchema, InputContentUrlSourceSchema]);
-const ImageInputContentSchema = z.object({
-	type: z.literal("image"),
-	source: InputContentSourceSchema,
-	metadata: z.unknown().optional()
-});
-const AudioInputContentSchema = z.object({
-	type: z.literal("audio"),
-	source: InputContentSourceSchema,
-	metadata: z.unknown().optional()
-});
-const VideoInputContentSchema = z.object({
-	type: z.literal("video"),
-	source: InputContentSourceSchema,
-	metadata: z.unknown().optional()
-});
-const DocumentInputContentSchema = z.object({
-	type: z.literal("document"),
-	source: InputContentSourceSchema,
-	metadata: z.unknown().optional()
-});
-const ImageInputPartSchema = ImageInputContentSchema;
-const AudioInputPartSchema = AudioInputContentSchema;
-const VideoInputPartSchema = VideoInputContentSchema;
-const DocumentInputPartSchema = DocumentInputContentSchema;
-const LegacyBinaryInputContentObjectSchema = z.object({
-	type: z.literal("binary"),
-	mimeType: z.string(),
-	id: z.string().optional(),
-	url: z.string().optional(),
-	data: z.string().optional(),
-	filename: z.string().optional()
-});
-const ensureBinaryPayload = (value, ctx) => {
-	if (!value.id && !value.url && !value.data) ctx.addIssue({
-		code: z.ZodIssueCode.custom,
-		message: "BinaryInputContent requires at least one of id, url, or data.",
-		path: ["id"]
-	});
-};
-const BinaryInputContentSchema = LegacyBinaryInputContentObjectSchema.superRefine((value, ctx) => {
-	ensureBinaryPayload(value, ctx);
-});
-const InputContentBaseSchema = z.discriminatedUnion("type", [
-	TextInputContentSchema,
-	ImageInputContentSchema,
-	AudioInputContentSchema,
-	VideoInputContentSchema,
-	DocumentInputContentSchema,
-	LegacyBinaryInputContentObjectSchema
-]);
-const InputContentSchema = InputContentBaseSchema.superRefine((value, ctx) => {
-	if (value.type === "binary") ensureBinaryPayload(value, ctx);
-});
-const DeveloperMessageSchema = BaseMessageSchema.extend({
-	role: z.literal("developer"),
-	content: z.string()
-});
-const SystemMessageSchema = BaseMessageSchema.extend({
-	role: z.literal("system"),
-	content: z.string()
-});
-const AssistantMessageSchema = BaseMessageSchema.extend({
-	role: z.literal("assistant"),
-	content: z.string().optional(),
-	toolCalls: z.array(ToolCallSchema).optional()
-});
-const UserMessageSchema = BaseMessageSchema.extend({
-	role: z.literal("user"),
-	content: z.union([z.string(), z.array(InputContentSchema)])
-});
-const ToolMessageSchema = z.object({
-	id: z.string(),
-	content: z.string(),
-	role: z.literal("tool"),
-	toolCallId: z.string(),
-	error: z.string().optional(),
-	encryptedValue: z.string().optional(),
-	subagentRunId: z.string().optional(),
-	metadata: OptionalMetadataSchema
-});
-const ActivityMessageSchema = z.object({
-	id: z.string(),
-	role: z.literal("activity"),
-	activityType: z.string(),
-	content: z.record(z.any()),
-	subagentRunId: z.string().optional(),
-	metadata: OptionalMetadataSchema
-});
-const ReasoningMessageSchema = z.object({
-	id: z.string(),
-	role: z.literal("reasoning"),
-	content: z.string(),
-	encryptedValue: z.string().optional(),
-	subagentRunId: z.string().optional(),
-	metadata: OptionalMetadataSchema
-});
-const MessageSchema = z.discriminatedUnion("role", [
-	DeveloperMessageSchema,
-	SystemMessageSchema,
-	AssistantMessageSchema,
-	UserMessageSchema,
-	ToolMessageSchema,
-	ActivityMessageSchema,
-	ReasoningMessageSchema
-]);
-const RoleSchema = z.union([
-	z.literal("developer"),
-	z.literal("system"),
-	z.literal("assistant"),
-	z.literal("user"),
-	z.literal("tool"),
-	z.literal("activity"),
-	z.literal("reasoning")
-]);
-const ContextSchema = z.object({
-	description: z.string(),
-	value: z.string()
-});
-const ToolSchema = z.object({
-	name: z.string(),
-	description: z.string(),
-	parameters: z.any(),
-	metadata: z.record(z.any()).optional()
-});
-const InterruptSchema = z.object({
-	id: z.string(),
-	reason: z.string(),
-	message: z.string().optional(),
-	toolCallId: z.string().optional(),
-	responseSchema: z.record(z.any()).optional(),
-	expiresAt: z.string().optional(),
-	metadata: z.record(z.any()).optional(),
-	subagentRunId: z.string().optional()
-});
-const ResumeEntrySchema = z.object({
-	interruptId: z.string(),
-	status: z.enum(["resolved", "cancelled"]),
-	payload: z.any().optional(),
-	metadata: OptionalMetadataSchema
-});
-const RunAgentInputSchema = z.object({
-	threadId: z.string(),
-	runId: z.string(),
-	parentRunId: z.string().optional(),
-	state: z.any().transform((v) => v ?? void 0),
-	messages: z.array(MessageSchema),
-	tools: z.array(ToolSchema),
-	context: z.array(ContextSchema),
-	forwardedProps: z.any(),
-	resume: z.array(ResumeEntrySchema).optional()
-});
-const StateSchema = z.any();
-var AGUIError = class extends Error {
-	constructor(message) {
-		super(message);
-	}
-};
-var AGUIConnectNotImplementedError = class extends AGUIError {
-	constructor() {
-		super("Connect not implemented. This method is not supported by the current agent.");
-	}
-};
-
-//#endregion
-//#region src/capabilities.ts
-/** Describes a sub-agent that can be invoked by a parent agent. */
-const SubAgentInfoSchema = z.object({
-	name: z.string(),
-	description: z.string().optional()
-});
-/**
-* 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 = z.object({
-	name: z.string().optional(),
-	type: z.string().optional(),
-	description: z.string().optional(),
-	version: z.string().optional(),
-	provider: z.string().optional(),
-	documentationUrl: z.string().optional(),
-	metadata: z.record(z.unknown()).optional()
-});
-/**
-* 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 = z.object({
-	streaming: z.boolean().optional(),
-	websocket: z.boolean().optional(),
-	httpBinary: z.boolean().optional(),
-	pushNotifications: z.boolean().optional(),
-	resumable: z.boolean().optional()
-});
-/**
-* 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 = z.object({
-	supported: z.boolean().optional(),
-	items: z.array(ToolSchema).optional(),
-	parallelCalls: z.boolean().optional(),
-	clientProvided: z.boolean().optional()
-});
-/**
-* Output format support. Enable `structuredOutput` when your agent can return
-* responses conforming to a JSON schema, which is useful for programmatic consumption.
-*/
-const OutputCapabilitiesSchema = z.object({
-	structuredOutput: z.boolean().optional(),
-	supportedMimeTypes: z.array(z.string()).optional()
-});
-/**
-* State and memory management capabilities. These tell the client how the agent
-* handles shared state and whether conversation context persists across runs.
-*/
-const StateCapabilitiesSchema = z.object({
-	snapshots: z.boolean().optional(),
-	deltas: z.boolean().optional(),
-	memory: z.boolean().optional(),
-	persistentState: z.boolean().optional()
-});
-/**
-* Multi-agent coordination capabilities. Enable these when your agent can
-* orchestrate or hand off work to other agents.
-*/
-const MultiAgentCapabilitiesSchema = z.object({
-	supported: z.boolean().optional(),
-	delegation: z.boolean().optional(),
-	handoffs: z.boolean().optional(),
-	subAgents: z.array(SubAgentInfoSchema).optional()
-});
-/**
-* Reasoning and thinking capabilities. Enable these when your agent exposes its
-* internal thought process (e.g., chain-of-thought, extended thinking).
-*/
-const ReasoningCapabilitiesSchema = z.object({
-	supported: z.boolean().optional(),
-	streaming: z.boolean().optional(),
-	encrypted: z.boolean().optional()
-});
-/**
-* Modalities the agent can accept as input. Clients use this to show/hide
-* file upload buttons, audio recorders, image pickers, etc.
-*/
-const MultimodalInputCapabilitiesSchema = z.object({
-	image: z.boolean().optional(),
-	audio: z.boolean().optional(),
-	video: z.boolean().optional(),
-	pdf: z.boolean().optional(),
-	file: z.boolean().optional()
-});
-/**
-* Modalities the agent can produce as output. Clients use this to anticipate
-* rich content in the agent's response.
-*/
-const MultimodalOutputCapabilitiesSchema = z.object({
-	image: z.boolean().optional(),
-	audio: z.boolean().optional()
-});
-/**
-* 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 = z.object({
-	input: MultimodalInputCapabilitiesSchema.optional(),
-	output: MultimodalOutputCapabilitiesSchema.optional()
-});
-/**
-* 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 = z.object({
-	codeExecution: z.boolean().optional(),
-	sandboxed: z.boolean().optional(),
-	maxIterations: z.number().optional(),
-	maxExecutionTime: z.number().optional()
-});
-/**
-* 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 = z.object({
-	supported: z.boolean().optional(),
-	approvals: z.boolean().optional(),
-	interventions: z.boolean().optional(),
-	feedback: z.boolean().optional(),
-	interrupts: z.boolean().optional(),
-	approveWithEdits: z.boolean().optional()
-});
-/**
-* A typed, categorized snapshot of an agent's current capabilities.
-* Returned by `getCapabilities()` on `AbstractAgent`.
-*
-* All fields are optional — agents only declare what they support.
-* Omitted fields mean the capability is not declared (unknown), not that
-* it's unsupported.
-*
-* The `custom` field is an escape hatch for integration-specific capabilities
-* that don't fit into the standard categories.
-*/
-const AgentCapabilitiesSchema = z.object({
-	identity: IdentityCapabilitiesSchema.optional(),
-	transport: TransportCapabilitiesSchema.optional(),
-	tools: ToolsCapabilitiesSchema.optional(),
-	output: OutputCapabilitiesSchema.optional(),
-	state: StateCapabilitiesSchema.optional(),
-	multiAgent: MultiAgentCapabilitiesSchema.optional(),
-	reasoning: ReasoningCapabilitiesSchema.optional(),
-	multimodal: MultimodalCapabilitiesSchema.optional(),
-	execution: ExecutionCapabilitiesSchema.optional(),
-	humanInTheLoop: HumanInTheLoopCapabilitiesSchema.optional(),
-	custom: z.record(z.unknown()).optional()
-});
-
-//#endregion
-//#region src/events.ts
-const TextMessageRoleSchema = z.union([
-	z.literal("developer"),
-	z.literal("system"),
-	z.literal("assistant"),
-	z.literal("user")
-]);
-let EventType = /* @__PURE__ */ function(EventType) {
-	EventType["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
-	EventType["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
-	EventType["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
-	EventType["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
-	EventType["TOOL_CALL_START"] = "TOOL_CALL_START";
-	EventType["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
-	EventType["TOOL_CALL_END"] = "TOOL_CALL_END";
-	EventType["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
-	EventType["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
-	/**
-	* @deprecated Use REASONING_START instead. Will be removed in 1.0.0.
-	*/
-	EventType["THINKING_START"] = "THINKING_START";
-	/**
-	* @deprecated Use REASONING_END instead. Will be removed in 1.0.0.
-	*/
-	EventType["THINKING_END"] = "THINKING_END";
-	/**
-	* @deprecated Use REASONING_MESSAGE_START instead. Will be removed in 1.0.0.
-	*/
-	EventType["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
-	/**
-	* @deprecated Use REASONING_MESSAGE_CONTENT instead. Will be removed in 1.0.0.
-	*/
-	EventType["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
-	/**
-	* @deprecated Use REASONING_MESSAGE_END instead. Will be removed in 1.0.0.
-	*/
-	EventType["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
-	EventType["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
-	EventType["STATE_DELTA"] = "STATE_DELTA";
-	EventType["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
-	EventType["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
-	EventType["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
-	EventType["RAW"] = "RAW";
-	EventType["CUSTOM"] = "CUSTOM";
-	EventType["RUN_STARTED"] = "RUN_STARTED";
-	EventType["RUN_FINISHED"] = "RUN_FINISHED";
-	EventType["RUN_ERROR"] = "RUN_ERROR";
-	EventType["STEP_STARTED"] = "STEP_STARTED";
-	EventType["STEP_FINISHED"] = "STEP_FINISHED";
-	EventType["REASONING_START"] = "REASONING_START";
-	EventType["REASONING_MESSAGE_START"] = "REASONING_MESSAGE_START";
-	EventType["REASONING_MESSAGE_CONTENT"] = "REASONING_MESSAGE_CONTENT";
-	EventType["REASONING_MESSAGE_END"] = "REASONING_MESSAGE_END";
-	EventType["REASONING_MESSAGE_CHUNK"] = "REASONING_MESSAGE_CHUNK";
-	EventType["REASONING_END"] = "REASONING_END";
-	EventType["REASONING_ENCRYPTED_VALUE"] = "REASONING_ENCRYPTED_VALUE";
-	EventType["SUBAGENT_STARTED"] = "SUBAGENT_STARTED";
-	EventType["SUBAGENT_FINISHED"] = "SUBAGENT_FINISHED";
-	EventType["SUBAGENT_ERROR"] = "SUBAGENT_ERROR";
-	return EventType;
-}({});
-const BaseEventSchema = z.object({
-	type: z.nativeEnum(EventType),
-	timestamp: z.number().optional(),
-	rawEvent: z.any().optional(),
-	metadata: OptionalMetadataSchema
-}).passthrough();
-const TextMessageStartEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TEXT_MESSAGE_START),
-	messageId: z.string(),
-	role: TextMessageRoleSchema.default("assistant"),
-	name: z.string().optional(),
-	subagentRunId: z.string().optional()
-});
-const TextMessageContentEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TEXT_MESSAGE_CONTENT),
-	messageId: z.string(),
-	delta: z.string(),
-	subagentRunId: z.string().optional()
-});
-const TextMessageEndEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TEXT_MESSAGE_END),
-	messageId: z.string(),
-	subagentRunId: z.string().optional()
-});
-const TextMessageChunkEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TEXT_MESSAGE_CHUNK),
-	messageId: z.string().optional(),
-	role: TextMessageRoleSchema.optional(),
-	delta: z.string().optional(),
-	name: z.string().optional(),
-	subagentRunId: z.string().optional()
-});
-/**
-* @deprecated Use ReasoningMessageStartEventSchema instead. Will be removed in 1.0.0.
-*/
-const ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({ type: z.literal(EventType.THINKING_TEXT_MESSAGE_START) });
-/**
-* @deprecated Use ReasoningMessageContentEventSchema instead. Will be removed in 1.0.0.
-*/
-const ThinkingTextMessageContentEventSchema = TextMessageContentEventSchema.omit({
-	messageId: true,
-	type: true,
-	subagentRunId: true
-}).extend({ type: z.literal(EventType.THINKING_TEXT_MESSAGE_CONTENT) });
-/**
-* @deprecated Use ReasoningMessageEndEventSchema instead. Will be removed in 1.0.0.
-*/
-const ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({ type: z.literal(EventType.THINKING_TEXT_MESSAGE_END) });
-const ToolCallStartEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TOOL_CALL_START),
-	toolCallId: z.string(),
-	toolCallName: z.string(),
-	parentMessageId: z.string().nullable().optional().transform((v) => v ?? void 0),
-	subagentRunId: z.string().optional()
-});
-const ToolCallArgsEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TOOL_CALL_ARGS),
-	toolCallId: z.string(),
-	delta: z.string(),
-	subagentRunId: z.string().optional()
-});
-const ToolCallEndEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TOOL_CALL_END),
-	toolCallId: z.string(),
-	subagentRunId: z.string().optional()
-});
-const ToolCallResultEventSchema = BaseEventSchema.extend({
-	messageId: z.string(),
-	type: z.literal(EventType.TOOL_CALL_RESULT),
-	toolCallId: z.string(),
-	content: z.string(),
-	role: z.literal("tool").optional(),
-	subagentRunId: z.string().optional()
-});
-const ToolCallChunkEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.TOOL_CALL_CHUNK),
-	toolCallId: z.string().optional(),
-	toolCallName: z.string().optional(),
-	parentMessageId: z.string().nullable().optional().transform((v) => v ?? void 0),
-	delta: z.string().optional(),
-	subagentRunId: z.string().optional()
-});
-/**
-* @deprecated Use ReasoningStartEventSchema instead. Will be removed in 1.0.0.
-*/
-const ThinkingStartEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.THINKING_START),
-	title: z.string().optional()
-});
+//#region src/token-usage.ts
+/** The AG-UI names of the six token counts, in the order an entry lists them. */
+const COUNT_KEYS = [
+	"inputTokens",
+	"outputTokens",
+	"totalTokens",
+	"reasoningTokens",
+	"cachedInputTokens",
+	"cacheWriteInputTokens"
+];
 /**
-* @deprecated Use ReasoningEndEventSchema instead. Will be removed in 1.0.0.
+* The count keys already warned about, so the diagnostic below fires once per
+* process per key rather than once per event. A provider that hands over a
+* string count hands one over on every call, and a per-call warning would bury
+* the stream it is meant to annotate.
 */
-const ThinkingEndEventSchema = BaseEventSchema.extend({ type: z.literal(EventType.THINKING_END) });
-const StateSnapshotEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.STATE_SNAPSHOT),
-	snapshot: StateSchema,
-	subagentRunId: z.string().optional()
-});
-const StateDeltaEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.STATE_DELTA),
-	delta: z.array(z.any()),
-	subagentRunId: z.string().optional()
-});
-const MessagesSnapshotEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.MESSAGES_SNAPSHOT),
-	messages: z.array(MessageSchema)
-});
-const ActivitySnapshotEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.ACTIVITY_SNAPSHOT),
-	messageId: z.string(),
-	activityType: z.string(),
-	content: z.record(z.any()),
-	replace: z.boolean().optional().default(true),
-	subagentRunId: z.string().optional()
-});
-const ActivityDeltaEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.ACTIVITY_DELTA),
-	messageId: z.string(),
-	activityType: z.string(),
-	patch: z.array(z.any()),
-	subagentRunId: z.string().optional()
-});
-const RawEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.RAW),
-	event: z.any(),
-	source: z.string().optional(),
-	subagentRunId: z.string().optional()
-});
-const CustomEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.CUSTOM),
-	name: z.string(),
-	value: z.any(),
-	subagentRunId: z.string().optional()
-});
-const RunStartedEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.RUN_STARTED),
-	threadId: z.string(),
-	runId: z.string(),
-	parentRunId: z.string().optional(),
-	input: RunAgentInputSchema.optional()
-});
-const RunFinishedSuccessOutcomeSchema = z.object({ type: z.literal("success") }).strict();
-const RunFinishedInterruptOutcomeSchema = z.object({
-	type: z.literal("interrupt"),
-	interrupts: z.array(InterruptSchema).min(1)
-}).strict();
-const RunFinishedOutcomeSchema = z.discriminatedUnion("type", [RunFinishedSuccessOutcomeSchema, RunFinishedInterruptOutcomeSchema]);
-const TokenUsageSchema = z.object({
-	provider: z.string().optional(),
-	model: z.string().optional(),
-	inputTokens: z.number().int().nonnegative().optional(),
-	outputTokens: z.number().int().nonnegative().optional(),
-	totalTokens: z.number().int().nonnegative().optional(),
-	reasoningTokens: z.number().int().nonnegative().optional(),
-	cachedInputTokens: z.number().int().nonnegative().optional()
-});
-const RunFinishedEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.RUN_FINISHED),
-	threadId: z.string(),
-	runId: z.string(),
-	result: z.any().optional(),
-	outcome: RunFinishedOutcomeSchema.nullable().optional().transform((v) => v ?? void 0),
-	usage: z.array(TokenUsageSchema).optional()
-});
-const RunErrorEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.RUN_ERROR),
-	message: z.string(),
-	code: z.string().optional(),
-	usage: z.array(TokenUsageSchema).optional()
-});
-const StepStartedEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.STEP_STARTED),
-	stepName: z.string(),
-	subagentRunId: z.string().optional()
-});
-const StepFinishedEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.STEP_FINISHED),
-	stepName: z.string(),
-	subagentRunId: z.string().optional()
-});
-const ReasoningEncryptedValueSubtypeSchema = z.union([z.literal("tool-call"), z.literal("message")]);
-const ReasoningStartEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.REASONING_START),
-	messageId: z.string(),
-	subagentRunId: z.string().optional()
-});
-const ReasoningMessageStartEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.REASONING_MESSAGE_START),
-	messageId: z.string(),
-	role: z.literal("reasoning"),
-	subagentRunId: z.string().optional()
-});
-const ReasoningMessageContentEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.REASONING_MESSAGE_CONTENT),
-	messageId: z.string(),
-	delta: z.string(),
-	subagentRunId: z.string().optional()
-});
-const ReasoningMessageEndEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.REASONING_MESSAGE_END),
-	messageId: z.string(),
-	subagentRunId: z.string().optional()
-});
-const ReasoningMessageChunkEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.REASONING_MESSAGE_CHUNK),
-	messageId: z.string().optional(),
-	delta: z.string().optional(),
-	subagentRunId: z.string().optional()
-});
-const ReasoningEndEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.REASONING_END),
-	messageId: z.string(),
-	subagentRunId: z.string().optional()
-});
-const ReasoningEncryptedValueEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.REASONING_ENCRYPTED_VALUE),
-	subtype: ReasoningEncryptedValueSubtypeSchema,
-	entityId: z.string(),
-	encryptedValue: z.string(),
-	subagentRunId: z.string().optional()
-});
-const SubagentStartedEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.SUBAGENT_STARTED),
-	subagentRunId: z.string(),
-	name: z.string(),
-	description: z.string().optional(),
-	parentSubagentRunId: z.string().optional(),
-	parentToolCallId: z.string().optional(),
-	parentMessageId: z.string().optional()
-});
-const SubagentFinishedSuccessOutcomeSchema = z.object({ type: z.literal("success") }).strict();
-const SubagentFinishedSuspendedOutcomeSchema = z.object({
-	type: z.literal("suspended"),
-	interruptIds: z.array(z.string()).optional()
-}).strict();
-const SubagentFinishedOutcomeSchema = z.discriminatedUnion("type", [SubagentFinishedSuccessOutcomeSchema, SubagentFinishedSuspendedOutcomeSchema]);
-const SubagentFinishedEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.SUBAGENT_FINISHED),
-	subagentRunId: z.string(),
-	result: z.any().optional(),
-	outcome: SubagentFinishedOutcomeSchema.optional()
-});
-const SubagentErrorEventSchema = BaseEventSchema.extend({
-	type: z.literal(EventType.SUBAGENT_ERROR),
-	subagentRunId: z.string(),
-	message: z.string(),
-	code: z.string().optional()
-});
-const EventSchemas = z.discriminatedUnion("type", [
-	TextMessageStartEventSchema,
-	TextMessageContentEventSchema,
-	TextMessageEndEventSchema,
-	TextMessageChunkEventSchema,
-	ThinkingStartEventSchema,
-	ThinkingEndEventSchema,
-	ThinkingTextMessageStartEventSchema,
-	ThinkingTextMessageContentEventSchema,
-	ThinkingTextMessageEndEventSchema,
-	ToolCallStartEventSchema,
-	ToolCallArgsEventSchema,
-	ToolCallEndEventSchema,
-	ToolCallChunkEventSchema,
-	ToolCallResultEventSchema,
-	StateSnapshotEventSchema,
-	StateDeltaEventSchema,
-	MessagesSnapshotEventSchema,
-	ActivitySnapshotEventSchema,
-	ActivityDeltaEventSchema,
-	RawEventSchema,
-	CustomEventSchema,
-	RunStartedEventSchema,
-	RunFinishedEventSchema,
-	RunErrorEventSchema,
-	StepStartedEventSchema,
-	StepFinishedEventSchema,
-	ReasoningStartEventSchema,
-	ReasoningMessageStartEventSchema,
-	ReasoningMessageContentEventSchema,
-	ReasoningMessageEndEventSchema,
-	ReasoningMessageChunkEventSchema,
-	ReasoningEndEventSchema,
-	ReasoningEncryptedValueEventSchema,
-	SubagentStartedEventSchema,
-	SubagentFinishedEventSchema,
-	SubagentErrorEventSchema
-]);
-
-//#endregion
-//#region src/token-usage.ts
+const warnedCountKeys = /* @__PURE__ */ new Set();
+/** What the value WAS, said in a way that points at the provider's bug. */
+const describeRejected = (v) => {
+	if (v === null) return "null";
+	if (typeof v === "string") return `${JSON.stringify(v)} (a string)`;
+	if (typeof v === "number") return `${String(v)} (a non-finite number)`;
+	if (typeof v === "object") return `an object`;
+	return `${String(v)} (a ${typeof v})`;
+};
 /**
 * Accept a value only if it is a real, finite number.
 *
@@ -790,8 +873,28 @@ const EventSchemas = z.discriminatedUnion("type", [
 * not reach the wire: consumers validate every incoming event and throw on
 * failure, so one malformed count would fail an otherwise-successful run at its
 * final event — costing the user the answer, not just the token count.
+*
+* Dropping it is right; dropping it in silence is not. The usage this run
+* reports is then simply wrong, with nothing anywhere saying which count went
+* missing or why, so a present-but-unusable value is named once per key.
+*
+* `undefined` and `NaN` are exempt because they are not defects: they are how a
+* provider spells "did not report this count". `undefined` covers both shapes —
+* an absent key in LangChain's `usage_metadata`, an explicit `undefined` in
+* AI-SDK's `LanguageModelUsage` — and AI-SDK uses `NaN` for the same thing,
+* which is why its mapper's docstring says so. Warning on those would fire on
+* ordinary traffic and train the reader to ignore the message.
+*
+* `key` is the AG-UI count name the value was headed for, not the vendor's
+* spelling of it, so one message reads the same whichever mapper produced it.
 */
-const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+const num = (v, key) => {
+	if (typeof v === "number" && Number.isFinite(v)) return v;
+	if (!(v === void 0 || typeof v === "number" && Number.isNaN(v)) && !warnedCountKeys.has(key)) {
+		warnedCountKeys.add(key);
+		console.warn(`[ag-ui] usage.${key} was ${describeRejected(v)}, not a number — omitted from this run's usage. Reported once per key.`);
+	}
+};
 /**
 * Read a property from a value of unknown shape, yielding `undefined` for
 * anything that is not an object. Lets the mappers take `unknown` rather than
@@ -799,13 +902,6 @@ const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
 * rather than assumed.
 */
 const prop = (v, key) => typeof v === "object" && v !== null ? v[key] : void 0;
-const COUNT_KEYS = [
-	"inputTokens",
-	"outputTokens",
-	"totalTokens",
-	"reasoningTokens",
-	"cachedInputTokens"
-];
 /**
 * Build a {@link TokenUsage} from already-guarded counts, or `undefined` when no
 * count survived. Returning `undefined` rather than a labels-only entry keeps
@@ -827,43 +923,57 @@ function buildEntry(counts, { provider, model }) {
 * Map a LangChain-family `usage_metadata` object into an AG-UI {@link TokenUsage}.
 *
 * LangChain and LangGraph both attach usage as `{ input_tokens, output_tokens,
-* total_tokens, input_token_details: { cache_read }, output_token_details:
-* { reasoning } }`. This maps only those numeric counts plus optional
-* provider/model labels — never prompt/completion content. Returns `undefined`
-* when no usable count is present, so callers can omit usage rather than
-* report zeros.
+* total_tokens, input_token_details: { cache_read, cache_creation },
+* output_token_details: { reasoning } }`. LangChain's accounting is the
+* protocol's — `input_tokens` already includes the cache details and
+* `output_tokens` the reasoning detail — so every count passes through as is.
+* This maps only those numeric counts plus optional provider/model labels —
+* never prompt/completion content. A count the provider
+* did not return is simply absent from `usage_metadata` and reads as
+* `undefined` here; that is not a defect and draws no warning. Returns
+* `undefined` when no usable count is present, so callers can omit usage rather
+* than report zeros.
 */
 function tokenUsageFromLangChainMetadata(usageMetadata, { provider, model }) {
 	if (!usageMetadata) return void 0;
 	const inputDetails = prop(usageMetadata, "input_token_details");
 	const outputDetails = prop(usageMetadata, "output_token_details");
 	return buildEntry({
-		inputTokens: num(prop(usageMetadata, "input_tokens")),
-		outputTokens: num(prop(usageMetadata, "output_tokens")),
-		totalTokens: num(prop(usageMetadata, "total_tokens")),
-		reasoningTokens: num(prop(outputDetails, "reasoning")),
-		cachedInputTokens: num(prop(inputDetails, "cache_read"))
+		inputTokens: num(prop(usageMetadata, "input_tokens"), "inputTokens"),
+		outputTokens: num(prop(usageMetadata, "output_tokens"), "outputTokens"),
+		totalTokens: num(prop(usageMetadata, "total_tokens"), "totalTokens"),
+		reasoningTokens: num(prop(outputDetails, "reasoning"), "reasoningTokens"),
+		cachedInputTokens: num(prop(inputDetails, "cache_read"), "cachedInputTokens"),
+		cacheWriteInputTokens: num(prop(inputDetails, "cache_creation"), "cacheWriteInputTokens")
 	}, {
 		provider,
 		model
 	});
 }
 /**
-* Map an AI-SDK (v5) `LanguageModelUsage` object into an AG-UI {@link TokenUsage}.
+* Map an AI-SDK `LanguageModelUsage` object into an AG-UI {@link TokenUsage}.
 *
-* AI-SDK's keys already match: `inputTokens`, `outputTokens`, `totalTokens`,
-* `reasoningTokens`, `cachedInputTokens`. AI-SDK reports `NaN`/`undefined` for
-* counts a provider didn't return, so only finite numbers are copied. Returns
-* `undefined` when no finite count is present (so callers omit empty usage).
+* AI-SDK's v5 keys already match — `inputTokens`, `outputTokens`,
+* `totalTokens`, `reasoningTokens`, `cachedInputTokens` — with the totals
+* inclusive the way the protocol counts them. v6 adds `inputTokenDetails:
+* { cacheReadTokens, cacheWriteTokens }` and `outputTokenDetails:
+* { reasoningTokens }`; the cache-write count exists only there, and the two
+* counts present in both forms are read from the top level first. AI-SDK
+* reports `NaN`/`undefined` for counts a provider didn't return, so only finite
+* numbers are copied. Returns `undefined` when no finite count is present (so
+* callers omit empty usage).
 */
 function tokenUsageFromAiSdkUsage(usage, { provider, model }) {
 	if (!usage) return void 0;
+	const inputDetails = prop(usage, "inputTokenDetails");
+	const outputDetails = prop(usage, "outputTokenDetails");
 	return buildEntry({
-		inputTokens: num(prop(usage, "inputTokens")),
-		outputTokens: num(prop(usage, "outputTokens")),
-		totalTokens: num(prop(usage, "totalTokens")),
-		reasoningTokens: num(prop(usage, "reasoningTokens")),
-		cachedInputTokens: num(prop(usage, "cachedInputTokens"))
+		inputTokens: num(prop(usage, "inputTokens"), "inputTokens"),
+		outputTokens: num(prop(usage, "outputTokens"), "outputTokens"),
+		totalTokens: num(prop(usage, "totalTokens"), "totalTokens"),
+		reasoningTokens: num(prop(usage, "reasoningTokens"), "reasoningTokens") ?? num(prop(outputDetails, "reasoningTokens"), "reasoningTokens"),
+		cachedInputTokens: num(prop(usage, "cachedInputTokens"), "cachedInputTokens") ?? num(prop(inputDetails, "cacheReadTokens"), "cachedInputTokens"),
+		cacheWriteInputTokens: num(prop(inputDetails, "cacheWriteTokens"), "cacheWriteInputTokens")
 	}, {
 		provider,
 		model
@@ -899,5 +1009,35 @@ function aggregateTokenUsage(entries) {
 }
 
 //#endregion
-export { AGUIConnectNotImplementedError, AGUIError, AGUI_METADATA_KEY, ActivityDeltaEventSchema, ActivityMessageSchema, ActivitySnapshotEventSchema, AgentCapabilitiesSchema, AssistantMessageSchema, AudioInputContentSchema, AudioInputPartSchema, BaseEventSchema, BaseMessageSchema, BinaryInputContentSchema, ContextSchema, CustomEventSchema, DeveloperMessageSchema, DocumentInputContentSchema, DocumentInputPartSchema, EventSchemas, EventType, ExecutionCapabilitiesSchema, FunctionCallSchema, HumanInTheLoopCapabilitiesSchema, IdentityCapabilitiesSchema, ImageInputContentSchema, ImageInputPartSchema, InputContentDataSourceSchema, InputContentSchema, InputContentSourceSchema, InputContentUrlSourceSchema, InterruptSchema, MessageSchema, MessagesSnapshotEventSchema, MetadataSchema, MultiAgentCapabilitiesSchema, MultimodalCapabilitiesSchema, MultimodalInputCapabilitiesSchema, MultimodalOutputCapabilitiesSchema, OptionalMetadataSchema, OutputCapabilitiesSchema, RawEventSchema, ReasoningCapabilitiesSchema, ReasoningEncryptedValueEventSchema, ReasoningEncryptedValueSubtypeSchema, ReasoningEndEventSchema, ReasoningMessageChunkEventSchema, ReasoningMessageContentEventSchema, ReasoningMessageEndEventSchema, ReasoningMessageSchema, ReasoningMessageStartEventSchema, ReasoningStartEventSchema, ResumeEntrySchema, RoleSchema, RunAgentInputSchema, RunErrorEventSchema, RunFinishedEventSchema, RunFinishedInterruptOutcomeSchema, RunFinishedOutcomeSchema, RunFinishedSuccessOutcomeSchema, RunStartedEventSchema, StateCapabilitiesSchema, StateDeltaEventSchema, StateSchema, StateSnapshotEventSchema, StepFinishedEventSchema, StepStartedEventSchema, SubAgentInfoSchema, SubagentErrorEventSchema, SubagentFinishedEventSchema, SubagentFinishedOutcomeSchema, SubagentFinishedSuccessOutcomeSchema, SubagentFinishedSuspendedOutcomeSchema, SubagentStartedEventSchema, SystemMessageSchema, TextInputContentSchema, TextMessageChunkEventSchema, TextMessageContentEventSchema, TextMessageEndEventSchema, TextMessageStartEventSchema, ThinkingEndEventSchema, ThinkingStartEventSchema, ThinkingTextMessageContentEventSchema, ThinkingTextMessageEndEventSchema, ThinkingTextMessageStartEventSchema, TokenUsageSchema, ToolCallArgsEventSchema, ToolCallChunkEventSchema, ToolCallEndEventSchema, ToolCallResultEventSchema, ToolCallSchema, ToolCallStartEventSchema, ToolMessageSchema, ToolSchema, ToolsCapabilitiesSchema, TransportCapabilitiesSchema, UserMessageSchema, VideoInputContentSchema, VideoInputPartSchema, aggregateTokenUsage, mergeMetadata, tokenUsageFromAiSdkUsage, tokenUsageFromLangChainMetadata };
+//#region src/content.ts
+/**
+* The text of string-or-parts content, for a consumer that can only hold a
+* string: the text parts concatenated in order, every other part dropped.
+*
+* This is the downgrade the specification permits for a peer that predates
+* content parts (/spec/draft/basic/versioning): it removes and reshapes, and
+* it invents nothing — no placeholder stands in for a dropped image, because a
+* downgrade MUST NOT supply a value the producer never sent. Content that is
+* entirely media flattens to the empty string, which the same rule allows.
+*
+* Losing content is never meant to be silent. This helper only reshapes; a
+* caller that knows it is talking to an older peer warns as well, the way the
+* era shims in `@ag-ui/client` do.
+*/
+function contentToText(content) {
+	if (content === void 0) return "";
+	if (typeof content === "string") return content;
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+/**
+* Whether string-or-parts content carries anything but text — the question a
+* caller asks before flattening, so it can warn about what the flattening
+* would drop.
+*/
+function contentHasMedia(content) {
+	return Array.isArray(content) && content.some((part) => part.type !== "text");
+}
+
+//#endregion
+export { AGUIConnectNotImplementedError, AGUIError, AGUI_METADATA_KEY, EventType, PROTOCOL_VERSION, aggregateTokenUsage, contentHasMedia, contentToText, mergeMetadata, omitOptionalNulls, tokenUsageFromAiSdkUsage, tokenUsageFromLangChainMetadata };
 //# sourceMappingURL=index.mjs.map