@codebolt/agent 6.1.19 → 6.1.21

package/dist/unified/types/libTypes.d.ts

@@ -181,6 +181,12 @@ export interface CodeboltAPI {
         executeTool(toolName: string, params: unknown): Promise<{
             data: unknown;
         }>;
+        /** List registered project-local and plugin MCP tools */
+        getRegisteredTools(): Promise<{
+            data?: {
+                tools: OpenAITool[];
+            };
+        }>;
         /** List available MCP tools */
         listTools(): Promise<string[]>;
         /** Get tool schema */

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,13 +17,29 @@ 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') {
         return false;
     }
     const candidate = value;
-    return candidate.type === 'function' && typeof ((_a = candidate.function) === null || _a === void 0 ? void 0 : _a.name) === 'string';
+    return candidate.type === 'function' &&
+        typeof ((_a = candidate.function) === null || _a === void 0 ? void 0 : _a.name) === 'string' &&
+        candidate.function.name.trim().length > 0;
+}
+function getToolName(tool) {
+    var _a, _b;
+    return ((_b = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.trim()) || '';
+}
+function compareToolsByName(leftTool, rightTool) {
+    return getToolName(leftTool).localeCompare(getToolName(rightTool));
 }
 function hashString(value) {
     let hash = 0;
@@ -76,30 +95,87 @@ function normalizeToolResponse(response) {
     return tools.filter(isTool).map(normalizeToolForModel);
 }
 function mergeTools(...toolGroups) {
-    var _a;
     const mergedTools = new Map();
     for (const tools of toolGroups) {
         for (const tool of tools) {
-            const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
+            const toolName = getToolName(tool);
             if (toolName && !mergedTools.has(toolName)) {
                 mergedTools.set(toolName, tool);
             }
         }
     }
-    return Array.from(mergedTools.values());
+    return Array.from(mergedTools.values()).sort(compareToolsByName);
+}
+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') {
-        return [];
-    }
-    try {
-        return normalizeToolResponse(await mcp.getLocalMCPServers());
+    if (typeof mcp.getRegisteredTools === 'function') {
+        try {
+            return normalizeToolResponse(await mcp.getRegisteredTools());
+        }
+        catch (error) {
+            console.error('[AgentToolLoader] Failed to load registered MCP tools:', error);
+        }
     }
-    catch (error) {
-        console.error('[AgentToolLoader] Failed to load project-local tools:', error);
-        return [];
+    if (typeof mcp.getLocalMCPServers === 'function') {
+        try {
+            return normalizeToolResponse(await mcp.getLocalMCPServers());
+        }
+        catch (error) {
+            console.error('[AgentToolLoader] Failed to load project-local tools:', error);
+        }
     }
+    return [];
 }
 async function listAgentAvailableTools(mentionedMCPs = []) {
     let codeboltTools = [];
@@ -123,16 +199,6 @@ async function listAgentAvailableTools(mentionedMCPs = []) {
     return mergeTools(codeboltTools, localTools, mentionedTools);
 }
 function appendUniqueTools(targetTools, toolsToAppend) {
-    var _a;
-    const existingToolNames = new Set(targetTools
-        .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 tool of toolsToAppend) {
-        const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
-        if (!toolName || existingToolNames.has(toolName)) {
-            continue;
-        }
-        targetTools.push(tool);
-        existingToolNames.add(toolName);
-    }
+    const mergedTools = mergeTools(targetTools, toolsToAppend);
+    targetTools.splice(0, targetTools.length, ...mergedTools);
 }

package/package.json

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

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 } : {}),
-    });
-}