veryfront 0.1.502 → 0.1.503

package/src/src/agent/default-hosted-invoke-agent-tool.ts

@@ -10,7 +10,8 @@ import {
   sleepTool,
   type ToolExecutionContext,
 } from "../tool/index.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema, SchemaValidator } from "../extensions/schema/index.js";
 import { buildExecuteToolTraceAttributes } from "./agent-trace-attributes.js";
 import type {
   ChildRunExecutionResult,
@@ -47,9 +48,9 @@ import {
 import type { HostedChildRunIdentifiers } from "./hosted-child-status.js";
 import {
   DEFAULT_HOSTED_CHILD_AGENT_ID,
+  getHostedChildForkToolInputSchema,
   type HostedChildForkRuntimeConfig,
   type HostedChildForkToolInput,
-  hostedChildForkToolInputSchema,
 } from "./hosted-child-tool-input.js";
 import type {
   DefaultHostedChildForkToolAssemblyResult,
@@ -138,16 +139,26 @@ export type DefaultHostedInvokeAgentToolOptions<TContext extends DefaultHostedIn
     ];
   };
 
-export const defaultHostedInvokeAgentSelectionSchema = z.object({
-  agent_id: z.string().optional().describe("Built-in child agent type or user-defined agent id."),
+const defaultHostedInvokeAgentSelectionFields = (v: SchemaValidator) => ({
+  agent_id: v.string().optional().describe("Built-in child agent type or user-defined agent id."),
 });
 
-export const defaultHostedInvokeAgentInputSchema = hostedChildForkToolInputSchema.extend(
-  defaultHostedInvokeAgentSelectionSchema.shape,
+export const getDefaultHostedInvokeAgentSelectionSchema = defineSchema((v) =>
+  v.object(defaultHostedInvokeAgentSelectionFields(v))
 );
 
-export type DefaultHostedInvokeAgentInput = z.infer<
-  typeof defaultHostedInvokeAgentInputSchema
+/** @deprecated Use getDefaultHostedInvokeAgentSelectionSchema() */
+export const defaultHostedInvokeAgentSelectionSchema = getDefaultHostedInvokeAgentSelectionSchema();
+
+export const getDefaultHostedInvokeAgentInputSchema = defineSchema((v) =>
+  getHostedChildForkToolInputSchema().extend(defaultHostedInvokeAgentSelectionFields(v))
+);
+
+/** @deprecated Use getDefaultHostedInvokeAgentInputSchema() */
+export const defaultHostedInvokeAgentInputSchema = getDefaultHostedInvokeAgentInputSchema();
+
+export type DefaultHostedInvokeAgentInput = InferSchema<
+  ReturnType<typeof getDefaultHostedInvokeAgentInputSchema>
 >;
 
 const DEFAULT_USER_AGENT_MODEL = "opus";

package/src/src/agent/durable.ts

@@ -1,6 +1,7 @@
 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";
 
 const AGENT_RUN_API_TIMEOUT_MS = 15_000;
 
@@ -32,19 +33,26 @@ function createTimedAbortSignal(timeoutMs: number, abortSignal?: AbortSignal) {
   };
 }
 
-export const ConversationRunTargetsSchema = z.object({
-  sourceTargetKind: z.enum(["project", "preview_branch"]).nullable(),
-  runtimeTargetKind: z.enum(["production", "preview_branch"]).nullable(),
-  targetBranchId: z.string().uuid().nullable(),
-});
+export const getConversationRunTargetsSchema = defineSchema((v) =>
+  v.object({
+    sourceTargetKind: v.enum(["project", "preview_branch"]).nullable(),
+    runtimeTargetKind: v.enum(["production", "preview_branch"]).nullable(),
+    targetBranchId: v.string().uuid().nullable(),
+  })
+);
+
+/** @deprecated Use getConversationRunTargetsSchema() */
+export const ConversationRunTargetsSchema = getConversationRunTargetsSchema();
 
-export type ConversationRunTargets = z.infer<typeof ConversationRunTargetsSchema>;
+export type ConversationRunTargets = InferSchema<
+  ReturnType<typeof getConversationRunTargetsSchema>
+>;
 
 export function resolveConversationRunTargets(input: {
   projectId?: string | null;
   branchId?: string | null;
 }): ConversationRunTargets {
-  return ConversationRunTargetsSchema.parse(
+  return getConversationRunTargetsSchema().parse(
     !input.projectId
       ? {
         sourceTargetKind: null,
@@ -65,63 +73,76 @@ export function resolveConversationRunTargets(input: {
   );
 }
 
-export const ConversationRunStatusSchema = z.enum([
-  "pending",
-  "running",
-  "waiting_for_tool",
-  "completed",
-  "failed",
-  "cancelled",
-]);
-
-export const ConversationRunProjectionSchema = z
-  .object({
-    runId: z.string().min(1).optional(),
-    run_id: z.string().min(1).optional(),
-    conversationId: z.string().uuid().optional(),
-    conversation_id: z.string().uuid().optional(),
-    messageId: z.string().uuid().optional(),
-    message_id: z.string().uuid().optional(),
-    latestEventId: z.number().int().nonnegative().optional(),
-    latest_event_id: z.number().int().nonnegative().optional(),
-    latestExternalEventSequence: z.number().int().nonnegative().optional(),
-    latest_external_event_sequence: z.number().int().nonnegative().optional(),
-    waitingToolCallId: z.string().min(1).nullable().optional(),
-    waiting_tool_call_id: z.string().min(1).nullable().optional(),
-    waitingToolName: z.string().nullable().optional(),
-    waiting_tool_name: z.string().nullable().optional(),
-    status: ConversationRunStatusSchema,
+export const getConversationRunStatusSchema = defineSchema((v) =>
+  v.enum(["pending", "running", "waiting_for_tool", "completed", "failed", "cancelled"])
+);
+
+/** @deprecated Use getConversationRunStatusSchema() */
+export const ConversationRunStatusSchema = getConversationRunStatusSchema();
+
+export interface ConversationRunProjection {
+  runId: string;
+  conversationId: string;
+  messageId: string;
+  latestEventId: number;
+  latestExternalEventSequence: number;
+  waitingToolCallId: string | null;
+  waitingToolName: string | null;
+  status: "pending" | "running" | "waiting_for_tool" | "completed" | "failed" | "cancelled";
+}
+
+export const getConversationRunProjectionSchema = defineSchema((v) =>
+  v.object({
+    runId: v.string().min(1).optional(),
+    run_id: v.string().min(1).optional(),
+    conversationId: v.string().uuid().optional(),
+    conversation_id: v.string().uuid().optional(),
+    messageId: v.string().uuid().optional(),
+    message_id: v.string().uuid().optional(),
+    latestEventId: v.number().int().nonnegative().optional(),
+    latest_event_id: v.number().int().nonnegative().optional(),
+    latestExternalEventSequence: v.number().int().nonnegative().optional(),
+    latest_external_event_sequence: v.number().int().nonnegative().optional(),
+    waitingToolCallId: v.string().min(1).nullable().optional(),
+    waiting_tool_call_id: v.string().min(1).nullable().optional(),
+    waitingToolName: v.string().nullable().optional(),
+    waiting_tool_name: v.string().nullable().optional(),
+    status: getConversationRunStatusSchema(),
   })
-  .passthrough()
-  .transform((data) => {
-    const runId = data.runId ?? data.run_id;
-    const conversationId = data.conversationId ?? data.conversation_id;
-    const messageId = data.messageId ?? data.message_id;
-    const latestEventId = data.latestEventId ?? data.latest_event_id ?? 0;
-    const latestExternalEventSequence = data.latestExternalEventSequence ??
-      data.latest_external_event_sequence;
-
-    if (!runId || !conversationId || !messageId) {
-      throw new Error("Missing run identifiers in durable run response");
-    }
+    .passthrough()
+    .transform((data): ConversationRunProjection => {
+      const d = data as Record<string, unknown>;
+      const runId = (d.runId ?? d.run_id) as string | undefined;
+      const conversationId = (d.conversationId ?? d.conversation_id) as string | undefined;
+      const messageId = (d.messageId ?? d.message_id) as string | undefined;
+      const latestEventId = ((d.latestEventId ?? d.latest_event_id) as number | undefined) ?? 0;
+      const latestExternalEventSequence = (d.latestExternalEventSequence ??
+        d.latest_external_event_sequence) as number | undefined;
+
+      if (!runId || !conversationId || !messageId) {
+        throw new Error("Missing run identifiers in durable run response");
+      }
 
-    if (latestExternalEventSequence === undefined) {
-      throw new Error("Missing latestExternalEventSequence in durable run response");
-    }
+      if (latestExternalEventSequence === undefined) {
+        throw new Error("Missing latestExternalEventSequence in durable run response");
+      }
 
-    return {
-      runId,
-      conversationId,
-      messageId,
-      latestEventId,
-      latestExternalEventSequence,
-      waitingToolCallId: data.waitingToolCallId ?? data.waiting_tool_call_id ?? null,
-      waitingToolName: data.waitingToolName ?? data.waiting_tool_name ?? null,
-      status: data.status,
-    };
-  });
+      return {
+        runId,
+        conversationId,
+        messageId,
+        latestEventId,
+        latestExternalEventSequence,
+        waitingToolCallId: ((d.waitingToolCallId ?? d.waiting_tool_call_id) as string | null) ??
+          null,
+        waitingToolName: ((d.waitingToolName ?? d.waiting_tool_name) as string | null) ?? null,
+        status: d.status as ConversationRunProjection["status"],
+      };
+    })
+);
 
-export type ConversationRunProjection = z.infer<typeof ConversationRunProjectionSchema>;
+/** @deprecated Use getConversationRunProjectionSchema() */
+export const ConversationRunProjectionSchema = getConversationRunProjectionSchema();
 export type ActiveConversationRunStatus = Extract<
   ConversationRunProjection["status"],
   "pending" | "running" | "waiting_for_tool"
@@ -195,92 +216,108 @@ export interface ConversationRunEventQueueController {
   };
 }
 
-export const CreateConversationRunAcceptedSchema = z
-  .object({
-    run: z
-      .object({
-        runId: z.string().min(1).optional(),
-        run_id: z.string().min(1).optional(),
-      })
-      .passthrough(),
+export const getCreateConversationRunAcceptedSchema = defineSchema((v) =>
+  v.object({
+    run: v.object({
+      runId: v.string().min(1).optional(),
+      run_id: v.string().min(1).optional(),
+    }).passthrough(),
   })
-  .passthrough()
-  .transform((data) => {
-    const runId = data.run.runId ?? data.run.run_id;
-    if (!runId) {
-      throw new Error("Missing run id in canonical create run response");
-    }
-
-    return { runId };
-  });
+    .passthrough()
+    .transform((data): { runId: string } => {
+      const d = data as { run: Record<string, unknown> };
+      const runId = (d.run.runId ?? d.run.run_id) as string | undefined;
+      if (!runId) {
+        throw new Error("Missing run id in canonical create run response");
+      }
+      return { runId };
+    })
+);
+
+/** @deprecated Use getCreateConversationRunAcceptedSchema() */
+export const CreateConversationRunAcceptedSchema = getCreateConversationRunAcceptedSchema();
+
+export const getCompleteConversationRunResponseSchema = defineSchema((v) =>
+  v.object({
+    completed: v.boolean(),
+    run: v.object({
+      runId: v.string().min(1).optional(),
+      run_id: v.string().min(1).optional(),
+      status: v.enum(["pending", "running", "waiting", "completed", "failed", "cancelled"]),
+    }).passthrough(),
+  }).passthrough()
+);
+
+/** @deprecated Use getCompleteConversationRunResponseSchema() */
+export const CompleteConversationRunResponseSchema = getCompleteConversationRunResponseSchema();
+
+export interface AppendConversationRunEventsResponse {
+  latestEventId: number;
+  latestExternalEventSequence: number;
+  appendedCount: number;
+  run: {
+    runId: string;
+    conversationId: string;
+    latestEventId: number;
+    latestExternalEventSequence: number;
+    [key: string]: unknown;
+  };
+}
 
-export const CompleteConversationRunResponseSchema = z
-  .object({
-    completed: z.boolean(),
-    run: z
-      .object({
-        runId: z.string().min(1).optional(),
-        run_id: z.string().min(1).optional(),
-        status: z.enum(["pending", "running", "waiting", "completed", "failed", "cancelled"]),
-      })
-      .passthrough(),
-  })
-  .passthrough();
-
-const AppendConversationRunEventsCamelRunSchema = z
-  .object({
-    runId: z.string().min(1),
-    conversationId: z.string().uuid(),
-    latestEventId: z.number().int().nonnegative(),
-    latestExternalEventSequence: z.number().int().nonnegative(),
-  })
-  .passthrough();
-
-const AppendConversationRunEventsSnakeRunSchema = z
-  .object({
-    run_id: z.string().min(1),
-    conversation_id: z.string().uuid(),
-    latest_event_id: z.number().int().nonnegative(),
-    latest_external_event_sequence: z.number().int().nonnegative(),
-  })
-  .passthrough();
-
-export const AppendConversationRunEventsResponseSchema = z.union([
-  z.object({
-    latestEventId: z.number().int().nonnegative(),
-    latestExternalEventSequence: z.number().int().nonnegative(),
-    appendedCount: z.number().int().nonnegative(),
-    run: AppendConversationRunEventsCamelRunSchema,
-  }),
-  z.object({
-    latest_event_id: z.number().int().nonnegative(),
-    latest_external_event_sequence: z.number().int().nonnegative(),
-    appended_count: z.number().int().nonnegative(),
-    run: AppendConversationRunEventsSnakeRunSchema,
-  }).transform((data) => ({
-    latestEventId: data.latest_event_id,
-    latestExternalEventSequence: data.latest_external_event_sequence,
-    appendedCount: data.appended_count,
-    run: {
-      ...data.run,
-      runId: data.run.run_id,
-      conversationId: data.run.conversation_id,
-      latestEventId: data.run.latest_event_id,
-      latestExternalEventSequence: data.run.latest_external_event_sequence,
-    },
-  })),
-]);
+export const getAppendConversationRunEventsResponseSchema = defineSchema((v) =>
+  v.union([
+    v.object({
+      latestEventId: v.number().int().nonnegative(),
+      latestExternalEventSequence: v.number().int().nonnegative(),
+      appendedCount: v.number().int().nonnegative(),
+      run: v.object({
+        runId: v.string().min(1),
+        conversationId: v.string().uuid(),
+        latestEventId: v.number().int().nonnegative(),
+        latestExternalEventSequence: v.number().int().nonnegative(),
+      }).passthrough(),
+    }),
+    v.object({
+      latest_event_id: v.number().int().nonnegative(),
+      latest_external_event_sequence: v.number().int().nonnegative(),
+      appended_count: v.number().int().nonnegative(),
+      run: v.object({
+        run_id: v.string().min(1),
+        conversation_id: v.string().uuid(),
+        latest_event_id: v.number().int().nonnegative(),
+        latest_external_event_sequence: v.number().int().nonnegative(),
+      }).passthrough(),
+    }).transform((data): AppendConversationRunEventsResponse => {
+      const d = data as Record<string, unknown>;
+      const run = d.run as Record<string, unknown>;
+      return {
+        latestEventId: d.latest_event_id as number,
+        latestExternalEventSequence: d.latest_external_event_sequence as number,
+        appendedCount: d.appended_count as number,
+        run: {
+          ...run,
+          runId: run.run_id as string,
+          conversationId: run.conversation_id as string,
+          latestEventId: run.latest_event_id as number,
+          latestExternalEventSequence: run.latest_external_event_sequence as number,
+        },
+      };
+    }),
+  ])
+);
 
-export type AppendConversationRunEventsResponse = z.infer<
-  typeof AppendConversationRunEventsResponseSchema
->;
+/** @deprecated Use getAppendConversationRunEventsResponseSchema() */
+export const AppendConversationRunEventsResponseSchema =
+  getAppendConversationRunEventsResponseSchema();
 
 const DEFAULT_MAX_CONVERSATION_RUN_BATCH_BYTES = 512 * 1024;
 
-const ConversationRunErrorSchema = z.object({
-  detail: z.string().min(1).optional(),
-  error: z.string().min(1).optional(),
-});
+const getConversationRunErrorSchema = defineSchema((v) =>
+  v.object({
+    detail: v.string().min(1).optional(),
+    error: v.string().min(1).optional(),
+  })
+);
 
 export interface ConversationAgentRunUsage {
   inputTokens: number;
@@ -347,7 +384,7 @@ export function parseAppendConversationRunEventsErrorBody(bodyText: string): str
   }
 
   try {
-    const parsed = ConversationRunErrorSchema.safeParse(JSON.parse(bodyText));
+    const parsed = getConversationRunErrorSchema().safeParse(JSON.parse(bodyText));
     if (parsed.success) {
       return parsed.data.detail ?? parsed.data.error ?? null;
     }
@@ -1067,7 +1104,7 @@ async function controlPlaneJson<T>(input: {
   url: string;
   method?: "GET" | "POST";
   body?: unknown;
-  responseSchema: z.ZodSchema<T>;
+  responseSchema: Schema<T>;
   operation: string;
   abortSignal?: AbortSignal;
 }): Promise<T> {
@@ -1174,7 +1211,12 @@ export async function monitorConversationRunStatus(input: {
       run.status === "failed" ||
       run.status === "cancelled"
     ) {
-      await input.onTerminal(new ConversationRunTerminalStateError(run, run.status));
+      await input.onTerminal(
+        new ConversationRunTerminalStateError(
+          run,
+          run.status as any,
+        ),
+      );
     }
     return;
   }

package/src/src/agent/hosted-ag-ui-chat-request.ts

@@ -1,6 +1,7 @@
 import { mapAgUiRuntimeMessagesToChatUiMessages } from "../chat/ag-ui.js";
 import type { ChatRequestContext, ChatRuntimeOverrides } from "../chat/types.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import {
   createAgUiRuntimeContextMap,
   deriveAgUiForwardedConfig,
@@ -17,19 +18,25 @@ import type {
   ParseHostedChatRequestOptions,
 } from "./hosted-chat-request-parser.js";
 
-export const hostedAgUiChatForwardedConfigSchema = z
-  .object({
-    projectId: z.string().nullable().optional(),
-    branchId: z.string().nullable().optional(),
-    conversationId: z.string().optional(),
-    environmentContext: z.string().optional(),
-    model: z.string().optional(),
-    allowDelegation: z.boolean().optional(),
+export const getHostedAgUiChatForwardedConfigSchema = defineSchema((v) =>
+  v.object({
+    projectId: v.string().nullable().optional(),
+    branchId: v.string().nullable().optional(),
+    conversationId: v.string().optional(),
+    environmentContext: v.string().optional(),
+    model: v.string().optional(),
+    allowDelegation: v.boolean().optional(),
     runtimeOverrides: hostedChatRuntimeOverridesSchema.optional(),
   })
-  .strict();
+    .strict()
+);
 
-export type HostedAgUiChatForwardedConfig = z.infer<typeof hostedAgUiChatForwardedConfigSchema>;
+/** @deprecated Use getHostedAgUiChatForwardedConfigSchema() */
+export const hostedAgUiChatForwardedConfigSchema = getHostedAgUiChatForwardedConfigSchema();
+
+export type HostedAgUiChatForwardedConfig = InferSchema<
+  ReturnType<typeof getHostedAgUiChatForwardedConfigSchema>
+>;
 
 export type DerivedHostedAgUiChatContext = {
   validatedContext: ChatRequestContext;
@@ -52,12 +59,15 @@ export type BuildParsedHostedAgUiRequestOptions = {
   verifyProjectAccess?: ParseHostedChatRequestOptions["verifyProjectAccess"];
 };
 
-const hostedValidationErrorBodySchema = z
-  .object({
-    error: z.string().optional(),
-    details: z.array(z.object({ message: z.string().optional() }).passthrough()).optional(),
+const getHostedValidationErrorBodySchema = defineSchema((v) =>
+  v.object({
+    error: v.string().optional(),
+    details: v.array(v.object({ message: v.string().optional() }).passthrough()).optional(),
   })
-  .passthrough();
+    .passthrough()
+);
+
+const hostedValidationErrorBodySchema = getHostedValidationErrorBodySchema();
 
 async function verifyHostedAgUiProjectAccess(input: {
   projectId: string | null;

package/src/src/agent/hosted-agent-service-routes.ts

@@ -1,4 +1,5 @@
 import { parseProviderError } from "../chat/provider-errors.js";
+import { CONTROL_PLANE_AGENT_STREAM_PATH } from "../channels/control-plane.js";
 import type { AgentServiceRoute } from "./agent-service.js";
 import { createAgUiRunErrorEvent, createAgUiSseErrorResponse } from "./ag-ui-host-support.js";
 import { createAgUiRuntimeHandler } from "./ag-ui-runtime-handler.js";
@@ -332,7 +333,7 @@ export function createHostedAgentServiceRouteSet<TExecution extends object>(
     },
     {
       method: "DELETE",
-      path: "/api/ag-ui/runs/:runId",
+      path: "/api/runs/:runId",
       handler: (request: Request, params: Record<string, string>) =>
         handleDurableChatRunCancelRequest({
           request,
@@ -341,12 +342,12 @@ export function createHostedAgentServiceRouteSet<TExecution extends object>(
     },
     {
       method: "POST",
-      path: "/api/ag-ui/runs",
+      path: "/api/runs",
       handler: (request: Request) => handleDurableChatRunExecuteRequest({ request }),
     },
     {
       method: "POST",
-      path: "/internal/agents/stream",
+      path: CONTROL_PLANE_AGENT_STREAM_PATH,
       handler: (request: Request) => handleRuntimeAgentRunInvocationExecuteRequest({ request }),
     },
   ];

package/src/src/agent/hosted-chat-request-parser.ts

@@ -70,6 +70,10 @@ function createValidationErrorResponse(input: {
   );
 }
 
+function getValidationErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "validation failed";
+}
+
 async function verifyHostedChatProjectAccess(input: {
   projectId: string | null;
   authToken: string;
@@ -123,7 +127,7 @@ export async function buildParsedHostedChatRequest(input: {
   return {
     userId: input.userId,
     authToken: input.authToken,
-    messages,
+    messages: messages as ChatUiMessage[],
     validatedContext: chatContext,
     projectId,
     conversationId,
@@ -153,7 +157,7 @@ export async function parseHostedChatRequestFromRequest(
   if (!parsed.success) {
     return createValidationErrorResponse({
       messagePrefix: "Invalid request",
-      validationMessage: parsed.error.message,
+      validationMessage: getValidationErrorMessage(parsed.error),
     });
   }
 
@@ -178,7 +182,7 @@ export async function parseRuntimeAgentRunInvocationHostedChatRequestFromRequest
   if (!invocation.success) {
     return createValidationErrorResponse({
       messagePrefix: "Invalid runtime agent invocation",
-      validationMessage: invocation.error.message,
+      validationMessage: getValidationErrorMessage(invocation.error),
     });
   }
 
@@ -188,7 +192,7 @@ export async function parseRuntimeAgentRunInvocationHostedChatRequestFromRequest
   if (!chatRequest.success) {
     return createValidationErrorResponse({
       messagePrefix: "Invalid runtime agent invocation",
-      validationMessage: chatRequest.error.message,
+      validationMessage: getValidationErrorMessage(chatRequest.error),
     });
   }