veryfront 0.1.519 → 0.1.521

package/src/extensions/ext-document-kreuzberg/src/index.ts

@@ -0,0 +1,95 @@
+/**
+ * ext-document-kreuzberg: document text extraction for Veryfront.
+ *
+ * Provides the `DocumentExtractor` contract via kreuzberg. Deno extraction can
+ * run inside an isolated Worker so a hung WASM call does not block the server.
+ *
+ * @module extensions/ext-document-kreuzberg
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import type { ExtensionFactory } from "../../../src/extensions/index.js";
+import type { DocumentExtractor, KreuzbergExtractor } from "../../../src/extensions/compat/index.js";
+import { loadKreuzberg } from "./kreuzberg.js";
+
+/** Maximum time to wait for document text extraction before aborting. */
+const EXTRACTION_TIMEOUT_MS = 30_000;
+
+function extractInWorkerDeno(
+  buffer: ArrayBuffer,
+  mimeType: string,
+): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    // Static URL literal so `deno compile` traces the worker script into
+    // the binary's embedded module graph.
+    const workerUrl = new URL("./upload-extraction-worker.ts", import.meta.url);
+    const worker = new Worker(workerUrl, { type: "module" });
+
+    const timer = dntShim.setTimeout(() => {
+      worker.terminate();
+      reject(
+        new Error(
+          `Text extraction timed out after ${
+            EXTRACTION_TIMEOUT_MS / 1000
+          }s. The file may be corrupted or unsupported`,
+        ),
+      );
+    }, EXTRACTION_TIMEOUT_MS);
+
+    worker.onmessage = (event: MessageEvent) => {
+      clearTimeout(timer);
+      worker.terminate();
+      const { content, error } = event.data as { content?: string; error?: string };
+      if (error) {
+        reject(new Error(error));
+      } else {
+        resolve(content ?? "");
+      }
+    };
+
+    worker.onerror = (event) => {
+      clearTimeout(timer);
+      worker.terminate();
+      reject(new Error(`Text extraction worker failed: ${event.message ?? "unknown"}`));
+    };
+
+    worker.postMessage({ buffer, mimeType }, [buffer]);
+  });
+}
+
+export class KreuzbergDocumentExtractor implements DocumentExtractor {
+  importKreuzberg(): Promise<KreuzbergExtractor> {
+    return loadKreuzberg();
+  }
+
+  async extractInWorker(buffer: ArrayBuffer, mimeType: string): Promise<string> {
+    const isDeno = typeof dntShim.Deno !== "undefined";
+    if (!isDeno) {
+      const { extractBytes } = await loadKreuzberg();
+      const result = await extractBytes(new Uint8Array(buffer), mimeType);
+      return result.content;
+    }
+    return extractInWorkerDeno(buffer, mimeType);
+  }
+}
+
+const extDocumentKreuzberg: ExtensionFactory = () => {
+  const extractor = new KreuzbergDocumentExtractor();
+
+  return {
+    name: "ext-document-kreuzberg",
+    version: "0.1.0",
+    capabilities: [
+      { type: "contract", name: "DocumentExtractor" },
+      { type: "fs:read" },
+    ],
+
+    setup(ctx) {
+      ctx.provide("DocumentExtractor", extractor);
+      ctx.logger.info("[ext-document-kreuzberg] document extraction registered");
+    },
+  };
+};
+
+export default extDocumentKreuzberg;

package/src/extensions/{ext-node-compatibility → ext-document-kreuzberg}/src/kreuzberg.ts

@@ -1,12 +1,12 @@
 /**
- * Shared kreuzberg loader for the ext-node-compatibility extension.
+ * Shared kreuzberg loader for the ext-document-kreuzberg extension.
  *
- * Used by both `NodeCompatImpl.importKreuzberg()` (direct calls from
- * Node/Bun) and the extension's upload-extraction worker (Deno isolate).
+ * Used by both `KreuzbergDocumentExtractor.importKreuzberg()` (direct calls
+ * from Node/Bun) and the extension's upload-extraction worker (Deno isolate).
  * Centralising the loader keeps the compiled-binary WASM glue + pdfium
  * pre-import dance in one place.
  *
- * @module extensions/ext-node-compatibility/kreuzberg
+ * @module extensions/ext-document-kreuzberg/kreuzberg
  */
 import * as dntShim from "../../../_dnt.shims.js";
 

