agent-orcha 0.0.1

package/dist/lib/workflows/types.d.ts

@@ -0,0 +1,630 @@
+import { z } from 'zod';
+export declare const InputMappingSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    from: z.ZodEnum<["context", "step", "vector", "mcp"]>;
+    path: z.ZodString;
+    transform: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    from: "mcp" | "vector" | "context" | "step";
+    transform?: string | undefined;
+}, {
+    path: string;
+    from: "mcp" | "vector" | "context" | "step";
+    transform?: string | undefined;
+}>]>;
+export declare const RetryConfigSchema: z.ZodObject<{
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    delay: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxAttempts: number;
+    delay: number;
+}, {
+    maxAttempts?: number | undefined;
+    delay?: number | undefined;
+}>;
+export declare const StepOutputSchema: z.ZodObject<{
+    key: z.ZodString;
+    extract: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    extract?: string | undefined;
+}, {
+    key: string;
+    extract?: string | undefined;
+}>;
+export declare const WorkflowStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    agent: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
+        from: z.ZodEnum<["context", "step", "vector", "mcp"]>;
+        path: z.ZodString;
+        transform: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        from: "mcp" | "vector" | "context" | "step";
+        transform?: string | undefined;
+    }, {
+        path: string;
+        from: "mcp" | "vector" | "context" | "step";
+        transform?: string | undefined;
+    }>]>>;
+    condition: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        delay: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        delay: number;
+    }, {
+        maxAttempts?: number | undefined;
+        delay?: number | undefined;
+    }>>;
+    output: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        extract: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        extract?: string | undefined;
+    }, {
+        key: string;
+        extract?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    input: Record<string, string | {
+        path: string;
+        from: "mcp" | "vector" | "context" | "step";
+        transform?: string | undefined;
+    }>;
+    id: string;
+    agent: string;
+    output?: {
+        key: string;
+        extract?: string | undefined;
+    } | undefined;
+    condition?: string | undefined;
+    retry?: {
+        maxAttempts: number;
+        delay: number;
+    } | undefined;
+}, {
+    input: Record<string, string | {
+        path: string;
+        from: "mcp" | "vector" | "context" | "step";
+        transform?: string | undefined;
+    }>;
+    id: string;
+    agent: string;
+    output?: {
+        key: string;
+        extract?: string | undefined;
+    } | undefined;
+    condition?: string | undefined;
+    retry?: {
+        maxAttempts?: number | undefined;
+        delay?: number | undefined;
+    } | undefined;
+}>;
+export declare const ParallelStepsSchema: z.ZodObject<{
+    parallel: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        agent: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
+            from: z.ZodEnum<["context", "step", "vector", "mcp"]>;
+            path: z.ZodString;
+            transform: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }, {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>]>>;
+        condition: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            delay: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            delay: number;
+        }, {
+            maxAttempts?: number | undefined;
+            delay?: number | undefined;
+        }>>;
+        output: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            extract: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            extract?: string | undefined;
+        }, {
+            key: string;
+            extract?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts: number;
+            delay: number;
+        } | undefined;
+    }, {
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            delay?: number | undefined;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    parallel: {
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts: number;
+            delay: number;
+        } | undefined;
+    }[];
+}, {
+    parallel: {
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            delay?: number | undefined;
+        } | undefined;
+    }[];
+}>;
+export declare const InputFieldSchema: z.ZodObject<{
+    type: z.ZodEnum<["string", "number", "boolean", "array", "object"]>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required: boolean;
+    description?: string | undefined;
+    default?: unknown;
+}, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required?: boolean | undefined;
+    description?: string | undefined;
+    default?: unknown;
+}>;
+export declare const WorkflowConfigSchema: z.ZodObject<{
+    timeout: z.ZodDefault<z.ZodNumber>;
+    onError: z.ZodDefault<z.ZodEnum<["stop", "continue", "retry"]>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    onError: "stop" | "retry" | "continue";
+}, {
+    timeout?: number | undefined;
+    onError?: "stop" | "retry" | "continue" | undefined;
+}>;
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    input: z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<["string", "number", "boolean", "array", "object"]>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required: boolean;
+            description?: string | undefined;
+            default?: unknown;
+        }, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required?: boolean | undefined;
+            description?: string | undefined;
+            default?: unknown;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        schema: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required: boolean;
+            description?: string | undefined;
+            default?: unknown;
+        }>;
+    }, {
+        schema: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required?: boolean | undefined;
+            description?: string | undefined;
+            default?: unknown;
+        }>;
+    }>;
+    steps: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        id: z.ZodString;
+        agent: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
+            from: z.ZodEnum<["context", "step", "vector", "mcp"]>;
+            path: z.ZodString;
+            transform: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }, {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>]>>;
+        condition: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            delay: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            delay: number;
+        }, {
+            maxAttempts?: number | undefined;
+            delay?: number | undefined;
+        }>>;
+        output: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            extract: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            extract?: string | undefined;
+        }, {
+            key: string;
+            extract?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts: number;
+            delay: number;
+        } | undefined;
+    }, {
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            delay?: number | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        parallel: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            agent: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
+                from: z.ZodEnum<["context", "step", "vector", "mcp"]>;
+                path: z.ZodString;
+                transform: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }, {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }>]>>;
+            condition: z.ZodOptional<z.ZodString>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodDefault<z.ZodNumber>;
+                delay: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                maxAttempts: number;
+                delay: number;
+            }, {
+                maxAttempts?: number | undefined;
+                delay?: number | undefined;
+            }>>;
+            output: z.ZodOptional<z.ZodObject<{
+                key: z.ZodString;
+                extract: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                key: string;
+                extract?: string | undefined;
+            }, {
+                key: string;
+                extract?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            input: Record<string, string | {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }>;
+            id: string;
+            agent: string;
+            output?: {
+                key: string;
+                extract?: string | undefined;
+            } | undefined;
+            condition?: string | undefined;
+            retry?: {
+                maxAttempts: number;
+                delay: number;
+            } | undefined;
+        }, {
+            input: Record<string, string | {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }>;
+            id: string;
+            agent: string;
+            output?: {
+                key: string;
+                extract?: string | undefined;
+            } | undefined;
+            condition?: string | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                delay?: number | undefined;
+            } | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        parallel: {
+            input: Record<string, string | {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }>;
+            id: string;
+            agent: string;
+            output?: {
+                key: string;
+                extract?: string | undefined;
+            } | undefined;
+            condition?: string | undefined;
+            retry?: {
+                maxAttempts: number;
+                delay: number;
+            } | undefined;
+        }[];
+    }, {
+        parallel: {
+            input: Record<string, string | {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }>;
+            id: string;
+            agent: string;
+            output?: {
+                key: string;
+                extract?: string | undefined;
+            } | undefined;
+            condition?: string | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                delay?: number | undefined;
+            } | undefined;
+        }[];
+    }>]>, "many">;
+    config: z.ZodOptional<z.ZodObject<{
+        timeout: z.ZodDefault<z.ZodNumber>;
+        onError: z.ZodDefault<z.ZodEnum<["stop", "continue", "retry"]>>;
+    }, "strip", z.ZodTypeAny, {
+        timeout: number;
+        onError: "stop" | "retry" | "continue";
+    }, {
+        timeout?: number | undefined;
+        onError?: "stop" | "retry" | "continue" | undefined;
+    }>>;
+    output: z.ZodRecord<z.ZodString, z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    name: string;
+    description: string;
+    output: Record<string, string>;
+    input: {
+        schema: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required: boolean;
+            description?: string | undefined;
+            default?: unknown;
+        }>;
+    };
+    steps: ({
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts: number;
+            delay: number;
+        } | undefined;
+    } | {
+        parallel: {
+            input: Record<string, string | {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }>;
+            id: string;
+            agent: string;
+            output?: {
+                key: string;
+                extract?: string | undefined;
+            } | undefined;
+            condition?: string | undefined;
+            retry?: {
+                maxAttempts: number;
+                delay: number;
+            } | undefined;
+        }[];
+    })[];
+    config?: {
+        timeout: number;
+        onError: "stop" | "retry" | "continue";
+    } | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    description: string;
+    output: Record<string, string>;
+    input: {
+        schema: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required?: boolean | undefined;
+            description?: string | undefined;
+            default?: unknown;
+        }>;
+    };
+    steps: ({
+        input: Record<string, string | {
+            path: string;
+            from: "mcp" | "vector" | "context" | "step";
+            transform?: string | undefined;
+        }>;
+        id: string;
+        agent: string;
+        output?: {
+            key: string;
+            extract?: string | undefined;
+        } | undefined;
+        condition?: string | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            delay?: number | undefined;
+        } | undefined;
+    } | {
+        parallel: {
+            input: Record<string, string | {
+                path: string;
+                from: "mcp" | "vector" | "context" | "step";
+                transform?: string | undefined;
+            }>;
+            id: string;
+            agent: string;
+            output?: {
+                key: string;
+                extract?: string | undefined;
+            } | undefined;
+            condition?: string | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                delay?: number | undefined;
+            } | undefined;
+        }[];
+    })[];
+    version?: string | undefined;
+    config?: {
+        timeout?: number | undefined;
+        onError?: "stop" | "retry" | "continue" | undefined;
+    } | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type InputMapping = z.infer<typeof InputMappingSchema>;
+export type RetryConfig = z.infer<typeof RetryConfigSchema>;
+export type StepOutput = z.infer<typeof StepOutputSchema>;
+export type WorkflowStep = z.infer<typeof WorkflowStepSchema>;
+export type ParallelSteps = z.infer<typeof ParallelStepsSchema>;
+export type InputField = z.infer<typeof InputFieldSchema>;
+export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>;
+export type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
+export interface StepResult {
+    output: unknown;
+    metadata: {
+        duration: number;
+        agent: string;
+        success: boolean;
+        error?: string;
+    };
+}
+export interface WorkflowContext {
+    input: Record<string, unknown>;
+    steps: Record<string, StepResult>;
+    vectors: Record<string, unknown[]>;
+}
+export interface WorkflowResult {
+    output: Record<string, unknown>;
+    metadata: {
+        duration: number;
+        stepsExecuted: number;
+        success: boolean;
+    };
+    stepResults: Record<string, StepResult>;
+}
+export interface WorkflowStatus {
+    type: 'step_start' | 'step_complete' | 'step_error' | 'workflow_start' | 'workflow_complete' | 'workflow_error';
+    stepId?: string;
+    agent?: string;
+    message: string;
+    progress?: {
+        current: number;
+        total: number;
+    };
+    elapsed?: number;
+    error?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/workflows/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/workflows/types.ts"],"names":[],"mappings":"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"}

package/dist/lib/workflows/types.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export const InputMappingSchema = z.union([
+    z.string(),
+    z.object({
+        from: z.enum(['context', 'step', 'vector', 'mcp']),
+        path: z.string(),
+        transform: z.string().optional(),
+    }),
+]);
+export const RetryConfigSchema = z.object({
+    maxAttempts: z.number().default(3),
+    delay: z.number().default(1000),
+});
+export const StepOutputSchema = z.object({
+    key: z.string(),
+    extract: z.string().optional(),
+});
+export const WorkflowStepSchema = z.object({
+    id: z.string().describe('Unique step identifier'),
+    agent: z.string().describe('Reference to agent name'),
+    input: z.record(InputMappingSchema),
+    condition: z.string().optional(),
+    retry: RetryConfigSchema.optional(),
+    output: StepOutputSchema.optional(),
+});
+export const ParallelStepsSchema = z.object({
+    parallel: z.array(WorkflowStepSchema),
+});
+export const InputFieldSchema = z.object({
+    type: z.enum(['string', 'number', 'boolean', 'array', 'object']),
+    required: z.boolean().default(false),
+    default: z.unknown().optional(),
+    description: z.string().optional(),
+});
+export const WorkflowConfigSchema = z.object({
+    timeout: z.number().default(300000),
+    onError: z.enum(['stop', 'continue', 'retry']).default('stop'),
+});
+export const WorkflowDefinitionSchema = z.object({
+    name: z.string().describe('Unique workflow identifier'),
+    description: z.string().describe('Human-readable description'),
+    version: z.string().default('1.0.0'),
+    input: z.object({
+        schema: z.record(InputFieldSchema),
+    }),
+    steps: z.array(z.union([WorkflowStepSchema, ParallelStepsSchema])),
+    config: WorkflowConfigSchema.optional(),
+    output: z.record(z.string()),
+    metadata: z.record(z.unknown()).optional(),
+});
+//# sourceMappingURL=types.js.map

package/dist/lib/workflows/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../lib/workflows/types.ts"],"names":[],"mappings":"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"}