@wave-av/workflow-sdk 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,615 @@
+import { z } from 'zod';
+
+/**
+ * WAVE Workflow SDK Types
+ *
+ * Type definitions for workflow definitions, executions, and events.
+ */
+
+/**
+ * Agent configuration within a workflow phase
+ */
+interface WorkflowAgent {
+    type: string;
+    config?: Record<string, unknown>;
+    timeout_seconds?: number;
+    retry_policy?: RetryPolicy;
+}
+/**
+ * Retry policy configuration
+ */
+interface RetryPolicy {
+    max_attempts: number;
+    backoff_type: 'fixed' | 'exponential';
+    initial_delay_ms: number;
+    max_delay_ms?: number;
+}
+/**
+ * Workflow phase definition
+ */
+interface WorkflowPhase {
+    name: string;
+    description?: string;
+    order: number;
+    agents: WorkflowAgent[];
+    condition?: PhaseCondition;
+    on_failure?: 'fail' | 'skip' | 'retry';
+}
+/**
+ * Conditional phase execution
+ */
+interface PhaseCondition {
+    type: 'expression' | 'previous_phase_status';
+    expression?: string;
+    required_status?: 'completed' | 'skipped';
+}
+/**
+ * Workflow configuration
+ */
+interface WorkflowConfig {
+    timeout_seconds?: number;
+    max_retries?: number;
+    checkpoint_enabled?: boolean;
+    parallel_phases?: boolean;
+    fail_fast?: boolean;
+    notification_channels?: string[];
+}
+/**
+ * Complete workflow definition
+ */
+interface WorkflowDefinition {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    organization_id: string;
+    created_by: string;
+    category: string;
+    version: string;
+    status: 'draft' | 'active' | 'deprecated' | 'archived';
+    phases: WorkflowPhase[];
+    config: WorkflowConfig;
+    tags?: string[];
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Execution status
+ */
+type ExecutionStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'timeout';
+/**
+ * Phase execution status
+ */
+interface PhaseExecutionStatus {
+    name: string;
+    order: number;
+    status: ExecutionStatus;
+    started_at?: string;
+    completed_at?: string;
+    error?: string;
+    output?: Record<string, unknown>;
+}
+/**
+ * Workflow execution record
+ */
+interface WorkflowExecution {
+    id: string;
+    workflow_id: string;
+    organization_id: string;
+    triggered_by: string;
+    trigger_type: 'manual' | 'scheduled' | 'webhook' | 'api' | 'event';
+    status: ExecutionStatus;
+    input_params?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    current_phase?: string;
+    phase_statuses: PhaseExecutionStatus[];
+    checkpoint_id?: string;
+    error?: string;
+    started_at?: string;
+    completed_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Execution log entry
+ */
+interface ExecutionLog {
+    id: string;
+    execution_id: string;
+    timestamp: string;
+    level: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    source: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Base workflow event
+ */
+interface WorkflowEvent<T = unknown> {
+    type: string;
+    timestamp: string;
+    workflow_id: string;
+    execution_id?: string;
+    organization_id: string;
+    data: T;
+}
+/**
+ * Execution started event
+ */
+interface ExecutionStartedEvent extends WorkflowEvent<{
+    trigger_type: string;
+    input_params?: Record<string, unknown>;
+}> {
+    type: 'execution.started';
+    execution_id: string;
+}
+/**
+ * Execution completed event
+ */
+interface ExecutionCompletedEvent extends WorkflowEvent<{
+    duration_ms: number;
+    output?: Record<string, unknown>;
+}> {
+    type: 'execution.completed';
+    execution_id: string;
+}
+/**
+ * Execution failed event
+ */
+interface ExecutionFailedEvent extends WorkflowEvent<{
+    error: string;
+    failed_phase?: string;
+    duration_ms: number;
+}> {
+    type: 'execution.failed';
+    execution_id: string;
+}
+/**
+ * Phase started event
+ */
+interface PhaseStartedEvent extends WorkflowEvent<{
+    phase_name: string;
+    phase_order: number;
+}> {
+    type: 'phase.started';
+    execution_id: string;
+}
+/**
+ * Phase completed event
+ */
+interface PhaseCompletedEvent extends WorkflowEvent<{
+    phase_name: string;
+    phase_order: number;
+    duration_ms: number;
+    output?: Record<string, unknown>;
+}> {
+    type: 'phase.completed';
+    execution_id: string;
+}
+/**
+ * Union of all workflow events
+ */
+type AnyWorkflowEvent = ExecutionStartedEvent | ExecutionCompletedEvent | ExecutionFailedEvent | PhaseStartedEvent | PhaseCompletedEvent;
+/**
+ * Execute workflow request
+ */
+interface ExecuteWorkflowRequest {
+    input_params?: Record<string, unknown>;
+    trigger_type?: 'manual' | 'api';
+    idempotency_key?: string;
+    checkpoint_id?: string;
+}
+/**
+ * Execute workflow response
+ */
+interface ExecuteWorkflowResponse {
+    execution: WorkflowExecution;
+}
+/**
+ * List executions request
+ */
+interface ListExecutionsRequest {
+    workflow_id?: string;
+    status?: ExecutionStatus;
+    limit?: number;
+    offset?: number;
+    order_by?: 'created_at' | 'started_at' | 'completed_at';
+    order?: 'asc' | 'desc';
+}
+/**
+ * List executions response
+ */
+interface ListExecutionsResponse {
+    executions: WorkflowExecution[];
+    total: number;
+    has_more: boolean;
+}
+declare const WorkflowAgentSchema: z.ZodObject<{
+    type: z.ZodString;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+    retry_policy: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        backoff_type: z.ZodEnum<["fixed", "exponential"]>;
+        initial_delay_ms: z.ZodNumber;
+        max_delay_ms: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_attempts: number;
+        backoff_type: "fixed" | "exponential";
+        initial_delay_ms: number;
+        max_delay_ms?: number | undefined;
+    }, {
+        max_attempts: number;
+        backoff_type: "fixed" | "exponential";
+        initial_delay_ms: number;
+        max_delay_ms?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    config?: Record<string, unknown> | undefined;
+    timeout_seconds?: number | undefined;
+    retry_policy?: {
+        max_attempts: number;
+        backoff_type: "fixed" | "exponential";
+        initial_delay_ms: number;
+        max_delay_ms?: number | undefined;
+    } | undefined;
+}, {
+    type: string;
+    config?: Record<string, unknown> | undefined;
+    timeout_seconds?: number | undefined;
+    retry_policy?: {
+        max_attempts: number;
+        backoff_type: "fixed" | "exponential";
+        initial_delay_ms: number;
+        max_delay_ms?: number | undefined;
+    } | undefined;
+}>;
+declare const WorkflowPhaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    order: z.ZodNumber;
+    agents: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timeout_seconds: z.ZodOptional<z.ZodNumber>;
+        retry_policy: z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodNumber;
+            backoff_type: z.ZodEnum<["fixed", "exponential"]>;
+            initial_delay_ms: z.ZodNumber;
+            max_delay_ms: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            max_attempts: number;
+            backoff_type: "fixed" | "exponential";
+            initial_delay_ms: number;
+            max_delay_ms?: number | undefined;
+        }, {
+            max_attempts: number;
+            backoff_type: "fixed" | "exponential";
+            initial_delay_ms: number;
+            max_delay_ms?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        config?: Record<string, unknown> | undefined;
+        timeout_seconds?: number | undefined;
+        retry_policy?: {
+            max_attempts: number;
+            backoff_type: "fixed" | "exponential";
+            initial_delay_ms: number;
+            max_delay_ms?: number | undefined;
+        } | undefined;
+    }, {
+        type: string;
+        config?: Record<string, unknown> | undefined;
+        timeout_seconds?: number | undefined;
+        retry_policy?: {
+            max_attempts: number;
+            backoff_type: "fixed" | "exponential";
+            initial_delay_ms: number;
+            max_delay_ms?: number | undefined;
+        } | undefined;
+    }>, "many">;
+    condition: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["expression", "previous_phase_status"]>;
+        expression: z.ZodOptional<z.ZodString>;
+        required_status: z.ZodOptional<z.ZodEnum<["completed", "skipped"]>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "expression" | "previous_phase_status";
+        expression?: string | undefined;
+        required_status?: "completed" | "skipped" | undefined;
+    }, {
+        type: "expression" | "previous_phase_status";
+        expression?: string | undefined;
+        required_status?: "completed" | "skipped" | undefined;
+    }>>;
+    on_failure: z.ZodOptional<z.ZodEnum<["fail", "skip", "retry"]>>;
+}, "strip", z.ZodTypeAny, {
+    order: number;
+    name: string;
+    agents: {
+        type: string;
+        config?: Record<string, unknown> | undefined;
+        timeout_seconds?: number | undefined;
+        retry_policy?: {
+            max_attempts: number;
+            backoff_type: "fixed" | "exponential";
+            initial_delay_ms: number;
+            max_delay_ms?: number | undefined;
+        } | undefined;
+    }[];
+    description?: string | undefined;
+    condition?: {
+        type: "expression" | "previous_phase_status";
+        expression?: string | undefined;
+        required_status?: "completed" | "skipped" | undefined;
+    } | undefined;
+    on_failure?: "fail" | "skip" | "retry" | undefined;
+}, {
+    order: number;
+    name: string;
+    agents: {
+        type: string;
+        config?: Record<string, unknown> | undefined;
+        timeout_seconds?: number | undefined;
+        retry_policy?: {
+            max_attempts: number;
+            backoff_type: "fixed" | "exponential";
+            initial_delay_ms: number;
+            max_delay_ms?: number | undefined;
+        } | undefined;
+    }[];
+    description?: string | undefined;
+    condition?: {
+        type: "expression" | "previous_phase_status";
+        expression?: string | undefined;
+        required_status?: "completed" | "skipped" | undefined;
+    } | undefined;
+    on_failure?: "fail" | "skip" | "retry" | undefined;
+}>;
+declare const WorkflowConfigSchema: z.ZodObject<{
+    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+    max_retries: z.ZodOptional<z.ZodNumber>;
+    checkpoint_enabled: z.ZodOptional<z.ZodBoolean>;
+    parallel_phases: z.ZodOptional<z.ZodBoolean>;
+    fail_fast: z.ZodOptional<z.ZodBoolean>;
+    notification_channels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    timeout_seconds?: number | undefined;
+    max_retries?: number | undefined;
+    checkpoint_enabled?: boolean | undefined;
+    parallel_phases?: boolean | undefined;
+    fail_fast?: boolean | undefined;
+    notification_channels?: string[] | undefined;
+}, {
+    timeout_seconds?: number | undefined;
+    max_retries?: number | undefined;
+    checkpoint_enabled?: boolean | undefined;
+    parallel_phases?: boolean | undefined;
+    fail_fast?: boolean | undefined;
+    notification_channels?: string[] | undefined;
+}>;
+declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodString;
+    version: z.ZodString;
+    phases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        order: z.ZodNumber;
+        agents: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            timeout_seconds: z.ZodOptional<z.ZodNumber>;
+            retry_policy: z.ZodOptional<z.ZodObject<{
+                max_attempts: z.ZodNumber;
+                backoff_type: z.ZodEnum<["fixed", "exponential"]>;
+                initial_delay_ms: z.ZodNumber;
+                max_delay_ms: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            }, {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            config?: Record<string, unknown> | undefined;
+            timeout_seconds?: number | undefined;
+            retry_policy?: {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            } | undefined;
+        }, {
+            type: string;
+            config?: Record<string, unknown> | undefined;
+            timeout_seconds?: number | undefined;
+            retry_policy?: {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            } | undefined;
+        }>, "many">;
+        condition: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["expression", "previous_phase_status"]>;
+            expression: z.ZodOptional<z.ZodString>;
+            required_status: z.ZodOptional<z.ZodEnum<["completed", "skipped"]>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "expression" | "previous_phase_status";
+            expression?: string | undefined;
+            required_status?: "completed" | "skipped" | undefined;
+        }, {
+            type: "expression" | "previous_phase_status";
+            expression?: string | undefined;
+            required_status?: "completed" | "skipped" | undefined;
+        }>>;
+        on_failure: z.ZodOptional<z.ZodEnum<["fail", "skip", "retry"]>>;
+    }, "strip", z.ZodTypeAny, {
+        order: number;
+        name: string;
+        agents: {
+            type: string;
+            config?: Record<string, unknown> | undefined;
+            timeout_seconds?: number | undefined;
+            retry_policy?: {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            } | undefined;
+        }[];
+        description?: string | undefined;
+        condition?: {
+            type: "expression" | "previous_phase_status";
+            expression?: string | undefined;
+            required_status?: "completed" | "skipped" | undefined;
+        } | undefined;
+        on_failure?: "fail" | "skip" | "retry" | undefined;
+    }, {
+        order: number;
+        name: string;
+        agents: {
+            type: string;
+            config?: Record<string, unknown> | undefined;
+            timeout_seconds?: number | undefined;
+            retry_policy?: {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            } | undefined;
+        }[];
+        description?: string | undefined;
+        condition?: {
+            type: "expression" | "previous_phase_status";
+            expression?: string | undefined;
+            required_status?: "completed" | "skipped" | undefined;
+        } | undefined;
+        on_failure?: "fail" | "skip" | "retry" | undefined;
+    }>, "many">;
+    config: z.ZodOptional<z.ZodObject<{
+        timeout_seconds: z.ZodOptional<z.ZodNumber>;
+        max_retries: z.ZodOptional<z.ZodNumber>;
+        checkpoint_enabled: z.ZodOptional<z.ZodBoolean>;
+        parallel_phases: z.ZodOptional<z.ZodBoolean>;
+        fail_fast: z.ZodOptional<z.ZodBoolean>;
+        notification_channels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        timeout_seconds?: number | undefined;
+        max_retries?: number | undefined;
+        checkpoint_enabled?: boolean | undefined;
+        parallel_phases?: boolean | undefined;
+        fail_fast?: boolean | undefined;
+        notification_channels?: string[] | undefined;
+    }, {
+        timeout_seconds?: number | undefined;
+        max_retries?: number | undefined;
+        checkpoint_enabled?: boolean | undefined;
+        parallel_phases?: boolean | undefined;
+        fail_fast?: boolean | undefined;
+        notification_channels?: string[] | undefined;
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    category: string;
+    name: string;
+    slug: string;
+    version: string;
+    phases: {
+        order: number;
+        name: string;
+        agents: {
+            type: string;
+            config?: Record<string, unknown> | undefined;
+            timeout_seconds?: number | undefined;
+            retry_policy?: {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            } | undefined;
+        }[];
+        description?: string | undefined;
+        condition?: {
+            type: "expression" | "previous_phase_status";
+            expression?: string | undefined;
+            required_status?: "completed" | "skipped" | undefined;
+        } | undefined;
+        on_failure?: "fail" | "skip" | "retry" | undefined;
+    }[];
+    config?: {
+        timeout_seconds?: number | undefined;
+        max_retries?: number | undefined;
+        checkpoint_enabled?: boolean | undefined;
+        parallel_phases?: boolean | undefined;
+        fail_fast?: boolean | undefined;
+        notification_channels?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+}, {
+    category: string;
+    name: string;
+    slug: string;
+    version: string;
+    phases: {
+        order: number;
+        name: string;
+        agents: {
+            type: string;
+            config?: Record<string, unknown> | undefined;
+            timeout_seconds?: number | undefined;
+            retry_policy?: {
+                max_attempts: number;
+                backoff_type: "fixed" | "exponential";
+                initial_delay_ms: number;
+                max_delay_ms?: number | undefined;
+            } | undefined;
+        }[];
+        description?: string | undefined;
+        condition?: {
+            type: "expression" | "previous_phase_status";
+            expression?: string | undefined;
+            required_status?: "completed" | "skipped" | undefined;
+        } | undefined;
+        on_failure?: "fail" | "skip" | "retry" | undefined;
+    }[];
+    config?: {
+        timeout_seconds?: number | undefined;
+        max_retries?: number | undefined;
+        checkpoint_enabled?: boolean | undefined;
+        parallel_phases?: boolean | undefined;
+        fail_fast?: boolean | undefined;
+        notification_channels?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+}>;
+declare const ExecuteWorkflowRequestSchema: z.ZodObject<{
+    input_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    trigger_type: z.ZodOptional<z.ZodEnum<["manual", "api"]>>;
+    idempotency_key: z.ZodOptional<z.ZodString>;
+    checkpoint_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    input_params?: Record<string, unknown> | undefined;
+    trigger_type?: "manual" | "api" | undefined;
+    idempotency_key?: string | undefined;
+    checkpoint_id?: string | undefined;
+}, {
+    input_params?: Record<string, unknown> | undefined;
+    trigger_type?: "manual" | "api" | undefined;
+    idempotency_key?: string | undefined;
+    checkpoint_id?: string | undefined;
+}>;
+
+export { type AnyWorkflowEvent, type ExecuteWorkflowRequest, ExecuteWorkflowRequestSchema, type ExecuteWorkflowResponse, type ExecutionCompletedEvent, type ExecutionFailedEvent, type ExecutionLog, type ExecutionStartedEvent, type ExecutionStatus, type ListExecutionsRequest, type ListExecutionsResponse, type PhaseCompletedEvent, type PhaseCondition, type PhaseExecutionStatus, type PhaseStartedEvent, type RetryPolicy, type WorkflowAgent, WorkflowAgentSchema, type WorkflowConfig, WorkflowConfigSchema, type WorkflowDefinition, WorkflowDefinitionSchema, type WorkflowEvent, type WorkflowExecution, type WorkflowPhase, WorkflowPhaseSchema };

package/dist/types.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+__export(types_exports, {
+  ExecuteWorkflowRequestSchema: () => ExecuteWorkflowRequestSchema,
+  WorkflowAgentSchema: () => WorkflowAgentSchema,
+  WorkflowConfigSchema: () => WorkflowConfigSchema,
+  WorkflowDefinitionSchema: () => WorkflowDefinitionSchema,
+  WorkflowPhaseSchema: () => WorkflowPhaseSchema
+});
+module.exports = __toCommonJS(types_exports);
+var import_zod = require("zod");
+var WorkflowAgentSchema = import_zod.z.object({
+  type: import_zod.z.string().min(1),
+  config: import_zod.z.record(import_zod.z.unknown()).optional(),
+  timeout_seconds: import_zod.z.number().int().positive().optional(),
+  retry_policy: import_zod.z.object({
+    max_attempts: import_zod.z.number().int().positive(),
+    backoff_type: import_zod.z.enum(["fixed", "exponential"]),
+    initial_delay_ms: import_zod.z.number().int().positive(),
+    max_delay_ms: import_zod.z.number().int().positive().optional()
+  }).optional()
+});
+var WorkflowPhaseSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1).max(100),
+  description: import_zod.z.string().max(500).optional(),
+  order: import_zod.z.number().int().positive(),
+  agents: import_zod.z.array(WorkflowAgentSchema),
+  condition: import_zod.z.object({
+    type: import_zod.z.enum(["expression", "previous_phase_status"]),
+    expression: import_zod.z.string().optional(),
+    required_status: import_zod.z.enum(["completed", "skipped"]).optional()
+  }).optional(),
+  on_failure: import_zod.z.enum(["fail", "skip", "retry"]).optional()
+});
+var WorkflowConfigSchema = import_zod.z.object({
+  timeout_seconds: import_zod.z.number().int().positive().max(86400).optional(),
+  max_retries: import_zod.z.number().int().min(0).max(10).optional(),
+  checkpoint_enabled: import_zod.z.boolean().optional(),
+  parallel_phases: import_zod.z.boolean().optional(),
+  fail_fast: import_zod.z.boolean().optional(),
+  notification_channels: import_zod.z.array(import_zod.z.string()).optional()
+});
+var WorkflowDefinitionSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1).max(200),
+  slug: import_zod.z.string().regex(/^[a-z0-9-]+$/).min(1).max(100),
+  description: import_zod.z.string().max(1e3).optional(),
+  category: import_zod.z.string().min(1).max(50),
+  version: import_zod.z.string().regex(/^\d+\.\d+\.\d+$/),
+  phases: import_zod.z.array(WorkflowPhaseSchema).min(1),
+  config: WorkflowConfigSchema.optional(),
+  tags: import_zod.z.array(import_zod.z.string().max(50)).max(10).optional()
+});
+var ExecuteWorkflowRequestSchema = import_zod.z.object({
+  input_params: import_zod.z.record(import_zod.z.unknown()).optional(),
+  trigger_type: import_zod.z.enum(["manual", "api"]).optional(),
+  idempotency_key: import_zod.z.string().max(100).optional(),
+  checkpoint_id: import_zod.z.string().uuid().optional()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExecuteWorkflowRequestSchema,
+  WorkflowAgentSchema,
+  WorkflowConfigSchema,
+  WorkflowDefinitionSchema,
+  WorkflowPhaseSchema
+});