@codebolt/agent 6.1.21 → 6.1.23

package/README.md

@@ -27,6 +27,7 @@ import { createAgent } from '@codebolt/agent/unified';
 
 const agent = createAgent({
   systemPrompt: 'You are a concise CodeBolt coding assistant.',
+  llmRole: 'codebolt.standard.text.fast',
   allowedTools: ['read_file', 'write_file'],
   maxTurns: 10,
 });

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

@@ -16,8 +16,9 @@ export declare class ChatHistoryMessageModifier extends BaseMessageModifier {
     private getChatHistory;
     setMaxHistoryMessages(max: number): void;
     private addMissingToolResponses;
+    private normalizeLegacyToolResponseMessage;
     private getStandaloneToolCall;
-    private getFunctionCallOutputId;
+    private getStandaloneToolResponseId;
     private getAssistantToolCallId;
     private getAssistantToolCallName;
     private getAssistantToolCallArguments;

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

@@ -82,9 +82,9 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
     addMissingToolResponses(historyMessages) {
         const existingToolResponseIds = new Set();
         for (const message of historyMessages) {
-            const functionCallOutputId = this.getFunctionCallOutputId(message);
-            if (functionCallOutputId) {
-                existingToolResponseIds.add(functionCallOutputId);
+            const standaloneToolResponseId = this.getStandaloneToolResponseId(message);
+            if (standaloneToolResponseId) {
+                existingToolResponseIds.add(standaloneToolResponseId);
             }
             if (typeof message.tool_call_id === 'string') {
                 existingToolResponseIds.add(message.tool_call_id);
@@ -92,7 +92,7 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
         }
         const repairedMessages = [];
         for (const message of historyMessages) {
-            repairedMessages.push(message);
+            repairedMessages.push(this.normalizeLegacyToolResponseMessage(message));
             const standaloneToolCall = this.getStandaloneToolCall(message);
             if (standaloneToolCall && !existingToolResponseIds.has(standaloneToolCall.id)) {
                 repairedMessages.push({
@@ -112,15 +112,29 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
                 const toolName = this.getAssistantToolCallName(toolCall);
                 const toolArguments = this.getAssistantToolCallArguments(toolCall);
                 repairedMessages.push({
-                    role: 'tool',
-                    content: this.buildMissingToolResponseContent(toolName, toolArguments),
-                    tool_call_id: toolCallId,
+                    type: 'function_call_output',
+                    call_id: toolCallId,
+                    output: this.buildMissingToolResponseContent(toolName, toolArguments),
+                    status: 'completed',
                 });
                 existingToolResponseIds.add(toolCallId);
             }
         }
         return repairedMessages;
     }
+    normalizeLegacyToolResponseMessage(message) {
+        if (message.role !== 'tool' || typeof message.tool_call_id !== 'string') {
+            return message;
+        }
+        return {
+            type: 'function_call_output',
+            call_id: message.tool_call_id,
+            output: typeof message.content === 'string'
+                ? message.content
+                : JSON.stringify(message.content),
+            status: 'completed',
+        };
+    }
     getStandaloneToolCall(message) {
         var _a, _b;
         const typedMessage = message;
@@ -151,9 +165,10 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
             arguments: toolArguments,
         };
     }
-    getFunctionCallOutputId(message) {
+    getStandaloneToolResponseId(message) {
         const typedMessage = message;
-        if (typedMessage.type === 'function_call_output' &&
+        if ((typedMessage.type === 'function_call_output' ||
+            typedMessage.type === 'tool_search_output') &&
             typeof typedMessage.call_id === 'string') {
             return typedMessage.call_id;
         }

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

@@ -8,6 +8,7 @@ export { ArgumentProcessorModifier, type ArgumentProcessorOptions } from './argu
 export { MemoryImportModifier, type MemoryImportOptions } from './memoryImportModifier';
 export { LoopDetectionModifier, type LoopDetectionOptions } from '../postInferenceProcessors/loopDetectionModifier';
 export { ToolInjectionModifier, type ToolInjectionOptions } from './toolInjectionModifier';
+export { ToolManifestPromptModifier, type ToolManifestPromptModifierOptions } from './toolManifestPromptModifier';
 export { ChatRecordingModifier, type ChatRecordingOptions } from './chatRecordingModifier';
 export { ChatHistoryMessageModifier, type ChatHistoryMessageModifierOptions } from './chatHistoryMessageModifier';
 export { ContextAssemblyModifier, type ContextAssemblyModifierOptions } from './contextAssemblyModifier';

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.CapabilityContextModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
+exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolManifestPromptModifier = 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; } });
@@ -22,6 +22,8 @@ var loopDetectionModifier_1 = require("../postInferenceProcessors/loopDetectionM
 Object.defineProperty(exports, "LoopDetectionModifier", { enumerable: true, get: function () { return loopDetectionModifier_1.LoopDetectionModifier; } });
 var toolInjectionModifier_1 = require("./toolInjectionModifier");
 Object.defineProperty(exports, "ToolInjectionModifier", { enumerable: true, get: function () { return toolInjectionModifier_1.ToolInjectionModifier; } });
+var toolManifestPromptModifier_1 = require("./toolManifestPromptModifier");
+Object.defineProperty(exports, "ToolManifestPromptModifier", { enumerable: true, get: function () { return toolManifestPromptModifier_1.ToolManifestPromptModifier; } });
 var chatRecordingModifier_1 = require("./chatRecordingModifier");
 Object.defineProperty(exports, "ChatRecordingModifier", { enumerable: true, get: function () { return chatRecordingModifier_1.ChatRecordingModifier; } });
 var chatHistoryMessageModifier_1 = require("./chatHistoryMessageModifier");

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

@@ -0,0 +1,18 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ToolManifestPromptModifierOptions {
+    mode?: "categories" | "list";
+    category?: string;
+    pattern?: string;
+    limit?: number;
+    includeDescriptions?: boolean;
+    includeResources?: boolean;
+    runtimeToolSetId?: string;
+    title?: string;
+}
+export declare class ToolManifestPromptModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ToolManifestPromptModifierOptions);
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolManifestPromptModifier = void 0;
+const base_1 = require("../base");
+const promptContext_1 = require("../../unified/base/promptContext");
+class ToolManifestPromptModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
+    async modify(_originalRequest, createdMessage) {
+        const codeboltjs = await import("@codebolt/codeboltjs");
+        const codeboltTools = codeboltjs.tools;
+        if (!(codeboltTools === null || codeboltTools === void 0 ? void 0 : codeboltTools.getAvailableToolsManifest) && !(codeboltTools === null || codeboltTools === void 0 ? void 0 : codeboltTools.getAvailableToolsManifestAsync)) {
+            return createdMessage;
+        }
+        const manifestOptions = {
+            mode: this.options.mode || "categories",
+        };
+        if (this.options.category !== undefined) {
+            manifestOptions.category = this.options.category;
+        }
+        if (this.options.pattern !== undefined) {
+            manifestOptions.pattern = this.options.pattern;
+        }
+        if (this.options.limit !== undefined) {
+            manifestOptions.limit = this.options.limit;
+        }
+        if (this.options.includeDescriptions !== undefined) {
+            manifestOptions.includeDescriptions = this.options.includeDescriptions;
+        }
+        if (this.options.includeResources !== undefined) {
+            manifestOptions.includeResources = this.options.includeResources;
+        }
+        if (this.options.runtimeToolSetId !== undefined) {
+            manifestOptions.runtimeToolSetId = this.options.runtimeToolSetId;
+        }
+        const manifest = codeboltTools.getAvailableToolsManifestAsync
+            ? await codeboltTools.getAvailableToolsManifestAsync(manifestOptions)
+            : codeboltTools.getAvailableToolsManifest(manifestOptions);
+        const contextMessage = {
+            role: "user",
+            content: `<tool_capability_catalogue title="${this.options.title || "Available CodeBolt tool areas"}">\n${manifest.text}\n</tool_capability_catalogue>`,
+        };
+        const updatedMessage = (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage);
+        return {
+            ...updatedMessage,
+            metadata: {
+                ...updatedMessage.metadata,
+                toolManifestInjected: true,
+                toolManifestMode: manifest.mode,
+                toolManifestTotalMatches: manifest.totalMatches,
+            },
+        };
+    }
+}
+exports.ToolManifestPromptModifier = ToolManifestPromptModifier;

package/dist/processor-pieces/postToolCallProcessors/conversationCompactorModifier.js

@@ -517,12 +517,16 @@ CRITICAL RULES:
         var _a;
         try {
             const prompt = this.getCompressionPrompt(historyToCompress);
-            const response = await codeboltjs_1.default.llm.inference({
+            const inferencePayload = {
+                formatVersion: 'codebolt.llm.v2',
                 input: [
                     { role: 'system', content: 'You are a precise conversation compression assistant.' },
                     { role: 'user', content: prompt }
                 ],
-            });
+                llmrole: this.options.llmRole,
+            };
+            console.log('[ConversationCompactor] llm.inference payload:', inferencePayload);
+            const response = await codeboltjs_1.default.llm.inference(inferencePayload);
             const summary = ((_a = response.completion) === null || _a === void 0 ? void 0 : _a.content) || '';
             if (this.options.enableLogging) {
                 console.log(`[ConversationCompactor] Generated summary (${summary.length} chars)`);
@@ -553,12 +557,16 @@ ORIGINAL MESSAGES COUNT: ${originalHistory.length}
 If the snapshot is accurate and complete, respond with just the original snapshot.
 If there are inaccuracies or missing critical information, provide a corrected version.
 Keep the same XML format.`;
-            const response = await codeboltjs_1.default.llm.inference({
+            const inferencePayload = {
+                formatVersion: 'codebolt.llm.v2',
                 input: [
                     { role: 'system', content: 'You are verifying a conversation compression for accuracy.' },
                     { role: 'user', content: verificationPrompt }
-                ]
-            });
+                ],
+                llmrole: this.options.llmRole,
+            };
+            console.log('[ConversationCompactor] llm.inference verification payload:', inferencePayload);
+            const response = await codeboltjs_1.default.llm.inference(inferencePayload);
             return ((_a = response.completion) === null || _a === void 0 ? void 0 : _a.content) || summary;
         }
         catch (error) {

package/dist/types/libFunctionTypes.d.ts

@@ -186,6 +186,16 @@ export interface UserMessage {
     mentionedFolders: string[];
     /** Images uploaded with the message */
     uploadedImages: string[];
+    /** Agent Prompt name for this message, when one was selected */
+    selectedAgentPromptName?: string;
+    /** Agent id that owns the selected Agent Prompt */
+    selectedAgentPromptAgentId?: string;
+    /** Prompt contributed by the selected Agent Prompt */
+    selectedAgentPromptText?: string;
+    /** Agent Prompt argument values used when rendering the prompt */
+    selectedAgentPromptArguments?: Record<string, string>;
+    /** Agent Prompt text combined with the raw user message */
+    effectiveUserMessage?: string;
     /** Selected agent information */
     selectedAgent: {
         id: string;
@@ -224,25 +234,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[];
+            };
         }>;
-        getRegisteredTools: () => Promise<{
-            data?: {
-                tools: OpenAITool[];
+        listExternalTools: (options?: {
+            namespace?: string;
+            sourceType?: ToolSourceType;
+            sourceId?: string;
+            grep?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                tools: RuntimeToolDescriptor[];
             };
         }>;
-        getTools: (mcps: any[]) => Promise<{
-            data: OpenAITool[];
+        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[];
+            };
         }>;
-        executeTool: (toolboxName: string, actualToolName: string, toolInput: any) => Promise<{
-            data: any;
+        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[];
+            };
+        }>;
+        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/types/socketMessageTypes.d.ts

@@ -45,7 +45,11 @@ export interface UserMessage {
         mentionedMultiFile: string[];
         mentionedMCPs: string[];
         uploadedImages: string[];
-        actions: any[];
+        selectedAgentPromptAgentId?: string;
+        selectedAgentPromptName?: string;
+        selectedAgentPromptText?: string;
+        selectedAgentPromptArguments?: Record<string, string>;
+        effectiveUserMessage?: string;
         mentionedAgents: any[];
         mentionedDocs: any[];
         mentionedEnvironments?: any[];
@@ -90,7 +94,11 @@ export interface ChatMessageFromUser {
     mentionedMultiFile: string[];
     mentionedMCPs: string[];
     uploadedImages: string[];
-    actions: any[];
+    selectedAgentPromptAgentId?: string;
+    selectedAgentPromptName?: string;
+    selectedAgentPromptText?: string;
+    selectedAgentPromptArguments?: Record<string, string>;
+    effectiveUserMessage?: string;
     mentionedAgents: any[];
     mentionedDocs: any[];
     mentionedEnvironments?: any[];

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,6 +56,7 @@ 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;
@@ -76,6 +78,7 @@ export declare class Agent implements AgentInterface {
     getPostToolCallProcessors(): PostToolCallProcessor[];
     private resolveRunContext;
     private getResumeMessageModifiers;
+    private normalizeLLMRole;
     private isProcessedMessage;
     private applyCompaction;
     private hydratePromptFromServerCompaction;

package/dist/unified/agent/agent.js

@@ -100,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;
@@ -113,14 +113,19 @@ 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)()}`;
@@ -165,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) {
@@ -306,6 +312,10 @@ class Agent {
     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;
     }

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

@@ -25,7 +25,7 @@ export declare class AgentStep implements AgentStepInterface {
     /**
      * Get current LLM configuration
      */
-    getLLMConfig(): string;
+    getLLMConfig(): string | undefined;
     updatePreInferenceProcessors(processors: PreInferenceProcessor[]): void;
     getPreInferenceProcessors(): PreInferenceProcessor[];
     updatePostInferenceProcessors(processors: PostInferenceProcessor[]): void;

package/dist/unified/base/agentStep.js

@@ -13,7 +13,7 @@ class AgentStep {
     constructor(options = {}) {
         this.preInferenceProcessors = options.preInferenceProcessors || [];
         this.postInferenceProcessors = options.postInferenceProcessors || [];
-        this.llmRole = options.llmRole || 'default';
+        this.llmRole = options.llmRole;
     }
     /**
      * Execute a single agent step
@@ -33,7 +33,10 @@ class AgentStep {
             }
             const actualMessageSentToLLM = {
                 ...preparedMessage,
-                message: (0, promptContext_1.buildInferenceParams)(preparedMessage),
+                message: {
+                    ...(0, promptContext_1.buildInferenceParams)(preparedMessage),
+                    ...(this.llmRole ? { llmrole: this.llmRole } : {}),
+                },
             };
             const rawLLMResponse = await this.generateResponse(actualMessageSentToLLM.message);
             const assistantResponseItems = ((_a = rawLLMResponse.items) !== null && _a !== void 0 ? _a : [])
@@ -64,6 +67,7 @@ class AgentStep {
     }
     async generateResponse(messageForLLM) {
         var _a, _b, _c, _d, _e;
+        console.log('[AgentStep] llm.inference payload:', messageForLLM);
         const response = await codeboltjs_1.default.llm.inference(messageForLLM);
         const completion = this.extractCompletion(response);
         if (!completion) {
@@ -129,7 +133,8 @@ class AgentStep {
      * Update LLM configuration
      */
     setLLMConfig(config) {
-        this.llmRole = config;
+        const normalized = config.trim();
+        this.llmRole = normalized ? normalized : undefined;
     }
     /**
      * Get current LLM configuration
@@ -140,14 +145,12 @@ class AgentStep {
     updatePreInferenceProcessors(processors) {
         this.preInferenceProcessors = processors;
     }
-    ;
     getPreInferenceProcessors() {
         return this.preInferenceProcessors;
     }
     updatePostInferenceProcessors(processors) {
         this.postInferenceProcessors = processors;
     }
-    ;
     getPostInferenceProcessors() {
         return this.postInferenceProcessors;
     }

package/dist/unified/base/initialPromptGenerator.js

@@ -145,9 +145,10 @@ class InitialPromptGenerator {
             if (!isResumedPrompt && this.baseSystemPrompt !== undefined) {
                 createdMessage = (0, promptContext_1.setSystemPrompt)(createdMessage, this.baseSystemPrompt);
             }
+            const userMessageText = input.effectiveUserMessage || input.userMessage || '';
             createdMessage = (0, promptContext_1.appendTranscriptMessage)(createdMessage, {
                 role: 'user',
-                content: buildUserMessageContent(input.userMessage || '', input.uploadedImages),
+                content: buildUserMessageContent(userMessageText, input.uploadedImages),
             });
             const flagContext = formatFlagContext(input.flags, input.mentionedFlags);
             if (flagContext) {