@playwright/mcp 0.0.36-alpha-2025-09-02 → 0.0.36-alpha-2025-09-04

package/lib/vscode/host.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -13,38 +14,64 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { fileURLToPath } from 'url';
-import path from 'path';
-import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { ListRootsRequestSchema, PingRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import * as mcpServer from '../mcp/server.js';
-import { logUnhandledError } from '../utils/log.js';
-import { packageJSON } from '../utils/package.js';
-import { BrowserServerBackend } from '../browserServerBackend.js';
-import { contextFactory } from '../browserContextFactory.js';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVSCodeTools = runVSCodeTools;
+const path_1 = __importDefault(require("path"));
+const mcpBundle = __importStar(require("../sdk/bundle"));
+const mcpServer = __importStar(require("../sdk/server"));
+const log_1 = require("../log");
+const package_1 = require("../package");
+const browserServerBackend_1 = require("../browser/browserServerBackend");
+const browserContextFactory_1 = require("../browser/browserContextFactory");
+const { z, zodToJsonSchema } = mcpBundle;
 const contextSwitchOptions = z.object({
     connectionString: z.string().optional().describe('The connection string to use to connect to the browser'),
     lib: z.string().optional().describe('The library to use for the connection'),
     debugController: z.boolean().optional().describe('Enable the debug controller')
 });
 class VSCodeProxyBackend {
-    _config;
-    _defaultTransportFactory;
-    name = 'Playwright MCP Client Switcher';
-    version = packageJSON.version;
-    _currentClient;
-    _contextSwitchTool;
-    _roots = [];
-    _clientVersion;
-    _context;
-    _browser;
-    _browserServer;
     constructor(_config, _defaultTransportFactory) {
         this._config = _config;
         this._defaultTransportFactory = _defaultTransportFactory;
+        this.name = 'Playwright MCP Client Switcher';
+        this.version = package_1.packageJSON.version;
+        this._roots = [];
         this._contextSwitchTool = this._defineContextSwitchTool();
     }
     async initialize(server, clientVersion, roots) {
@@ -69,7 +96,8 @@ class VSCodeProxyBackend {
         });
     }
     serverClosed(server) {
-        void this._currentClient?.close().catch(logUnhandledError);
+        var _a;
+        void ((_a = this._currentClient) === null || _a === void 0 ? void 0 : _a.close().catch(log_1.logUnhandledError));
     }
     onContext(context) {
         this._context = context;
@@ -97,7 +125,7 @@ class VSCodeProxyBackend {
             const lines = [`### Result`];
             if (url) {
                 lines.push(`URL: ${url}`);
-                lines.push(`Version: ${packageJSON.dependencies.playwright}`);
+                lines.push(`Version: ${package_1.packageJSON.dependencies.playwright}`);
             }
             else {
                 lines.push(`No open browsers.`);
@@ -111,11 +139,11 @@ class VSCodeProxyBackend {
                 content: [{ type: 'text', text: '### Result\nSuccessfully disconnected.\n' }],
             };
         }
-        await this._setCurrentClient(new StdioClientTransport({
+        await this._setCurrentClient(new mcpBundle.StdioClientTransport({
             command: process.execPath,
             cwd: process.cwd(),
             args: [
-                path.join(fileURLToPath(import.meta.url), '..', 'main.js'),
+                path_1.default.join(__dirname, 'main.js'),
                 JSON.stringify(this._config),
                 params.connectionString,
                 params.lib,
@@ -138,28 +166,29 @@ class VSCodeProxyBackend {
         };
     }
     async _setCurrentClient(transport) {
-        await this._currentClient?.close();
+        var _a;
+        await ((_a = this._currentClient) === null || _a === void 0 ? void 0 : _a.close());
         this._currentClient = undefined;
-        const client = new Client(this._clientVersion);
+        const client = new mcpBundle.Client(this._clientVersion);
         client.registerCapabilities({
             roots: {
                 listRoots: true,
             },
         });
-        client.setRequestHandler(ListRootsRequestSchema, () => ({ roots: this._roots }));
-        client.setRequestHandler(PingRequestSchema, () => ({}));
+        client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._roots }));
+        client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
         await client.connect(transport);
         this._currentClient = client;
     }
 }
-export async function runVSCodeTools(config) {
+async function runVSCodeTools(config) {
     const serverBackendFactory = {
         name: 'Playwright w/ vscode',
         nameInConfig: 'playwright-vscode',
-        version: packageJSON.version,
-        create: () => new VSCodeProxyBackend(config, delegate => mcpServer.wrapInProcess(new BrowserServerBackend(config, {
+        version: package_1.packageJSON.version,
+        create: () => new VSCodeProxyBackend(config, delegate => mcpServer.wrapInProcess(new browserServerBackend_1.BrowserServerBackend(config, {
             async createContext(clientInfo, abortSignal, toolName) {
-                const context = await contextFactory(config).createContext(clientInfo, abortSignal, toolName);
+                const context = await (0, browserContextFactory_1.contextFactory)(config).createContext(clientInfo, abortSignal, toolName);
                 delegate.onContext(context.browserContext);
                 return context;
             },

package/lib/vscode/main.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -13,21 +14,53 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import * as mcpServer from '../mcp/server.js';
-import { BrowserServerBackend } from '../browserServerBackend.js';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcpBundle = __importStar(require("../sdk/bundle"));
+const mcpServer = __importStar(require("../sdk/server"));
+const browserServerBackend_1 = require("../browser/browserServerBackend");
 class VSCodeBrowserContextFactory {
-    _config;
-    _playwright;
-    _connectionString;
-    name = 'vscode';
-    description = 'Connect to a browser running in the Playwright VS Code extension';
     constructor(_config, _playwright, _connectionString) {
         this._config = _config;
         this._playwright = _playwright;
         this._connectionString = _connectionString;
+        this.name = 'vscode';
+        this.description = 'Connect to a browser running in the Playwright VS Code extension';
     }
     async createContext(clientInfo, abortSignal) {
+        var _a;
         let launchOptions = this._config.browser.launchOptions;
         if (this._config.browser.userDataDir) {
             launchOptions = {
@@ -40,7 +73,7 @@ class VSCodeBrowserContextFactory {
         connectionString.searchParams.set('launch-options', JSON.stringify(launchOptions));
         const browserType = this._playwright.chromium; // it could also be firefox or webkit, we just need some browser type to call `connect` on
         const browser = await browserType.connect(connectionString.toString());
-        const context = browser.contexts()[0] ?? await browser.newContext(this._config.browser.contextOptions);
+        const context = (_a = browser.contexts()[0]) !== null && _a !== void 0 ? _a : await browser.newContext(this._config.browser.contextOptions);
         return {
             browserContext: context,
             close: async () => {
@@ -50,13 +83,15 @@ class VSCodeBrowserContextFactory {
     }
 }
 async function main(config, connectionString, lib) {
-    const playwright = await import(lib).then(mod => mod.default ?? mod);
+    const playwright = await Promise.resolve(`${lib}`).then(s => __importStar(require(s))).then(mod => { var _a; return (_a = mod.default) !== null && _a !== void 0 ? _a : mod; });
     const factory = new VSCodeBrowserContextFactory(config, playwright, connectionString);
     await mcpServer.connect({
         name: 'Playwright MCP',
         nameInConfig: 'playwright-vscode',
-        create: () => new BrowserServerBackend(config, factory),
+        create: () => new browserServerBackend_1.BrowserServerBackend(config, factory),
         version: 'unused'
-    }, new StdioServerTransport(), false);
+    }, new mcpBundle.StdioServerTransport(), false);
 }
-await main(JSON.parse(process.argv[2]), process.argv[3], process.argv[4]);
+void (async () => {
+    await main(JSON.parse(process.argv[2]), process.argv[3], process.argv[4]);
+})();

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@playwright/mcp",
-  "version": "0.0.36-alpha-2025-09-02",
+  "version": "0.0.36-alpha-2025-09-04",
   "description": "Playwright Tools for MCP",
-  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/microsoft/playwright-mcp.git"
@@ -38,21 +37,19 @@
     }
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.16.0",
     "commander": "^13.1.0",
     "debug": "^4.4.1",
     "dotenv": "^17.2.0",
     "mime": "^4.0.7",
     "playwright": "1.56.0-alpha-1756505518000",
     "playwright-core": "1.56.0-alpha-1756505518000",
-    "ws": "^8.18.1",
-    "zod": "^3.24.1",
-    "zod-to-json-schema": "^3.24.4"
+    "ws": "^8.18.1"
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.57.0",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.19.0",
+    "@modelcontextprotocol/sdk": "^1.16.0",
     "@playwright/test": "1.56.0-alpha-1756505518000",
     "@stylistic/eslint-plugin": "^3.0.1",
     "@types/debug": "^4.1.12",
@@ -66,7 +63,9 @@
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-notice": "^1.0.0",
     "openai": "^5.10.2",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.2",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.24.4"
   },
   "bin": {
     "mcp-server-playwright": "cli.js"

package/lib/loop/loop.js

@@ -1,69 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import debug from 'debug';
-export async function runTask(delegate, client, task, oneShot = false) {
-    const { tools } = await client.listTools();
-    const taskContent = oneShot ? `Perform following task: ${task}.` : `Perform following task: ${task}. Once the task is complete, call the "done" tool.`;
-    const conversation = delegate.createConversation(taskContent, tools, oneShot);
-    for (let iteration = 0; iteration < 5; ++iteration) {
-        debug('history')('Making API call for iteration', iteration);
-        const toolCalls = await delegate.makeApiCall(conversation);
-        if (toolCalls.length === 0)
-            throw new Error('Call the "done" tool when the task is complete.');
-        const toolResults = [];
-        for (const toolCall of toolCalls) {
-            const doneResult = delegate.checkDoneToolCall(toolCall);
-            if (doneResult !== null)
-                return conversation.messages;
-            const { name, arguments: args, id } = toolCall;
-            try {
-                debug('tool')(name, args);
-                const response = await client.callTool({
-                    name,
-                    arguments: args,
-                });
-                const responseContent = (response.content || []);
-                debug('tool')(responseContent);
-                const text = responseContent.filter(part => part.type === 'text').map(part => part.text).join('\n');
-                toolResults.push({
-                    toolCallId: id,
-                    content: text,
-                });
-            }
-            catch (error) {
-                debug('tool')(error);
-                toolResults.push({
-                    toolCallId: id,
-                    content: `Error while executing tool "${name}": ${error instanceof Error ? error.message : String(error)}\n\nPlease try to recover and complete the task.`,
-                    isError: true,
-                });
-                // Skip remaining tool calls for this iteration
-                for (const remainingToolCall of toolCalls.slice(toolCalls.indexOf(toolCall) + 1)) {
-                    toolResults.push({
-                        toolCallId: remainingToolCall.id,
-                        content: `This tool call is skipped due to previous error.`,
-                        isError: true,
-                    });
-                }
-                break;
-            }
-        }
-        delegate.addToolResults(conversation, toolResults);
-        if (oneShot)
-            return conversation.messages;
-    }
-    throw new Error('Failed to perform step, max attempts reached');
-}

package/lib/loop/loopClaude.js

@@ -1,152 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const model = 'claude-sonnet-4-20250514';
-export class ClaudeDelegate {
-    _anthropic;
-    async anthropic() {
-        if (!this._anthropic) {
-            const anthropic = await import('@anthropic-ai/sdk');
-            this._anthropic = new anthropic.Anthropic();
-        }
-        return this._anthropic;
-    }
-    createConversation(task, tools, oneShot) {
-        const llmTools = tools.map(tool => ({
-            name: tool.name,
-            description: tool.description || '',
-            inputSchema: tool.inputSchema,
-        }));
-        if (!oneShot) {
-            llmTools.push({
-                name: 'done',
-                description: 'Call this tool when the task is complete.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-            });
-        }
-        return {
-            messages: [{
-                    role: 'user',
-                    content: task
-                }],
-            tools: llmTools,
-        };
-    }
-    async makeApiCall(conversation) {
-        // Convert generic messages to Claude format
-        const claudeMessages = [];
-        for (const message of conversation.messages) {
-            if (message.role === 'user') {
-                claudeMessages.push({
-                    role: 'user',
-                    content: message.content
-                });
-            }
-            else if (message.role === 'assistant') {
-                const content = [];
-                // Add text content
-                if (message.content) {
-                    content.push({
-                        type: 'text',
-                        text: message.content,
-                        citations: []
-                    });
-                }
-                // Add tool calls
-                if (message.toolCalls) {
-                    for (const toolCall of message.toolCalls) {
-                        content.push({
-                            type: 'tool_use',
-                            id: toolCall.id,
-                            name: toolCall.name,
-                            input: toolCall.arguments
-                        });
-                    }
-                }
-                claudeMessages.push({
-                    role: 'assistant',
-                    content
-                });
-            }
-            else if (message.role === 'tool') {
-                // Tool results are added differently - we need to find if there's already a user message with tool results
-                const lastMessage = claudeMessages[claudeMessages.length - 1];
-                const toolResult = {
-                    type: 'tool_result',
-                    tool_use_id: message.toolCallId,
-                    content: message.content,
-                    is_error: message.isError,
-                };
-                if (lastMessage && lastMessage.role === 'user' && Array.isArray(lastMessage.content)) {
-                    // Add to existing tool results message
-                    lastMessage.content.push(toolResult);
-                }
-                else {
-                    // Create new tool results message
-                    claudeMessages.push({
-                        role: 'user',
-                        content: [toolResult]
-                    });
-                }
-            }
-        }
-        // Convert generic tools to Claude format
-        const claudeTools = conversation.tools.map(tool => ({
-            name: tool.name,
-            description: tool.description,
-            input_schema: tool.inputSchema,
-        }));
-        const anthropic = await this.anthropic();
-        const response = await anthropic.messages.create({
-            model,
-            max_tokens: 10000,
-            messages: claudeMessages,
-            tools: claudeTools,
-        });
-        // Extract tool calls and add assistant message to generic conversation
-        const toolCalls = response.content.filter(block => block.type === 'tool_use');
-        const textContent = response.content.filter(block => block.type === 'text').map(block => block.text).join('');
-        const llmToolCalls = toolCalls.map(toolCall => ({
-            name: toolCall.name,
-            arguments: toolCall.input,
-            id: toolCall.id,
-        }));
-        // Add assistant message to generic conversation
-        conversation.messages.push({
-            role: 'assistant',
-            content: textContent,
-            toolCalls: llmToolCalls.length > 0 ? llmToolCalls : undefined
-        });
-        return llmToolCalls;
-    }
-    addToolResults(conversation, results) {
-        for (const result of results) {
-            conversation.messages.push({
-                role: 'tool',
-                toolCallId: result.toolCallId,
-                content: result.content,
-                isError: result.isError,
-            });
-        }
-    }
-    checkDoneToolCall(toolCall) {
-        if (toolCall.name === 'done')
-            return toolCall.arguments.result;
-        return null;
-    }
-}

package/lib/loop/loopOpenAI.js

@@ -1,141 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const model = 'gpt-4.1';
-export class OpenAIDelegate {
-    _openai;
-    async openai() {
-        if (!this._openai) {
-            const oai = await import('openai');
-            this._openai = new oai.OpenAI();
-        }
-        return this._openai;
-    }
-    createConversation(task, tools, oneShot) {
-        const genericTools = tools.map(tool => ({
-            name: tool.name,
-            description: tool.description || '',
-            inputSchema: tool.inputSchema,
-        }));
-        if (!oneShot) {
-            genericTools.push({
-                name: 'done',
-                description: 'Call this tool when the task is complete.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-            });
-        }
-        return {
-            messages: [{
-                    role: 'user',
-                    content: task
-                }],
-            tools: genericTools,
-        };
-    }
-    async makeApiCall(conversation) {
-        // Convert generic messages to OpenAI format
-        const openaiMessages = [];
-        for (const message of conversation.messages) {
-            if (message.role === 'user') {
-                openaiMessages.push({
-                    role: 'user',
-                    content: message.content
-                });
-            }
-            else if (message.role === 'assistant') {
-                const toolCalls = [];
-                if (message.toolCalls) {
-                    for (const toolCall of message.toolCalls) {
-                        toolCalls.push({
-                            id: toolCall.id,
-                            type: 'function',
-                            function: {
-                                name: toolCall.name,
-                                arguments: JSON.stringify(toolCall.arguments)
-                            }
-                        });
-                    }
-                }
-                const assistantMessage = {
-                    role: 'assistant'
-                };
-                if (message.content)
-                    assistantMessage.content = message.content;
-                if (toolCalls.length > 0)
-                    assistantMessage.tool_calls = toolCalls;
-                openaiMessages.push(assistantMessage);
-            }
-            else if (message.role === 'tool') {
-                openaiMessages.push({
-                    role: 'tool',
-                    tool_call_id: message.toolCallId,
-                    content: message.content,
-                });
-            }
-        }
-        // Convert generic tools to OpenAI format
-        const openaiTools = conversation.tools.map(tool => ({
-            type: 'function',
-            function: {
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.inputSchema,
-            },
-        }));
-        const openai = await this.openai();
-        const response = await openai.chat.completions.create({
-            model,
-            messages: openaiMessages,
-            tools: openaiTools,
-            tool_choice: 'auto'
-        });
-        const message = response.choices[0].message;
-        // Extract tool calls and add assistant message to generic conversation
-        const toolCalls = message.tool_calls || [];
-        const genericToolCalls = toolCalls.map(toolCall => {
-            const functionCall = toolCall.function;
-            return {
-                name: functionCall.name,
-                arguments: JSON.parse(functionCall.arguments),
-                id: toolCall.id,
-            };
-        });
-        // Add assistant message to generic conversation
-        conversation.messages.push({
-            role: 'assistant',
-            content: message.content || '',
-            toolCalls: genericToolCalls.length > 0 ? genericToolCalls : undefined
-        });
-        return genericToolCalls;
-    }
-    addToolResults(conversation, results) {
-        for (const result of results) {
-            conversation.messages.push({
-                role: 'tool',
-                toolCallId: result.toolCallId,
-                content: result.content,
-                isError: result.isError,
-            });
-        }
-    }
-    checkDoneToolCall(toolCall) {
-        if (toolCall.name === 'done')
-            return toolCall.arguments.result;
-        return null;
-    }
-}