veryfront 0.1.501 → 0.1.503

package/src/src/workflow/schemas/workflow.schema.ts

@@ -4,199 +4,259 @@
  * Schemas for workflow status, nodes, and execution state.
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
 /**
  * Workflow status schema
  */
-export const WorkflowStatusSchema = z.enum([
-  "pending",
-  "running",
-  "waiting",
-  "completed",
-  "failed",
-  "cancelled",
-]);
+export const getWorkflowStatusSchema = defineSchema((v) =>
+  v.enum(
+    [
+      "pending",
+      "running",
+      "waiting",
+      "completed",
+      "failed",
+      "cancelled",
+    ] as const,
+  )
+);
 
 /**
  * Node status schema
  */
-export const NodeStatusSchema = z.enum([
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "skipped",
-]);
+export const getNodeStatusSchema = defineSchema((v) =>
+  v.enum(
+    [
+      "pending",
+      "running",
+      "completed",
+      "failed",
+      "skipped",
+    ] as const,
+  )
+);
 
 /**
  * Workflow node type schema
  */
-export const WorkflowNodeTypeSchema = z.enum([
-  "step",
-  "parallel",
-  "map",
-  "branch",
-  "wait",
-  "subWorkflow",
-  "loop",
-]);
+export const getWorkflowNodeTypeSchema = defineSchema((v) =>
+  v.enum(
+    [
+      "step",
+      "parallel",
+      "map",
+      "branch",
+      "wait",
+      "subWorkflow",
+      "loop",
+    ] as const,
+  )
+);
 
 /**
  * Backoff strategy schema
  */
-export const BackoffStrategySchema = z.enum(["fixed", "linear", "exponential"]);
+export const getBackoffStrategySchema = defineSchema((v) =>
+  v.enum(["fixed", "linear", "exponential"] as const)
+);
 
 /**
  * Retry config schema
  */
-export const RetryConfigSchema = z.object({
-  maxAttempts: z.number().int().positive().optional(),
-  backoff: BackoffStrategySchema.optional(),
-  initialDelay: z.number().nonnegative().optional(),
-  maxDelay: z.number().nonnegative().optional(),
-  // retryIf is a function, can't be in schema
-});
+export const getRetryConfigSchema = defineSchema((v) =>
+  v.object({
+    maxAttempts: v.number().int().positive().optional(),
+    backoff: getBackoffStrategySchema().optional(),
+    initialDelay: v.number().nonnegative().optional(),
+    maxDelay: v.number().nonnegative().optional(),
+    // retryIf is a function, can't be in schema
+  })
+);
 
 /**
  * Loop execution context schema
  */
-export const LoopExecutionContextSchema = z.object({
-  iteration: z.number().int().nonnegative(),
-  totalIterations: z.number().int().nonnegative(),
-  previousResults: z.array(z.unknown()),
-  isFirstIteration: z.boolean(),
-  isLastAllowedIteration: z.boolean(),
-});
+export const getLoopExecutionContextSchema = defineSchema((v) =>
+  v.object({
+    iteration: v.number().int().nonnegative(),
+    totalIterations: v.number().int().nonnegative(),
+    previousResults: v.array(v.unknown()),
+    isFirstIteration: v.boolean(),
+    isLastAllowedIteration: v.boolean(),
+  })
+);
 
 /**
  * Node state schema
  */
-export const NodeStateSchema = z.object({
-  nodeId: z.string(),
-  status: NodeStatusSchema,
-  input: z.unknown().optional(),
-  output: z.unknown().optional(),
-  error: z.string().optional(),
-  attempt: z.number().int().nonnegative(),
-  startedAt: z.date().optional(),
-  completedAt: z.date().optional(),
-});
+export const getNodeStateSchema = defineSchema((v) =>
+  v.object({
+    nodeId: v.string(),
+    status: getNodeStatusSchema(),
+    input: v.unknown().optional(),
+    output: v.unknown().optional(),
+    error: v.string().optional(),
+    attempt: v.number().int().nonnegative(),
+    startedAt: v.date().optional(),
+    completedAt: v.date().optional(),
+  })
+);
 
 /**
  * Workflow context schema (allows any additional node outputs)
  */
