feat(core)!: extract zod from @ag-ui/core, ship @ag-ui/core/schemas subpath

docs/sdk/js/core/events.mdx

@@ -589,43 +589,51 @@ The following event types are deprecated:
 See [Reasoning Migration](/concepts/reasoning#migration-from-thinking-events)
 for detailed migration guidance.
 
-## Event Schemas
-
-The SDK uses Zod schemas to validate events:
-
-```typescript
-const EventSchemas = z.discriminatedUnion("type", [
-  TextMessageStartEventSchema,
-  TextMessageContentEventSchema,
-  TextMessageEndEventSchema,
-  ToolCallStartEventSchema,
-  ToolCallArgsEventSchema,
-  ToolCallEndEventSchema,
-  ToolCallResultEventSchema,
-  StateSnapshotEventSchema,
-  StateDeltaEventSchema,
-  MessagesSnapshotEventSchema,
-  ActivitySnapshotEventSchema,
-  ActivityDeltaEventSchema,
-  RawEventSchema,
-  CustomEventSchema,
-  RunStartedEventSchema,
-  RunFinishedEventSchema,
-  RunErrorEventSchema,
-  StepStartedEventSchema,
-  StepFinishedEventSchema,
-  ReasoningStartEventSchema,
-  ReasoningMessageStartEventSchema,
-  ReasoningMessageContentEventSchema,
-  ReasoningMessageEndEventSchema,
-  ReasoningMessageChunkEventSchema,
-  ReasoningEndEventSchema,
-  ReasoningEncryptedValueEventSchema,
-])
-```
-
-This allows for runtime validation of events and provides TypeScript type
-inference.
+## Event validation
+
+`@ag-ui/core` ships TypeScript types for every event but does not bundle a runtime
+schema validator in its main entry. Consumers that need to validate untrusted event
+streams (for example, when parsing wire data over HTTP) plug in an `AgentValidator` —
+a pluggable interface based on [Standard Schema](https://github.com/standard-schema/standard-schema).
+
+The `@ag-ui/core/schemas` subpath exports a ready-made `zodValidator` backed by zod.
+Install zod explicitly to use it (zod is an optional peer dependency):
+
+```typescript
+import { zodValidator } from "@ag-ui/core/schemas";
+import { EventType } from "@ag-ui/core";
+
+const result = zodValidator.validateEvent({
+  type: EventType.TEXT_MESSAGE_START,
+  messageId: "msg-1",
+  // role defaults to "assistant" when omitted
+});
+
+if (result.success) {
+  // result.value is typed as { type: EventType; [k: string]: unknown }
+  console.log(result.value);
+} else {
+  console.error("Invalid event:", result.issues);
+}
+```
+
+For a custom validator backed by zod, valibot, arktype, or any library that implements
+the Standard Schema spec:
+
+```typescript
+import { fromStandardSchema, type AgentValidator } from "@ag-ui/core";
+import { z } from "zod";
+
+const myEventSchema = z.object({ type: z.string() }).passthrough();
+
+const myValidator: AgentValidator = {
+  validateEvent: fromStandardSchema(myEventSchema),
+};
+```
+
+The HTTP transform in `@ag-ui/client` and the protobuf decoder in `@ag-ui/proto`
+both accept an optional validator argument and default to `zodValidator` from
+`@ag-ui/core/schemas`, preserving full runtime validation with no additional setup.
 
 ### ToolCallChunkEvent
 

docs/sdk/js/core/multimodal-inputs.mdx

@@ -11,7 +11,7 @@ description:
 multimodal content parts.
 
 ```typescript
-import { UserMessage } from "@ag-ui/core"
+import type { UserMessage } from "@ag-ui/core"
 
 const message: UserMessage = {
   id: "user-1",

integrations/adk-middleware/typescript/package.json

@@ -34,7 +34,8 @@
     "@arethetypeswrong/cli": "^0.17.4",
     "tsdown": "^0.20.1",
     "typescript": "^5.3.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.18",
+    "zod": "^3.24.0"
   },
   "exports": {
     ".": {

integrations/adk-middleware/typescript/src/index.ts

@@ -1,5 +1,6 @@
 import { HttpAgent } from "@ag-ui/client";
-import { AgentCapabilities, AgentCapabilitiesSchema } from "@ag-ui/core";
+import type { AgentCapabilities } from "@ag-ui/core";
+import { AgentCapabilitiesSchema } from "@ag-ui/core/schemas";
 
 export class ADKAgent extends HttpAgent {
   /**

sdks/typescript/README.md

@@ -7,11 +7,11 @@ For more information visit the [official documentation](https://docs.ag-ui.com/)
 ## Multimodal user messages
 
 ```ts
-import { UserMessageSchema } from "@ag-ui/core";
+import type { UserMessage } from "@ag-ui/core";
 
-const message = UserMessageSchema.parse({
+const message: UserMessage = {
   id: "user-123",
-  role: "user" as const,
+  role: "user",
   content: [
     { type: "text", text: "Please describe this image" },
     {
@@ -23,7 +23,7 @@ const message = UserMessageSchema.parse({
       },
     },
   ],
-});
+};
 
 console.log(message);
 // { id: "user-123", role: "user", content: [...] }

sdks/typescript/packages/client/src/transform/http.ts

@@ -1,10 +1,10 @@
-import { BaseEvent, EventSchemas } from "@ag-ui/core";
+import { BaseEvent, EventType, type AgentValidator } from "@ag-ui/core";
+import { zodValidator } from "@ag-ui/core/schemas";
 import { Subject, ReplaySubject, Observable } from "rxjs";
 import { HttpEvent, HttpEventType } from "../run/http-request";
 import { parseSSEStream } from "./sse";
 import { parseProtoStream } from "./proto";
 import * as proto from "@ag-ui/proto";
-import { EventType } from "@ag-ui/core";
 import { type DebugLoggerInput, resolveDebugLogger } from "@/debug-logger";
 
 /**
@@ -13,6 +13,7 @@ import { type DebugLoggerInput, resolveDebugLogger } from "@/debug-logger";
 export const transformHttpEventStream = (
   source$: Observable<HttpEvent>,
   debugLogger?: DebugLoggerInput,
+  validator: AgentValidator = zodValidator,
 ): Observable<BaseEvent> => {
   const log = resolveDebugLogger(debugLogger);
   const eventSubject = new Subject<BaseEvent>();
@@ -51,16 +52,22 @@ export const transformHttpEventStream = (
           // Use SSE JSON parser for all other cases
           parseSSEStream(bufferSubject, log).subscribe({
             next: (json) => {
-              try {
-                const parsedEvent = EventSchemas.parse(json);
-                log?.event("HTTP", "Event validated:", parsedEvent, {
-                  type: parsedEvent.type,
+              const result = validator.validateEvent(json);
+              if (result.success) {
+                log?.event("HTTP", "Event validated:", result.value, {
+                  type: result.value.type,
                   valid: true,
                 });
-                eventSubject.next(parsedEvent as BaseEvent);
-              } catch (err) {
-                log?.event("HTTP", "Event invalid:", { json, error: String(err) });
-                eventSubject.error(err);
+                eventSubject.next(result.value as BaseEvent);
+              } else {
+                log?.event("HTTP", "Event invalid:", { json, issues: result.issues });
+                eventSubject.error(
+                  new Error(
+                    `Invalid event: ${result.issues
+                      .map((i) => (i.path?.length ? `[${i.path.join(".")}] ${i.message}` : i.message))
+                      .join("; ")}`,
+                  ),
+                );
               }
             },
             error: (err) => {

sdks/typescript/packages/client/vitest.config.ts

@@ -8,6 +8,7 @@ export default mergeConfig(
     resolve: {
       alias: {
         "@/": path.resolve(__dirname, "./src") + "/",
+        "@ag-ui/core/schemas": path.resolve(__dirname, "../core/src/schemas.ts"),
         "@ag-ui/core": path.resolve(__dirname, "../core/src/index.ts"),
         "@ag-ui/proto": path.resolve(__dirname, "../proto/src/index.ts"),
         "@ag-ui/encoder": path.resolve(__dirname, "../encoder/src/index.ts"),