package/src/extensions/ext-sandbox-shell-tools/src/index.ts

@@ -0,0 +1,38 @@
+/**
+ * ext-sandbox-shell-tools, SandboxShellToolsProvider backed by bash-tool.
+ *
+ * @module extensions/ext-sandbox-shell-tools
+ */
+
+import type { ExtensionFactory } from "../../../src/extensions/index.js";
+import {
+  type CreateSandboxShellToolsInput,
+  type SandboxShellToolsProvider,
+  SandboxShellToolsProviderName,
+} from "../../../src/extensions/sandbox/index.js";
+import { createBashTool } from "bash-tool";
+
+type BashToolFactory = (
+  input: CreateSandboxShellToolsInput,
+) => Promise<{ tools: Record<string, unknown> }>;
+
+export function createSandboxShellToolsProvider(
+  createBashToolImpl: BashToolFactory,
+): SandboxShellToolsProvider {
+  return async (input) => await createBashToolImpl(input);
+}
+
+const provider = createSandboxShellToolsProvider(createBashTool);
+
+const extSandboxShellTools: ExtensionFactory = () => ({
+  name: "ext-sandbox-shell-tools",
+  version: "0.1.0",
+  capabilities: [{ type: "contract", name: SandboxShellToolsProviderName }],
+  setup(ctx) {
+    ctx.provide(SandboxShellToolsProviderName, provider);
+    ctx.logger.info("[ext-sandbox-shell-tools] Sandbox shell tools provider registered");
+  },
+});
+
+export default extSandboxShellTools;
+export { provider as createBashSandboxShellToolsProvider };

package/src/extensions/{ext-zod → ext-schema-zod}/src/adapter.ts

@@ -7,7 +7,7 @@
  *
  * The entire zod surface used by the contract is confined to this file.
  *
- * @module extensions/ext-zod/adapter
+ * @module extensions/ext-schema-zod/adapter
  */
 
 import { z } from "zod";

package/src/extensions/{ext-zod → ext-schema-zod}/src/index.ts

@@ -1,5 +1,5 @@
 /**
- * ext-zod — SchemaValidator implementation backed by zod.
+ * ext-schema-zod — SchemaValidator implementation backed by zod.
  *
  * Provides the `SchemaValidator` contract via a zod-backed adapter. Core
  * modules declare schemas through `defineSchema((v) => …)` (in
@@ -10,7 +10,7 @@
  * the adapter without going through full extension bootstrap can import
  * `createZodAdapter` directly from this module's `./adapter.ts`.
  *
- * @module extensions/ext-zod
+ * @module extensions/ext-schema-zod
  */
 
 import type { ExtensionFactory } from "../../../src/extensions/index.js";
