@codebolt/agent 5.0.8 → 5.0.9

package/dist/composablepattern/examples/codebolt-storage-example.js

@@ -1,223 +0,0 @@
-"use strict";
-/**
- * @fileoverview Example demonstrating CodeBolt backend storage for ComposableAgent
- * @description Shows how to use CodeBolt's state and memory functions instead of SQLite
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.knowledgeAgentWithDbStorage = exports.taskAgentWithProjectStorage = exports.weatherAgentWithAgentStorage = void 0;
-exports.setupCodeBoltStorageExample = setupCodeBoltStorageExample;
-exports.createCustomStorageAgent = createCustomStorageAgent;
-exports.setupMultiStorageAgents = setupMultiStorageAgents;
-exports.storageComparison = storageComparison;
-const index_1 = require("../index");
-const zod_1 = require("zod");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-/**
- * Example: Weather Agent with CodeBolt Agent State Storage
- * Data is stored in CodeBolt's agent state backend
- */
-exports.weatherAgentWithAgentStorage = new index_1.ComposableAgent({
-    name: 'Weather Agent',
-    instructions: `
-    You are a helpful weather assistant that provides accurate weather information.
-    Always ask for a location if none is provided.
-    Keep responses concise but informative.
-  `,
-    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
-    tools: {
-        weatherTool: (0, index_1.createTool)({
-            id: 'get-weather',
-            description: 'Get current weather for a location',
-            inputSchema: zod_1.z.object({
-                location: zod_1.z.string().describe('City name'),
-            }),
-            outputSchema: zod_1.z.object({
-                temperature: zod_1.z.number(),
-                conditions: zod_1.z.string(),
-                location: zod_1.z.string(),
-            }),
-            execute: async ({ context }) => {
-                // Mock weather data
-                return {
-                    temperature: 22,
-                    conditions: 'Partly cloudy',
-                    location: context.location
-                };
-            },
-        })
-    },
-    // Use CodeBolt agent state for memory storage
-    memory: (0, index_1.createCodeBoltAgentMemory)('weather_agent'),
-    maxTurns: 10
-});
-/**
- * Example: Task Management Agent with CodeBolt Project State Storage
- * Data is stored in CodeBolt's project state backend
- */
-exports.taskAgentWithProjectStorage = new index_1.ComposableAgent({
-    name: 'Task Manager',
-    instructions: `
-    You are a task management assistant that helps users organize their work.
-    You can create, list, update, and complete tasks.
-    Keep track of task status and priorities.
-  `,
-    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
-    tools: {
-        createTaskTool: (0, index_1.createTool)({
-            id: 'create-task',
-            description: 'Create a new task',
-            inputSchema: zod_1.z.object({
-                title: zod_1.z.string().describe('Task title'),
-                description: zod_1.z.string().optional().describe('Task description'),
-                priority: zod_1.z.enum(['low', 'medium', 'high']).default('medium'),
-            }),
-            outputSchema: zod_1.z.object({
-                taskId: zod_1.z.string(),
-                title: zod_1.z.string(),
-                status: zod_1.z.string(),
-            }),
-            execute: async ({ context }) => {
-                const taskId = `task_${Date.now()}`;
-                return {
-                    taskId,
-                    title: context.title,
-                    status: 'created'
-                };
-            },
-        })
-    },
-    // Use CodeBolt project state for memory storage
-    memory: (0, index_1.createCodeBoltProjectMemory)('task_agent'),
-    maxTurns: 15
-});
-/**
- * Example: Knowledge Agent with CodeBolt Memory Database Storage
- * Data is stored in CodeBolt's in-memory database backend
- */
-exports.knowledgeAgentWithDbStorage = new index_1.ComposableAgent({
-    name: 'Knowledge Assistant',
-    instructions: `
-    You are a knowledge management assistant that helps users store and retrieve information.
-    You can save facts, remember conversations, and answer questions based on stored knowledge.
-  `,
-    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
-    tools: {
-        saveKnowledgeTool: (0, index_1.createTool)({
-            id: 'save-knowledge',
-            description: 'Save a piece of knowledge',
-            inputSchema: zod_1.z.object({
-                topic: zod_1.z.string().describe('Knowledge topic'),
-                content: zod_1.z.string().describe('Knowledge content'),
-                tags: zod_1.z.array(zod_1.z.string()).optional().describe('Optional tags'),
-            }),
-            outputSchema: zod_1.z.object({
-                success: zod_1.z.boolean(),
-                knowledgeId: zod_1.z.string(),
-            }),
-            execute: async ({ context }) => {
-                const knowledgeId = `knowledge_${Date.now()}`;
-                return {
-                    success: true,
-                    knowledgeId
-                };
-            },
-        })
-    },
-    // Use CodeBolt memory database for storage
-    memory: (0, index_1.createCodeBoltDbMemory)('knowledge_agent'),
-    maxTurns: 20
-});
-/**
- * Example usage within CodeBolt onMessage
- */
-function setupCodeBoltStorageExample() {
-    codeboltjs_1.default.onMessage(async (reqMessage) => {
-        try {
-            // Example 1: Weather agent with agent state storage
-            if (reqMessage.userMessage.includes('weather')) {
-                const result = await exports.weatherAgentWithAgentStorage.run();
-                return result.message;
-            }
-            // Example 2: Task agent with project state storage
-            if (reqMessage.userMessage.includes('task')) {
-                const result = await exports.taskAgentWithProjectStorage.run();
-                return result.message;
-            }
-            // Example 3: Knowledge agent with memory database storage
-            if (reqMessage.userMessage.includes('knowledge') || reqMessage.userMessage.includes('remember')) {
-                const result = await exports.knowledgeAgentWithDbStorage.run();
-                return result.message;
-            }
-            return 'Please specify what you need help with: weather, tasks, or knowledge management.';
-        }
-        catch (error) {
-            console.error('Agent execution error:', error);
-            return 'Sorry, I encountered an error while processing your request.';
-        }
-    });
-}
-/**
- * Example: Custom storage configuration
- */
-function createCustomStorageAgent() {
-    return new index_1.ComposableAgent({
-        name: 'Custom Storage Agent',
-        instructions: 'I use custom storage prefixes to avoid conflicts.',
-        model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
-        // Use custom prefix to avoid storage conflicts
-        memory: (0, index_1.createCodeBoltAgentMemory)('my_app_agent_v2'),
-        maxTurns: 10
-    });
-}
-/**
- * Example: Multiple agents with different storage backends
- */
-function setupMultiStorageAgents() {
-    const sessionAgent = new index_1.ComposableAgent({
-        name: 'Session Agent',
-        instructions: 'I handle session-specific data.',
-        model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
-        // Session data stored in agent state
-        memory: (0, index_1.createCodeBoltAgentMemory)('session'),
-    });
-    const globalAgent = new index_1.ComposableAgent({
-        name: 'Global Agent',
-        instructions: 'I handle project-wide data.',
-        model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
-        // Global data stored in project state
-        memory: (0, index_1.createCodeBoltProjectMemory)('global'),
-    });
-    const cacheAgent = new index_1.ComposableAgent({
-        name: 'Cache Agent',
-        instructions: 'I handle temporary cached data.',
-        model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
-        // Cache data stored in memory database
-        memory: (0, index_1.createCodeBoltDbMemory)('cache'),
-    });
-    return { sessionAgent, globalAgent, cacheAgent };
-}
-/**
- * Storage comparison and migration helper
- */
-async function storageComparison() {
-    console.log('=== CodeBolt Storage Options ===');
-    console.log('1. Agent State Storage:');
-    console.log('   - Persisted across agent sessions');
-    console.log('   - Scoped to agent/user context');
-    console.log('   - Best for: User preferences, agent settings');
-    console.log('2. Project State Storage:');
-    console.log('   - Persisted across project sessions');
-    console.log('   - Scoped to current project');
-    console.log('   - Best for: Project-specific data, global settings');
-    console.log('3. Memory Database Storage:');
-    console.log('   - Fast in-memory access');
-    console.log('   - May not persist across restarts');
-    console.log('   - Best for: Temporary data, caching, session data');
-    console.log('4. Migration from SQLite:');
-    console.log('   - No need for external database dependencies');
-    console.log('   - Seamless integration with CodeBolt ecosystem');
-    console.log('   - Automatic backup and sync (if supported by CodeBolt)');
-}

