@codebolt/agent 6.1.19 → 6.1.20

package/README.md

@@ -23,35 +23,35 @@ Older examples that import from `@codebolt/agent/composable`, `@codebolt/agent/b
 ## Quick start
 
 ```typescript
-import { createCodeboltAgent } from '@codebolt/agent/unified';
+import { createAgent } from '@codebolt/agent/unified';
 
-const agent = createCodeboltAgent({
+const agent = createAgent({
   systemPrompt: 'You are a concise CodeBolt coding assistant.',
   allowedTools: ['read_file', 'write_file'],
   maxTurns: 10,
 });
 
-const result = await agent.processMessage('Inspect the current project and summarize it.');
+const result = await agent.run('Inspect the current project and summarize it.');
 
 if (!result.success) {
   throw new Error(result.error);
 }
 
-console.log(result.finalMessage ?? result.result);
+console.log(result.finalMessage ?? result.state?.prompt);
 ```
 
 ## Unified agent runtime
 
-Use `CodeboltAgent` or `createCodeboltAgent` for the default CodeBolt-aware runtime. It automatically adds common message modifiers for chat history, environment context, directory context, IDE context, system prompt injection, tool injection, and `@file` processing.
+Use `Agent` or `createAgent` for the default CodeBolt-aware runtime. It automatically adds common message modifiers for chat history, environment context, directory context, IDE context, system prompt injection, tool injection, and `@file` processing. Pass `includeDefaultModifiers: false` and `includeDefaultProcessors: false` when you need a bare runtime.
 
 ```typescript
 import {
-  CodeboltAgent,
+  Agent,
   ChatCompressionModifier,
   ToolValidationModifier,
 } from '@codebolt/agent/unified';
 
-const agent = new CodeboltAgent({
+const agent = new Agent({
   instructions: 'Help the user safely modify code.',
   processors: {
     preInferenceProcessors: [new ChatCompressionModifier()],
@@ -61,10 +61,19 @@ const agent = new CodeboltAgent({
   maxTurns: 25,
 });
 
-const response = await agent.processMessage('Fix the lint errors in this package.');
+const response = await agent.run('Fix the lint errors in this package.');
 ```
 
-For lower-level control, use `Agent`, `InitialPromptGenerator`, `AgentStep`, and `ResponseExecutor` from `@codebolt/agent/unified`.
+For lower-level control, disable defaults or use `InitialPromptGenerator`, `AgentStep`, and `ResponseExecutor` from `@codebolt/agent/unified`.
+
+Use `state` to continue a later run without depending on the internal prompt shape:
+
+```typescript
+const first = await agent.run('Inspect the project.');
+const second = await agent.run('Now summarize the risks.', {
+  state: first.state ?? undefined,
+});
+```
 
 ## Processor pieces
 
@@ -148,7 +157,7 @@ The unified framework includes layered compaction utilities:
 - `PostCompactCleanup`
 - `TokenEstimator`
 
-These are used by `Agent` and `CodeboltAgent` to reduce transcript size and recover from token-limit errors.
+These are used by `Agent` to reduce transcript size and recover from token-limit errors.
 
 ## Development
 

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

@@ -1,5 +1,46 @@
-import { AgentConfig, AgentInterface } from "@codebolt/types/agent";
+import { AgentConfig, AgentInterface, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor, ProcessedMessage, ToolResult } from "@codebolt/types/agent";
 import { FlatUserMessage } from "@codebolt/types/sdk";
+import { LoopDetectionService } from "../services/LoopDetectionService";
+import type { CompactionOrchestratorOptions } from "../services/compaction/types";
+export interface AgentOptions extends AgentConfig {
+    context?: ProcessedMessage;
+    allowedTools?: string[];
+    compaction?: CompactionOrchestratorOptions;
+    loopDetectionService?: LoopDetectionService;
+    maxTurns?: number;
+    includeDefaultModifiers?: boolean;
+    includeDefaultProcessors?: boolean;
+    messageModifiers?: MessageModifier[];
+    preInferenceProcessors?: PreInferenceProcessor[];
+    postInferenceProcessors?: PostInferenceProcessor[];
+    preToolCallProcessors?: PreToolCallProcessor[];
+    postToolCallProcessors?: PostToolCallProcessor[];
+}
+export interface AgentRunResult {
+    success: boolean;
+    state: AgentRunState | null;
+    toolResults: ToolResult[];
+    finalMessage?: string;
+    error?: string;
+    /**
+     * @deprecated Use `state.prompt` instead.
+     */
+    result: ProcessedMessage | null;
+    /**
+     * @deprecated Use `state` instead.
+     */
+    context: ProcessedMessage | null;
+}
+export interface AgentRunState {
+    prompt: ProcessedMessage;
+}
+export interface AgentRunOptions {
+    state?: AgentRunState;
+    context?: ProcessedMessage;
+}
+export interface CreateAgentOptions extends AgentOptions {
+    systemPrompt?: string;
+}
 export declare class Agent implements AgentInterface {
     private readonly config;
     private readonly messageModifiers;
@@ -8,15 +49,30 @@ export declare class Agent implements AgentInterface {
     private readonly preToolCallProcessors;
     private readonly postToolCallProcessors;
     private readonly enableLogging;
+    private readonly baseSystemPrompt;
+    private readonly context;
+    private readonly allowedTools;
     private readonly compactionOrchestrator;
     private readonly loopDetectionService;
     private readonly maxTurns;
-    constructor(config: AgentConfig);
+    private readonly localToolSchemas;
+    private readonly localToolsByExecutionName;
+    constructor(config: AgentOptions);
+    run(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
+    processMessage(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
     execute(reqMessage: FlatUserMessage): Promise<{
         success: boolean;
         result: any;
         error?: string;
     }>;
+    getConfig(): AgentOptions;
+    getMessageModifiers(): MessageModifier[];
+    getPreInferenceProcessors(): PreInferenceProcessor[];
+    getPostInferenceProcessors(): PostInferenceProcessor[];
+    getPreToolCallProcessors(): PreToolCallProcessor[];
+    getPostToolCallProcessors(): PostToolCallProcessor[];
+    private resolveRunContext;
+    private isProcessedMessage;
     private applyCompaction;
     private tryRecoverPrompt;
     private refreshAvailableTools;
@@ -24,3 +80,4 @@ export declare class Agent implements AgentInterface {
     private getRecoverableResponseError;
     private collectResponseMessages;
 }
+export declare function createAgent(options: CreateAgentOptions): Agent;

package/dist/unified/agent/agent.js

@@ -1,45 +1,147 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
+exports.createAgent = createAgent;
 const base_1 = require("../base");
 const agentStep_1 = require("../base/agentStep");
 const responseExecutor_1 = require("../base/responseExecutor");
 const promptContext_1 = require("../base/promptContext");
 const compactionOrchestrator_1 = require("../services/compaction/compactionOrchestrator");
 const agentToolLoader_1 = require("../utils/agentToolLoader");
+const processor_pieces_1 = require("../../processor-pieces");
+const DEFAULT_SYSTEM_PROMPT = 'Based on User Message send reply';
+function getProcessorKey(processor) {
+    var _a;
+    const candidate = processor;
+    if (typeof candidate.id === 'string' && candidate.id.length > 0) {
+        return candidate.id;
+    }
+    if (typeof candidate.name === 'string' && candidate.name.length > 0) {
+        return candidate.name;
+    }
+    if ((_a = candidate.constructor) === null || _a === void 0 ? void 0 : _a.name) {
+        return candidate.constructor.name;
+    }
+    return String(processor);
+}
+function mergeProcessors(defaults, custom) {
+    const merged = new Map();
+    for (const processor of defaults) {
+        merged.set(getProcessorKey(processor), processor);
+    }
+    for (const processor of custom) {
+        merged.set(getProcessorKey(processor), processor);
+    }
+    return Array.from(merged.values());
+}
+function createDefaultMessageModifiers(systemPrompt, allowedTools) {
+    return [
+        new processor_pieces_1.ChatHistoryMessageModifier({
+            enableChatHistory: true,
+            includeSystemMessages: false,
+        }),
+        new processor_pieces_1.EnvironmentContextModifier({ enableFullContext: true }),
+        new processor_pieces_1.DirectoryContextModifier(),
+        new processor_pieces_1.IdeContextModifier({
+            includeActiveFile: true,
+            includeOpenFiles: true,
+            includeCursorPosition: true,
+            includeSelectedText: true
+        }),
+        new processor_pieces_1.CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
+        new processor_pieces_1.ToolInjectionModifier({
+            includeToolDescriptions: true,
+            ...(allowedTools ? { allowedTools } : {})
+        }),
+        new processor_pieces_1.AtFileProcessorModifier({ enableRecursiveSearch: true })
+    ];
+}
+function createDefaultPreInferenceProcessors() {
+    return [];
+}
+function createDefaultPostInferenceProcessors() {
+    return [];
+}
+function createDefaultPreToolCallProcessors() {
+    return [];
+}
+function createDefaultPostToolCallProcessors() {
+    return [];
+}
+function createDefaultUserMessage(message) {
+    const timestamp = Date.now();
+    return {
+        userMessage: message,
+        selectedAgent: {
+            id: 'codebolt-agent',
+            name: 'Codebolt Agent'
+        },
+        mentionedFiles: [],
+        mentionedFullPaths: [],
+        mentionedFolders: [],
+        mentionedMCPs: [],
+        uploadedImages: [],
+        mentionedAgents: [],
+        mentionedEnvironments: [],
+        messageId: `msg-${timestamp}`,
+        threadId: `thread-${timestamp}`
+    };
+}
+function collectProcessors(fromNested, fromTopLevel) {
+    return [
+        ...(fromNested !== null && fromNested !== void 0 ? fromNested : []),
+        ...(fromTopLevel !== null && fromTopLevel !== void 0 ? fromTopLevel : []),
+    ];
+}
 class Agent {
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f;
-        const runtimeConfig = config;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const localToolRegistry = (0, agentToolLoader_1.createAgentLocalToolRegistry)(config.tools || []);
+        const includeDefaultModifiers = (_b = (_a = config.includeDefaultModifiers) !== null && _a !== void 0 ? _a : config.defaultProcessors) !== null && _b !== void 0 ? _b : true;
+        const includeDefaultProcessors = (_d = (_c = config.includeDefaultProcessors) !== null && _c !== void 0 ? _c : config.defaultProcessors) !== null && _d !== void 0 ? _d : true;
+        const customMessageModifiers = collectProcessors((_e = config.processors) === null || _e === void 0 ? void 0 : _e.messageModifiers, config.messageModifiers);
+        const defaultMessageModifiers = includeDefaultModifiers
+            ? createDefaultMessageModifiers(config.instructions || DEFAULT_SYSTEM_PROMPT, config.allowedTools)
+            : [];
         this.config = { ...config };
-        this.messageModifiers = ((_a = config.processors) === null || _a === void 0 ? void 0 : _a.messageModifiers) || [];
-        this.preInferenceProcessors = ((_b = config.processors) === null || _b === void 0 ? void 0 : _b.preInferenceProcessors) || [];
-        this.postInferenceProcessors = ((_c = config.processors) === null || _c === void 0 ? void 0 : _c.postInferenceProcessors) || [];
-        this.preToolCallProcessors = ((_d = config.processors) === null || _d === void 0 ? void 0 : _d.preToolCallProcessors) || [];
-        this.postToolCallProcessors = ((_e = config.processors) === null || _e === void 0 ? void 0 : _e.postToolCallProcessors) || [];
         this.enableLogging = config.enableLogging !== false;
-        this.compactionOrchestrator = new compactionOrchestrator_1.CompactionOrchestrator(runtimeConfig.compaction || {});
-        this.loopDetectionService = runtimeConfig.loopDetectionService;
-        this.maxTurns = (_f = runtimeConfig.maxTurns) !== null && _f !== void 0 ? _f : 25;
+        this.baseSystemPrompt = config.instructions || DEFAULT_SYSTEM_PROMPT;
+        this.context = config.context;
+        this.allowedTools = config.allowedTools;
+        this.messageModifiers = mergeProcessors(defaultMessageModifiers, customMessageModifiers);
+        this.preInferenceProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPreInferenceProcessors() : [], collectProcessors((_f = config.processors) === null || _f === void 0 ? void 0 : _f.preInferenceProcessors, config.preInferenceProcessors));
+        this.postInferenceProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPostInferenceProcessors() : [], collectProcessors((_g = config.processors) === null || _g === void 0 ? void 0 : _g.postInferenceProcessors, config.postInferenceProcessors));
+        this.preToolCallProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPreToolCallProcessors() : [], collectProcessors((_h = config.processors) === null || _h === void 0 ? void 0 : _h.preToolCallProcessors, config.preToolCallProcessors));
+        this.postToolCallProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPostToolCallProcessors() : [], collectProcessors((_j = config.processors) === null || _j === void 0 ? void 0 : _j.postToolCallProcessors, config.postToolCallProcessors));
+        this.compactionOrchestrator = new compactionOrchestrator_1.CompactionOrchestrator(config.compaction);
+        this.loopDetectionService = config.loopDetectionService;
+        this.maxTurns = (_l = (_k = config.maxTurns) !== null && _k !== void 0 ? _k : config.maxIterations) !== null && _l !== void 0 ? _l : 25;
+        this.localToolSchemas = localToolRegistry.schemas;
+        this.localToolsByExecutionName = localToolRegistry.byExecutionName;
     }
-    async execute(reqMessage) {
-        var _a;
-        if (!reqMessage) {
-            return {
-                success: false,
-                result: null,
-                error: 'Request message is required'
-            };
-        }
+    async run(message, options) {
+        var _a, _b;
         try {
-            const promptGenerator = new base_1.InitialPromptGenerator({
-                processors: this.messageModifiers,
-                baseSystemPrompt: this.config.instructions || 'Based on User Message send reply',
-                enableLogging: this.enableLogging
-            });
-            let prompt = await promptGenerator.processMessage(reqMessage);
+            const reqMessage = typeof message === 'string'
+                ? createDefaultUserMessage(message)
+                : message;
+            let prompt;
+            const contextToUse = this.resolveRunContext(options);
+            if (contextToUse) {
+                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;
             let turnNumber = 0;
+            let finalMessage;
+            const toolResults = [];
             while (!completed) {
                 turnNumber += 1;
                 if (turnNumber > this.maxTurns) {
@@ -82,6 +184,7 @@ class Agent {
                 const responseExecutor = new responseExecutor_1.ResponseExecutor({
                     preToolCallProcessors: this.preToolCallProcessors,
                     postToolCallProcessors: this.postToolCallProcessors,
+                    localToolsByExecutionName: this.localToolsByExecutionName,
                     ...(this.loopDetectionService
                         ? { loopDetectionService: this.loopDetectionService }
                         : {}),
@@ -94,10 +197,17 @@ class Agent {
                 });
                 completed = executionResult.completed;
                 prompt = executionResult.nextMessage;
+                finalMessage = executionResult.finalMessage;
+                toolResults.push(...((_b = executionResult.toolResults) !== null && _b !== void 0 ? _b : []));
             }
+            const state = { prompt };
             return {
                 success: true,
-                result: prompt
+                state,
+                toolResults,
+                ...(finalMessage !== undefined ? { finalMessage } : {}),
+                result: prompt,
+                context: prompt,
             };
         }
         catch (error) {
@@ -107,11 +217,51 @@ class Agent {
             }
             return {
                 success: false,
+                state: null,
+                toolResults: [],
                 result: null,
+                context: null,
                 error: errorMessage
             };
         }
     }
+    async processMessage(message, options) {
+        return this.run(message, options);
+    }
+    async execute(reqMessage) {
+        return this.run(reqMessage);
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    getMessageModifiers() {
+        return [...this.messageModifiers];
+    }
+    getPreInferenceProcessors() {
+        return [...this.preInferenceProcessors];
+    }
+    getPostInferenceProcessors() {
+        return [...this.postInferenceProcessors];
+    }
+    getPreToolCallProcessors() {
+        return [...this.preToolCallProcessors];
+    }
+    getPostToolCallProcessors() {
+        return [...this.postToolCallProcessors];
+    }
+    resolveRunContext(options) {
+        var _a, _b, _c;
+        if (!options) {
+            return this.context;
+        }
+        if (this.isProcessedMessage(options)) {
+            return options;
+        }
+        return (_c = (_b = (_a = options.state) === null || _a === void 0 ? void 0 : _a.prompt) !== null && _b !== void 0 ? _b : options.context) !== null && _c !== void 0 ? _c : this.context;
+    }
+    isProcessedMessage(value) {
+        return 'message' in value && 'metadata' in value;
+    }
     async applyCompaction(prompt) {
         const result = await this.compactionOrchestrator.compact((0, promptContext_1.getTranscriptMessages)(prompt));
         if (!result.wasCompacted) {
@@ -155,8 +305,9 @@ class Agent {
     }
     async refreshAvailableTools(originalRequest, prompt) {
         var _a, _b, _c;
-        if (((_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['toolsInjected']) !== true ||
-            ((_b = prompt.metadata) === null || _b === void 0 ? void 0 : _b['toolsLocation']) !== 'Tool') {
+        const shouldRefreshDiscoveredTools = ((_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['toolsInjected']) === true &&
+            ((_b = prompt.metadata) === null || _b === void 0 ? void 0 : _b['toolsLocation']) === 'Tool';
+        if (!shouldRefreshDiscoveredTools && this.localToolSchemas.length === 0) {
             return prompt;
         }
         const existingTools = Array.isArray(prompt.message.tools)
@@ -166,13 +317,21 @@ class Agent {
             const mentionedMCPs = Array.isArray(originalRequest.mentionedMCPs)
                 ? originalRequest.mentionedMCPs
                 : [];
-            let refreshedTools = await (0, agentToolLoader_1.listAgentAvailableTools)(mentionedMCPs);
+            let refreshedTools = shouldRefreshDiscoveredTools
+                ? await (0, agentToolLoader_1.listAgentAvailableTools)(mentionedMCPs)
+                : [];
+            (0, agentToolLoader_1.assertNoLocalToolSchemaCollisions)(this.localToolSchemas, refreshedTools);
             const allowedToolNames = this.getAllowedToolNames(prompt);
             if (allowedToolNames && allowedToolNames.length > 0) {
                 const allowed = new Set(allowedToolNames);
                 refreshedTools = refreshedTools.filter((tool) => { var _a; return !!((_a = tool.function) === null || _a === void 0 ? void 0 : _a.name) && allowed.has(tool.function.name); });
             }
-            const mergedTools = (0, agentToolLoader_1.mergeTools)(refreshedTools, existingTools);
+            let localToolSchemas = this.localToolSchemas;
+            if (allowedToolNames && allowedToolNames.length > 0) {
+                const allowed = new Set(allowedToolNames);
+                localToolSchemas = localToolSchemas.filter((tool) => { var _a; return !!((_a = tool.function) === null || _a === void 0 ? void 0 : _a.name) && allowed.has(tool.function.name); });
+            }
+            const mergedTools = (0, agentToolLoader_1.mergeTools)(localToolSchemas, refreshedTools, existingTools);
             return {
                 ...prompt,
                 message: {
@@ -190,6 +349,9 @@ class Agent {
             };
         }
         catch (error) {
+            if (error instanceof agentToolLoader_1.LocalToolConfigurationError) {
+                throw error;
+            }
             if (this.enableLogging) {
                 console.error('[Agent] Failed to refresh tools:', error);
             }
@@ -199,11 +361,13 @@ class Agent {
     getAllowedToolNames(prompt) {
         var _a;
         const metadataAllowedTools = (_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['allowedTools'];
-        if (!Array.isArray(metadataAllowedTools)) {
-            return undefined;
+        if (Array.isArray(metadataAllowedTools)) {
+            const allowedToolNames = metadataAllowedTools.filter((toolName) => typeof toolName === 'string' && toolName.length > 0);
+            if (allowedToolNames.length > 0) {
+                return allowedToolNames;
+            }
         }
-        const allowedToolNames = metadataAllowedTools.filter((toolName) => typeof toolName === 'string' && toolName.length > 0);
-        return allowedToolNames.length > 0 ? allowedToolNames : undefined;
+        return this.allowedTools;
     }
     getRecoverableResponseError(response) {
         var _a, _b, _c, _d;
@@ -241,3 +405,10 @@ class Agent {
     }
 }
 exports.Agent = Agent;
+function createAgent(options) {
+    const normalizedOptions = { ...options };
+    if (normalizedOptions.instructions === undefined && options.systemPrompt !== undefined) {
+        normalizedOptions.instructions = options.systemPrompt;
+    }
+    return new Agent(normalizedOptions);
+}

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

@@ -2,14 +2,14 @@
  * Tool creation utilities for the Unified Agent Framework
  */
 import { z, ZodType } from 'zod';
-import type { OpenAITool } from '../types/libTypes';
-import { ToolConfig, ToolInterface } from '@codebolt/types/agent';
+import type { Tool as OpenAITool } from '@codebolt/types/sdk';
+import { AgentLocalToolExecutionContext, ToolConfig, ToolInterface } from '@codebolt/types/agent';
 export declare class Tool implements ToolInterface {
     id: string;
     description: string;
     inputSchema: ZodType;
     outputSchema?: ZodType | undefined;
-    executionFunction: (context: unknown) => unknown;
+    executionFunction: (context: AgentLocalToolExecutionContext) => unknown;
     constructor(config: ToolConfig);
     execute(input: unknown, context: unknown): Promise<{
         success: boolean;

package/dist/unified/base/initialPromptGenerator.js

@@ -29,6 +29,61 @@ const formatFlagContext = (flags, mentionedFlags) => {
         '</flags>',
     ].join('\n');
 };
+const createImageUrlBlock = (mediaType, base64Data) => ({
+    type: 'image_url',
+    image_url: {
+        url: `data:${mediaType};base64,${base64Data}`,
+    },
+});
+const normalizeImageAttachment = (image) => {
+    var _a, _b;
+    if (!image)
+        return null;
+    if (typeof image === 'string') {
+        const dataUrlMatch = image.match(/^data:([^;,]+);base64,(.+)$/);
+        if (!dataUrlMatch)
+            return null;
+        const mediaType = dataUrlMatch[1];
+        const base64Data = dataUrlMatch[2];
+        if (!mediaType || !base64Data)
+            return null;
+        return createImageUrlBlock(mediaType, base64Data);
+    }
+    if (typeof image === 'object') {
+        const imageBlock = image;
+        if (imageBlock.type === 'image_url' &&
+            typeof ((_a = imageBlock.image_url) === null || _a === void 0 ? void 0 : _a.url) === 'string') {
+            return {
+                type: 'image_url',
+                image_url: {
+                    url: imageBlock.image_url.url,
+                },
+            };
+        }
+        if (imageBlock.type === 'image' &&
+            ((_b = imageBlock.source) === null || _b === void 0 ? void 0 : _b.type) === 'base64' &&
+            typeof imageBlock.source.media_type === 'string' &&
+            typeof imageBlock.source.data === 'string') {
+            return createImageUrlBlock(imageBlock.source.media_type, imageBlock.source.data);
+        }
+    }
+    return null;
+};
+const buildUserMessageContent = (text, uploadedImages) => {
+    const imageBlocks = (uploadedImages || [])
+        .map(normalizeImageAttachment)
+        .filter((image) => image !== null);
+    if (imageBlocks.length === 0) {
+        return text.trim();
+    }
+    return [
+        {
+            type: 'text',
+            text: text.trim() || 'Please use the attached image.',
+        },
+        ...imageBlocks,
+    ];
+};
 /**
  * Initial prompt generator that combines message modifiers with unified processing
  */
@@ -68,7 +123,7 @@ class InitialPromptGenerator {
             }
             createdMessage = (0, promptContext_1.appendTranscriptMessage)(createdMessage, {
                 role: 'user',
-                content: input.userMessage.trim(),
+                content: buildUserMessageContent(input.userMessage || '', input.uploadedImages),
             });
             const flagContext = formatFlagContext(input.flags, input.mentionedFlags);
             if (flagContext) {

package/dist/unified/base/responseExecutor.d.ts

@@ -1,4 +1,4 @@
-import { AgentResponseExecutor, PostToolCallProcessor, PreToolCallProcessor, ResponseInput, ResponseOutput } from '@codebolt/types/agent';
+import { AgentResponseExecutor, AgentLocalTool, PostToolCallProcessor, PreToolCallProcessor, ResponseInput, ResponseOutput } from '@codebolt/types/agent';
 import { LoopDetectionService } from '../services/LoopDetectionService';
 export declare class ResponseExecutor implements AgentResponseExecutor {
     private preToolCallProcessors;
@@ -6,10 +6,12 @@ export declare class ResponseExecutor implements AgentResponseExecutor {
     private completed;
     private finalMessage;
     private loopDetectionService;
+    private localToolsByExecutionName;
     constructor(options: {
         preToolCallProcessors: PreToolCallProcessor[];
         postToolCallProcessors: PostToolCallProcessor[];
         loopDetectionService?: LoopDetectionService;
+        localToolsByExecutionName?: Map<string, AgentLocalTool>;
     });
     executeResponse(input: ResponseInput): Promise<ResponseOutput>;
     private parseToolCall;

package/dist/unified/base/responseExecutor.js

@@ -16,6 +16,7 @@ class ResponseExecutor {
         this.preToolCallProcessors = options.preToolCallProcessors;
         this.postToolCallProcessors = options.postToolCallProcessors;
         this.loopDetectionService = options.loopDetectionService;
+        this.localToolsByExecutionName = options.localToolsByExecutionName || new Map();
     }
     async executeResponse(input) {
         var _a, _b, _c;
@@ -40,7 +41,7 @@ class ResponseExecutor {
             }
         }
         const compactionMessagePromise = this.runRequiredCompaction(input.rawLLMOutput);
-        const toolExecution = await this.executeTools(input.rawLLMOutput);
+        const toolExecution = await this.executeTools(input);
         const compactionCompleted = await compactionMessagePromise;
         if (compactionCompleted) {
             await Promise.resolve(codeboltjs_1.default.chat.sendMessage('Conversation Compacted'));
@@ -175,8 +176,9 @@ class ResponseExecutor {
             return false;
         }
     }
-    async executeTools(llmResponse) {
+    async executeTools(input) {
         var _a;
+        const llmResponse = input.rawLLMOutput;
         const lastMessageContent = this.extractLastMessageContent(llmResponse);
         const toolCalls = this.getToolCalls(llmResponse);
         if (toolCalls.length === 0) {
@@ -220,7 +222,7 @@ class ResponseExecutor {
                 toolResults.push(skippedResult);
                 continue;
             }
-            const executionResult = await this.executeSingleToolCall(currentToolCall);
+            const executionResult = await this.executeSingleToolCall(currentToolCall, input);
             toolResults.push(executionResult.toolResult);
             followUpMessages.push(...executionResult.followUpMessages);
             userRejectedToolUse = executionResult.didUserReject;
@@ -229,7 +231,7 @@ class ResponseExecutor {
             const completionToolCall = completionToolCalls.at(-1);
             if (completionToolCall) {
                 const completionArguments = completionToolCall.toolInput;
-                const [, completionResult] = await this.executeTool(completionToolCall.toolName, completionArguments);
+                const [, completionResult] = await this.executeTool(completionToolCall.toolName, completionArguments, input);
                 this.finalMessage = (_a = this.extractCompletionMessage(completionArguments)) !== null && _a !== void 0 ? _a : lastMessageContent;
                 await this.sendFinalMessageToChat(this.finalMessage);
                 const parsedCompletionResult = this.parseToolResult(completionToolCall.toolUseId, completionResult === '' ? 'The user is satisfied with the result.' : completionResult);
@@ -285,7 +287,7 @@ class ResponseExecutor {
             return String(value);
         }
     }
-    async executeSingleToolCall(toolCall) {
+    async executeSingleToolCall(toolCall, input) {
         try {
             let resultTuple;
             if (toolCall.toolName === 'codebolt--thread_management') {
@@ -309,7 +311,7 @@ class ResponseExecutor {
                 resultTuple = [false, 'tool result is successful'];
             }
             else {
-                resultTuple = await this.executeTool(toolCall.toolName, toolCall.toolInput);
+                resultTuple = await this.executeTool(toolCall.toolName, toolCall.toolInput, input);
             }
             const [didUserReject, result] = resultTuple;
             const parsedResult = this.parseToolResult(toolCall.toolUseId, result);
@@ -334,12 +336,26 @@ class ResponseExecutor {
             };
         }
     }
-    async executeTool(toolName, toolInput) {
-        var _a, _b, _c;
+    async executeTool(toolName, toolInput, input) {
+        var _a, _b, _c, _d;
         const executionToolName = (0, agentToolLoader_1.resolveToolExecutionName)(toolName);
+        const localTool = this.localToolsByExecutionName.get(executionToolName);
+        if (localTool) {
+            const localResult = await localTool.execute(toolInput, {
+                initialUserMessage: input.initialUserMessage,
+                llmMessageSent: input.actualMessageSentToLLM,
+                rawLLMResponse: input.rawLLMOutput,
+                nextMessage: input.nextMessage,
+                toolName: executionToolName,
+            });
+            if (!localResult.success) {
+                return [false, localResult.error || `Local tool "${executionToolName}" failed.`];
+            }
+            return [false, (_a = localResult.result) !== null && _a !== void 0 ? _a : ''];
+        }
         const parts = executionToolName.split('--');
-        const toolboxName = parts.length > 1 ? ((_a = parts[0]) !== null && _a !== void 0 ? _a : '') : 'codebolt';
-        const actualToolName = parts.length > 1 ? ((_b = parts[1]) !== null && _b !== void 0 ? _b : '') : ((_c = parts[0]) !== null && _c !== void 0 ? _c : '');
+        const toolboxName = parts.length > 1 ? ((_b = parts[0]) !== null && _b !== void 0 ? _b : '') : 'codebolt';
+        const actualToolName = parts.length > 1 ? ((_c = parts[1]) !== null && _c !== void 0 ? _c : '') : ((_d = parts[0]) !== null && _d !== void 0 ? _d : '');
         const { data } = await codeboltjs_1.default.mcp.executeTool(toolboxName, actualToolName, toolInput);
         if (Array.isArray(data) && data.length >= 2) {
             const [didUserReject, content] = data;

package/dist/unified/index.d.ts

@@ -16,8 +16,7 @@ export { AgentStep } from './base/agentStep';
 export { ResponseExecutor } from './base/responseExecutor';
 export { LoopDetectionService, LoopType } from './services/LoopDetectionService';
 export { CompressionCoordinator, type CompressionCoordinatorOptions, type CompressionDecision, type CompressionMetadata, type CompressionRecoveryResult, type CompressionStage, } from './services/CompressionCoordinator';
-export { Agent } from './agent/agent';
-export { CodeboltAgent, createCodeboltAgent, type CodeboltAgentConfig } from './agent/codeboltAgent';
+export { Agent, createAgent, type AgentOptions, type AgentRunResult, type AgentRunOptions, type AgentRunState, type CreateAgentOptions } from './agent/agent';
 export { Tool, createTool } from './agent/tools';
 export { Workflow } from './agent/workflow';
 export { type OpenAIMessage, type OpenAITool, type ToolResult, type CodeboltAPI, type AgentExecutionResult, type StreamChunk, type StreamCallback } from './types/libTypes';

package/dist/unified/index.js

@@ -10,7 +10,7 @@
  * The framework is designed to be modular, extensible, and easy to use.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenEstimator = exports.PostCompactCleanup = exports.ReactiveCompact = exports.AutoCompact = exports.ContextCollapse = exports.MicroCompact = exports.SnipCompact = exports.CompactionOrchestrator = exports.Workflow = exports.createTool = exports.Tool = exports.createCodeboltAgent = exports.CodeboltAgent = exports.Agent = exports.CompressionCoordinator = exports.LoopType = exports.LoopDetectionService = exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
+exports.TokenEstimator = exports.PostCompactCleanup = exports.ReactiveCompact = exports.AutoCompact = exports.ContextCollapse = exports.MicroCompact = exports.SnipCompact = exports.CompactionOrchestrator = exports.Workflow = exports.createTool = exports.Tool = exports.createAgent = exports.Agent = exports.CompressionCoordinator = exports.LoopType = exports.LoopDetectionService = exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
 // Error types
 var types_1 = require("./types/types");
 Object.defineProperty(exports, "UnifiedAgentError", { enumerable: true, get: function () { return types_1.UnifiedAgentError; } });
@@ -35,9 +35,7 @@ Object.defineProperty(exports, "CompressionCoordinator", { enumerable: true, get
 // Agent framework components
 var agent_1 = require("./agent/agent");
 Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
-var codeboltAgent_1 = require("./agent/codeboltAgent");
-Object.defineProperty(exports, "CodeboltAgent", { enumerable: true, get: function () { return codeboltAgent_1.CodeboltAgent; } });
-Object.defineProperty(exports, "createCodeboltAgent", { enumerable: true, get: function () { return codeboltAgent_1.createCodeboltAgent; } });
+Object.defineProperty(exports, "createAgent", { enumerable: true, get: function () { return agent_1.createAgent; } });
 var tools_1 = require("./agent/tools");
 Object.defineProperty(exports, "Tool", { enumerable: true, get: function () { return tools_1.Tool; } });
 Object.defineProperty(exports, "createTool", { enumerable: true, get: function () { return tools_1.createTool; } });

package/dist/unified/utils/agentToolLoader.d.ts

@@ -1,13 +1,23 @@
+import type { AgentLocalTool } from '@codebolt/types/agent';
 import type { Tool } from '@codebolt/types/sdk';
 type ToolResponse = {
     data?: {
         tools?: unknown;
     } | unknown;
 };
+export declare class LocalToolConfigurationError extends Error {
+    constructor(message: string);
+}
+export interface AgentLocalToolRegistry {
+    schemas: Tool[];
+    byExecutionName: Map<string, AgentLocalTool>;
+}
 export declare function normalizeToolForModel(tool: Tool): Tool;
 export declare function resolveToolExecutionName(modelToolName: string): string;
 export declare function normalizeToolResponse(response: ToolResponse | undefined): Tool[];
 export declare function mergeTools(...toolGroups: Tool[][]): Tool[];
+export declare function createAgentLocalToolRegistry(localTools?: AgentLocalTool[]): AgentLocalToolRegistry;
+export declare function assertNoLocalToolSchemaCollisions(localSchemas: Tool[], externalSchemas: Tool[]): void;
 export declare function listProjectLocalTools(): Promise<Tool[]>;
 export declare function listAgentAvailableTools(mentionedMCPs?: unknown[]): Promise<Tool[]>;
 export declare function appendUniqueTools(targetTools: Tool[], toolsToAppend: Tool[]): void;

package/dist/unified/utils/agentToolLoader.js

@@ -3,10 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalToolConfigurationError = void 0;
 exports.normalizeToolForModel = normalizeToolForModel;
 exports.resolveToolExecutionName = resolveToolExecutionName;
 exports.normalizeToolResponse = normalizeToolResponse;
 exports.mergeTools = mergeTools;
+exports.createAgentLocalToolRegistry = createAgentLocalToolRegistry;
+exports.assertNoLocalToolSchemaCollisions = assertNoLocalToolSchemaCollisions;
 exports.listProjectLocalTools = listProjectLocalTools;
 exports.listAgentAvailableTools = listAgentAvailableTools;
 exports.appendUniqueTools = appendUniqueTools;
@@ -14,6 +17,13 @@ const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const MODEL_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const LOCAL_TOOL_PREFIX = 'local/';
 const toolExecutionNameByModelName = new Map();
+class LocalToolConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LocalToolConfigurationError';
+    }
+}
+exports.LocalToolConfigurationError = LocalToolConfigurationError;
 function isTool(value) {
     var _a;
     if (!value || typeof value !== 'object') {
@@ -88,6 +98,57 @@ function mergeTools(...toolGroups) {
     }
     return Array.from(mergedTools.values());
 }
+function isAgentLocalTool(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === 'string' &&
+        candidate.id.length > 0 &&
+        typeof candidate.execute === 'function' &&
+        typeof candidate.toOpenAITool === 'function';
+}
+function createAgentLocalToolRegistry(localTools = []) {
+    var _a;
+    const schemas = [];
+    const byExecutionName = new Map();
+    const modelNames = new Set();
+    for (const localTool of localTools) {
+        if (!isAgentLocalTool(localTool)) {
+            throw new LocalToolConfigurationError('Agent local tools must be created with createTool(...) or implement id, execute(...), and toOpenAITool().');
+        }
+        if (byExecutionName.has(localTool.id)) {
+            throw new LocalToolConfigurationError(`Duplicate local agent tool id "${localTool.id}".`);
+        }
+        const schema = normalizeToolForModel(localTool.toOpenAITool());
+        const modelName = (_a = schema.function) === null || _a === void 0 ? void 0 : _a.name;
+        if (!modelName) {
+            throw new LocalToolConfigurationError(`Local agent tool "${localTool.id}" produced an invalid OpenAI tool schema.`);
+        }
+        if (modelNames.has(modelName)) {
+            throw new LocalToolConfigurationError(`Duplicate local agent tool model name "${modelName}".`);
+        }
+        schemas.push(schema);
+        modelNames.add(modelName);
+        byExecutionName.set(localTool.id, localTool);
+    }
+    return { schemas, byExecutionName };
+}
+function assertNoLocalToolSchemaCollisions(localSchemas, externalSchemas) {
+    var _a;
+    if (localSchemas.length === 0 || externalSchemas.length === 0) {
+        return;
+    }
+    const localToolNames = new Set(localSchemas
+        .map((tool) => { var _a; return (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name; })
+        .filter((toolName) => typeof toolName === 'string' && toolName.length > 0));
+    for (const externalSchema of externalSchemas) {
+        const externalToolName = (_a = externalSchema.function) === null || _a === void 0 ? void 0 : _a.name;
+        if (externalToolName && localToolNames.has(externalToolName)) {
+            throw new LocalToolConfigurationError(`Local agent tool "${externalToolName}" collides with an existing CodeBolt or MCP tool.`);
+        }
+    }
+}
 async function listProjectLocalTools() {
     const mcp = codeboltjs_1.default.mcp;
     if (typeof mcp.getLocalMCPServers !== 'function') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "6.1.19",
+  "version": "6.1.20",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -1,61 +0,0 @@
-import { AgentConfig, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor, ProcessedMessage } from "@codebolt/types/agent";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-import { LoopDetectionService } from "../services/LoopDetectionService";
-import type { CompactionOrchestratorOptions } from "../services/compaction/types";
-export interface CodeboltAgentConfig extends AgentConfig {
-    enableLogging?: boolean;
-    context?: ProcessedMessage;
-    allowedTools?: string[];
-    compaction?: CompactionOrchestratorOptions;
-    loopDetectionService?: LoopDetectionService;
-    maxTurns?: number;
-}
-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;
-    private readonly context;
-    private readonly allowedTools;
-    private readonly compactionOrchestrator;
-    private readonly loopDetectionService;
-    private readonly maxTurns;
-    constructor(config: CodeboltAgentConfig);
-    private createDefaultMessageModifiers;
-    private createDefaultUserMessage;
-    processMessage(message: string | FlatUserMessage, context?: ProcessedMessage): Promise<{
-        success: boolean;
-        result: any;
-        context: ProcessedMessage | null;
-        finalMessage?: string;
-        error?: string;
-    }>;
-    getConfig(): CodeboltAgentConfig;
-    getMessageModifiers(): MessageModifier[];
-    getPreInferenceProcessors(): PreInferenceProcessor[];
-    getPostInferenceProcessors(): PostInferenceProcessor[];
-    getPreToolCallProcessors(): PreToolCallProcessor[];
-    getPostToolCallProcessors(): PostToolCallProcessor[];
-    private applyCompaction;
-    private tryRecoverPrompt;
-    private refreshAvailableTools;
-    private getAllowedToolNames;
-    private getRecoverableResponseError;
-    private collectResponseMessages;
-}
-export declare function createCodeboltAgent(options: {
-    systemPrompt: string;
-    messageModifiers?: MessageModifier[];
-    preInferenceProcessors?: PreInferenceProcessor[];
-    postInferenceProcessors?: PostInferenceProcessor[];
-    preToolCallProcessors?: PreToolCallProcessor[];
-    postToolCallProcessors?: PostToolCallProcessor[];
-    enableLogging?: boolean;
-    compaction?: CompactionOrchestratorOptions;
-    loopDetectionService?: LoopDetectionService;
-    maxTurns?: number;
-}): CodeboltAgent;

package/dist/unified/agent/codeboltAgent.js

@@ -1,334 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeboltAgent = void 0;
-exports.createCodeboltAgent = createCodeboltAgent;
-const base_1 = require("../base");
-const agentStep_1 = require("../base/agentStep");
-const responseExecutor_1 = require("../base/responseExecutor");
-const promptContext_1 = require("../base/promptContext");
-const compactionOrchestrator_1 = require("../services/compaction/compactionOrchestrator");
-const agentToolLoader_1 = require("../utils/agentToolLoader");
-const processor_pieces_1 = require("../../processor-pieces");
-class CodeboltAgent {
-    constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        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;
-        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.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) || [];
-        this.postToolCallProcessors = ((_f = config.processors) === null || _f === void 0 ? void 0 : _f.postToolCallProcessors) || [];
-        this.compactionOrchestrator = new compactionOrchestrator_1.CompactionOrchestrator(config.compaction);
-        this.loopDetectionService = config.loopDetectionService;
-        this.maxTurns = (_g = config.maxTurns) !== null && _g !== void 0 ? _g : 25;
-    }
-    createDefaultMessageModifiers(systemPrompt, allowedTools) {
-        return [
-            new processor_pieces_1.ChatHistoryMessageModifier({
-                enableChatHistory: true,
-                includeSystemMessages: false,
-            }),
-            new processor_pieces_1.EnvironmentContextModifier({ enableFullContext: true }),
-            new processor_pieces_1.DirectoryContextModifier(),
-            new processor_pieces_1.IdeContextModifier({
-                includeActiveFile: true,
-                includeOpenFiles: true,
-                includeCursorPosition: true,
-                includeSelectedText: true
-            }),
-            new processor_pieces_1.CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
-            new processor_pieces_1.ToolInjectionModifier({
-                includeToolDescriptions: true,
-                ...(allowedTools && { allowedTools })
-            }),
-            new processor_pieces_1.AtFileProcessorModifier({ enableRecursiveSearch: true })
-        ];
-    }
-    createDefaultUserMessage(message) {
-        return {
-            userMessage: message,
-            selectedAgent: {
-                id: 'codebolt-agent',
-                name: 'Codebolt Agent'
-            },
-            mentionedFiles: [],
-            mentionedFullPaths: [],
-            mentionedFolders: [],
-            mentionedMCPs: [],
-            uploadedImages: [],
-            mentionedAgents: [],
-            mentionedEnvironments: [],
-            messageId: `msg-${Date.now()}`,
-            threadId: `thread-${Date.now()}`
-        };
-    }
-    async processMessage(message, context) {
-        var _a;
-        try {
-            const reqMessage = typeof message === 'string'
-                ? this.createDefaultUserMessage(message)
-                : message;
-            let prompt;
-            const contextToUse = context || this.context;
-            if (contextToUse) {
-                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;
-            let turnNumber = 0;
-            let finalMessage;
-            while (!completed) {
-                turnNumber += 1;
-                if (turnNumber > this.maxTurns) {
-                    throw new Error(`Agent exceeded the maximum turn limit of ${this.maxTurns}.`);
-                }
-                this.compactionOrchestrator.resetForTurn();
-                prompt = await this.applyCompaction(prompt);
-                prompt = await this.refreshAvailableTools(reqMessage, prompt);
-                const agentStep = new agentStep_1.AgentStep({
-                    preInferenceProcessors: this.preInferenceProcessors,
-                    postInferenceProcessors: this.postInferenceProcessors
-                });
-                let stepResult;
-                while (!stepResult) {
-                    try {
-                        const nextStepResult = await agentStep.executeStep(reqMessage, prompt);
-                        this.compactionOrchestrator.updateModelTokenLimit((_a = nextStepResult.rawLLMResponse) === null || _a === void 0 ? void 0 : _a.tokenLimit);
-                        const recoverableResponseError = this.getRecoverableResponseError(nextStepResult.rawLLMResponse);
-                        if (!recoverableResponseError) {
-                            stepResult = nextStepResult;
-                            break;
-                        }
-                        const recoveredPrompt = await this.tryRecoverPrompt(prompt, new Error(recoverableResponseError));
-                        if (!recoveredPrompt) {
-                            throw new Error(recoverableResponseError);
-                        }
-                        prompt = recoveredPrompt;
-                    }
-                    catch (error) {
-                        const recoveredPrompt = await this.tryRecoverPrompt(prompt, error);
-                        if (!recoveredPrompt) {
-                            throw error;
-                        }
-                        prompt = recoveredPrompt;
-                    }
-                }
-                if (!stepResult) {
-                    throw new Error('Agent step did not produce a response.');
-                }
-                const responseExecutor = new responseExecutor_1.ResponseExecutor({
-                    preToolCallProcessors: this.preToolCallProcessors,
-                    postToolCallProcessors: this.postToolCallProcessors,
-                    ...(this.loopDetectionService
-                        ? { loopDetectionService: this.loopDetectionService }
-                        : {}),
-                });
-                const executionResult = await responseExecutor.executeResponse({
-                    initialUserMessage: reqMessage,
-                    actualMessageSentToLLM: stepResult.actualMessageSentToLLM,
-                    rawLLMOutput: stepResult.rawLLMResponse,
-                    nextMessage: stepResult.nextMessage
-                });
-                completed = executionResult.completed;
-                prompt = executionResult.nextMessage;
-                finalMessage = executionResult.finalMessage;
-            }
-            return {
-                success: true,
-                result: prompt,
-                context: prompt,
-                ...(finalMessage !== undefined ? { finalMessage } : {}),
-            };
-        }
-        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,
-                context: null,
-                error: errorMessage
-            };
-        }
-    }
-    getConfig() {
-        return { ...this.config };
-    }
-    getMessageModifiers() {
-        return [...this.messageModifiers];
-    }
-    getPreInferenceProcessors() {
-        return [...this.preInferenceProcessors];
-    }
-    getPostInferenceProcessors() {
-        return [...this.postInferenceProcessors];
-    }
-    getPreToolCallProcessors() {
-        return [...this.preToolCallProcessors];
-    }
-    getPostToolCallProcessors() {
-        return [...this.postToolCallProcessors];
-    }
-    async applyCompaction(prompt) {
-        const result = await this.compactionOrchestrator.compact((0, promptContext_1.getTranscriptMessages)(prompt));
-        if (!result.wasCompacted) {
-            return prompt;
-        }
-        return {
-            ...(0, promptContext_1.replaceTranscriptMessages)(prompt, result.messages),
-            metadata: {
-                ...prompt.metadata,
-                compaction: {
-                    totalTokensFreed: result.totalTokensFreed,
-                    layersApplied: result.layersApplied,
-                    boundaries: result.boundaries,
-                    timestamp: new Date().toISOString(),
-                },
-            },
-        };
-    }
-    async tryRecoverPrompt(prompt, error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (!this.compactionOrchestrator.getReactiveLayer().isRecoverableError(errorMessage)) {
-            return null;
-        }
-        const recovery = await this.compactionOrchestrator.recoverFromError((0, promptContext_1.getTranscriptMessages)(prompt), error);
-        if (!recovery.wasCompacted) {
-            return null;
-        }
-        return {
-            ...(0, promptContext_1.replaceTranscriptMessages)(prompt, recovery.messages),
-            metadata: {
-                ...prompt.metadata,
-                reactiveCompaction: {
-                    totalTokensFreed: recovery.totalTokensFreed,
-                    layersApplied: recovery.layersApplied,
-                    boundaries: recovery.boundaries,
-                    timestamp: new Date().toISOString(),
-                    error: errorMessage,
-                },
-            },
-        };
-    }
-    async refreshAvailableTools(originalRequest, prompt) {
-        var _a, _b, _c;
-        if (((_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['toolsInjected']) !== true ||
-            ((_b = prompt.metadata) === null || _b === void 0 ? void 0 : _b['toolsLocation']) !== 'Tool') {
-            return prompt;
-        }
-        const existingTools = Array.isArray(prompt.message.tools)
-            ? prompt.message.tools
-            : [];
-        try {
-            const mentionedMCPs = Array.isArray(originalRequest.mentionedMCPs)
-                ? originalRequest.mentionedMCPs
-                : [];
-            let refreshedTools = await (0, agentToolLoader_1.listAgentAvailableTools)(mentionedMCPs);
-            const allowedToolNames = this.getAllowedToolNames(prompt);
-            if (allowedToolNames && allowedToolNames.length > 0) {
-                const allowed = new Set(allowedToolNames);
-                refreshedTools = refreshedTools.filter((tool) => { var _a; return !!((_a = tool.function) === null || _a === void 0 ? void 0 : _a.name) && allowed.has(tool.function.name); });
-            }
-            const mergedTools = (0, agentToolLoader_1.mergeTools)(refreshedTools, existingTools);
-            return {
-                ...prompt,
-                message: {
-                    ...prompt.message,
-                    tools: mergedTools,
-                    ...(mergedTools.length > 0
-                        ? { tool_choice: (_c = prompt.message.tool_choice) !== null && _c !== void 0 ? _c : 'auto' }
-                        : {}),
-                },
-                metadata: {
-                    ...prompt.metadata,
-                    toolsCount: mergedTools.length,
-                    toolsRefreshedAt: new Date().toISOString(),
-                },
-            };
-        }
-        catch (error) {
-            if (this.enableLogging) {
-                console.error('[CodeboltAgent] Failed to refresh tools:', error);
-            }
-            return prompt;
-        }
-    }
-    getAllowedToolNames(prompt) {
-        var _a;
-        const metadataAllowedTools = (_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['allowedTools'];
-        if (Array.isArray(metadataAllowedTools)) {
-            const allowedToolNames = metadataAllowedTools.filter((toolName) => typeof toolName === 'string' && toolName.length > 0);
-            if (allowedToolNames.length > 0) {
-                return allowedToolNames;
-            }
-        }
-        return this.allowedTools;
-    }
-    getRecoverableResponseError(response) {
-        var _a, _b, _c, _d;
-        const reactiveLayer = this.compactionOrchestrator.getReactiveLayer();
-        const candidateMessages = this.collectResponseMessages(response);
-        const recoverableMessage = candidateMessages.find((message) => reactiveLayer.isRecoverableError(message));
-        if (recoverableMessage) {
-            return recoverableMessage;
-        }
-        const finishReasons = [
-            response.finish_reason,
-            ...((_a = response.choices) !== null && _a !== void 0 ? _a : []).map((choice) => choice.finish_reason),
-        ].filter((reason) => typeof reason === 'string');
-        const hasLengthFinishReason = finishReasons.some((reason) => reason.toLowerCase() === 'length');
-        const hasToolCalls = ((_c = (_b = response.tool_calls) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0 ||
-            ((_d = response.choices) !== null && _d !== void 0 ? _d : []).some((choice) => { var _a, _b, _c; return ((_c = (_b = (_a = choice.message) === null || _a === void 0 ? void 0 : _a.tool_calls) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0; });
-        if (hasLengthFinishReason && candidateMessages.length === 0 && !hasToolCalls) {
-            return 'Too many tokens or token limit reached before producing usable output.';
-        }
-        return null;
-    }
-    collectResponseMessages(response) {
-        var _a, _b;
-        const messages = [];
-        if (typeof response.content === 'string' && response.content.trim().length > 0) {
-            messages.push(response.content.trim());
-        }
-        for (const choice of (_a = response.choices) !== null && _a !== void 0 ? _a : []) {
-            if (typeof ((_b = choice.message) === null || _b === void 0 ? void 0 : _b.content) === 'string' &&
-                choice.message.content.trim().length > 0) {
-                messages.push(choice.message.content.trim());
-            }
-        }
-        return messages;
-    }
-}
-exports.CodeboltAgent = CodeboltAgent;
-function createCodeboltAgent(options) {
-    var _a;
-    return new CodeboltAgent({
-        instructions: options.systemPrompt,
-        processors: {
-            messageModifiers: options.messageModifiers || [],
-            preInferenceProcessors: options.preInferenceProcessors || [],
-            postInferenceProcessors: options.postInferenceProcessors || [],
-            preToolCallProcessors: options.preToolCallProcessors || [],
-            postToolCallProcessors: options.postToolCallProcessors || []
-        },
-        enableLogging: (_a = options.enableLogging) !== null && _a !== void 0 ? _a : true,
-        ...(options.compaction ? { compaction: options.compaction } : {}),
-        ...(options.loopDetectionService ? { loopDetectionService: options.loopDetectionService } : {}),
-        ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
-    });
-}