-export const WorkflowContextSchema = z
-  .object({
-    input: z.unknown(),
-  })
-  .passthrough();
+export const getWorkflowContextSchema = defineSchema((v) =>
+  v
+    .object({
+      input: v.unknown(),
+    })
+    .passthrough()
+);
 
 /**
  * Checkpoint schema
  */
-export const CheckpointSchema = z.object({
-  id: z.string(),
-  nodeId: z.string(),
-  timestamp: z.date(),
-  context: WorkflowContextSchema,
-  nodeStates: z.record(z.string(), NodeStateSchema),
-});
+export const getCheckpointSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    nodeId: v.string(),
+    timestamp: v.date(),
+    context: getWorkflowContextSchema(),
+    nodeStates: v.record(v.string(), getNodeStateSchema()),
+  })
+);
 
 /**
  * Approval status schema
  */
-export const ApprovalStatusSchema = z.enum([
-  "pending",
-  "approved",
-  "rejected",
-  "expired",
-]);
+export const getApprovalStatusSchema = defineSchema((v) =>
+  v.enum(
+    [
+      "pending",
+      "approved",
+      "rejected",
+      "expired",
+    ] as const,
+  )
+);
 
 /**
  * Pending approval schema
  */
-export const PendingApprovalSchema = z.object({
-  id: z.string(),
-  nodeId: z.string(),
-  message: z.string(),
-  payload: z.unknown(),
-  approvers: z.array(z.string()).optional(),
-  requestedAt: z.date(),
-  expiresAt: z.date().optional(),
-  status: ApprovalStatusSchema,
-  decidedBy: z.string().optional(),
-  decidedAt: z.date().optional(),
-  comment: z.string().optional(),
-});
+export const getPendingApprovalSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    nodeId: v.string(),
+    message: v.string(),
+    payload: v.unknown(),
+    approvers: v.array(v.string()).optional(),
+    requestedAt: v.date(),
+    expiresAt: v.date().optional(),
+    status: getApprovalStatusSchema(),
+    decidedBy: v.string().optional(),
+    decidedAt: v.date().optional(),
+    comment: v.string().optional(),
+  })
+);
 
 /**
  * Workflow error schema
  */
-export const WorkflowErrorSchema = z.object({
-  message: z.string(),
-  stack: z.string().optional(),
-  nodeId: z.string().optional(),
-});
+export const getWorkflowErrorSchema = defineSchema((v) =>
+  v.object({
+    message: v.string(),
+    stack: v.string().optional(),
+    nodeId: v.string().optional(),
+  })
+);
 
 /**
  * Approval decision schema
  */
-export const ApprovalDecisionSchema = z.object({
-  approved: z.boolean(),
-  approver: z.string(),
-  comment: z.string().optional(),
-});
+export const getApprovalDecisionSchema = defineSchema((v) =>
+  v.object({
+    approved: v.boolean(),
+    approver: v.string(),
+    comment: v.string().optional(),
+  })
+);
 
 /**
  * Workflow job schema
  */
-export const WorkflowJobSchema = z.object({
-  runId: z.string(),
-  workflowId: z.string(),
-  input: z.unknown(),
-  priority: z.number().optional(),
-  createdAt: z.date(),
-});
+export const getWorkflowJobSchema = defineSchema((v) =>
+  v.object({
+    runId: v.string(),
+    workflowId: v.string(),
+    input: v.unknown(),
+    priority: v.number().optional(),
+    createdAt: v.date(),
+  })
+);
 
 /**
  * Run filter schema
  */
-export const RunFilterSchema = z.object({
-  workflowId: z.string().optional(),
-  status: z.union([WorkflowStatusSchema, z.array(WorkflowStatusSchema)]).optional(),
-  createdAfter: z.date().optional(),
-  createdBefore: z.date().optional(),
-  limit: z.number().int().positive().optional(),
-  offset: z.number().int().nonnegative().optional(),
-});
+export const getRunFilterSchema = defineSchema((v) =>
+  v.object({
+    workflowId: v.string().optional(),
+    status: v.union([getWorkflowStatusSchema(), v.array(getWorkflowStatusSchema())]).optional(),
+    createdAfter: v.date().optional(),
+    createdBefore: v.date().optional(),
+    limit: v.number().int().positive().optional(),
+    offset: v.number().int().nonnegative().optional(),
+  })
+);
 
 /**
  * Parallel strategy schema
  */