package/dist/composablepattern/examples/custom-steps-example.d.ts

@@ -1,20 +0,0 @@
-/**
- * @fileoverview Custom Step Creation Examples
- * @description Examples showing how to create custom workflow steps with your own logic
- */
-/**
- * E-commerce order processing workflow
- */
-export declare const orderProcessingWorkflow: import("../workflow").Workflow;
-/**
- * Data analysis workflow
- */
-export declare const dataAnalysisWorkflow: import("../workflow").Workflow;
-/**
- * Text processing workflow
- */
-export declare const textProcessingWorkflow: import("../workflow").Workflow;
-export declare function runOrderProcessingExample(): Promise<import("../workflow").WorkflowResult>;
-export declare function runDataAnalysisExample(): Promise<import("../workflow").WorkflowResult>;
-export declare function runTextProcessingExample(): Promise<import("../workflow").WorkflowResult>;
-export declare function runAllCustomStepExamples(): Promise<void>;

package/dist/composablepattern/examples/custom-steps-example.js

@@ -1,455 +0,0 @@
-"use strict";
-/**
- * @fileoverview Custom Step Creation Examples
- * @description Examples showing how to create custom workflow steps with your own logic
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.textProcessingWorkflow = exports.dataAnalysisWorkflow = exports.orderProcessingWorkflow = void 0;
-exports.runOrderProcessingExample = runOrderProcessingExample;
-exports.runDataAnalysisExample = runDataAnalysisExample;
-exports.runTextProcessingExample = runTextProcessingExample;
-exports.runAllCustomStepExamples = runAllCustomStepExamples;
-const index_1 = require("../index");
-// ================================
-// Basic Custom Step Examples
-// ================================
-/**
- * Example: Simple math calculation step
- */
-const mathStep = (0, index_1.createSimpleStep)({
-    id: 'calculate-total',
-    name: 'Calculate Order Total',
-    description: 'Calculate total price with tax and shipping',
-    inputSchema: index_1.z.object({
-        items: index_1.z.array(index_1.z.object({
-            price: index_1.z.number(),
-            quantity: index_1.z.number()
-        })),
-        taxRate: index_1.z.number().default(0.08),
-        shippingCost: index_1.z.number().default(10)
-    }),
-    execute: (data) => {
-        const subtotal = data.items.reduce((sum, item) => sum + (item.price * item.quantity), 0);
-        const tax = subtotal * data.taxRate;
-        const total = subtotal + tax + data.shippingCost;
-        return {
-            subtotal,
-            tax,
-            shipping: data.shippingCost,
-            total,
-            itemCount: data.items.length
-        };
-    }
-});
-/**
- * Example: String processing step
- */
-const textProcessingStep = (0, index_1.createSimpleStep)({
-    id: 'process-text',
-    name: 'Process Text Data',
-    execute: (data) => {
-        const text = data.rawText || '';
-        return {
-            processedText: text.toLowerCase().trim(),
-            wordCount: text.split(/\s+/).filter((w) => w.length > 0).length,
-            characterCount: text.length,
-            sentences: text.split(/[.!?]+/).filter((s) => s.trim().length > 0).length,
-            containsEmail: /\S+@\S+\.\S+/.test(text),
-            containsPhone: /\d{3}-\d{3}-\d{4}/.test(text)
-        };
-    }
-});
-/**
- * Example: Async API call step
- */
-const fetchDataStep = (0, index_1.createAsyncStep)({
-    id: 'fetch-user-data',
-    name: 'Fetch User Information',
-    description: 'Fetch user data from external API',
-    retry: {
-        maxAttempts: 3,
-        delay: 1000,
-        backoff: 'exponential'
-    },
-    execute: async (data, context) => {
-        // Simulate API call
-        const userId = data.userId;
-        // Mock API response (in real usage, this would be an actual fetch call)
-        await new Promise(resolve => setTimeout(resolve, 500)); // Simulate network delay
-        const userData = {
-            id: userId,
-            name: 'John Doe',
-            email: 'john.doe@example.com',
-            preferences: {
-                theme: 'dark',
-                notifications: true
-            },
-            lastLogin: new Date().toISOString()
-        };
-        return { userData };
-    }
-});
-/**
- * Example: Advanced custom step with full control
- */
-const advancedProcessingStep = (0, index_1.createStep)({
-    id: 'advanced-processing',
-    name: 'Advanced Data Processing',
-    description: 'Complex data processing with validation and error handling',
-    inputSchema: index_1.z.object({
-        dataset: index_1.z.array(index_1.z.record(index_1.z.any())),
-        processingOptions: index_1.z.object({
-            filterBy: index_1.z.string().optional(),
-            sortBy: index_1.z.string().optional(),
-            groupBy: index_1.z.string().optional()
-        }).optional()
-    }),
-    execute: async (context) => {
-        const { dataset, processingOptions = {} } = context.data;
-        try {
-            let processedData = [...dataset];
-            // Apply filtering
-            if (processingOptions.filterBy) {
-                processedData = processedData.filter(item => item[processingOptions.filterBy] !== undefined);
-            }
-            // Apply sorting
-            if (processingOptions.sortBy) {
-                processedData.sort((a, b) => {
-                    const aVal = a[processingOptions.sortBy];
-                    const bVal = b[processingOptions.sortBy];
-                    return aVal > bVal ? 1 : aVal < bVal ? -1 : 0;
-                });
-            }
-            // Apply grouping
-            let groupedData = null;
-            if (processingOptions.groupBy) {
-                groupedData = processedData.reduce((groups, item) => {
-                    const key = item[processingOptions.groupBy];
-                    if (!groups[key])
-                        groups[key] = [];
-                    groups[key].push(item);
-                    return groups;
-                }, {});
-            }
-            return {
-                stepId: 'advanced-processing',
-                success: true,
-                output: {
-                    processedData,
-                    groupedData,
-                    statistics: {
-                        originalCount: dataset.length,
-                        processedCount: processedData.length,
-                        processingOptions
-                    }
-                },
-                executionTime: 0
-            };
-        }
-        catch (error) {
-            return {
-                stepId: 'advanced-processing',
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                executionTime: 0
-            };
-        }
-    }
-});
-/**
- * Example: Conditional step based on data
- */
-const conditionalStep = (0, index_1.createStep)({
-    id: 'conditional-logic',
-    name: 'Conditional Processing',
-    condition: (context) => context.data.shouldProcess === true,
-    execute: async (context) => {
-        const processingType = context.data.processingType || 'default';
-        let result;
-        switch (processingType) {
-            case 'fast':
-                result = { processed: true, method: 'fast', duration: 100 };
-                break;
-            case 'thorough':
-                result = { processed: true, method: 'thorough', duration: 500 };
-                break;
-            default:
-                result = { processed: true, method: 'default', duration: 200 };
-        }
-        return {
-            stepId: 'conditional-logic',
-            success: true,
-            output: result,
-            executionTime: 0
-        };
-    }
-});
-// ================================
-// Workflow Examples Using Custom Steps
-// ================================
-/**
- * E-commerce order processing workflow
- */
-exports.orderProcessingWorkflow = (0, index_1.createWorkflow)({
-    name: 'Order Processing Pipeline',
-    description: 'Process e-commerce orders with calculations, validation, and data fetching',
-    initialData: {
-        orderId: 'ORD-12345',
-        userId: 'USER-789',
-        items: [
-            { price: 29.99, quantity: 2 },
-            { price: 15.50, quantity: 1 }
-        ],
-        taxRate: 0.08,
-        shippingCost: 10
-    },
-    steps: [
-        // Step 1: Log the start
-        (0, index_1.createLoggingStep)({
-            id: 'log-start',
-            name: 'Log Order Start',
-            level: 'info',
-            message: 'Starting order processing',
-            fields: ['orderId', 'userId']
-        }),
-        // Step 2: Validate order data
-        (0, index_1.createValidationStep)({
-            id: 'validate-order',
-            name: 'Validate Order',
-            schema: index_1.z.object({
-                orderId: index_1.z.string(),
-                userId: index_1.z.string(),
-                items: index_1.z.array(index_1.z.object({
-                    price: index_1.z.number().positive(),
-                    quantity: index_1.z.number().int().positive()
-                })).min(1)
-            }),
-            stopOnFailure: true
-        }),
-        // Step 3: Calculate totals
-        mathStep,
-        // Step 4: Fetch user data (parallel with calculations)
-        fetchDataStep,
-        // Step 5: Process order summary
-        (0, index_1.createSimpleStep)({
-            id: 'create-summary',
-            name: 'Create Order Summary',
-            dependencies: ['calculate-total', 'fetch-user-data'],
-            execute: (data) => ({
-                orderSummary: {
-                    orderId: data.orderId,
-                    customer: data.userData,
-                    billing: {
-                        subtotal: data.subtotal,
-                        tax: data.tax,
-                        shipping: data.shipping,
-                        total: data.total
-                    },
-                    items: data.items,
-                    processedAt: new Date().toISOString()
-                }
-            })
-        }),
-        // Step 6: Log completion
-        (0, index_1.createLoggingStep)({
-            id: 'log-completion',
-            name: 'Log Order Completion',
-            level: 'info',
-            message: 'Order processing completed',
-            fields: ['orderId', 'total']
-        })
-    ]
-});
-/**
- * Data analysis workflow
- */
-exports.dataAnalysisWorkflow = (0, index_1.createWorkflow)({
-    name: 'Data Analysis Pipeline',
-    description: 'Analyze dataset with preprocessing, validation, and statistics',
-    initialData: {
-        dataset: [
-            { id: 1, name: 'Alice', age: 25, department: 'Engineering' },
-            { id: 2, name: 'Bob', age: 30, department: 'Marketing' },
-            { id: 3, name: 'Charlie', age: 35, department: 'Engineering' },
-            { id: 4, name: 'Diana', age: 28, department: 'Sales' }
-        ],
-        processingOptions: {
-            sortBy: 'age',
-            groupBy: 'department'
-        }
-    },
-    steps: [
-        // Step 1: Validate dataset
-        (0, index_1.createValidationStep)({
-            id: 'validate-dataset',
-            name: 'Validate Dataset',
-            field: 'dataset',
-            schema: index_1.z.array(index_1.z.object({
-                id: index_1.z.number(),
-                name: index_1.z.string(),
-                age: index_1.z.number(),
-                department: index_1.z.string()
-            })).min(1)
-        }),
-        // Step 2: Advanced processing
-        advancedProcessingStep,
-        // Step 3: Calculate statistics
-        (0, index_1.createSimpleStep)({
-            id: 'calculate-stats',
-            name: 'Calculate Statistics',
-            execute: (data) => {
-                const dataset = data.processedData;
-                const ages = dataset.map((item) => item.age);
-                return {
-                    statistics: {
-                        totalRecords: dataset.length,
-                        averageAge: ages.reduce((sum, age) => sum + age, 0) / ages.length,
-                        minAge: Math.min(...ages),
-                        maxAge: Math.max(...ages),
-                        departments: [...new Set(dataset.map((item) => item.department))],
-                        groupSizes: Object.entries(data.groupedData || {}).map(([dept, items]) => ({
-                            department: dept,
-                            count: items.length
-                        }))
-                    }
-                };
-            }
-        }),
-        // Step 4: Generate report
-        (0, index_1.createSimpleStep)({
-            id: 'generate-report',
-            name: 'Generate Analysis Report',
-            execute: (data) => ({
-                report: {
-                    summary: `Analyzed ${data.statistics.totalRecords} records`,
-                    demographics: {
-                        averageAge: data.statistics.averageAge,
-                        ageRange: `${data.statistics.minAge} - ${data.statistics.maxAge}`
-                    },
-                    departments: data.statistics.departments,
-                    groupBreakdown: data.statistics.groupSizes,
-                    generatedAt: new Date().toISOString()
-                }
-            })
-        })
-    ]
-});
-/**
- * Text processing workflow
- */
-exports.textProcessingWorkflow = (0, index_1.createWorkflow)({
-    name: 'Text Processing Pipeline',
-    description: 'Process and analyze text content',
-    initialData: {
-        rawText: `
-      Hello! My name is John Doe. You can reach me at john.doe@example.com 
-      or call me at 555-123-4567. I'm excited to work with your team on this 
-      new project. We have three main goals: improve efficiency, reduce costs, 
-      and enhance user experience.
-    `,
-        shouldProcess: true,
-        processingType: 'thorough'
-    },
-    steps: [
-        // Step 1: Basic text processing
-        textProcessingStep,
-        // Step 2: Conditional advanced processing
-        conditionalStep,
-        // Step 3: Extract entities
-        (0, index_1.createSimpleStep)({
-            id: 'extract-entities',
-            name: 'Extract Entities',
-            execute: (data) => {
-                const text = data.processedText || data.rawText;
-                // Simple entity extraction (in real usage, you might use NLP libraries)
-                const emails = text.match(/\S+@\S+\.\S+/g) || [];
-                const phones = text.match(/\d{3}-\d{3}-\d{4}/g) || [];
-                const names = text.match(/[A-Z][a-z]+ [A-Z][a-z]+/g) || [];
-                return {
-                    entities: {
-                        emails,
-                        phones,
-                        names,
-                        total: emails.length + phones.length + names.length
-                    }
-                };
-            }
-        }),
-        // Step 4: Create analysis summary
-        (0, index_1.createSimpleStep)({
-            id: 'create-text-summary',
-            name: 'Create Text Analysis Summary',
-            execute: (data) => ({
-                textAnalysis: {
-                    content: {
-                        wordCount: data.wordCount,
-                        characterCount: data.characterCount,
-                        sentences: data.sentences
-                    },
-                    entities: data.entities,
-                    processingMethod: data.method || 'none',
-                    containsPersonalInfo: data.containsEmail || data.containsPhone,
-                    analysisScore: Math.min(10, (data.wordCount / 10) + data.entities.total)
-                }
-            })
-        })
-    ]
-});
-// ================================
-// Example Usage Functions
-// ================================
-async function runOrderProcessingExample() {
-    console.log('Running order processing workflow...');
-    const result = await exports.orderProcessingWorkflow.execute();
-    if (result.success) {
-        console.log('Order processed successfully!');
-        console.log('Order summary:', result.data.orderSummary);
-    }
-    else {
-        console.error('Order processing failed:', result.error);
-    }
-    return result;
-}
-async function runDataAnalysisExample() {
-    console.log('Running data analysis workflow...');
-    const result = await exports.dataAnalysisWorkflow.execute();
-    if (result.success) {
-        console.log('Data analysis completed!');
-        console.log('Report:', result.data.report);
-    }
-    else {
-        console.error('Data analysis failed:', result.error);
-    }
-    return result;
-}
-async function runTextProcessingExample() {
-    console.log('Running text processing workflow...');
-    const result = await exports.textProcessingWorkflow.execute();
-    if (result.success) {
-        console.log('Text processing completed!');
-        console.log('Analysis:', result.data.textAnalysis);
-    }
-    else {
-        console.error('Text processing failed:', result.error);
-    }
-    return result;
-}
-// Run all examples
-async function runAllCustomStepExamples() {
-    try {
-        console.log('=== Running All Custom Step Examples ===\n');
-        await runOrderProcessingExample();
-        console.log('\n' + '='.repeat(50) + '\n');
-        await runDataAnalysisExample();
-        console.log('\n' + '='.repeat(50) + '\n');
-        await runTextProcessingExample();
-        console.log('\n=== All Custom Step Examples Completed ===');
-    }
-    catch (error) {
-        console.error('Example execution failed:', error);
-    }
-}
-// Run examples if this file is executed directly
-if (require.main === module) {
-    runAllCustomStepExamples().catch(console.error);
-}