veryfront 0.1.502 → 0.1.504

package/src/src/agent/schemas/tool.schema.ts

@@ -1,8 +1,11 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
 /** Input schema when an agent is used as a tool */
-export const AgentToolInputSchema = z.object({
-  input: z.string().describe("Input for the agent"),
-});
+export const getAgentToolInputSchema = defineSchema((v) =>
+  v.object({
+    input: v.string().describe("Input for the agent"),
+  })
+);
 
-export type AgentToolInput = z.infer<typeof AgentToolInputSchema>;
+export type AgentToolInput = InferSchema<ReturnType<typeof getAgentToolInputSchema>>;

package/src/src/agent/veryfront-cloud-agent-service.ts

@@ -64,6 +64,10 @@ import { type HostedProjectSkillIdsContext } from "./hosted-project-steering-ada
 import type { RuntimeLoadSkillToolContext } from "./runtime-load-skill-tool.js";
 import type { RuntimeProjectSteeringLookup } from "./runtime-project-skill-catalog.js";
 import type { RuntimeSkillDefinition } from "./runtime-skill-metadata.js";
+import {
+  loadRuntimeAgentMarkdownDefinitionFromFile,
+  resolveRuntimeAgentDefinitionsDir,
+} from "./runtime-agent-definition-files.js";
 import type { RuntimeAgentMarkdownDefinition } from "./runtime-agent-definition.js";
 import {
   buildVeryfrontCloudRuntimeInstructions,
@@ -314,6 +318,7 @@ function createNodeVeryfrontCloudAgentServiceContext(
     tracker: createDetachedRunTracker<AgUiResumeValue>(),
     discoveryResult: null as DiscoveryResult | null,
     agentConfig: null as RuntimeAgentMarkdownDefinition | null,
+    agentConfigs: new Map<string, RuntimeAgentMarkdownDefinition>(),
   };
 }
 
@@ -340,21 +345,50 @@ function getMarkdownAgentConfig(
   return context.projectSteering.getAgentConfig();
 }
 