-export const ParallelStrategySchema = z.enum(["all", "race", "allSettled"]);
+export const getParallelStrategySchema = defineSchema((v) =>
+  v.enum(["all", "race", "allSettled"] as const)
+);
 
 /**
  * Wait type schema
  */
-export const WaitTypeSchema = z.enum(["approval", "event"]);
+export const getWaitTypeSchema = defineSchema((v) => v.enum(["approval", "event"] as const));
+
+// Backward-compat aliases (consumed by schemas/index.ts and other unmigrated callers)
+export const WorkflowStatusSchema = getWorkflowStatusSchema();
+export const NodeStatusSchema = getNodeStatusSchema();
+export const WorkflowNodeTypeSchema = getWorkflowNodeTypeSchema();
+export const BackoffStrategySchema = getBackoffStrategySchema();
+export const RetryConfigSchema = getRetryConfigSchema();
+export const LoopExecutionContextSchema = getLoopExecutionContextSchema();
+export const NodeStateSchema = getNodeStateSchema();
+export const WorkflowContextSchema = getWorkflowContextSchema();
+export const CheckpointSchema = getCheckpointSchema();
+export const ApprovalStatusSchema = getApprovalStatusSchema();
+export const PendingApprovalSchema = getPendingApprovalSchema();
+export const WorkflowErrorSchema = getWorkflowErrorSchema();
+export const ApprovalDecisionSchema = getApprovalDecisionSchema();
+export const WorkflowJobSchema = getWorkflowJobSchema();
+export const RunFilterSchema = getRunFilterSchema();
+export const ParallelStrategySchema = getParallelStrategySchema();
+export const WaitTypeSchema = getWaitTypeSchema();
 
 // Inferred types
