@codebolt/agent 1.2.1 → 2.2.2

package/dist/composablepattern/examples/document-agent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Document Agent Example
+ * @description Example showing how to create a document processing agent using the composable pattern
+ */
+import { ComposableAgent } from '../index';
+export declare const processDocumentTool: import("../types").Tool<{
+    content: string;
+    operation: "summarize" | "extract_keywords" | "chunk" | "analyze";
+}, {
+    result: string;
+    metadata: Record<string, any>;
+} | {
+    result: string;
+    metadata?: undefined;
+}>;
+export declare const documentAgent: ComposableAgent;
+export declare function runDocumentExample(): Promise<import("../types").ExecutionResult>;

package/dist/composablepattern/examples/document-agent.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * @fileoverview Document Agent Example
+ * @description Example showing how to create a document processing agent using the composable pattern
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentAgent = exports.processDocumentTool = void 0;
+exports.runDocumentExample = runDocumentExample;
+const index_1 = require("../index");
+// Create document processing tool
+exports.processDocumentTool = (0, index_1.createTool)({
+    id: 'process-document',
+    description: 'Process and analyze a document',
+    inputSchema: index_1.z.object({
+        content: index_1.z.string().describe('Document content to process'),
+        operation: index_1.z.enum(['summarize', 'extract_keywords', 'chunk', 'analyze']).describe('Operation to perform')
+    }),
+    outputSchema: index_1.z.object({
+        result: index_1.z.string(),
+        metadata: index_1.z.record(index_1.z.any()).optional()
+    }),
+    execute: async ({ context }) => {
+        const doc = index_1.MDocument.fromText(context.content);
+        switch (context.operation) {
+            case 'summarize':
+                // Simple summarization (in real usage, you might use an LLM for this)
+                const words = context.content.split(/\s+/);
+                const summary = words.slice(0, 50).join(' ') + (words.length > 50 ? '...' : '');
+                return {
+                    result: `Summary: ${summary}`,
+                    metadata: doc.getMetadata()
+                };
+            case 'extract_keywords':
+                // Simple keyword extraction
+                const keywordPattern = /\b[A-Z][a-z]+\b/g;
+                const keywords = [...new Set(context.content.match(keywordPattern) || [])].slice(0, 10);
+                return {
+                    result: `Keywords: ${keywords.join(', ')}`,
+                    metadata: { keywordCount: keywords.length }
+                };
+            case 'chunk':
+                const chunks = doc.chunk({ size: 500, strategy: 'paragraph' });
+                return {
+                    result: `Document chunked into ${chunks.length} pieces`,
+                    metadata: { chunkCount: chunks.length, chunks: chunks.slice(0, 3) }
+                };
+            case 'analyze':
+                const metadata = doc.getMetadata();
+                return {
+                    result: `Document analysis: ${metadata.wordCount} words, ${metadata.charCount} characters`,
+                    metadata
+                };
+            default:
+                return { result: 'Unknown operation' };
+        }
+    },
+});
+// Create a document from sample text
+const doc = index_1.MDocument.fromText(`
+  Climate change poses significant challenges to global agriculture.
+  Rising temperatures and changing precipitation patterns affect crop yields.
+  Farmers worldwide are adapting their practices to mitigate these impacts.
+  
+  Sustainable farming techniques, including crop rotation and precision agriculture,
+  are becoming increasingly important. Technology plays a crucial role in
+  monitoring soil conditions and optimizing resource usage.
+`);
+// Create document agent
+exports.documentAgent = new index_1.ComposableAgent({
+    name: 'Document Processing Agent',
+    instructions: `
+    You are a helpful document processing assistant that can analyze, summarize, and extract information from documents.
+    
+    Your capabilities include:
+    - Summarizing document content
+    - Extracting keywords and key topics
+    - Chunking documents for processing
+    - Analyzing document structure and metadata
+    
+    Use the process-document tool to perform these operations.
+  `,
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    tools: { processDocumentTool: exports.processDocumentTool },
+    memory: (0, index_1.createCodeBoltAgentMemory)()
+});
+// Example usage
+async function runDocumentExample() {
+    try {
+        console.log('Running document processing agent example...');
+        const result = await exports.documentAgent.execute(`Please analyze this document about climate change and agriculture: "${doc.getContent()}"`);
+        if (result.success) {
+            console.log('Agent response:', result.message);
+        }
+        else {
+            console.error('Agent failed:', result.error);
+        }
+        return result;
+    }
+    catch (error) {
+        console.error('Example failed:', error);
+        throw error;
+    }
+}
+// Run example if this file is executed directly
+if (require.main === module) {
+    runDocumentExample().catch(console.error);
+}

package/dist/composablepattern/examples/simple-codebolt-integration.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Simple CodeBolt Integration Example
+ * @description Shows the new simplified integration where codeboltjs automatically saves user messages
+ */
+declare const myAgent: any;
+declare const researchAgent: any;
+declare const writingAgent: any;
+export { myAgent, researchAgent, writingAgent };

