@codebolt/agent 6.1.20 → 6.1.22

package/dist/types/libFunctionTypes.d.ts

@@ -224,20 +224,152 @@ export interface EmitAgentEventResponse {
     };
     error?: string;
 }
+export type ToolSourceType = 'built-in' | 'mcp' | 'plugin' | 'project-local' | 'agent-local' | 'unknown';
+export interface ToolNamespace {
+    namespace: string;
+    sourceType?: ToolSourceType;
+    sourceId?: string;
+    displayName?: string;
+    toolCount?: number;
+}
+export interface ToolSource {
+    sourceId: string;
+    sourceType: ToolSourceType;
+    displayName?: string;
+    namespaces?: string[];
+    toolCount?: number;
+}
+export interface RuntimeToolDescriptor {
+    name: string;
+    toolName: string;
+    namespace: string;
+    sourceType: ToolSourceType;
+    sourceId?: string;
+    displayName?: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
 /**
  * Interface for codebolt API functionality
  */
 export interface CodeboltAPI {
-    mcp: {
-        listMcpFromServers: (servers: string[]) => Promise<{
-            data: OpenAITool[];
+    tools?: {
+        listBuiltInTools: (options?: {
+            namespace?: string;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                tools: RuntimeToolDescriptor[];
+            };
+        }>;
+        listExternalTools: (options?: {
+            namespace?: string;
+            sourceType?: ToolSourceType;
+            sourceId?: string;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                tools: RuntimeToolDescriptor[];
+            };
+        }>;
+        listRuntimeTools: (options?: {
+            includeBuiltIn?: boolean;
+            includeExternal?: boolean;
+            includeAgentLocal?: boolean;
+            agentLocalTools?: Array<OpenAITool | RuntimeToolDescriptor>;
+            namespace?: string;
+            sourceType?: ToolSourceType;
+            sourceId?: string;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                tools: RuntimeToolDescriptor[];
+            };
         }>;
-        getTools: (mcps: any[]) => Promise<{
-            data: OpenAITool[];
+        listToolNamespaces: (options?: {
+            includeBuiltIn?: boolean;
+            includeExternal?: boolean;
+            includeAgentLocal?: boolean;
+            agentLocalTools?: Array<OpenAITool | RuntimeToolDescriptor>;
+            namespace?: string;
+            sourceType?: ToolSourceType;
+            sourceId?: string;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                namespaces: ToolNamespace[];
+            };
         }>;
-        executeTool: (toolboxName: string, actualToolName: string, toolInput: any) => Promise<{
-            data: any;
+        listToolsByNamespace: (namespace: string, options?: {
+            includeBuiltIn?: boolean;
+            includeExternal?: boolean;
+            includeAgentLocal?: boolean;
+            agentLocalTools?: Array<OpenAITool | RuntimeToolDescriptor>;
+            sourceType?: ToolSourceType;
+            sourceId?: string;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                tools: RuntimeToolDescriptor[];
+            };
         }>;
+        listToolSources: (options?: {
+            includeBuiltIn?: boolean;
+            includeExternal?: boolean;
+            includeAgentLocal?: boolean;
+            agentLocalTools?: Array<OpenAITool | RuntimeToolDescriptor>;
+            namespace?: string;
+            sourceType?: ToolSourceType;
+            sourceId?: string;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                sources: ToolSource[];
+            };
+        }>;
+        listToolsBySource: (sourceId: string, options?: {
+            includeBuiltIn?: boolean;
+            includeExternal?: boolean;
+            includeAgentLocal?: boolean;
+            agentLocalTools?: Array<OpenAITool | RuntimeToolDescriptor>;
+            namespace?: string;
+            sourceType?: ToolSourceType;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                tools: RuntimeToolDescriptor[];
+            };
+        }>;
+        getRuntimeTool: (name: string) => Promise<{
+            data: {
+                tool?: RuntimeToolDescriptor;
+            };
+        }>;
+        execute: (toolName: string, toolInput?: any, options?: {
+            namespace?: string;
+            sourceId?: string;
+        }) => Promise<{
+            data?: any;
+            result?: any;
+        }>;
+    };
+    mcp: {
+        getEnabledMCPServers: () => Promise<unknown>;
+        getLocalMCPServers: () => Promise<unknown>;
+        getMentionedMCPServers: (userMessage: unknown) => Promise<unknown>;
+        searchAvailableMCPServers: (query: string) => Promise<unknown>;
+        configureMCPServer: (name: string, config: Record<string, unknown>) => Promise<unknown>;
+        getMcpList: () => Promise<unknown>;
+        getEnabledMcps: () => Promise<unknown>;
     };
     fs: {
         readFile: (filepath: string) => Promise<string>;

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

@@ -5,6 +5,7 @@ import type { CompactionOrchestratorOptions } from "../services/compaction/types
 export interface AgentOptions extends AgentConfig {
     context?: ProcessedMessage;
     allowedTools?: string[];
+    llmRole?: string;
     compaction?: CompactionOrchestratorOptions;
     loopDetectionService?: LoopDetectionService;
     maxTurns?: number;
@@ -55,10 +56,14 @@ export declare class Agent implements AgentInterface {
     private readonly compactionOrchestrator;
     private readonly loopDetectionService;
     private readonly maxTurns;
+    private readonly llmRole;
     private readonly localToolSchemas;
     private readonly localToolsByExecutionName;
+    private readonly runtimeToolSetId;
     constructor(config: AgentOptions);
     run(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
+    private registerRuntimeToolsForSearch;
+    private unregisterRuntimeToolsForSearch;
     processMessage(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
     execute(reqMessage: FlatUserMessage): Promise<{
         success: boolean;
@@ -72,8 +77,16 @@ export declare class Agent implements AgentInterface {
     getPreToolCallProcessors(): PreToolCallProcessor[];
     getPostToolCallProcessors(): PostToolCallProcessor[];
     private resolveRunContext;
+    private getResumeMessageModifiers;
+    private normalizeLLMRole;
     private isProcessedMessage;
     private applyCompaction;
+    private hydratePromptFromServerCompaction;
+    private isServerCompactionCurrent;
+    private extractCurrentRunMessages;
+    private isCurrentRunUserMessage;
+    private extractServerCompactedMessages;
+    private isServerCompactedMessage;
     private tryRecoverPrompt;
     private refreshAvailableTools;
     private getAllowedToolNames;

package/dist/unified/agent/agent.js

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
 exports.createAgent = createAgent;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const crypto_1 = require("crypto");
 const base_1 = require("../base");
 const agentStep_1 = require("../base/agentStep");
 const responseExecutor_1 = require("../base/responseExecutor");
@@ -95,7 +100,7 @@ function collectProcessors(fromNested, fromTopLevel) {
 }
 class Agent {
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         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;
@@ -108,27 +113,39 @@ class Agent {
         this.baseSystemPrompt = config.instructions || DEFAULT_SYSTEM_PROMPT;
         this.context = config.context;
         this.allowedTools = config.allowedTools;
+        this.llmRole = this.normalizeLLMRole(config.llmRole);
         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);
+        const compactionLLMRole = (_l = this.normalizeLLMRole((_k = config.compaction) === null || _k === void 0 ? void 0 : _k.llmRole)) !== null && _l !== void 0 ? _l : this.llmRole;
+        this.compactionOrchestrator = new compactionOrchestrator_1.CompactionOrchestrator({
+            ...config.compaction,
+            ...(compactionLLMRole ? { llmRole: compactionLLMRole } : {}),
+        });
         this.loopDetectionService = config.loopDetectionService;
-        this.maxTurns = (_l = (_k = config.maxTurns) !== null && _k !== void 0 ? _k : config.maxIterations) !== null && _l !== void 0 ? _l : 25;
+        this.maxTurns = (_o = (_m = config.maxTurns) !== null && _m !== void 0 ? _m : config.maxIterations) !== null && _o !== void 0 ? _o : 25;
         this.localToolSchemas = localToolRegistry.schemas;
         this.localToolsByExecutionName = localToolRegistry.byExecutionName;
+        this.runtimeToolSetId = `agent-${(0, crypto_1.randomUUID)()}`;
     }
     async run(message, options) {
         var _a, _b;
         try {
+            await this.registerRuntimeToolsForSearch();
             const reqMessage = typeof message === 'string'
                 ? createDefaultUserMessage(message)
                 : message;
             let prompt;
             const contextToUse = this.resolveRunContext(options);
             if (contextToUse) {
-                prompt = contextToUse;
+                const promptGenerator = new base_1.InitialPromptGenerator({
+                    processors: this.getResumeMessageModifiers(),
+                    initialPrompt: contextToUse,
+                    enableLogging: this.enableLogging
+                });
+                prompt = await promptGenerator.processMessage(reqMessage);
             }
             else {
                 const promptGenerator = new base_1.InitialPromptGenerator({
@@ -138,6 +155,7 @@ class Agent {
                 });
                 prompt = await promptGenerator.processMessage(reqMessage);
             }
+            prompt = await this.hydratePromptFromServerCompaction(reqMessage, prompt);
             let completed = false;
             let turnNumber = 0;
             let finalMessage;
@@ -152,7 +170,8 @@ class Agent {
                 prompt = await this.refreshAvailableTools(reqMessage, prompt);
                 const agentStep = new agentStep_1.AgentStep({
                     preInferenceProcessors: this.preInferenceProcessors,
-                    postInferenceProcessors: this.postInferenceProcessors
+                    postInferenceProcessors: this.postInferenceProcessors,
+                    ...(this.llmRole ? { llmRole: this.llmRole } : {}),
                 });
                 let stepResult;
                 while (!stepResult) {
@@ -224,6 +243,37 @@ class Agent {
                 error: errorMessage
             };
         }
+        finally {
+            await this.unregisterRuntimeToolsForSearch();
+        }
+    }
+    async registerRuntimeToolsForSearch() {
+        var _a, _b;
+        if (this.localToolSchemas.length === 0) {
+            return;
+        }
+        try {
+            await ((_b = (_a = codeboltjs_1.default.searchableAssets) === null || _a === void 0 ? void 0 : _a.registerRuntimeTools) === null || _b === void 0 ? void 0 : _b.call(_a, this.runtimeToolSetId, this.localToolSchemas));
+        }
+        catch (error) {
+            if (this.enableLogging) {
+                console.error('[Agent] Failed to register runtime tools for search:', error);
+            }
+        }
+    }
+    async unregisterRuntimeToolsForSearch() {
+        var _a, _b;
+        if (this.localToolSchemas.length === 0) {
+            return;
+        }
+        try {
+            await ((_b = (_a = codeboltjs_1.default.searchableAssets) === null || _a === void 0 ? void 0 : _a.unregisterRuntimeTools) === null || _b === void 0 ? void 0 : _b.call(_a, this.runtimeToolSetId));
+        }
+        catch (error) {
+            if (this.enableLogging) {
+                console.error('[Agent] Failed to unregister runtime tools for search:', error);
+            }
+        }
     }
     async processMessage(message, options) {
         return this.run(message, options);
@@ -259,6 +309,13 @@ class Agent {
         }
         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;
     }
+    getResumeMessageModifiers() {
+        return this.messageModifiers.filter((modifier) => { var _a; return ((_a = modifier.constructor) === null || _a === void 0 ? void 0 : _a.name) !== 'ChatHistoryMessageModifier'; });
+    }
+    normalizeLLMRole(llmRole) {
+        const normalized = llmRole === null || llmRole === void 0 ? void 0 : llmRole.trim();
+        return normalized ? normalized : undefined;
+    }
     isProcessedMessage(value) {
         return 'message' in value && 'metadata' in value;
     }
@@ -280,6 +337,111 @@ class Agent {
             },
         };
     }
+    async hydratePromptFromServerCompaction(requestMessage, prompt) {
+        if (!requestMessage.threadId) {
+            return prompt;
+        }
+        try {
+            const response = await codeboltjs_1.default.thread.getThreadContextCompacted({
+                threadId: requestMessage.threadId,
+            });
+            if (!this.isServerCompactionCurrent(response === null || response === void 0 ? void 0 : response.context)) {
+                return prompt;
+            }
+            const compactedMessages = this.extractServerCompactedMessages(response === null || response === void 0 ? void 0 : response.compactedContext);
+            if (compactedMessages.length === 0) {
+                return prompt;
+            }
+            const currentRunMessages = this.extractCurrentRunMessages(requestMessage, prompt);
+            return {
+                ...(0, promptContext_1.replaceTranscriptMessages)(prompt, [
+                    ...compactedMessages,
+                    ...currentRunMessages,
+                ]),
+                metadata: {
+                    ...prompt.metadata,
+                    serverCompaction: {
+                        threadId: requestMessage.threadId,
+                        timestamp: new Date().toISOString(),
+                        messageCount: compactedMessages.length,
+                        currentRunMessageCount: currentRunMessages.length,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            if (this.enableLogging) {
+                console.error('[Agent] Failed to hydrate prompt from server compaction:', error);
+            }
+            return prompt;
+        }
+    }
+    isServerCompactionCurrent(context) {
+        if (!context || typeof context !== 'object') {
+            return true;
+        }
+        const metadata = context.metadata;
+        if (!metadata || typeof metadata !== 'object') {
+            return true;
+        }
+        const messageCount = Number(metadata.messageCount);
+        const lastCompactionMessageCount = Number(metadata.lastCompactionMessageCount);
+        if (!Number.isFinite(messageCount) || !Number.isFinite(lastCompactionMessageCount)) {
+            return true;
+        }
+        return messageCount <= lastCompactionMessageCount;
+    }
+    extractCurrentRunMessages(requestMessage, prompt) {
+        const transcriptMessages = (0, promptContext_1.getTranscriptMessages)(prompt);
+        const lastMessage = transcriptMessages[transcriptMessages.length - 1];
+        if (!lastMessage || lastMessage.role !== 'user') {
+            return [];
+        }
+        const requestedContent = requestMessage.userMessage || '';
+        if (!this.isCurrentRunUserMessage(lastMessage, requestedContent)) {
+            return [];
+        }
+        return [{ ...lastMessage }];
+    }
+    isCurrentRunUserMessage(message, requestedContent) {
+        if (typeof message.content === 'string') {
+            return message.content === requestedContent ||
+                message.content.startsWith(`${requestedContent}\n\n`);
+        }
+        if (!Array.isArray(message.content)) {
+            return false;
+        }
+        const firstTextPart = message.content.find((part) => !!part &&
+            typeof part === 'object' &&
+            !Array.isArray(part) &&
+            part.type === 'text' &&
+            typeof part.text === 'string');
+        return (firstTextPart === null || firstTextPart === void 0 ? void 0 : firstTextPart.text) === requestedContent ||
+            (firstTextPart === null || firstTextPart === void 0 ? void 0 : firstTextPart.text.startsWith(`${requestedContent}\n\n`)) ||
+            (requestedContent.length === 0 && (firstTextPart === null || firstTextPart === void 0 ? void 0 : firstTextPart.text) === 'Please use the attached image.');
+    }
+    extractServerCompactedMessages(compactedContext) {
+        var _a;
+        const data = typeof compactedContext === 'object' && compactedContext !== null
+            ? compactedContext.data
+            : undefined;
+        const messages = typeof data === 'object' && data !== null
+            ? ((_a = data.input) !== null && _a !== void 0 ? _a : data.messages)
+            : undefined;
+        if (!Array.isArray(messages)) {
+            return [];
+        }
+        return messages
+            .filter((message) => this.isServerCompactedMessage(message))
+            .map((message) => ({ ...message }));
+    }
+    isServerCompactedMessage(value) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        const message = value;
+        return typeof message.role === 'string' && message.content !== undefined;
+    }
     async tryRecoverPrompt(prompt, error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (!this.compactionOrchestrator.getReactiveLayer().isRecoverableError(errorMessage)) {
@@ -370,35 +532,34 @@ class Agent {
         return this.allowedTools;
     }
     getRecoverableResponseError(response) {
-        var _a, _b, _c, _d;
+        var _a;
         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 finishReasons = [response.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; });
+        const hasToolCalls = ((_a = response.items) !== null && _a !== void 0 ? _a : []).some((item) => (item === null || item === void 0 ? void 0 : item.type) === 'function_call');
         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;
+        var _a;
         const messages = [];
-        if (typeof response.content === 'string' && response.content.trim().length > 0) {
-            messages.push(response.content.trim());
+        const outputText = response.output_text || response.content;
+        if (typeof outputText === 'string' && outputText.trim().length > 0) {
+            messages.push(outputText.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());
+        for (const item of (_a = response.items) !== null && _a !== void 0 ? _a : []) {
+            if ((item === null || item === void 0 ? void 0 : item.type) === 'message' && item.role === 'assistant') {
+                const content = item.content;
+                if (typeof content === 'string' && content.trim().length > 0) {
+                    messages.push(content.trim());
+                }
             }
         }
         return messages;

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

@@ -31,6 +31,20 @@ export declare class Tool implements ToolInterface {
      * @returns OpenAI function specification
      */
     toOpenAITool(): OpenAITool;
+    private getZodDef;
+    private getZodTypeName;
+    private getZodDescription;
+    private applyDescription;
+    private withDescriptionFrom;
+    private getObjectShape;
+    /**
+     * Converts a Zod schema to JSON Schema format for OpenAI functions.
+     *
+     * The converter intentionally checks Zod's schema metadata instead of
+     * relying only on instanceof. Local tools are often created in another
+     * workspace package with its own zod module instance, which makes
+     * instanceof checks fail even though the schema is valid.
+     */
     private zodSchemaToJsonSchema;
     /**
      * Converts individual Zod types to JSON Schema