tool calling loop

eleanorjboyd · eleanorjboyd · commit fffb8f182bc6 · 2025-07-18T16:32:37.000-07:00
diff --git a/src/features/chat/chatParticipant.tsx b/src/features/chat/chatParticipant.tsx
@@ -1,66 +1,153 @@
-
-import { sendChatParticipantRequest } from "@vscode/chat-extension-utils";
-import { traceInfo, traceWarn } from "../../common/logging";
-import * as vscode from "vscode";
-import { PythonEnvsPrompt } from "./prompts";
-import { PromptElementAndProps } from "@vscode/chat-extension-utils/dist/toolsPrompt";
-import { ChatEnvironmentErrorInfo, ERROR_CHAT_CONTEXT_QUEUE } from "./send_prompt";
-import { PythonHelperChatParticipant } from "./pythonHelperChatParticipant";
+import { traceInfo, traceWarn } from '../../common/logging';
+import * as vscode from 'vscode';
+import { PythonEnvsPrompt, PythonEnvsPromptProps } from './prompts';
+import { PythonHelperChatParticipant } from './pythonHelperChatParticipant';
+import { PromptElement, renderPrompt, UserMessage } from '@vscode/prompt-tsx';
+import { LanguageModelTextPart, LanguageModelToolCallPart } from 'vscode';
+import { ToolCallRound, ToolResultMetadata } from '@vscode/chat-extension-utils/dist/toolsPrompt';
 
 export const CHAT_PARTICIPANT_ID = 'python-helper';
 export const CHAT_PARTICIPANT_AT_MENTION = `@${CHAT_PARTICIPANT_ID}`;
 