+function loadMarkdownAgentConfig(
+  context: NodeVeryfrontCloudAgentServiceContext,
+  agentId: string,
+): RuntimeAgentMarkdownDefinition {
+  if (agentId === context.options.agentId) {
+    return getMarkdownAgentConfig(context);
+  }
+
+  const agentsDir = resolveRuntimeAgentDefinitionsDir({
+    baseDir: resolveBaseDir(context.options),
+    id: agentId,
+  });
+
+  return loadRuntimeAgentMarkdownDefinitionFromFile({
+    agentsDir,
+    id: agentId,
+  });
+}
+
 async function resolveAgentConfig(
   context: NodeVeryfrontCloudAgentServiceContext,
+  agentId: string,
 ): Promise<RuntimeAgentMarkdownDefinition> {
+  const cachedAgentConfig = context.agentConfigs.get(agentId);
+  if (cachedAgentConfig) {
+    return cachedAgentConfig;
+  }
+
   const source = context.options.agentSource ?? "auto";
-  const codeAgent = getAgent(context.options.agentId);
+  const codeAgent = getAgent(agentId);
 
   if (source !== "markdown" && codeAgent) {
-    return await createRuntimeAgentDefinitionFromCodeAgent(codeAgent);
+    const agentConfig = await createRuntimeAgentDefinitionFromCodeAgent(codeAgent);
+    context.agentConfigs.set(agentConfig.id, agentConfig);
+    return agentConfig;
   }
 
   if (source === "code") {
-    throw new Error(`Code agent "${context.options.agentId}" was not discovered.`);
+    throw new Error(`Code agent "${agentId}" was not discovered.`);
   }
 
-  return getMarkdownAgentConfig(context);
+  const agentConfig = loadMarkdownAgentConfig(context, agentId);
+  context.agentConfigs.set(agentConfig.id, agentConfig);
+  return agentConfig;
 }
 
 function getResolvedAgentConfig(
@@ -387,7 +421,7 @@ async function initializeNodeVeryfrontCloudAgentServiceContext(
   context: NodeVeryfrontCloudAgentServiceContext,
 ): Promise<void> {
   await discoverProjectPrimitives(context);
-  context.agentConfig = await resolveAgentConfig(context);
+  context.agentConfig = await resolveAgentConfig(context, context.options.agentId);
 }
 
 function getDiscoveredHostTools(): HostToolSet {
@@ -639,7 +673,7 @@ async function prepareChatExecution(
 
   setPrepareChatExecutionStartAttributes(context, { projectId, userId });
 
-  const agentConfig = getResolvedAgentConfig(context);
+  const agentConfig = await resolveAgentConfig(context, req.agentId ?? context.options.agentId);
   const {
     effectiveMessages,
     rootRunContext,

package/src/src/cache/schemas/cache-backend.schema.ts

@@ -1,13 +1,22 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
-export const CacheBackendTypeSchema = z.enum(["memory", "redis", "api", "disk"]);
+export const getCacheBackendTypeSchema = defineSchema((v) =>
+  v.enum(["memory", "redis", "api", "disk"])
+);
 
-export const CacheSetBatchEntrySchema = z.object({
-  key: z.string(),
-  value: z.string(),
-  ttl: z.number().int().positive().optional(),
-});
+export const getCacheSetBatchEntrySchema = defineSchema((v) =>
+  v.object({
+    key: v.string(),
+    value: v.string(),
+    ttl: v.number().int().positive().optional(),
+  })
+);
 
 // Inferred types
-export type CacheBackendType = z.infer<typeof CacheBackendTypeSchema>;
-export type CacheSetBatchEntry = z.infer<typeof CacheSetBatchEntrySchema>;
+export type CacheBackendType = InferSchema<ReturnType<typeof getCacheBackendTypeSchema>>;
+export type CacheSetBatchEntry = InferSchema<ReturnType<typeof getCacheSetBatchEntrySchema>>;
+
+// Backward compat aliases
+export const CacheBackendTypeSchema = getCacheBackendTypeSchema();
+export const CacheSetBatchEntrySchema = getCacheSetBatchEntrySchema();

package/src/src/cache/schemas/cache-key.schema.ts

@@ -1,11 +1,17 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
 /** Context used for generating cache keys in multi-project environments */
-export const CacheKeyContextSchema = z.object({
-  projectId: z.string().min(1, "projectId cannot be empty"),
-  mode: z.enum(["production", "preview"]),
-  versionId: z.string().min(1, "versionId cannot be empty"),
-});
+export const getCacheKeyContextSchema = defineSchema((v) =>
+  v.object({
+    projectId: v.string().min(1, "projectId cannot be empty"),
+    mode: v.enum(["production", "preview"]),
+    versionId: v.string().min(1, "versionId cannot be empty"),
+  })
+);
 
 // Inferred type
-export type CacheKeyContext = z.infer<typeof CacheKeyContextSchema>;
+export type CacheKeyContext = InferSchema<ReturnType<typeof getCacheKeyContextSchema>>;
+
+// Backward compat alias
+export const CacheKeyContextSchema = getCacheKeyContextSchema();

package/src/src/channels/control-plane.ts

@@ -4,107 +4,143 @@ import type { Agent } from "../agent/index.js";
 import type { HandlerContext } from "../types/index.js";
 import { skillRegistry } from "../skill/registry.js";
 import { base64urlEncodeBytes } from "../utils/base64url.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema, Schema } from "../extensions/schema/index.js";
 
 const SIGNATURE_SKEW_SECONDS = 5;
 
 export const CONTROL_PLANE_AGENTS_LIST_PATH = "/api/control-plane/agents/list";
 export const CONTROL_PLANE_AGENT_STREAM_PATH = "/api/control-plane/agents/stream";
 export const CONTROL_PLANE_AGENT_RUNS_PATH_PREFIX = "/api/control-plane/agents/runs/";
-export const LEGACY_INTERNAL_AGENTS_LIST_PATH = "/internal/agents/list";
-export const LEGACY_INTERNAL_AGENT_STREAM_PATH = "/internal/agents/stream";
-export const LEGACY_INTERNAL_AGENT_RUNS_PATH_PREFIX = "/internal/agents/runs/";
-
-const compactJwsHeaderSchema = z.object({
-  alg: z.literal("EdDSA"),
-  typ: z.string().optional(),
-  kid: z.string().optional(),
-});
-
-export const ControlPlaneSurfaceSchema = z.enum(["studio", "channels", "a2a", "mcp"]);
-
-export const ControlPlaneAgentsListRequestSchema = z.object({
-  requestId: z.string().min(1),
-  projectId: z.string().min(1),
-  surface: ControlPlaneSurfaceSchema,
-});
-
-export const RuntimeAgentSkillSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  examples: z.array(z.string()).optional(),
-});
-
-export const RuntimeAgentSuggestionSchema = z.discriminatedUnion("type", [
-  z.object({
-    id: z.string().min(1),
-    type: z.literal("prompt"),
-    title: z.string().min(1),
-    description: z.string().optional(),
-    prompt: z.string().min(1),
-  }),
-  z.object({
-    id: z.string().min(1),
-    type: z.literal("task"),
-    title: z.string().min(1),
-    description: z.string().optional(),
-    task: z.string().min(1),
-    prompt: z.string().min(1).optional(),
-  }),
-]);
-
-export const RuntimeAgentSuggestionsSchema = z.object({
-  welcomeMessage: z.string().min(1).optional(),
-  suggestions: z.array(RuntimeAgentSuggestionSchema),
-});
-
-export const RuntimeAgentSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().nullable().optional(),
-  model: z.string().nullable().optional(),
-  version: z.string().nullable().optional(),
-  skills: z.array(RuntimeAgentSkillSchema).optional(),
-  suggestions: RuntimeAgentSuggestionsSchema.optional(),
-});
-
-export const RuntimeAgentListResponseSchema = z.object({
-  agents: z.array(RuntimeAgentSchema),
-});
-
-const dispatchClaimsSchema = z.object({
-  iss: z.string(),
-  aud: z.string(),
-  sub: z.string(),
-  project_id: z.string(),
-  platform: z.string(),
-  body_sha256: z.string(),
-  iat: z.number().int(),
-  exp: z.number().int(),
-});
-
-const controlPlaneClaimsSchema = z.object({
-  iss: z.string(),
-  aud: z.string(),
-  sub: z.string(),
-  surface: ControlPlaneSurfaceSchema,
-  project_id: z.string(),
-  request_hash: z.string(),
-  iat: z.number().int(),
-  exp: z.number().int(),
-});
-
-export type ControlPlaneSurface = z.infer<typeof ControlPlaneSurfaceSchema>;
-export type ControlPlaneAgentsListRequest = z.infer<typeof ControlPlaneAgentsListRequestSchema>;
-export type RuntimeAgentSkill = z.infer<typeof RuntimeAgentSkillSchema>;
-export type RuntimeAgentSuggestion = z.infer<typeof RuntimeAgentSuggestionSchema>;
-export type RuntimeAgentSuggestions = z.infer<typeof RuntimeAgentSuggestionsSchema>;
-export type RuntimeAgent = z.infer<typeof RuntimeAgentSchema>;
-export type RuntimeAgentListResponse = z.infer<typeof RuntimeAgentListResponseSchema>;
-export type DispatchClaims = z.infer<typeof dispatchClaimsSchema>;
-export type ControlPlaneClaims = z.infer<typeof controlPlaneClaimsSchema>;
+
+const getCompactJwsHeaderSchema = defineSchema((v) =>
+  v.object({
+    alg: v.literal("EdDSA"),
+    typ: v.string().optional(),
+    kid: v.string().optional(),
+  })
+);
+const compactJwsHeaderSchema = getCompactJwsHeaderSchema();
+
+export const getControlPlaneSurfaceSchema = defineSchema((v) =>
+  v.enum(["studio", "channels", "a2a", "mcp"])
+);
+export const ControlPlaneSurfaceSchema = getControlPlaneSurfaceSchema();
+
+export const getControlPlaneAgentsListRequestSchema = defineSchema((v) =>
+  v.object({
+    requestId: v.string().min(1),
+    projectId: v.string().min(1),
+    surface: getControlPlaneSurfaceSchema(),
+  })
+);
+export const ControlPlaneAgentsListRequestSchema = getControlPlaneAgentsListRequestSchema();
+
+export const getRuntimeAgentSkillSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().min(1),
+    name: v.string().min(1),
+    description: v.string().optional(),
+    tags: v.array(v.string()).optional(),
+    examples: v.array(v.string()).optional(),
+  })
+);
+export const RuntimeAgentSkillSchema = getRuntimeAgentSkillSchema();
+
+export const getRuntimeAgentSuggestionSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      id: v.string().min(1),
+      type: v.literal("prompt"),
+      title: v.string().min(1),
+      description: v.string().optional(),
+      prompt: v.string().min(1),
+    }),
+    v.object({
+      id: v.string().min(1),
+      type: v.literal("task"),
+      title: v.string().min(1),
+      description: v.string().optional(),
+      task: v.string().min(1),
+      prompt: v.string().min(1).optional(),
+    }),
+  ])
+);
+export const RuntimeAgentSuggestionSchema = getRuntimeAgentSuggestionSchema();
+
+export const getRuntimeAgentSuggestionsSchema = defineSchema((v) =>
+  v.object({
+    welcomeMessage: v.string().min(1).optional(),
+    suggestions: v.array(getRuntimeAgentSuggestionSchema()),
+  })
+);
+export const RuntimeAgentSuggestionsSchema = getRuntimeAgentSuggestionsSchema();
+
+export const getRuntimeAgentSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().min(1),
+    name: v.string().min(1),
+    description: v.string().nullable().optional(),
+    model: v.string().nullable().optional(),
+    version: v.string().nullable().optional(),
+    skills: v.array(getRuntimeAgentSkillSchema()).optional(),
+    suggestions: getRuntimeAgentSuggestionsSchema().optional(),
+  })
+);
+export const RuntimeAgentSchema = getRuntimeAgentSchema();
+
+export const getRuntimeAgentListResponseSchema = defineSchema((v) =>
+  v.object({
+    agents: v.array(getRuntimeAgentSchema()),
+  })
+);
+export const RuntimeAgentListResponseSchema = getRuntimeAgentListResponseSchema();
+
+const getDispatchClaimsSchema = defineSchema((v) =>
+  v.object({
+    iss: v.string(),
+    aud: v.string(),
+    sub: v.string(),
+    project_id: v.string(),
+    platform: v.string(),
+    body_sha256: v.string(),
+    iat: v.number().int(),
+    exp: v.number().int(),
+  })
+);
+const dispatchClaimsSchema = getDispatchClaimsSchema();
+
+const getControlPlaneClaimsSchema = defineSchema((v) =>
+  v.object({
+    iss: v.string(),
+    aud: v.string(),
+    sub: v.string(),
+    surface: getControlPlaneSurfaceSchema(),
+    project_id: v.string(),
+    request_hash: v.string(),
+    iat: v.number().int(),
+    exp: v.number().int(),
+  })
+);
+const controlPlaneClaimsSchema = getControlPlaneClaimsSchema();
+
+export type ControlPlaneSurface = InferSchema<ReturnType<typeof getControlPlaneSurfaceSchema>>;
+export type ControlPlaneAgentsListRequest = InferSchema<
+  ReturnType<typeof getControlPlaneAgentsListRequestSchema>
+>;
+export type RuntimeAgentSkill = InferSchema<ReturnType<typeof getRuntimeAgentSkillSchema>>;
+export type RuntimeAgentSuggestion = InferSchema<
+  ReturnType<typeof getRuntimeAgentSuggestionSchema>
+>;
+export type RuntimeAgentSuggestions = InferSchema<
+  ReturnType<typeof getRuntimeAgentSuggestionsSchema>
+>;
+export type RuntimeAgent = InferSchema<ReturnType<typeof getRuntimeAgentSchema>>;
+export type RuntimeAgentListResponse = InferSchema<
+  ReturnType<typeof getRuntimeAgentListResponseSchema>
+>;
+export type DispatchClaims = InferSchema<ReturnType<typeof getDispatchClaimsSchema>>;
+export type ControlPlaneClaims = InferSchema<ReturnType<typeof getControlPlaneClaimsSchema>>;
 
 export interface RuntimeAgentDiscoveryDeps {
   ensureProjectDiscovery: (ctx: HandlerContext) => Promise<void>;
@@ -168,7 +204,7 @@ async function verifySignedRequestJws<TClaims extends SignedRequestClaims>(
   body: string,
   options: {
     audience: string;
-    claimsSchema: z.ZodType<TClaims>;
+    claimsSchema: Schema<TClaims>;
     expectedProjectId?: string;
     expectedSubject?: string;
     hashClaimKey: keyof TClaims & string;