@codebolt/agent 6.1.8 → 6.1.11

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

@@ -9,6 +9,6 @@ export declare class CapabilityContextModifier extends BaseMessageModifier {
     constructor(options?: CapabilityContextModifierOptions);
     modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private normalizeCapabilities;
-    private resolveCapabilityContext;
-    private formatCapabilityContext;
+    private resolveSelectedCapability;
+    private formatSelectedCapabilitiesContext;
 }

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

@@ -17,31 +17,24 @@ class CapabilityContextModifier extends base_1.BaseMessageModifier {
         if (selectedCapabilities.length === 0) {
             return createdMessage;
         }
-        const resolvedContexts = [];
+        const skillContexts = [];
+        const selectedCapabilityInfo = [];
         const capabilityErrors = [];
         for (const capabilityName of selectedCapabilities) {
-            const resolvedContext = await this.resolveCapabilityContext(capabilityName, originalRequest);
+            const resolvedContext = await this.resolveSelectedCapability(capabilityName, originalRequest);
+            if (resolvedContext.info) {
+                selectedCapabilityInfo.push(resolvedContext.info);
+            }
             if (resolvedContext.context) {
-                resolvedContexts.push(resolvedContext.context);
+                skillContexts.push(resolvedContext.context);
             }
             if (resolvedContext.error) {
                 capabilityErrors.push(resolvedContext.error);
             }
         }
-        if (resolvedContexts.length === 0) {
-            return {
-                ...createdMessage,
-                metadata: {
-                    ...createdMessage.metadata,
-                    selectedCapabilities,
-                    selectedCapabilityErrors: capabilityErrors,
-                    selectedCapabilitiesProcessed: false,
-                },
-            };
-        }
         const contextMessage = {
             role: 'user',
-            content: this.formatCapabilityContext(resolvedContexts),
+            content: this.formatSelectedCapabilitiesContext(selectedCapabilities, selectedCapabilityInfo, skillContexts),
         };
         return {
             ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
@@ -49,7 +42,7 @@ class CapabilityContextModifier extends base_1.BaseMessageModifier {
                 ...createdMessage.metadata,
                 selectedCapabilities,
                 selectedCapabilitiesProcessed: true,
-                selectedCapabilityNames: resolvedContexts.map((context) => context.name),
+                selectedCapabilityNames: skillContexts.map((context) => context.name),
                 selectedCapabilityErrors: capabilityErrors,
             },
         };
@@ -62,7 +55,7 @@ class CapabilityContextModifier extends base_1.BaseMessageModifier {
             .map((capabilityName) => capabilityName.trim())
             .filter(Boolean)));
     }
-    async resolveCapabilityContext(capabilityName, originalRequest) {
+    async resolveSelectedCapability(capabilityName, originalRequest) {
         var _a, _b;
         try {
             const capabilityDetail = await codeboltjs_1.default.capability.getCapabilityDetail(capabilityName);
@@ -75,16 +68,31 @@ class CapabilityContextModifier extends base_1.BaseMessageModifier {
                 };
             }
             const capabilityType = capabilityDetail.capability.type;
-            const response = await codeboltjs_1.default.capability.startCapability(capabilityName, capabilityType, {
+            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) || 'Capability did not return a successful response',
+                        error: (response === null || response === void 0 ? void 0 : response.error) || 'Skill did not return a successful response',
                     },
                 };
             }
@@ -92,16 +100,26 @@ class CapabilityContextModifier extends base_1.BaseMessageModifier {
             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: 'Capability response did not include prompt context',
+                        error: 'Skill response did not include prompt context',
                     },
                 };
             }
             return {
+                info: {
+                    name: capabilityName,
+                    type: capabilityType,
+                    autoLoaded: true,
+                },
                 context: {
                     name: skillPrompt.skillName || capabilityName,
-                    type: capabilityType,
+                    type: 'skill',
                     prompt,
                     refs: skillPrompt.refs,
                     metadata: skillPrompt.metadata,
@@ -117,17 +135,31 @@ class CapabilityContextModifier extends base_1.BaseMessageModifier {
             };
         }
     }
-    formatCapabilityContext(resolvedContexts) {
-        const contextSections = resolvedContexts.map((context) => {
+    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 capability: ${context.name} (${context.type}) ---\n${context.prompt}${refs}`;
+            return `--- Selected skill capability: ${context.name} ---\n${context.prompt}${refs}`;
         });
         return [
-            'The user selected the following capabilities for this turn. Use this capability context while answering the user.',
-            ...contextSections,
-        ].join('\n\n');
+            '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/package.json

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