veryfront 0.1.502 → 0.1.504

package/src/src/integrations/schema.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 
 const integrationNames = [
   "gmail",
@@ -53,123 +54,151 @@ const integrationNames = [
   "aws",
 ] as const;
 
-export const IntegrationNameSchema = z.enum(integrationNames);
+export const getIntegrationNameSchema = defineSchema((v) => v.enum(integrationNames));
+export const IntegrationNameSchema = getIntegrationNameSchema();
 
-export const EnvVarSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  required: z.boolean(),
-  sensitive: z.boolean().optional(),
-  placeholder: z.string().optional(),
-  docsUrl: z.string().optional(),
-  default: z.string().optional(),
-});
+export const getEnvVarSchema = defineSchema((v) =>
+  v.object({
+    name: v.string(),
+    description: v.string(),
+    required: v.boolean(),
+    sensitive: v.boolean().optional(),
+    placeholder: v.string().optional(),
+    docsUrl: v.string().optional(),
+    default: v.string().optional(),
+  })
+);
+export const EnvVarSchema = getEnvVarSchema();
 
-export const OAuthFieldSchema = z.object({
-  name: z.string(),
-  label: z.string(),
-  type: z.string(),
-  required: z.boolean(),
-  envVar: z.string(),
-  default: z.string().optional(),
-});
+export const getOAuthFieldSchema = defineSchema((v) =>
+  v.object({
+    name: v.string(),
+    label: v.string(),
+    type: v.string(),
+    required: v.boolean(),
+    envVar: v.string(),
+    default: v.string().optional(),
+  })
+);
+export const OAuthFieldSchema = getOAuthFieldSchema();
 
-export const OAuthConfigSchema = z.object({
-  type: z.enum(["oauth2", "oauth1", "api-key"]),
-  provider: z.string().optional(),
-  authorizationUrl: z.string().optional(),
-  tokenUrl: z.string().optional(),
-  scopes: z.array(z.string()).optional(),
-  callbackPath: z.string().optional(),
-  tokenAuthMethod: z.string().optional(),
-  pkce: z.boolean().optional(),
-  usePKCE: z.boolean().optional(),
-  supportsRefreshToken: z.boolean().optional(),
-  requiredApis: z
-    .array(z.object({ name: z.string(), enableUrl: z.string() }))
-    .optional(),
-  additionalParams: z.record(z.string(), z.string()).optional(),
-  additionalAuthParams: z.record(z.string(), z.string()).optional(),
-  fields: z.array(OAuthFieldSchema).optional(),
-  envVars: z
-    .record(z.string(), z.object({ description: z.string(), required: z.boolean() }))
-    .optional(),
-  keyName: z.string().optional(),
-  headerName: z.string().optional(),
-  headerPrefix: z.string().optional(),
-  tokenName: z.string().optional(),
-  docsUrl: z.string().optional(),
-});
+export const getOAuthConfigSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(["oauth2", "oauth1", "api-key"]),
+    provider: v.string().optional(),
+    authorizationUrl: v.string().optional(),
+    tokenUrl: v.string().optional(),
+    scopes: v.array(v.string()).optional(),
+    callbackPath: v.string().optional(),
+    tokenAuthMethod: v.string().optional(),
+    pkce: v.boolean().optional(),
+    usePKCE: v.boolean().optional(),
+    supportsRefreshToken: v.boolean().optional(),
+    requiredApis: v
+      .array(v.object({ name: v.string(), enableUrl: v.string() }))
+      .optional(),
+    additionalParams: v.record(v.string(), v.string()).optional(),
+    additionalAuthParams: v.record(v.string(), v.string()).optional(),
+    fields: v.array(getOAuthFieldSchema()).optional(),
+    envVars: v
+      .record(v.string(), v.object({ description: v.string(), required: v.boolean() }))
+      .optional(),
+    keyName: v.string().optional(),
+    headerName: v.string().optional(),
+    headerPrefix: v.string().optional(),
+    tokenName: v.string().optional(),
+    docsUrl: v.string().optional(),
+  })
+);
+export const OAuthConfigSchema = getOAuthConfigSchema();
 
