@codebolt/agent 6.1.7 → 6.1.10

package/dist/processor-pieces/messageModifiers/capabilityContextModifier.d.ts

@@ -0,0 +1,14 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface CapabilityContextModifierOptions {
+    timeout?: number;
+}
+export declare class CapabilityContextModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: CapabilityContextModifierOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private normalizeCapabilities;
+    private resolveSelectedCapability;
+    private formatSelectedCapabilitiesContext;
+}

package/dist/processor-pieces/messageModifiers/capabilityContextModifier.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityContextModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("../../unified/base/promptContext");
+class CapabilityContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
+    async modify(originalRequest, createdMessage) {
+        const selectedCapabilities = this.normalizeCapabilities(originalRequest.selectedCapabilities);
+        if (selectedCapabilities.length === 0) {
+            return createdMessage;
+        }
+        const skillContexts = [];
+        const selectedCapabilityInfo = [];
+        const capabilityErrors = [];
+        for (const capabilityName of selectedCapabilities) {
+            const resolvedContext = await this.resolveSelectedCapability(capabilityName, originalRequest);
+            if (resolvedContext.info) {
+                selectedCapabilityInfo.push(resolvedContext.info);
+            }
+            if (resolvedContext.context) {
+                skillContexts.push(resolvedContext.context);
+            }
+            if (resolvedContext.error) {
+                capabilityErrors.push(resolvedContext.error);
+            }
+        }
+        const contextMessage = {
+            role: 'user',
+            content: this.formatSelectedCapabilitiesContext(selectedCapabilities, selectedCapabilityInfo, skillContexts),
+        };
+        return {
+            ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
+            metadata: {
+                ...createdMessage.metadata,
+                selectedCapabilities,
+                selectedCapabilitiesProcessed: true,
+                selectedCapabilityNames: skillContexts.map((context) => context.name),
+                selectedCapabilityErrors: capabilityErrors,
+            },
+        };
+    }
+    normalizeCapabilities(selectedCapabilities) {
+        if (!Array.isArray(selectedCapabilities)) {
+            return [];
+        }
+        return Array.from(new Set(selectedCapabilities
+            .map((capabilityName) => capabilityName.trim())
+            .filter(Boolean)));
+    }
+    async resolveSelectedCapability(capabilityName, originalRequest) {
+        var _a, _b;
+        try {
+            const capabilityDetail = await codeboltjs_1.default.capability.getCapabilityDetail(capabilityName);
+            if (!(capabilityDetail === null || capabilityDetail === void 0 ? void 0 : capabilityDetail.success) || !((_a = capabilityDetail.capability) === null || _a === void 0 ? void 0 : _a.type)) {
+                return {
+                    error: {
+                        name: capabilityName,
+                        error: (capabilityDetail === null || capabilityDetail === void 0 ? void 0 : capabilityDetail.error) || 'Capability detail did not include a capability type',
+                    },
+                };
+            }
+            const capabilityType = capabilityDetail.capability.type;
+            if (capabilityType !== 'skill') {
+                return {
+                    info: {
+                        name: capabilityName,
+                        type: capabilityType,
+                        autoLoaded: false,
+                        reason: 'Only skill capabilities are auto-loaded. Talents and powers stay selected and must be invoked with the capability tool if needed.',
+                    },
+                };
+            }
+            const response = await codeboltjs_1.default.capability.startSkill(capabilityName, {
+                arguments: originalRequest.userMessage,
+                input: originalRequest.userMessage,
+                task: originalRequest.userMessage,
+            }, this.options.timeout);
+            if (!(response === null || response === void 0 ? void 0 : response.success)) {
+                return {
+                    info: {
+                        name: capabilityName,
+                        type: capabilityType,
+                        autoLoaded: false,
+                    },
+                    error: {
+                        name: capabilityName,
+                        error: (response === null || response === void 0 ? void 0 : response.error) || 'Skill did not return a successful response',
+                    },
+                };
+            }
+            const skillPrompt = ((_b = response.additionalContext) === null || _b === void 0 ? void 0 : _b['skillPrompt']) || response.result;
+            const prompt = typeof (skillPrompt === null || skillPrompt === void 0 ? void 0 : skillPrompt.prompt) === 'string' ? skillPrompt.prompt.trim() : '';
+            if (!prompt) {
+                return {
+                    info: {
+                        name: capabilityName,
+                        type: capabilityType,
+                        autoLoaded: false,
+                    },
+                    error: {
+                        name: capabilityName,
+                        error: 'Skill response did not include prompt context',
+                    },
+                };
+            }
+            return {
+                info: {
+                    name: capabilityName,
+                    type: capabilityType,
+                    autoLoaded: true,
+                },
+                context: {
+                    name: skillPrompt.skillName || capabilityName,
+                    type: 'skill',
+                    prompt,
+                    refs: skillPrompt.refs,
+                    metadata: skillPrompt.metadata,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                error: {
+                    name: capabilityName,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    formatSelectedCapabilitiesContext(selectedCapabilities, selectedCapabilityInfo, skillContexts) {
+        const infoByName = new Map(selectedCapabilityInfo.map((info) => [info.name, info]));
+        const selectedSections = selectedCapabilities.map((capabilityName) => {
+            const info = infoByName.get(capabilityName);
+            const type = (info === null || info === void 0 ? void 0 : info.type) ? ` (${info.type})` : '';
+            const status = (info === null || info === void 0 ? void 0 : info.autoLoaded) ? 'skill context loaded' : 'not auto-loaded';
+            const reason = (info === null || info === void 0 ? void 0 : info.reason) ? ` - ${info.reason}` : '';
+            return `- ${capabilityName}${type}: ${status}${reason}`;
+        });
+        const skillContextSections = skillContexts.map((context) => {
+            const refs = Array.isArray(context.refs) && context.refs.length > 0
+                ? `\n\nCapability references:\n${context.refs.map((ref) => `- ${JSON.stringify(ref)}`).join('\n')}`
+                : '';
+            return `--- Selected skill capability: ${context.name} ---\n${context.prompt}${refs}`;
+        });
+        return [
+            'The user selected the following capabilities for this turn:',
+            ...selectedSections,
+            '',
+            'Skill capabilities are auto-loaded as prompt context below. Talents and powers are not auto-started.',
+            'Use the capability tool to inspect or invoke selected talents/powers only if the user request needs them.',
+            ...(skillContextSections.length > 0
+                ? ['', ...skillContextSections]
+                : []),
+        ].join('\n');
+    }
+}
+exports.CapabilityContextModifier = CapabilityContextModifier;

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

@@ -3,6 +3,7 @@ export { CoreSystemPromptModifier, type CoreSystemPromptOptions } from './coreSy
 export { DirectoryContextModifier, type DirectoryContextOptions } from './directoryContextModifier';
 export { IdeContextModifier, type IdeContextOptions, type FileInfo, type IdeContext } from './ideContextModifier';
 export { AtFileProcessorModifier, type AtFileProcessorOptions } from './atFileProcessorModifier';
+export { CapabilityContextModifier, type CapabilityContextModifierOptions } from './capabilityContextModifier';
 export { ArgumentProcessorModifier, type ArgumentProcessorOptions } from './argumentProcessorModifier';
 export { MemoryImportModifier, type MemoryImportOptions } from './memoryImportModifier';
 export { LoopDetectionModifier, type LoopDetectionOptions } from '../postInferenceProcessors/loopDetectionModifier';

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
+exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.CapabilityContextModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
 // Gemini-CLI equivalent modifiers
 var environmentContextModifier_1 = require("./environmentContextModifier");
 Object.defineProperty(exports, "EnvironmentContextModifier", { enumerable: true, get: function () { return environmentContextModifier_1.EnvironmentContextModifier; } });
@@ -12,6 +12,8 @@ var ideContextModifier_1 = require("./ideContextModifier");
 Object.defineProperty(exports, "IdeContextModifier", { enumerable: true, get: function () { return ideContextModifier_1.IdeContextModifier; } });
 var atFileProcessorModifier_1 = require("./atFileProcessorModifier");
 Object.defineProperty(exports, "AtFileProcessorModifier", { enumerable: true, get: function () { return atFileProcessorModifier_1.AtFileProcessorModifier; } });
+var capabilityContextModifier_1 = require("./capabilityContextModifier");
+Object.defineProperty(exports, "CapabilityContextModifier", { enumerable: true, get: function () { return capabilityContextModifier_1.CapabilityContextModifier; } });
 var argumentProcessorModifier_1 = require("./argumentProcessorModifier");
 Object.defineProperty(exports, "ArgumentProcessorModifier", { enumerable: true, get: function () { return argumentProcessorModifier_1.ArgumentProcessorModifier; } });
 var memoryImportModifier_1 = require("./memoryImportModifier");

package/package.json

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