ag-ui-validate 0.1.0

package/dist/vitest.js

@@ -0,0 +1,2089 @@
+import { expect } from "vitest";
+//#region src/cli-args.ts
+function decideExitCode(summary, maxWarnings) {
+	if (summary.errors > 0) return 1;
+	if (maxWarnings !== void 0 && summary.warnings > maxWarnings) return 1;
+	return 0;
+}
+//#endregion
+//#region src/protocol/event-table.ts
+/** Version of @ag-ui/core this table was derived from. */
+const SDK_VERSION = "0.0.58";
+/** Canonical wire event types and their schemas, derived from @ag-ui/core. */
+const EVENT_TABLE = {
+	"TEXT_MESSAGE_START": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessagestart",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"role": {
+				kind: "string",
+				required: false,
+				enum: [
+					"developer",
+					"system",
+					"assistant",
+					"user"
+				]
+			},
+			"name": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TEXT_MESSAGE_CONTENT": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessagecontent",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"delta": {
+				kind: "string",
+				required: true
+			}
+		}
+	},
+	"TEXT_MESSAGE_END": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessageend",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"TEXT_MESSAGE_CHUNK": {
+		category: "text",
+		specUrl: "https://docs.ag-ui.com/concepts/events#textmessagechunk",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: false
+			},
+			"role": {
+				kind: "string",
+				required: false,
+				enum: [
+					"developer",
+					"system",
+					"assistant",
+					"user"
+				]
+			},
+			"delta": {
+				kind: "string",
+				required: false
+			},
+			"name": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TOOL_CALL_START": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallstart",
+		fields: {
+			"toolCallId": {
+				kind: "string",
+				required: true
+			},
+			"toolCallName": {
+				kind: "string",
+				required: true
+			},
+			"parentMessageId": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TOOL_CALL_ARGS": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallargs",
+		fields: {
+			"toolCallId": {
+				kind: "string",
+				required: true
+			},
+			"delta": {
+				kind: "string",
+				required: true
+			}
+		}
+	},
+	"TOOL_CALL_END": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallend",
+		fields: { "toolCallId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"TOOL_CALL_CHUNK": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallchunk",
+		fields: {
+			"toolCallId": {
+				kind: "string",
+				required: false
+			},
+			"toolCallName": {
+				kind: "string",
+				required: false
+			},
+			"parentMessageId": {
+				kind: "string",
+				required: false
+			},
+			"delta": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"TOOL_CALL_RESULT": {
+		category: "toolcall",
+		specUrl: "https://docs.ag-ui.com/concepts/events#toolcallresult",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"toolCallId": {
+				kind: "string",
+				required: true
+			},
+			"content": {
+				kind: "string",
+				required: true
+			},
+			"role": {
+				kind: "string",
+				required: false,
+				enum: ["tool"]
+			}
+		}
+	},
+	"THINKING_START": {
+		category: "thinking",
+		deprecated: "REASONING_START",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: { "title": {
+			kind: "string",
+			required: false
+		} }
+	},
+	"THINKING_END": {
+		category: "thinking",
+		deprecated: "REASONING_END",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: {}
+	},
+	"THINKING_TEXT_MESSAGE_START": {
+		category: "thinking",
+		deprecated: "REASONING_MESSAGE_START",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: {}
+	},
+	"THINKING_TEXT_MESSAGE_CONTENT": {
+		category: "thinking",
+		deprecated: "REASONING_MESSAGE_CONTENT",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: { "delta": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"THINKING_TEXT_MESSAGE_END": {
+		category: "thinking",
+		deprecated: "REASONING_MESSAGE_END",
+		specUrl: "https://docs.ag-ui.com/concepts/events#thinking-events-deprecated",
+		fields: {}
+	},
+	"STATE_SNAPSHOT": {
+		category: "state",
+		specUrl: "https://docs.ag-ui.com/concepts/events#statesnapshot",
+		fields: { "snapshot": {
+			kind: "any",
+			required: true
+		} }
+	},
+	"STATE_DELTA": {
+		category: "state",
+		specUrl: "https://docs.ag-ui.com/concepts/events#statedelta",
+		fields: { "delta": {
+			kind: "array",
+			required: true
+		} }
+	},
+	"MESSAGES_SNAPSHOT": {
+		category: "state",
+		specUrl: "https://docs.ag-ui.com/concepts/events#messagessnapshot",
+		fields: { "messages": {
+			kind: "array",
+			required: true
+		} }
+	},
+	"ACTIVITY_SNAPSHOT": {
+		category: "activity",
+		specUrl: "https://docs.ag-ui.com/concepts/events#activitysnapshot",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"activityType": {
+				kind: "string",
+				required: true
+			},
+			"content": {
+				kind: "object",
+				required: true
+			},
+			"replace": {
+				kind: "boolean",
+				required: false
+			}
+		}
+	},
+	"ACTIVITY_DELTA": {
+		category: "activity",
+		specUrl: "https://docs.ag-ui.com/concepts/events#activitydelta",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"activityType": {
+				kind: "string",
+				required: true
+			},
+			"patch": {
+				kind: "array",
+				required: true
+			}
+		}
+	},
+	"RAW": {
+		category: "special",
+		specUrl: "https://docs.ag-ui.com/concepts/events#raw",
+		fields: {
+			"event": {
+				kind: "any",
+				required: true
+			},
+			"source": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"CUSTOM": {
+		category: "special",
+		specUrl: "https://docs.ag-ui.com/concepts/events#custom",
+		fields: {
+			"name": {
+				kind: "string",
+				required: true
+			},
+			"value": {
+				kind: "any",
+				required: true
+			}
+		}
+	},
+	"RUN_STARTED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#runstarted",
+		fields: {
+			"threadId": {
+				kind: "string",
+				required: true
+			},
+			"runId": {
+				kind: "string",
+				required: true
+			},
+			"parentRunId": {
+				kind: "string",
+				required: false
+			},
+			"input": {
+				kind: "object",
+				required: false
+			}
+		}
+	},
+	"RUN_FINISHED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#runfinished",
+		fields: {
+			"threadId": {
+				kind: "string",
+				required: true
+			},
+			"runId": {
+				kind: "string",
+				required: true
+			},
+			"result": {
+				kind: "any",
+				required: false
+			},
+			"outcome": {
+				kind: "object",
+				required: false
+			},
+			"usage": {
+				kind: "array",
+				required: false
+			}
+		}
+	},
+	"RUN_ERROR": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#runerror",
+		fields: {
+			"message": {
+				kind: "string",
+				required: true
+			},
+			"code": {
+				kind: "string",
+				required: false
+			},
+			"usage": {
+				kind: "array",
+				required: false
+			}
+		}
+	},
+	"STEP_STARTED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#stepstarted",
+		fields: { "stepName": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"STEP_FINISHED": {
+		category: "lifecycle",
+		specUrl: "https://docs.ag-ui.com/concepts/events#stepfinished",
+		fields: { "stepName": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_START": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningstart",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_MESSAGE_START": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessagestart",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"role": {
+				kind: "string",
+				required: true,
+				enum: ["reasoning"]
+			}
+		}
+	},
+	"REASONING_MESSAGE_CONTENT": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessagecontent",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: true
+			},
+			"delta": {
+				kind: "string",
+				required: true
+			}
+		}
+	},
+	"REASONING_MESSAGE_END": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessageend",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_MESSAGE_CHUNK": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningmessagechunk",
+		fields: {
+			"messageId": {
+				kind: "string",
+				required: false
+			},
+			"delta": {
+				kind: "string",
+				required: false
+			}
+		}
+	},
+	"REASONING_END": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningend",
+		fields: { "messageId": {
+			kind: "string",
+			required: true
+		} }
+	},
+	"REASONING_ENCRYPTED_VALUE": {
+		category: "reasoning",
+		specUrl: "https://docs.ag-ui.com/concepts/events#reasoningencryptedvalue",
+		fields: {
+			"subtype": {
+				kind: "string",
+				required: true,
+				enum: ["tool-call", "message"]
+			},
+			"entityId": {
+				kind: "string",
+				required: true
+			},
+			"encryptedValue": {
+				kind: "string",
+				required: true
+			}
+		}
+	}
+};
+/** All canonical wire `type` values, in @ag-ui/core enum order. */
+const EVENT_TYPES = Object.keys(EVENT_TABLE);
+/**
+* Wire types documented as drafts (https://docs.ag-ui.com/drafts/overview) but
+* not yet in @ag-ui/core. Not errors: reported at info severity.
+*/
+const DRAFT_EVENT_TYPES = ["META"];
+//#endregion
+//#region src/rules/catalog.json
+var catalog_default = {
+	$comment: "AG-UI conformance rule catalog. Data, not code: a Python/Go implementation shares these rules. Severities follow the working agreement that behaviour the spec does not clearly govern is at most 'info' — entries with 'specQuestion' were downgraded accordingly; see docs/spec-questions.md.",
+	catalogVersion: "0.1.0",
+	spec: "0.x",
+	rules: [
+		{
+			"id": "AGUI001",
+			"severity": "error",
+			"title": "Run does not start with RUN_STARTED",
+			"messageTemplate": "First event of the run is {type}; expected RUN_STARTED",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runstarted",
+			"specQuote": "The RunStarted event is the first event emitted when an agent begins processing a request.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI002",
+			"severity": "error",
+			"title": "Multiple RUN_STARTED in one run",
+			"messageTemplate": "Duplicate RUN_STARTED (runId '{runId}') before the active run terminated",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#lifecycle-events",
+			"specQuote": "The RunStarted and either RunFinished or RunError events are mandatory, forming the boundaries of an agent run.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI003",
+			"severity": "error",
+			"title": "Run not terminated",
+			"messageTemplate": "Run '{runId}' ended without RUN_FINISHED or RUN_ERROR",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runfinished",
+			"specQuote": "Every run terminates with either RunFinished or RunError.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI004",
+			"severity": "error",
+			"title": "Event after terminal event",
+			"messageTemplate": "{type} follows the run's terminal {terminalType}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#lifecycle-events",
+			"specQuote": "The RunStarted and either RunFinished or RunError events are mandatory, forming the boundaries of an agent run.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI005",
+			"severity": "error",
+			"title": "RUN_FINISHED and RUN_ERROR are mutually exclusive",
+			"messageTemplate": "{type} emitted after the run already terminated with {terminalType}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runfinished",
+			"specQuote": "Every run terminates with either RunFinished or RunError.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI006",
+			"severity": "error",
+			"title": "STEP_FINISHED without matching STEP_STARTED",
+			"messageTemplate": "STEP_FINISHED '{stepName}' has no open STEP_STARTED",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#stepfinished",
+			"specQuote": "The stepName must match the corresponding StepStarted event.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI007",
+			"severity": "error",
+			"title": "Step unterminated at run end",
+			"messageTemplate": "STEP_STARTED '{stepName}' never finished",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#stepstarted",
+			"specQuote": "The stepName must match the corresponding StepStarted event.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI008",
+			"severity": "warning",
+			"title": "Unstable threadId/runId across the run",
+			"messageTemplate": "RUN_FINISHED {field} '{actual}' does not match RUN_STARTED {field} '{expected}'",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runstarted",
+			"specQuote": "It also provides crucial identifiers that can be used to associate subsequent events with this specific run.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI101",
+			"severity": "error",
+			"title": "TEXT_MESSAGE_CONTENT without start",
+			"messageTemplate": "TEXT_MESSAGE_CONTENT for messageId '{messageId}' with no open TEXT_MESSAGE_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#text-message-events",
+			"specQuote": "A message begins with a TextMessageStart event, followed by one or more TextMessageContent events that deliver chunks of text as they become available, and concludes with a TextMessageEnd event.",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI102",
+			"severity": "error",
+			"title": "TEXT_MESSAGE_END without start",
+			"messageTemplate": "TEXT_MESSAGE_END for messageId '{messageId}' with no open TEXT_MESSAGE_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#textmessageend",
+			"specQuote": "messageId: Matches the ID from TextMessageStart",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI103",
+			"severity": "error",
+			"title": "Text message unterminated at run end",
+			"messageTemplate": "TEXT_MESSAGE_START messageId '{messageId}' never ended",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#text-message-events",
+			"specQuote": "A message begins with a TextMessageStart event, followed by one or more TextMessageContent events that deliver chunks of text as they become available, and concludes with a TextMessageEnd event.",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI104",
+			"severity": "error",
+			"title": "Duplicate messageId within a run",
+			"messageTemplate": "messageId '{messageId}' was already used by a completed message",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#textmessagestart",
+			"specQuote": "It establishes a unique messageId that will be referenced by subsequent content chunks and the end event.",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI105",
+			"severity": "warning",
+			"title": "Empty content delta",
+			"messageTemplate": "TEXT_MESSAGE_CONTENT for messageId '{messageId}' has an empty delta",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#textmessagecontent",
+			"specQuote": "delta: Text content chunk (non-empty)",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"specQuestion": "SQ-2",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI106",
+			"severity": "error",
+			"title": "Interleaved message streams sharing a messageId",
+			"messageTemplate": "TEXT_MESSAGE_START for messageId '{messageId}', which is already open",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#implementation-considerations",
+			"specQuote": "Events with the same ID (e.g., messageId, toolCallId) belong to the same logical stream",
+			"since": "0.x",
+			"feature": "agentic-chat",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI201",
+			"severity": "error",
+			"title": "TOOL_CALL_ARGS without start",
+			"messageTemplate": "TOOL_CALL_ARGS for toolCallId '{toolCallId}' with no open TOOL_CALL_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#tool-call-events",
+			"specQuote": "When an agent needs to use a tool, it emits a ToolCallStart event, followed by one or more ToolCallArgs events that stream the arguments being passed to the tool, and concludes with a ToolCallEnd event.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI202",
+			"severity": "error",
+			"title": "TOOL_CALL_END without start",
+			"messageTemplate": "TOOL_CALL_END for toolCallId '{toolCallId}' with no open TOOL_CALL_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallend",
+			"specQuote": "toolCallId: Matches the ID from ToolCallStart",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI203",
+			"severity": "error",
+			"title": "Unterminated tool call",
+			"messageTemplate": "TOOL_CALL_START id '{toolCallId}' never terminated",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#tool-call-events",
+			"specQuote": "When an agent needs to use a tool, it emits a ToolCallStart event, followed by one or more ToolCallArgs events that stream the arguments being passed to the tool, and concludes with a ToolCallEnd event.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI204",
+			"severity": "error",
+			"title": "Tool call arguments are not valid JSON",
+			"messageTemplate": "Concatenated TOOL_CALL_ARGS for toolCallId '{toolCallId}' do not parse as JSON: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallargs",
+			"specQuote": "Frontends should concatenate these deltas in the order received to construct the complete arguments object.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI205",
+			"severity": "error",
+			"title": "Duplicate toolCallId within a run",
+			"messageTemplate": "toolCallId '{toolCallId}' was already used by a completed tool call",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallstart",
+			"specQuote": "toolCallId: Unique identifier for the tool call",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI206",
+			"severity": "warning",
+			"title": "TOOL_CALL_RESULT before TOOL_CALL_END",
+			"messageTemplate": "TOOL_CALL_RESULT for toolCallId '{toolCallId}' arrived while the call is still open",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallresult",
+			"specQuote": "This event is sent after the tool has been executed by the system and contains the actual output generated by the tool.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI207",
+			"severity": "error",
+			"title": "TOOL_CALL_RESULT references unknown toolCallId",
+			"messageTemplate": "TOOL_CALL_RESULT references toolCallId '{toolCallId}', which was never started",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallresult",
+			"specQuote": "toolCallId: Matches the ID from the corresponding ToolCallStart event",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI208",
+			"severity": "info",
+			"title": "parentMessageId references unknown message",
+			"messageTemplate": "TOOL_CALL_START parentMessageId '{parentMessageId}' matches no message observed in this stream",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#toolcallstart",
+			"specQuote": "The optional parentMessageId allows linking the tool call to a specific message in the conversation, providing context for why the tool is being used.",
+			"since": "0.x",
+			"feature": "backend-tool-rendering",
+			"specQuestion": "SQ-11",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI301",
+			"severity": "info",
+			"title": "STATE_DELTA before any STATE_SNAPSHOT",
+			"messageTemplate": "STATE_DELTA precedes any STATE_SNAPSHOT; the base it applies to is not observable on this stream",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statesnapshot",
+			"specQuote": "This event is typically sent at the beginning of an interaction or when synchronization is needed.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"specQuestion": "SQ-1",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI302",
+			"severity": "error",
+			"title": "STATE_DELTA failed to apply",
+			"messageTemplate": "STATE_DELTA failed to apply: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statedelta",
+			"specQuote": "Each delta represents specific changes to apply to the current state model.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI303",
+			"severity": "error",
+			"title": "STATE_DELTA is not a valid RFC 6902 patch document",
+			"messageTemplate": "STATE_DELTA is not a valid RFC 6902 patch document: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statedelta",
+			"specQuote": "The StateDelta event contains incremental updates to the agent's state in the form of JSON Patch operations (as defined in RFC 6902).",
+			"since": "0.x",
+			"feature": "shared-state",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI304",
+			"severity": "info",
+			"title": "Mid-run STATE_SNAPSHOT discards accumulated deltas",
+			"messageTemplate": "STATE_SNAPSHOT replaces state previously built from {deltaCount} delta(s)",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#statesnapshot",
+			"specQuote": "This event is typically sent at the beginning of an interaction or when synchronization is needed.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI305",
+			"severity": "warning",
+			"title": "Shared state declared but never established",
+			"messageTemplate": "features include 'shared-state' but no STATE_SNAPSHOT was emitted",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#state-management-events",
+			"specQuote": "These events are used to manage and synchronize the agent's state with the frontend.",
+			"since": "0.x",
+			"feature": "shared-state",
+			"requiresFeature": true,
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI401",
+			"severity": "error",
+			"title": "REASONING_MESSAGE_CONTENT without start",
+			"messageTemplate": "REASONING_MESSAGE_CONTENT for messageId '{messageId}' with no open REASONING_MESSAGE_START",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#reasoningmessagecontent",
+			"specQuote": "Multiple content events with the same messageId should be concatenated to form the complete visible reasoning.",
+			"since": "0.x",
+			"specQuestion": "SQ-4",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI402",
+			"severity": "warning",
+			"title": "Reasoning unterminated at run end",
+			"messageTemplate": "{startType} messageId '{messageId}' never ended",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#reasoning-events",
+			"specQuote": "Reasoning events support LLM reasoning visibility and continuity, enabling chain-of-thought reasoning while maintaining privacy.",
+			"since": "0.x",
+			"specQuestion": "SQ-4",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI501",
+			"severity": "error",
+			"title": "Malformed SSE framing",
+			"messageTemplate": "Malformed SSE framing: {detail}",
+			"specUrl": "https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation",
+			"since": "0.x",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI502",
+			"severity": "error",
+			"title": "Event payload is not valid JSON",
+			"messageTemplate": "Event payload is not valid JSON: {error}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#base-event-properties",
+			"specQuote": "All events share a common set of base properties.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI503",
+			"severity": "error",
+			"title": "Unknown event type",
+			"messageTemplate": "Unknown event type '{type}' (not in @ag-ui/core v{sdkVersion}, and not RAW or CUSTOM)",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#event-types-overview",
+			"specQuote": "Events in the protocol are categorized by their purpose.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI504",
+			"severity": "error",
+			"title": "Event fails schema validation for its declared type",
+			"messageTemplate": "{type}: {detail}",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#base-event-properties",
+			"specQuote": "All events share a common set of base properties.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI505",
+			"severity": "warning",
+			"title": "Unexpected Content-Type",
+			"messageTemplate": "Content-Type '{contentType}' is neither text/event-stream nor application/x-ndjson",
+			"specUrl": "https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model",
+			"since": "0.x",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI506",
+			"severity": "info",
+			"title": "No keepalive frame within the configured window",
+			"messageTemplate": "No event or keepalive frame for {seconds}s",
+			"specUrl": "https://docs.ag-ui.com/concepts/architecture#standard-http-client",
+			"since": "0.x",
+			"specQuestion": "SQ-5",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI507",
+			"severity": "info",
+			"title": "Response appears buffered rather than incrementally flushed",
+			"messageTemplate": "Response appears buffered: {detail}",
+			"specUrl": "https://docs.ag-ui.com/concepts/architecture#standard-http-client",
+			"since": "0.x",
+			"specQuestion": "SQ-5",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI508",
+			"severity": "error",
+			"title": "Stream ended without a terminal event",
+			"messageTemplate": "Connection ended mid-run '{runId}' without RUN_FINISHED or RUN_ERROR",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#runfinished",
+			"specQuote": "Every run terminates with either RunFinished or RunError.",
+			"since": "0.x",
+			"checkedIn": "transport"
+		},
+		{
+			"id": "AGUI901",
+			"severity": "info",
+			"title": "RAW event wraps a typed AG-UI event",
+			"messageTemplate": "RAW event wraps an event of type '{wrappedType}', which has a typed AG-UI equivalent",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#raw",
+			"specQuote": "The Raw event acts as a container for events originating from external systems or sources that don't natively follow the Agent UI Protocol.",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI902",
+			"severity": "info",
+			"title": "Events carry no timestamps",
+			"messageTemplate": "None of the {eventCount} events carry the optional timestamp property",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#base-event-properties",
+			"specQuote": "timestamp: Optional timestamp indicating when the event was created",
+			"since": "0.x",
+			"checkedIn": "core"
+		},
+		{
+			"id": "AGUI903",
+			"severity": "info",
+			"title": "CUSTOM event name is not namespaced",
+			"messageTemplate": "CUSTOM event name '{name}' has no namespace prefix (e.g. 'vendor.event')",
+			"specUrl": "https://docs.ag-ui.com/concepts/events#custom",
+			"specQuote": "Teams should document their custom events to ensure consistent implementation across frontends and agents.",
+			"since": "0.x",
+			"specQuestion": "SQ-14",
+			"checkedIn": "core"
+		}
+	]
+};
+//#endregion
+//#region src/rules/catalog.ts
+const SEVERITIES = [
+	"error",
+	"warning",
+	"info"
+];
+const LAYERS = ["core", "transport"];
+/** Validates catalog data and returns it typed. Throws on structural problems. */
+function validateCatalog(data) {
+	const problems = [];
+	const cat = data;
+	if (typeof cat !== "object" || cat === null || !Array.isArray(cat.rules)) throw new Error("rule catalog: expected an object with a rules array");
+	const seen = /* @__PURE__ */ new Set();
+	for (const rule of cat.rules) {
+		const where = rule?.id ?? "<missing id>";
+		if (!/^AGUI\d{3}$/.test(rule.id ?? "")) problems.push(`${where}: id must match AGUI###`);
+		if (seen.has(rule.id)) problems.push(`${where}: duplicate id`);
+		seen.add(rule.id);
+		if (!SEVERITIES.includes(rule.severity)) problems.push(`${where}: bad severity '${rule.severity}'`);
+		if (!rule.title) problems.push(`${where}: missing title`);
+		if (!rule.messageTemplate) problems.push(`${where}: missing messageTemplate`);
+		if (!rule.specUrl?.startsWith("https://")) problems.push(`${where}: specUrl must be an https URL`);
+		if (!rule.since) problems.push(`${where}: missing since`);
+		if (!LAYERS.includes(rule.checkedIn)) problems.push(`${where}: bad checkedIn '${rule.checkedIn}'`);
+		if (rule.requiresFeature && !rule.feature) problems.push(`${where}: requiresFeature without feature`);
+	}
+	if (problems.length > 0) throw new Error(`rule catalog is invalid:\n  ${problems.join("\n  ")}`);
+	return cat;
+}
+const CATALOG = validateCatalog(catalog_default);
+const RULES = new Map(CATALOG.rules.map((r) => [r.id, r]));
+/** Fills a rule's messageTemplate. Unknown placeholders are left intact. */
+function formatMessage(rule, params) {
+	return rule.messageTemplate.replace(/\{(\w+)\}/g, (whole, key) => key in params ? String(params[key]) : whole);
+}
+//#endregion
+//#region src/rules/checks/context.ts
+function newRunState(init) {
+	return {
+		...init,
+		terminal: null,
+		openMessages: /* @__PURE__ */ new Map(),
+		closedMessages: /* @__PURE__ */ new Map(),
+		knownMessageIds: /* @__PURE__ */ new Set(),
+		openToolCalls: /* @__PURE__ */ new Map(),
+		closedToolCalls: /* @__PURE__ */ new Map(),
+		knownToolCallIds: /* @__PURE__ */ new Set(),
+		openSteps: /* @__PURE__ */ new Map(),
+		openReasoningBlocks: /* @__PURE__ */ new Map(),
+		openReasoningMessages: /* @__PURE__ */ new Map(),
+		state: {
+			known: false,
+			value: void 0,
+			deltasSinceSnapshot: 0,
+			snapshotSeen: false,
+			agui301Fired: false
+		},
+		textChunk: null,
+		toolChunk: null,
+		reasoningChunk: null
+	};
+}
+/** Reads a field only if it is a string (schema problems already reported). */
+function str(event, field) {
+	const v = event[field];
+	return typeof v === "string" ? v : void 0;
+}
+//#endregion
+//#region src/rules/checks/lifecycle.ts
+function handleStepEvent(api) {
+	const { type, event, run, emit, index } = api;
+	const stepName = str(event, "stepName");
+	if (stepName === void 0) return;
+	if (type === "STEP_STARTED") {
+		const open = run.openSteps.get(stepName);
+		if (open !== void 0) open.count += 1;
+		else run.openSteps.set(stepName, {
+			count: 1,
+			firstIndex: index
+		});
+		return;
+	}
+	if (type === "STEP_FINISHED") {
+		const open = run.openSteps.get(stepName);
+		if (open === void 0) {
+			emit("AGUI006", { stepName }, { pointer: "/stepName" });
+			return;
+		}
+		open.count -= 1;
+		if (open.count === 0) run.openSteps.delete(stepName);
+	}
+}
+/** AGUI008 — RUN_FINISHED must carry the ids RUN_STARTED established. */
+function checkRunIdStability(api) {
+	const { event, run, emit } = api;
+	if (run.implicit) return;
+	for (const field of ["threadId", "runId"]) {
+		const actual = str(api.event, field);
+		const expected = field === "threadId" ? run.threadId : run.runId;
+		if (actual !== void 0 && expected !== null && actual !== expected) emit("AGUI008", {
+			field,
+			actual,
+			expected
+		}, {
+			pointer: `/${field}`,
+			relatedEventIndex: run.startIndex
+		});
+	}
+}
+/** AGUI007 — open steps when the run reaches a clean end. */
+function endOfRunSteps(run, emit, atIndex) {
+	for (const [stepName, open] of run.openSteps) emit("AGUI007", { stepName }, {
+		eventIndex: atIndex,
+		relatedEventIndex: open.firstIndex
+	});
+}
+//#endregion
+//#region src/rules/checks/reasoning.ts
+function handleReasoningEvent(api) {
+	const { type, event, run, emit, index } = api;
+	switch (type) {
+		case "REASONING_START": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningBlocks.set(id, index);
+			return;
+		}
+		case "REASONING_END": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningBlocks.delete(id);
+			return;
+		}
+		case "REASONING_MESSAGE_START": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningMessages.set(id, index);
+			return;
+		}
+		case "REASONING_MESSAGE_CONTENT": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			const openChunk = run.reasoningChunk !== null && run.reasoningChunk.messageId === id;
+			if (!run.openReasoningMessages.has(id) && !openChunk) emit("AGUI401", { messageId: id }, { pointer: "/messageId" });
+			return;
+		}
+		case "REASONING_MESSAGE_END": {
+			const id = str(event, "messageId");
+			if (id !== void 0) run.openReasoningMessages.delete(id);
+			return;
+		}
+		case "REASONING_MESSAGE_CHUNK": {
+			const id = str(event, "messageId");
+			if (id === void 0) {
+				if (run.reasoningChunk === null) {
+					emit("AGUI504", {
+						type,
+						detail: "first REASONING_MESSAGE_CHUNK must include messageId"
+					}, { pointer: "/messageId" });
+					return;
+				}
+				if (event.delta === "") run.reasoningChunk = null;
+				return;
+			}
+			if (run.reasoningChunk !== null && run.reasoningChunk.messageId !== id) run.reasoningChunk = null;
+			if (event.delta === "") {
+				run.reasoningChunk = null;
+				return;
+			}
+			if (run.reasoningChunk === null) run.reasoningChunk = {
+				messageId: id,
+				startIndex: index
+			};
+			return;
+		}
+	}
+}
+/** Chunked reasoning also closes on any non-reasoning event (documented). */
+function closeReasoningChunk(run) {
+	run.reasoningChunk = null;
+}
+/** AGUI402 — unterminated reasoning at a clean run end. */
+function endOfRunReasoning(run, emit, atIndex) {
+	for (const [id, startIndex] of run.openReasoningBlocks) emit("AGUI402", {
+		startType: "REASONING_START",
+		messageId: id
+	}, {
+		eventIndex: atIndex,
+		relatedEventIndex: startIndex
+	});
+	for (const [id, startIndex] of run.openReasoningMessages) emit("AGUI402", {
+		startType: "REASONING_MESSAGE_START",
+		messageId: id
+	}, {
+		eventIndex: atIndex,
+		relatedEventIndex: startIndex
+	});
+}
+//#endregion
+//#region src/protocol/jsonpatch.ts
+const OPS = [
+	"add",
+	"remove",
+	"replace",
+	"move",
+	"copy",
+	"test"
+];
+/** RFC 6901: "" → whole document; "/a/b" → ["a", "b"]. Returns null when invalid. */
+function parsePointer(pointer) {
+	if (typeof pointer !== "string") return null;
+	if (pointer === "") return [];
+	if (!pointer.startsWith("/")) return null;
+	return pointer.slice(1).split("/").map((t) => t.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+/** Structural validation of a patch document, without applying it. */
+function validatePatchShape(patch) {
+	if (!Array.isArray(patch)) return {
+		error: "patch document must be an array of operations",
+		opIndex: -1,
+		pointer: ""
+	};
+	for (let i = 0; i < patch.length; i++) {
+		const op = patch[i];
+		if (typeof op !== "object" || op === null || Array.isArray(op)) return {
+			error: `operation ${i} is not an object`,
+			opIndex: i,
+			pointer: `/${i}`
+		};
+		const o = op;
+		if (!OPS.includes(o.op)) return {
+			error: `operation ${i} has invalid op '${String(o.op)}'`,
+			opIndex: i,
+			pointer: `/${i}/op`
+		};
+		if (parsePointer(o.path) === null) return {
+			error: `operation ${i} (${String(o.op)}) has invalid path`,
+			opIndex: i,
+			pointer: `/${i}/path`
+		};
+		if ((o.op === "add" || o.op === "replace" || o.op === "test") && !("value" in o)) return {
+			error: `operation ${i} (${String(o.op)}) is missing value`,
+			opIndex: i,
+			pointer: `/${i}`
+		};
+		if ((o.op === "move" || o.op === "copy") && parsePointer(o.from) === null) return {
+			error: `operation ${i} (${String(o.op)}) is missing or has invalid from`,
+			opIndex: i,
+			pointer: `/${i}`
+		};
+	}
+	return null;
+}
+function clone(value) {
+	if (Array.isArray(value)) return value.map(clone);
+	if (typeof value === "object" && value !== null) {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) out[k] = clone(v);
+		return out;
+	}
+	return value;
+}
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+	if (typeof a === "object" && a !== null && typeof b === "object" && b !== null && !Array.isArray(a) && !Array.isArray(b)) {
+		const ka = Object.keys(a);
+		const kb = Object.keys(b);
+		return ka.length === kb.length && ka.every((k) => deepEqual(a[k], b[k]));
+	}
+	return false;
+}
+function arrayIndex(token, length, allowAppend) {
+	if (allowAppend && token === "-") return length;
+	if (!/^(0|[1-9]\d*)$/.test(token)) return null;
+	const i = Number(token);
+	return i > length ? null : i;
+}
+function locate(doc, tokens, forAdd) {
+	if (tokens.length === 0) return {
+		parent: null,
+		key: "",
+		exists: true,
+		value: doc
+	};
+	let current = doc;
+	for (let i = 0; i < tokens.length - 1; i++) {
+		const token = tokens[i];
+		if (Array.isArray(current)) {
+			const idx = arrayIndex(token, current.length, false);
+			if (idx === null || idx >= current.length) return `path segment '/${token}' does not exist`;
+			current = current[idx];
+		} else if (typeof current === "object" && current !== null) {
+			const obj = current;
+			if (!(token in obj)) return `path segment '/${token}' does not exist`;
+			current = obj[token];
+		} else return `path segment '/${token}' is not an object or array`;
+	}
+	const last = tokens[tokens.length - 1];
+	if (Array.isArray(current)) {
+		const idx = arrayIndex(last, current.length, forAdd);
+		if (idx === null) return `'${last}' is not a valid index for an array of length ${current.length}`;
+		return {
+			parent: current,
+			key: idx,
+			exists: idx < current.length,
+			value: current[idx]
+		};
+	}
+	if (typeof current === "object" && current !== null) {
+		const obj = current;
+		return {
+			parent: obj,
+			key: last,
+			exists: last in obj,
+			value: obj[last]
+		};
+	}
+	return `target of '/${last}' is not an object or array`;
+}
+/** Applies an RFC 6902 patch. Validates shape first; never throws. */
+function applyPatch(doc, patch) {
+	const shape = validatePatchShape(patch);
+	if (shape !== null) return {
+		ok: false,
+		error: shape.error,
+		opIndex: shape.opIndex
+	};
+	let result = clone(doc);
+	const ops = patch;
+	const getAt = (pointer) => {
+		const loc = locate(result, parsePointer(pointer), false);
+		if (typeof loc === "string") return {
+			ok: false,
+			error: `${pointer}: ${loc}`
+		};
+		if (!loc.exists) return {
+			ok: false,
+			error: `${pointer} does not exist`
+		};
+		return {
+			ok: true,
+			value: loc.value
+		};
+	};
+	const setAt = (pointer, value, mustExist) => {
+		const tokens = parsePointer(pointer);
+		if (tokens.length === 0) {
+			result = value;
+			return null;
+		}
+		const loc = locate(result, tokens, !mustExist);
+		if (typeof loc === "string") return `${pointer}: ${loc}`;
+		if (mustExist && !loc.exists) return `${pointer} does not exist`;
+		if (Array.isArray(loc.parent)) {
+			if (mustExist) loc.parent[loc.key] = value;
+			else loc.parent.splice(loc.key, 0, value);
+		} else loc.parent[loc.key] = value;
+		return null;
+	};
+	const removeAt = (pointer) => {
+		const tokens = parsePointer(pointer);
+		if (tokens.length === 0) return {
+			ok: false,
+			error: "cannot remove the whole document"
+		};
+		const loc = locate(result, tokens, false);
+		if (typeof loc === "string") return {
+			ok: false,
+			error: `${pointer}: ${loc}`
+		};
+		if (!loc.exists) return {
+			ok: false,
+			error: `${pointer} does not exist`
+		};
+		if (Array.isArray(loc.parent)) loc.parent.splice(loc.key, 1);
+		else delete loc.parent[loc.key];
+		return {
+			ok: true,
+			removed: loc.value
+		};
+	};
+	for (let i = 0; i < ops.length; i++) {
+		const op = ops[i];
+		const path = op.path;
+		let error = null;
+		switch (op.op) {
+			case "add":
+				error = setAt(path, clone(op.value), false);
+				break;
+			case "replace":
+				error = setAt(path, clone(op.value), true);
+				break;
+			case "remove": {
+				const r = removeAt(path);
+				if (!r.ok) error = r.error;
+				break;
+			}
+			case "move": {
+				const from = op.from;
+				if (path.startsWith(`${from}/`)) {
+					error = `cannot move ${from} into its own child ${path}`;
+					break;
+				}
+				const r = removeAt(from);
+				if (!r.ok) {
+					error = r.error;
+					break;
+				}
+				error = setAt(path, r.removed, false);
+				break;
+			}
+			case "copy": {
+				const r = getAt(op.from);
+				if (!r.ok) {
+					error = r.error;
+					break;
+				}
+				error = setAt(path, clone(r.value), false);
+				break;
+			}
+			case "test": {
+				const r = getAt(path);
+				if (!r.ok) error = r.error;
+				else if (!deepEqual(r.value, op.value)) error = `test failed at ${path}`;
+				break;
+			}
+		}
+		if (error !== null) return {
+			ok: false,
+			error,
+			opIndex: i
+		};
+	}
+	return {
+		ok: true,
+		result
+	};
+}
+//#endregion
+//#region src/rules/checks/state.ts
+function handleStateEvent(api) {
+	const { type, event, run, stream, emit } = api;
+	switch (type) {
+		case "STATE_SNAPSHOT":
+			api.feature("shared-state");
+			if (run.state.deltasSinceSnapshot > 0) emit("AGUI304", { deltaCount: run.state.deltasSinceSnapshot }, {});
+			run.state.known = true;
+			run.state.value = event.snapshot;
+			run.state.snapshotSeen = true;
+			run.state.deltasSinceSnapshot = 0;
+			stream.anySnapshot = true;
+			return;
+		case "STATE_DELTA": {
+			api.feature("shared-state");
+			const delta = event.delta;
+			if (!Array.isArray(delta)) return;
+			const shape = validatePatchShape(delta);
+			if (shape !== null) {
+				emit("AGUI303", { error: shape.error }, { pointer: `/delta${shape.pointer}` });
+				return;
+			}
+			if (!run.state.snapshotSeen && !run.state.agui301Fired) {
+				emit("AGUI301", {}, {});
+				run.state.agui301Fired = true;
+			}
+			if (run.state.known) {
+				const applied = applyPatch(run.state.value, delta);
+				if (applied.ok) run.state.value = applied.result;
+				else emit("AGUI302", { error: applied.error }, { pointer: `/delta/${applied.opIndex}` });
+			}
+			run.state.deltasSinceSnapshot += 1;
+			return;
+		}
+		case "MESSAGES_SNAPSHOT": {
+			const messages = event.messages;
+			if (!Array.isArray(messages)) return;
+			for (const message of messages) {
+				if (typeof message !== "object" || message === null) continue;
+				const m = message;
+				if (typeof m.id === "string") run.knownMessageIds.add(m.id);
+				if (Array.isArray(m.toolCalls)) {
+					for (const call of m.toolCalls) if (typeof call === "object" && call !== null) {
+						const id = call.id;
+						if (typeof id === "string") run.knownToolCallIds.add(id);
+					}
+				}
+			}
+			return;
+		}
+	}
+}
+//#endregion
+//#region src/rules/checks/text.ts
+function handleTextEvent(api) {
+	const { type, event, run, emit, index } = api;
+	api.feature("agentic-chat");
+	switch (type) {
+		case "TEXT_MESSAGE_START": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			if (run.openMessages.has(id)) {
+				emit("AGUI106", { messageId: id }, {
+					pointer: "/messageId",
+					relatedEventIndex: run.openMessages.get(id).startIndex
+				});
+				return;
+			}
+			if (run.closedMessages.has(id)) {
+				emit("AGUI104", { messageId: id }, {
+					pointer: "/messageId",
+					relatedEventIndex: run.closedMessages.get(id)
+				});
+				return;
+			}
+			run.openMessages.set(id, { startIndex: index });
+			run.knownMessageIds.add(id);
+			return;
+		}
+		case "TEXT_MESSAGE_CONTENT": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			const open = run.openMessages.get(id);
+			if (open === void 0) {
+				const closedAt = run.closedMessages.get(id);
+				emit("AGUI101", { messageId: id }, {
+					pointer: "/messageId",
+					...closedAt !== void 0 ? { relatedEventIndex: closedAt } : {}
+				});
+				return;
+			}
+			if (event.delta === "") emit("AGUI105", { messageId: id }, {
+				pointer: "/delta",
+				relatedEventIndex: open.startIndex
+			});
+			return;
+		}
+		case "TEXT_MESSAGE_END": {
+			const id = str(event, "messageId");
+			if (id === void 0) return;
+			if (!run.openMessages.has(id)) {
+				emit("AGUI102", { messageId: id }, { pointer: "/messageId" });
+				return;
+			}
+			run.openMessages.delete(id);
+			run.closedMessages.set(id, index);
+			return;
+		}
+		case "TEXT_MESSAGE_CHUNK": {
+			const id = str(event, "messageId");
+			if (id === void 0) {
+				if (run.textChunk === null) emit("AGUI504", {
+					type,
+					detail: "first TEXT_MESSAGE_CHUNK for a message must include messageId"
+				}, { pointer: "/messageId" });
+				return;
+			}
+			if (run.openMessages.has(id)) return;
+			if (run.textChunk !== null && run.textChunk.messageId === id) return;
+			closeTextChunk(run, index);
+			if (run.closedMessages.has(id)) {
+				emit("AGUI104", { messageId: id }, {
+					pointer: "/messageId",
+					relatedEventIndex: run.closedMessages.get(id)
+				});
+				return;
+			}
+			run.textChunk = {
+				messageId: id,
+				startIndex: index
+			};
+			run.knownMessageIds.add(id);
+			return;
+		}
+	}
+}
+/** Chunk streams close implicitly on the next non-chunk event. */
+function closeTextChunk(run, atIndex) {
+	if (run.textChunk === null) return;
+	run.closedMessages.set(run.textChunk.messageId, atIndex);
+	run.textChunk = null;
+}
+/** AGUI103 — open messages when the run reaches a clean end. */
+function endOfRunText(run, emit, atIndex) {
+	for (const [id, open] of run.openMessages) emit("AGUI103", { messageId: id }, {
+		eventIndex: atIndex,
+		relatedEventIndex: open.startIndex
+	});
+}
+//#endregion
+//#region src/rules/checks/toolcalls.ts
+function handleToolCallEvent(api) {
+	const { type, event, run, emit, index } = api;
+	api.feature("backend-tool-rendering");
+	switch (type) {
+		case "TOOL_CALL_START": {
+			const id = str(event, "toolCallId");
+			if (id === void 0) return;
+			if (run.openToolCalls.has(id) || run.closedToolCalls.has(id)) {
+				const related = run.openToolCalls.get(id)?.startIndex ?? run.closedToolCalls.get(id);
+				emit("AGUI205", { toolCallId: id }, {
+					pointer: "/toolCallId",
+					relatedEventIndex: related
+				});
+				return;
+			}
+			run.openToolCalls.set(id, {
+				startIndex: index,
+				args: "",
+				sawArgs: false
+			});
+			const parent = str(event, "parentMessageId");
+			if (parent !== void 0 && !run.knownMessageIds.has(parent)) emit("AGUI208", { parentMessageId: parent }, { pointer: "/parentMessageId" });
+			return;
+		}
+		case "TOOL_CALL_ARGS": {
+			const id = str(event, "toolCallId");
+			if (id === void 0) return;
+			const open = run.openToolCalls.get(id);
+			if (open === void 0) {
+				emit("AGUI201", { toolCallId: id }, { pointer: "/toolCallId" });
+				return;
+			}
+			const delta = str(event, "delta");
+			if (delta !== void 0) {
+				open.args += delta;
+				open.sawArgs = true;
+			}
+			return;
+		}
+		case "TOOL_CALL_END": {
+			const id = str(event, "toolCallId");
+			if (id === void 0) return;
+			const open = run.openToolCalls.get(id);
+			if (open === void 0) {
+				emit("AGUI202", { toolCallId: id }, { pointer: "/toolCallId" });
+				return;
+			}
+			run.openToolCalls.delete(id);
+			run.closedToolCalls.set(id, index);
+			checkArgsJson(id, open, emit, index);
+			return;
+		}
+		case "TOOL_CALL_RESULT": {
+			const id = str(event, "toolCallId");
+			if (id !== void 0) {
+				const open = run.openToolCalls.get(id);
+				if (open !== void 0) emit("AGUI206", { toolCallId: id }, {
+					pointer: "/toolCallId",
+					relatedEventIndex: open.startIndex
+				});
+				else if (!run.closedToolCalls.has(id) && !run.knownToolCallIds.has(id)) emit("AGUI207", { toolCallId: id }, { pointer: "/toolCallId" });
+			}
+			const messageId = str(event, "messageId");
+			if (messageId !== void 0) run.knownMessageIds.add(messageId);
+			return;
+		}
+		case "TOOL_CALL_CHUNK": {
+			const id = str(event, "toolCallId");
+			const delta = str(event, "delta");
+			if (id === void 0) {
+				if (run.toolChunk === null) {
+					emit("AGUI504", {
+						type,
+						detail: "first TOOL_CALL_CHUNK for a tool call must include toolCallId and toolCallName"
+					}, { pointer: "/toolCallId" });
+					return;
+				}
+				if (delta !== void 0) {
+					run.toolChunk.args += delta;
+					run.toolChunk.sawArgs = true;
+				}
+				return;
+			}
+			const openExplicit = run.openToolCalls.get(id);
+			if (openExplicit !== void 0) {
+				if (delta !== void 0) {
+					openExplicit.args += delta;
+					openExplicit.sawArgs = true;
+				}
+				return;
+			}
+			if (run.toolChunk !== null && run.toolChunk.toolCallId === id) {
+				if (delta !== void 0) {
+					run.toolChunk.args += delta;
+					run.toolChunk.sawArgs = true;
+				}
+				return;
+			}
+			closeToolChunk(run, emit, index);
+			if (run.closedToolCalls.has(id)) {
+				emit("AGUI205", { toolCallId: id }, {
+					pointer: "/toolCallId",
+					relatedEventIndex: run.closedToolCalls.get(id)
+				});
+				return;
+			}
+			if (str(event, "toolCallName") === void 0) emit("AGUI504", {
+				type,
+				detail: "first TOOL_CALL_CHUNK for a tool call must include toolCallName"
+			}, { pointer: "/toolCallName" });
+			run.toolChunk = {
+				toolCallId: id,
+				startIndex: index,
+				args: delta ?? "",
+				sawArgs: delta !== void 0 && delta.length > 0
+			};
+			return;
+		}
+	}
+}
+function checkArgsJson(id, call, emit, atIndex) {
+	if (!call.sawArgs || call.args.length === 0) return;
+	try {
+		JSON.parse(call.args);
+	} catch (e) {
+		emit("AGUI204", {
+			toolCallId: id,
+			error: e instanceof Error ? e.message : String(e)
+		}, {
+			eventIndex: atIndex,
+			relatedEventIndex: call.startIndex
+		});
+	}
+}
+/** Chunk streams close implicitly on the next non-chunk event. */
+function closeToolChunk(run, emit, atIndex) {
+	if (run.toolChunk === null) return;
+	const { toolCallId, startIndex, args, sawArgs } = run.toolChunk;
+	run.toolChunk = null;
+	run.closedToolCalls.set(toolCallId, atIndex);
+	checkArgsJson(toolCallId, {
+		startIndex,
+		args,
+		sawArgs
+	}, emit, atIndex);
+}
+/** AGUI203 — open tool calls when the run reaches a clean end. */
+function endOfRunToolCalls(run, emit, atIndex) {
+	for (const [id, open] of run.openToolCalls) emit("AGUI203", { toolCallId: id }, {
+		eventIndex: atIndex,
+		relatedEventIndex: open.startIndex
+	});
+}
+//#endregion
+//#region src/rules/checks/transport.ts
+const TRANSPORT_SKIP_REASON = "transport-layer rule; only checkable against a live connection (validated by ag-ui-validate/transport)";
+const TRANSPORT_RULE_IDS = CATALOG.rules.filter((r) => r.checkedIn === "transport").map((r) => r.id);
+//#endregion
+//#region src/types.ts
+const CANONICAL_FEATURES = [
+	"agentic-chat",
+	"backend-tool-rendering",
+	"human-in-the-loop",
+	"agentic-generative-ui",
+	"tool-based-generative-ui",
+	"shared-state",
+	"predictive-state-updates"
+];
+//#endregion
+//#region src/index.ts
+const DRAFTS_META_URL = "https://docs.ag-ui.com/drafts/meta-events";
+const NOT_INFERABLE = ["agentic-generative-ui", "tool-based-generative-ui"];
+/** "runStarted" → "RUN_STARTED": case-insensitive match against wire types. */
+const CANONICAL_BY_SQUASHED = new Map(EVENT_TYPES.map((t) => [t.replace(/_/g, "").toLowerCase(), t]));
+function describeValue(v) {
+	if (v === null) return "null";
+	if (Array.isArray(v)) return "array";
+	return typeof v;
+}
+function createValidator(opts = {}) {
+	const overrides = opts.severityOverrides ?? {};
+	const declaredFeatures = new Set(opts.features ?? []);
+	const layers = /* @__PURE__ */ new Set(["core", ...opts.layers ?? []]);
+	const diagnostics = [];
+	const internalErrors = [];
+	const explicitSkips = /* @__PURE__ */ new Map();
+	const stream = {
+		eventCount: 0,
+		sawTimestamp: false,
+		anySnapshot: false,
+		agui001Fired: false,
+		features: /* @__PURE__ */ new Set()
+	};
+	let run = null;
+	let finalized = false;
+	function mkEmit(batch, current) {
+		return (ruleId, params, extra = {}) => {
+			const rule = RULES.get(ruleId);
+			if (rule === void 0) {
+				internalErrors.push(`emit() for unknown rule ${ruleId}`);
+				return;
+			}
+			const override = overrides[ruleId];
+			if (override === "off") return;
+			const severity = override ?? extra.severity ?? rule.severity;
+			const aboutCurrentEvent = extra.eventIndex === void 0 && current !== null;
+			const diag = {
+				rule: ruleId,
+				severity,
+				message: formatMessage(rule, params) + (extra.messageSuffix ?? ""),
+				eventIndex: extra.eventIndex ?? current?.index ?? -1,
+				specUrl: extra.specUrl ?? rule.specUrl
+			};
+			if (aboutCurrentEvent) diag.eventType = current.type;
+			if (extra.pointer !== void 0) diag.pointer = extra.pointer;
+			if (extra.relatedEventIndex !== void 0) diag.relatedEventIndex = extra.relatedEventIndex;
+			diagnostics.push(diag);
+			batch.push(diag);
+		};
+	}
+	function validateSchema(type, spec, ev, emit) {
+		for (const [field, fs] of Object.entries(spec.fields)) {
+			const v = ev[field];
+			if (v === void 0) {
+				if (fs.required) emit("AGUI504", {
+					type,
+					detail: `missing required field '${field}' (${fs.kind})`
+				}, { pointer: `/${field}` });
+				continue;
+			}
+			let kindOk = true;
+			switch (fs.kind) {
+				case "string":
+				case "number":
+				case "boolean":
+					kindOk = typeof v === fs.kind;
+					break;
+				case "array":
+					kindOk = Array.isArray(v);
+					break;
+				case "object": kindOk = typeof v === "object" && v !== null && !Array.isArray(v);
+			}
+			if (!kindOk) {
+				emit("AGUI504", {
+					type,
+					detail: `field '${field}' must be ${fs.kind === "array" ? "an" : "a"} ${fs.kind}, got ${describeValue(v)}`
+				}, { pointer: `/${field}` });
+				continue;
+			}
+			if (fs.enum !== void 0 && typeof v === "string" && !fs.enum.includes(v)) emit("AGUI504", {
+				type,
+				detail: `field '${field}' must be one of ${fs.enum.join("|")}, got '${v}'`
+			}, { pointer: `/${field}` });
+		}
+	}
+	/** Chunk streams close implicitly on any event of a different type. */
+	function closeChunks(r, emit, atIndex, except) {
+		if (except !== "TEXT_MESSAGE_CHUNK") closeTextChunk(r, atIndex);
+		if (except !== "TOOL_CALL_CHUNK") closeToolChunk(r, emit, atIndex);
+		if (except !== "REASONING_MESSAGE_CHUNK") closeReasoningChunk(r);
+	}
+	/** Unterminated-at-run-end rules. Only on a *clean* end (RUN_FINISHED or a
+	* stream that just stops): after RUN_ERROR, open streams are expected
+	* debris of the failure, and flagging them would manufacture noise. */
+	function endOfRunChecks(r, emit, atIndex) {
+		endOfRunText(r, emit, atIndex);
+		endOfRunToolCalls(r, emit, atIndex);
+		endOfRunSteps(r, emit, atIndex);
+		endOfRunReasoning(r, emit, atIndex);
+	}
+	/** Opens the implicit run scope for streams that never announced one. */
+	function ensureRun(index, type, emit) {
+		if (run === null) {
+			if (!stream.agui001Fired) {
+				emit("AGUI001", { type }, {});
+				stream.agui001Fired = true;
+			}
+			run = newRunState({
+				runId: null,
+				threadId: null,
+				startIndex: index,
+				implicit: true
+			});
+		}
+		return run;
+	}
+	function processEvent(input, batch) {
+		const index = stream.eventCount;
+		stream.eventCount += 1;
+		let parsed = input;
+		if (typeof input === "string") try {
+			parsed = JSON.parse(input);
+		} catch (e) {
+			mkEmit(batch, {
+				index,
+				type: ""
+			})("AGUI502", { error: e instanceof Error ? e.message : String(e) });
+			return;
+		}
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+			mkEmit(batch, {
+				index,
+				type: ""
+			})("AGUI502", { error: `payload is ${describeValue(parsed)}, expected a JSON object` });
+			return;
+		}
+		const ev = parsed;
+		if (typeof ev.type !== "string") {
+			mkEmit(batch, {
+				index,
+				type: ""
+			})("AGUI504", {
+				type: "(untyped)",
+				detail: "event has no string 'type' property"
+			}, { pointer: "/type" });
+			return;
+		}
+		const type = ev.type;
+		const emit = mkEmit(batch, {
+			index,
+			type
+		});
+		if ("timestamp" in ev && ev.timestamp !== void 0) {
+			if (typeof ev.timestamp === "number") stream.sawTimestamp = true;
+			else emit("AGUI504", {
+				type,
+				detail: `field 'timestamp' must be a number, got ${describeValue(ev.timestamp)}`
+			}, { pointer: "/timestamp" });
+		}
+		const spec = EVENT_TABLE[type];
+		if (spec === void 0) {
+			if (DRAFT_EVENT_TYPES.includes(type)) emit("AGUI503", {
+				type,
+				sdkVersion: SDK_VERSION
+			}, {
+				severity: "info",
+				specUrl: DRAFTS_META_URL,
+				messageSuffix: " — documented draft event type, not yet in @ag-ui/core"
+			});
+			else {
+				const canonical = CANONICAL_BY_SQUASHED.get(type.replace(/[_\-\s]/g, "").toLowerCase());
+				emit("AGUI503", {
+					type,
+					sdkVersion: SDK_VERSION
+				}, { ...canonical !== void 0 ? { messageSuffix: ` — did you mean '${canonical}'? AG-UI wire types use SCREAMING_SNAKE_CASE` } : {} });
+			}
+			return;
+		}
+		validateSchema(type, spec, ev, emit);
+		if (type === "RUN_STARTED") {
+			if (run === null) run = newRunState({
+				runId: str(ev, "runId") ?? null,
+				threadId: str(ev, "threadId") ?? null,
+				startIndex: index,
+				implicit: false
+			});
+			else if (run.terminal !== null) run = newRunState({
+				runId: str(ev, "runId") ?? null,
+				threadId: str(ev, "threadId") ?? null,
+				startIndex: index,
+				implicit: false
+			});
+			else if (run.implicit) {
+				closeChunks(run, emit, index);
+				run.implicit = false;
+				run.runId = str(ev, "runId") ?? null;
+				run.threadId = str(ev, "threadId") ?? null;
+			} else {
+				closeChunks(run, emit, index);
+				emit("AGUI002", { runId: str(ev, "runId") ?? "(missing)" }, { relatedEventIndex: run.startIndex });
+			}
+			return;
+		}
+		const r = ensureRun(index, type, emit);
+		if (r.terminal !== null) {
+			const terminalType = r.terminal.type;
+			if ((type === "RUN_FINISHED" || type === "RUN_ERROR") && type !== terminalType) emit("AGUI005", {
+				type,
+				terminalType
+			}, { relatedEventIndex: r.terminal.index });
+			else emit("AGUI004", {
+				type,
+				terminalType
+			}, { relatedEventIndex: r.terminal.index });
+			return;
+		}
+		closeChunks(r, emit, index, type);
+		if (type === "RUN_FINISHED" || type === "RUN_ERROR") {
+			if (type === "RUN_FINISHED") {
+				checkRunIdStability(api(index, type, ev, r, emit));
+				endOfRunChecks(r, emit, index);
+				const outcome = ev.outcome;
+				if (typeof outcome === "object" && outcome !== null && outcome.type === "interrupt") stream.features.add("human-in-the-loop");
+			}
+			r.terminal = {
+				type,
+				index
+			};
+			return;
+		}
+		const a = api(index, type, ev, r, emit);
+		switch (spec.category) {
+			case "lifecycle":
+				handleStepEvent(a);
+				break;
+			case "text":
+				handleTextEvent(a);
+				break;
+			case "toolcall":
+				handleToolCallEvent(a);
+				break;
+			case "state":
+				handleStateEvent(a);
+				break;
+			case "reasoning":
+				handleReasoningEvent(a);
+				break;
+			case "thinking": break;
+			case "activity": break;
+			case "special": if (type === "RAW") {
+				const wrapped = ev.event;
+				if (typeof wrapped === "object" && wrapped !== null) {
+					const wrappedType = wrapped.type;
+					if (typeof wrappedType === "string" && EVENT_TABLE[wrappedType] !== void 0) emit("AGUI901", { wrappedType }, { pointer: "/event/type" });
+				}
+			} else if (type === "CUSTOM") {
+				const name = str(ev, "name");
+				if (name !== void 0) {
+					if (name === "PredictState") stream.features.add("predictive-state-updates");
+					if (!/[.:/]/.test(name)) emit("AGUI903", { name }, { pointer: "/name" });
+				}
+			}
+		}
+	}
+	function api(index, type, event, r, emit) {
+		return {
+			index,
+			type,
+			event,
+			run: r,
+			stream,
+			emit,
+			feature: (f) => stream.features.add(f)
+		};
+	}
+	return {
+		feed(event) {
+			const batch = [];
+			try {
+				processEvent(event, batch);
+			} catch (e) {
+				internalErrors.push(`feed(event ${stream.eventCount - 1}): ${e instanceof Error ? e.stack ?? e.message : String(e)}`);
+			}
+			return batch;
+		},
+		finalize() {
+			if (finalized) return [];
+			finalized = true;
+			const batch = [];
+			const emit = mkEmit(batch, null);
+			try {
+				if (run !== null && run.terminal === null) {
+					closeChunks(run, emit, -1);
+					emit("AGUI003", { runId: run.runId ?? "(unknown)" }, {
+						eventIndex: -1,
+						relatedEventIndex: run.startIndex
+					});
+					endOfRunChecks(run, emit, -1);
+				}
+				if (stream.eventCount > 0 && !stream.sawTimestamp) emit("AGUI902", { eventCount: stream.eventCount }, { eventIndex: -1 });
+				if (declaredFeatures.has("shared-state") && !stream.anySnapshot) emit("AGUI305", {}, { eventIndex: -1 });
+			} catch (e) {
+				internalErrors.push(`finalize(): ${e instanceof Error ? e.stack ?? e.message : String(e)}`);
+			}
+			return batch;
+		},
+		emitExternal(rule, params = {}, extra = {}) {
+			const batch = [];
+			try {
+				mkEmit(batch, null)(rule, params, extra);
+			} catch (e) {
+				internalErrors.push(`emitExternal(${rule}): ${e instanceof Error ? e.message : String(e)}`);
+			}
+			return batch[0] ?? null;
+		},
+		markSkipped(rule, reason) {
+			explicitSkips.set(String(rule), String(reason));
+		},
+		report() {
+			const summary = {
+				errors: 0,
+				warnings: 0,
+				info: 0
+			};
+			for (const d of diagnostics) if (d.severity === "error") summary.errors += 1;
+			else if (d.severity === "warning") summary.warnings += 1;
+			else summary.info += 1;
+			const features = {};
+			for (const f of CANONICAL_FEATURES) features[f] = NOT_INFERABLE.includes(f) ? "not-inferable" : stream.features.has(f) ? "exercised" : "not-exercised";
+			let skipped = layers.has("transport") ? [] : TRANSPORT_RULE_IDS.filter((id) => overrides[id] !== "off").map((rule) => ({
+				rule,
+				reason: TRANSPORT_SKIP_REASON
+			}));
+			if (!declaredFeatures.has("shared-state") && overrides.AGUI305 !== "off") skipped.push({
+				rule: "AGUI305",
+				reason: "only evaluated when the 'shared-state' feature is declared via options.features"
+			});
+			for (const [rule, severity] of Object.entries(overrides)) if (severity === "off" && RULES.has(rule)) skipped.push({
+				rule,
+				reason: "disabled by severityOverrides"
+			});
+			if (explicitSkips.size > 0) {
+				skipped = skipped.filter((s) => !explicitSkips.has(s.rule));
+				for (const [rule, reason] of explicitSkips) skipped.push({
+					rule,
+					reason
+				});
+			}
+			return {
+				diagnostics: [...diagnostics],
+				summary,
+				features,
+				skipped,
+				eventCount: stream.eventCount,
+				internalErrors: [...internalErrors]
+			};
+		}
+	};
+}
+//#endregion
+//#region src/report/pretty.ts
+const SYMBOL = {
+	error: "✖",
+	warning: "⚠",
+	info: "ℹ"
+};
+const SGR = {
+	error: "31",
+	warning: "33",
+	info: "36"
+};
+function paint(code, s, on) {
+	return on ? `\x1b[${code}m${s}\x1b[0m` : s;
+}
+function formatDiagnosticLine(d, opts) {
+	const where = d.eventIndex >= 0 ? `event ${d.eventIndex}` : "—";
+	const head = paint(SGR[d.severity], `${SYMBOL[d.severity]} ${d.rule}`, opts.color);
+	const meta = paint("2", `${d.severity.padEnd(7)} ${where.padEnd(10)}`, opts.color);
+	const cite = paint("2", `  ↳ ${d.specUrl}`, opts.color);
+	return `${head}  ${meta} ${d.message}\n${cite}`;
+}
+//#endregion
+//#region src/vitest/matcher.ts
+function toBeValidAGUI(received, options = {}) {
+	let events;
+	if (typeof received === "string") events = received.split(/\r?\n/).filter((line) => line.trim() !== "");
+	else if (Array.isArray(received)) events = received;
+	else throw new TypeError(`toBeValidAGUI expects an array of events (objects or JSON strings) or a JSONL string; received ${received === null ? "null" : typeof received}. Wrap a single event in an array.`);
+	const validatorOptions = {};
+	if (options.features !== void 0) validatorOptions.features = options.features;
+	if (options.severityOverrides !== void 0) validatorOptions.severityOverrides = options.severityOverrides;
+	const v = createValidator(validatorOptions);
+	for (const e of events) v.feed(e);
+	v.finalize();
+	const report = v.report();
+	const { errors, warnings, info } = report.summary;
+	const pass = decideExitCode(report.summary, options.maxWarnings) === 0;
+	return {
+		pass,
+		message: () => {
+			if (pass) return `expected the stream to violate AG-UI conformance, but it is valid: ${report.eventCount} events, ${errors} errors, ${warnings} warnings, ${info} info`;
+			const lines = [];
+			if (errors > 0) lines.push(`expected a valid AG-UI stream, but found ${errors} error-severity finding${errors === 1 ? "" : "s"}:`);
+			else lines.push(`expected a valid AG-UI stream, but ${warnings} warning${warnings === 1 ? "" : "s"} exceed maxWarnings: ${options.maxWarnings}:`);
+			for (const d of report.diagnostics) {
+				if (d.severity === "info") continue;
+				lines.push(formatDiagnosticLine(d, { color: false }));
+			}
+			return lines.join("\n");
+		}
+	};
+}
+//#endregion
+//#region src/vitest/index.ts
+expect.extend({ toBeValidAGUI(received, options) {
+	return toBeValidAGUI(received, options);
+} });
+//#endregion
+export { toBeValidAGUI };
+
+//# sourceMappingURL=vitest.js.map