-export const IntegrationEndpointParamSchema = z.object({
-  type: z.enum(["string", "number", "boolean", "string[]", "object", "array"]),
-  in: z.enum(["path", "query", "header", "body"]),
-  description: z.string(),
-  required: z.boolean().optional(),
-  default: z.unknown().optional(),
-});
+export const getIntegrationEndpointParamSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(["string", "number", "boolean", "string[]", "object", "array"]),
+    in: v.enum(["path", "query", "header", "body"]),
+    description: v.string(),
+    required: v.boolean().optional(),
+    default: v.unknown().optional(),
+  })
+);
+export const IntegrationEndpointParamSchema = getIntegrationEndpointParamSchema();
 
-export const IntegrationEndpointBodyFieldSchema = z.object({
-  type: z.enum(["string", "number", "boolean", "object", "array"]),
-  description: z.string(),
-  required: z.boolean().optional(),
-  default: z.unknown().optional(),
-});
+export const getIntegrationEndpointBodyFieldSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(["string", "number", "boolean", "object", "array"]),
+    description: v.string(),
+    required: v.boolean().optional(),
+    default: v.unknown().optional(),
+  })
+);
+export const IntegrationEndpointBodyFieldSchema = getIntegrationEndpointBodyFieldSchema();
 
-export const IntegrationEndpointSchema = z.object({
-  type: z.enum(["rest", "graphql"]).optional(),
-  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
-  url: z.string(),
-  query: z.string().optional(),
-  params: z.record(z.string(), IntegrationEndpointParamSchema).optional(),
-  body: z.record(z.string(), IntegrationEndpointBodyFieldSchema).optional(),
-  contentType: z.string().optional(),
-  response: z.object({ transform: z.string().optional() }).optional(),
-});
+export const getIntegrationEndpointSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(["rest", "graphql"]).optional(),
+    method: v.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+    url: v.string(),
+    query: v.string().optional(),
+    params: v.record(v.string(), getIntegrationEndpointParamSchema()).optional(),
+    body: v.record(v.string(), getIntegrationEndpointBodyFieldSchema()).optional(),
+    contentType: v.string().optional(),
+    response: v.object({ transform: v.string().optional() }).optional(),
+  })
+);
+export const IntegrationEndpointSchema = getIntegrationEndpointSchema();
 
-export const IntegrationToolSchema = z.object({
-  id: z.string().optional(),
-  name: z.string(),
-  description: z.string(),
-  requiresWrite: z.boolean().optional(),
-  file: z.string().optional(),
-  endpoint: IntegrationEndpointSchema.optional(),
-});
+export const getIntegrationToolSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().optional(),
+    name: v.string(),
+    description: v.string(),
+    requiresWrite: v.boolean().optional(),
+    file: v.string().optional(),
+    endpoint: getIntegrationEndpointSchema().optional(),
+  })
+);
+export const IntegrationToolSchema = getIntegrationToolSchema();
 
-export const IntegrationPromptSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  prompt: z.string(),
-  category: z.string().optional(),
-  icon: z.string().optional(),
-});
+export const getIntegrationPromptSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    title: v.string(),
+    prompt: v.string(),
+    category: v.string().optional(),
+    icon: v.string().optional(),
+  })
+);
+export const IntegrationPromptSchema = getIntegrationPromptSchema();
 
