veryfront 0.1.519 → 0.1.520

package/src/src/agent/runtime/agent-definition-files.ts

@@ -1,41 +1,68 @@
+import type { Schema, SchemaValidator } from "../../extensions/schema/index.js";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, resolve } from "node:path";
-import { z } from "zod";
+import { defineSchema } from "../../schemas/define.js";
+import { lazySchema } from "../../schemas/lazy.js";
 import {
   parseRuntimeAgentMarkdownDefinition,
   type RuntimeAgentMarkdownDefinition,
 } from "./agent-definition.js";
 
-const runtimeAgentDefinitionFileNameSchema = z.string().min(1).regex(/^[A-Za-z0-9._-]+\.md$/);
-const runtimeAgentDefinitionFileIdSchema = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/);
-
-export const resolveRuntimeAgentDefinitionsDirInputSchema = z.object({
-  baseDir: z.string().min(1),
-  id: runtimeAgentDefinitionFileIdSchema,
-  fileName: runtimeAgentDefinitionFileNameSchema.optional(),
-});
+export type ResolveRuntimeAgentDefinitionsDirInput = {
+  baseDir: string;
+  id: string;
+  fileName?: string;
+};
 
-export type ResolveRuntimeAgentDefinitionsDirInput = z.infer<
-  typeof resolveRuntimeAgentDefinitionsDirInputSchema
->;
+export type ListRuntimeAgentMarkdownDefinitionIdsInput = {
+  baseDir: string;
+};
 
-export const listRuntimeAgentMarkdownDefinitionIdsInputSchema = z.object({
-  baseDir: z.string().min(1),
-});
+export type LoadRuntimeAgentMarkdownDefinitionFromFileInput = {
+  agentsDir: string;
+  id: string;
+  fileName?: string;
+};
 
-export type ListRuntimeAgentMarkdownDefinitionIdsInput = z.infer<
-  typeof listRuntimeAgentMarkdownDefinitionIdsInputSchema
->;
+function runtimeAgentDefinitionFileName(v: SchemaValidator): Schema<string> {
+  return v.string().min(1).regex(/^[A-Za-z0-9._-]+\.md$/);
+}
 
-export const loadRuntimeAgentMarkdownDefinitionFromFileInputSchema = z.object({
-  agentsDir: z.string().min(1),
-  id: runtimeAgentDefinitionFileIdSchema,
-  fileName: runtimeAgentDefinitionFileNameSchema.optional(),
-});
+function runtimeAgentDefinitionFileId(v: SchemaValidator): Schema<string> {
+  return v.string().min(1).regex(/^[A-Za-z0-9._-]+$/);
+}
 
