@codebolt/agent 5.0.6 → 5.0.8

package/dist/processor-pieces/postToolCallProcessors/index.d.ts

@@ -1,2 +1,2 @@
 export { ShellProcessorModifier } from './shellProcessorModifier';
-export { ConversationCompactorModifier, type ConversationCompactorOptions } from './conversationCompactorModifier';
+export { ConversationCompactorModifier, type ConversationCompactorOptions, type CompressionMetadata, CompressionStatus } from './conversationCompactorModifier';

package/dist/processor-pieces/postToolCallProcessors/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationCompactorModifier = exports.ShellProcessorModifier = void 0;
+exports.CompressionStatus = exports.ConversationCompactorModifier = exports.ShellProcessorModifier = void 0;
 var shellProcessorModifier_1 = require("./shellProcessorModifier");
 Object.defineProperty(exports, "ShellProcessorModifier", { enumerable: true, get: function () { return shellProcessorModifier_1.ShellProcessorModifier; } });
 var conversationCompactorModifier_1 = require("./conversationCompactorModifier");
 Object.defineProperty(exports, "ConversationCompactorModifier", { enumerable: true, get: function () { return conversationCompactorModifier_1.ConversationCompactorModifier; } });
+Object.defineProperty(exports, "CompressionStatus", { enumerable: true, get: function () { return conversationCompactorModifier_1.CompressionStatus; } });

package/dist/processor-pieces/postToolCallProcessors/shellProcessorModifier.js