-export const IntegrationConfigSchema = z.object({
-  name: IntegrationNameSchema,
-  displayName: z.string(),
-  icon: z.string().optional(),
-  description: z.string(),
-  auth: OAuthConfigSchema,
-  envVars: z.array(EnvVarSchema).optional(),
-  /**
-   * Optional map of npm packages to semver ranges. When this integration is
-   * selected during `veryfront init`, these deps are merged into the
-   * generated project's `package.json#dependencies`. Use this for templates
-   * that import packages beyond the init scaffold's defaults (react,
-   * react-dom, veryfront, zod).
-   */
-  npmDependencies: z.record(z.string(), z.string()).optional(),
-  tools: z.array(IntegrationToolSchema),
-  prompts: z.array(IntegrationPromptSchema).optional(),
-  suggestedWith: z.array(z.string()).optional(),
-  dependencies: z.record(z.string(), z.string()).optional(),
-  category: z.string().optional(),
-});
+export const getIntegrationConfigSchema = defineSchema((v) =>
+  v.object({
+    name: getIntegrationNameSchema(),
+    displayName: v.string(),
+    icon: v.string().optional(),
+    description: v.string(),
+    auth: getOAuthConfigSchema(),
+    envVars: v.array(getEnvVarSchema()).optional(),
+    /**
+     * Optional map of npm packages to semver ranges. When this integration is
+     * selected during `veryfront init`, these deps are merged into the
+     * generated project's `package.json#dependencies`. Use this for templates
+     * that import packages beyond the init scaffold's defaults (react,
+     * react-dom, veryfront, zod).
+     */
+    npmDependencies: v.record(v.string(), v.string()).optional(),
+    tools: v.array(getIntegrationToolSchema()),
+    prompts: v.array(getIntegrationPromptSchema()).optional(),
+    suggestedWith: v.array(v.string()).optional(),
+    dependencies: v.record(v.string(), v.string()).optional(),
+    category: v.string().optional(),
+  })
+);
+export const IntegrationConfigSchema = getIntegrationConfigSchema();
 
-export type IntegrationName = z.infer<typeof IntegrationNameSchema>;
-export type EnvVarConfig = z.infer<typeof EnvVarSchema>;
-export type OAuthField = z.infer<typeof OAuthFieldSchema>;
-export type OAuthConfig = z.infer<typeof OAuthConfigSchema>;
-export type IntegrationToolMeta = z.infer<typeof IntegrationToolSchema>;
-export type IntegrationPrompt = z.infer<typeof IntegrationPromptSchema>;
-export type IntegrationConfig = z.infer<typeof IntegrationConfigSchema>;
+export type IntegrationName = InferSchema<ReturnType<typeof getIntegrationNameSchema>>;
+export type EnvVarConfig = InferSchema<ReturnType<typeof getEnvVarSchema>>;
+export type OAuthField = InferSchema<ReturnType<typeof getOAuthFieldSchema>>;
+export type OAuthConfig = InferSchema<ReturnType<typeof getOAuthConfigSchema>>;
+export type IntegrationToolMeta = InferSchema<ReturnType<typeof getIntegrationToolSchema>>;
+export type IntegrationPrompt = InferSchema<ReturnType<typeof getIntegrationPromptSchema>>;
+export type IntegrationConfig = InferSchema<ReturnType<typeof getIntegrationConfigSchema>>;

package/src/src/internal-agents/ag-ui-sse.ts

@@ -10,7 +10,8 @@ import {
   finalizeAgUiBrowserEvents,
   mapRuntimeStreamEventToAgUiBrowserEvents,
 } from "../agent/ag-ui-browser-encoder.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { Schema } from "../extensions/schema/index.js";
 
 const encoder = new TextEncoder();
 
@@ -23,92 +24,93 @@ export function createStreamTransformState(): StreamTransformState {
   return createAgUiBrowserEncoderState();
 }
 
