@codebolt/agent 1.2.1 → 2.2.2

package/dist/composablepattern/workflow.js

@@ -0,0 +1,562 @@
+"use strict";
+/**
+ * @fileoverview Workflow system for Composable Agent Pattern
+ * @description Provides workflow orchestration for multi-step agent processes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflow = void 0;
+exports.createAgentStep = createAgentStep;
+exports.createTransformStep = createTransformStep;
+exports.createConditionalStep = createConditionalStep;
+exports.createDelayStep = createDelayStep;
+exports.createStep = createStep;
+exports.createSimpleStep = createSimpleStep;
+exports.createAsyncStep = createAsyncStep;
+exports.createValidationStep = createValidationStep;
+exports.createLoggingStep = createLoggingStep;
+exports.createWorkflow = createWorkflow;
+const zod_1 = require("zod");
+// ================================
+// Workflow Engine
+// ================================
+class Workflow {
+    constructor(config) {
+        this.config = config;
+        this.context = {
+            data: { ...config.initialData || {} },
+            history: [],
+            currentStep: 0,
+            metadata: {
+                workflowName: config.name,
+                startTime: new Date().toISOString(),
+                steps: config.steps.map(s => ({ id: s.id, name: s.name }))
+            }
+        };
+    }
+    /**
+     * Execute the workflow
+     */
+    async execute() {
+        const startTime = Date.now();
+        try {
+            await this.executeSteps(this.config.steps);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: this.context.data,
+                stepResults: this.context.history,
+                executionTime,
+                metadata: {
+                    ...this.context.metadata,
+                    endTime: new Date().toISOString(),
+                    totalSteps: this.context.history.length
+                }
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            return {
+                success: false,
+                data: this.context.data,
+                stepResults: this.context.history,
+                executionTime,
+                error: error instanceof Error ? error.message : String(error),
+                metadata: {
+                    ...this.context.metadata,
+                    endTime: new Date().toISOString(),
+                    failedAt: this.context.currentStep
+                }
+            };
+        }
+    }
+    /**
+     * Execute a list of steps
+     */
+    async executeSteps(steps) {
+        const parallelSteps = [];
+        for (const step of steps) {
+            // Check dependencies
+            if (step.dependencies) {
+                const unmetDeps = step.dependencies.filter(depId => !this.context.history.some(h => h.stepId === depId && h.success));
+                if (unmetDeps.length > 0) {
+                    throw new Error(`Step ${step.id} has unmet dependencies: ${unmetDeps.join(', ')}`);
+                }
+            }
+            // Check condition
+            if (step.condition && !(await step.condition(this.context))) {
+                continue;
+            }
+            if (step.parallel) {
+                parallelSteps.push(step);
+            }
+            else {
+                // Execute any pending parallel steps first
+                if (parallelSteps.length > 0) {
+                    await this.executeParallelSteps(parallelSteps);
+                    parallelSteps.length = 0;
+                }
+                // Execute this step
+                await this.executeStep(step);
+            }
+        }
+        // Execute any remaining parallel steps
+        if (parallelSteps.length > 0) {
+            await this.executeParallelSteps(parallelSteps);
+        }
+    }
+    /**
+     * Execute parallel steps
+     */
+    async executeParallelSteps(steps) {
+        const maxConcurrency = this.config.maxParallelSteps || steps.length;
+        const batches = this.chunkArray(steps, maxConcurrency);
+        for (const batch of batches) {
+            await Promise.all(batch.map(step => this.executeStep(step)));
+        }
+    }
+    /**
+     * Execute a single step with retry logic
+     */
+    async executeStep(step) {
+        var _a;
+        const maxAttempts = ((_a = step.retry) === null || _a === void 0 ? void 0 : _a.maxAttempts) || 1;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                const startTime = Date.now();
+                // Validate input if schema provided
+                if (step.inputSchema) {
+                    step.inputSchema.parse(this.context.data);
+                }
+                const result = await step.execute(this.context);
+                // Validate output if schema provided
+                if (step.outputSchema && result.output !== undefined) {
+                    step.outputSchema.parse(result.output);
+                }
+                result.executionTime = Date.now() - startTime;
+                this.context.history.push(result);
+                // Merge step output into context
+                if (result.output && typeof result.output === 'object') {
+                    this.context.data = { ...this.context.data, ...result.output };
+                }
+                return; // Success, exit retry loop
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < maxAttempts && step.retry) {
+                    const delay = this.calculateRetryDelay(step.retry, attempt);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        // All attempts failed
+        const result = {
+            stepId: step.id,
+            success: false,
+            error: (lastError === null || lastError === void 0 ? void 0 : lastError.message) || 'Unknown error',
+            executionTime: 0
+        };
+        this.context.history.push(result);
+        if (!this.config.continueOnError) {
+            throw lastError || new Error(`Step ${step.id} failed`);
+        }
+    }
+    /**
+     * Calculate retry delay with backoff
+     */
+    calculateRetryDelay(retryConfig, attempt) {
+        const baseDelay = retryConfig.delay;
+        switch (retryConfig.backoff) {
+            case 'exponential':
+                return baseDelay * Math.pow(2, attempt - 1);
+            case 'linear':
+            default:
+                return baseDelay * attempt;
+        }
+    }
+    /**
+     * Split array into chunks
+     */
+    chunkArray(array, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += chunkSize) {
+            chunks.push(array.slice(i, i + chunkSize));
+        }
+        return chunks;
+    }
+    /**
+     * Get current workflow context
+     */
+    getContext() {
+        return { ...this.context };
+    }
+    /**
+     * Update workflow context data
+     */
+    updateContext(data) {
+        this.context.data = { ...this.context.data, ...data };
+    }
+}
+exports.Workflow = Workflow;
+// ================================
+// Step Factory Functions
+// ================================
+/**
+ * Create an agent execution step
+ */
+function createAgentStep(config) {
+    return {
+        id: config.id,
+        name: config.name,
+        description: `Execute agent: ${config.agent.config.name}`,
+        execute: async (context) => {
+            try {
+                // Apply input mapping
+                let stepData = { ...context.data };
+                if (config.inputMapping) {
+                    for (const [stepKey, contextKey] of Object.entries(config.inputMapping)) {
+                        if (context.data[contextKey] !== undefined) {
+                            stepData[stepKey] = context.data[contextKey];
+                        }
+                    }
+                }
+                // Replace template variables in message
+                const message = config.messageTemplate.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+                    return stepData[key] !== undefined ? String(stepData[key]) : match;
+                });
+                const result = await config.agent.execute(message);
+                // Apply output mapping
+                let output = { agentResult: result };
+                if (config.outputMapping) {
+                    output = {};
+                    for (const [contextKey, resultKey] of Object.entries(config.outputMapping)) {
+                        const value = resultKey.split('.').reduce((obj, key) => obj === null || obj === void 0 ? void 0 : obj[key], { agentResult: result });
+                        if (value !== undefined) {
+                            output[contextKey] = value;
+                        }
+                    }
+                }
+                return {
+                    stepId: config.id,
+                    success: result.success,
+                    output,
+                    error: result.error,
+                    executionTime: 0 // Will be set by executeStep
+                };
+            }
+            catch (error) {
+                return {
+                    stepId: config.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    executionTime: 0
+                };
+            }
+        }
+    };
+}
+/**
+ * Create a data transformation step
+ */
+function createTransformStep(config) {
+    return {
+        id: config.id,
+        name: config.name,
+        description: 'Transform data',
+        inputSchema: config.inputSchema,
+        outputSchema: config.outputSchema,
+        execute: async (context) => {
+            try {
+                const output = await config.transform(context.data);
+                return {
+                    stepId: config.id,
+                    success: true,
+                    output,
+                    executionTime: 0
+                };
+            }
+            catch (error) {
+                return {
+                    stepId: config.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    executionTime: 0
+                };
+            }
+        }
+    };
+}
+/**
+ * Create a conditional branch step
+ */
+function createConditionalStep(config) {
+    return {
+        id: config.id,
+        name: config.name,
+        description: 'Conditional execution',
+        execute: async (context) => {
+            try {
+                const conditionResult = await config.condition(context);
+                const stepsToExecute = conditionResult ? config.trueBranch : (config.falseBranch || []);
+                // Execute conditional steps
+                const subWorkflow = new Workflow({
+                    name: `${config.id}-branch`,
+                    steps: stepsToExecute,
+                    initialData: context.data
+                });
+                const result = await subWorkflow.execute();
+                return {
+                    stepId: config.id,
+                    success: result.success,
+                    output: result.data,
+                    error: result.error,
+                    executionTime: result.executionTime,
+                    metadata: {
+                        conditionResult,
+                        branchExecuted: conditionResult ? 'true' : 'false',
+                        subSteps: result.stepResults.length
+                    }
+                };
+            }
+            catch (error) {
+                return {
+                    stepId: config.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    executionTime: 0
+                };
+            }
+        }
+    };
+}
+/**
+ * Create a delay step
+ */
+function createDelayStep(config) {
+    return {
+        id: config.id,
+        name: config.name,
+        description: `Delay for ${config.delay}ms`,
+        execute: async () => {
+            await new Promise(resolve => setTimeout(resolve, config.delay));
+            return {
+                stepId: config.id,
+                success: true,
+                executionTime: config.delay
+            };
+        }
+    };
+}
+/**
+ * Create a simple custom step with your own logic
+ *
+ * @param config - Step configuration with custom execute function
+ * @returns WorkflowStep
+ *
+ * @example
+ * ```typescript
+ * const customStep = createStep({
+ *   id: 'my-step',
+ *   name: 'My Custom Step',
+ *   description: 'Does something custom',
+ *   execute: async (context) => {
+ *     // Your custom logic here
+ *     const result = await doSomething(context.data);
+ *     return {
+ *       stepId: 'my-step',
+ *       success: true,
+ *       output: { customResult: result },
+ *       executionTime: 0
+ *     };
+ *   }
+ * });
+ * ```
+ */
+function createStep(config) {
+    return {
+        id: config.id,
+        name: config.name,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        outputSchema: config.outputSchema,
+        execute: config.execute,
+        condition: config.condition,
+        dependencies: config.dependencies,
+        parallel: config.parallel,
+        retry: config.retry
+    };
+}
+/**
+ * Create a simple step that executes a function with the context data
+ *
+ * @param config - Step configuration with transform function
+ * @returns WorkflowStep
+ *
+ * @example
+ * ```typescript
+ * const mathStep = createSimpleStep({
+ *   id: 'calculate',
+ *   name: 'Calculate Total',
+ *   execute: (data) => {
+ *     const total = data.items.reduce((sum, item) => sum + item.price, 0);
+ *     return { total, itemCount: data.items.length };
+ *   }
+ * });
+ * ```
+ */
+function createSimpleStep(config) {
+    return createStep({
+        ...config,
+        execute: async (context) => {
+            try {
+                const output = await config.execute(context.data);
+                return {
+                    stepId: config.id,
+                    success: true,
+                    output,
+                    executionTime: 0 // Will be set by executeStep
+                };
+            }
+            catch (error) {
+                return {
+                    stepId: config.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    executionTime: 0
+                };
+            }
+        }
+    });
+}
+/**
+ * Create an async step that can perform asynchronous operations
+ *
+ * @param config - Step configuration with async function
+ * @returns WorkflowStep
+ *
+ * @example
+ * ```typescript
+ * const apiStep = createAsyncStep({
+ *   id: 'fetch-data',
+ *   name: 'Fetch External Data',
+ *   execute: async (data) => {
+ *     const response = await fetch(`/api/data/${data.id}`);
+ *     const result = await response.json();
+ *     return { fetchedData: result };
+ *   },
+ *   retry: {
+ *     maxAttempts: 3,
+ *     delay: 1000,
+ *     backoff: 'exponential'
+ *   }
+ * });
+ * ```
+ */
+function createAsyncStep(config) {
+    return createStep({
+        ...config,
+        execute: async (context) => {
+            try {
+                const output = await config.execute(context.data, context);
+                return {
+                    stepId: config.id,
+                    success: true,
+                    output,
+                    executionTime: 0 // Will be set by executeStep
+                };
+            }
+            catch (error) {
+                return {
+                    stepId: config.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    executionTime: 0
+                };
+            }
+        }
+    });
+}
+/**
+ * Create a validation step that validates data against a schema
+ *
+ * @param config - Validation configuration
+ * @returns WorkflowStep
+ */
+function createValidationStep(config) {
+    return createStep({
+        id: config.id,
+        name: config.name,
+        description: `Validate ${config.field || 'data'} against schema`,
+        execute: async (context) => {
+            try {
+                const dataToValidate = config.field
+                    ? context.data[config.field]
+                    : context.data;
+                const validatedData = config.schema.parse(dataToValidate);
+                return {
+                    stepId: config.id,
+                    success: true,
+                    output: config.field
+                        ? { [config.field]: validatedData }
+                        : validatedData,
+                    executionTime: 0
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof zod_1.z.ZodError
+                    ? `Validation failed: ${error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join(', ')}`
+                    : error instanceof Error ? error.message : String(error);
+                return {
+                    stepId: config.id,
+                    success: !config.stopOnFailure,
+                    error: errorMessage,
+                    executionTime: 0,
+                    metadata: { validationError: true }
+                };
+            }
+        }
+    });
+}
+/**
+ * Create a logging step for debugging workflows
+ *
+ * @param config - Logging configuration
+ * @returns WorkflowStep
+ */
+function createLoggingStep(config) {
+    return createStep({
+        id: config.id,
+        name: config.name,
+        description: `Log workflow state`,
+        execute: async (context) => {
+            const level = config.level || 'info';
+            const message = config.message || `Step ${config.id} executed`;
+            // Extract specific fields if specified
+            const logData = config.fields
+                ? config.fields.reduce((acc, field) => {
+                    acc[field] = context.data[field];
+                    return acc;
+                }, {})
+                : context.data;
+            // Log to console (in production, you might use a proper logger)
+            console[level](`[Workflow] ${message}`, {
+                stepId: config.id,
+                data: logData,
+                executionStep: context.currentStep,
+                timestamp: new Date().toISOString()
+            });
+            return {
+                stepId: config.id,
+                success: true,
+                output: { logged: true, logLevel: level },
+                executionTime: 0
+            };
+        }
+    });
+}
+/**
+ * Create a workflow from configuration
+ */
+function createWorkflow(config) {
+    return new Workflow(config);
+}

package/dist/processor/agent/agentStep.d.ts

@@ -0,0 +1,49 @@
+import { IAgentStep, AgentStepInput, AgentStepOutput, ProcessedMessage, ToolList, ToolExecutor, Processor } from '../types/interfaces';
+export interface AgentStepOptions {
+    inputProcessors?: Processor[];
+    outputProcessors?: Processor[];
+    toolList?: ToolList;
+    toolExecutor?: ToolExecutor;
+    maxIterations?: number;
+}
+export declare abstract class AgentStep implements IAgentStep {
+    protected readonly inputProcessors: Processor[];
+    protected readonly outputProcessors: Processor[];
+    protected readonly toolList?: ToolList;
+    protected readonly toolExecutor?: ToolExecutor;
+    protected readonly maxIterations: number;
+    constructor(options?: AgentStepOptions);
+    /**
+     * Single step processing with input/output processors
+     */
+    step(message: ProcessedMessage, context?: Record<string, any>): Promise<ProcessedMessage>;
+    generateOneStep(input: AgentStepInput): Promise<AgentStepOutput>;
+    generateWithToolExecution(input: AgentStepInput): Promise<AgentStepOutput>;
+    loop(input: AgentStepInput, maxIterations?: number): Promise<AgentStepOutput>;
+    protected abstract analyzeForToolCalls(message: ProcessedMessage, tools: any[], context?: Record<string, any>): Promise<Array<{
+        tool: string;
+        parameters: any;
+    }> | null>;
+    protected abstract generateFinalResponse(message: ProcessedMessage, toolResults: any, context?: Record<string, any>): Promise<AgentStepOutput>;
+}
+export interface LLMConfig {
+    llmname?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface LLMAgentStepOptions extends AgentStepOptions {
+    llmconfig?: LLMConfig;
+}
+export declare class LLMAgentStep extends AgentStep {
+    protected readonly llmConfig: LLMConfig;
+    constructor(options?: LLMAgentStepOptions);
+    protected analyzeForToolCalls(message: ProcessedMessage, tools: any[], context?: Record<string, any>): Promise<Array<{
+        tool: string;
+        parameters: any;
+    }> | null>;
+    protected generateFinalResponse(message: ProcessedMessage, toolResults: any, context?: Record<string, any>): Promise<AgentStepOutput>;
+    private extractFilePath;
+}