@codebolt/agent 1.2.1 → 2.2.3

package/dist/unified/agent/workflow.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflow = void 0;
+const crypto_1 = require("crypto");
+class Workflow {
+    constructor(config) {
+        this.context = {};
+        this.currentStepIndex = 0;
+        this.executionId = '';
+        this.startTime = 0;
+        this.stepResults = [];
+        this.config = config;
+    }
+    execute() {
+        this.executionId = (0, crypto_1.randomUUID)();
+        this.startTime = Date.now();
+        try {
+            // Validate input if schema exists
+            if (this.config.inputSchema) {
+                this.config.inputSchema.parse(this.context);
+            }
+            // Execute all steps synchronously (note: this is a limitation due to BaseWorkflow interface)
+            // In a real implementation, you might want to use async/await with proper error handling
+            const stepResults = this.executeSteps();
+            const executionTime = Date.now() - this.startTime;
+            const success = stepResults.every(result => result.success);
+            // Validate output if schema exists
+            if (this.config.outputSchema && success) {
+                this.config.outputSchema.parse(this.context);
+            }
+            return {
+                executionId: this.executionId,
+                success,
+                data: this.context,
+                stepResults,
+                executionTime,
+                error: success ? undefined : 'One or more steps failed'
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - this.startTime;
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                executionId: this.executionId,
+                success: false,
+                data: this.context,
+                stepResults: this.stepResults,
+                executionTime,
+                error: errorMessage
+            };
+        }
+    }
+    executeStep() {
+        if (this.currentStepIndex >= this.config.steps.length) {
+            throw new Error('No more steps to execute');
+        }
+        const step = this.config.steps[this.currentStepIndex];
+        try {
+            // Note: Since BaseWorkflow expects sync methods, we can't properly handle async step execution
+            // This is a design limitation that would need to be addressed in the BaseWorkflow interface
+            const result = {
+                stepId: step.id,
+                success: true,
+                result: null,
+                metaData: this.context
+            };
+            this.currentStepIndex++;
+            this.stepResults.push(result);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            this.currentStepIndex++;
+            const errorResult = {
+                stepId: step.id,
+                success: false,
+                result: null,
+                error: errorMessage
+            };
+            this.stepResults.push(errorResult);
+            return errorResult;
+        }
+    }
+    executeSteps() {
+        const allResults = [];
+        for (let i = 0; i < this.config.steps.length; i++) {
+            const step = this.config.steps[i];
+            try {
+                // Note: This is a synchronous implementation due to BaseWorkflow interface constraints
+                // In a real async implementation, you would await step.execute(this.context)
+                const result = {
+                    stepId: step.id,
+                    success: true,
+                    result: `Step ${step.id} executed synchronously`,
+                    metaData: this.context
+                };
+                allResults.push(result);
+                // Update context with successful result
+                if (result.success && result.result !== null) {
+                    this.updateContext({
+                        [`step_${result.stepId}`]: result.result,
+                        ...result.metaData
+                    });
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                const errorResult = {
+                    stepId: step.id,
+                    success: false,
+                    result: null,
+                    error: errorMessage
+                };
+                allResults.push(errorResult);
+                // Break on error (can be made configurable)
+                break;
+            }
+        }
+        this.stepResults = allResults;
+        return allResults;
+    }
+    getContext() {
+        return { ...this.context };
+    }
+    updateContext(newContext) {
+        this.context = { ...this.context, ...newContext };
+    }
+    // Additional utility methods for better workflow management
+    reset() {
+        this.context = {};
+        this.currentStepIndex = 0;
+        this.executionId = '';
+        this.startTime = 0;
+        this.stepResults = [];
+    }
+    getCurrentStepIndex() {
+        return this.currentStepIndex;
+    }
+    getTotalSteps() {
+        return this.config.steps.length;
+    }
+    getExecutionId() {
+        return this.executionId;
+    }
+    setInitialContext(context) {
+        this.context = { ...context };
+    }
+    getStepResults() {
+        return [...this.stepResults];
+    }
+    // Async versions of the methods for proper workflow execution
+    // These can be used when the BaseWorkflow interface is updated to support async
+    async executeAsync() {
+        this.executionId = (0, crypto_1.randomUUID)();
+        this.startTime = Date.now();
+        try {
+            // Validate input if schema exists
+            if (this.config.inputSchema) {
+                this.config.inputSchema.parse(this.context);
+            }
+            // Execute all steps asynchronously
+            const stepResults = await this.executeStepsAsync();
+            const executionTime = Date.now() - this.startTime;
+            const success = stepResults.every(result => result.success);
+            // Validate output if schema exists
+            if (this.config.outputSchema && success) {
+                this.config.outputSchema.parse(this.context);
+            }
+            return {
+                executionId: this.executionId,
+                success,
+                data: this.context,
+                stepResults,
+                executionTime,
+                error: success ? undefined : 'One or more steps failed'
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - this.startTime;
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                executionId: this.executionId,
+                success: false,
+                data: this.context,
+                stepResults: this.stepResults,
+                executionTime,
+                error: errorMessage
+            };
+        }
+    }
+    async executeStepAsync() {
+        if (this.currentStepIndex >= this.config.steps.length) {
+            throw new Error('No more steps to execute');
+        }
+        const step = this.config.steps[this.currentStepIndex];
+        try {
+            const result = await step.execute(this.context);
+            // Handle different return types based on step type
+            if (Array.isArray(result)) {
+                // For parallel, condition, or loop steps that return multiple results
+                const lastResult = result[result.length - 1];
+                this.currentStepIndex++;
+                this.stepResults.push(...result);
+                return lastResult;
+            }
+            else {
+                // For single step execution
+                this.currentStepIndex++;
+                this.stepResults.push(result);
+                return result;
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            this.currentStepIndex++;
+            const errorResult = {
+                stepId: step.id,
+                success: false,
+                result: null,
+                error: errorMessage
+            };
+            this.stepResults.push(errorResult);
+            return errorResult;
+        }
+    }
+    async executeStepsAsync() {
+        const allResults = [];
+        for (let i = 0; i < this.config.steps.length; i++) {
+            const step = this.config.steps[i];
+            try {
+                const result = await step.execute(this.context);
+                // Handle different return types based on step type
+                if (Array.isArray(result)) {
+                    // For parallel, condition, or loop steps that return multiple results
+                    allResults.push(...result);
+                    // Update context with successful results
+                    result.forEach(stepResult => {
+                        if (stepResult.success && stepResult.result !== null) {
+                            this.updateContext({
+                                [`step_${stepResult.stepId}`]: stepResult.result,
+                                ...stepResult.metaData
+                            });
+                        }
+                    });
+                }
+                else {
+                    // For single step execution
+                    allResults.push(result);
+                    // Update context with successful result
+                    if (result.success && result.result !== null) {
+                        this.updateContext({
+                            [`step_${result.stepId}`]: result.result,
+                            ...result.metaData
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                const errorResult = {
+                    stepId: step.id,
+                    success: false,
+                    result: null,
+                    error: errorMessage
+                };
+                allResults.push(errorResult);
+                // Break on error (can be made configurable)
+                break;
+            }
+        }
+        this.stepResults = allResults;
+        return allResults;
+    }
+}
+exports.Workflow = Workflow;

package/dist/unified/agent/workflowControls.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class WorkflowControls {
+    constructor();
+}
+export declare class Parallel extends WorkflowControls {
+}
+export declare class Conditional extends WorkflowControls {
+}
+export declare class Step extends WorkflowControls {
+}
+export declare class Router extends WorkflowControls {
+}

package/dist/unified/agent/workflowControls.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = exports.Step = exports.Conditional = exports.Parallel = exports.WorkflowControls = void 0;
+class WorkflowControls {
+    constructor() {
+    }
+}
+exports.WorkflowControls = WorkflowControls;
+class Parallel extends WorkflowControls {
+}
+exports.Parallel = Parallel;
+class Conditional extends WorkflowControls {
+}
+exports.Conditional = Conditional;
+class Step extends WorkflowControls {
+}
+exports.Step = Step;
+class Router extends WorkflowControls {
+}
+exports.Router = Router;

package/dist/unified/agent/workflowSteps.d.ts

@@ -0,0 +1,63 @@
+import { AgentInterface, BaseWorkFlowStep, StepConfig, StepType, ToolInterface, workflowContext, workflowStepOutput } from "@codebolt/types/agent";
+import { ZodType } from "zod";
+export declare class ParallelStep implements BaseWorkFlowStep {
+    id: string;
+    description: string;
+    type: StepType;
+    inputSchema?: ZodType<any, any, any>;
+    outputSchema?: ZodType<any, any, any>;
+    private steps;
+    constructor(config: StepConfig, steps: WorkFlowStep[]);
+    execute(context: any): Promise<workflowContext>;
+}
+export declare class ConditionStep implements BaseWorkFlowStep {
+    id: string;
+    description: string;
+    type: StepType;
+    inputSchema?: ZodType<any, any, any>;
+    outputSchema?: ZodType<any, any, any>;
+    private steps;
+    constructor(config: StepConfig, steps: WorkFlowStep[]);
+    execute(context: any): Promise<workflowContext>;
+}
+export declare class LoopStep implements BaseWorkFlowStep {
+    id: string;
+    description: string;
+    type: StepType;
+    inputSchema?: ZodType<any, any, any>;
+    outputSchema?: ZodType<any, any, any>;
+    private steps;
+    private maxIterations;
+    constructor(config: StepConfig, steps: WorkFlowStep[], maxIterations?: number);
+    execute(context: any): Promise<workflowContext>;
+}
+export declare class WorkFlowStep implements BaseWorkFlowStep {
+    id: string;
+    description: string;
+    type: StepType;
+    inputSchema?: ZodType<any, any, any>;
+    outputSchema?: ZodType<any, any, any>;
+    private config;
+    constructor(config: StepConfig);
+    execute(context: any): Promise<workflowStepOutput>;
+}
+export declare class AgentStep implements BaseWorkFlowStep {
+    private agent;
+    id: string;
+    description: string;
+    type: StepType;
+    inputSchema?: ZodType<any, any, any>;
+    outputSchema?: ZodType<any, any, any>;
+    constructor(config: StepConfig, agent: AgentInterface);
+    execute(context: any): Promise<workflowStepOutput>;
+}
+export declare class ToolStep implements BaseWorkFlowStep {
+    private tool;
+    id: string;
+    description: string;
+    type: StepType;
+    inputSchema?: ZodType<any, any, any>;
+    outputSchema?: ZodType<any, any, any>;
+    constructor(config: StepConfig, tool: ToolInterface);
+    execute(context: any): Promise<workflowStepOutput>;
+}

package/dist/unified/agent/workflowSteps.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolStep = exports.AgentStep = exports.WorkFlowStep = exports.LoopStep = exports.ConditionStep = exports.ParallelStep = void 0;
+class ParallelStep {
+    constructor(config, steps) {
+        this.steps = steps;
+        this.id = config.id;
+        this.description = config.description;
+        this.type = config.type;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+    }
+    async execute(context) {
+        try {
+            // Execute all steps in parallel using Promise.all
+            const stepPromises = this.steps.map((step, index) => step.execute(context).catch(error => ({
+                stepId: `${this.id}_step_${index}`,
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            })));
+            const results = await Promise.all(stepPromises);
+            return results;
+        }
+        catch (error) {
+            // If Promise.all fails entirely, return error result
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return [{
+                    stepId: this.id,
+                    success: false,
+                    result: null,
+                    error: `Failed to execute parallel steps: ${errorMessage}`
+                }];
+        }
+    }
+}
+exports.ParallelStep = ParallelStep;
+class ConditionStep {
+    constructor(config, steps) {
+        this.steps = steps;
+        this.id = config.id;
+        this.description = config.description;
+        this.type = config.type;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+    }
+    async execute(context) {
+        try {
+            // For condition step, execute steps sequentially based on conditions
+            // This is a basic implementation - you may want to add condition logic
+            const results = [];
+            for (let i = 0; i < this.steps.length; i++) {
+                const step = this.steps[i];
+                try {
+                    const result = await step.execute(context);
+                    results.push(result);
+                    // If step fails and it's a condition, you might want to break or continue
+                    // This depends on your condition logic
+                    if (!result.success) {
+                        break; // Stop on first failure for condition step
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                    results.push({
+                        stepId: `${this.id}_step_${i}`,
+                        success: false,
+                        result: null,
+                        error: errorMessage
+                    });
+                    break; // Stop on error
+                }
+            }
+            return results;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return [{
+                    stepId: this.id,
+                    success: false,
+                    result: null,
+                    error: `Failed to execute condition steps: ${errorMessage}`
+                }];
+        }
+    }
+}
+exports.ConditionStep = ConditionStep;
+class LoopStep {
+    constructor(config, steps, maxIterations = 10) {
+        this.steps = steps;
+        this.id = config.id;
+        this.description = config.description;
+        this.type = config.type;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+        this.maxIterations = maxIterations;
+    }
+    async execute(context) {
+        try {
+            const allResults = [];
+            let iteration = 0;
+            let shouldContinue = true;
+            while (shouldContinue && iteration < this.maxIterations) {
+                const iterationResults = [];
+                // Execute all steps in this iteration
+                for (let i = 0; i < this.steps.length; i++) {
+                    const step = this.steps[i];
+                    try {
+                        const result = await step.execute(context);
+                        result.stepId = `${result.stepId}_loop_${iteration}`;
+                        iterationResults.push(result);
+                        // You can add loop exit conditions based on step results
+                        // For example, stop if a specific condition is met
+                        if (!result.success) {
+                            shouldContinue = false;
+                            break;
+                        }
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                        iterationResults.push({
+                            stepId: `${this.id}_step_${i}_loop_${iteration}`,
+                            success: false,
+                            result: null,
+                            error: errorMessage
+                        });
+                        shouldContinue = false;
+                        break;
+                    }
+                }
+                allResults.push(...iterationResults);
+                iteration++;
+                // You can add custom loop continuation logic here
+                // For now, it continues until max iterations or failure
+            }
+            return allResults;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return [{
+                    stepId: this.id,
+                    success: false,
+                    result: null,
+                    error: `Failed to execute loop steps: ${errorMessage}`
+                }];
+        }
+    }
+}
+exports.LoopStep = LoopStep;
+class WorkFlowStep {
+    constructor(config) {
+        this.config = config;
+        this.id = config.id;
+        this.description = config.description;
+        this.type = config.type;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+    }
+    async execute(context) {
+        try {
+            const result = await this.config.execute(context);
+            return {
+                stepId: this.config.id,
+                success: true,
+                result: result,
+                metaData: context
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                stepId: this.config.id,
+                success: false,
+                result: null,
+                error: errorMessage
+            };
+        }
+    }
+}
+exports.WorkFlowStep = WorkFlowStep;
+class AgentStep {
+    constructor(config, agent) {
+        this.agent = agent;
+        this.id = config.id;
+        this.description = config.description;
+        this.type = config.type;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+    }
+    async execute(context) {
+        let { result, success, error } = await this.agent.execute(context);
+        return {
+            stepId: this.id,
+            success: success,
+            result: result,
+            error: error
+        };
+    }
+}
+exports.AgentStep = AgentStep;
+class ToolStep {
+    constructor(config, tool) {
+        this.id = config.id;
+        this.description = config.description;
+        this.type = config.type;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+        this.tool = tool;
+    }
+    async execute(context) {
+        try {
+            let { result, success, error } = await this.tool.execute({}, context);
+            return {
+                stepId: this.id,
+                success: success,
+                result: result,
+                error: error
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                stepId: this.id,
+                success: false,
+                result: null,
+                error: errorMessage
+            };
+        }
+    }
+}
+exports.ToolStep = ToolStep;
+// export class parllelAgentStep implements BaseWorkFlowStep{
+//     private agents: AgentInterface[]
+//     private config: StepConfig
+//     constructor(config: StepConfig, agents: AgentInterface[]) {
+//         super(config)
+//         this.config = config
+//         this.agents = agents
+//     }
+//     async execute(context: any): Promise<workflowStepOutput> {
+//         try {
+//             // Execute all agents in parallel using Promise.all
+//             const agentPromises = this.agents.map((agent, index) => 
+//                 agent.execute().then(result => ({
+//                     agentIndex: index,
+//                     ...result
+//                 })).catch(error => ({
+//                     agentIndex: index,
+//                     success: false,
+//                     result: null,
+//                     error: error instanceof Error ? error.message : 'Unknown error occurred'
+//                 }))
+//             );
+//             const results = await Promise.all(agentPromises);
+//             // Aggregate results
+//             const successfulResults = results.filter(result => result.success);
+//             const failedResults = results.filter(result => !result.success);
+//             const overallSuccess = failedResults.length === 0;
+//             return {
+//                 stepId: this.id,
+//                 success: overallSuccess,
+//                 result: {
+//                     totalAgents: this.agents.length,
+//                     successfulAgents: successfulResults.length,
+//                     failedAgents: failedResults.length,
+//                     results: results,
+//                     successfulResults: successfulResults.map(r => r.result),
+//                     errors: failedResults.map(r => ({ agentIndex: r.agentIndex, error: r.error }))
+//                 },
+//                 error: failedResults.length > 0 ? 
+//                     `${failedResults.length} out of ${this.agents.length} agents failed` : 
+//                     undefined
+//             };
+//         } catch (error) {
+//             const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+//             return {
+//                 stepId: this.id,
+//                 success: false,
+//                 result: null,
+//                 error: `Failed to execute parallel agents: ${errorMessage}`
+//             };
+//         }
+//     }
+// }

package/dist/unified/base/agentStep.d.ts

@@ -0,0 +1,32 @@
+import { PostInferenceProcessor, PreInferenceProcessor, AgentStepInterface, AgentStepOutput, ProcessedMessage } from '@codebolt/types/agent';
+import { FlatUserMessage } from '@codebolt/types/sdk';
+/**
+ * Unified agent step that handles LLM interaction and tool call analysis
+ */
+export declare class AgentStep implements AgentStepInterface {
+    private preInferenceProcessors;
+    private postInferenceProcessors;
+    private llmRole;
+    constructor(options?: {
+        preInferenceProcessors?: PreInferenceProcessor[];
+        postInferenceProcessors?: PostInferenceProcessor[];
+        llmRole?: string;
+    });
+    /**
+     * Execute a single agent step
+     */
+    executeStep(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<AgentStepOutput>;
+    private generateResponse;
+    /**
+     * Update LLM configuration
+     */
+    setLLMConfig(config: string): void;
+    /**
+     * Get current LLM configuration
+     */
+    getLLMConfig(): string;
+    updatePreInferenceProcessors(processors: PreInferenceProcessor[]): void;
+    getPreInferenceProcessors(): PreInferenceProcessor[];
+    updatePostInferenceProcessors(processors: PostInferenceProcessor[]): void;
+    getPostInferenceProcessors(): PostInferenceProcessor[];
+}