@jupyterlite/ai 0.9.1 → 0.11.0

package/lib/agent.js

@@ -1,6 +1,6 @@
 import { Signal } from '@lumino/signaling';
-import { Agent, Runner, user } from '@openai/agents';
-import { BrowserMCPServerStreamableHttp } from './mcp/browser';
+import { ToolLoopAgent, stepCountIs } from 'ai';
+import { createMCPClient } from '@ai-sdk/mcp';
 import { createModel } from './providers/models';
 import { SECRETS_NAMESPACE } from './tokens';
 export class AgentManagerFactory {
@@ -8,7 +8,7 @@ export class AgentManagerFactory {
         Private.setToken(options.token);
         this._settingsModel = options.settingsModel;
         this._secretsManager = options.secretsManager;
-        this._mcpServers = [];
+        this._mcpClients = [];
         this._mcpConnectionChanged = new Signal(this);
         // Initialize agent on construction
         this._initializeAgents().catch(error => console.warn('Failed to initialize agent in constructor:', error));
@@ -35,7 +35,23 @@ export class AgentManagerFactory {
      * @returns True if the server is connected, false otherwise
      */
     isMCPServerConnected(serverName) {
-        return this._mcpServers.some(server => server.name === serverName);
+        return this._mcpClients.some(wrapper => wrapper.name === serverName);
+    }
+    /**
+     * Gets the MCP tools from connected servers
+     */
+    async getMCPTools() {
+        const mcpTools = {};
+        for (const wrapper of this._mcpClients) {
+            try {
+                const tools = await wrapper.client.tools();
+                Object.assign(mcpTools, tools);
+            }
+            catch (error) {
+                console.warn(`Failed to get tools from MCP server ${wrapper.name}:`, error);
+            }
+        }
+        return mcpTools;
     }
     /**
      * Handles settings changes and reinitializes the agent.
@@ -44,33 +60,36 @@ export class AgentManagerFactory {
         this._initializeAgents().catch(error => console.warn('Failed to initialize agent on settings change:', error));
     }
     /**
-     * Initializes MCP (Model Context Protocol) servers based on current settings.
-     * Closes existing servers and connects to enabled servers from configuration.
+     * Initializes MCP (Model Context Protocol) clients based on current settings.
+     * Closes existing clients and connects to enabled servers from configuration.
      */
-    async _initializeMCPServers() {
+    async _initializeMCPClients() {
         const config = this._settingsModel.config;
         const enabledServers = config.mcpServers.filter(server => server.enabled);
         let connectionChanged = false;
-        // Close existing servers
-        for (const server of this._mcpServers) {
+        // Close existing clients
+        for (const wrapper of this._mcpClients) {
             try {
-                await server.close();
+                await wrapper.client.close();
                 connectionChanged = true;
             }
             catch (error) {
-                console.warn('Error closing MCP server:', error);
+                console.warn('Error closing MCP client:', error);
             }
         }
-        this._mcpServers = [];
-        // Initialize new servers
+        this._mcpClients = [];
         for (const serverConfig of enabledServers) {
             try {
-                const mcpServer = new BrowserMCPServerStreamableHttp({
-                    url: serverConfig.url,
-                    name: serverConfig.name
+                const client = await createMCPClient({
+                    transport: {
+                        type: 'http',
+                        url: serverConfig.url
+                    }
+                });
+                this._mcpClients.push({
+                    name: serverConfig.name,
+                    client
                 });
-                await mcpServer.connect();
-                this._mcpServers.push(mcpServer);
                 connectionChanged = true;
             }
             catch (error) {
@@ -79,7 +98,7 @@ export class AgentManagerFactory {
         }
         // Emit connection change signal if there were any changes
         if (connectionChanged) {
-            this._mcpConnectionChanged.emit(this._mcpServers.length > 0);
+            this._mcpConnectionChanged.emit(this._mcpClients.length > 0);
         }
     }
     /**
@@ -92,10 +111,10 @@ export class AgentManagerFactory {
         }
         this._isInitializing = true;
         try {
-            await this._initializeMCPServers();
-            const mcpServers = this._mcpServers.filter(server => server !== null);
+            await this._initializeMCPClients();
+            const mcpTools = await this.getMCPTools();
             this._agentManagers.forEach(manager => {
-                manager.initializeAgent(mcpServers);
+                manager.initializeAgent(mcpTools);
             });
         }
         catch (error) {
@@ -108,7 +127,7 @@ export class AgentManagerFactory {
     _agentManagers = [];
     _settingsModel;
     _secretsManager;
-    _mcpServers;
+    _mcpClients;
     _mcpConnectionChanged;
     _isInitializing = false;
 }
@@ -120,7 +139,7 @@ const DEFAULT_MAX_TURNS = 25;
 /**
  * Manages the AI agent lifecycle and execution loop.
  * Provides agent initialization, tool management, MCP server integration,
- * and handles the complete agent execution cycle including tool approvals.
+ * and handles the complete agent execution cycle.
  * Emits events for UI updates instead of directly manipulating the chat interface.
  */
 export class AgentManager {
@@ -135,13 +154,10 @@ export class AgentManager {
         this._secretsManager = options.secretsManager;
         this._selectedToolNames = [];
         this._agent = null;
-        this._runner = new Runner({ tracingDisabled: true });
         this._history = [];
-        this._mcpServers = [];
+        this._mcpTools = {};
         this._isInitializing = false;
         this._controller = null;
-        this._pendingApprovals = new Map();
-        this._interruptedState = null;
         this._agentEvent = new Signal(this);
         this._tokenUsage = options.tokenUsage ?? {
             inputTokens: 0,
@@ -199,18 +215,18 @@ export class AgentManager {
         this.initializeAgent().catch(error => console.warn('Failed to initialize agent on tools change:', error));
     }
     /**
-     * Gets the currently selected tools as OpenAI agents tools.
-     * @returns Array of selected tools formatted for OpenAI agents
+     * Gets the currently selected tools as a record.
+     * @returns Record of selected tools
      */
     get selectedAgentTools() {
         if (!this._toolRegistry) {
-            return [];
+            return {};
         }
-        const result = [];
+        const result = {};
         for (const name of this._selectedToolNames) {
             const tool = this._toolRegistry.get(name);
             if (tool) {
-                result.push(tool);
+                result[name] = tool;
             }
         }
         return result;
@@ -238,14 +254,21 @@ export class AgentManager {
     }
     /**
      * Clears conversation history and resets agent state.
-     * Removes all conversation history, pending approvals, and interrupted state.
      */
     clearHistory() {
-        this._history = [];
-        this._runner = new Runner({ tracingDisabled: true });
+        // Stop any ongoing streaming
+        this.stopStreaming();
+        // Reject any pending approvals
+        for (const [approvalId, pending] of this._pendingApprovals) {
+            pending.resolve(false, 'Chat cleared');
+            this._agentEvent.emit({
+                type: 'tool_approval_resolved',
+                data: { approvalId, approved: false }
+            });
+        }
         this._pendingApprovals.clear();
-        this._interruptedState = null;
-        // Reset token usage
+        // Clear history and token usage
+        this._history = [];
         this._tokenUsage = { inputTokens: 0, outputTokens: 0 };
         this._tokenUsageChanged.emit(this._tokenUsage);
     }
@@ -255,13 +278,44 @@ export class AgentManager {
     stopStreaming() {
         this._controller?.abort();
     }
+    /**
+     * Approves a pending tool call.
+     * @param approvalId The approval ID to approve
+     * @param reason Optional reason for approval
+     */
+    approveToolCall(approvalId, reason) {
+        const pending = this._pendingApprovals.get(approvalId);
+        if (pending) {
+            pending.resolve(true, reason);
+            this._pendingApprovals.delete(approvalId);
+            this._agentEvent.emit({
+                type: 'tool_approval_resolved',
+                data: { approvalId, approved: true }
+            });
+        }
+    }
+    /**
+     * Rejects a pending tool call.
+     * @param approvalId The approval ID to reject
+     * @param reason Optional reason for rejection
+     */
+    rejectToolCall(approvalId, reason) {
+        const pending = this._pendingApprovals.get(approvalId);
+        if (pending) {
+            pending.resolve(false, reason);
+            this._pendingApprovals.delete(approvalId);
+            this._agentEvent.emit({
+                type: 'tool_approval_resolved',
+                data: { approvalId, approved: false }
+            });
+        }
+    }
     /**
      * Generates AI response to user message using the agent.
-     * Handles the complete execution cycle including tool calls and approvals.
+     * Handles the complete execution cycle including tool calls.
      * @param message The user message to respond to (may include processed attachment content)
      */
     async generateResponse(message) {
-        const config = this._settingsModel.config;
         this._controller = new AbortController();
         try {
             // Ensure we have an agent
@@ -271,140 +325,79 @@ export class AgentManager {
             if (!this._agent) {
                 throw new Error('Failed to initialize agent');
             }
-            const shouldUseTools = config.toolsEnabled &&
-                this._selectedToolNames.length > 0 &&
-                this._toolRegistry &&
-                Object.keys(this._toolRegistry.tools).length > 0 &&
-                this._supportsToolCalling();
             // Add user message to history
-            this._history.push(user(message));
-            // Get provider-specific maxTurns or use default
-            const activeProviderConfig = this._settingsModel.getProvider(this._activeProvider);
-            const maxTurns = activeProviderConfig?.parameters?.maxTurns ?? DEFAULT_MAX_TURNS;
-            // Main agentic loop
-            let result = await this._runner.run(this._agent, this._history, {
-                stream: true,
-                signal: this._controller.signal,
-                ...(shouldUseTools && { maxTurns })
+            this._history.push({
+                role: 'user',
+                content: message
             });
-            await this._processRunResult(result);
-            let hasInterruptions = result.interruptions && result.interruptions.length > 0;
-            while (hasInterruptions) {
-                this._interruptedState = result;
-                const interruptions = result.interruptions;
-                if (interruptions.length > 1) {
-                    await this._handleGroupedToolApprovals(interruptions);
-                }
-                else {
-                    await this._handleSingleToolApproval(interruptions[0]);
+            let continueLoop = true;
+            while (continueLoop) {
+                const result = await this._agent.stream({
+                    messages: this._history,
+                    abortSignal: this._controller.signal
+                });
+                const streamResult = await this._processStreamResult(result);
+                // Get response messages and update token usage
+                const responseMessages = await result.response;
+                this._updateTokenUsage(await result.usage);
+                // Add response messages to history
+                if (responseMessages.messages?.length) {
+                    this._history.push(...responseMessages.messages);
                 }
-                // Wait for all approvals to be resolved
-                while (this._pendingApprovals.size > 0) {
-                    await new Promise(resolve => setTimeout(resolve, 100));
+                // Add approval response if processed
+                if (streamResult.approvalResponse) {
+                    // Check if the last message is a tool message we can append to
+                    const lastMsg = this._history[this._history.length - 1];
+                    if (lastMsg &&
+                        lastMsg.role === 'tool' &&
+                        Array.isArray(lastMsg.content) &&
+                        Array.isArray(streamResult.approvalResponse.content)) {
+                        const toolContent = lastMsg.content;
+                        toolContent.push(...streamResult.approvalResponse.content);
+                    }
+                    else {
+                        // Add as separate message
+                        this._history.push(streamResult.approvalResponse);
+                    }
                 }
-                // Continue execution
-                result = await this._runner.run(this._agent, result.state, {
-                    stream: true,
-                    signal: this._controller.signal,
-                    maxTurns
-                });
-                await this._processRunResult(result);
-                hasInterruptions =
-                    result.interruptions && result.interruptions.length > 0;
+                continueLoop = streamResult.approvalProcessed;
             }
-            // Clear interrupted state
-            this._interruptedState = null;
-            this._history = result.history;
         }
         catch (error) {
-            this._agentEvent.emit({
-                type: 'error',
-                data: { error: error }
-            });
+            if (error.name !== 'AbortError') {
+                this._agentEvent.emit({
+                    type: 'error',
+                    data: { error: error }
+                });
+            }
         }
         finally {
             this._controller = null;
         }
     }
     /**
-     * Approves a tool call by interruption ID.
-     * @param interruptionId The interruption ID to approve
-     */
-    async approveToolCall(interruptionId) {
-        const pending = this._pendingApprovals.get(interruptionId);
-        if (!pending) {
-            console.warn(`No pending approval found for interruption ${interruptionId}`);
-            return;
-        }
-        if (this._interruptedState) {
-            this._interruptedState.state.approve(pending.interruption);
-        }
-        pending.approved = true;
-        this._pendingApprovals.delete(interruptionId);
-    }
-    /**
-     * Rejects a tool call by interruption ID.
-     * @param interruptionId The interruption ID to reject
-     */
-    async rejectToolCall(interruptionId) {
-        const pending = this._pendingApprovals.get(interruptionId);
-        if (!pending) {
-            console.warn(`No pending approval found for interruption ${interruptionId}`);
-            return;
-        }
-        if (this._interruptedState) {
-            this._interruptedState.state.reject(pending.interruption);
-        }
-        pending.approved = false;
-        this._pendingApprovals.delete(interruptionId);
-    }
-    /**
-     * Approves all tools in a group by group ID.
-     * @param groupId The group ID containing the tool calls
-     * @param interruptionIds Array of interruption IDs to approve
-     */
-    async approveGroupedToolCalls(groupId, interruptionIds) {
-        for (const interruptionId of interruptionIds) {
-            const pending = this._pendingApprovals.get(interruptionId);
-            if (pending && pending.groupId === groupId) {
-                if (this._interruptedState) {
-                    this._interruptedState.state.approve(pending.interruption);
-                }
-                pending.approved = true;
-                this._pendingApprovals.delete(interruptionId);
-            }
-        }
-    }
-    /**
-     * Rejects all tools in a group by group ID.
-     * @param groupId The group ID containing the tool calls
-     * @param interruptionIds Array of interruption IDs to reject
+     * Updates token usage statistics.
      */
-    async rejectGroupedToolCalls(groupId, interruptionIds) {
-        for (const interruptionId of interruptionIds) {
-            const pending = this._pendingApprovals.get(interruptionId);
-            if (pending && pending.groupId === groupId) {
-                if (this._interruptedState) {
-                    this._interruptedState.state.reject(pending.interruption);
-                }
-                pending.approved = false;
-                this._pendingApprovals.delete(interruptionId);
-            }
+    _updateTokenUsage(usage) {
+        if (usage) {
+            this._tokenUsage.inputTokens += usage.inputTokens ?? 0;
+            this._tokenUsage.outputTokens += usage.outputTokens ?? 0;
+            this._tokenUsageChanged.emit(this._tokenUsage);
         }
     }
     /**
      * Initializes the AI agent with current settings and tools.
-     * Sets up the agent with model configuration, tools, and MCP servers.
+     * Sets up the agent with model configuration, tools, and MCP tools.
      */
-    initializeAgent = async (mcpServers) => {
+    initializeAgent = async (mcpTools) => {
         if (this._isInitializing) {
             return;
         }
         this._isInitializing = true;
         try {
             const config = this._settingsModel.config;
-            if (mcpServers !== undefined) {
-                this._mcpServers = mcpServers;
+            if (mcpTools !== undefined) {
+                this._mcpTools = mcpTools;
             }
             const model = await this._createModel();
             const shouldUseTools = config.toolsEnabled &&
@@ -412,24 +405,23 @@ export class AgentManager {
                 this._toolRegistry &&
                 Object.keys(this._toolRegistry.tools).length > 0 &&
                 this._supportsToolCalling();
-            const tools = shouldUseTools ? this.selectedAgentTools : [];
+            const tools = shouldUseTools
+                ? { ...this.selectedAgentTools, ...this._mcpTools }
+                : this._mcpTools;
             const activeProviderConfig = this._settingsModel.getProvider(this._activeProvider);
             const temperature = activeProviderConfig?.parameters?.temperature ?? DEFAULT_TEMPERATURE;
-            const maxTokens = activeProviderConfig?.parameters?.maxTokens;
-            this._agent = new Agent({
-                name: 'Assistant',
-                instructions: shouldUseTools
-                    ? this._getEnhancedSystemPrompt(config.systemPrompt || '')
-                    : config.systemPrompt || 'You are a helpful assistant.',
-                model: model,
-                mcpServers: this._mcpServers,
+            const maxTokens = activeProviderConfig?.parameters?.maxOutputTokens;
+            const maxTurns = activeProviderConfig?.parameters?.maxTurns ?? DEFAULT_MAX_TURNS;
+            const instructions = shouldUseTools
+                ? this._getEnhancedSystemPrompt(config.systemPrompt || '')
+                : config.systemPrompt || 'You are a helpful assistant.';
+            this._agent = new ToolLoopAgent({
+                model,
+                instructions,
                 tools,
-                ...(temperature && {
-                    modelSettings: {
-                        temperature,
-                        maxTokens
-                    }
-                })
+                temperature,
+                maxOutputTokens: maxTokens,
+                stopWhen: stepCountIs(maxTurns)
             });
         }
         catch (error) {
@@ -441,175 +433,159 @@ export class AgentManager {
         }
     };
     /**
-     * Processes the result stream from agent execution.
+     * Processes the stream result from agent execution.
      * Handles message streaming, tool calls, and emits appropriate events.
-     * @param result The async iterable result from agent execution
+     * @param result The stream result from agent execution
+     * @returns Processing result including approval info if applicable
      */
-    async _processRunResult(result) {
+    async _processStreamResult(result) {
         let fullResponse = '';
         let currentMessageId = null;
-        for await (const event of result) {
-            if (event.type === 'raw_model_stream_event') {
-                const data = event.data;
-                if (data.type === 'response_started') {
-                    currentMessageId = `msg-${Date.now()}-${Math.random()}`;
-                    fullResponse = '';
-                    this._agentEvent.emit({
-                        type: 'message_start',
-                        data: { messageId: currentMessageId }
-                    });
-                }
-                else if (data.type === 'output_text_delta') {
-                    if (currentMessageId) {
-                        const chunk = data.delta || '';
-                        fullResponse += chunk;
+        const processResult = { approvalProcessed: false };
+        for await (const part of result.fullStream) {
+            switch (part.type) {
+                case 'text-delta':
+                    if (!currentMessageId) {
+                        currentMessageId = `msg-${Date.now()}-${Math.random()}`;
                         this._agentEvent.emit({
-                            type: 'message_chunk',
-                            data: {
-                                messageId: currentMessageId,
-                                chunk,
-                                fullContent: fullResponse
-                            }
+                            type: 'message_start',
+                            data: { messageId: currentMessageId }
                         });
                     }
-                }
-                else if (data.type === 'response_done') {
-                    if (currentMessageId) {
-                        this._agentEvent.emit({
-                            type: 'message_complete',
-                            data: {
-                                messageId: currentMessageId,
-                                content: fullResponse
-                            }
-                        });
+                    fullResponse += part.text;
+                    this._agentEvent.emit({
+                        type: 'message_chunk',
+                        data: {
+                            messageId: currentMessageId,
+                            chunk: part.text,
+                            fullContent: fullResponse
+                        }
+                    });
+                    break;
+                case 'tool-call':
+                    // Complete current message before tool call
+                    if (currentMessageId && fullResponse) {
+                        this._emitMessageComplete(currentMessageId, fullResponse);
                         currentMessageId = null;
+                        fullResponse = '';
                     }
-                    const usage = data.response.usage;
-                    const { inputTokens, outputTokens } = usage;
-                    this._tokenUsage.inputTokens += inputTokens;
-                    this._tokenUsage.outputTokens += outputTokens;
-                    this._tokenUsageChanged.emit(this._tokenUsage);
-                }
-                else if (data.type === 'model') {
-                    const modelEvent = data.event;
-                    if (modelEvent.type === 'tool-call') {
-                        this._handleToolCallStart(modelEvent);
+                    this._agentEvent.emit({
+                        type: 'tool_call_start',
+                        data: {
+                            callId: part.toolCallId,
+                            toolName: part.toolName,
+                            input: this._formatToolInput(JSON.stringify(part.input))
+                        }
+                    });
+                    break;
+                case 'tool-result':
+                    this._handleToolResult(part);
+                    break;
+                case 'tool-approval-request':
+                    // Complete current message before approval
+                    if (currentMessageId && fullResponse) {
+                        this._emitMessageComplete(currentMessageId, fullResponse);
+                        currentMessageId = null;
+                        fullResponse = '';
                     }
-                }
-            }
-            else if (event.type === 'run_item_stream_event') {
-                if (event.name === 'tool_output') {
-                    this._handleToolOutput(event);
-                }
+                    await this._handleApprovalRequest(part, processResult);
+                    break;
+                // Ignore: text-start, text-end, finish, error, and others
+                default:
+                    break;
             }
         }
-    }
-    /**
-     * Formats tool input for display by pretty-printing JSON strings.
-     * @param input The tool input string to format
-     * @returns Pretty-printed JSON string
-     */
-    _formatToolInput(input) {
-        try {
-            // Parse and re-stringify with formatting
-            const parsed = JSON.parse(input);
-            return JSON.stringify(parsed, null, 2);
-        }
-        catch {
-            // If parsing fails, return the string as-is
-            return input;
+        // Complete final message if content remains
+        if (currentMessageId && fullResponse) {
+            this._emitMessageComplete(currentMessageId, fullResponse);
         }
+        return processResult;
     }
     /**
-     * Handles the start of a tool call from the model event.
-     * @param modelEvent The model event containing tool call information
+     * Emits a message_complete event.
      */
-    _handleToolCallStart(modelEvent) {
-        const toolCallId = modelEvent.toolCallId;
-        const toolName = modelEvent.toolName;
-        const toolInput = modelEvent.input;
+    _emitMessageComplete(messageId, content) {
         this._agentEvent.emit({
-            type: 'tool_call_start',
-            data: {
-                callId: toolCallId,
-                toolName,
-                input: this._formatToolInput(toolInput)
-            }
+            type: 'message_complete',
+            data: { messageId, content }
         });
     }
     /**
-     * Handles tool execution output and completion.
-     * @param event The tool output event containing result information
-     */
-    _handleToolOutput(event) {
-        const toolEvent = event;
-        const toolCallOutput = toolEvent.item;
-        const callId = toolCallOutput.rawItem.callId;
-        const resultText = typeof toolCallOutput.output === 'string'
-            ? toolCallOutput.output
-            : JSON.stringify(toolCallOutput.output, null, 2);
-        const isError = toolCallOutput.rawItem.type === 'function_call_result' &&
-            toolCallOutput.rawItem.status === 'incomplete';
-        const toolName = toolCallOutput.rawItem.type === 'function_call_result'
-            ? toolCallOutput.rawItem.name
-            : 'Unknown Tool';
+     * Handles tool-result stream parts.
+     */
+    _handleToolResult(part) {
+        const output = typeof part.output === 'string'
+            ? part.output
+            : JSON.stringify(part.output, null, 2);
+        const isError = typeof part.output === 'object' &&
+            part.output !== null &&
+            'success' in part.output &&
+            part.output.success === false;
         this._agentEvent.emit({
             type: 'tool_call_complete',
             data: {
-                callId,
-                toolName,
-                output: resultText,
+                callId: part.toolCallId,
+                toolName: part.toolName,
+                output,
                 isError
             }
         });
     }
     /**
-     * Handles approval request for a single tool call.
-     * @param interruption The tool approval interruption item
+     * Handles tool-approval-request stream parts.
      */
-    async _handleSingleToolApproval(interruption) {
-        const toolName = interruption.rawItem.name || 'Unknown Tool';
-        const toolInput = interruption.rawItem.arguments || '{}';
-        const interruptionId = `int-${Date.now()}-${Math.random()}`;
-        const callId = interruption.rawItem.type === 'function_call'
-            ? interruption.rawItem.callId
-            : undefined;
-        this._pendingApprovals.set(interruptionId, { interruption });
+    async _handleApprovalRequest(part, result) {
+        const { approvalId, toolCall } = part;
         this._agentEvent.emit({
-            type: 'tool_approval_required',
+            type: 'tool_approval_request',
             data: {
-                interruptionId,
-                toolName,
-                toolInput: this._formatToolInput(toolInput),
-                callId
+                approvalId,
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                args: toolCall.input
             }
         });
+        const approved = await this._waitForApproval(approvalId);
+        result.approvalProcessed = true;
+        result.approvalResponse = {
+            role: 'tool',
+            content: [
+                {
+                    type: 'tool-approval-response',
+                    approvalId,
+                    approved
+                }
+            ]
+        };
     }
     /**
-     * Handles approval requests for multiple grouped tool calls.
-     * @param interruptions Array of tool approval interruption items
-     */
-    async _handleGroupedToolApprovals(interruptions) {
-        const groupId = `group-${Date.now()}-${Math.random()}`;
-        const approvals = interruptions.map(interruption => {
-            const toolName = interruption.rawItem.name || 'Unknown Tool';
-            const toolInput = interruption.rawItem.arguments || '{}';
-            const interruptionId = `int-${Date.now()}-${Math.random()}`;
-            this._pendingApprovals.set(interruptionId, { interruption, groupId });
-            return {
-                interruptionId,
-                toolName,
-                toolInput: this._formatToolInput(toolInput)
-            };
-        });
-        this._agentEvent.emit({
-            type: 'grouped_approval_required',
-            data: {
-                groupId,
-                approvals
-            }
+     * Waits for user approval of a tool call.
+     * @param approvalId The approval ID to wait for
+     * @returns Promise that resolves to true if approved, false if rejected
+     */
+    _waitForApproval(approvalId) {
+        return new Promise(resolve => {
+            this._pendingApprovals.set(approvalId, {
+                resolve: (approved) => {
+                    resolve(approved);
+                }
+            });
         });
     }
+    /**
+     * Formats tool input for display by pretty-printing JSON strings.
+     * @param input The tool input string to format
+     * @returns Pretty-printed JSON string
+     */
+    _formatToolInput(input) {
+        try {
+            const parsed = JSON.parse(input);
+            return JSON.stringify(parsed, null, 2);
+        }
+        catch {
+            return input;
+        }
+    }
     /**
      * Checks if the current provider supports tool calling.
      * @returns True if the provider supports tool calling, false otherwise
@@ -678,17 +654,24 @@ Guidelines:
 - End with a brief summary of accomplishments
 - Use natural, conversational tone throughout
 
-COMMAND DISCOVERY:
-- When you want to execute JupyterLab commands, ALWAYS use the 'discover_commands' tool first to find available commands and their metadata, with the optional query parameter.
-- The query should typically be a single word, e.g., 'terminal', 'notebook', 'cell', 'file', 'edit', 'view', 'run', etc, to find relevant commands.
-- If searching with a query does not yield the desired command, try again with a different query or use an empty query to list all commands.
-- This ensures you have complete information about command IDs, descriptions, and required arguments before attempting to execute them. Only after discovering the available commands should you use the 'execute_command' tool with the correct command ID and arguments.
+PRIMARY TOOL USAGE - COMMAND-BASED OPERATIONS:
+Most operations in JupyterLab should be performed using the command system:
+1. Use 'discover_commands' to find available commands and their metadata
+2. Use 'execute_command' to perform the actual operation
+
+COMMAND DISCOVERY WORKFLOW:
+- For file and notebook operations, use query 'jupyterlab-ai-commands' to discover the curated set of AI commands (~17 commands for file/notebook/directory operations)
+- For other JupyterLab operations (terminal, launcher, UI), use specific keywords like 'terminal', 'launcher', etc.
+- IMPORTANT: Always use 'jupyterlab-ai-commands' as the query for file/notebook tasks - this returns a focused set of commands instead of 100+ generic JupyterLab commands
 
-TOOL SELECTION GUIDELINES:
-- For file operations (create, read, write, modify files and directories): Use dedicated file manipulation tools
-- For general JupyterLab UI interactions (opening panels, running commands, navigating interface): Use the general command tool (execute_command)
-- Examples of file operations: Creating notebooks, editing code files, managing project structure
-- Examples of UI interactions: Opening terminal, switching tabs, running notebook cells, accessing menus
+KERNEL PREFERENCE FOR NOTEBOOKS AND CONSOLES:
+When creating notebooks or consoles for a specific programming language, use the 'kernelPreference' argument to specify the kernel:
+- To specify by language: { "kernelPreference": { "language": "python" } } or { "kernelPreference": { "language": "julia" } }
+- To specify by kernel name: { "kernelPreference": { "name": "python3" } } or { "kernelPreference": { "name": "julia-1.10" } }
+- Example: execute_command with commandId="notebook:create-new" and args={ "kernelPreference": { "language": "python" } }
+- Example: execute_command with commandId="console:create" and args={ "kernelPreference": { "name": "python3" } }
+- Common kernel names: "python3" (Python), "julia-1.10" (Julia), "ir" (R), "xpython" (xeus-python)
+- If unsure of exact kernel name, prefer using "language" which will match any kernel supporting that language
 `;
         return baseSystemPrompt + progressReportingPrompt;
     }
@@ -699,18 +682,16 @@ TOOL SELECTION GUIDELINES:
     _secretsManager;
     _selectedToolNames;
     _agent;
-    _runner;
     _history;
-    _mcpServers;
+    _mcpTools;
     _isInitializing;
     _controller;
-    _pendingApprovals;
-    _interruptedState;
     _agentEvent;
     _tokenUsage;
     _tokenUsageChanged;
     _activeProvider = '';
     _activeProviderChanged = new Signal(this);
+    _pendingApprovals = new Map();
 }
 var Private;
 (function (Private) {