package/dist/composablepattern/examples/simple-codebolt-integration.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * @fileoverview Simple CodeBolt Integration Example
+ * @description Shows the new simplified integration where codeboltjs automatically saves user messages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writingAgent = exports.researchAgent = exports.myAgent = void 0;
+// This is how simple it now is - no manual saveUserMessage needed!
+const codebolt = require('@codebolt/codeboltjs');
+const { ComposableAgent, createTool, z } = require('@codebolt/agent/composable');
+// Create a simple tool
+const weatherTool = createTool({
+    id: 'get-weather',
+    description: 'Get current weather for a location',
+    inputSchema: z.object({
+        location: z.string().describe('City name'),
+    }),
+    outputSchema: z.object({
+        temperature: z.number(),
+        conditions: z.string(),
+        location: z.string(),
+    }),
+    execute: async ({ context }) => {
+        // Mock weather data
+        return {
+            temperature: 22,
+            conditions: 'Sunny',
+            location: context.location
+        };
+    },
+});
+// Create your agent
+const myAgent = new ComposableAgent({
+    name: 'Weather Assistant',
+    instructions: `
+    You are a helpful weather assistant. 
+    Use the weather tool to get current weather information.
+    Be friendly and provide helpful responses.
+  `,
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    tools: { weatherTool },
+    processing: {
+        processMentionedMCPs: true, // Auto-add mentioned MCPs as tools
+        processRemixPrompt: true, // Use remix prompt to enhance instructions
+        processMentionedFiles: true, // Include mentioned file contents
+        processMentionedAgents: true // Add mentioned agents as sub-agents
+    }
+});
+exports.myAgent = myAgent;
+// Simple CodeBolt integration - no manual saveUserMessage needed!
+codebolt.onMessage(async (reqMessage) => {
+    try {
+        // codeboltjs automatically saves the user message now!
+        // You can access it anytime with codebolt.userMessage.*
+        console.log('Current message:', codebolt.userMessage.getText());
+        console.log('Mentioned files:', codebolt.userMessage.getMentionedFiles());
+        console.log('Mentioned MCPs:', codebolt.userMessage.getMentionedMCPs());
+        // Just run the agent - it automatically gets the user context
+        const result = await myAgent.run();
+        return result.success ? result.message : 'Error occurred';
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return 'Sorry, something went wrong.';
+    }
+});
+// Example: Multiple agents sharing the same user context
+const researchAgent = new ComposableAgent({
+    name: 'Research Agent',
+    instructions: 'Research topics and provide detailed information.',
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    processing: { processMentionedFiles: true }
+});
+exports.researchAgent = researchAgent;
+const writingAgent = new ComposableAgent({
+    name: 'Writing Agent',
+    instructions: 'Write content based on research and requirements.',
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    processing: { processRemixPrompt: true }
+});
+exports.writingAgent = writingAgent;
+// Alternative onMessage handler using multiple agents
+codebolt.onMessage(async (reqMessage) => {
+    try {
+        // Access user context directly from codebolt
+        const messageText = codebolt.userMessage.getText().toLowerCase();
+        const hasFiles = codebolt.userMessage.getMentionedFiles().length > 0;
+        const hasRemixPrompt = !!codebolt.userMessage.getRemixPrompt();
+        let result;
+        if (messageText.includes('research') || hasFiles) {
+            result = await researchAgent.run();
+        }
+        else if (messageText.includes('write') || hasRemixPrompt) {
+            result = await writingAgent.run();
+        }
+        else {
+            result = await myAgent.run();
+        }
+        return result.success ? result.message : 'Error occurred';
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return 'Sorry, something went wrong.';
+    }
+});
+// Example: Using session data for state management
+codebolt.onMessage(async (reqMessage) => {
+    try {
+        // Store conversation state
+        const conversationId = codebolt.userMessage.getThreadId() || 'default';
+        const userId = codebolt.userMessage.getMessageId() || 'anonymous';
+        // Set session data
+        codebolt.userMessage.setSessionData('conversationId', conversationId);
+        codebolt.userMessage.setSessionData('userId', userId);
+        // Configure processing based on user preferences (could be stored in DB)
+        if (userId === 'power-user') {
+            codebolt.userMessage.updateProcessingConfig({
+                processMentionedMCPs: true,
+                processMentionedFiles: true,
+                processRemixPrompt: true,
+                processMentionedAgents: true
+            });
+        }
+        const result = await myAgent.run();
+        // Store result for conversation continuity
+        codebolt.userMessage.setSessionData('lastResult', result.message);
+        return result.message;
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return 'Error processing request';
+    }
+});
+// Example: Conditional processing based on message content
+codebolt.onMessage(async (reqMessage) => {
+    try {
+        const files = codebolt.userMessage.getMentionedFiles();
+        const mcps = codebolt.userMessage.getMentionedMCPs();
+        // Conditionally update processing config
+        if (files.some((f) => f.endsWith('.env') || f.endsWith('.secret'))) {
+            // Don't process sensitive files
+            codebolt.userMessage.updateProcessingConfig({
+                processMentionedFiles: false
+            });
+        }
+        if (mcps.some((mcp) => mcp.toolbox === 'admin')) {
+            // Only process admin MCPs for authorized users
+            const isAdmin = checkUserPermissions(codebolt.userMessage.getMessageId());
+            codebolt.userMessage.updateProcessingConfig({
+                processMentionedMCPs: isAdmin
+            });
+        }
+        const result = await myAgent.run();
+        return result.message;
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return 'Error processing request';
+    }
+});
+function checkUserPermissions(userId) {
+    // Mock permission check
+    return userId === 'admin-user';
+}

