veryfront 0.1.501 → 0.1.503

package/src/src/tool/sleep.ts

@@ -1,6 +1,8 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { z } from "zod";
+import type { InferSchema, Schema } from "../extensions/schema/index.js";
+import { resolveSchemaValidator } from "../schemas/define.js";
 import { tool } from "./factory.js";
+import type { Tool } from "./types.js";
 
 export const DEFAULT_SLEEP_TOOL_MAX_SECONDS = 60;
 
@@ -16,15 +18,27 @@ const defaultSleepToolWait: SleepToolWait = (milliseconds) =>
     dntShim.setTimeout(resolve, milliseconds);
   });
 
-function createSleepToolInputSchema(maxSeconds: number) {
-  return z.object({
-    seconds: z.number().min(1).max(maxSeconds).describe(
+interface SleepToolInputShape {
+  seconds: number;
+}
+
+/**
+ * Build the sleep-tool input schema parameterised by `maxSeconds`.
+ *
+ * Resolves the `SchemaValidator` through the shared fallback path (rather than going
+ * through `defineSchema`) because `defineSchema` produces a memoized
+ * zero-arg getter — incompatible with per-instance parametric schemas.
+ */
+function createSleepToolInputSchema(maxSeconds: number): Schema<SleepToolInputShape> {
+  const v = resolveSchemaValidator();
+  return v.object({
+    seconds: v.number().min(1).max(maxSeconds).describe(
       `Number of seconds to wait (1-${maxSeconds})`,
     ),
-  });
+  }) as unknown as Schema<SleepToolInputShape>;
 }
 
-export type SleepToolInput = z.infer<ReturnType<typeof createSleepToolInputSchema>>;
+export type SleepToolInput = InferSchema<ReturnType<typeof createSleepToolInputSchema>>;
 
 export type SleepToolOutput = {
   sleptFor: number;
@@ -51,4 +65,38 @@ export function createSleepTool(options: CreateSleepToolOptions = {}) {
   });
 }
 
-export const sleepTool = createSleepTool();
+/**
+ * Lazily-built default sleep tool.
+ *
+ * Construction is deferred to first access so importers don't pay the
+ * SchemaValidator-resolution cost (and don't fail under tests that haven't
+ * registered the adapter) just by loading this module.
+ */
+let cachedDefaultSleepTool: Tool<SleepToolInput, SleepToolOutput> | undefined;
+function getDefaultSleepTool(): Tool<SleepToolInput, SleepToolOutput> {
+  cachedDefaultSleepTool ??= createSleepTool();
+  return cachedDefaultSleepTool;
+}
+
+/**
+ * Default sleep tool (max 60 s) exposed as a property accessor so the
+ * underlying `tool({...})` materialization is deferred until first use.
+ * Preserves the existing `sleepTool.execute(...)` call shape.
+ */
+export const sleepTool: Tool<SleepToolInput, SleepToolOutput> = new Proxy(
+  {} as Tool<SleepToolInput, SleepToolOutput>,
+  {
+    get(_target, prop, receiver) {
+      return Reflect.get(getDefaultSleepTool(), prop, receiver);
+    },
+    has(_target, prop) {
+      return prop in getDefaultSleepTool();
+    },
+    ownKeys() {
+      return Reflect.ownKeys(getDefaultSleepTool());
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      return Object.getOwnPropertyDescriptor(getDefaultSleepTool(), prop);
+    },
+  },
+);

package/src/src/tool/types.ts

@@ -2,8 +2,7 @@
  * Tool type definitions
  */
 
-import type { z } from "zod";
-import type { JsonSchema } from "./schema/json-schema.js";
+import type { JsonSchema, Schema } from "../extensions/schema/index.js";
 import type { BlobStorage } from "../workflow/blob/types.js";
 // type-only import — no runtime circular dependency (tool ↔ mcp)
 import type { ToolAnnotations } from "../mcp/types.js";
@@ -19,12 +18,17 @@ export interface ToolConfig<TInput = any, TOutput = any> {
   /** Tool description for the AI model */
   description: string;
 
-  /** Input schema (Zod schema) */
-  inputSchema: z.ZodSchema<TInput>;
+  /**
+   * Input schema produced via `defineSchema((v) => …)` (or any
+   * `SchemaValidator`-backed builder). Validates input before `execute` runs
+   * and seeds the JSON Schema exposed to AI providers.
+   */
+  inputSchema: Schema<TInput>;
 
   /**
-   * Allow unknown/non-Zod schemas to fall back to a permissive JSON schema.
-   * Use only for truly dynamic tools; prefer z.unknown() or z.any() instead.
+   * Allow unknown/non-contract schemas to fall back to a permissive JSON
+   * schema. Use only for truly dynamic tools; prefer `v.unknown()` or
+   * `v.any()` from the SchemaValidator DSL instead.
    */
   allowUnknownSchema?: boolean;
 
@@ -117,8 +121,8 @@ export interface Tool<TInput = any, TOutput = any> {
   /** Tool description */
   description: string;
 
-  /** Input schema (Zod) */
-  inputSchema: z.ZodSchema<TInput>;
+  /** Input schema produced by `defineSchema` (or any SchemaValidator-backed builder). */
+  inputSchema: Schema<TInput>;
 
   /**
    * Pre-converted JSON Schema (for OpenAI/provider compatibility)

package/src/src/transforms/npm-import-rewrites.ts

@@ -18,9 +18,7 @@ import { join } from "../platform/compat/path/index.js";
  * Bare specifiers that should be rewritten to their pinned npm: versions.
  * Each must have a corresponding entry in deno.json's import map.
  */
-const REWRITABLE_PACKAGES = [
-  "zod",
-] as const;
+const REWRITABLE_PACKAGES = [] as const;
 
 interface RewriteRule {
   pattern: RegExp;

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.501";
+export const VERSION = "0.1.503";

package/src/src/workflow/blob/veryfront-cloud-storage.ts

@@ -1,5 +1,6 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 import { agentLogger as logger } from "../../utils/index.js";
 import { API_ERROR, CONFIG_INVALID, INVALID_ARGUMENT } from "../../errors/index.js";
 
@@ -15,44 +16,57 @@ const DEFAULT_PREFIX = ".veryfront/blobs/";
 const DATA_SUFFIX = ".blob";
 const META_SUFFIX = ".meta.json";
 
-const UploadCreateResponseSchema = z.object({
-  file_upload_url: z.string().url(),
-  file_path: z.string(),
-  upload_id: z.string(),
-  required_headers: z.record(z.string(), z.string()),
-});
-
-const UploadMetadataResponseSchema = z.object({
-  id: z.string(),
-  path: z.string(),
-  file_name: z.string(),
-  content_type: z.string().nullable(),
-  size: z.number(),
-  url: z.string().nullable(),
-  status: z.enum(["pending", "active", "failed"]),
-  visibility: z.enum(["project", "public", "private"]),
-  created_at: z.string(),
-  updated_at: z.string(),
-  deleted_at: z.string().nullable(),
-});
-
-const UploadSignedUrlResponseSchema = z.object({
-  signed_url: z.string().url(),
-  expires_at: z.string(),
-});
-
-const BlobMetadataSchema = z.object({
-  version: z.literal(1),
-  id: z.string(),
-  size: z.number().nonnegative(),
-  mimeType: z.string(),
-  createdAt: z.string(),
-  expiresAt: z.string().optional(),
-  metadata: z.record(z.string(), z.string()).optional(),
-});
-
-type UploadMetadataResponse = z.infer<typeof UploadMetadataResponseSchema>;
-type BlobMetadata = z.infer<typeof BlobMetadataSchema>;
+const getUploadCreateResponseSchema = defineSchema((v) =>
+  v.object({
+    file_upload_url: v.string().url(),
+    file_path: v.string(),
+    upload_id: v.string(),
+    required_headers: v.record(v.string(), v.string()),
+  })
+);
+
+const getUploadMetadataResponseSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    path: v.string(),
+    file_name: v.string(),
+    content_type: v.string().nullable(),
+    size: v.number(),
+    url: v.string().nullable(),
+    status: v.enum(["pending", "active", "failed"]),
+    visibility: v.enum(["project", "public", "private"]),
+    created_at: v.string(),
+    updated_at: v.string(),
+    deleted_at: v.string().nullable(),
+  })
+);
+
+const getUploadSignedUrlResponseSchema = defineSchema((v) =>
+  v.object({
+    signed_url: v.string().url(),
+    expires_at: v.string(),
+  })
+);
+
+const getBlobMetadataSchema = defineSchema((v) =>
+  v.object({
+    version: v.literal(1),
+    id: v.string(),
+    size: v.number().nonnegative(),
+    mimeType: v.string(),
+    createdAt: v.string(),
+    expiresAt: v.string().optional(),
+    metadata: v.record(v.string(), v.string()).optional(),
+  })
+);
+
+const UploadCreateResponseSchema = getUploadCreateResponseSchema();
+const UploadMetadataResponseSchema = getUploadMetadataResponseSchema();
+const UploadSignedUrlResponseSchema = getUploadSignedUrlResponseSchema();
+const BlobMetadataSchema = getBlobMetadataSchema();
+
+type UploadMetadataResponse = InferSchema<ReturnType<typeof getUploadMetadataResponseSchema>>;
+type BlobMetadata = InferSchema<ReturnType<typeof getBlobMetadataSchema>>;
 
 export interface VeryfrontCloudBlobStorageConfig {
   /** Veryfront API base URL. Defaults to the current Veryfront Cloud bootstrap. */

package/src/src/workflow/claude-code/tool.ts

@@ -4,47 +4,38 @@
  * Pre-configured tools for using the Claude Agent SDK in workflow steps.
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema, Schema } from "../../extensions/schema/index.js";
 import type { Tool } from "../../tool/index.js";
 import { executeAgent } from "./agent.js";
 import type { ClaudeCodeMode, ClaudeCodeResult } from "./types.js";
 
-/**
- * Input schema for claude-code tool
- */
-const claudeCodeInputSchema = z.object({
-  /** Task description for the agent */
-  task: z.string().describe("The task for the Claude Code agent to perform"),
-
-  /** Tool mode */
-  mode: z
-    .enum(["code", "analysis", "custom"])
-    .optional()
-    .default("code")
-    .describe("Tool mode: code (read-write), analysis (read-only), custom (user-specified)"),
-
-  /** Maximum turns */
-  maxTurns: z
-    .number()
-    .max(100)
-    .optional()
-    .default(20)
-    .describe("Maximum agentic loop turns"),
-
-  /** Files to focus on */
-  files: z
-    .array(z.string())
-    .optional()
-    .describe("Specific files to focus on"),
-
-  /** Additional context */
-  context: z
-    .record(z.unknown())
-    .optional()
-    .describe("Additional context to include in the prompt"),
-});
-
-type ClaudeCodeInput = z.infer<typeof claudeCodeInputSchema>;
+const getClaudeCodeInputSchema = defineSchema((v) =>
+  v.object({
+    task: v.string().describe("The task for the Claude Code agent to perform"),
+    mode: v
+      .enum(["code", "analysis", "custom"])
+      .optional()
+      .default("code")
+      .describe("Tool mode: code (read-write), analysis (read-only), custom (user-specified)"),
+    maxTurns: v
+      .number()
+      .max(100)
+      .optional()
+      .default(20)
+      .describe("Maximum agentic loop turns"),
+    files: v
+      .array(v.string())
+      .optional()
+      .describe("Specific files to focus on"),
+    context: v
+      .record(v.string(), v.unknown())
+      .optional()
+      .describe("Additional context to include in the prompt"),
+  })
+);
+
+type ClaudeCodeInput = InferSchema<ReturnType<typeof getClaudeCodeInputSchema>>;
 
 /**
  * Build the full prompt from input
@@ -90,7 +81,7 @@ export const claudeCodeTool: Tool<ClaudeCodeInput, ClaudeCodeResult> = {
   type: "function",
   description: "Run a Claude Code agent for complex coding tasks. " +
     "Supports file editing, bash commands, and iterative problem-solving.",
-  inputSchema: claudeCodeInputSchema as unknown as z.ZodSchema<ClaudeCodeInput>,
+  inputSchema: getClaudeCodeInputSchema() as unknown as Schema<ClaudeCodeInput>,
   inputSchemaJson: {
     type: "object",
     properties: {

package/src/src/workflow/dsl/workflow.ts

@@ -4,7 +4,7 @@
  * Main factory function for creating durable workflows
  **************************/
 
-import type { z } from "zod";
+import type { Schema } from "../../extensions/schema/index.js";
 import type {
   RetryConfig,
   StepBuilderContext,
@@ -22,8 +22,8 @@ export interface WorkflowOptions<TInput = unknown, TOutput = unknown> {
   id: string;
   description?: string;
   version?: string;
-  inputSchema?: z.ZodSchema<TInput>;
-  outputSchema?: z.ZodSchema<TOutput>;
+  inputSchema?: Schema<TInput>;
+  outputSchema?: Schema<TOutput>;
   retry?: RetryConfig;
   timeout?: string | number;
   introspect?: boolean;

package/src/src/workflow/schemas/index.ts

@@ -12,6 +12,23 @@ export {
   type BackoffStrategy,
   BackoffStrategySchema,
   CheckpointSchema,
+  getApprovalDecisionSchema,
+  getApprovalStatusSchema,
+  getBackoffStrategySchema,
+  getCheckpointSchema,
+  getLoopExecutionContextSchema,
+  getNodeStateSchema,
+  getNodeStatusSchema,
+  getParallelStrategySchema,
+  getPendingApprovalSchema,
+  getRetryConfigSchema,
+  getRunFilterSchema,
+  getWaitTypeSchema,
+  getWorkflowContextSchema,
+  getWorkflowErrorSchema,
+  getWorkflowJobSchema,
+  getWorkflowNodeTypeSchema,
+  getWorkflowStatusSchema,
   type LoopExecutionContext,
   LoopExecutionContextSchema,
   type NodeState,