-export type LoadRuntimeAgentMarkdownDefinitionFromFileInput = z.infer<
-  typeof loadRuntimeAgentMarkdownDefinitionFromFileInputSchema
->;
+const runtimeAgentDefinitionFileNameSchema = lazySchema(
+  defineSchema<string>(runtimeAgentDefinitionFileName),
+);
+
+export const resolveRuntimeAgentDefinitionsDirInputSchema = lazySchema(
+  defineSchema<ResolveRuntimeAgentDefinitionsDirInput>((v) =>
+    v.object({
+      baseDir: v.string().min(1),
+      id: runtimeAgentDefinitionFileId(v),
+      fileName: runtimeAgentDefinitionFileName(v).optional(),
+    })
+  ),
+);
+
+export const listRuntimeAgentMarkdownDefinitionIdsInputSchema = lazySchema(
+  defineSchema<ListRuntimeAgentMarkdownDefinitionIdsInput>((v) =>
+    v.object({
+      baseDir: v.string().min(1),
+    })
+  ),
+);
+
+export const loadRuntimeAgentMarkdownDefinitionFromFileInputSchema = lazySchema(
+  defineSchema<LoadRuntimeAgentMarkdownDefinitionFromFileInput>((v) =>
+    v.object({
+      agentsDir: v.string().min(1),
+      id: runtimeAgentDefinitionFileId(v),
+      fileName: runtimeAgentDefinitionFileName(v).optional(),
+    })
+  ),
+);
 
 function getRuntimeAgentDefinitionFileName(input: {
   id: string;

package/src/src/agent/runtime/agent-definition.ts

@@ -1,5 +1,5 @@
 import { extract } from "../../platform/compat/std/front-matter-yaml.js";
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 import type { ChatSystemMessage } from "../../chat/types.js";
 import { createRuntimePromptBlock } from "./prompt-block.js";
@@ -14,7 +14,7 @@ export const getRuntimeAgentThinkingConfigSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentThinkingConfigSchema() */
-export const runtimeAgentThinkingConfigSchema = getRuntimeAgentThinkingConfigSchema();
+export const runtimeAgentThinkingConfigSchema = lazySchema(getRuntimeAgentThinkingConfigSchema);
 
 export type RuntimeAgentThinkingConfig = InferSchema<
   ReturnType<typeof getRuntimeAgentThinkingConfigSchema>
@@ -35,7 +35,9 @@ export const getRuntimeAgentMarkdownDefinitionSchema = defineSchema((v) =>
 export const DEFAULT_RUNTIME_AGENT_CONTEXT_MARKER = "<!-- veryfront-runtime-context -->";
 
 /** @deprecated Use getRuntimeAgentMarkdownDefinitionSchema() */
-export const runtimeAgentMarkdownDefinitionSchema = getRuntimeAgentMarkdownDefinitionSchema();
+export const runtimeAgentMarkdownDefinitionSchema = lazySchema(
+  getRuntimeAgentMarkdownDefinitionSchema,
+);
 
 export type RuntimeAgentMarkdownDefinition = InferSchema<
   ReturnType<typeof getRuntimeAgentMarkdownDefinitionSchema>
@@ -49,8 +51,9 @@ export const getParseRuntimeAgentMarkdownDefinitionInputSchema = defineSchema((v
 );
 
 /** @deprecated Use getParseRuntimeAgentMarkdownDefinitionInputSchema() */
-export const parseRuntimeAgentMarkdownDefinitionInputSchema =
-  getParseRuntimeAgentMarkdownDefinitionInputSchema();
+export const parseRuntimeAgentMarkdownDefinitionInputSchema = lazySchema(
+  getParseRuntimeAgentMarkdownDefinitionInputSchema,
+);
 
 export type ParseRuntimeAgentMarkdownDefinitionInput = InferSchema<
   ReturnType<typeof getParseRuntimeAgentMarkdownDefinitionInputSchema>

package/src/src/agent/runtime/agent-invocation-contract.ts

@@ -1,4 +1,4 @@
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema, RefinementCtx } from "../../extensions/schema/index.js";
 import { parseAgUiJsonRequestOrError } from "../ag-ui/request-shared.js";
 
@@ -21,12 +21,12 @@ export const getRuntimeAgentRunIdSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentRunIdSchema() */
-export const RuntimeAgentRunIdSchema = getRuntimeAgentRunIdSchema();
+export const RuntimeAgentRunIdSchema = lazySchema(getRuntimeAgentRunIdSchema);
 
 export const getRuntimeAgentToolCallIdSchema = defineSchema((v) => v.string().min(1).max(128));
 
 /** @deprecated Use getRuntimeAgentToolCallIdSchema() */
-export const RuntimeAgentToolCallIdSchema = getRuntimeAgentToolCallIdSchema();
+export const RuntimeAgentToolCallIdSchema = lazySchema(getRuntimeAgentToolCallIdSchema);
 
 export const getRuntimeAgentServiceIdSchema = defineSchema((v) =>
   v.string().min(1).max(128).regex(
@@ -36,12 +36,12 @@ export const getRuntimeAgentServiceIdSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentServiceIdSchema() */
-export const RuntimeAgentServiceIdSchema = getRuntimeAgentServiceIdSchema();
+export const RuntimeAgentServiceIdSchema = lazySchema(getRuntimeAgentServiceIdSchema);
 
 export const getRuntimeAgentIdSchema = defineSchema((v) => v.string().min(1).max(128));
 
 /** @deprecated Use getRuntimeAgentIdSchema() */
-export const RuntimeAgentIdSchema = getRuntimeAgentIdSchema();
+export const RuntimeAgentIdSchema = lazySchema(getRuntimeAgentIdSchema);
 
 export const getRuntimeAgentToolNameSchema = defineSchema((v) =>
   v.string().min(1).max(128).regex(
@@ -51,7 +51,7 @@ export const getRuntimeAgentToolNameSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentToolNameSchema() */
-export const RuntimeAgentToolNameSchema = getRuntimeAgentToolNameSchema();
+export const RuntimeAgentToolNameSchema = lazySchema(getRuntimeAgentToolNameSchema);
 
 const getRuntimeAgentToolJsonSchemaDocumentSchema = defineSchema((v) =>
   v.record(v.string(), v.unknown()).refine(
@@ -74,7 +74,7 @@ export const getRuntimeAgentToolSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentToolSchema() */
-export const RuntimeAgentToolSchema = getRuntimeAgentToolSchema();
+export const RuntimeAgentToolSchema = lazySchema(getRuntimeAgentToolSchema);
 
 export const getRuntimeAgentContextItemSchema = defineSchema((v) =>
   v.discriminatedUnion("type", [
@@ -102,7 +102,7 @@ export const getRuntimeAgentContextItemSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentContextItemSchema() */
-export const RuntimeAgentContextItemSchema = getRuntimeAgentContextItemSchema();
+export const RuntimeAgentContextItemSchema = lazySchema(getRuntimeAgentContextItemSchema);
 
 export const getRuntimeAgentSourceContextSchema = defineSchema((v) =>
   v.discriminatedUnion("type", [
@@ -123,14 +123,14 @@ export const getRuntimeAgentSourceContextSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentSourceContextSchema() */
-export const RuntimeAgentSourceContextSchema = getRuntimeAgentSourceContextSchema();
+export const RuntimeAgentSourceContextSchema = lazySchema(getRuntimeAgentSourceContextSchema);
 
 export const getRuntimeAgentTargetKindSchema = defineSchema((v) =>
   v.enum(["production", "environment", "preview_branch"])
 );
 
 /** @deprecated Use getRuntimeAgentTargetKindSchema() */
-export const RuntimeAgentTargetKindSchema = getRuntimeAgentTargetKindSchema();
+export const RuntimeAgentTargetKindSchema = lazySchema(getRuntimeAgentTargetKindSchema);
 
 type RuntimeAgentTargetSelectionInput = {
   runtimeTargetKind?: InferSchema<ReturnType<typeof getRuntimeAgentTargetKindSchema>> | null;
@@ -187,7 +187,7 @@ export const getRuntimeAgentProjectContextSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentProjectContextSchema() */
-export const RuntimeAgentProjectContextSchema = getRuntimeAgentProjectContextSchema();
+export const RuntimeAgentProjectContextSchema = lazySchema(getRuntimeAgentProjectContextSchema);
 
 export const getRuntimeAgentValidatedClaimsSchema = defineSchema((v) =>
   v.object({
@@ -199,7 +199,7 @@ export const getRuntimeAgentValidatedClaimsSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentValidatedClaimsSchema() */
-export const RuntimeAgentValidatedClaimsSchema = getRuntimeAgentValidatedClaimsSchema();
+export const RuntimeAgentValidatedClaimsSchema = lazySchema(getRuntimeAgentValidatedClaimsSchema);
 
 export const getRuntimeAgentRunContextSchema = defineSchema((v) =>
   v.object({
@@ -266,7 +266,7 @@ export const getRuntimeAgentRunContextSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentRunContextSchema() */
-export const RuntimeAgentRunContextSchema = getRuntimeAgentRunContextSchema();
+export const RuntimeAgentRunContextSchema = lazySchema(getRuntimeAgentRunContextSchema);
 
 export const getRuntimeAgentRunInvocationSchema = defineSchema((v) =>
   v.object({
@@ -286,7 +286,7 @@ export const getRuntimeAgentRunInvocationSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeAgentRunInvocationSchema() */
-export const RuntimeAgentRunInvocationSchema = getRuntimeAgentRunInvocationSchema();
+export const RuntimeAgentRunInvocationSchema = lazySchema(getRuntimeAgentRunInvocationSchema);
 
 export type RuntimeAgentTool = InferSchema<ReturnType<typeof getRuntimeAgentToolSchema>>;
 export type RuntimeAgentContextItem = InferSchema<

package/src/src/agent/runtime/client-profile.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";
 
 export const getRuntimeClientTypeSchema = defineSchema((v) =>
@@ -24,11 +24,11 @@ export const getRuntimeClientProfileSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeClientTypeSchema() */
-export const runtimeClientTypeSchema = getRuntimeClientTypeSchema();
+export const runtimeClientTypeSchema = lazySchema(getRuntimeClientTypeSchema);
 /** @deprecated Use getRuntimeClientCapabilitySchema() */
-export const runtimeClientCapabilitySchema = getRuntimeClientCapabilitySchema();
+export const runtimeClientCapabilitySchema = lazySchema(getRuntimeClientCapabilitySchema);
 /** @deprecated Use getRuntimeClientProfileSchema() */
-export const runtimeClientProfileSchema = getRuntimeClientProfileSchema();
+export const runtimeClientProfileSchema = lazySchema(getRuntimeClientProfileSchema);
 
 export type RuntimeClientType = InferSchema<ReturnType<typeof getRuntimeClientTypeSchema>>;
 export type RuntimeClientCapability = InferSchema<

package/src/src/agent/runtime/load-skill-tool.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 { tool } from "../../tool/index.js";
 import type { Tool } from "../../tool/types.js";
@@ -82,7 +82,7 @@ export const getRuntimeLoadSkillToolInputSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeLoadSkillToolInputSchema() */
-const runtimeLoadSkillToolInputSchema = getRuntimeLoadSkillToolInputSchema();
+const runtimeLoadSkillToolInputSchema = lazySchema(getRuntimeLoadSkillToolInputSchema);
 
 export type RuntimeLoadSkillToolInput = InferSchema<
   ReturnType<typeof getRuntimeLoadSkillToolInputSchema>

package/src/src/agent/runtime/project-files-client.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";
 
 const DEFAULT_PROJECT_FILES_TIMEOUT_MS = 15_000;
@@ -35,9 +35,9 @@ const getApiErrorBodySchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeProjectFileSchema() */
-export const runtimeProjectFileSchema = getRuntimeProjectFileSchema();
+export const runtimeProjectFileSchema = lazySchema(getRuntimeProjectFileSchema);
 /** @deprecated Use getRuntimeProjectFileListItemSchema() */
-export const runtimeProjectFileListItemSchema = getRuntimeProjectFileListItemSchema();
+export const runtimeProjectFileListItemSchema = lazySchema(getRuntimeProjectFileListItemSchema);
 
 export type RuntimeProjectFile = InferSchema<ReturnType<typeof getRuntimeProjectFileSchema>>;
 export type RuntimeProjectFileListItem = InferSchema<

package/src/src/agent/runtime/skill-metadata.ts

@@ -1,5 +1,5 @@
 import { extract } from "../../platform/compat/std/front-matter-yaml.js";
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 
 function normalizeAllowedTools(value: string | string[] | undefined): string[] {
   if (value === undefined) {
@@ -52,7 +52,7 @@ export const getRuntimeSkillFrontmatterSchema = defineSchema((v) =>
 );
 
 /** @deprecated Use getRuntimeSkillFrontmatterSchema() */
-export const RuntimeSkillFrontmatterSchema = getRuntimeSkillFrontmatterSchema();
+export const RuntimeSkillFrontmatterSchema = lazySchema(getRuntimeSkillFrontmatterSchema);
 
 export type RuntimeSkillDefinition = {
   id: string;

package/src/src/agent/service/auth.ts

@@ -1,4 +1,5 @@
-import { importSPKI, jwtVerify, type KeyLike } from "jose";
+import { tryResolve } from "../../extensions/contracts.js";
+import type { AuthProvider, TokenPayload } from "../../extensions/auth/index.js";
 
 export type HostedServiceAuthErrorCode =
   | "UNAUTHENTICATED"
@@ -74,11 +75,14 @@ export type HostedServiceAuthFetch = (
   init?: RequestInit,
 ) => Promise<Response>;
 
+export type HostedServiceJwtVerifier = Pick<AuthProvider, "verifyWithPublicKey">;
+
 export type HostedServiceAuthOptions = {
   getConfig: () => HostedServiceAuthConfig;
   logger?: HostedServiceAuthLogger;
   trace?: HostedServiceAuthTrace;
   fetch?: HostedServiceAuthFetch;
+  authProvider?: HostedServiceJwtVerifier;
   projectAccessTimeoutMs?: number;
 };
 
@@ -106,9 +110,6 @@ export type AgentServiceAuthFetch = HostedServiceAuthFetch;
 export type AgentServiceAuthOptions = HostedServiceAuthOptions;
 export type AgentServiceAuth = HostedServiceAuth;
 
-let cachedPublicKeyInput: string | undefined;
-let cachedPublicKeyPromise: Promise<KeyLike> | undefined;
-
 function defaultTrace<TResult>(
   _operationName: string,
   operation: () => Promise<TResult>,
@@ -124,13 +125,10 @@ function getProjectAccessTimeoutMs(options: HostedServiceAuthOptions): number {
   return options.projectAccessTimeoutMs ?? 15_000;
 }
 
-function getPublicKey(publicKeyInput: string): Promise<KeyLike> {
-  if (cachedPublicKeyInput !== publicKeyInput || !cachedPublicKeyPromise) {
-    cachedPublicKeyInput = publicKeyInput;
-    cachedPublicKeyPromise = importSPKI(publicKeyInput, "RS256");
-  }
-
-  return cachedPublicKeyPromise;
+function getAuthProvider(
+  options: HostedServiceAuthOptions,
+): HostedServiceJwtVerifier | undefined {
+  return options.authProvider ?? tryResolve<HostedServiceJwtVerifier>("AuthProvider");
 }
 
 export function getHostedServiceTokenFromRequest(request: Request): string | null {
@@ -269,10 +267,21 @@ export function createHostedServiceAuth(
       }
 
       try {
-        const publicKey = await getPublicKey(config.OAUTH_PUBLIC_KEY);
-        const { payload } = await jwtVerify(token, publicKey, {
+        const authProvider = getAuthProvider(options);
+        if (!authProvider) {
+          return {
+            success: false,
+            error: {
+              statusCode: 500,
+              errorCode: "SERVER_ERROR",
+              message: "JWT auth provider not configured",
+            },
+          };
+        }
+
+        const payload = await authProvider.verifyWithPublicKey(token, config.OAUTH_PUBLIC_KEY, {
           algorithms: ["RS256"],
-        });
+        }) as TokenPayload;
 
         const userId = typeof payload.userId === "string" ? payload.userId : null;
         if (!userId) {

package/src/src/agent/service/config.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/define.js";
+import { lazySchema } from "../../schemas/lazy.js";
 
 function parseBooleanFlag(value: string): boolean {
   return value === "true";
@@ -8,58 +9,84 @@ function splitAllowedOrigins(value: string): string[] {
   return value.split(",").map((origin) => origin.trim());
 }
 
-const booleanFlagSchema = z.string().default("false").transform(parseBooleanFlag);
+export type AgentServiceRegistrationMode = "auto" | "enabled" | "disabled";
 
-const agentServiceRegistrationModeInputSchema = z
-  .enum(["auto", "enabled", "disabled", "true", "false"])
-  .default("auto")
-  .transform((value) => {
-    if (value === "true") return "enabled";
-    if (value === "false") return "disabled";
-    return value;
-  });
+export type AgentServiceConfig = {
+  VERYFRONT_API_URL: string;
+  VERYFRONT_MCP_URL: string;
+  VERYFRONT_API_TOKEN?: string;
+  VERYFRONT_PROJECT_ID?: string;
+  VERYFRONT_AGENT_SERVICE_URL?: string;
+  VERYFRONT_AGENT_SERVICE_KEY?: string;
+  VERYFRONT_AGENT_SERVICE_REGISTRATION: AgentServiceRegistrationMode;
+  VERYFRONT_AGENT_SERVICE_HEARTBEAT_INTERVAL_MS: number;
+  VERYFRONT_AGENT_SERVICE_REGION?: string;
+  VERYFRONT_STUDIO_MCP_URL: string;
+  VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT: boolean;
+  VERYFRONT_ENABLE_DURABLE_TASK: boolean;
+  NODE_ENV: "development" | "test" | "production";
+  PORT: number;
+  OAUTH_PUBLIC_KEY?: string;
+  ALLOWED_ORIGINS: string[];
+  OTEL_ENABLED: boolean;
+  OTEL_EXPORTER_OTLP_ENDPOINT?: string;
+};
 
-export const agentServiceConfigSchema = z.object({
-  VERYFRONT_API_URL: z.string().url().default("https://api.veryfront.com"),
-  VERYFRONT_API_TOKEN: z.string().min(1).optional(),
-  VERYFRONT_PROJECT_ID: z.string().min(1).optional(),
-  VERYFRONT_AGENT_SERVICE_URL: z.string().url().optional(),
-  VERYFRONT_AGENT_SERVICE_KEY: z.string().min(1).max(128).optional(),
-  VERYFRONT_AGENT_SERVICE_REGISTRATION: agentServiceRegistrationModeInputSchema,
-  VERYFRONT_AGENT_SERVICE_HEARTBEAT_INTERVAL_MS: z.coerce.number().positive().default(30_000),
-  VERYFRONT_AGENT_SERVICE_REGION: z.string().min(1).max(128).optional(),
-  NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
-  PORT: z.coerce.number().default(3001),
-  OAUTH_PUBLIC_KEY: z.string().optional(),
-  VERYFRONT_STUDIO_MCP_URL: z.string().default(""),
-  VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT: booleanFlagSchema,
-  VERYFRONT_ENABLE_DURABLE_TASK: booleanFlagSchema,
-  ALLOWED_ORIGINS: z.string().default("http://localhost:3000,http://veryfront.me:3000"),
-  OTEL_ENABLED: booleanFlagSchema,
-  OTEL_EXPORTER_OTLP_ENDPOINT: z.string().optional(),
-}).transform((env) => ({
-  VERYFRONT_API_URL: env.VERYFRONT_API_URL,
-  VERYFRONT_MCP_URL: `${env.VERYFRONT_API_URL}/mcp`,
-  VERYFRONT_API_TOKEN: env.VERYFRONT_API_TOKEN,
-  VERYFRONT_PROJECT_ID: env.VERYFRONT_PROJECT_ID,
-  VERYFRONT_AGENT_SERVICE_URL: env.VERYFRONT_AGENT_SERVICE_URL,
-  VERYFRONT_AGENT_SERVICE_KEY: env.VERYFRONT_AGENT_SERVICE_KEY,
-  VERYFRONT_AGENT_SERVICE_REGISTRATION: env.VERYFRONT_AGENT_SERVICE_REGISTRATION,
-  VERYFRONT_AGENT_SERVICE_HEARTBEAT_INTERVAL_MS: env.VERYFRONT_AGENT_SERVICE_HEARTBEAT_INTERVAL_MS,
-  VERYFRONT_AGENT_SERVICE_REGION: env.VERYFRONT_AGENT_SERVICE_REGION,
-  VERYFRONT_STUDIO_MCP_URL: env.VERYFRONT_STUDIO_MCP_URL,
-  VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT: env.VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT,
-  VERYFRONT_ENABLE_DURABLE_TASK: env.VERYFRONT_ENABLE_DURABLE_TASK,
-  NODE_ENV: env.NODE_ENV,
-  PORT: env.PORT,
-  OAUTH_PUBLIC_KEY: env.OAUTH_PUBLIC_KEY,
-  ALLOWED_ORIGINS: splitAllowedOrigins(env.ALLOWED_ORIGINS),
-  OTEL_ENABLED: env.OTEL_ENABLED,
-  OTEL_EXPORTER_OTLP_ENDPOINT: env.OTEL_EXPORTER_OTLP_ENDPOINT,
-}));
+export type AgentServiceConfigInput = Record<string, string | number | undefined>;
 
-export type AgentServiceConfig = z.infer<typeof agentServiceConfigSchema>;
-export type AgentServiceConfigInput = z.input<typeof agentServiceConfigSchema>;
+const getAgentServiceConfigSchema = defineSchema<AgentServiceConfig>((v) => {
+  const booleanFlagSchema = v.string().default("false").transform(parseBooleanFlag);
+  const agentServiceRegistrationModeInputSchema = v
+    .enum(["auto", "enabled", "disabled", "true", "false"] as const)
+    .default("auto")
+    .transform((value) => {
+      if (value === "true") return "enabled";
+      if (value === "false") return "disabled";
+      return value as AgentServiceRegistrationMode;
+    });
+
+  return v.object({
+    VERYFRONT_API_URL: v.string().url().default("https://api.veryfront.com"),
+    VERYFRONT_API_TOKEN: v.string().min(1).optional(),
+    VERYFRONT_PROJECT_ID: v.string().min(1).optional(),
+    VERYFRONT_AGENT_SERVICE_URL: v.string().url().optional(),
+    VERYFRONT_AGENT_SERVICE_KEY: v.string().min(1).max(128).optional(),
+    VERYFRONT_AGENT_SERVICE_REGISTRATION: agentServiceRegistrationModeInputSchema,
+    VERYFRONT_AGENT_SERVICE_HEARTBEAT_INTERVAL_MS: v.coerce.number().positive().default(30_000),
+    VERYFRONT_AGENT_SERVICE_REGION: v.string().min(1).max(128).optional(),
+    NODE_ENV: v.enum(["development", "test", "production"] as const).default("development"),
+    PORT: v.coerce.number().default(3001),
+    OAUTH_PUBLIC_KEY: v.string().optional(),
+    VERYFRONT_STUDIO_MCP_URL: v.string().default(""),
+    VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT: booleanFlagSchema,
+    VERYFRONT_ENABLE_DURABLE_TASK: booleanFlagSchema,
+    ALLOWED_ORIGINS: v.string().default("http://localhost:3000,http://veryfront.me:3000"),
+    OTEL_ENABLED: booleanFlagSchema,
+    OTEL_EXPORTER_OTLP_ENDPOINT: v.string().optional(),
+  }).transform((env) => ({
+    VERYFRONT_API_URL: env.VERYFRONT_API_URL,
+    VERYFRONT_MCP_URL: `${env.VERYFRONT_API_URL}/mcp`,
+    VERYFRONT_API_TOKEN: env.VERYFRONT_API_TOKEN,
+    VERYFRONT_PROJECT_ID: env.VERYFRONT_PROJECT_ID,
+    VERYFRONT_AGENT_SERVICE_URL: env.VERYFRONT_AGENT_SERVICE_URL,
+    VERYFRONT_AGENT_SERVICE_KEY: env.VERYFRONT_AGENT_SERVICE_KEY,
+    VERYFRONT_AGENT_SERVICE_REGISTRATION: env.VERYFRONT_AGENT_SERVICE_REGISTRATION,
+    VERYFRONT_AGENT_SERVICE_HEARTBEAT_INTERVAL_MS:
+      env.VERYFRONT_AGENT_SERVICE_HEARTBEAT_INTERVAL_MS,
+    VERYFRONT_AGENT_SERVICE_REGION: env.VERYFRONT_AGENT_SERVICE_REGION,
+    VERYFRONT_STUDIO_MCP_URL: env.VERYFRONT_STUDIO_MCP_URL,
+    VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT: env.VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT,
+    VERYFRONT_ENABLE_DURABLE_TASK: env.VERYFRONT_ENABLE_DURABLE_TASK,
+    NODE_ENV: env.NODE_ENV,
+    PORT: env.PORT,
+    OAUTH_PUBLIC_KEY: env.OAUTH_PUBLIC_KEY,
+    ALLOWED_ORIGINS: splitAllowedOrigins(env.ALLOWED_ORIGINS),
+    OTEL_ENABLED: env.OTEL_ENABLED,
+    OTEL_EXPORTER_OTLP_ENDPOINT: env.OTEL_EXPORTER_OTLP_ENDPOINT,
+  }));
+});
+
+export const agentServiceConfigSchema = lazySchema(getAgentServiceConfigSchema);
 
 export const hostedAgentServiceConfigSchema = agentServiceConfigSchema;
 export type HostedAgentServiceConfig = AgentServiceConfig;

package/src/src/agent/service/node-runtime-infrastructure.ts

@@ -1,4 +1,4 @@
-import * as api from "@opentelemetry/api";
+import * as api from "../../observability/tracing/api-shim.js";
 import {
   createOpenTelemetryServiceTracer,
   type ServiceTracerAttributes,