@codebolt/agent 5.0.2 → 5.0.7

package/dist/systemprompt.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+declare class SystemPrompt {
+    private filepath;
+    private key;
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath?: string, key?: string);
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText(): string;
+}
+export { SystemPrompt };

package/dist/systemprompt.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemPrompt = void 0;
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+class SystemPrompt {
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath = "", key = "") {
+        this.filepath = filepath;
+        this.key = key;
+    }
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText() {
+        try {
+            const absolutePath = path_1.default.resolve(this.filepath);
+            const fileContents = fs_1.default.readFileSync(absolutePath, 'utf8');
+            const data = js_yaml_1.default.load(fileContents);
+            if (!data || typeof data !== 'object') {
+                throw new Error('Invalid YAML structure');
+            }
+            if (!data[this.key]) {
+                throw new Error(`Prompt not found for key: ${this.key}`);
+            }
+            const promptData = data[this.key];
+            return typeof promptData === 'string' ? promptData : promptData.prompt;
+        }
+        catch (error) {
+            console.error(`SystemPrompt Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error; // Re-throw to allow caller handling
+        }
+    }
+}
+exports.SystemPrompt = SystemPrompt;

package/dist/taskInstruction.d.ts

@@ -0,0 +1,37 @@
+import { UserMessage } from "./usermessage";
+import type { UserMessageContent } from "./types/libFunctionTypes";
+import type { Tools, UserMessages } from "./types/InternalTypes";
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
+declare class TaskInstruction {
+    /** Available tools for the task */
+    tools: Tools;
+    /** Messages from the user for this task */
+    userMessages: UserMessageContent[];
+    /** The user message object containing input */
+    userMessage: UserMessage;
+    /** Path to the YAML file with task instructions */
+    filepath: string;
+    /** The section reference within the YAML file */
+    refsection: string;
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
+    constructor(tools: Tools | undefined, userMessage: UserMessage, filepath?: string, refsection?: string);
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
+    toPrompt(): Promise<UserMessages[]>;
+}
+export { TaskInstruction };

package/dist/taskInstruction.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInstruction = void 0;
+/**
+ * Encapsulates task instructions and their related metadata.
+ * Handles loading and processing of task instructions from YAML files.
+ */
+const yaml = require('js-yaml');
+const fs = require('fs');
+const path = require('path');
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
+class TaskInstruction {
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
+    constructor(tools = {}, userMessage, filepath = "", refsection = "") {
+        /** Messages from the user for this task */
+        this.userMessages = [];
+        this.tools = tools;
+        this.userMessage = userMessage;
+        this.filepath = filepath;
+        this.refsection = refsection;
+    }
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
+    async toPrompt() {
+        try {
+            this.userMessages = await this.userMessage.toPrompt();
+            const fileContents = fs.readFileSync(path.resolve(this.filepath), 'utf8');
+            const data = yaml.load(fileContents);
+            const task = data[this.refsection];
+            this.userMessages.push({
+                type: "text",
+                text: `Task Description: ${task.description}\nExpected Output: ${task.expected_output}`
+            });
+            return this.userMessages;
+        }
+        catch (error) {
+            console.error(`Error processing task instruction: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.TaskInstruction = TaskInstruction;

package/dist/types/libFunctionTypes.d.ts

@@ -6,9 +6,17 @@
  * - API interfaces exposed to library users
  * - Configuration options for library functions
  * - User-facing data structures
+ *
+ * Note: Core message and tool types are imported from @codebolt/types/sdk.
+ * Local extensions are provided for backward compatibility.
  */
+import type { MessageObject, ToolCall as SDKToolCall, ToolChoice, LLMCompletion } from '@codebolt/types/sdk';
+import type { ToolResult as AgentToolResult } from '@codebolt/types/agent';
+export type { MessageObject, ToolChoice, LLMCompletion };
+export type { AgentToolResult };
 /**
  * Represents a message in the conversation with roles and content.
+ * Extended version with looser typing for backward compatibility.
  */
 export interface Message {
     /** The role of the message sender: user, assistant, tool, or system */
@@ -24,22 +32,12 @@ export interface Message {
 }
 /**
  * Represents a tool call in OpenAI format
+ * Re-exported from SDK with same structure
  */
-export interface ToolCall {
-    /** Unique identifier for this tool call */
-    id: string;
-    /** The type of tool call */
-    type: 'function';
-    /** Function call details */
-    function: {
-        /** Name of the function to call */
-        name: string;
-        /** Arguments for the function call as JSON string */
-        arguments: string;
-    };
-}
+export type ToolCall = SDKToolCall;
 /**
  * Represents a tool definition in OpenAI format
+ * Extended with looser parameter typing for flexibility
  */
 export interface Tool {
     /** The type of tool */
@@ -56,6 +54,7 @@ export interface Tool {
 }
 /**
  * LLM inference request parameters
+ * Local version with required llmrole for backward compatibility
  */
 export interface LLMInferenceParams {
     /** Array of messages in the conversation */
@@ -63,12 +62,7 @@ export interface LLMInferenceParams {
     /** Available tools for the model to use */
     tools?: Tool[];
     /** How the model should use tools */
-    tool_choice?: 'auto' | 'none' | 'required' | {
-        type: 'function';
-        function: {
-            name: string;
-        };
-    };
+    tool_choice?: ToolChoice;
     /** The LLM role to determine which model to use */
     llmrole: string;
     /** Maximum number of tokens to generate */

package/dist/types/libFunctionTypes.js

@@ -7,5 +7,8 @@
  * - API interfaces exposed to library users
  * - Configuration options for library functions
  * - User-facing data structures
+ *
+ * Note: Core message and tool types are imported from @codebolt/types/sdk.
+ * Local extensions are provided for backward compatibility.
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/processorTypes.d.ts

@@ -1,16 +1,16 @@
 /**
  * Processor types and interfaces for the Unified Agent Framework
- * @deprecated Use specific processor type files instead
+ * @deprecated Use types from @codebolt/types/agent instead
  *
  * This file is kept for backward compatibility.
- * New code should import from the specific processor type files:
- * - './processorTypes/messageModifierTypes'
- * - './processorTypes/preInferenceProcessorTypes'
- * - './processorTypes/postInferenceTypes'
- * - './processorTypes/preToolCallProcessorTypes'
- * - './processorTypes/postToolCallProcessorTypes'
+ * New code should import from @codebolt/types/agent:
+ * - MessageModifier, MessageModifierOptions
+ * - PreInferenceProcessor, PostInferenceProcessor
+ * - PreToolCallProcessor, PostToolCallProcessor
+ * - ProcessedMessage, ToolCall, ToolResult
  */
-export * from './processorTypes';
+import type { ToolResult } from '@codebolt/types/agent';
+export type { ToolResult };
 export interface ToolCall {
     id: string;
     function: {

package/dist/types/processorTypes.js

@@ -1,34 +1,17 @@
 "use strict";
 /**
  * Processor types and interfaces for the Unified Agent Framework
- * @deprecated Use specific processor type files instead
+ * @deprecated Use types from @codebolt/types/agent instead
  *
  * This file is kept for backward compatibility.
- * New code should import from the specific processor type files:
- * - './processorTypes/messageModifierTypes'
- * - './processorTypes/preInferenceProcessorTypes'
- * - './processorTypes/postInferenceTypes'
- * - './processorTypes/preToolCallProcessorTypes'
- * - './processorTypes/postToolCallProcessorTypes'
+ * New code should import from @codebolt/types/agent:
+ * - MessageModifier, MessageModifierOptions
+ * - PreInferenceProcessor, PostInferenceProcessor
+ * - PreToolCallProcessor, PostToolCallProcessor
+ * - ProcessedMessage, ToolCall, ToolResult
  */
-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.BaseProcessor = void 0;
-// Re-export all processor types from their specific modules
-__exportStar(require("./processorTypes"), exports);
 // Base processor class
 class BaseProcessor {
     constructor(options) {

package/dist/unified/agent/agent.js

@@ -42,11 +42,11 @@ class Agent {
                     // console.log('[Agent] Step completed, processing response');
                 }
                 const responseExecutor = new responseExecutor_1.ResponseExecutor({
-                    preToolCalProcessors: this.preToolCallProcessors,
+                    preToolCallProcessors: this.preToolCallProcessors,
                     postToolCallProcessors: this.postToolCallProcessors
                 });
                 const executionResult = await responseExecutor.executeResponse({
-                    initailUserMessage: reqMessage,
+                    initialUserMessage: reqMessage,
                     actualMessageSentToLLM: stepResult.actualMessageSentToLLM,
                     rawLLMOutput: stepResult.rawLLMResponse,
                     nextMessage: stepResult.nextMessage

package/dist/unified/agent/codeboltAgent.d.ts

@@ -0,0 +1,122 @@
+import { AgentConfig, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor } from "@codebolt/types/agent";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+/**
+ * Configuration options for CodeboltAgent
+ */
+export interface CodeboltAgentConfig extends AgentConfig {
+    /**
+     * Enable logging for debugging purposes.
+     * Defaults to true.
+     */
+    enableLogging?: boolean;
+}
+/**
+ * CodeboltAgent is a high-level agent class that:
+ * - Uses InitialPromptGenerator with configurable processors/modifiers
+ * - Runs an agent loop with AgentStep and ResponseExecutor
+ * - Handles tool execution and conversation flow automatically
+ * - Is triggered via processMessage (not via onMessage listener)
+ *
+ * @example
+ * ```typescript
+ * import { CodeboltAgent } from '@codebolt/agent/unified';
+ * import {
+ *     EnvironmentContextModifier,
+ *     CoreSystemPromptModifier,
+ *     DirectoryContextModifier,
+ *     IdeContextModifier,
+ *     AtFileProcessorModifier,
+ *     ToolInjectionModifier,
+ *     ChatHistoryMessageModifier
+ * } from '@codebolt/agent/processor-pieces';
+ *
+ * const systemPrompt = `You are an AI coding assistant...`;
+ *
+ * const agent = new CodeboltAgent({
+ *     instructions: systemPrompt,
+ *     processors: {
+ *         messageModifiers: [
+ *             new ChatHistoryMessageModifier({ enableChatHistory: true }),
+ *             new EnvironmentContextModifier({ enableFullContext: true }),
+ *             new DirectoryContextModifier(),
+ *             new IdeContextModifier({
+ *                 includeActiveFile: true,
+ *                 includeOpenFiles: true,
+ *                 includeCursorPosition: true,
+ *                 includeSelectedText: true
+ *             }),
+ *             new CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
+ *             new ToolInjectionModifier({ includeToolDescriptions: true }),
+ *             new AtFileProcessorModifier({ enableRecursiveSearch: true })
+ *         ],
+ *         preInferenceProcessors: [],
+ *         postInferenceProcessors: [],
+ *         preToolCallProcessors: [],
+ *         postToolCallProcessors: []
+ *     }
+ * });
+ *
+ * // Process a message (triggered from graph node)
+ * const result = await agent.processMessage(userMessage);
+ * ```
+ */
+export declare class CodeboltAgent {
+    private readonly config;
+    private readonly messageModifiers;
+    private readonly preInferenceProcessors;
+    private readonly postInferenceProcessors;
+    private readonly preToolCallProcessors;
+    private readonly postToolCallProcessors;
+    private readonly enableLogging;
+    private readonly baseSystemPrompt;
+    constructor(config: CodeboltAgentConfig);
+    /**
+     * Creates default message modifiers when none are provided
+     */
+    private createDefaultMessageModifiers;
+    /**
+     * Process a message through the agent pipeline.
+     * This is the main entry point - triggered from graph nodes.
+     */
+    processMessage(reqMessage: FlatUserMessage): Promise<{
+        success: boolean;
+        result: any;
+        error?: string;
+    }>;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): CodeboltAgentConfig;
+    /**
+     * Get all message modifiers
+     */
+    getMessageModifiers(): MessageModifier[];
+    /**
+     * Get all pre-inference processors
+     */
+    getPreInferenceProcessors(): PreInferenceProcessor[];
+    /**
+     * Get all post-inference processors
+     */
+    getPostInferenceProcessors(): PostInferenceProcessor[];
+    /**
+     * Get all pre-tool-call processors
+     */
+    getPreToolCallProcessors(): PreToolCallProcessor[];
+    /**
+     * Get all post-tool-call processors
+     */
+    getPostToolCallProcessors(): PostToolCallProcessor[];
+}
+/**
+ * Factory function to create a CodeboltAgent with common defaults
+ */
+export declare function createCodeboltAgent(options: {
+    systemPrompt: string;
+    messageModifiers?: MessageModifier[];
+    preInferenceProcessors?: PreInferenceProcessor[];
+    postInferenceProcessors?: PostInferenceProcessor[];
+    preToolCallProcessors?: PreToolCallProcessor[];
+    postToolCallProcessors?: PostToolCallProcessor[];
+    enableLogging?: boolean;
+}): CodeboltAgent;

package/dist/unified/agent/codeboltAgent.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeboltAgent = void 0;
+exports.createCodeboltAgent = createCodeboltAgent;
+const base_1 = require("../base");
+const responseExecutor_1 = require("../base/responseExecutor");
+const agentStep_1 = require("../base/agentStep");
+const processor_pieces_1 = require("../../processor-pieces");
+/**
+ * CodeboltAgent is a high-level agent class that:
+ * - Uses InitialPromptGenerator with configurable processors/modifiers
+ * - Runs an agent loop with AgentStep and ResponseExecutor
+ * - Handles tool execution and conversation flow automatically
+ * - Is triggered via processMessage (not via onMessage listener)
+ *
+ * @example
+ * ```typescript
+ * import { CodeboltAgent } from '@codebolt/agent/unified';
+ * import {
+ *     EnvironmentContextModifier,
+ *     CoreSystemPromptModifier,
+ *     DirectoryContextModifier,
+ *     IdeContextModifier,
+ *     AtFileProcessorModifier,
+ *     ToolInjectionModifier,
+ *     ChatHistoryMessageModifier
+ * } from '@codebolt/agent/processor-pieces';
+ *
+ * const systemPrompt = `You are an AI coding assistant...`;
+ *
+ * const agent = new CodeboltAgent({
+ *     instructions: systemPrompt,
+ *     processors: {
+ *         messageModifiers: [
+ *             new ChatHistoryMessageModifier({ enableChatHistory: true }),
+ *             new EnvironmentContextModifier({ enableFullContext: true }),
+ *             new DirectoryContextModifier(),
+ *             new IdeContextModifier({
+ *                 includeActiveFile: true,
+ *                 includeOpenFiles: true,
+ *                 includeCursorPosition: true,
+ *                 includeSelectedText: true
+ *             }),
+ *             new CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
+ *             new ToolInjectionModifier({ includeToolDescriptions: true }),
+ *             new AtFileProcessorModifier({ enableRecursiveSearch: true })
+ *         ],
+ *         preInferenceProcessors: [],
+ *         postInferenceProcessors: [],
+ *         preToolCallProcessors: [],
+ *         postToolCallProcessors: []
+ *     }
+ * });
+ *
+ * // Process a message (triggered from graph node)
+ * const result = await agent.processMessage(userMessage);
+ * ```
+ */
+class CodeboltAgent {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f;
+        this.config = { ...config };
+        this.enableLogging = config.enableLogging !== false;
+        this.baseSystemPrompt = config.instructions || 'Based on User Message send reply';
+        // Use provided modifiers or default ones
+        this.messageModifiers = ((_b = (_a = config.processors) === null || _a === void 0 ? void 0 : _a.messageModifiers) === null || _b === void 0 ? void 0 : _b.length)
+            ? config.processors.messageModifiers
+            : this.createDefaultMessageModifiers(this.baseSystemPrompt);
+        this.preInferenceProcessors = ((_c = config.processors) === null || _c === void 0 ? void 0 : _c.preInferenceProcessors) || [];
+        this.postInferenceProcessors = ((_d = config.processors) === null || _d === void 0 ? void 0 : _d.postInferenceProcessors) || [];
+        this.preToolCallProcessors = ((_e = config.processors) === null || _e === void 0 ? void 0 : _e.preToolCallProcessors) || [];
+        this.postToolCallProcessors = ((_f = config.processors) === null || _f === void 0 ? void 0 : _f.postToolCallProcessors) || [];
+    }
+    /**
+     * Creates default message modifiers when none are provided
+     */
+    createDefaultMessageModifiers(systemPrompt) {
+        return [
+            // 1. Chat History
+            new processor_pieces_1.ChatHistoryMessageModifier({ enableChatHistory: true }),
+            // 2. Environment Context (date, OS)
+            new processor_pieces_1.EnvironmentContextModifier({ enableFullContext: true }),
+            // 3. Directory Context (folder structure)
+            new processor_pieces_1.DirectoryContextModifier(),
+            // 4. IDE Context (active file, opened files)
+            new processor_pieces_1.IdeContextModifier({
+                includeActiveFile: true,
+                includeOpenFiles: true,
+                includeCursorPosition: true,
+                includeSelectedText: true
+            }),
+            // 5. Core System Prompt (instructions)
+            new processor_pieces_1.CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
+            // 6. Tools (function declarations)
+            new processor_pieces_1.ToolInjectionModifier({ includeToolDescriptions: true }),
+            // 7. At-file processing (@file mentions)
+            new processor_pieces_1.AtFileProcessorModifier({ enableRecursiveSearch: true })
+        ];
+    }
+    /**
+     * Process a message through the agent pipeline.
+     * This is the main entry point - triggered from graph nodes.
+     */
+    async processMessage(reqMessage) {
+        try {
+            if (this.enableLogging) {
+                console.log('[CodeboltAgent] Processing message');
+            }
+            const promptGenerator = new base_1.InitialPromptGenerator({
+                processors: this.messageModifiers,
+                baseSystemPrompt: this.baseSystemPrompt,
+                enableLogging: this.enableLogging
+            });
+            let prompt = await promptGenerator.processMessage(reqMessage);
+            let completed = false;
+            while (!completed) {
+                const agentStep = new agentStep_1.AgentStep({
+                    preInferenceProcessors: this.preInferenceProcessors,
+                    postInferenceProcessors: this.postInferenceProcessors
+                });
+                const stepResult = await agentStep.executeStep(reqMessage, prompt);
+                prompt = stepResult.nextMessage;
+                const responseExecutor = new responseExecutor_1.ResponseExecutor({
+                    preToolCallProcessors: this.preToolCallProcessors,
+                    postToolCallProcessors: this.postToolCallProcessors
+                });
+                const executionResult = await responseExecutor.executeResponse({
+                    initialUserMessage: reqMessage,
+                    actualMessageSentToLLM: stepResult.actualMessageSentToLLM,
+                    rawLLMOutput: stepResult.rawLLMResponse,
+                    nextMessage: stepResult.nextMessage
+                });
+                completed = executionResult.completed;
+                prompt = executionResult.nextMessage;
+            }
+            if (this.enableLogging) {
+                console.log('[CodeboltAgent] Message processing completed');
+            }
+            return {
+                success: true,
+                result: prompt,
+                error: undefined
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            if (this.enableLogging) {
+                console.error('[CodeboltAgent] Execution failed:', error);
+            }
+            return {
+                success: false,
+                result: null,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get all message modifiers
+     */
+    getMessageModifiers() {
+        return [...this.messageModifiers];
+    }
+    /**
+     * Get all pre-inference processors
+     */
+    getPreInferenceProcessors() {
+        return [...this.preInferenceProcessors];
+    }
+    /**
+     * Get all post-inference processors
+     */
+    getPostInferenceProcessors() {
+        return [...this.postInferenceProcessors];
+    }
+    /**
+     * Get all pre-tool-call processors
+     */
+    getPreToolCallProcessors() {
+        return [...this.preToolCallProcessors];
+    }
+    /**
+     * Get all post-tool-call processors
+     */
+    getPostToolCallProcessors() {
+        return [...this.postToolCallProcessors];
+    }
+}
+exports.CodeboltAgent = CodeboltAgent;
+/**
+ * Factory function to create a CodeboltAgent with common defaults
+ */
+function createCodeboltAgent(options) {
+    return new CodeboltAgent({
+        instructions: options.systemPrompt,
+        processors: {
+            messageModifiers: options.messageModifiers || [],
+            preInferenceProcessors: options.preInferenceProcessors || [],
+            postInferenceProcessors: options.postInferenceProcessors || [],
+            preToolCallProcessors: options.preToolCallProcessors || [],
+            postToolCallProcessors: options.postToolCallProcessors || []
+        },
+        enableLogging: options.enableLogging
+    });
+}