veryfront 0.1.502 → 0.1.504

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 {

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;
@@ -165,6 +175,7 @@ export async function buildParsedHostedAgUiRequest(
   }
 
   return {
+    agentId: undefined,
     agUiInput: input.agUiInput,
     userId: input.userId,
     authToken: input.authToken,