+export function registerChatParticipant(_context: vscode.ExtensionContext) {
+    traceInfo('Registering python helper chat participant'); // Log registration start
 
+    // Define the request handler for the chat participant
+    const requestHandler: vscode.ChatRequestHandler = async (
+        request: vscode.ChatRequest, // prompt made in pip file
+        chatContext: vscode.ChatContext, // history
+        stream: vscode.ChatResponseStream,
+        token: vscode.CancellationToken,
+    ) => {
+        traceWarn('Python helper chat participant invoked with request:', request); // Log request details
 
-export function registerChatParticipant(
-	_context: vscode.ExtensionContext,
-) {
-    traceInfo('Registering python helper chat participant');
-    const participant = vscode.chat.createChatParticipant(CHAT_PARTICIPANT_ID,
-		async (
-			request: vscode.ChatRequest,
-			chatContext: vscode.ChatContext,
-			stream: vscode.ChatResponseStream,
-			token: vscode.CancellationToken
-		) => {
-            traceWarn('Python helper chat participant invoked with request:', request);
-            const userPrompt = request.prompt;
-
-         
-            const prompt: PromptElementAndProps<PythonEnvsPrompt> = {
-				promptElement: PythonEnvsPrompt,
-				props: {
-					title: 'Python Environment',
-					description: 'Provide information about the Python environment.',
-					request: {
-						prompt: '' + userPrompt + ' What is the current Python environment? What packages are installed?',
-					},
-				},
-			};
-
-            const { result } = sendChatParticipantRequest(
-                request,
-                chatContext,
-                {
-                    prompt,
-                    requestJustification: vscode.l10n.t('Tell me about my environment.'),
-                    responseStreamOptions: {
-                        stream,
-                        references: false,
-                        responseText: true,
-                    },
+        // gather the available tools
+        const first100tools = vscode.lm.tools.slice(0, 100);
+        const tools: vscode.LanguageModelChatTool[] = first100tools.map((tool): vscode.LanguageModelChatTool => {
+            return {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema ?? {},
+            };
+        });
+        traceInfo('Tools prepared:', tools); // Log tools
+
+        const userPrompt = request.prompt;
+        traceInfo('User prompt received:', userPrompt); // Log user prompt
+
+        const refTools = request.toolReferences;
+        const refToolInvToken = request.toolInvocationToken;
+        const refRef = request.references;
+        const refCom = request.command;
+        const refPrompt = request.prompt;
+        let model = request.model;
+        traceInfo('References received:', refTools, refToolInvToken, refRef, refCom, refPrompt, model); // Log references
+
+        // takes the info and creates a prompt using the PythonEnvsPrompt
+        const result = await renderPrompt<PythonEnvsPromptProps>(
+            PythonEnvsPrompt, // Extract the constructor PythonEnvsPromptProps
+            {
+                title: 'Python Environment',
+                description: 'Provide information about the Python environment.',
+                request: {
+                    prompt: '' + userPrompt + ' What is the current Python environment? What packages are installed?',
                 },
-                token,
-            );
+            },
+            { modelMaxPromptTokens: model.maxInputTokens },
+            model,
+        );
+
+        // result of building the prompt
+        let messages = result.messages;
+
+        const options: vscode.LanguageModelChatRequestOptions = {
+            justification: 'To make a request to @toolsTSX',
+            tools: tools,
+        };
+
+        const toolReferences = [...request.toolReferences];
+        const accumulatedToolResults: Record<string, vscode.LanguageModelToolResult> = {};
+        const toolCallRounds: ToolCallRound[] = [];
+        const runWithTools = async (): Promise<void> => {
+            const requestedTool = toolReferences.shift();
+
+            if (requestedTool) {
+                 // NOT WORKING::: If a toolReference is present, force the model to call that tool
+                options.toolMode = vscode.LanguageModelChatToolMode.Required;
+                options.tools = vscode.lm.tools.filter((tool) => tool.name === requestedTool.name);
+            } else {
+                options.toolMode = undefined;
+                options.tools = [...tools];
+            }
+            console.log('Requested tool:', requestedTool); // Log requested tool
+
+            // Send the request to the model
+            const response = await model.sendRequest(messages, options, token);
+            traceInfo('Chat participant response sent:', response); // Log response
+
+            // Stream the response back to VS Code
+            let responseStr = '';
+            const toolCalls: vscode.LanguageModelToolCallPart[] = [];
+
+            for await (const chunk of response.stream) {
+                if (chunk instanceof LanguageModelTextPart) {
+                    stream.markdown(chunk.value);
+                    responseStr += chunk.value; // Accumulate the response string
+                } else if (chunk instanceof LanguageModelToolCallPart) {
+                    // If the response contains vscode.LanguageModelToolCallPart, then you should re-send the prompt with a ToolCall element for each of those.
+                    console.log('TOOL CALL', chunk);
+                    toolCalls.push(chunk);
+                }
+            }
 
-            return await result;
-		}
-	);
+            if (toolCalls.length) {
+                traceInfo('Tool calls detected:', toolCalls); // Log tool calls
+
+                // If the model called any tools, then we do another round- render the prompt with those tool calls (rendering the PromptElements will invoke the tools)
+                // and include the tool results in the prompt for the next request.
+                toolCallRounds.push({
+                    response: responseStr,
+                    toolCalls,
+                });
+
+                const result = await renderPrompt<PythonEnvsPromptProps>(
+                    PythonEnvsPrompt, // Extract the constructor PythonEnvsPromptProps
+                    {
+                        title: 'Python Environment',
+                        description: 'Provide information about the Python environment.',
+                        request: {
+                            prompt:
+                                '' +
+                                userPrompt +
+                                ' What is the current Python environment? What packages are installed?',
+                        },
+                    },
+                    { modelMaxPromptTokens: model.maxInputTokens },
+                    model,
+                );
+
+                // result of building the prompt
+                let messages = result.messages;
+                const toolResultMetadata = result.metadatas.getAll(ToolResultMetadata);
+                if (toolResultMetadata?.length) {
+                    // Cache tool results for later, so they can be incorporated into later prompts without calling the tool again
+                    toolResultMetadata.forEach((meta) => (accumulatedToolResults[meta.toolCallId] = meta.result));
+                }
+
+                // This loops until the model doesn't want to call any more tools, then the request is done.
+                return runWithTools();
+            }
+        };
+        await runWithTools(); // Ensure tools are run before proceeding
+
+        // end of request handler
+    };
+
+    const participant = vscode.chat.createChatParticipant(CHAT_PARTICIPANT_ID, requestHandler);
     participant.iconPath = new vscode.ThemeIcon('python');
 
+    traceInfo('Chat participant created and registered'); // Log participant creation
+
     // Register using our singleton manager
     return PythonHelperChatParticipant.register(participant, _context);
-
-
 }
-
diff --git a/src/features/chat/prompts.tsx b/src/features/chat/prompts.tsx
@@ -17,35 +17,50 @@ export interface PythonEnvsPromptProps extends BasePromptElementProps {
 
 export class PythonEnvsPrompt extends PromptElement<PythonEnvsPromptProps, void> {
 	render(_state: void, _sizing: PromptSizing) {
+        traceWarn('Render function called'); // Log when render is invoked
 
+        // this.props is PythonEnvsPromptProps
         const isContext = !ERROR_CHAT_CONTEXT_QUEUE.isEmpty();
-                if (!isContext) {
-                    traceWarn('No context found for python helper chat participant');
-                    return;
-                }
+        traceWarn('Context queue is empty:', !isContext); // Log the state of the context queue
+
+        if (!isContext) {
+            traceWarn('No context found for python helper chat participant');
+            return;
+        }
+
         const contextErr: ChatEnvironmentErrorInfo | undefined = ERROR_CHAT_CONTEXT_QUEUE.pop();
+        traceWarn('Popped context error:', contextErr); // Log the popped context error
+
         if (!contextErr) {
             traceWarn('No context error found for python helper chat participant');
             return;
         }
+
         const attemptedPackages = contextErr.attemptedPackages.join(', ');
         const packagesBeforeInstall = contextErr.packagesBeforeInstall.join(', ');
-        console.log(packagesBeforeInstall)
+        traceWarn('Attempted packages:', attemptedPackages); // Log attempted packages
+        traceWarn('Packages before install:', packagesBeforeInstall); // Log packages before install
+
         const envString = contextErr.environment.displayName + ' (' + contextErr.environment.environmentPath + ') ' + contextErr.environment.version;
-        console.log(envString);
+        traceWarn('Environment string:', envString); // Log environment string
 
         const rawPrompt = this.props.request.prompt .replace(/^@pythonHelper\s*/, '');
-                    let _errorInfo: ChatEnvironmentErrorInfo | undefined;
-                    try {
-                        _errorInfo = JSON.parse(rawPrompt);
-                    } catch (e) {
-                        // Handle parse error
-                    }
-        return (
-            <>
+        traceWarn('Raw prompt:', rawPrompt); // Log the raw prompt
+
+        // let errorInfo: ChatEnvironmentErrorInfo | undefined;
+        // try {
+        //     errorInfo = JSON.stringify(rawPrompt);
+        //     traceWarn('Parsed error info:', errorInfo); // Log parsed error info
+        // } catch (e) {
+        //     console.error('Error parsing raw prompt the prompt:', rawPrompt);
+        //     traceWarn('Error parsing raw prompt:', e); // Log parsing error
+        // }
+        const msg =  <>
                 <UserMessage priority={100}>🚨 **Package Management Error**##<br /> ❗ Error Details<br />``` <br /> {contextErr.errorMessage}<br />```<br />Stack Trace<br />```<br />{contextErr.stackTrace}<br />```<br />## 📝 **Context**<br />**Attempted Packages:**{attemptedPackages}<br /><br /> **Package Manager:** {contextErr.packageManager}<br /> **Environment:** {envString}<br /> **Packages Before Install:** {packagesBeforeInstall}<br />## 🛠️ **How to Diagnose & Fix**<br />1. **Diagnose the error above.**<br />2. **Suggest a fix.**<br />3. Use the following tools where applicable:<br />- `installPythonPackage`: Install a package with a version specification, etc.<br />   -`configurePythonEnvironment`: Create an environment with the given attributes.<br /> If you see one best path forward, start doing that WITHOUT asking the user again. If you see 2 to 3 paths to solve this problem, reply with the two paths like so: `button1: prompt solution` `button2: prompt solution</UserMessage>
             </>
-        )
+
+        traceWarn('Returning message final:', msg); // Log the final message to be returned
+        return msg;
 
         //  <UserMessage priority={69}><br /> **Attempted Packages:**{attemptedPackages}<br /> **Package Manager:** {contextErr.packageManager}<br /> **Environment:** {contextErr.environment}<br /> **Packages Before Install:** {contextErr.packagesBeforeInstall}</UserMessage>
                         // <UserMessage priority={67}><br /> **Environment:** {envString}<br /></UserMessage>
diff --git a/src/features/chat/send_prompt.ts b/src/features/chat/send_prompt.ts
@@ -2,6 +2,7 @@
 // //     const token: CancellationToken = new CancellationTokenSource().token;
 
 import { commands, extensions, l10n, ProgressLocation, ProgressOptions, window } from 'vscode';
+import { traceInfo, traceWarn } from '../../common/logging';
 
 // import {
 //     CancellationToken,
@@ -95,30 +96,41 @@ function isCopilotChatInstalled(): boolean {
     return !!extensions.getExtension(COPILOT_CHAT_EXTENSION_ID);
 }
 export async function sendPromptIfCopilotChatInstalled(prompt: string): Promise<void> {
+    traceInfo('Checking if Copilot Chat is installed'); // Log check start
+
     const sendPrompt = async () => {
-        // Artificial delay to work around
-        // https://github.com/microsoft/vscode-copilot/issues/16541
+        traceInfo('Preparing to send prompt to Copilot Chat'); // Log prompt preparation
+
         const progressOptions: ProgressOptions = {
             location: ProgressLocation.Notification,
             title: l10n.t('Analyzing your python environment extension logs...'),
             cancellable: false,
         };
         await window.withProgress(progressOptions, async () => {
+            traceInfo('Showing progress notification'); // Log progress notification
             await new Promise((resolve) => setTimeout(resolve, 5));
         });
+
+        traceInfo('Executing chat open command with prompt:', prompt); // Log command execution
+
         const abc = await commands.executeCommand('workbench.action.chat.open', {
             query: prompt,
             mode: 'agent',
         });
+
         if (abc) {
-            console.log('Chat opened successfully');
+            traceInfo('Chat opened successfully'); // Log success
+        } else {
+            traceWarn('Failed to open chat'); // Log failure
         }
     };
-    // If the user has Copilot Chat installed, assume they are
-    // logged in and can receive the 'sendToNewChat' command
+
     if (isCopilotChatInstalled()) {
+        traceInfo('Copilot Chat is installed, sending prompt'); // Log installation check
         await sendPrompt();
         return;
+    } else {
+        traceWarn('Copilot Chat is not installed'); // Log absence
     }
 }
 
