@bubblelab/bubble-core 0.1.197 → 0.1.199

package/dist/bubbles/service-bubble/ai-agent.d.ts

@@ -701,7 +701,14 @@ export declare class AIAgentBubble extends ServiceBubble<AIAgentParamsParsed, AI
     private shouldStopAfterTools;
     private shouldContinueToAgent;
     private rescueAttempts;
+    /** Current graph messages — kept in sync by executeToolsWithHooks so that
+     *  the use-capability tool can snapshot master state before delegation. */
+    private _currentGraphMessages;
+    /** Emit a trace event via executionMeta._onTrace (if wired by the host). */
+    private _trace;
     private static readonly MAX_RESCUE_ATTEMPTS;
+    /** Max characters for a single tool result before truncation (~50k chars ≈ ~12k tokens). */
+    private static readonly MAX_TOOL_RESULT_CHARS;
     constructor(params?: AIAgentParams, context?: BubbleContext, instanceId?: string);
     testCredential(): Promise<boolean>;
     /**

package/dist/bubbles/service-bubble/ai-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-agent.d.ts","sourceRoot":"","sources":["../../../src/bubbles/service-bubble/ai-agent.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ai-agent.d.ts","sourceRoot":"","sources":["../../../src/bubbles/service-bubble/ai-agent.ts"],"names":[],"mappings":"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"}

package/dist/bubbles/service-bubble/ai-agent.js

@@ -309,7 +309,19 @@ export class AIAgentBubble extends ServiceBubble {
     shouldStopAfterTools = false;
     shouldContinueToAgent = false;
     rescueAttempts = 0;
+    /** Current graph messages — kept in sync by executeToolsWithHooks so that
+     *  the use-capability tool can snapshot master state before delegation. */
+    _currentGraphMessages = [];
+    /** Emit a trace event via executionMeta._onTrace (if wired by the host). */
+    _trace(source, message, data) {
+        const onTrace = this.context?.executionMeta?._onTrace;
+        if (typeof onTrace === 'function') {
+            onTrace(source, message, data);
+        }
+    }
     static MAX_RESCUE_ATTEMPTS = 1;