package/dist/composablepattern/examples/weather-agent.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Weather Agent Example
+ * @description Example showing how to create a weather agent using the composable pattern
+ */
+import { ComposableAgent } from '../index';
+export declare const weatherTool: import("../types").Tool<{
+    location: string;
+}, {
+    temperature: number;
+    feelsLike: number;
+    humidity: number;
+    windSpeed: number;
+    windGust: number;
+    conditions: string;
+    location: string;
+}>;
+export declare const codeboltagent: ComposableAgent;
+export declare function runWeatherExample(): Promise<import("../types").ExecutionResult>;

package/dist/composablepattern/examples/weather-agent.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * @fileoverview Weather Agent Example
+ * @description Example showing how to create a weather agent using the composable pattern
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeboltagent = exports.weatherTool = void 0;
+exports.runWeatherExample = runWeatherExample;
+const index_1 = require("../index");
+// Mock weather function (in real usage, this would call a weather API)
+async function getWeather(location) {
+    // This is a mock implementation
+    // In real usage, you would call a weather API like OpenWeatherMap
+    return {
+        temperature: 22,
+        feelsLike: 25,
+        humidity: 65,
+        windSpeed: 10,
+        windGust: 15,
+        conditions: 'Partly cloudy',
+        location: location
+    };
+}
+// Create weather tool
+exports.weatherTool = (0, index_1.createTool)({
+    id: 'get-weather',
+    description: 'Get current weather for a location',
+    inputSchema: index_1.z.object({
+        location: index_1.z.string().describe('City name'),
+    }),
+    outputSchema: index_1.z.object({
+        temperature: index_1.z.number(),
+        feelsLike: index_1.z.number(),
+        humidity: index_1.z.number(),
+        windSpeed: index_1.z.number(),
+        windGust: index_1.z.number(),
+        conditions: index_1.z.string(),
+        location: index_1.z.string(),
+    }),
+    execute: async ({ context }) => {
+        return await getWeather(context.location);
+    },
+});
+// Create agent
+exports.codeboltagent = new index_1.ComposableAgent({
+    name: 'Weather Agent',
+    instructions: `
+    You are a helpful weather assistant that provides accurate weather information and can help planning activities based on the weather.
+
+    Your primary function is to help users get weather details for specific locations. When responding:
+    - Always ask for a location if none is provided
+    - If the location name isn't in English, please translate it
+    - If giving a location with multiple parts (e.g. "New York, NY"), use the most relevant part (e.g. "New York")
+    - Include relevant details like humidity, wind conditions, and precipitation
+    - Keep responses concise but informative
+    - If the user asks for activities and provides the weather forecast, suggest activities based on the weather forecast.
+    - If the user asks for activities, respond in the format they request.
+
+    Use the weatherTool to fetch current weather data.
+  `,
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    tools: { weatherTool: exports.weatherTool },
+    memory: (0, index_1.createCodeBoltDbMemory)(),
+});
+// Example usage
+async function runWeatherExample() {
+    try {
+        console.log('Running weather agent example...');
+        const result = await exports.codeboltagent.execute('What is the weather like in New York?');
+        if (result.success) {
+            console.log('Agent response:', result.message);
+        }
+        else {
+            console.error('Agent failed:', result.error);
+        }
+        return result;
+    }
+    catch (error) {
+        console.error('Example failed:', error);
+        throw error;
+    }
+}
+// Run example if this file is executed directly
+if (require.main === module) {
+    runWeatherExample().catch(console.error);
+}

package/dist/composablepattern/examples/workflow-example.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Workflow Examples
+ * @description Examples showing how to create and execute workflows with multiple agents
+ */
+import { Workflow } from '../workflow';
+export declare const contentCreationWorkflow: Workflow;
+export declare const customerSupportWorkflow: Workflow;
+export declare const dataProcessingWorkflow: Workflow;
+export declare function runContentWorkflowExample(): Promise<import("../workflow").WorkflowResult>;
+export declare function runCustomerSupportExample(): Promise<import("../workflow").WorkflowResult>;
+export declare function runDataProcessingExample(): Promise<import("../workflow").WorkflowResult>;
+export declare function runAllWorkflowExamples(): Promise<void>;