veryfront 0.1.519 → 0.1.521

package/src/src/agent/durable.ts

@@ -1,6 +1,6 @@
 import "../../_dnt.polyfills.js";
 import * as dntShim from "../../_dnt.shims.js";
-import { defineSchema } from "../schemas/index.js";
+import { defineSchema, lazySchema } from "../schemas/index.js";
 import type { InferSchema, Schema } from "../extensions/schema/index.js";
 
 const AGENT_RUN_API_TIMEOUT_MS = 15_000;
@@ -42,7 +42,7 @@ export const getConversationRunTargetsSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getConversationRunTargetsSchema() */
-export const ConversationRunTargetsSchema = getConversationRunTargetsSchema();
+export const ConversationRunTargetsSchema = lazySchema(getConversationRunTargetsSchema);
 
 export type ConversationRunTargets = InferSchema<
   ReturnType<typeof getConversationRunTargetsSchema>
@@ -78,7 +78,7 @@ export const getConversationRunStatusSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getConversationRunStatusSchema() */
-export const ConversationRunStatusSchema = getConversationRunStatusSchema();
+export const ConversationRunStatusSchema = lazySchema(getConversationRunStatusSchema);
 
 export interface ConversationRunProjection {
   runId: string;
@@ -142,7 +142,7 @@ export const getConversationRunProjectionSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getConversationRunProjectionSchema() */
-export const ConversationRunProjectionSchema = getConversationRunProjectionSchema();
+export const ConversationRunProjectionSchema = lazySchema(getConversationRunProjectionSchema);
 export type ActiveConversationRunStatus = Extract<
   ConversationRunProjection["status"],
   "pending" | "running" | "waiting_for_tool"
@@ -235,7 +235,9 @@ export const getCreateConversationRunAcceptedSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getCreateConversationRunAcceptedSchema() */
-export const CreateConversationRunAcceptedSchema = getCreateConversationRunAcceptedSchema();
+export const CreateConversationRunAcceptedSchema = lazySchema(
+  getCreateConversationRunAcceptedSchema,
+);
 
 export const getCompleteConversationRunResponseSchema = defineSchema((v) =>
   v.object({
@@ -249,7 +251,9 @@ export const getCompleteConversationRunResponseSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getCompleteConversationRunResponseSchema() */
-export const CompleteConversationRunResponseSchema = getCompleteConversationRunResponseSchema();
+export const CompleteConversationRunResponseSchema = lazySchema(
+  getCompleteConversationRunResponseSchema,
+);
 
 export interface AppendConversationRunEventsResponse {
   latestEventId: number;
@@ -307,8 +311,9 @@ export const getAppendConversationRunEventsResponseSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getAppendConversationRunEventsResponseSchema() */
-export const AppendConversationRunEventsResponseSchema =
-  getAppendConversationRunEventsResponseSchema();
+export const AppendConversationRunEventsResponseSchema = lazySchema(
+  getAppendConversationRunEventsResponseSchema,
+);
 
 const DEFAULT_MAX_CONVERSATION_RUN_BATCH_BYTES = 512 * 1024;
 

package/src/src/agent/external-agent-worker-client.ts

@@ -1,82 +1,171 @@
-import { z } from "zod";
-
-export const ExternalAgentWorkerSchema = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  implementation_kind: z.string(),
-  worker_key: z.string(),
-  display_name: z.string().nullable().optional(),
-  status: z.string().optional(),
-  metadata: z.unknown().nullable().optional(),
-  last_heartbeat_at: z.string().nullable().optional(),
-  created_at: z.string().optional(),
-  updated_at: z.string().optional(),
-});
-
-const ExternalAgentWorkerRequestMessageSchema = z.object({
-  id: z.string(),
-  role: z.string(),
-  parts: z.array(z.object({ type: z.string() }).passthrough()).default([]),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-});
-
-export const ExternalAgentWorkerRequestSnapshotSchema = z.object({
-  messages: z.array(ExternalAgentWorkerRequestMessageSchema),
-  tools: z.array(z.unknown()).default([]),
-  context: z.array(z.unknown()).default([]),
-  forwardedProps: z.record(z.string(), z.unknown()).optional(),
-  traceContext: z.unknown().optional(),
-});
-
-export const ExternalAgentWorkerSessionSchema = z.object({
-  id: z.string().uuid(),
-  run_id: z.string(),
-  implementation_kind: z.string(),
-  worker_id: z.string().uuid().nullable(),
-  session_key: z.string(),
-  status: z.string(),
-  metadata: z.unknown().nullable().optional(),
-  created_at: z.string().optional(),
-  updated_at: z.string().optional(),
-  ended_at: z.string().nullable().optional(),
-});
-
-export const ExternalAgentWorkerRunSchema = z.object({
-  run_id: z.string(),
-  conversation_id: z.string().uuid(),
-  message_id: z.string().uuid(),
-  project_id: z.string().uuid().nullable(),
-  agent_id: z.string(),
-  status: z.string(),
-  request_snapshot: ExternalAgentWorkerRequestSnapshotSchema.nullable(),
-  source_target_kind: z.string().nullable().optional(),
-  source_target_environment_id: z.string().uuid().nullable().optional(),
-  source_target_branch_id: z.string().uuid().nullable().optional(),
-  source_target_release_version: z.string().nullable().optional(),
-  runtime_target_kind: z.string().nullable().optional(),
-  runtime_target_environment_id: z.string().uuid().nullable().optional(),
-  runtime_target_branch_id: z.string().uuid().nullable().optional(),
-  latest_event_id: z.number(),
-  latest_external_event_sequence: z.number(),
-  lease_owner: z.string().nullable(),
-  lease_expires_at: z.string().nullable(),
-  worker_session: ExternalAgentWorkerSessionSchema.nullable().default(null),
-});
-
-const RegisterExternalAgentWorkerResponseSchema = z.object({
-  worker: ExternalAgentWorkerSchema,
-  token: z.string().min(1),
-});
-
-export type ExternalAgentWorker = z.infer<typeof ExternalAgentWorkerSchema>;
-export type ExternalAgentWorkerRequestSnapshot = z.infer<
-  typeof ExternalAgentWorkerRequestSnapshotSchema
->;
-export type ExternalAgentWorkerRun = z.infer<typeof ExternalAgentWorkerRunSchema>;
-export type ExternalAgentWorkerSession = z.infer<
-  typeof ExternalAgentWorkerSessionSchema
->;
+import type { Schema, SchemaValidator } from "../extensions/schema/index.js";
+import { defineSchema } from "../schemas/define.js";
+import { lazySchema } from "../schemas/lazy.js";
+
+export interface ExternalAgentWorker {
+  id: string;
+  project_id: string;
+  implementation_kind: string;
+  worker_key: string;
+  display_name?: string | null;
+  status?: string;
+  metadata?: unknown | null;
+  last_heartbeat_at?: string | null;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export interface ExternalAgentWorkerRequestSnapshot {
+  messages: Array<{
+    id: string;
+    role: string;
+    parts: Array<{ type: string } & Record<string, unknown>>;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+  }>;
+  tools: unknown[];
+  context: unknown[];
+  forwardedProps?: Record<string, unknown>;
+  traceContext?: unknown;
+}
+
+export interface ExternalAgentWorkerSession {
+  id: string;
+  run_id: string;
+  implementation_kind: string;
+  worker_id: string | null;
+  session_key: string;
+  status: string;
+  metadata?: unknown | null;
+  created_at?: string;
+  updated_at?: string;
+  ended_at?: string | null;
+}
+
+export interface ExternalAgentWorkerRun {
+  run_id: string;
+  conversation_id: string;
+  message_id: string;
+  project_id: string | null;
+  agent_id: string;
+  status: string;
+  request_snapshot: ExternalAgentWorkerRequestSnapshot | null;
+  source_target_kind?: string | null;
+  source_target_environment_id?: string | null;
+  source_target_branch_id?: string | null;
+  source_target_release_version?: string | null;
+  runtime_target_kind?: string | null;
+  runtime_target_environment_id?: string | null;
+  runtime_target_branch_id?: string | null;
+  latest_event_id: number;
+  latest_external_event_sequence: number;
+  lease_owner: string | null;
+  lease_expires_at: string | null;
+  worker_session: ExternalAgentWorkerSession | null;
+}
+
+function externalAgentWorker(v: SchemaValidator): Schema<ExternalAgentWorker> {
+  return v.object({
+    id: v.string().uuid(),
+    project_id: v.string().uuid(),
+    implementation_kind: v.string(),
+    worker_key: v.string(),
+    display_name: v.string().nullable().optional(),
+    status: v.string().optional(),
+    metadata: v.unknown().nullable().optional(),
+    last_heartbeat_at: v.string().nullable().optional(),
+    created_at: v.string().optional(),
+    updated_at: v.string().optional(),
+  });
+}
+
+export const ExternalAgentWorkerSchema = lazySchema(
+  defineSchema<ExternalAgentWorker>(externalAgentWorker),
+);
+
+function externalAgentWorkerRequestMessage(
+  v: SchemaValidator,
+): Schema<ExternalAgentWorkerRequestSnapshot["messages"][number]> {
+  return v.object({
+    id: v.string(),
+    role: v.string(),
+    parts: v.array(v.object({ type: v.string() }).passthrough()).default([]),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+    createdAt: v.string().optional(),
+  });
+}
+
+function externalAgentWorkerRequestSnapshot(
+  v: SchemaValidator,
+): Schema<ExternalAgentWorkerRequestSnapshot> {
+  return v.object({
+    messages: v.array(externalAgentWorkerRequestMessage(v)),
+    tools: v.array(v.unknown()).default([]),
+    context: v.array(v.unknown()).default([]),
+    forwardedProps: v.record(v.string(), v.unknown()).optional(),
+    traceContext: v.unknown().optional(),
+  });
+}
+
+export const ExternalAgentWorkerRequestSnapshotSchema = lazySchema(
+  defineSchema<ExternalAgentWorkerRequestSnapshot>(externalAgentWorkerRequestSnapshot),
+);
+
+function externalAgentWorkerSession(v: SchemaValidator): Schema<ExternalAgentWorkerSession> {
+  return v.object({
+    id: v.string().uuid(),
+    run_id: v.string(),
+    implementation_kind: v.string(),
+    worker_id: v.string().uuid().nullable(),
+    session_key: v.string(),
+    status: v.string(),
+    metadata: v.unknown().nullable().optional(),
+    created_at: v.string().optional(),
+    updated_at: v.string().optional(),
+    ended_at: v.string().nullable().optional(),
+  });
+}
+
+export const ExternalAgentWorkerSessionSchema = lazySchema(
+  defineSchema<ExternalAgentWorkerSession>(externalAgentWorkerSession),
+);
+
+function externalAgentWorkerRun(v: SchemaValidator): Schema<ExternalAgentWorkerRun> {
+  return v.object({
+    run_id: v.string(),
+    conversation_id: v.string().uuid(),
+    message_id: v.string().uuid(),
+    project_id: v.string().uuid().nullable(),
+    agent_id: v.string(),
+    status: v.string(),
+    request_snapshot: externalAgentWorkerRequestSnapshot(v).nullable(),
+    source_target_kind: v.string().nullable().optional(),
+    source_target_environment_id: v.string().uuid().nullable().optional(),
+    source_target_branch_id: v.string().uuid().nullable().optional(),
+    source_target_release_version: v.string().nullable().optional(),
+    runtime_target_kind: v.string().nullable().optional(),
+    runtime_target_environment_id: v.string().uuid().nullable().optional(),
+    runtime_target_branch_id: v.string().uuid().nullable().optional(),
+    latest_event_id: v.number(),
+    latest_external_event_sequence: v.number(),
+    lease_owner: v.string().nullable(),
+    lease_expires_at: v.string().nullable(),
+    worker_session: externalAgentWorkerSession(v).nullable().default(null),
+  });
+}
+
+export const ExternalAgentWorkerRunSchema = lazySchema(
+  defineSchema<ExternalAgentWorkerRun>(externalAgentWorkerRun),
+);
+
+const RegisterExternalAgentWorkerResponseSchema = lazySchema(
+  defineSchema<{ worker: ExternalAgentWorker; token: string }>((v) =>
+    v.object({
+      worker: externalAgentWorker(v),
+      token: v.string().min(1),
+    })
+  ),
+);
 
 export interface ExternalAgentWorkerClientOptions {
   apiUrl: string;
@@ -146,12 +235,12 @@ class DefaultExternalAgentWorkerClient implements ExternalAgentWorkerClient {
     this.#fetch = options.fetch ?? fetch;
   }
 
-  async #request<S extends z.ZodTypeAny>(
+  async #request<T>(
     path: string,
-    schema: S,
+    schema: Schema<T>,
     init: RequestInit = {},
     options: { workerId?: string } = {},
-  ): Promise<z.output<S>> {
+  ): Promise<T> {
     const token = options.workerId
       ? this.#workerTokensByWorkerId.get(options.workerId) ?? this.#authToken
       : this.#authToken;
@@ -197,7 +286,11 @@ class DefaultExternalAgentWorkerClient implements ExternalAgentWorkerClient {
   async heartbeatWorker(workerId: string): Promise<ExternalAgentWorker> {
     const response = await this.#request(
       `/agent-workers/workers/${encodeURIComponent(workerId)}/heartbeat`,
-      z.object({ worker: ExternalAgentWorkerSchema }),
+      lazySchema(
+        defineSchema<{ worker: ExternalAgentWorker }>((v) =>
+          v.object({ worker: externalAgentWorker(v) })
+        ),
+      ),
       { method: "POST" },
       { workerId },
     );
@@ -209,7 +302,11 @@ class DefaultExternalAgentWorkerClient implements ExternalAgentWorkerClient {
   ): Promise<ExternalAgentWorkerRun | null> {
     const response = await this.#request(
       `/agent-workers/workers/${encodeURIComponent(input.workerId)}/claim`,
-      z.object({ run: ExternalAgentWorkerRunSchema.nullable() }),
+      lazySchema(
+        defineSchema<{ run: ExternalAgentWorkerRun | null }>((v) =>
+          v.object({ run: externalAgentWorkerRun(v).nullable() })
+        ),
+      ),
       {
         method: "POST",
         body: JSON.stringify({ lease_duration_seconds: input.leaseDurationSeconds }),
@@ -226,7 +323,11 @@ class DefaultExternalAgentWorkerClient implements ExternalAgentWorkerClient {
       `/agent-workers/workers/${encodeURIComponent(input.workerId)}/runs/${
         encodeURIComponent(input.runId)
       }/lease`,
-      z.object({ run: ExternalAgentWorkerRunSchema.nullable() }),
+      lazySchema(
+        defineSchema<{ run: ExternalAgentWorkerRun | null }>((v) =>
+          v.object({ run: externalAgentWorkerRun(v).nullable() })
+        ),
+      ),
       {
         method: "POST",
         body: JSON.stringify({ lease_duration_seconds: input.leaseDurationSeconds }),
@@ -243,7 +344,11 @@ class DefaultExternalAgentWorkerClient implements ExternalAgentWorkerClient {
       `/agent-workers/workers/${encodeURIComponent(input.workerId)}/runs/${
         encodeURIComponent(input.runId)
       }/session`,
-      z.object({ session: ExternalAgentWorkerSessionSchema }),
+      lazySchema(
+        defineSchema<{ session: ExternalAgentWorkerSession }>((v) =>
+          v.object({ session: externalAgentWorkerSession(v) })
+        ),
+      ),
       {
         method: "PUT",
         body: JSON.stringify({
@@ -262,7 +367,7 @@ class DefaultExternalAgentWorkerClient implements ExternalAgentWorkerClient {
       `/conversations/${encodeURIComponent(input.conversationId)}/runs/${
         encodeURIComponent(input.runId)
       }/events`,
-      z.unknown(),
+      lazySchema(defineSchema((v) => v.unknown())),
       {
         method: "POST",
         body: JSON.stringify({
@@ -276,7 +381,7 @@ class DefaultExternalAgentWorkerClient implements ExternalAgentWorkerClient {
   async completeRun(input: CompleteExternalAgentWorkerRunInput): Promise<void> {
     await this.#request(
       `/runs/${encodeURIComponent(input.runId)}/complete`,
-      z.unknown(),
+      lazySchema(defineSchema((v) => v.unknown())),
       {
         method: "POST",
         body: JSON.stringify({

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

@@ -1,6 +1,6 @@
 import { mapAgUiRuntimeMessagesToChatUiMessages } from "../../chat/ag-ui.js";
 import type { ChatRequestContext, ChatRuntimeOverrides } from "../../chat/types.js";
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 import {
   createAgUiRuntimeContextMap,
@@ -32,7 +32,9 @@ export const getHostedAgUiChatForwardedConfigSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getHostedAgUiChatForwardedConfigSchema() */
-export const hostedAgUiChatForwardedConfigSchema = getHostedAgUiChatForwardedConfigSchema();
+export const hostedAgUiChatForwardedConfigSchema = lazySchema(
+  getHostedAgUiChatForwardedConfigSchema,
+);
 
 export type HostedAgUiChatForwardedConfig = InferSchema<
   ReturnType<typeof getHostedAgUiChatForwardedConfigSchema>
@@ -67,7 +69,7 @@ const getHostedValidationErrorBodySchema = defineSchema((v) =>
     .passthrough()
 );
 
-const hostedValidationErrorBodySchema = getHostedValidationErrorBodySchema();
+const hostedValidationErrorBodySchema = lazySchema(getHostedValidationErrorBodySchema);
 
 async function verifyHostedAgUiProjectAccess(input: {
   projectId: string | null;

package/src/src/agent/hosted/agent-project-steering.ts

@@ -1,4 +1,6 @@
-import { z } from "zod";
+import { ensureBuiltinSchemaValidator } from "../../extensions/builtin-extensions.js";
+import { defineSchema } from "../../schemas/define.js";
+import { lazySchema } from "../../schemas/lazy.js";
 import {
   createHostedProjectSteeringAdapter,
   type HostedProjectSkillIdsContext,
@@ -20,19 +22,28 @@ import type { RuntimeProjectSteeringLookup } from "../runtime/project-skill-cata
 import type { RuntimeLoadSkillToolContext } from "../runtime/load-skill-tool.js";
 import type { RuntimeSkillDefinition } from "../runtime/skill-metadata.js";
 
-const runtimeAgentFileIdSchema = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/);
-const runtimeAgentDefinitionFileNameSchema = z.string().min(1).regex(/^[A-Za-z0-9._-]+\.md$/);
+export type HostedAgentProjectSteeringOptionsData = {
+  baseDir: string;
+  agentId: string;
+  fileName?: string;
+  skillsDir?: string;
+};
 
-export const hostedAgentProjectSteeringOptionsSchema = z.object({
-  baseDir: z.string().min(1),
-  agentId: runtimeAgentFileIdSchema,
-  fileName: runtimeAgentDefinitionFileNameSchema.optional(),
-  skillsDir: z.string().min(1).optional(),
-});
+export const hostedAgentProjectSteeringOptionsSchema = lazySchema(
+  defineSchema<HostedAgentProjectSteeringOptionsData>((v) => {
+    const runtimeAgentFileIdSchema = v.string().min(1).regex(/^[A-Za-z0-9._-]+$/);
+    const runtimeAgentDefinitionFileNameSchema = v.string().min(1).regex(
+      /^[A-Za-z0-9._-]+\.md$/,
+    );
 
-export type HostedAgentProjectSteeringOptionsData = z.infer<
-  typeof hostedAgentProjectSteeringOptionsSchema
->;
+    return v.object({
+      baseDir: v.string().min(1),
+      agentId: runtimeAgentFileIdSchema,
+      fileName: runtimeAgentDefinitionFileNameSchema.optional(),
+      skillsDir: v.string().min(1).optional(),
+    });
+  }),
+);
 
 export type HostedAgentProjectSteeringLogger = HostedProjectSteeringLogger & {
   error?: (message: string, metadata?: Record<string, unknown>) => void;
@@ -63,6 +74,7 @@ function stringifyError(error: unknown): string {
 export function createHostedAgentProjectSteering(
   options: HostedAgentProjectSteeringOptions,
 ): HostedAgentProjectSteering {
+  ensureBuiltinSchemaValidator();
   const parsedOptions = hostedAgentProjectSteeringOptionsSchema.parse(options);
   const agentsDir = resolveRuntimeAgentDefinitionsDir({
     baseDir: parsedOptions.baseDir,

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

@@ -1,6 +1,6 @@
 import type { ChatRuntimeOverrides, DurableRootRunDescriptor } from "../../chat/types.js";
 import { getChatRequestContextSchema, getChatUiMessagesSchema } from "../../chat/types.js";
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 import type { RuntimeAgentRunInvocation } from "../runtime/agent-invocation-contract.js";
 
@@ -21,7 +21,9 @@ export const getHostedDurableRootRunDescriptorSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getHostedDurableRootRunDescriptorSchema() */
-export const hostedDurableRootRunDescriptorSchema = getHostedDurableRootRunDescriptorSchema();
+export const hostedDurableRootRunDescriptorSchema = lazySchema(
+  getHostedDurableRootRunDescriptorSchema,
+);
 
 export const getHostedChatRuntimeOverridesSchema = defineSchema((v) =>
   v.object({
@@ -32,7 +34,7 @@ export const getHostedChatRuntimeOverridesSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getHostedChatRuntimeOverridesSchema() */
-export const hostedChatRuntimeOverridesSchema = getHostedChatRuntimeOverridesSchema();
+export const hostedChatRuntimeOverridesSchema = lazySchema(getHostedChatRuntimeOverridesSchema);
 
 export const getHostedChatRequestSchema = defineSchema((v) =>
   v.object({
@@ -47,7 +49,7 @@ export const getHostedChatRequestSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getHostedChatRequestSchema() */
-export const hostedChatRequestSchema = getHostedChatRequestSchema();
+export const hostedChatRequestSchema = lazySchema(getHostedChatRequestSchema);
 
 export type HostedChatRequest = InferSchema<ReturnType<typeof getHostedChatRequestSchema>>;
 export type HostedChatRequestInput = {

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

@@ -1,4 +1,4 @@
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } 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";
@@ -26,7 +26,7 @@ export const getHostedChildForkToolInputSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getHostedChildForkToolInputSchema() */
-export const hostedChildForkToolInputSchema = getHostedChildForkToolInputSchema();
+export const hostedChildForkToolInputSchema = lazySchema(getHostedChildForkToolInputSchema);
 
 export type HostedChildForkToolInput = InferSchema<
   ReturnType<typeof getHostedChildForkToolInputSchema>

package/src/src/agent/index.ts

@@ -16,12 +16,14 @@
  * ```ts
  * import { agent } from "veryfront/agent";
  * import { tool } from "veryfront/tool";
- * import { defineSchema } from "veryfront/schemas";
+ * import { defineSchema, lazySchema } from "veryfront/schemas";
+ *
+ * const getSearchInput = defineSchema((v) => v.object({ query: v.string() }));
  *
  * const searchTool = tool({
  *   id: "search",
  *   description: "Search the knowledge base",
- *   inputSchema: defineSchema((v) => v.object({ query: v.string() }))(),
+ *   inputSchema: lazySchema(getSearchInput),
  *   execute: async ({ query }) => ({ results: [] }),
  * });
  *

package/src/src/agent/invoke-agent-child-runs.ts

@@ -1,5 +1,5 @@
 import "../../_dnt.polyfills.js";
-import { defineSchema } from "../schemas/index.js";
+import { defineSchema, lazySchema } from "../schemas/index.js";
 import type { InferSchema } from "../extensions/schema/index.js";
 import { appendConversationRunEvents, isIgnorableConversationRunAppendError } from "./durable.js";
 
@@ -24,7 +24,9 @@ export const getInvokeAgentChildRunLifecycleValueSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getInvokeAgentChildRunLifecycleValueSchema() */
-export const InvokeAgentChildRunLifecycleValueSchema = getInvokeAgentChildRunLifecycleValueSchema();
+export const InvokeAgentChildRunLifecycleValueSchema = lazySchema(
+  getInvokeAgentChildRunLifecycleValueSchema,
+);
 
 export type InvokeAgentChildRunLifecycleValue = InferSchema<
   ReturnType<typeof getInvokeAgentChildRunLifecycleValueSchema>
@@ -44,7 +46,9 @@ export const getInvokeAgentChildRunStateDeltaSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getInvokeAgentChildRunStateDeltaSchema() */
-export const InvokeAgentChildRunStateDeltaSchema = getInvokeAgentChildRunStateDeltaSchema();
+export const InvokeAgentChildRunStateDeltaSchema = lazySchema(
+  getInvokeAgentChildRunStateDeltaSchema,
+);
 
 export type InvokeAgentChildRunStateDelta = InferSchema<
   ReturnType<typeof getInvokeAgentChildRunStateDeltaSchema>
@@ -59,8 +63,9 @@ export const getInvokeAgentChildRunLifecycleCustomEventSchema = defineSchema((v)
 );
 
 /** @deprecated Use getInvokeAgentChildRunLifecycleCustomEventSchema() */
-export const InvokeAgentChildRunLifecycleCustomEventSchema =
-  getInvokeAgentChildRunLifecycleCustomEventSchema();
+export const InvokeAgentChildRunLifecycleCustomEventSchema = lazySchema(
+  getInvokeAgentChildRunLifecycleCustomEventSchema,
+);
 
 export type InvokeAgentChildRunLifecycleCustomEvent = InferSchema<
   ReturnType<typeof getInvokeAgentChildRunLifecycleCustomEventSchema>