veryfront 0.1.502 → 0.1.504

package/src/src/agent/ag-ui-run-control.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { extractRequest } from "./ag-ui-request-shared.js";
 import {
   RunNotActiveError,
@@ -7,19 +8,24 @@ import {
   WaitNotPendingError,
 } from "./runtime/resume-session.js";
 
-const RESUME_PATH_REGEX = /^\/api\/ag-ui\/runs\/([^/]+)\/resume$/;
-const CANCEL_PATH_REGEX = /^\/api\/ag-ui\/runs\/([^/]+)$/;
+const RESUME_PATH_REGEX = /^\/api\/runs\/([^/]+)\/resume$/;
+const CANCEL_PATH_REGEX = /^\/api\/runs\/([^/]+)$/;
 
-export const AgUiResumeSignalSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("tool_result"),
-    toolCallId: z.string().min(1).max(128),
-    result: z.unknown(),
-    isError: z.boolean().optional().default(false),
-  }),
-]);
+export const getAgUiResumeSignalSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      type: v.literal("tool_result"),
+      toolCallId: v.string().min(1).max(128),
+      result: v.unknown(),
+      isError: v.boolean().optional().default(false),
+    }),
+  ])
+);
 
-export type AgUiResumeSignal = z.infer<typeof AgUiResumeSignalSchema>;
+/** @deprecated Use getAgUiResumeSignalSchema() */
+export const AgUiResumeSignalSchema = getAgUiResumeSignalSchema();
+
+export type AgUiResumeSignal = InferSchema<ReturnType<typeof getAgUiResumeSignalSchema>>;
 
 type ResumeValue = {
   result: unknown;
@@ -67,7 +73,7 @@ export function createAgUiResumeHandler(
     }
 
     try {
-      const parsed = AgUiResumeSignalSchema.parse(await request.json());
+      const parsed = getAgUiResumeSignalSchema().parse(await request.json());
       const outcome = options.sessionManager.submitSignal(runId, {
         waitKey: parsed.toolCallId,
         value: {
@@ -78,11 +84,16 @@ export function createAgUiResumeHandler(
 
       return Response.json(outcome, { status: 200 });
     } catch (error) {
-      if (error instanceof z.ZodError) {
+      if (
+        error instanceof Error &&
+        "issues" in error &&
+        Array.isArray((error as Record<string, unknown>).issues)
+      ) {
+        const issues = (error as { issues: Array<{ path: unknown[]; message: string }> }).issues;
         return Response.json(
           {
             error: "Invalid AG-UI resume request",
-            details: error.issues.map((issue) => ({
+            details: issues.map((issue) => ({
               path: issue.path,
               message: issue.message,
             })),

package/src/src/agent/ag-ui-runtime-handler.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { isResponseLike } from "./response-like.js";
 import {
   AgentRuntime,
@@ -482,11 +481,16 @@ export function createAgUiRuntimeHandler(
 
       throw new Error("createAgUiRuntimeHandler configuration became invalid during execution.");
     } catch (error) {
-      if (error instanceof z.ZodError) {
+      if (
+        error instanceof Error &&
+        "issues" in error &&
+        Array.isArray((error as Record<string, unknown>).issues)
+      ) {
+        const issues = (error as { issues: Array<{ path: unknown[]; message: string }> }).issues;
         return Response.json(
           {
             error: "Invalid AG-UI runtime request",
-            details: error.issues.map((issue) => ({
+            details: issues.map((issue) => ({
               path: issue.path,
               message: issue.message,
             })),

package/src/src/agent/ag-ui-sse-parser.ts

@@ -0,0 +1,306 @@
+import { isRecord } from "../chat/conversation.js";
+import { safeJsonParse } from "../chat/provider-errors.js";
+
+/** AG-UI runtime event type constants normalized from browser-wire SSE events. */
+export const agUiSseEventTypes = {
+  custom: "CUSTOM",
+  textMessageStart: "TEXT_MESSAGE_START",
+  textMessageContent: "TEXT_MESSAGE_CONTENT",
+  textMessageEnd: "TEXT_MESSAGE_END",
+  reasoningMessageStart: "REASONING_MESSAGE_START",
+  reasoningMessageContent: "REASONING_MESSAGE_CONTENT",
+  reasoningMessageEnd: "REASONING_MESSAGE_END",
+  toolCallStart: "TOOL_CALL_START",
+  toolCallArgs: "TOOL_CALL_ARGS",
+  toolCallEnd: "TOOL_CALL_END",
+  toolCallResult: "TOOL_CALL_RESULT",
+  runStarted: "RUN_STARTED",
+  stateSnapshot: "STATE_SNAPSHOT",
+  messagesSnapshot: "MESSAGES_SNAPSHOT",
+  stepStarted: "STEP_STARTED",
+  stepFinished: "STEP_FINISHED",
+  runError: "RUN_ERROR",
+  runFinished: "RUN_FINISHED",
+} as const;
+
+/** Normalized AG-UI runtime event type value. */
+export type AgUiSseEventType = (typeof agUiSseEventTypes)[keyof typeof agUiSseEventTypes];
+
+/** Parsed AG-UI SSE response summary for evals, canaries, and host tests. */
+export interface ParsedAgUiSseRun {
+  responseStatus: number;
+  events: Array<Record<string, unknown>>;
+  eventTypes: string[];
+  toolStarts: string[];
+  toolArgs: string[];
+  text: string;
+  runError: string | null;
+}
+
+/** Progress snapshot emitted while parsing an AG-UI SSE response. */
+export interface AgUiSseProgressSnapshot {
+  eventCount: number;
+  lastEventType: string | null;
+  lastToolCallName: string | null;
+  toolStarts: string[];
+  textLength: number;
+}
+
+/** Options for `parseAgUiSseResponse()`. */
+export interface ParseAgUiSseResponseOptions {
+  onProgress?: (snapshot: AgUiSseProgressSnapshot) => void;
+  progressThrottleMs?: number;
+}
+
+/** Stringify an AG-UI SSE event or fallback value for diagnostics. */
+export function stringifyAgUiSseEvent(value: unknown): string {
+  return JSON.stringify(value) ?? String(value);
+}
+
+/** Return a string field from a parsed AG-UI SSE event record. */
+export function getAgUiSseStringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key];
+  return typeof value === "string" ? value : null;
+}
+
+/** Filter parsed AG-UI SSE events by normalized event type. */
+export function getAgUiSseEventsOfType(
+  events: Array<Record<string, unknown>>,
+  eventType: string,
+): Array<Record<string, unknown>> {
+  return events.filter((event) => getAgUiSseStringField(event, "type") === eventType);
+}
+
+/** Build a compact ordered event-type signature for regression checks. */
+export function buildAgUiSseTraceSignature(eventTypes: string[]): string {
+  return eventTypes.join(" > ");
+}
+
+function serializeToolResult(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+
+  try {
+    return JSON.stringify(value ?? null);
+  } catch {
+    return String(value);
+  }
+}
+
+function createEmptyParsedRun(responseStatus: number): ParsedAgUiSseRun {
+  return {
+    responseStatus,
+    events: [],
+    eventTypes: [],
+    toolStarts: [],
+    toolArgs: [],
+    text: "",
+    runError: null,
+  };
+}
+
+function createProgressSnapshot(run: ParsedAgUiSseRun): AgUiSseProgressSnapshot {
+  const lastEvent = run.events.at(-1);
+  const lastToolStart = [...run.events]
+    .reverse()
+    .find((event) => getAgUiSseStringField(event, "type") === agUiSseEventTypes.toolCallStart);
+
+  return {
+    eventCount: run.events.length,
+    lastEventType: lastEvent ? getAgUiSseStringField(lastEvent, "type") : null,
+    lastToolCallName: lastToolStart ? getAgUiSseStringField(lastToolStart, "toolCallName") : null,
+    toolStarts: [...run.toolStarts],
+    textLength: run.text.length,
+  };
+}
+
+function applyParsedEvent(run: ParsedAgUiSseRun, event: Record<string, unknown>) {
+  run.events.push(event);
+
+  const type = getAgUiSseStringField(event, "type");
+  if (type) {
+    run.eventTypes.push(type);
+  }
+
+  if (type === agUiSseEventTypes.toolCallStart) {
+    const toolCallName = getAgUiSseStringField(event, "toolCallName");
+    if (toolCallName) {
+      run.toolStarts.push(toolCallName);
+    }
+  }
+
+  if (type === agUiSseEventTypes.toolCallArgs) {
+    const delta = getAgUiSseStringField(event, "delta");
+    if (delta) {
+      run.toolArgs.push(delta);
+    }
+  }
+
+  if (type === agUiSseEventTypes.textMessageContent) {
+    const delta = getAgUiSseStringField(event, "delta");
+    if (delta) {
+      run.text += delta;
+    }
+  }
+}
+
+function coerceBrowserWireEvent(
+  eventName: string,
+  payload: Record<string, unknown>,
+): Record<string, unknown> {
+  switch (eventName) {
+    case "RunStarted":
+      return { type: agUiSseEventTypes.runStarted, ...payload };
+    case "StateSnapshot":
+      return { type: agUiSseEventTypes.stateSnapshot, ...payload };
+    case "MessagesSnapshot":
+      return { type: agUiSseEventTypes.messagesSnapshot, ...payload };
+    case "TextMessageStart":
+      return { type: agUiSseEventTypes.textMessageStart, ...payload };
+    case "TextMessageContent":
+      return { type: agUiSseEventTypes.textMessageContent, ...payload };
+    case "TextMessageEnd":
+      return { type: agUiSseEventTypes.textMessageEnd, ...payload };
+    case "ReasoningMessageStart":
+      return { type: agUiSseEventTypes.reasoningMessageStart, ...payload };
+    case "ReasoningMessageContent":
+      return { type: agUiSseEventTypes.reasoningMessageContent, ...payload };
+    case "ReasoningMessageEnd":
+      return { type: agUiSseEventTypes.reasoningMessageEnd, ...payload };
+    case "StepStarted":
+      return { type: agUiSseEventTypes.stepStarted, ...payload };
+    case "StepFinished":
+      return { type: agUiSseEventTypes.stepFinished, ...payload };
+    case "ToolCallStart":
+      return { type: agUiSseEventTypes.toolCallStart, ...payload };
+    case "ToolCallArgs":
+      return { type: agUiSseEventTypes.toolCallArgs, ...payload };
+    case "ToolCallEnd":
+      return { type: agUiSseEventTypes.toolCallEnd, ...payload };
+    case "ToolCallResult":
+      return {
+        type: agUiSseEventTypes.toolCallResult,
+        ...payload,
+        ...(payload.result !== undefined ? { content: serializeToolResult(payload.result) } : {}),
+      };
+    case "Custom":
+      return { type: agUiSseEventTypes.custom, ...payload };
+    case "RunError":
+      return { type: agUiSseEventTypes.runError, ...payload };
+    case "RunFinished":
+      return { type: agUiSseEventTypes.runFinished, ...payload };
+    default:
+      return { type: eventName, ...payload };
+  }
+}
+
+function normalizeParsedEvent(
+  payload: Record<string, unknown>,
+  eventName: string | null,
+): Record<string, unknown> | null {
+  if (typeof payload.type === "string") {
+    return payload;
+  }
+
+  if (!eventName) {
+    return null;
+  }
+
+  return coerceBrowserWireEvent(eventName, payload);
+}
+
+function consumeSseBuffer(
+  run: ParsedAgUiSseRun,
+  buffer: string,
+  options: ParseAgUiSseResponseOptions,
+  state: { lastProgressAt: number; progressThrottleMs: number },
+): string {
+  let nextBuffer = buffer;
+  let separatorIndex = nextBuffer.indexOf("\n\n");
+
+  while (separatorIndex !== -1) {
+    const entry = nextBuffer.slice(0, separatorIndex).trim();
+    nextBuffer = nextBuffer.slice(separatorIndex + 2);
+    const eventName = entry
+      .split("\n")
+      .flatMap((line) =>
+        line.startsWith("event:") ? [line.slice("event:".length).trimStart()] : []
+      )[0] ?? null;
+
+    const data = entry
+      .split("\n")
+      .flatMap((line) => line.startsWith("data:") ? [line.slice("data:".length).trimStart()] : [])
+      .join("\n");
+
+    if (data.length > 0 && data !== "[DONE]") {
+      const parsed = safeJsonParse(data);
+      if (parsed.ok && isRecord(parsed.value)) {
+        const normalizedEvent = normalizeParsedEvent(parsed.value, eventName);
+        if (normalizedEvent) {
+          applyParsedEvent(run, normalizedEvent);
+          const now = Date.now();
+          if (options.onProgress && now - state.lastProgressAt >= state.progressThrottleMs) {
+            options.onProgress(createProgressSnapshot(run));
+            state.lastProgressAt = now;
+          }
+        }
+      }
+    }
+
+    separatorIndex = nextBuffer.indexOf("\n\n");
+  }
+
+  return nextBuffer;
+}
+
+/** Parse an AG-UI SSE `Response` into normalized events, text, tool starts, and terminal error state. */
+export async function parseAgUiSseResponse(
+  response: Response,
+  options: ParseAgUiSseResponseOptions = {},
+): Promise<ParsedAgUiSseRun> {
+  const run = createEmptyParsedRun(response.status);
+  const decoder = new TextDecoder();
+  const rawChunks: string[] = [];
+  const state = { lastProgressAt: 0, progressThrottleMs: options.progressThrottleMs ?? 15_000 };
+
+  if (!response.body) {
+    const body = await response.text();
+    rawChunks.push(body);
+  } else {
+    const reader = response.body.getReader();
+    let buffer = "";
+
+    while (true) {
+      const result = await reader.read();
+      if (result.done) {
+        const tail = decoder.decode();
+        if (tail.length > 0) {
+          rawChunks.push(tail);
+          buffer += tail;
+        }
+        break;
+      }
+
+      const decoded = decoder.decode(result.value, { stream: true });
+      rawChunks.push(decoded);
+      buffer += decoded;
+      buffer = consumeSseBuffer(run, buffer, options, state);
+    }
+  }
+
+  if (options.onProgress) {
+    options.onProgress(createProgressSnapshot(run));
+  }
+
+  run.text = run.text.trim();
+
+  const runErrorEvent = getAgUiSseEventsOfType(run.events, agUiSseEventTypes.runError)[0];
+  run.runError = runErrorEvent && typeof runErrorEvent.message === "string"
+    ? runErrorEvent.message
+    : response.ok
+    ? null
+    : rawChunks.join("").trim() || `${response.status}`;
+
+  return run;
+}

package/src/src/agent/ag-ui-tool-shared.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { Schema } from "../extensions/schema/index.js";
 import { SKILL_TOOL_IDS } from "../skill/types.js";
 import { toolRegistry } from "../tool/registry.js";
 import type { Tool } from "../tool/types.js";
@@ -7,6 +8,8 @@ import type { Agent } from "./types.js";
 
 export type AgUiResumeValue = { result: unknown; isError: boolean };
 
+const getAnyObjectSchema = defineSchema((v) => v.record(v.string(), v.unknown()));
+
 export interface AgUiInjectedToolLike {
   name: string;
   description?: string;
@@ -22,7 +25,7 @@ export function createInjectedAgUiTool(
     id: tool.name,
     type: "function",
     description: tool.description ?? tool.name,
-    inputSchema: z.record(z.string(), z.unknown()),
+    inputSchema: getAnyObjectSchema() as Schema<Record<string, unknown>>,
     inputSchemaJson: (tool.parameters ??
       { type: "object", properties: {}, additionalProperties: true }) as Tool["inputSchemaJson"],
     execute: async (_input, context) => {

package/src/src/agent/chat-handler.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { isResponseLike } from "./response-like.js";
 import { getAgent } from "./composition/index.js";
 import type { Message } from "./types.js";
@@ -13,72 +14,88 @@ const MAX_TEXT_PART_LENGTH = 10_000;
 const MAX_MESSAGES_PER_REQUEST = 100;
 
 // ---------------------------------------------------------------------------
-// Zod schemas for validating parts-based chat UI messages
+// Schemas for validating parts-based chat UI messages
 // ---------------------------------------------------------------------------
 
-const textPartSchema = z.object({
-  type: z.literal("text"),
-  text: z.string().max(MAX_TEXT_PART_LENGTH),
-  state: z.string().optional(),
-});
-
-const toolCallPartSchema = z.object({
-  type: z.literal("tool-call"),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  args: z.unknown(),
-});
-
-const toolResultPartSchema = z.object({
-  type: z.literal("tool-result"),
-  toolCallId: z.string(),
-  result: z.unknown(),
-});
-
-const dynamicToolPartSchema = z
-  .object({
-    type: z.string().startsWith("tool-"),
-    toolCallId: z.string(),
-    toolName: z.string(),
-    state: z.string().optional(),
-    input: z.unknown().optional(),
-    output: z.unknown().optional(),
+const getTextPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("text"),
+    text: v.string().max(MAX_TEXT_PART_LENGTH),
+    state: v.string().optional(),
   })
-  .passthrough();
-
-const stepPartSchema = z.object({
-  type: z.enum(["step-start", "step-end"]),
-  stepIndex: z.number().optional(),
-}).passthrough();
-
-const reasoningPartSchema = z.object({
-  type: z.literal("reasoning"),
-  text: z.string(),
-  state: z.string().optional(),
-}).passthrough();
-
-const partSchema = z.union([
-  textPartSchema,
-  toolCallPartSchema,
-  toolResultPartSchema,
-  dynamicToolPartSchema,
-  stepPartSchema,
-  reasoningPartSchema,
-]);
-
-const messageSchema = z.object({
-  id: z.string().optional(),
-  role: z.enum(["user", "assistant", "system", "tool"]),
-  parts: z.array(partSchema).min(1),
-});
-
-const chatRequestSchema = z.object({
-  messages: z.array(messageSchema).min(1).max(MAX_MESSAGES_PER_REQUEST),
-  model: z.string().optional(),
-});
-
-type ParsedMessage = z.infer<typeof messageSchema>;
-type ParsedTextPart = z.infer<typeof textPartSchema>;
+);
+
+const getToolCallPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("tool-call"),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    args: v.unknown(),
+  })
+);
+
+const getToolResultPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("tool-result"),
+    toolCallId: v.string(),
+    result: v.unknown(),
+  })
+);
+
+const getDynamicToolPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.string(),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    state: v.string().optional(),
+    input: v.unknown().optional(),
+    output: v.unknown().optional(),
+  }).passthrough()
+);
+
+const getStepPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(["step-start", "step-end"]),
+    stepIndex: v.number().optional(),
+  }).passthrough()
+);
+
+const getReasoningPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("reasoning"),
+    text: v.string(),
+    state: v.string().optional(),
+  }).passthrough()
+);
+
+const getPartSchema = defineSchema((v) =>
+  v.union([
+    getTextPartSchema(),
+    getToolCallPartSchema(),
+    getToolResultPartSchema(),
+    getDynamicToolPartSchema(),
+    getStepPartSchema(),
+    getReasoningPartSchema(),
+  ])
+);
+
+const getMessageSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().optional(),
+    role: v.enum(["user", "assistant", "system", "tool"]),
+    parts: v.array(getPartSchema()).min(1),
+  })
+);
+
+const getChatRequestSchema = defineSchema((v) =>
+  v.object({
+    messages: v.array(getMessageSchema()).min(1).max(MAX_MESSAGES_PER_REQUEST),
+    model: v.string().optional(),
+  })
+);
+
+type ParsedMessage = InferSchema<ReturnType<typeof getMessageSchema>>;
+type ParsedTextPart = InferSchema<ReturnType<typeof getTextPartSchema>>;
 
 // ---------------------------------------------------------------------------
 // Message transformation
@@ -414,7 +431,7 @@ export function createChatHandler(
 
     try {
       const body = await request.json();
-      const { messages: rawMessages, model: requestModel } = chatRequestSchema.parse(body);
+      const { messages: rawMessages, model: requestModel } = getChatRequestSchema().parse(body);
 
       const context = typeof options?.context === "function"
         ? await options.context(request)
@@ -446,11 +463,16 @@ export function createChatHandler(
 
       return result.toDataStreamResponse();
     } catch (error) {
-      if (error instanceof z.ZodError) {
+      if (
+        error instanceof Error &&
+        "issues" in error &&
+        Array.isArray((error as Record<string, unknown>).issues)
+      ) {
+        const issues = (error as { issues: Array<{ path: unknown[]; message: string }> }).issues;
         return Response.json(
           {
             error: "Invalid request",
-            details: error.issues.map((e) => ({ path: e.path, message: e.message })),
+            details: issues.map((e) => ({ path: e.path, message: e.message })),
           },
           { status: 400 },
         );

package/src/src/agent/composition/composition.ts

@@ -14,14 +14,14 @@ import type { Tool } from "../../tool/index.js";
 import { setActiveSpanAttributes, withSpan } from "../../observability/tracing/otlp-setup.js";
 import { ScopedRegistryFacade } from "../../registry/scoped-registry-facade.js";
 import { ProjectScopedRegistryManager } from "../../registry/project-scoped-registry-manager.js";
-import { AgentToolInputSchema } from "../schemas/index.js";
+import { getAgentToolInputSchema } from "../schemas/index.js";
 
 export function agentAsTool(agent: Agent, description: string): Tool {
   return {
     id: `agent_${agent.id}`,
     type: "function",
     description,
-    inputSchema: AgentToolInputSchema,
+    inputSchema: getAgentToolInputSchema(),
     execute({ input }) {
       return withSpan(
         "agent.composition.agentAsTool.execute",