-export type WorkflowStatus = z.infer<typeof WorkflowStatusSchema>;
-export type NodeStatus = z.infer<typeof NodeStatusSchema>;
-export type WorkflowNodeType = z.infer<typeof WorkflowNodeTypeSchema>;
-export type BackoffStrategy = z.infer<typeof BackoffStrategySchema>;
-export type RetryConfig = z.infer<typeof RetryConfigSchema> & {
+export type WorkflowStatus = InferSchema<ReturnType<typeof getWorkflowStatusSchema>>;
+export type NodeStatus = InferSchema<ReturnType<typeof getNodeStatusSchema>>;
+export type WorkflowNodeType = InferSchema<ReturnType<typeof getWorkflowNodeTypeSchema>>;
+export type BackoffStrategy = InferSchema<ReturnType<typeof getBackoffStrategySchema>>;
+export type RetryConfig = InferSchema<ReturnType<typeof getRetryConfigSchema>> & {
   retryIf?: (error: Error) => boolean;
 };
-export type LoopExecutionContext = z.infer<typeof LoopExecutionContextSchema>;
-export type NodeState = z.infer<typeof NodeStateSchema>;
+export type LoopExecutionContext = InferSchema<ReturnType<typeof getLoopExecutionContextSchema>>;
+export type NodeState = InferSchema<ReturnType<typeof getNodeStateSchema>>;
 // Checkpoint type is defined in ../types.ts (requires WorkflowContext interface)
-export type ApprovalStatus = z.infer<typeof ApprovalStatusSchema>;
-export type PendingApproval = z.infer<typeof PendingApprovalSchema>;
-export type WorkflowError = z.infer<typeof WorkflowErrorSchema>;
-export type ApprovalDecision = z.infer<typeof ApprovalDecisionSchema>;
-export type WorkflowJob = z.infer<typeof WorkflowJobSchema>;
-export type RunFilter = z.infer<typeof RunFilterSchema>;
-export type ParallelStrategy = z.infer<typeof ParallelStrategySchema>;
-export type WaitType = z.infer<typeof WaitTypeSchema>;
+export type ApprovalStatus = InferSchema<ReturnType<typeof getApprovalStatusSchema>>;
+export type PendingApproval = InferSchema<ReturnType<typeof getPendingApprovalSchema>>;
+export type WorkflowError = InferSchema<ReturnType<typeof getWorkflowErrorSchema>>;
+export type ApprovalDecision = InferSchema<ReturnType<typeof getApprovalDecisionSchema>>;
+export type WorkflowJob = InferSchema<ReturnType<typeof getWorkflowJobSchema>>;
+export type RunFilter = InferSchema<ReturnType<typeof getRunFilterSchema>>;
+export type ParallelStrategy = InferSchema<ReturnType<typeof getParallelStrategySchema>>;
+export type WaitType = InferSchema<ReturnType<typeof getWaitTypeSchema>>;

package/src/src/workflow/types.ts

@@ -6,7 +6,7 @@
 import * as dntShim from "../../_dnt.shims.js";
 
 
-import type { z } from "zod";
+import type { Schema } from "../extensions/schema/index.js";
 import type { Agent } from "../agent/index.js";
 import type { Tool } from "../tool/index.js";
 import type { BlobRef, BlobStorage } from "./blob/types.js";
@@ -209,8 +209,8 @@ export interface WorkflowDefinition<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/esm/src/schemas/zod-adapter.d.ts

@@ -1,25 +0,0 @@
-/**
- * Zod-backed `SchemaValidator` adapter.
- *
- * This is the default (core-provided) implementation of the
- * `SchemaValidator` contract. It thinly wraps zod so that core modules can
- * declare schemas through the extension-neutral DSL while still getting zod's
- * runtime behavior.
- *
- * The entire zod surface used by the contract is confined to this file; when
- * `@veryfront/ext-zod` takes over in Phase B this file will be deleted and
- * the `"zod"` import map entry removed.
- *
- * @module schemas/zod-adapter
- */
-import type { SchemaValidator } from "../extensions/schema/index.js";
-/** The zod-backed `SchemaValidator` singleton registered by `registerZodAdapter`. */
-export declare const zodAdapter: SchemaValidator;
-/**
- * Register the zod adapter as the default `SchemaValidator` implementation.
- *
- * Called once at core bootstrap (`src/schemas/index.ts` side-effect import).
- * Phase B will delete this function when `@veryfront/ext-zod` takes over.
- */
-export declare function registerZodAdapter(): void;
-//# sourceMappingURL=zod-adapter.d.ts.map

package/esm/src/schemas/zod-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zod-adapter.d.ts","sourceRoot":"","sources":["../../../src/src/schemas/zod-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAGV,eAAe,EAIhB,MAAM,+BAA+B,CAAC;AAoFvC,qFAAqF;AACrF,eAAO,MAAM,UAAU,EAAE,eA4DxB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/esm/src/schemas/zod-adapter.js

@@ -1,120 +0,0 @@
-/**
- * Zod-backed `SchemaValidator` adapter.
- *
- * This is the default (core-provided) implementation of the
- * `SchemaValidator` contract. It thinly wraps zod so that core modules can
- * declare schemas through the extension-neutral DSL while still getting zod's
- * runtime behavior.
- *
- * The entire zod surface used by the contract is confined to this file; when
- * `@veryfront/ext-zod` takes over in Phase B this file will be deleted and
- * the `"zod"` import map entry removed.
- *
- * @module schemas/zod-adapter
- */
-import { z } from "zod";
-import { register } from "../extensions/contracts.js";
-/** Unwrap our opaque Schema<T> back to the underlying zod schema. */
-function toZod(schema) {
-    return schema.__zod;
-}
-/** Wrap a zod schema as an opaque Schema<T> with chainables routed through zod. */
-function wrap(zs) {
-    // The wrapper fakes the full Schema<T> surface; unsupported chainables on
-    // unsuitable kinds (e.g. calling `.email()` on a number) throw at runtime
-    // just like zod would.
-    // deno-lint-ignore no-explicit-any -- safe within this adapter
-    const anyZs = zs;
-    const s = {
-        _output: undefined,
-        optional: () => wrap(zs.optional()),
-        nullable: () => wrap(zs.nullable()),
-        nullish: () => wrap(zs.nullish()),
-        default: (value) => wrap(anyZs.default(value)),
-        describe: (description) => wrap(zs.describe(description)),
-        refine: (check, message) => wrap(zs.refine(check, message)),
-        transform: (fn) => wrap(zs.transform(fn)),
-        strict: () => wrap(anyZs.strict()),
-        passthrough: () => wrap(anyZs.passthrough()),
-        partial: () => wrap(anyZs.partial()),
-        extend: (shape) => {
-            const zodShape = toZodShape(shape);
-            return wrap(anyZs.extend(zodShape));
-        },
-        merge: (other) => wrap(anyZs.merge(toZod(other))),
-        min: (value, message) => wrap(anyZs.min(value, message)),
-        max: (value, message) => wrap(anyZs.max(value, message)),
-        int: (message) => wrap(anyZs.int(message)),
-        positive: (message) => wrap(anyZs.positive(message)),
-        nonnegative: (message) => wrap(anyZs.nonnegative(message)),
-        regex: (pattern, message) => wrap(anyZs.regex(pattern, message)),
-        email: (message) => wrap(anyZs.email(message)),
-        url: (message) => wrap(anyZs.url(message)),
-        uuid: (message) => wrap(anyZs.uuid(message)),
-        datetime: (message) => wrap(anyZs.datetime(message)),
-        parse: (data) => zs.parse(data),
-        safeParse: (data) => {
-            const res = zs.safeParse(data);
-            if (res.success)
-                return { success: true, data: res.data };
-            const issues = res.error.issues.map((issue) => ({
-                path: issue.path,
-                message: issue.message,
-                code: issue.code,
-            }));
-            return { success: false, issues, error: res.error };
-        },
-    };
-    // Attach the underlying zod schema for adapter round-trips without
-    // widening the public Schema<T> surface.
-    s.__zod = zs;
-    return s;
-}
-function toZodShape(shape) {
-    const out = {};
-    for (const [key, value] of Object.entries(shape)) {
-        out[key] = toZod(value);
-    }
-    return out;
-}
-const coerce = {
-    string: () => wrap(z.coerce.string()),
-    number: () => wrap(z.coerce.number()),
-    boolean: () => wrap(z.coerce.boolean()),
-    date: () => wrap(z.coerce.date()),
-};
-/** The zod-backed `SchemaValidator` singleton registered by `registerZodAdapter`. */
-export const zodAdapter = {
-    string: () => wrap(z.string()),
-    number: () => wrap(z.number()),
-    boolean: () => wrap(z.boolean()),
-    date: () => wrap(z.date()),
-    null: () => wrap(z.null()),
-    unknown: () => wrap(z.unknown()),
-    // deno-lint-ignore no-explicit-any -- contract mirrors zod's `any` constructor
-    any: () => wrap(z.any()),
-    object: (shape) => wrap(z.object(toZodShape(shape))),
-    array: (element) => wrap(z.array(toZod(element))),
-    record: (keys, values) => wrap(z.record(toZod(keys), toZod(values))),
-    union: (schemas) => {
-        const zodSchemas = schemas.map((s) => toZod(s));
-        return wrap(z.union(zodSchemas));
-    },
-    discriminatedUnion: (discriminator, schemas) => {
-        const zodSchemas = schemas.map((s) => toZod(s));
-        return wrap(z.discriminatedUnion(discriminator, zodSchemas));
-    },
-    literal: (value) => wrap(z.literal(value)),
-    enum: (values) => wrap(z.enum(values)),
-    coerce,
-    validate: (schema, data) => schema.safeParse(data),
-};
-/**
- * Register the zod adapter as the default `SchemaValidator` implementation.
- *
- * Called once at core bootstrap (`src/schemas/index.ts` side-effect import).
- * Phase B will delete this function when `@veryfront/ext-zod` takes over.
- */
-export function registerZodAdapter() {
-    register("SchemaValidator", zodAdapter);
-}