veryfront 0.1.502 → 0.1.504

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

@@ -27,6 +27,7 @@ export type HostedChatProjectAccessResult =
   | { success: false; error: HostedChatProjectAccessError };
 
 export type ParsedHostedChatRequest = {
+  agentId: string | undefined;
   userId: string;
   authToken: string;
   messages: ChatUiMessage[];
@@ -70,6 +71,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;
@@ -95,6 +100,7 @@ async function verifyHostedChatProjectAccess(input: {
 
 export async function buildParsedHostedChatRequest(input: {
   chatRequest: HostedChatRequest;
+  agentId?: string;
   authToken: string;
   userId: string;
   verifyProjectAccess?: ParseHostedChatRequestOptions["verifyProjectAccess"];
@@ -121,9 +127,10 @@ export async function buildParsedHostedChatRequest(input: {
   }
 
   return {
+    agentId: input.agentId,
     userId: input.userId,
     authToken: input.authToken,
-    messages,
+    messages: messages as ChatUiMessage[],
     validatedContext: chatContext,
     projectId,
     conversationId,
@@ -153,7 +160,7 @@ export async function parseHostedChatRequestFromRequest(
   if (!parsed.success) {
     return createValidationErrorResponse({
       messagePrefix: "Invalid request",
-      validationMessage: parsed.error.message,
+      validationMessage: getValidationErrorMessage(parsed.error),
     });
   }
 
@@ -178,7 +185,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 +195,7 @@ export async function parseRuntimeAgentRunInvocationHostedChatRequestFromRequest
   if (!chatRequest.success) {
     return createValidationErrorResponse({
       messagePrefix: "Invalid runtime agent invocation",
-      validationMessage: chatRequest.error.message,
+      validationMessage: getValidationErrorMessage(chatRequest.error),
     });
   }
 
@@ -196,6 +203,7 @@ export async function parseRuntimeAgentRunInvocationHostedChatRequestFromRequest
     authToken: authenticatedRequest.authToken,
     userId: authenticatedRequest.userId,
     chatRequest: chatRequest.data,
+    agentId: invocation.data.run.agentId,
     verifyProjectAccess: options.verifyProjectAccess,
   });
 }

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

@@ -1,44 +1,58 @@
 import type { ChatRuntimeOverrides, DurableRootRunDescriptor } from "../chat/types.js";
-import { chatRequestContextSchema, chatUiMessagesSchema } from "../chat/types.js";
-import { z } from "zod";
+import { getChatRequestContextSchema, getChatUiMessagesSchema } from "../chat/types.js";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import type { RuntimeAgentRunInvocation } from "./runtime-agent-invocation-contract.js";
 
-const durableRootRunIdSchema = z.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/);
+const getDurableRootRunIdSchema = defineSchema((v) =>
+  v.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/)
+);
 
-export const hostedDurableRootRunDescriptorSchema: z.ZodType<DurableRootRunDescriptor> = z
-  .object({
-    runId: durableRootRunIdSchema,
-    messageId: z.string().uuid(),
-    latestEventId: z.number().int().nonnegative().optional(),
-    latestExternalEventSequence: z.number().int().nonnegative().optional(),
-    parentConversationId: z.string().uuid().optional(),
-    parentRunId: durableRootRunIdSchema.optional(),
-    spawnedFromToolCallId: z.string().min(1).max(256).optional(),
-  })
-  .strict();
+export const getHostedDurableRootRunDescriptorSchema = defineSchema((v) =>
+  v.object({
+    runId: getDurableRootRunIdSchema(),
+    messageId: v.string().uuid(),
+    latestEventId: v.number().int().nonnegative().optional(),
+    latestExternalEventSequence: v.number().int().nonnegative().optional(),
+    parentConversationId: v.string().uuid().optional(),
+    parentRunId: getDurableRootRunIdSchema().optional(),
+    spawnedFromToolCallId: v.string().min(1).max(256).optional(),
+  }).strict()
+);
+
+/** @deprecated Use getHostedDurableRootRunDescriptorSchema() */
+export const hostedDurableRootRunDescriptorSchema = getHostedDurableRootRunDescriptorSchema();
+
+export const getHostedChatRuntimeOverridesSchema = defineSchema((v) =>
+  v.object({
+    allowedTools: v.array(v.string().min(1)).max(100).optional(),
+    thinking: v.union([v.literal(false), v.number().int().positive()]).optional(),
+    maxSteps: v.number().int().positive().optional(),
+  }).strip()
+);
+
+/** @deprecated Use getHostedChatRuntimeOverridesSchema() */
+export const hostedChatRuntimeOverridesSchema = getHostedChatRuntimeOverridesSchema();
 
-export const hostedChatRuntimeOverridesSchema: z.ZodType<ChatRuntimeOverrides> = z
-  .object({
-    allowedTools: z.array(z.string().min(1)).max(100).optional(),
-    thinking: z.union([z.literal(false), z.number().int().positive()]).optional(),
-    maxSteps: z.number().int().positive().optional(),
+export const getHostedChatRequestSchema = defineSchema((v) =>
+  v.object({
+    messages: getChatUiMessagesSchema(),
+    context: getChatRequestContextSchema(),
+    model: v.string().optional(),
+    allowDelegation: v.boolean().optional(),
+    forwardedProps: v.record(v.string(), v.unknown()).optional(),
+    runtimeOverrides: getHostedChatRuntimeOverridesSchema().optional(),
+    durableRootRun: getHostedDurableRootRunDescriptorSchema().optional(),
   })
-  .strip();
+);
 
-export const hostedChatRequestSchema = z.object({
-  messages: chatUiMessagesSchema,
-  context: chatRequestContextSchema,
-  model: z.string().optional(),
-  allowDelegation: z.boolean().optional(),
-  forwardedProps: z.record(z.string(), z.unknown()).optional(),
-  runtimeOverrides: hostedChatRuntimeOverridesSchema.optional(),
-  durableRootRun: hostedDurableRootRunDescriptorSchema.optional(),
-});
+/** @deprecated Use getHostedChatRequestSchema() */
+export const hostedChatRequestSchema = getHostedChatRequestSchema();
 
-export type HostedChatRequest = z.infer<typeof hostedChatRequestSchema>;
+export type HostedChatRequest = InferSchema<ReturnType<typeof getHostedChatRequestSchema>>;
 export type HostedChatRequestInput = {
   messages: RuntimeAgentRunInvocation["messages"];
-  context: z.infer<typeof chatRequestContextSchema>;
+  context: InferSchema<ReturnType<typeof getChatRequestContextSchema>>;
   model?: string;
   allowDelegation?: boolean;
   forwardedProps?: Record<string, unknown>;
@@ -92,7 +106,7 @@ export function buildHostedChatRequestInputFromRuntimeAgentInvocation(
 export function buildHostedChatRequestFromRuntimeAgentInvocation(
   input: RuntimeAgentRunInvocation,
 ): HostedChatRequest {
-  return hostedChatRequestSchema.parse(
+  return getHostedChatRequestSchema().parse(
     buildHostedChatRequestInputFromRuntimeAgentInvocation(input),
   );
 }

package/src/src/agent/hosted-child-fork-step-message-preparation.ts

@@ -79,7 +79,9 @@ export function prepareHostedChildForkRuntimeStepMessages(
 ): HostedChildForkRuntimeStepMessages {
   const currentInstructions = input.buildInstructions();
   const compactedMessages = compactForStep(
-    convertAgentRuntimeMessagesToProviderMessages(input.messages),
+    convertAgentRuntimeMessagesToProviderMessages(
+      input.messages as any,
+    ),
     estimateOverhead(currentInstructions, input.forkToolNames.length),
   );
   const resolvedSystem = input.resolveSystem?.({

package/src/src/agent/hosted-child-status.ts

@@ -90,6 +90,8 @@ export function resolveHostedChildTerminalErrorCode(
       return hostedChildTerminalErrorCodes.failed;
     case "completed":
       return hostedChildTerminalErrorCodes.completedExternally;
+    default:
+      return hostedChildTerminalErrorCodes.failed;
   }
 }
 
@@ -149,7 +151,12 @@ export async function monitorHostedChildRunStatus(
         continue;
       }
 
-      input.onTerminal(new HostedChildTerminalStateError(run.status, input.identifiers));
+      input.onTerminal(
+        new HostedChildTerminalStateError(
+          run.status as never,
+          input.identifiers,
+        ),
+      );
       return;
     } catch (error) {
       if (input.abortSignal?.aborted || isAbortError(error)) {

package/src/src/agent/hosted-child-tool-input.ts

@@ -1,28 +1,36 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { withDefaultResearchArtifactPath } from "./default-research-artifact-policy.js";
 import type { RuntimeAgentThinkingConfig } from "./runtime-agent-definition.js";
 
 export const DEFAULT_HOSTED_CHILD_AGENT_ID = "invoke-agent-child";
 
-export const hostedChildForkToolInputSchema = z.object({
-  description: z.string().describe("3-5 word task summary"),
-  prompt: z.string().describe("Detailed instructions for the task"),
-  project_id: z.string().optional().describe(
-    "Override project context. Use after studio_open_project.",
-  ),
-  tools: z.array(z.string()).optional().describe(
-    "Tool subset for this fork. Omit = inherit all parent tools.",
-  ),
-  model: z.string().optional().describe('Model override (e.g. "sonnet" for cheaper work).'),
-  thinking: z
-    .number()
-    .nonnegative()
-    .optional()
-    .describe("Thinking override in budget tokens. Use 0 to disable thinking."),
-  max_steps: z.number().optional().describe("Max steps override."),
-});
+export const getHostedChildForkToolInputSchema = defineSchema((v) =>
+  v.object({
+    description: v.string().describe("3-5 word task summary"),
+    prompt: v.string().describe("Detailed instructions for the task"),
+    project_id: v.string().optional().describe(
+      "Override project context. Use after studio_open_project.",
+    ),
+    tools: v.array(v.string()).optional().describe(
+      "Tool subset for this fork. Omit = inherit all parent tools.",
+    ),
+    model: v.string().optional().describe('Model override (e.g. "sonnet" for cheaper work).'),
+    thinking: v
+      .number()
+      .nonnegative()
+      .optional()
+      .describe("Thinking override in budget tokens. Use 0 to disable thinking."),
+    max_steps: v.number().optional().describe("Max steps override."),
+  })
+);
 
-export type HostedChildForkToolInput = z.infer<typeof hostedChildForkToolInputSchema>;
+/** @deprecated Use getHostedChildForkToolInputSchema() */
+export const hostedChildForkToolInputSchema = getHostedChildForkToolInputSchema();
+
+export type HostedChildForkToolInput = InferSchema<
+  ReturnType<typeof getHostedChildForkToolInputSchema>
+>;
 
 export type HostedChildForkRuntimeConfig = {
   description: string;

package/src/src/agent/hosted-durable-child-fork-execution.ts

@@ -491,8 +491,8 @@ async function executeHostedDurableChildLifecycle<
       childRunId: identifiers.childRunId,
       childMessageId: identifiers.childMessageId,
       description: input.forkInput.description,
-      sourceTargetKind: targets.sourceTargetKind,
-      runtimeTargetKind: targets.runtimeTargetKind,
+      sourceTargetKind: targets.sourceTargetKind as any,
+      runtimeTargetKind: targets.runtimeTargetKind as any,
       targetBranchId: targets.targetBranchId,
     },
     model: bootstrapContext.resolvedModel,
@@ -524,7 +524,7 @@ async function executeHostedDurableChildLifecycle<
     }
 
     return input.buildTerminalFailureResult({
-      status: lifecycleResult.terminalState.status,
+      status: lifecycleResult.terminalState.status as any,
       identifiers,
       targets,
       terminalErrorCode: lifecycleResult.terminalState.terminalErrorCode ??

package/src/src/agent/hosted-form-input-tool.ts

@@ -5,7 +5,7 @@ import {
   buildInputRequestLifecycleDataEvent,
   createInputRequest,
   type FormInputToolInput,
-  formInputToolInputSchema,
+  getFormInputToolInputSchema,
   getInputRequest,
   type InputRequestOutput,
 } from "./input-request-protocol.js";
@@ -22,10 +22,10 @@ export interface HostedFormInputToolContext {
 }
 
 export function createHostedFormInputTool(context: HostedFormInputToolContext, apiUrl: string) {
-  return tool({
+  return tool<FormInputToolInput, unknown>({
     description:
       "Display a durable structured form to collect user input. Use this when you need a concrete choice or structured values before continuing. The request is persisted as an input_request and the tool waits until the user submits or the request expires.",
-    inputSchema: formInputToolInputSchema,
+    inputSchema: getFormInputToolInputSchema(),
     execute: async (input, execOptions) =>
       executeDurableFormInputFlow(context, apiUrl, input, execOptions),
   });
@@ -51,11 +51,21 @@ async function executeDurableFormInputFlow(
       ? execContext.toolCallId
       : `form_input-${dntShim.crypto.randomUUID()}`;
 
-  const { result, createdRequest } = await executeDurableHumanInputFlow({
+  // Explicitly type the executeDurableHumanInputFlow generics so
+  // `created`/`createdRequest`/`current` are correctly typed downstream.
+  // (The contract DSL erases callback parameter types through .transform, so
+  // we annotate at the boundary to keep inference flowing.)
+  const { result, createdRequest } = await executeDurableHumanInputFlow<
+    InputRequestOutput,
+    InputRequestOutput
+  >({
     runId: parentRunId,
     threadId: conversationId,
     toolCallId,
-    request: input,
+    // FormInputToolInput omits `metadata`; spread it explicitly as undefined to
+    // satisfy the contract DSL's strict object shape (optional fields are
+    // typed as required-key, undefined-or-T value).
+    request: { ...input, metadata: undefined },
     timeoutMs: INPUT_REQUEST_TIMEOUT_MS + 5_000,
     pollIntervalMs: INPUT_REQUEST_POLL_INTERVAL_MS,
     onRequest: async (pendingRequest) => {

package/src/src/agent/human-input.ts

@@ -1,103 +1,140 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { z } from "zod";
-import { AgUiRuntimeRunIdSchema } from "./runtime-ag-ui-contract.js";
+import { defineSchema } from "../schemas/index.js";
+import type {
+  InferInput,
+  InferSchema,
+  SchemaValidator,
+  ValidationIssue,
+} from "../extensions/schema/index.js";
+import { getAgUiRuntimeRunIdSchema } from "./runtime-ag-ui-contract.js";
 import { RunResumeSessionManager } from "./runtime/index.js";
 
-const TOOL_CALL_ID_SCHEMA = z.string().min(1).max(128);
+const TOOL_CALL_ID_SCHEMA = (v: SchemaValidator) => v.string().min(1).max(128);
 
-export const HumanInputOptionSchema = z.object({
-  value: z.string(),
-  label: z.string(),
-  description: z.string().optional(),
-  recommended: z.boolean().optional(),
-});
+export const getHumanInputOptionSchema = defineSchema((v) =>
+  v.object({
+    value: v.string(),
+    label: v.string(),
+    description: v.string().optional(),
+    recommended: v.boolean().optional(),
+  })
+);
 
-const BaseHumanInputFieldSchema = z.object({
-  name: z.string().min(1).max(128),
-  label: z.string().min(1).max(256),
-  description: z.string().max(1024).optional(),
-  required: z.boolean().optional().default(false),
-  secret: z.boolean().optional().default(false),
+// Common base fields shared by every human-input field variant. Factored as a
+// shape-helper because the contract DSL doesn't expose `Schema.shape` access
+// nor a way to share field defaults across discriminated-union members other
+// than constructing the shape repeatedly.
+const baseHumanInputFieldFields = (v: SchemaValidator) => ({
+  name: v.string().min(1).max(128),
+  label: v.string().min(1).max(256),
+  description: v.string().max(1024).optional(),
+  required: v.boolean().optional().default(false),
+  secret: v.boolean().optional().default(false),
 });
 
-export const HumanInputFieldSchema = z.discriminatedUnion("type", [
-  BaseHumanInputFieldSchema.extend({
-    type: z.enum(["text", "email", "url", "password", "number"]),
-    placeholder: z.string().max(512).optional(),
-    defaultValue: z.string().optional(),
-    pattern: z.string().max(512).optional(),
-    minLength: z.number().int().nonnegative().optional(),
-    maxLength: z.number().int().positive().optional(),
-    min: z.number().optional(),
-    max: z.number().optional(),
-  }),
-  BaseHumanInputFieldSchema.extend({
-    type: z.literal("textarea"),
-    placeholder: z.string().max(512).optional(),
-    defaultValue: z.string().optional(),
-    minLength: z.number().int().nonnegative().optional(),
-    maxLength: z.number().int().positive().optional(),
-    rows: z.number().int().positive().optional().default(3),
-  }),
-  BaseHumanInputFieldSchema.extend({
-    type: z.literal("select"),
-    options: z.array(HumanInputOptionSchema).min(1),
-    defaultValue: z.string().optional(),
-    placeholder: z.string().max(512).optional(),
-  }),
-  BaseHumanInputFieldSchema.extend({
-    type: z.literal("checkbox"),
-    defaultValue: z.boolean().optional().default(false),
-  }),
-  BaseHumanInputFieldSchema.extend({
-    type: z.literal("radio"),
-    options: z.array(HumanInputOptionSchema).min(1),
-    defaultValue: z.string().optional(),
-  }),
-  BaseHumanInputFieldSchema.extend({
-    type: z.literal("confirm"),
-    confirmLabel: z.string().max(64).optional().default("Yes"),
-    denyLabel: z.string().max(64).optional().default("No"),
-  }),
-]);
-
-export const HumanInputRequestSchema = z.object({
-  title: z.string().min(1).max(256),
-  description: z.string().max(2048).optional(),
-  fields: z.array(HumanInputFieldSchema).min(1),
-  submitLabel: z.string().max(64).optional().default("Submit"),
-  metadata: z.record(z.string(), z.unknown()).optional(),
+export const getHumanInputFieldSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      ...baseHumanInputFieldFields(v),
+      type: v.enum(["text", "email", "url", "password", "number"] as const),
+      placeholder: v.string().max(512).optional(),
+      defaultValue: v.string().optional(),
+      pattern: v.string().max(512).optional(),
+      minLength: v.number().int().nonnegative().optional(),
+      maxLength: v.number().int().positive().optional(),
+      min: v.number().optional(),
+      max: v.number().optional(),
+    }),
+    v.object({
+      ...baseHumanInputFieldFields(v),
+      type: v.literal("textarea"),
+      placeholder: v.string().max(512).optional(),
+      defaultValue: v.string().optional(),
+      minLength: v.number().int().nonnegative().optional(),
+      maxLength: v.number().int().positive().optional(),
+      rows: v.number().int().positive().optional().default(3),
+    }),
+    v.object({
+      ...baseHumanInputFieldFields(v),
+      type: v.literal("select"),
+      options: v.array(getHumanInputOptionSchema()).min(1),
+      defaultValue: v.string().optional(),
+      placeholder: v.string().max(512).optional(),
+    }),
+    v.object({
+      ...baseHumanInputFieldFields(v),
+      type: v.literal("checkbox"),
+      defaultValue: v.boolean().optional().default(false),
+    }),
+    v.object({
+      ...baseHumanInputFieldFields(v),
+      type: v.literal("radio"),
+      options: v.array(getHumanInputOptionSchema()).min(1),
+      defaultValue: v.string().optional(),
+    }),
+    v.object({
+      ...baseHumanInputFieldFields(v),
+      type: v.literal("confirm"),
+      confirmLabel: v.string().max(64).optional().default("Yes"),
+      denyLabel: v.string().max(64).optional().default("No"),
+    }),
+  ])
+);
+
+// Base shape for HumanInputRequest so the same fields can be reused without
+// `metadata` to derive `formInputToolInputSchema` (the contract DSL doesn't
+// expose `.omit`).
+export const humanInputRequestBaseFields = (v: SchemaValidator) => ({
+  title: v.string().min(1).max(256),
+  description: v.string().max(2048).optional(),
+  fields: v.array(getHumanInputFieldSchema()).min(1),
+  submitLabel: v.string().max(64).optional().default("Submit"),
 });
 
-export const HumanInputResponseValuesSchema = z.record(
-  z.string(),
-  z.union([z.string(), z.boolean(), z.number(), z.null()]),
+export const getHumanInputRequestSchema = defineSchema((v) =>
+  v.object({
+    ...humanInputRequestBaseFields(v),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+  })
 );
 
-export const HumanInputResultSchema = z.discriminatedUnion("submitted", [
-  z.object({
-    submitted: z.literal(true),
-    values: HumanInputResponseValuesSchema,
-  }),
-  z.object({
-    submitted: z.literal(false),
-    values: HumanInputResponseValuesSchema.default({}),
-  }),
-]);
-
-export const HumanInputPendingRequestSchema = z.object({
-  runId: AgUiRuntimeRunIdSchema,
-  toolCallId: TOOL_CALL_ID_SCHEMA,
-  request: HumanInputRequestSchema,
-});
+export const getHumanInputResponseValuesSchema = defineSchema((v) =>
+  v.record(
+    v.string(),
+    v.union([v.string(), v.boolean(), v.number(), v.null()]),
+  )
+);
+
+export const getHumanInputResultSchema = defineSchema((v) =>
+  v.discriminatedUnion("submitted", [
+    v.object({
+      submitted: v.literal(true),
+      values: getHumanInputResponseValuesSchema(),
+    }),
+    v.object({
+      submitted: v.literal(false),
+      values: getHumanInputResponseValuesSchema().default({}),
+    }),
+  ])
+);
+
+export const getHumanInputPendingRequestSchema = defineSchema((v) =>
+  v.object({
+    runId: getAgUiRuntimeRunIdSchema(),
+    toolCallId: TOOL_CALL_ID_SCHEMA(v),
+    request: getHumanInputRequestSchema(),
+  })
+);
 
-export type HumanInputOption = z.infer<typeof HumanInputOptionSchema>;
-export type HumanInputField = z.infer<typeof HumanInputFieldSchema>;
-export type HumanInputFieldInput = z.input<typeof HumanInputFieldSchema>;
-export type HumanInputRequest = z.infer<typeof HumanInputRequestSchema>;
-export type HumanInputRequestInput = z.input<typeof HumanInputRequestSchema>;
-export type HumanInputResult = z.infer<typeof HumanInputResultSchema>;
-export type HumanInputPendingRequest = z.infer<typeof HumanInputPendingRequestSchema>;
+export type HumanInputOption = InferSchema<ReturnType<typeof getHumanInputOptionSchema>>;
+export type HumanInputField = InferSchema<ReturnType<typeof getHumanInputFieldSchema>>;
+export type HumanInputFieldInput = InferInput<ReturnType<typeof getHumanInputFieldSchema>>;
+export type HumanInputRequest = InferSchema<ReturnType<typeof getHumanInputRequestSchema>>;
+export type HumanInputRequestInput = InferInput<ReturnType<typeof getHumanInputRequestSchema>>;
+export type HumanInputResult = InferSchema<ReturnType<typeof getHumanInputResultSchema>>;
+export type HumanInputPendingRequest = InferSchema<
+  ReturnType<typeof getHumanInputPendingRequestSchema>
+>;
 
 export type HumanInputResumeValue = {
   result: unknown;
@@ -153,7 +190,7 @@ export class HumanInputResumeError extends Error {
 }
 
 export class InvalidHumanInputResultError extends Error {
-  constructor(readonly detail: z.ZodIssue[]) {
+  constructor(readonly detail: ValidationIssue[]) {
     super("Invalid human input resume payload");
     this.name = "InvalidHumanInputResultError";
   }
@@ -221,7 +258,7 @@ export async function waitForHumanInput(
   options: WaitForHumanInputOptions,
 ): Promise<HumanInputResult> {
   options.sessionManager.prepareForSignal(options.runId, options.toolCallId);
-  const pendingRequest = HumanInputPendingRequestSchema.parse({
+  const pendingRequest = getHumanInputPendingRequestSchema().parse({
     runId: options.runId,
     toolCallId: options.toolCallId,
     request: options.request,
@@ -234,9 +271,9 @@ export async function waitForHumanInput(
     throw new HumanInputResumeError(resumed.result);
   }
 
-  const parsed = HumanInputResultSchema.safeParse(resumed.result);
+  const parsed = getHumanInputResultSchema().safeParse(resumed.result);
   if (!parsed.success) {
-    throw new InvalidHumanInputResultError(parsed.error.issues);
+    throw new InvalidHumanInputResultError(parsed.issues);
   }
 
   return parsed.data;