@codebolt/agent 5.0.8 → 5.0.9

package/dist/composablepattern/workflow.js

@@ -1,562 +0,0 @@
-"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/followupquestionbuilder.d.ts

@@ -1,75 +0,0 @@
-import type { OpenAIMessage, OpenAITool, ToolResult, CodeboltAPI } from "./types/libFunctionTypes";
-/**
- * Builds follow-up prompts for continuing conversations with tool results.
- * Manages conversation history and summarization when conversations get too long.
- */
-declare class FollowUpPromptBuilder {
-    /** Previous conversation messages */
-    private previousConversation;
-    /** Tool results to add to the conversation */
-    private toolResults;
-    /** Available tools for the conversation */
-    private tools;
-    /** The last LLM response, if available */
-    private llmResponse?;
-    /** Maximum conversation length before summarization */
-    private maxConversationLength;
-    /** Whether to force summarization */
-    private forceSummarization;
-    /** Codebolt API instance */
-    private codebolt?;
-    /**
-     * Creates a new FollowUpQuestionBuilder instance.
-     *
-     * @param codebolt - Optional codebolt API instance
-     */
-    constructor(codebolt?: CodeboltAPI);
-    /**
-     * Adds the previous conversation to the builder.
-     *
-     * @param previousPrompt - The previous prompt object containing messages and tools
-     * @returns The FollowUpQuestionBuilder instance for chaining
-     */
-    addPreviousConversation(previousPrompt: {
-        messages: OpenAIMessage[];
-        tools: OpenAITool[];
-        tool_choice?: string;
-    }, llmResponse: {
-        completion: any;
-    }): this;
-    addLLMResponseToConverstaion(llmResponse: {
-        completion: any;
-    }): this;
-    /**
-     * Adds tool execution results to the conversation.
-     *
-     * @param toolResults - Array of tool execution results
-     * @returns The FollowUpQuestionBuilder instance for chaining
-     */
-    addToolResult(toolResults: ToolResult[]): this;
-    /**
-     * Checks if the conversation is too long and sets up summarization with custom max length.
-     *
-     * @param maxLength - Maximum number of messages before summarization
-     * @returns The FollowUpQuestionBuilder instance for chaining
-     */
-    checkAndSummarizeConversationIfLong(maxLength: number): this;
-    /**
-     * Performs conversation summarization if needed.
-     *
-     * @returns Promise that resolves to the summarized messages
-     */
-    private performSummarization;
-    /**
-     * Builds the follow-up conversation prompt with tool results.
-     *
-     * @returns Promise that resolves to the conversation prompt object
-     */
-    build(): Promise<{
-        messages: OpenAIMessage[];
-        tools: OpenAITool[];
-        tool_choice: "auto";
-        full: boolean;
-    }>;
-}
-export { FollowUpPromptBuilder };