-const agUiEventPayloadSchemas = {
-  RunStarted: z.object({
-    runId: z.string().min(1),
-    threadId: z.string().min(1),
-    agentId: z.string().min(1),
-  }),
-  StateSnapshot: z.object({
-    snapshot: z.record(z.string(), z.unknown()),
-  }),
-  MessagesSnapshot: z.object({
-    messages: z.array(z.object({
-      id: z.string().min(1),
-      role: z.enum(["user", "assistant", "system", "tool"]),
-      parts: z.array(z.record(z.string(), z.unknown())),
-      metadata: z.record(z.string(), z.unknown()).optional(),
-      createdAt: z.string().optional(),
-    })),
-  }),
-  TextMessageStart: z.object({
-    messageId: z.string().min(1),
-    role: z.literal("assistant"),
-  }),
-  TextMessageContent: z.object({
-    messageId: z.string().min(1),
-    delta: z.string(),
-  }),
-  TextMessageEnd: z.object({
-    messageId: z.string().min(1),
-  }),
-  ReasoningMessageStart: z.object({
-    messageId: z.string().min(1),
-    role: z.literal("reasoning"),
-  }),
-  ReasoningMessageContent: z.object({
-    messageId: z.string().min(1),
-    delta: z.string(),
-  }),
-  ReasoningMessageEnd: z.object({
-    messageId: z.string().min(1),
-  }),
-  StepStarted: z.object({
-    stepName: z.string().min(1),
-  }),
-  StepFinished: z.object({
-    stepName: z.string().min(1),
-  }),
-  ToolCallStart: z.object({
-    toolCallId: z.string().min(1),
-    toolCallName: z.string().min(1),
-  }),
-  ToolCallArgs: z.object({
-    toolCallId: z.string().min(1),
-    delta: z.string(),
-  }),
-  ToolCallEnd: z.object({
-    toolCallId: z.string().min(1),
-  }),
-  ToolCallResult: z.object({
-    toolCallId: z.string().min(1),
-    result: z.unknown(),
-    isError: z.boolean().optional(),
-  }),
-  Custom: z.object({
-    name: z.string().min(1),
-    value: z.unknown(),
-  }),
-  RunError: z.object({
-    code: z.string().min(1).optional(),
-    message: z.string().min(1),
-  }),
-  RunFinished: z.object({
-    metadata: z.object({
-      provider: z.string().optional(),
-      model: z.string().optional(),
-      inputTokens: z.number().int().nonnegative().optional(),
-      outputTokens: z.number().int().nonnegative().optional(),
-      totalTokens: z.number().int().nonnegative().optional(),
-      finishReason: z.string().optional(),
+const getAgUiEventPayloadSchemas = defineSchema((v) => {
+  const schemas = {
+    RunStarted: v.object({
+      runId: v.string().min(1),
+      threadId: v.string().min(1),
+      agentId: v.string().min(1),
     }),
-  }),
-} as const satisfies Record<string, z.ZodType<Record<string, unknown>>>;
+    StateSnapshot: v.object({ snapshot: v.record(v.string(), v.unknown()) }),
+    MessagesSnapshot: v.object({
+      messages: v.array(v.object({
+        id: v.string().min(1),
+        role: v.enum(["user", "assistant", "system", "tool"]),
+        parts: v.array(v.record(v.string(), v.unknown())),
+        metadata: v.record(v.string(), v.unknown()).optional(),
+        createdAt: v.string().optional(),
+      })),
+    }),
+    TextMessageStart: v.object({ messageId: v.string().min(1), role: v.literal("assistant") }),
+    TextMessageContent: v.object({ messageId: v.string().min(1), delta: v.string() }),
+    TextMessageEnd: v.object({ messageId: v.string().min(1) }),
+    ReasoningMessageStart: v.object({ messageId: v.string().min(1), role: v.literal("reasoning") }),
+    ReasoningMessageContent: v.object({ messageId: v.string().min(1), delta: v.string() }),
+    ReasoningMessageEnd: v.object({ messageId: v.string().min(1) }),
+    StepStarted: v.object({ stepName: v.string().min(1) }),
+    StepFinished: v.object({ stepName: v.string().min(1) }),
+    ToolCallStart: v.object({ toolCallId: v.string().min(1), toolCallName: v.string().min(1) }),
+    ToolCallArgs: v.object({ toolCallId: v.string().min(1), delta: v.string() }),
+    ToolCallEnd: v.object({ toolCallId: v.string().min(1) }),
+    ToolCallResult: v.object({
+      toolCallId: v.string().min(1),
+      result: v.unknown(),
+      isError: v.boolean().optional(),
+    }),
+    Custom: v.object({ name: v.string().min(1), value: v.unknown() }),
+    RunError: v.object({ code: v.string().min(1).optional(), message: v.string().min(1) }),
+    RunFinished: v.object({
+      metadata: v.object({
+        provider: v.string().optional(),
+        model: v.string().optional(),
+        inputTokens: v.number().int().nonnegative().optional(),
+        outputTokens: v.number().int().nonnegative().optional(),
+        totalTokens: v.number().int().nonnegative().optional(),
+        finishReason: v.string().optional(),
+      }),
+    }),
+  };
+  // Return a record schema that validates to any - we only use this for per-key lookups
+  return schemas as unknown as Schema<Record<string, unknown>>;
+});
+
+// Eagerly resolve the schemas map so lookup works at runtime
+let _agUiEventPayloadSchemas: Record<string, Schema<Record<string, unknown>>> | null = null;
+
+function resolveAgUiEventPayloadSchemas(): Record<string, Schema<Record<string, unknown>>> {
+  if (!_agUiEventPayloadSchemas) {
+    // The defineSchema factory above returns the schemas record (cast); unwrap it.
+    _agUiEventPayloadSchemas = getAgUiEventPayloadSchemas() as unknown as Record<
+      string,
+      Schema<Record<string, unknown>>
+    >;
+  }
+  return _agUiEventPayloadSchemas;
+}
 
-type AgUiEventName = keyof typeof agUiEventPayloadSchemas;
+type AgUiEventName =
+  | "RunStarted"
+  | "StateSnapshot"
+  | "MessagesSnapshot"
+  | "TextMessageStart"
+  | "TextMessageContent"
+  | "TextMessageEnd"
+  | "ReasoningMessageStart"
+  | "ReasoningMessageContent"
+  | "ReasoningMessageEnd"
+  | "StepStarted"
+  | "StepFinished"
+  | "ToolCallStart"
+  | "ToolCallArgs"
+  | "ToolCallEnd"
+  | "ToolCallResult"
+  | "Custom"
+  | "RunError"
+  | "RunFinished";
 
 export function formatAgUiEvent(event: string, payload: Record<string, unknown>): Uint8Array {
-  const schema = agUiEventPayloadSchemas[event as AgUiEventName];
+  const schemas = resolveAgUiEventPayloadSchemas();
+  const schema = schemas[event as AgUiEventName];
   const validatedPayload = schema ? schema.parse(payload) : payload;
   return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(validatedPayload)}\n\n`);
 }

package/src/src/internal-agents/run-stream.ts

@@ -7,7 +7,8 @@ import {
 import { normalizeAgUiRuntimeMessages } from "../agent/ag-ui-runtime-support.js";
 import { SKILL_TOOL_IDS } from "../skill/types.js";
 import { type Tool, toolRegistry } from "../tool/index.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { Schema } from "../extensions/schema/index.js";
 import {
   createStreamTransformState,
   finalizeRunEvents,
@@ -19,7 +20,8 @@ import { AgentRunCancelledError, type AgentRunSessionManager } from "./session-m
 import type { RuntimeRunAgentInput } from "./schema.js";
 import { serverLogger } from "../utils/index.js";
 
-const anyObjectSchema = z.record(z.string(), z.unknown());
+const getAnyObjectSchema = defineSchema((v) => v.record(v.string(), v.unknown()));
+const anyObjectSchema = getAnyObjectSchema() as Schema<Record<string, unknown>>;
 const logger = serverLogger.component("internal-agent-run-stream");
 
 type RuntimeFilteredAgent = Agent & {