@codebolt/agent 1.2.1 → 2.2.2

package/dist/processor/agent/agentStep.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMAgentStep = exports.AgentStep = void 0;
+class AgentStep {
+    constructor(options = {}) {
+        this.inputProcessors = options.inputProcessors || [];
+        this.outputProcessors = options.outputProcessors || [];
+        this.toolList = options.toolList;
+        this.toolExecutor = options.toolExecutor;
+        this.maxIterations = options.maxIterations || 10;
+    }
+    /**
+     * Single step processing with input/output processors
+     */
+    async step(message, context) {
+        var _a;
+        try {
+            let processedMessage = message;
+            // Apply input processors
+            for (const processor of this.inputProcessors) {
+                const results = await processor.processInput({
+                    message: processedMessage,
+                    context
+                });
+                // Find the processed message from results
+                const messageEvent = results.find(r => r.type === 'MessageProcessed' || r.type === 'MessageWithContext');
+                if (messageEvent && messageEvent.value) {
+                    processedMessage = messageEvent.value;
+                }
+            }
+            // Analyze for tool calls
+            const toolCalls = await this.analyzeForToolCalls(processedMessage, ((_a = this.toolList) === null || _a === void 0 ? void 0 : _a.getAllTools()) || [], context);
+            if (toolCalls && toolCalls.length > 0) {
+                // Execute tools if we have a tool executor
+                if (this.toolExecutor) {
+                    const toolResults = await this.toolExecutor.executeTools({
+                        toolCalls,
+                        tools: this.toolList || { getAllTools: () => [], getTool: () => undefined, addTool: () => { }, removeTool: () => { } },
+                        context
+                    });
+                    // Generate response with tool results
+                    const stepOutput = await this.generateFinalResponse(processedMessage, toolResults, context);
+                    processedMessage = stepOutput.response;
+                }
+                else {
+                    // Return message with tool calls for external execution
+                    processedMessage = {
+                        messages: [
+                            ...processedMessage.messages,
+                            {
+                                role: 'assistant',
+                                content: `I need to use tools: ${toolCalls.map(t => t.tool).join(', ')}`,
+                                tool_calls: toolCalls.map(t => ({
+                                    id: `tool-${Date.now()}`,
+                                    function: { name: t.tool, arguments: t.parameters }
+                                }))
+                            }
+                        ]
+                    };
+                }
+            }
+            else {
+                // No tool calls needed, generate final response
+                const stepOutput = await this.generateFinalResponse(processedMessage, null, context);
+                processedMessage = stepOutput.response;
+            }
+            // Apply output processors
+            for (const processor of this.outputProcessors) {
+                const results = await processor.processInput({
+                    message: processedMessage,
+                    context
+                });
+                // Find the processed message from results
+                const messageEvent = results.find(r => r.type === 'MessageProcessed' || r.type === 'FinalResponse');
+                if (messageEvent && messageEvent.value) {
+                    processedMessage = messageEvent.value;
+                }
+            }
+            return processedMessage;
+        }
+        catch (error) {
+            console.error('Error in AgentStep.step:', error);
+            throw error;
+        }
+    }
+    async generateOneStep(input) {
+        try {
+            const { message, tools, context } = input;
+            // Analyze for tool calls
+            const toolCalls = await this.analyzeForToolCalls(message, tools, context);
+            if (toolCalls && toolCalls.length > 0) {
+                // Execute tools
+                const toolResults = await this.toolExecutor.executeTools({
+                    toolCalls,
+                    tools: { getAllTools: () => tools, getTool: (name) => tools.find(t => t.name === name), addTool: () => { }, removeTool: () => { } },
+                    context
+                });
+                // Generate response with tool results
+                return await this.generateFinalResponse(message, toolResults, context);
+            }
+            else {
+                // No tool calls needed, generate final response
+                return await this.generateFinalResponse(message, null, context);
+            }
+        }
+        catch (error) {
+            console.error('Error in generateOneStep:', error);
+            throw error;
+        }
+    }
+    async generateWithToolExecution(input) {
+        try {
+            const { message, tools, context } = input;
+            // Analyze for tool calls
+            const toolCalls = await this.analyzeForToolCalls(message, tools, context);
+            if (toolCalls && toolCalls.length > 0) {
+                // Execute tools
+                const toolResults = await this.toolExecutor.executeTools({
+                    toolCalls,
+                    tools: { getAllTools: () => tools, getTool: (name) => tools.find(t => t.name === name), addTool: () => { }, removeTool: () => { } },
+                    context
+                });
+                // Generate response with tool results
+                return await this.generateFinalResponse(message, toolResults, context);
+            }
+            else {
+                // No tool calls needed, generate final response
+                return await this.generateFinalResponse(message, null, context);
+            }
+        }
+        catch (error) {
+            console.error('Error in generateWithToolExecution:', error);
+            throw error;
+        }
+    }
+    async loop(input, maxIterations) {
+        const maxIter = maxIterations || this.maxIterations;
+        let currentMessage = input.message;
+        let iteration = 0;
+        while (iteration < maxIter) {
+            iteration++;
+            // Generate one step
+            const stepResult = await this.generateOneStep({
+                message: currentMessage,
+                tools: input.tools,
+                context: input.context
+            });
+            // Check if finished
+            if (stepResult.finished) {
+                return stepResult;
+            }
+            // Update message for next iteration
+            currentMessage = stepResult.response;
+        }
+        // Max iterations reached
+        return await this.generateFinalResponse(currentMessage, null, input.context);
+    }
+}
+exports.AgentStep = AgentStep;
+class LLMAgentStep extends AgentStep {
+    constructor(options = {}) {
+        super(options);
+        this.llmConfig = options.llmconfig || { llmname: "DefaultLLM" };
+    }
+    async analyzeForToolCalls(message, tools, context) {
+        // Generic implementation that can work with any LLM
+        // In a real scenario, you would call your LLM service here
+        const lastMessage = message.messages[message.messages.length - 1];
+        const content = typeof lastMessage.content === 'string'
+            ? lastMessage.content.toLowerCase()
+            : JSON.stringify(lastMessage.content).toLowerCase();
+        const toolCalls = [];
+        // Simple keyword-based tool detection (replace with actual LLM call)
+        if (content.includes('read') && content.includes('file')) {
+            const filePath = this.extractFilePath(content);
+            if (filePath) {
+                toolCalls.push({
+                    tool: 'FileRead',
+                    parameters: { filePath }
+                });
+            }
+        }
+        if (content.includes('write') && content.includes('file')) {
+            const filePath = this.extractFilePath(content);
+            if (filePath) {
+                toolCalls.push({
+                    tool: 'FileWrite',
+                    parameters: { filePath, content: 'Content to be written' }
+                });
+            }
+        }
+        if (content.includes('delete') && content.includes('file')) {
+            const filePath = this.extractFilePath(content);
+            if (filePath) {
+                toolCalls.push({
+                    tool: 'FileDelete',
+                    parameters: { filePath }
+                });
+            }
+        }
+        return toolCalls.length > 0 ? toolCalls : null;
+    }
+    async generateFinalResponse(message, toolResults, context) {
+        // Generic implementation that can work with any LLM
+        // In a real scenario, you would call your LLM service here
+        const lastMessage = message.messages[message.messages.length - 1];
+        let responseContent = `I've processed your request: "${lastMessage.content}". Here's my response based on the available information.`;
+        // Add tool results if available
+        if (toolResults && toolResults.results) {
+            const toolResultsText = toolResults.results
+                .map((r) => `${r.tool}: ${r.success ? 'Success' : 'Failed'}`)
+                .join(', ');
+            responseContent += `\n\nTool execution results: ${toolResultsText}`;
+        }
+        const response = {
+            messages: [
+                ...message.messages,
+                {
+                    role: 'assistant',
+                    content: responseContent
+                }
+            ],
+            metadata: {
+                ...message.metadata,
+                responseGenerated: true,
+                timestamp: new Date().toISOString(),
+                model: this.llmConfig.model || this.llmConfig.llmname || 'generic-llm'
+            }
+        };
+        return {
+            response,
+            finished: true
+        };
+    }
+    extractFilePath(content) {
+        // Simple file path extraction (replace with more sophisticated parsing)
+        const filePathMatch = content.match(/['"`]([^'"`]+\.\w+)['"`]/);
+        return filePathMatch ? filePathMatch[1] : null;
+    }
+}
+exports.LLMAgentStep = LLMAgentStep;

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

@@ -0,0 +1,19 @@
+import { ToolExecutor as IToolExecutor, ToolExecutionInput, ToolExecutionOutput, ToolList } from '../types/interfaces';
+export interface ToolExecutorOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    enableLogging?: boolean;
+}
+export declare class ToolExecutor implements IToolExecutor {
+    private readonly toolList;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    private readonly enableLogging;
+    constructor(toolList: ToolList, options?: ToolExecutorOptions);
+    executeTools(input: ToolExecutionInput): Promise<ToolExecutionOutput>;
+    private executeToolWithRetry;
+    private delay;
+    addTool(tool: any): void;
+    removeTool(toolName: string): boolean;
+    getToolNames(): string[];
+}

package/dist/processor/agent/toolExecutor.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = void 0;
+class ToolExecutor {
+    constructor(toolList, options = {}) {
+        this.toolList = toolList;
+        this.maxRetries = options.maxRetries || 3;
+        this.retryDelay = options.retryDelay || 1000;
+        this.enableLogging = options.enableLogging !== false;
+    }
+    async executeTools(input) {
+        try {
+            const { toolCalls, tools, context } = input;
+            const results = [];
+            for (const toolCall of toolCalls) {
+                try {
+                    const tool = tools.getTool(toolCall.tool);
+                    if (!tool) {
+                        results.push({
+                            tool: toolCall.tool,
+                            result: null,
+                            error: `Tool '${toolCall.tool}' not found`
+                        });
+                        continue;
+                    }
+                    // Execute tool with retry logic
+                    const result = await this.executeToolWithRetry(tool, toolCall.parameters);
+                    results.push({
+                        tool: toolCall.tool,
+                        result,
+                        error: undefined
+                    });
+                }
+                catch (error) {
+                    results.push({
+                        tool: toolCall.tool,
+                        result: null,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            const success = results.every(r => !r.error);
+            return {
+                results,
+                success
+            };
+        }
+        catch (error) {
+            console.error('Error in ToolExecutor.executeTools:', error);
+            throw error;
+        }
+    }
+    async executeToolWithRetry(tool, parameters) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                if (this.enableLogging) {
+                    console.log(`[ToolExecutor] Executing ${tool.name} (attempt ${attempt}/${this.maxRetries})`);
+                }
+                const result = await tool.execute(parameters);
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (this.enableLogging) {
+                    console.warn(`[ToolExecutor] Attempt ${attempt} failed for ${tool.name}:`, lastError.message);
+                }
+                if (attempt < this.maxRetries) {
+                    await this.delay(this.retryDelay);
+                }
+            }
+        }
+        throw lastError || new Error(`Tool execution failed after ${this.maxRetries} attempts`);
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    // Helper methods for tool management
+    addTool(tool) {
+        this.toolList.addTool(tool);
+    }
+    removeTool(toolName) {
+        this.toolList.removeTool(toolName);
+        return true;
+    }
+    getToolNames() {
+        return this.toolList.getAllTools().map(tool => tool.name);
+    }
+}
+exports.ToolExecutor = ToolExecutor;

package/dist/processor/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types/interfaces';
+export { BaseProcessor } from './processors/baseProcessor';
+export { BaseMessageModifier, RequestMessage } from './messageModifiers/baseMessageModifier';
+export { BaseTool } from './tools/baseTool';
+export { AgentStep, AgentStepOptions, LLMAgentStep, LLMAgentStepOptions, LLMConfig } from './agent/agentStep';
+export { ToolExecutor, ToolExecutorOptions } from './agent/toolExecutor';
+export { ToolList as ToolListClass } from './tools/toolList';

package/dist/processor/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolListClass = exports.ToolExecutor = exports.LLMAgentStep = exports.AgentStep = exports.BaseTool = exports.RequestMessage = exports.BaseMessageModifier = exports.BaseProcessor = void 0;
+// Core interfaces
+__exportStar(require("./types/interfaces"), exports);
+// Base classes
+var baseProcessor_1 = require("./processors/baseProcessor");
+Object.defineProperty(exports, "BaseProcessor", { enumerable: true, get: function () { return baseProcessor_1.BaseProcessor; } });
+var baseMessageModifier_1 = require("./messageModifiers/baseMessageModifier");
+Object.defineProperty(exports, "BaseMessageModifier", { enumerable: true, get: function () { return baseMessageModifier_1.BaseMessageModifier; } });
+Object.defineProperty(exports, "RequestMessage", { enumerable: true, get: function () { return baseMessageModifier_1.RequestMessage; } });
+var baseTool_1 = require("./tools/baseTool");
+Object.defineProperty(exports, "BaseTool", { enumerable: true, get: function () { return baseTool_1.BaseTool; } });
+// Agent components
+var agentStep_1 = require("./agent/agentStep");
+Object.defineProperty(exports, "AgentStep", { enumerable: true, get: function () { return agentStep_1.AgentStep; } });
+Object.defineProperty(exports, "LLMAgentStep", { enumerable: true, get: function () { return agentStep_1.LLMAgentStep; } });
+var toolExecutor_1 = require("./agent/toolExecutor");
+Object.defineProperty(exports, "ToolExecutor", { enumerable: true, get: function () { return toolExecutor_1.ToolExecutor; } });
+// Tool management
+var toolList_1 = require("./tools/toolList");
+Object.defineProperty(exports, "ToolListClass", { enumerable: true, get: function () { return toolList_1.ToolList; } });

package/dist/processor/messageModifiers/baseMessageModifier.d.ts

@@ -0,0 +1,20 @@
+import { MessageModifier, MessageModifierInput, ProcessedMessage } from '../types/interfaces';
+export interface MessageModifierOptions {
+    context?: Record<string, any>;
+}
+export declare abstract class BaseMessageModifier implements MessageModifier {
+    protected context: Record<string, any>;
+    constructor(options?: MessageModifierOptions);
+    abstract modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
+    clearContext(): void;
+}
+export declare class RequestMessage {
+    private messageModifiers;
+    constructor(options?: {
+        messageModifiers?: MessageModifier[];
+    });
+    addModifier(modifier: MessageModifier): void;
+    modify(message: any): Promise<ProcessedMessage>;
+}

package/dist/processor/messageModifiers/baseMessageModifier.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestMessage = exports.BaseMessageModifier = void 0;
+class BaseMessageModifier {
+    constructor(options = {}) {
+        this.context = {};
+        this.context = options.context || {};
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+}
+exports.BaseMessageModifier = BaseMessageModifier;
+// New RequestMessage class that can chain multiple modifiers
+class RequestMessage {
+    constructor(options = {}) {
+        this.messageModifiers = [];
+        this.messageModifiers = options.messageModifiers || [];
+    }
+    addModifier(modifier) {
+        this.messageModifiers.push(modifier);
+    }
+    async modify(message) {
+        let currentMessage = {
+            messages: [
+                {
+                    role: 'user',
+                    content: typeof message === 'string' ? message : JSON.stringify(message)
+                }
+            ]
+        };
+        // Apply each modifier in sequence
+        for (const modifier of this.messageModifiers) {
+            try {
+                currentMessage = await modifier.modify({
+                    originalRequest: message,
+                    createdMessage: currentMessage,
+                    context: {}
+                });
+            }
+            catch (error) {
+                console.error('Error applying message modifier:', error);
+                // Continue with other modifiers
+            }
+        }
+        return currentMessage;
+    }
+}
+exports.RequestMessage = RequestMessage;

package/dist/processor/processors/baseProcessor.d.ts

@@ -0,0 +1,14 @@
+import { Processor, ProcessorInput, ProcessorOutput } from '../types/interfaces';
+export declare abstract class BaseProcessor implements Processor {
+    protected context: Record<string, any>;
+    constructor(options?: Record<string, any>);
+    abstract processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
+    clearContext(): void;
+    protected createEvent(type: string, value?: any): ProcessorOutput;
+    protected createEvents(...events: Array<{
+        type: string;
+        value?: any;
+    }>): ProcessorOutput[];
+}

package/dist/processor/processors/baseProcessor.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcessor = void 0;
+class BaseProcessor {
+    constructor(options) {
+        this.context = {};
+        if (options) {
+            this.context = { ...options };
+        }
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+    // Helper method to create events
+    createEvent(type, value) {
+        return { type, value };
+    }
+    // Helper method to create multiple events
+    createEvents(...events) {
+        return events.map(event => this.createEvent(event.type, event.value));
+    }
+}
+exports.BaseProcessor = BaseProcessor;

package/dist/processor/tools/baseTool.d.ts

@@ -0,0 +1,10 @@
+import { Tool } from '../types/interfaces';
+export declare abstract class BaseTool implements Tool {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, any>;
+    constructor(name: string, description: string, parameters: Record<string, any>);
+    abstract execute(params: any, abortSignal?: AbortSignal): Promise<any>;
+    protected checkAbortSignal(abortSignal?: AbortSignal): void;
+    protected validateParameters(params: any): boolean;
+}

package/dist/processor/tools/baseTool.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTool = void 0;
+class BaseTool {
+    constructor(name, description, parameters) {
+        this.name = name;
+        this.description = description;
+        this.parameters = parameters;
+    }
+    checkAbortSignal(abortSignal) {
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            throw new Error('Operation was aborted');
+        }
+    }
+    validateParameters(params) {
+        // Basic validation - can be overridden by subclasses
+        return params && typeof params === 'object';
+    }
+}
+exports.BaseTool = BaseTool;

package/dist/processor/tools/toolList.d.ts

@@ -0,0 +1,9 @@
+import { ToolList as IToolList, Tool } from '../types/interfaces';
+export declare class ToolList implements IToolList {
+    private tools;
+    constructor(tools?: Tool[]);
+    getTool(name: string): Tool | undefined;
+    getAllTools(): Tool[];
+    addTool(tool: Tool): void;
+    removeTool(name: string): void;
+}

package/dist/processor/tools/toolList.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolList = void 0;
+class ToolList {
+    constructor(tools = []) {
+        this.tools = new Map();
+        tools.forEach(tool => this.addTool(tool));
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    getAllTools() {
+        return Array.from(this.tools.values());
+    }
+    addTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    removeTool(name) {
+        this.tools.delete(name);
+    }
+}
+exports.ToolList = ToolList;

package/dist/processor/types/interfaces.d.ts

@@ -0,0 +1,94 @@
+export interface ToolCall {
+    id: string;
+    function: {
+        name: string;
+        arguments: string | Record<string, any>;
+    };
+}
+export interface Message {
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    content: string | any[];
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    [key: string]: any;
+}
+export interface ProcessedMessage {
+    messages: Message[];
+    metadata?: Record<string, any>;
+}
+export interface ProcessorInput {
+    message: ProcessedMessage;
+    context?: Record<string, any>;
+}
+export interface ProcessorOutput {
+    type: string;
+    value?: any;
+}
+export interface Processor {
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
+    clearContext(): void;
+}
+export interface MessageModifierInput {
+    originalRequest: any;
+    createdMessage: ProcessedMessage;
+    context?: Record<string, any>;
+}
+export interface MessageModifier {
+    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
+    clearContext(): void;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: Record<string, any>;
+    execute(params: any, abortSignal?: AbortSignal): Promise<any>;
+}
+export interface ToolList {
+    getTool(name: string): Tool | undefined;
+    getAllTools(): Tool[];
+    addTool(tool: Tool): void;
+    removeTool(name: string): void;
+}
+export interface AgentStepInput {
+    message: ProcessedMessage;
+    tools: Tool[];
+    context?: Record<string, any>;
+}
+export interface AgentStepOutput {
+    response: ProcessedMessage;
+    toolCalls?: Array<{
+        tool: string;
+        parameters: any;
+    }>;
+    finished: boolean;
+}
+export interface IAgentStep {
+    generateOneStep(input: AgentStepInput): Promise<AgentStepOutput>;
+    generateWithToolExecution(input: AgentStepInput): Promise<AgentStepOutput>;
+    loop(input: AgentStepInput, maxIterations?: number): Promise<AgentStepOutput>;
+}
+export interface ToolExecutionInput {
+    toolCalls: Array<{
+        tool: string;
+        parameters: any;
+    }>;
+    tools: ToolList;
+    context?: Record<string, any>;
+}
+export interface ToolExecutionOutput {
+    results: Array<{
+        tool: string;
+        result: any;
+        error?: string;
+    }>;
+    success: boolean;
+}
+export interface ToolExecutor {
+    executeTools(input: ToolExecutionInput): Promise<ToolExecutionOutput>;
+}
+export type AgentEventType = 'content' | 'tool_call_request' | 'tool_call_response' | 'tool_call_confirmation' | 'user_cancelled' | 'error' | 'chat_compressed' | 'thought' | 'max_session_turns' | 'finished' | 'loop_detected';