@@ -22,7 +22,7 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
     async modify(input) {
         var _a;
         try {
-            const { llmMessageSent, rawLLMResponseMessage, nextPrompt, toolResults } = input;
+            const { nextPrompt, toolResults } = input;
             // Process shell commands in tool results if they exist
             let processedNextPrompt = nextPrompt;
             let shouldExit = false;
@@ -46,7 +46,7 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
                 if (typeof message.content === 'string') {
                     let processedContent = message.content;
                     // Replace {{args}} placeholders if metadata has args
-                    const args = ((_a = processedNextPrompt.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
+                    const args = ((_a = processedNextPrompt.metadata) === null || _a === void 0 ? void 0 : _a['args']) || '';
                     if (processedContent.includes(this.ARGS_PLACEHOLDER)) {
                         processedContent = processedContent.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), args);
                         contentModified = true;
@@ -97,7 +97,7 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
         let processedPrompt = nextPrompt;
         for (const result of shellResults) {
             if (result.content && typeof result.content === 'string') {
-                const args = ((_a = processedPrompt.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
+                const args = ((_a = processedPrompt.metadata) === null || _a === void 0 ? void 0 : _a['args']) || '';
                 // Process any shell injections in the tool result content
                 if (result.content.includes(this.SHELL_TRIGGER)) {
                     const processedContent = await this.processShellInjections(result.content, args);
@@ -127,6 +127,8 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
         // Process injections in reverse order to maintain correct indices
         for (let i = injections.length - 1; i >= 0; i--) {
             const injection = injections[i];
+            if (!injection)
+                continue;
             try {
                 // Replace {{args}} in the command with shell-escaped args
                 const command = injection.command.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), this.escapeShellArg(args));
@@ -175,11 +177,12 @@ class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
         return injections;
     }
     validateCommand(command) {
+        var _a;
         if (!this.options.enableShellExecution) {
             throw new Error('Shell execution is disabled');
         }
         // Extract the base command (first word)
-        const baseCommand = command.trim().split(/\s+/)[0];
+        const baseCommand = (_a = command.trim().split(/\s+/)[0]) !== null && _a !== void 0 ? _a : '';
         // Check blocked commands
         if (this.options.blockedCommands.some(blocked => baseCommand.includes(blocked))) {
             throw new Error(`Command '${baseCommand}' is blocked for security reasons`);

package/dist/processor-pieces/preInferenceProcessors/chatCompressionModifier.d.ts

@@ -25,7 +25,7 @@ export declare class ChatCompressionModifier extends BasePreInferenceProcessor {
     private readonly options;
     private hasFailedCompressionAttempt;
     constructor(options?: ChatCompressionOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     tryCompressChat(messages: MessageObject[], force?: boolean): Promise<ChatCompressionInfo & {
         compressedMessages?: MessageObject[];
     }>;

package/dist/processor-pieces/preInferenceProcessors/chatCompressionModifier.js

@@ -27,6 +27,7 @@ var CompressionStatus;
  * Returns the index of the content after the fraction of the total characters in the history.
  */
 function findIndexAfterFraction(history, fraction) {
+    var _a;
     if (fraction <= 0 || fraction >= 1) {
         throw new Error('Fraction must be between 0 and 1');
     }
@@ -35,7 +36,8 @@ function findIndexAfterFraction(history, fraction) {
     const targetCharacters = totalCharacters * fraction;
     let charactersSoFar = 0;
     for (let i = 0; i < contentLengths.length; i++) {
-        charactersSoFar += contentLengths[i];
+        const length = (_a = contentLengths[i]) !== null && _a !== void 0 ? _a : 0;
+        charactersSoFar += length;
         if (charactersSoFar >= targetCharacters) {
             return i;
         }
@@ -72,7 +74,7 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
             force: options.force || false
         };
     }
-    async modify(originalRequest, createdMessage) {
+    async modify(_originalRequest, createdMessage) {
         try {
             const compressionResult = await this.tryCompressChat(createdMessage.message.messages, this.options.force || false);
             if (compressionResult.compressionStatus === CompressionStatus.COMPRESSED) {
@@ -107,7 +109,6 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
         }
     }
     async tryCompressChat(messages, force = false) {
-        var _a;
         const curatedHistory = messages;
         // Regardless of `force`, don't do anything if the history is empty.
         if (curatedHistory.length === 0 ||
@@ -144,9 +145,12 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
         }
         let compressBeforeIndex = findIndexAfterFraction(curatedHistory, 1 - COMPRESSION_PRESERVE_THRESHOLD);
         // Find the first user message after the index. This is the start of the next turn.
-        while (compressBeforeIndex < curatedHistory.length &&
-            (((_a = curatedHistory[compressBeforeIndex]) === null || _a === void 0 ? void 0 : _a.role) === 'assistant' ||
-                isFunctionResponse(curatedHistory[compressBeforeIndex]))) {
+        while (compressBeforeIndex < curatedHistory.length) {
+            const currentMessage = curatedHistory[compressBeforeIndex];
+            if (!currentMessage)
+                break;
+            if (currentMessage.role !== 'assistant' && !isFunctionResponse(currentMessage))
+                break;
             compressBeforeIndex++;
         }
         const historyToCompress = curatedHistory.slice(0, compressBeforeIndex);
@@ -189,7 +193,7 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
             compressedMessages,
         };
     }
-    async countTokens(model, messages) {
+    async countTokens(_model, messages) {
         // Mock token counting - should be replaced with actual API call
         // Rough approximation: 4 characters per token
         const totalCharacters = messages.reduce((sum, msg) => {
@@ -200,15 +204,7 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
     async generateCompressionSummary(messages) {
         // This should use the actual compression prompt and LLM call
         // For now, using a simplified version similar to the original
-        const compressionPrompt = `You are tasked with creating a concise summary of a conversation history to preserve context while reducing token usage.
-
-Please analyze the conversation and create a state snapshot that captures:
-1. Key topics discussed
-2. Important decisions made
-3. Current context and progress
-4. Any ongoing tasks or issues
-
-Format your response as a clear, structured summary that maintains the essential information needed to continue the conversation effectively.`;
+        // Compression prompt would be used for LLM summarization in a full implementation
         // Mock LLM call - should be replaced with actual LLM integration
         const summaryParts = [];
         let userQuestions = [];

package/dist/processor-pieces/pretoolCallProcessors/toolParameterModifier.d.ts

@@ -7,7 +7,7 @@ import { PreToolCallProcessorInput, PreToolCallProcessorOutput } from '@codebolt
 export interface ParameterTransformation {
     sourcePath: string;
     targetPath: string;
-    transformation?: (value: any) => any;
+    transformation?: (value: unknown) => unknown;
     description?: string;
 }
 export interface ToolParameterModifierOptions {
@@ -15,7 +15,6 @@ export interface ToolParameterModifierOptions {
     toolNameMappings?: Record<string, string>;
 }
 export declare class ToolParameterModifier extends BasePreToolCallProcessor {
-    private options;
-    constructor(options: ToolParameterModifierOptions);
+    constructor(_options: ToolParameterModifierOptions);
     modify(input: PreToolCallProcessorInput): Promise<PreToolCallProcessorOutput>;
 }

package/dist/processor-pieces/pretoolCallProcessors/toolParameterModifier.js

@@ -7,9 +7,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolParameterModifier = void 0;
 const basePreToolCallProcessor_1 = require("../base/basePreToolCallProcessor");
 class ToolParameterModifier extends basePreToolCallProcessor_1.BasePreToolCallProcessor {
-    constructor(options) {
+    constructor(_options) {
         super();
-        this.options = options;
     }
     async modify(input) {
         // For now, pass through unchanged since we need to understand the exact structure

package/dist/processor-pieces/utils/messageModifierHelper.js

@@ -3,12 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addUserContext = exports.addSystemMessage = exports.mergeMessages = void 0;
 // Helper method to merge messages
 const mergeMessages = (existing, additional) => {
-    return {
+    const result = {
         message: {
             ...existing.message,
             ...additional.message,
             messages: [...existing.message.messages, ...additional.message.messages],
-            tools: additional.message.tools
         },
         metadata: {
             ...existing.metadata,
@@ -17,6 +16,10 @@ const mergeMessages = (existing, additional) => {
             mergedAt: new Date().toISOString()
         }
     };
+    if (additional.message.tools) {
+        result.message.tools = additional.message.tools;
+    }
+    return result;
 };
 exports.mergeMessages = mergeMessages;
 // Helper method to add system message

package/dist/types/InternalTypes.d.ts

@@ -158,20 +158,22 @@ export interface StateChangeEvent {
     newValue: any;
     timestamp: number;
 }
-export interface InternalError extends Error {
+export interface InternalErrorInfo {
     code: string;
     module: string;
     severity: 'low' | 'medium' | 'high' | 'critical';
-    context?: Record<string, any>;
+    context?: Record<string, unknown> | undefined;
     timestamp: number;
-    stackTrace?: string;
+    stackTrace?: string | undefined;
 }
-export declare class InternalError extends Error {
+export declare class InternalError extends Error implements InternalErrorInfo {
     code: string;
     module: string;
     severity: 'low' | 'medium' | 'high' | 'critical';
-    context?: Record<string, any> | undefined;
-    constructor(message: string, code: string, module: string, severity?: 'low' | 'medium' | 'high' | 'critical', context?: Record<string, any> | undefined);
+    context?: Record<string, unknown> | undefined;
+    timestamp: number;
+    stackTrace: string | undefined;
+    constructor(message: string, code: string, module: string, severity?: 'low' | 'medium' | 'high' | 'critical', context?: Record<string, unknown> | undefined);
 }
 export interface InternalEventMap {
     'websocket:connected': () => void;

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

@@ -59,8 +59,7 @@ class Agent {
             }
             return {
                 success: true,
-                result: prompt,
-                error: undefined
+                result: prompt
             };
         }
         catch (error) {

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

@@ -1,4 +1,4 @@
-import { AgentConfig, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor } from "@codebolt/types/agent";
+import { AgentConfig, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor, ProcessedMessage } from "@codebolt/types/agent";
 import { FlatUserMessage } from "@codebolt/types/sdk";
 /**
  * Configuration options for CodeboltAgent
@@ -9,6 +9,18 @@ export interface CodeboltAgentConfig extends AgentConfig {
      * Defaults to true.
      */
     enableLogging?: boolean;
+    /**
+     * Agent context to continue from.
+     * When provided, the agent will skip initial prompt generation
+     * and continue from where the previous agent left off.
+     */
+    context?: ProcessedMessage;
+    /**
+     * List of allowed tool names. If provided, only these tools will be available to the agent.
+     * If not provided, all tools will be available.
+     * Example: ['readFile', 'writeFile', 'executeCommand']
+     */
+    allowedTools?: string[];
 }
 /**
  * CodeboltAgent is a high-level agent class that:
@@ -69,18 +81,27 @@ export declare class CodeboltAgent {
     private readonly postToolCallProcessors;
     private readonly enableLogging;
     private readonly baseSystemPrompt;
+    private readonly context;
+    private readonly allowedTools;
     constructor(config: CodeboltAgentConfig);
     /**
      * Creates default message modifiers when none are provided
      */
     private createDefaultMessageModifiers;
+    /**
+     * Creates a default FlatUserMessage from a string
+     */
+    private createDefaultUserMessage;
     /**
      * Process a message through the agent pipeline.
      * This is the main entry point - triggered from graph nodes.
+     * @param message - Either a string message or a FlatUserMessage object
+     * @param context - Optional context from a previous agent to continue from
      */
-    processMessage(reqMessage: FlatUserMessage): Promise<{
+    processMessage(message: string | FlatUserMessage, context?: ProcessedMessage): Promise<{
         success: boolean;
         result: any;
+        context: ProcessedMessage | null;
         error?: string;
     }>;
     /**

package/dist/unified/agent/codeboltAgent.js

@@ -62,10 +62,12 @@ class CodeboltAgent {
         this.config = { ...config };
         this.enableLogging = config.enableLogging !== false;
         this.baseSystemPrompt = config.instructions || 'Based on User Message send reply';
+        this.context = config.context;
+        this.allowedTools = config.allowedTools;
         // 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.createDefaultMessageModifiers(this.baseSystemPrompt, this.allowedTools);
         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) || [];
@@ -74,7 +76,7 @@ class CodeboltAgent {
     /**
      * Creates default message modifiers when none are provided
      */
-    createDefaultMessageModifiers(systemPrompt) {
+    createDefaultMessageModifiers(systemPrompt, allowedTools) {
         return [
             // 1. Chat History
             new processor_pieces_1.ChatHistoryMessageModifier({ enableChatHistory: true }),
@@ -92,26 +94,65 @@ class CodeboltAgent {
             // 5. Core System Prompt (instructions)
             new processor_pieces_1.CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
             // 6. Tools (function declarations)
-            new processor_pieces_1.ToolInjectionModifier({ includeToolDescriptions: true }),
+            new processor_pieces_1.ToolInjectionModifier({
+                includeToolDescriptions: true,
+                ...(allowedTools && { allowedTools })
+            }),
             // 7. At-file processing (@file mentions)
             new processor_pieces_1.AtFileProcessorModifier({ enableRecursiveSearch: true })
         ];
     }
+    /**
+     * Creates a default FlatUserMessage from a string
+     */
+    createDefaultUserMessage(message) {
+        return {
+            userMessage: message,
+            selectedAgent: {
+                id: 'codebolt-agent',
+                name: 'Codebolt Agent'
+            },
+            mentionedFiles: [],
+            mentionedFullPaths: [],
+            mentionedFolders: [],
+            mentionedMCPs: [],
+            uploadedImages: [],
+            mentionedAgents: [],
+            messageId: `msg-${Date.now()}`,
+            threadId: `thread-${Date.now()}`
+        };
+    }
     /**
      * Process a message through the agent pipeline.
      * This is the main entry point - triggered from graph nodes.
+     * @param message - Either a string message or a FlatUserMessage object
+     * @param context - Optional context from a previous agent to continue from
      */
-    async processMessage(reqMessage) {
+    async processMessage(message, context) {
         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);
+            const reqMessage = typeof message === 'string'
+                ? this.createDefaultUserMessage(message)
+                : message;
+            // Use provided context, config context, or generate new one
+            const contextToUse = context || this.context;
+            let prompt;
+            if (contextToUse) {
+                if (this.enableLogging) {
+                    console.log('[CodeboltAgent] Continuing from previous context');
+                }
+                prompt = contextToUse;
+            }
+            else {
+                const promptGenerator = new base_1.InitialPromptGenerator({
+                    processors: this.messageModifiers,
+                    baseSystemPrompt: this.baseSystemPrompt,
+                    enableLogging: this.enableLogging
+                });
+                prompt = await promptGenerator.processMessage(reqMessage);
+            }
             let completed = false;
             while (!completed) {
                 const agentStep = new agentStep_1.AgentStep({
@@ -139,7 +180,7 @@ class CodeboltAgent {
             return {
                 success: true,
                 result: prompt,
-                error: undefined
+                context: prompt
             };
         }
         catch (error) {
@@ -150,6 +191,7 @@ class CodeboltAgent {
             return {
                 success: false,
                 result: null,
+                context: null,
                 error: errorMessage
             };
         }
@@ -196,6 +238,7 @@ exports.CodeboltAgent = CodeboltAgent;
  * Factory function to create a CodeboltAgent with common defaults
  */
 function createCodeboltAgent(options) {
+    var _a;
     return new CodeboltAgent({
         instructions: options.systemPrompt,
         processors: {
@@ -205,6 +248,6 @@ function createCodeboltAgent(options) {
             preToolCallProcessors: options.preToolCallProcessors || [],
             postToolCallProcessors: options.postToolCallProcessors || []
         },
-        enableLogging: options.enableLogging
+        enableLogging: (_a = options.enableLogging) !== null && _a !== void 0 ? _a : true
     });
 }

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

@@ -7,21 +7,17 @@ import { ToolConfig, ToolInterface } from '@codebolt/types/agent';
 export declare class Tool implements ToolInterface {
     id: string;
     description: string;
-    inputSchema: ZodType<any, any, any>;
-    outputSchema?: ZodType<any, any, any>;
-    executionFunction: (context: any) => any;
+    inputSchema: ZodType;
+    outputSchema?: ZodType | undefined;
+    executionFunction: (context: unknown) => unknown;
     constructor(config: ToolConfig);
-    execute(input: any, context: any): Promise<{
+    execute(input: unknown, context: unknown): Promise<{
         success: boolean;
-        error: string | undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        result: any;
-        error?: undefined;
+        result?: unknown;
+        error?: string;
     }>;
     getToolDescription(): string;
-    getToolSchema(): z.ZodType<any, any, any>;
+    getToolSchema(): z.ZodType<any, z.ZodTypeDef, any>;
     private validateInput;
     /**
      * Validates output against the tool's output schema (if provided)

package/dist/unified/agent/tools.js

@@ -17,13 +17,22 @@ class Tool {
     async execute(input, context) {
         const inputValidation = this.validateInput(input);
         if (!inputValidation.valid) {
-            return { success: false, error: inputValidation.error };
+            const result = { success: false };
+            if (inputValidation.error) {
+                result.error = inputValidation.error;
+            }
+            return result;
         }
         try {
-            let output = await this.executionFunction({ input, ...context });
+            const execContext = typeof context === 'object' && context !== null ? context : {};
+            const output = await this.executionFunction({ input, ...execContext });
             const outputValidation = this.validateOutput(output);
             if (!outputValidation.valid) {
-                return { success: false, error: outputValidation.error };
+                const result = { success: false };
+                if (outputValidation.error) {
+                    result.error = outputValidation.error;
+                }
+                return result;
             }
             return { success: true, result: output };
         }