veryfront 0.1.502 → 0.1.503

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",

package/src/src/agent/conversation-bootstrap.ts

@@ -1,30 +1,51 @@
 import "../../_dnt.polyfills.js";
 import * as dntShim from "../../_dnt.shims.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema, Schema } from "../extensions/schema/index.js";
 import { isUuid, toConversationPartsFromUiMessage } from "../chat/conversation.js";
 import type { ChatUiMessage } from "../chat/types.js";
 import { type ConversationRunProjection, createConversationAgentRun } from "./durable.js";
 
 const CONVERSATION_API_TIMEOUT_MS = 15_000;
 
-export const ConversationRecordSchema = z
-  .object({
-    id: z.string(),
-    projectId: z.string().nullable().optional(),
-    project_id: z.string().nullable().optional(),
+// Hand-written transform output type.
+export interface ConversationRecord {
+  id: string;
+  projectId: string | null;
+}
+
+export const getConversationRecordSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    projectId: v.string().nullable().optional(),
+    project_id: v.string().nullable().optional(),
+  })
+    .passthrough()
+    .transform((data): ConversationRecord => {
+      const d = data as Record<string, unknown>;
+      return {
+        id: d.id as string,
+        projectId: (d.projectId as string | null | undefined) ??
+          (d.project_id as string | null | undefined) ?? null,
+      };
+    })
+);
+
+/** @deprecated Use getConversationRecordSchema() */
+export const ConversationRecordSchema = getConversationRecordSchema();
+
+export const getConversationMessageRecordSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().uuid(),
   })
-  .passthrough()
-  .transform((data) => ({
-    id: data.id,
-    projectId: data.projectId ?? data.project_id ?? null,
-  }));
+);
 
-export const ConversationMessageRecordSchema = z.object({
-  id: z.string().uuid(),
-});
+/** @deprecated Use getConversationMessageRecordSchema() */
+export const ConversationMessageRecordSchema = getConversationMessageRecordSchema();
 
-export type ConversationRecord = z.infer<typeof ConversationRecordSchema>;
-export type ConversationMessageRecord = z.infer<typeof ConversationMessageRecordSchema>;
+export type ConversationMessageRecord = InferSchema<
+  ReturnType<typeof getConversationMessageRecordSchema>
+>;
 
 export interface ConversationControlPlaneResponseError {
   status: number;
@@ -43,7 +64,7 @@ async function controlPlaneJson<T>(input: {
   url: string;
   method?: "GET" | "POST" | "PATCH";
   body?: unknown;
-  responseSchema: z.ZodSchema<T>;
+  responseSchema: Schema<T>;
   operation: string;
   onResponseError?: (error: ConversationControlPlaneResponseError) => void;
 }): Promise<T> {

package/src/src/agent/conversation-hosted-lifecycle.ts

@@ -146,16 +146,18 @@ async function publishConversationChildProgress(
   ctx: ConversationChildLifecycleContext,
   status: InvokeAgentChildRunProgressInput["status"],
 ): Promise<void> {
-  await publishInvokeAgentChildRunProgress({
-    authToken: ctx.authToken,
-    apiUrl: ctx.apiUrl,
-    conversationId: ctx.parentConversationId,
-    runId: ctx.parentRunId,
-    ...(ctx.projectId !== undefined ? { projectId: ctx.projectId } : {}),
-    ...ctx.progress,
-    status,
-    ...(ctx.publishParentRunEvents ? { publishParentRunEvents: ctx.publishParentRunEvents } : {}),
-  });
+  await publishInvokeAgentChildRunProgress(
+    {
+      authToken: ctx.authToken,
+      apiUrl: ctx.apiUrl,
+      conversationId: ctx.parentConversationId,
+      runId: ctx.parentRunId,
+      ...(ctx.projectId !== undefined ? { projectId: ctx.projectId } : {}),
+      ...ctx.progress,
+      status,
+      ...(ctx.publishParentRunEvents ? { publishParentRunEvents: ctx.publishParentRunEvents } : {}),
+    } as Parameters<typeof publishInvokeAgentChildRunProgress>[0],
+  );
 }
 
 export function createConversationChildLifecycleAdapter(

package/src/src/agent/conversation-run-events.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { type ChatStreamEvent } from "../chat/protocol.js";
 import { normalizeConversationRunEvents } from "./conversation-run-event-normalization.js";
 
@@ -16,11 +17,18 @@ export const conversationRunEventTypes = {
   toolCallResult: "TOOL_CALL_RESULT",
 } as const;
 
-export const ConversationRunEventSchema = z.object({
-  type: z.string().min(1),
-}).passthrough();
+export const getConversationRunEventSchema = defineSchema((v) =>
+  v.object({
+    type: v.string().min(1),
+  }).passthrough()
+);
 
-export type ConversationRunEvent = z.infer<typeof ConversationRunEventSchema>;
+/** @deprecated Use getConversationRunEventSchema() */
+export const ConversationRunEventSchema = getConversationRunEventSchema();
+
+export type ConversationRunEvent =
+  & InferSchema<ReturnType<typeof getConversationRunEventSchema>>
+  & Record<string, unknown>;
 
 function serializeToolInput(input: unknown): string {
   try {