+    /** Max characters for a single tool result before truncation (~50k chars ≈ ~12k tokens). */
+    static MAX_TOOL_RESULT_CHARS = 50_000;
     constructor(params = {
         message: 'Hello, how are you?',
         systemPrompt: 'You are a helpful AI assistant',
@@ -404,24 +416,40 @@ export class AIAgentBubble extends ServiceBubble {
         await applyCapabilityPreprocessing(this.params, this.context, this.resolveCapabilityCredentials.bind(this));
         // Extract execution metadata (used for conversation history + agent memory)
         const execMeta = this.context?.executionMeta;
+        // Memory injection — tools, prompt, and reflection are built externally (Pro)
+        // and passed via executionMeta. This keeps all memory logic out of OSS.
+        const isCapabilityAgent = this.params.name?.startsWith('Capability Agent:');
         // Inject Slack channel context into system prompt
-        const slackChannel = execMeta?._slackChannel;
-        if (slackChannel) {
-            this.params.systemPrompt = `${this.params.systemPrompt}\n**Current Slack channel:** ${slackChannel}`;
+        // Skip for capability agents (e.g. memory) — they only need their own prompt
+        if (!isCapabilityAgent) {
+            const slackChannel = execMeta?._slackChannel;
+            if (slackChannel) {
+                this.params.systemPrompt = `${this.params.systemPrompt}\n**Current Slack channel:** ${slackChannel}`;
+            }
+            // Inject bot identity and mention format context
+            const botDisplayName = execMeta?._selfBotDisplayName;
+            const selfBotUserId = execMeta?._selfBotUserId;
+            if (botDisplayName) {
+                let botContext = `**Your Slack identity:** ${botDisplayName}`;
+                if (selfBotUserId) {
+                    botContext += ` (user ID: ${selfBotUserId})`;
+                }
+                botContext += `\nIn Slack messages, \`<@userId>\` is a mention — when you see \`<@${selfBotUserId ?? 'your_id'}>\`, that's someone addressing you.`;
+                botContext += `\nConversation messages are prefixed with \`[Name (userId)]\` — this tells you who sent each message. Use these names when addressing users.`;
+                this.params.systemPrompt = `${this.params.systemPrompt}\n${botContext}`;
+            }
         }
         // Auto-inject trigger conversation history if no explicit conversationHistory was provided
         // This enables Slack thread context to automatically flow into AI agents
+        // Skip for capability agents (e.g. memory) — they only need their own prompt
         // Check both legacy path (context.triggerConversationHistory) and new path (executionMeta)
-        if (!this.params.conversationHistory?.length) {
+        if (!isCapabilityAgent && !this.params.conversationHistory?.length) {
             const convHistory = execMeta?.triggerConversationHistory ??
                 this.context?.triggerConversationHistory;
             if (convHistory?.length) {
                 this.params.conversationHistory = convHistory;
             }
         }
-        // Memory injection — tools, prompt, and reflection are built externally (Pro)
-        // and passed via executionMeta. This keeps all memory logic out of OSS.
-        const isCapabilityAgent = this.params.name?.startsWith('Capability Agent:');
         if (!isCapabilityAgent && this.params.memoryEnabled) {
             const memoryTools = execMeta?.memoryTools;
             const memorySystemPrompt = execMeta?.memorySystemPrompt;
@@ -1040,6 +1068,22 @@ export class AIAgentBubble extends ServiceBubble {
                     const capDef = getCapability(capabilityId);
                     if (!capConfig || !capDef)
                         return { error: `Capability "${capabilityId}" not found` };
+                    // Snapshot master agent state before delegation so that the
+                    // subagent's beforeToolCall hook can save both states if an
+                    // approval interrupt is triggered (fixes multi-cap state leak).
+                    const execMeta = this.context?.executionMeta;
+                    if (execMeta && this._currentGraphMessages.length > 0) {
+                        const { mapChatMessagesToStoredMessages } = await import('@langchain/core/messages');
+                        execMeta._masterAgentSnapshot = {
+                            messages: mapChatMessagesToStoredMessages(this._currentGraphMessages),
+                            capabilityId,
+                            capabilityTask: task,
+                        };
+                        this._trace('use-capability', `snapshotted master state before delegating`, {
+                            masterMsgCount: this._currentGraphMessages.length,
+                            capabilityId,
+                        });
+                    }
                     const subAgent = new AIAgentBubble({
                         message: task,
                         systemPrompt: '', // capability's systemPrompt fills this via beforeAction
@@ -1049,6 +1093,16 @@ export class AIAgentBubble extends ServiceBubble {
                         credentials: this.params.credentials,
                     }, this.context, `capability-${capabilityId}`);
                     const result = await subAgent.action();
+                    // Clean up snapshot after delegation completes
+                    if (execMeta) {
+                        delete execMeta._masterAgentSnapshot;
+                    }
+                    this._trace('use-capability', `subAgent returned`, {
+                        capabilityId,
+                        success: result.success,
+                        pendingApproval: !!execMeta?._pendingApproval,
+                        shouldStopAfterTools: this.shouldStopAfterTools,
+                    });
                     if (!result.success) {
                         return { success: false, error: result.error };
                     }
@@ -1252,8 +1306,15 @@ export class AIAgentBubble extends ServiceBubble {
         const toolMessages = [];
         let currentMessages = [...messages];
         let hooksModifiedMessages = false;
+        // Keep master snapshot in sync so use-capability can capture state
+        this._currentGraphMessages = currentMessages;
         // Reset stop flag at the start of tool execution
         this.shouldStopAfterTools = false;
+        this._trace('executeToolsWithHooks', `ENTRY`, {
+            toolCallCount: toolCalls.length,
+            toolCalls: toolCalls.map(tc => `${tc.name}(${tc.id?.slice(-8)})`).join(', '),
+            totalMsgs: messages.length,
+        });
         // Execute each tool call
         for (const toolCall of toolCalls) {
             const tool = tools.find((t) => t.name === toolCall.name);
@@ -1346,11 +1407,17 @@ export class AIAgentBubble extends ServiceBubble {
                 }
                 // Execute the tool
                 const toolOutput = await tool.invoke(toolCall.args);
-                // Create tool message
+                // Create tool message — cap result size to avoid blowing up LLM context
+                let toolContent = typeof toolOutput === 'string'
+                    ? toolOutput
+                    : JSON.stringify(toolOutput);
+                if (toolContent.length > AIAgentBubble.MAX_TOOL_RESULT_CHARS) {
+                    toolContent =
+                        toolContent.slice(0, AIAgentBubble.MAX_TOOL_RESULT_CHARS) +
+                            `\n\n[... truncated — result was ${toolContent.length} chars, limit is ${AIAgentBubble.MAX_TOOL_RESULT_CHARS}]`;
+                }
                 const toolMessage = new ToolMessage({
-                    content: typeof toolOutput === 'string'
-                        ? toolOutput
-                        : JSON.stringify(toolOutput),
+                    content: toolContent,
                     tool_call_id: toolCall.id,
                 });
                 toolMessages.push(toolMessage);
@@ -1431,6 +1498,17 @@ export class AIAgentBubble extends ServiceBubble {
     async createAgentGraph(llm, tools, systemPrompt) {
         // Define the agent node
         const agentNode = async ({ messages }) => {
+            this._trace('agentNode', `LLM CALL`, {
+                msgCount: messages.length,
+                lastMsgType: messages[messages.length - 1]?._getType(),
+                lastMsgPreview: (() => {
+                    const last = messages[messages.length - 1];
+                    if (!last)
+                        return '';
+                    const content = typeof last.content === 'string' ? last.content : JSON.stringify(last.content);
+                    return content.slice(0, 120);
+                })(),
+            });
             // systemPrompt is already enhanced by beforeAction() if expectedOutputSchema was provided
             // Use cache_control for Anthropic models to cache the system prompt across iterations
             const isAnthropic = llm instanceof ChatAnthropic;
@@ -1632,25 +1710,36 @@ export class AIAgentBubble extends ServiceBubble {
             const lastAIMessage = aiMessages[aiMessages.length - 1];
             // Check if the last AI message has tool calls
             if (lastAIMessage?.tool_calls && lastAIMessage.tool_calls.length > 0) {
+                this._trace('afterLLMCheck', `→ tools`, {
+                    toolCalls: lastAIMessage.tool_calls.map(tc => `${tc.name}(${tc.id?.slice(-8)})`).join(', '),
+                });
                 return 'tools';
             }
+            this._trace('afterLLMCheck', `→ __end__ (no tool calls)`);
             return '__end__';
         };
         // Define conditional edge after tools to check if we should stop
         const shouldContinueAfterTools = () => {
+            const execMeta = this.context?.executionMeta;
+            this._trace('shouldContinueAfterTools', `CHECK`, {
+                shouldStop: this.shouldStopAfterTools,
+                pendingApproval: !!execMeta?._pendingApproval,
+            });
             // Check if the afterToolCall hook requested stopping
             if (this.shouldStopAfterTools) {
+                this._trace('shouldContinueAfterTools', `→ __end__ (shouldStopAfterTools)`);
                 return '__end__';
             }
             // Check for pending approval signal from sub-agent (shared via executionMeta).
             // In multi-capability mode the master and sub-agent share the same BubbleContext,
             // so a sub-agent setting _pendingApproval is visible here.
-            const execMeta = this.context?.executionMeta;
             if (execMeta?._pendingApproval) {
+                this._trace('shouldContinueAfterTools', `→ __end__ (pendingApproval)`);
                 this.shouldStopAfterTools = true;
                 return '__end__';
             }
             // Otherwise continue back to agent
+            this._trace('shouldContinueAfterTools', `→ agent (continue)`);
             return 'agent';
         };
         // Build the graph
@@ -1685,10 +1774,128 @@ export class AIAgentBubble extends ServiceBubble {
         try {
             // Build messages array starting with conversation history (for KV cache optimization)
             const initialMessages = [];
+            let enrichedMessage;
             // Resume from saved agent state (lossless — preserves tool_calls, etc.)
             const resumeExecMeta = this.context?.executionMeta;
+            const resumeStateV2 = resumeExecMeta?._resumeAgentStateV2;
             const resumeState = resumeExecMeta?._resumeAgentState;
-            if (resumeState && Array.isArray(resumeState) && resumeState.length > 0) {
+            // Clear stale _pendingApproval ONLY when actually resuming, so that
+            // non-resume executeAgent calls (e.g. personality reflection) don't
+            // wipe the flag before postFlowAction reads it.
+            if (resumeExecMeta && (resumeStateV2 || resumeState)) {
+                delete resumeExecMeta._pendingApproval;
+            }
+            if (resumeStateV2 && resumeStateV2.__version === 2) {
+                // V2: Multi-cap scoped resume — master and subagent states are separate.
+                // Restore the master's messages, find the pending use-capability call,
+                // inject the subagent's state so it resumes via the V1 path, then
+                // execute the use-capability tool directly.
+                this._trace('v2-resume', `START`, {
+                    masterMsgs: resumeStateV2.masterState.length,
+                    subagentMsgs: resumeStateV2.subagentState.length,
+                    capabilityId: resumeStateV2.capabilityId,
+                    task: resumeStateV2.capabilityTask?.slice(0, 80),
+                });
+                const { mapStoredMessagesToChatMessages } = await import('@langchain/core/messages');
+                const masterRestored = mapStoredMessagesToChatMessages(resumeStateV2.masterState);
+                // Collect existing tool results
+                const existingToolResultIds = new Set();
+                for (const msg of masterRestored) {
+                    if (msg._getType() === 'tool') {
+                        const tm = msg;
+                        if (tm.tool_call_id)
+                            existingToolResultIds.add(tm.tool_call_id);
+                    }
+                }
+                // Build tool lookup for direct execution
+                const toolsByName = new Map();
+                if (tools) {
+                    for (const t of tools)
+                        toolsByName.set(t.name, t);
+                }
+                // Inject the subagent's state so the use-capability tool's subagent
+                // picks it up via the V1 resume path in its own executeAgent call.
+                // IMPORTANT: Delete _resumeAgentStateV2 BEFORE tool.invoke() so the
+                // subagent doesn't re-enter the V2 path (it shares executionMeta).
+                if (resumeExecMeta) {
+                    resumeExecMeta._resumeAgentState = resumeStateV2.subagentState;
+                    delete resumeExecMeta._resumeAgentStateV2;
+                }
+                // Repair master messages: find the pending use-capability tool call
+                // and execute it (which re-creates the subagent that resumes via V1).
+                const repairedMessages = [];
+                for (let i = 0; i < masterRestored.length; i++) {
+                    repairedMessages.push(masterRestored[i]);
+                    const msg = masterRestored[i];
+                    if (msg._getType() !== 'ai')
+                        continue;
+                    const aiMsg = msg;
+                    const pendingCalls = aiMsg.tool_calls?.filter((tc) => tc.id && !existingToolResultIds.has(tc.id));
+                    if (!pendingCalls?.length)
+                        continue;
+                    for (const tc of pendingCalls) {
+                        if (toolsByName.has(tc.name)) {
+                            try {
+                                this._trace('v2-resume', `executing tool "${tc.name}"`, {
+                                    callId: tc.id,
+                                    args: JSON.stringify(tc.args).slice(0, 200),
+                                });
+                                const tool = toolsByName.get(tc.name);
+                                // Sync _currentGraphMessages so use-capability can snapshot
+                                // master state for the subagent's beforeToolCall hook.
+                                // Without this, _masterAgentSnapshot is empty during V2 resume
+                                // and subsequent approvals fall to the V1 path, corrupting state.
+                                this._currentGraphMessages = [...repairedMessages];
+                                const result = await tool.invoke(tc.args);
+                                let content = typeof result === 'string' ? result : JSON.stringify(result);
+                                if (content.length > AIAgentBubble.MAX_TOOL_RESULT_CHARS) {
+                                    content =
+                                        content.slice(0, AIAgentBubble.MAX_TOOL_RESULT_CHARS) +
+                                            `\n\n[... truncated — result was ${content.length} chars, limit is ${AIAgentBubble.MAX_TOOL_RESULT_CHARS}]`;
+                                }
+                                repairedMessages.push(new ToolMessage({ content, tool_call_id: tc.id }));
+                            }
+                            catch (err) {
+                                console.warn(`[AIAgent] V2 resume: tool execution failed for "${tc.name}":`, err);
+                                repairedMessages.push(new ToolMessage({
+                                    content: `Tool execution failed: ${err instanceof Error ? err.message : String(err)}`,
+                                    tool_call_id: tc.id,
+                                }));
+                            }
+                        }
+                        else {
+                            repairedMessages.push(new ToolMessage({
+                                content: 'This action has been approved by the user. You may now execute this tool.',
+                                tool_call_id: tc.id,
+                            }));
+                        }
+                        existingToolResultIds.add(tc.id);
+                    }
+                }
+                // Clean up remaining resume state and pre-approval flag so that
+                // subsequent subagents (created by normal master loop) don't
+                // accidentally pick up stale state.
+                // Note: _resumeAgentStateV2 already deleted above (before tool.invoke).
+                if (resumeExecMeta) {
+                    delete resumeExecMeta._resumeAgentState;
+                    delete resumeExecMeta._approvedAction;
+                }
+                this._trace('v2-resume', `DONE`, {
+                    repairedMessages: repairedMessages.length,
+                    types: repairedMessages.map((m) => m._getType()).join(','),
+                    pendingApproval: !!resumeExecMeta?._pendingApproval,
+                    shouldStopAfterTools: this.shouldStopAfterTools,
+                });
+                // If a new approval was triggered during V2 resume (subagent set _pendingApproval),
+                // we should stop the master loop immediately to avoid re-executing.
+                if (resumeExecMeta?._pendingApproval) {
+                    this._trace('v2-resume', `_pendingApproval detected — will stop master loop`);
+                    this.shouldStopAfterTools = true;
+                }
+                initialMessages.push(...repairedMessages);
+            }
+            else if (resumeState && Array.isArray(resumeState) && resumeState.length > 0) {
+                this._trace('v1-resume', `restoring ${resumeState.length} messages (single-cap/subagent path)`);
                 const { mapStoredMessagesToChatMessages } = await import('@langchain/core/messages');
                 const restored = mapStoredMessagesToChatMessages(resumeState);
                 // Collect existing tool_call_ids that already have ToolMessage responses
@@ -1740,7 +1947,12 @@ export class AIAgentBubble extends ServiceBubble {
                                 console.log(`[AIAgent] Resume: executing approved tool "${tc.name}" directly`);
                                 const tool = toolsByName.get(tc.name);
                                 const result = await tool.invoke(tc.args);
-                                const content = typeof result === 'string' ? result : JSON.stringify(result);
+                                let content = typeof result === 'string' ? result : JSON.stringify(result);
+                                if (content.length > AIAgentBubble.MAX_TOOL_RESULT_CHARS) {
+                                    content =
+                                        content.slice(0, AIAgentBubble.MAX_TOOL_RESULT_CHARS) +
+                                            `\n\n[... truncated — result was ${content.length} chars, limit is ${AIAgentBubble.MAX_TOOL_RESULT_CHARS}]`;
+                                }
                                 repairedMessages.push(new ToolMessage({ content, tool_call_id: tc.id }));
                             }
                             catch (err) {
@@ -1772,7 +1984,8 @@ export class AIAgentBubble extends ServiceBubble {
             else if (conversationHistory && conversationHistory.length > 0) {
                 // Normal path: lossy ConversationMessage[] → BaseMessage[]
                 // This enables KV cache optimization by keeping previous turns as separate messages
-                // Pop the trigger (last entry) — it will be re-appended as the raw humanMessage
+                // Pop the trigger (last entry) — its enriched content replaces the raw message below
+                const lastHistoryMsg = conversationHistory[conversationHistory.length - 1];
                 for (const historyMsg of conversationHistory.slice(0, -1)) {
                     switch (historyMsg.role) {
                         case 'user':
@@ -1793,13 +2006,20 @@ export class AIAgentBubble extends ServiceBubble {
                             break;
                     }
                 }
+                // Use the enriched content from the last conversation history entry
+                // (includes user name, timezone) instead of the raw trigger message
+                if (lastHistoryMsg.role === 'user') {
+                    enrichedMessage = lastHistoryMsg.content;
+                }
             }
             // Create the current human message with text and optional images
+            // Prefer enriched message (with user name/timezone) over raw trigger text
+            const triggerMessage = enrichedMessage ?? message;
             let humanMessage;
             if (images && images.length > 0) {
                 console.log('[AIAgent] Creating multimodal message with', images.length, 'images');
                 // Create multimodal content array
-                const content = [{ type: 'text', text: message }];
+                const content = [{ type: 'text', text: triggerMessage }];
                 // Add images to content
                 for (const image of images) {
                     let imageUrl;
@@ -1843,16 +2063,26 @@ export class AIAgentBubble extends ServiceBubble {
             }
             else {
                 // Text-only message
-                humanMessage = new HumanMessage(message);
+                humanMessage = new HumanMessage(triggerMessage);
             }
             // In the resume flow the trigger message is already part of the saved
             // state (it was the HumanMessage that started the original execution).
             // Re-appending it causes the LLM to see the same request twice, which
             // triggers a duplicate tool call.  Skip it when resuming.
-            if (!resumeState) {
+            if (!resumeState && !resumeStateV2) {
                 initialMessages.push(humanMessage);
             }
+            this._trace('agent-loop', `STARTING graph.invoke`, {
+                initialMsgCount: initialMessages.length,
+                initialMsgTypes: initialMessages.map((m) => m._getType()).join(','),
+                shouldStopAfterTools: this.shouldStopAfterTools,
+                maxIterations,
+            });
             const result = await graph.invoke({ messages: initialMessages }, { recursionLimit: maxIterations });
+            this._trace('agent-loop', `graph.invoke COMPLETED`, {
+                totalMessages: result.messages.length,
+                pendingApproval: !!this.context?.executionMeta?._pendingApproval,
+            });
             console.log('[AIAgent] Graph execution completed');
             console.log('[AIAgent] Total messages:', result.messages.length);
             iterations = result.messages.length;