@@ -19,12 +19,12 @@ import { createZodAdapter } from "./adapter.js";
 const extZod: ExtensionFactory = () => {
   const impl = createZodAdapter();
   return {
-    name: "ext-zod",
+    name: "ext-schema-zod",
     version: "0.1.0",
     capabilities: [{ type: "contract", name: "SchemaValidator" }],
     setup(ctx) {
       ctx.provide("SchemaValidator", impl);
-      ctx.logger.info("[ext-zod] SchemaValidator registered");
+      ctx.logger.info("[ext-schema-zod] SchemaValidator registered");
     },
     teardown() {
       // No resources to release.

package/src/extensions/{ext-zod → ext-schema-zod}/src/json-schema.ts

@@ -3,10 +3,10 @@
  *
  * Operates directly on zod's internal `_def` shape (covers both v3 and v4)
  * because zod ships no first-class JSON-Schema export. Confined to
- * `extensions/ext-zod/` so the rest of the codebase never has to import zod
+ * `extensions/ext-schema-zod/` so the rest of the codebase never has to import zod
  * to learn what a tool's input schema looks like.
  *
- * @module extensions/ext-zod/json-schema
+ * @module extensions/ext-schema-zod/json-schema
  */
 
 import type { z } from "zod";

package/src/extensions/ext-tracing-opentelemetry/src/index.ts

@@ -0,0 +1,290 @@
+/**
+ * ext-tracing-opentelemetry — TracingExporter implementation backed by the
+ * official OpenTelemetry JS SDK.
+ *
+ * Provides the `TracingExporter` and `NodeTelemetryProvider` contracts:
+ *  - `start(config)` — builds the SDK provider + OTLP HTTP exporter
+ *  - `export(spans)` — no-op (SDK handles export via BatchSpanProcessor)
+ *  - `shutdown()` — flushes + shuts down the provider
+ *  - `getProvider()` — returns the SDK TracerProvider for shim wiring
+ *  - `initialize(options)` — starts NodeSDK auto-instrumentation
+ *
+ * Configuration is read from `ctx.config` (see `OtlpExtConfig`) and falls
+ * back to standard OTEL environment variables.
+ *
+ * @module extensions/ext-tracing-opentelemetry
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import type { ExtensionFactory } from "../../../src/extensions/index.js";
+import type {
+  NodeTelemetryInitializeOptions,
+  NodeTelemetryProvider,
+  SpanData,
+  TracingExporter,
+} from "../../../src/extensions/tracing/index.js";
+
+import { metrics, trace } from "@opentelemetry/api";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import {
+  BasicTracerProvider,
+  BatchSpanProcessor,
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler,
+} from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+
+/**
+ * The TracerProvider interface as expected by the core shim.
+ * Using structural typing — the real SDK provider satisfies this shape.
+ */
+interface ShimTracerProvider {
+  getTracer(name: string, version?: string): unknown;
+}
+
+/**
+ * Configuration shape accepted by this extension factory.
+ */
+export interface OtlpExtConfig {
+  otel?: {
+    serviceName?: string;
+    serviceVersion?: string;
+    endpoint?: string;
+    headers?: string | Record<string, string>;
+  };
+}
+
+function readEnv(name: string): string | undefined {
+  try {
+    return (dntShim.dntGlobalThis as { Deno?: { env: { get(n: string): string | undefined } } }).Deno?.env
+      .get(name);
+  } catch {
+    return undefined;
+  }
+}
+
+function parseHeaders(headerInput: string | Record<string, string> | undefined): Record<
+  string,
+  string
+> {
+  if (!headerInput) return {};
+  if (typeof headerInput !== "string") return headerInput;
+
+  // "Basic xxx" or "Authorization=Basic xxx"
+  if (headerInput.startsWith("Basic ")) return { Authorization: headerInput };
+  if (headerInput.startsWith("Authorization=")) {
+    return { Authorization: headerInput.slice("Authorization=".length) };
+  }
+
+  const result: Record<string, string> = {};
+  for (const part of headerInput.split(",")) {
+    const [key, ...valueParts] = part.split("=");
+    if (key && valueParts.length > 0) result[key.trim()] = valueParts.join("=").trim();
+  }
+  return result;
+}
+
+function resolveConfig(ctxConfig: Record<string, unknown>): {
+  serviceName: string;
+  serviceVersion: string;
+  endpoint: string;
+  headers: Record<string, string>;
+  enabled: boolean;
+} {
+  const otelCfg = (ctxConfig as OtlpExtConfig).otel ?? {};
+
+  const enabled = readEnv("OTEL_TRACES_ENABLED") === "true";
+  const serviceName = otelCfg.serviceName ?? readEnv("OTEL_SERVICE_NAME") ?? "veryfront";
+  const serviceVersion = otelCfg.serviceVersion ?? "0.1.0";
+  const endpoint = otelCfg.endpoint ??
+    readEnv("OTEL_EXPORTER_OTLP_ENDPOINT") ??
+    "";
+  const headersRaw = otelCfg.headers ?? readEnv("OTEL_EXPORTER_OTLP_HEADERS");
+  const headers = parseHeaders(headersRaw);
+
+  return { enabled, serviceName, serviceVersion, endpoint, headers };
+}
+
+class OtlpTracingExporter implements TracingExporter {
+  private sdkProvider: BasicTracerProvider | null = null;
+
+  async start(ctxConfig: Record<string, unknown>): Promise<void> {
+    const cfg = resolveConfig(ctxConfig);
+
+    // Honor OTEL_TRACES_ENABLED: when unset/false, skip exporter wiring so
+    // deployments opting out never create OTLP traffic or set globals.
+    if (!cfg.enabled) return;
+
+    const resource = resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: cfg.serviceName,
+      [ATTR_SERVICE_VERSION]: cfg.serviceVersion,
+    });
+
+    const endpointBase = cfg.endpoint.replace(/\/$/, "");
+    const exporter = new OTLPTraceExporter({
+      url: endpointBase ? `${endpointBase}/v1/traces` : undefined,
+      headers: cfg.headers,
+    });
+
+    const provider = new BasicTracerProvider({
+      resource,
+      spanProcessors: [new BatchSpanProcessor(exporter)],
+    });
+
+    // Wire OTel SDK globals so the real API delegates to this provider.
+    // The shim also gets wired separately in bootstrap.ts via getProvider().
+    trace.setGlobalTracerProvider(provider);
+
+    const contextManager = new AsyncLocalStorageContextManager();
+    contextManager.enable();
+
+    const propagator = new W3CTraceContextPropagator();
+
+    // Set propagator via OTel API (import is available in this extension).
+    const { propagation, context: otelContext } = await import("@opentelemetry/api");
+    propagation.setGlobalPropagator(propagator);
+    otelContext.setGlobalContextManager(contextManager);
+
+    this.sdkProvider = provider;
+  }
+
+  // eslint-disable-next-line require-await
+  async export(_spans: SpanData[]): Promise<void> {
+    // BatchSpanProcessor handles export automatically; this method is a no-op.
+    // Callers that want to push custom SpanData batches can extend this.
+  }
+
+  async shutdown(): Promise<void> {
+    if (this.sdkProvider) {
+      try {
+        await this.sdkProvider.shutdown();
+      } finally {
+        this.sdkProvider = null;
+      }
+    }
+  }
+
+  getProvider(): ShimTracerProvider {
+    if (this.sdkProvider) return this.sdkProvider;
+    // Return a passthrough to OTel's real global provider if start() wasn't
+    // called (e.g., test scaffolding without full setup).
+    return trace.getTracerProvider();
+  }
+
+  getMetricsAPI(): { getMeter(name: string | undefined, version?: string): unknown } | null {
+    // Return the OTel Metrics API so the core metrics subsystem can get meters.
+    return metrics;
+  }
+
+  getTraceAPI(): { getActiveSpan(): unknown; getSpan(ctx: unknown): unknown } | null {
+    if (!this.sdkProvider) return null;
+    return {
+      getActiveSpan: () => trace.getActiveSpan(),
+      getSpan: (ctx) => trace.getSpan(ctx as Parameters<typeof trace.getSpan>[0]),
+    };
+  }
+}
+
+class OpenTelemetryNodeTelemetryProvider implements NodeTelemetryProvider {
+  private sdk: NodeSDK | null = null;
+
+  async initialize(options: NodeTelemetryInitializeOptions): Promise<boolean> {
+    const resource = resourceFromAttributes({
+      "service.name": options.serviceName,
+      "service.version": options.serviceVersion,
+      "deployment.environment": options.deploymentEnvironment,
+    });
+    const traceExporter = new OTLPTraceExporter({ headers: options.exporterHeaders });
+
+    const sdk = new NodeSDK({
+      resource,
+      sampler: new ParentBasedSampler({
+        root: new TraceIdRatioBasedSampler(options.samplingRatio),
+      }),
+      spanProcessor: new BatchSpanProcessor(traceExporter, {
+        maxExportBatchSize: 100,
+        scheduledDelayMillis: 500,
+      }),
+      instrumentations: [
+        getNodeAutoInstrumentations({
+          "@opentelemetry/instrumentation-fs": { enabled: options.instrumentation.fs },
+          "@opentelemetry/instrumentation-http": { enabled: options.instrumentation.http },
+          "@opentelemetry/instrumentation-express": { enabled: options.instrumentation.express },
+        }),
+      ],
+    });
+
+    sdk.start();
+    this.sdk = sdk;
+
+    options.logger?.info("OpenTelemetry initialized", {
+      serviceName: options.serviceName,
+      samplingRatio: options.samplingRatio,
+    });
+
+    options.processTarget?.on("SIGTERM", async () => {
+      await this.shutdown();
+      options.logger?.info("OpenTelemetry shutdown complete");
+    });
+
+    return true;
+  }
+
+  async shutdown(): Promise<void> {
+    if (!this.sdk) return;
+    try {
+      await this.sdk.shutdown();
+    } finally {
+      this.sdk = null;
+    }
+  }
+}
+
+/**
+ * Default export — the ext-tracing-opentelemetry extension factory.
+ *
+ * Produces an extension that registers a `TracingExporter` contract
+ * implementation backed by the OpenTelemetry JS SDK.
+ */
+const extOpenTelemetry: ExtensionFactory = () => {
+  const exporterImpl = new OtlpTracingExporter();
+  const nodeTelemetryProvider = new OpenTelemetryNodeTelemetryProvider();
+
+  return {
+    name: "ext-tracing-opentelemetry",
+    version: "0.1.0",
+    capabilities: [
+      { type: "contract", name: "TracingExporter" },
+      { type: "contract", name: "NodeTelemetryProvider" },
+      { type: "net:outbound", hosts: ["*"] },
+      {
+        type: "env:read",
+        keys: [
+          "OTEL_EXPORTER_OTLP_ENDPOINT",
+          "OTEL_EXPORTER_OTLP_HEADERS",
+          "OTEL_SERVICE_NAME",
+          "OTEL_TRACES_ENABLED",
+        ],
+      },
+    ],
+    async setup(ctx) {
+      await exporterImpl.start(ctx.config);
+      ctx.provide("TracingExporter", exporterImpl);
+      ctx.provide("NodeTelemetryProvider", nodeTelemetryProvider);
+      ctx.logger.info("[ext-tracing-opentelemetry] TracingExporter registered");
+    },
+    async teardown() {
+      await nodeTelemetryProvider.shutdown();
+      await exporterImpl.shutdown();
+    },
+  };
+};
+
+export default extOpenTelemetry;
+export { OpenTelemetryNodeTelemetryProvider, OtlpTracingExporter };

package/src/src/agent/ag-ui/detached-start.ts

@@ -1,5 +1,5 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 import { INVALID_ARGUMENT } from "../../errors/index.js";
 import { streamDataStreamEvents } from "../data-stream.js";
@@ -89,9 +89,9 @@ export const getAgUiDetachedStartAcceptedSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getAgUiDetachedStartRequestSchema() */
-export const AgUiDetachedStartRequestSchema = getAgUiDetachedStartRequestSchema();
+export const AgUiDetachedStartRequestSchema = lazySchema(getAgUiDetachedStartRequestSchema);
 /** @deprecated Use getAgUiDetachedStartAcceptedSchema() */
-export const AgUiDetachedStartAcceptedSchema = getAgUiDetachedStartAcceptedSchema();
+export const AgUiDetachedStartAcceptedSchema = lazySchema(getAgUiDetachedStartAcceptedSchema);
 
 export type AgUiDetachedStartRequest = InferSchema<
   ReturnType<typeof getAgUiDetachedStartRequestSchema>

package/src/src/agent/ag-ui/host-support.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 { formatAgUiEvent } from "../../internal-agents/ag-ui-sse.js";
 import type { Message } from "../types.js";
@@ -103,11 +103,11 @@ export const getAgUiRequestSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getAgUiInjectedToolSchema() */
-export const AgUiInjectedToolSchema = getAgUiInjectedToolSchema();
+export const AgUiInjectedToolSchema = lazySchema(getAgUiInjectedToolSchema);
 /** @deprecated Use getAgUiContextItemSchema() */
-export const AgUiContextItemSchema = getAgUiContextItemSchema();
+export const AgUiContextItemSchema = lazySchema(getAgUiContextItemSchema);
 /** @deprecated Use getAgUiRequestSchema() */
-export const AgUiRequestSchema = getAgUiRequestSchema();
+export const AgUiRequestSchema = lazySchema(getAgUiRequestSchema);
 
 export type AgUiInjectedTool = InferSchema<ReturnType<typeof getAgUiInjectedToolSchema>>;
 export type AgUiContextItem = InferSchema<ReturnType<typeof getAgUiContextItemSchema>>;

package/src/src/agent/ag-ui/request-shared.ts

@@ -2,7 +2,7 @@ import { INVALID_ARGUMENT } from "../../errors/index.js";
 
 /**
  * Detects a validation error thrown by a `Schema.parse()` call. Works with
- * both the contract-DSL adapter (ext-zod wraps `ZodError` and sets `issues`)
+ * both the contract-DSL adapter (ext-schema-zod wraps `ZodError` and sets `issues`)
  * and raw zod errors.
  */
 function isSchemaValidationError(

package/src/src/agent/ag-ui/run-control.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 { extractRequest } from "./request-shared.js";
 import {
@@ -23,7 +23,7 @@ export const getAgUiResumeSignalSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getAgUiResumeSignalSchema() */
-export const AgUiResumeSignalSchema = getAgUiResumeSignalSchema();
+export const AgUiResumeSignalSchema = lazySchema(getAgUiResumeSignalSchema);
 
 export type AgUiResumeSignal = InferSchema<ReturnType<typeof getAgUiResumeSignalSchema>>;
 

package/src/src/agent/conversation/bootstrap.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";
 import { isUuid, toConversationPartsFromUiMessage } from "../../chat/conversation.js";
 import type { ChatUiMessage } from "../../chat/types.js";
@@ -32,7 +32,7 @@ export const getConversationRecordSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getConversationRecordSchema() */
-export const ConversationRecordSchema = getConversationRecordSchema();
+export const ConversationRecordSchema = lazySchema(getConversationRecordSchema);
 
 export const getConversationMessageRecordSchema = defineSchema((v) =>
   v.object({
@@ -41,7 +41,7 @@ export const getConversationMessageRecordSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getConversationMessageRecordSchema() */
-export const ConversationMessageRecordSchema = getConversationMessageRecordSchema();
+export const ConversationMessageRecordSchema = lazySchema(getConversationMessageRecordSchema);
 
 export type ConversationMessageRecord = InferSchema<
   ReturnType<typeof getConversationMessageRecordSchema>

package/src/src/agent/conversation/run-events.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 { type ChatStreamEvent } from "../../chat/protocol.js";
 import { normalizeConversationRunEvents } from "./run-event-normalization.js";
@@ -24,7 +24,7 @@ export const getConversationRunEventSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getConversationRunEventSchema() */
-export const ConversationRunEventSchema = getConversationRunEventSchema();
+export const ConversationRunEventSchema = lazySchema(getConversationRunEventSchema);
 
 export type ConversationRunEvent =
   & InferSchema<ReturnType<typeof getConversationRunEventSchema>>

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

@@ -13,7 +13,7 @@ import {
   sleepTool,
   type ToolExecutionContext,
 } from "../tool/index.js";
-import { defineSchema } from "../schemas/index.js";
+import { defineSchema, lazySchema } from "../schemas/index.js";
 import type { InferSchema, SchemaValidator } from "../extensions/schema/index.js";
 import { buildExecuteToolTraceAttributes } from "./agent-trace-attributes.js";
 import type {
@@ -150,14 +150,18 @@ export const getDefaultHostedInvokeAgentSelectionSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getDefaultHostedInvokeAgentSelectionSchema() */
-export const defaultHostedInvokeAgentSelectionSchema = getDefaultHostedInvokeAgentSelectionSchema();
+export const defaultHostedInvokeAgentSelectionSchema = lazySchema(
+  getDefaultHostedInvokeAgentSelectionSchema,
+);
 
 export const getDefaultHostedInvokeAgentInputSchema = defineSchema((v) =>
   getHostedChildForkToolInputSchema().extend(defaultHostedInvokeAgentSelectionFields(v))
 );
 
 /** @deprecated Use getDefaultHostedInvokeAgentInputSchema() */
-export const defaultHostedInvokeAgentInputSchema = getDefaultHostedInvokeAgentInputSchema();
+export const defaultHostedInvokeAgentInputSchema = lazySchema(
+  getDefaultHostedInvokeAgentInputSchema,
+);
 
 export type DefaultHostedInvokeAgentInput = InferSchema<
   ReturnType<typeof getDefaultHostedInvokeAgentInputSchema>