@codebolt/agent 5.0.8 → 5.0.9

package/dist/processor/agent/agentStep.js

@@ -1,241 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-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

@@ -1,90 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-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

@@ -1,36 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-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

@@ -1,55 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-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

@@ -1,29 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,20 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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

@@ -1,22 +0,0 @@
-"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

@@ -1,94 +0,0 @@
-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';