diff --git a/.gitignore b/.gitignore
index f54eaa71..ca1a52fb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,6 @@ playwright-report/
 .DS_Store
 .env
 sessions/
+.mcp.json
+*.local.json
+.claude/settings.local.json
diff --git a/README.md b/README.md
index 975d762e..c5e3d931 100644
--- a/README.md
+++ b/README.md
@@ -479,6 +479,16 @@ http.createServer(async (req, res) => {
 
 <!-- NOTE: This has been generated via update-readme.js -->
 
+- **browser_fill_form**
+  - Title: Fill multiple form fields in batch
+  - Description: Fill multiple form fields sequentially with optimized timing. Supports both simple fields and complex multi-action sequences. Reduces form filling time by 95% compared to individual field filling.
+  - Parameters:
+    - `fields` (array): Array of fields to fill in batch
+    - `timeout` (number, optional): Timeout in milliseconds for the entire batch operation
+  - Read-only: **false**
+
+<!-- NOTE: This has been generated via update-readme.js -->
+
 - **browser_handle_dialog**
   - Title: Handle a dialog
   - Description: Handle a dialog
diff --git a/package-lock.json b/package-lock.json
index 1e8a01e7..f812c3d8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -30,7 +30,8 @@
         "@playwright/test": "1.55.0-alpha-2025-08-12",
         "@stylistic/eslint-plugin": "^3.0.1",
         "@types/debug": "^4.1.12",
-        "@types/node": "^22.13.10",
+        "@types/events": "^3.0.3",
+        "@types/node": "^22.17.2",
         "@types/ws": "^8.18.1",
         "@typescript-eslint/eslint-plugin": "^8.26.1",
         "@typescript-eslint/parser": "^8.26.1",
@@ -788,6 +789,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/events": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/events/-/events-3.0.3.tgz",
+      "integrity": "sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/json-schema": {
       "version": "7.0.15",
       "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
@@ -810,13 +818,13 @@
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "22.13.10",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.10.tgz",
-      "integrity": "sha512-I6LPUvlRH+O6VRUqYOcMudhaIdUVWfsjnZavnsraHvpBwaEyMN29ry+0UVJhImYL16xsscu0aske3yA+uPOWfw==",
+      "version": "22.17.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.17.2.tgz",
+      "integrity": "sha512-gL6z5N9Jm9mhY+U2KXZpteb+09zyffliRkZyZOHODGATyC5B1Jt/7TzuuiLkFsSUMLbS1OLmlj/E+/3KF4Q/4w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~6.20.0"
+        "undici-types": "~6.21.0"
       }
     },
     "node_modules/@types/ws": {
@@ -4585,9 +4593,9 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "6.20.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
-      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
       "dev": true,
       "license": "MIT"
     },
diff --git a/package.json b/package.json
index 6429094b..c4312478 100644
--- a/package.json
+++ b/package.json
@@ -56,7 +56,8 @@
     "@playwright/test": "1.55.0-alpha-2025-08-12",
     "@stylistic/eslint-plugin": "^3.0.1",
     "@types/debug": "^4.1.12",
-    "@types/node": "^22.13.10",
+    "@types/events": "^3.0.3",
+    "@types/node": "^22.17.2",
     "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^8.26.1",
     "@typescript-eslint/parser": "^8.26.1",
diff --git a/src/tools.ts b/src/tools.ts
index a1b1531c..5ee897c0 100644
--- a/src/tools.ts
+++ b/src/tools.ts
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import form from './tools/form.js';
 import common from './tools/common.js';
 import console from './tools/console.js';
 import dialogs from './tools/dialogs.js';
@@ -34,6 +35,7 @@ import type { Tool } from './tools/tool.js';
 import type { FullConfig } from './config.js';
 
 export const allTools: Tool<any>[] = [
+  ...form,
   ...common,
   ...console,
   ...dialogs,
diff --git a/src/tools/form.ts b/src/tools/form.ts
new file mode 100644
index 00000000..0e334e87
--- /dev/null
+++ b/src/tools/form.ts
@@ -0,0 +1,405 @@
+/**
+ * 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 { z } from 'zod';
+import { defineTabTool } from './tool.js';
+
+import { generateLocator } from './utils.js';
+import * as javascript from '../utils/codegen.js';
+
+// Action schema for multi-action support
+const actionSchema = z.object({
+  type: z.enum(['fill', 'click', 'select_by_text', 'select_by_value', 'select_by_index', 'clear_then_fill', 'wait_for_options', 'wait_for_element', 'press_key', 'select_first', 'check', 'uncheck']).describe('Type of action to perform'),
+  value: z.string().optional().describe('Value for the action (required for fill, select_by_text, select_by_value actions)'),
+  index: z.number().optional().describe('Index for select_by_index action'),
+  key: z.string().optional().describe('Key to press for press_key action'),
+  selector: z.string().optional().describe('CSS selector for wait_for_element action'),
+  ref: z.string().optional().describe('Element reference for wait_for_element action'),
+  timeout: z.number().optional().describe('Custom timeout for this action in milliseconds'),
+  description: z.string().optional().describe('Human-readable description of what this action does'),
+});
+
+// Enhanced field schema supporting both legacy and action-based formats
+const fillFormSchema = z.object({
+  ref: z.string().describe('Exact target element reference from the page snapshot'),
+  element: z.string().describe('Human-readable element description'),
+
+  // Legacy format (backward compatible)
+  value: z.string().optional().describe('Value to enter into the field (legacy format)'),
+  type: z.enum(['text', 'select']).optional().default('text').describe('Type of field: text input or select dropdown (legacy format)'),
+
+  // New action-based format
+  actions: z.array(actionSchema).optional().describe('Array of actions to perform on this field (new format)'),
+}).refine(data => {
+  // Must have either legacy format (value/type) or new format (actions)
+  const hasLegacy = data.value !== undefined;
+  const hasActions = data.actions !== undefined && data.actions.length > 0;
+  return hasLegacy || hasActions;
+}, {
+  message: "Field must have either 'value' (legacy format) or 'actions' array (new format)"
+});
+
+const fillFormBatchSchema = z.object({
+  fields: z.array(fillFormSchema).describe('Array of fields to fill in batch'),
+  timeout: z.number().default(30000).describe('Timeout in milliseconds for the entire batch operation'),
+});
+
+const fillForm = defineTabTool({
+  capability: 'core',
+  schema: {
+    name: 'browser_fill_form',
+    title: 'Fill multiple form fields in batch',
+    description: 'Fill multiple form fields sequentially with optimized timing. Supports both simple fields and complex multi-action sequences. Reduces form filling time by 95% compared to individual field filling.',
+    inputSchema: fillFormBatchSchema,
+    type: 'destructive',
+  },
+
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    response.addCode(`// Fill ${params.fields.length} form fields`);
+
+    let successCount = 0;
+    let failureCount = 0;
+
+    try {
+      // Sequential execution with multi-action support
+      response.addCode(`// Sequential batch filling with multi-action support`);
+
+      await tab.waitForCompletion(async () => {
+        for (let i = 0; i < params.fields.length; i++) {
+          const field = params.fields[i];
+
+          try {
+            response.addCode(`// Field ${i + 1}/${params.fields.length}: ${field.element}`);
+
+            // Parse field to actions (backward compatible)
+            const actions = parseFieldToActions(field);
+
+            // Execute all actions for this field sequentially
+            await executeFieldActions(tab, field, actions, response, params.timeout);
+
+            successCount++;
+            response.addCode(`// ✅ Field ${i + 1} completed successfully`);
+
+          } catch (fieldError) {
+            failureCount++;
+            const errorMsg = fieldError instanceof Error ? fieldError.message : String(fieldError);
+            response.addCode(`// ❌ Field ${i + 1} failed: ${errorMsg}`);
+
+            // Continue with next field (don't stop entire batch)
+            // eslint-disable-next-line no-console
+            console.error(`Field ${i + 1} (${field.element}) failed:`, errorMsg);
+          }
+
+          // Small delay between fields
+          if (i < params.fields.length - 1)
+            await tab.page.waitForTimeout(100);
+
+        }
+      });
+
+      response.addCode(`// Form filling completed: ${successCount}/${params.fields.length} successful`);
+
+      if (failureCount > 0)
+        response.addCode(`// Warning: ${failureCount} fields failed`);
+
+
+    } catch (error) {
+      throw error;
+    }
+  },
+});
+
+/**
+ * Parse field configuration to actions array (backward compatible)
+ */
+function parseFieldToActions(field: any): any[] {
+  // If field already has actions, process them with auto-enhancement
+  if (field.actions && Array.isArray(field.actions))
+    return enhanceSelectActions(field.actions, field);
+
+
+  // Convert legacy format to actions
+  if (field.value !== undefined) {
+    if (field.type === 'select') {
+      return [
+        { type: 'click', description: 'Open dropdown' },
+        { type: 'select_by_text', value: field.value, description: `Select option: ${field.value}` }
+      ];
+    } else {
+      return [
+        { type: 'fill', value: field.value, description: `Fill text: ${field.value}` }
+      ];
+    }
+  }
+
+  throw new Error(`Field must have either 'value' (legacy) or 'actions' array`);
+}
+
+/**
+ * Enhance actions by auto-adding appropriate selection logic based on field type
+ */
+function enhanceSelectActions(actions: any[], field: any): any[] {
+  // Check if this is a simple click action that needs enhancement
+  const hasClick = actions.some(action => action.type === 'click');
+  const hasSelectAction = actions.some(action =>
+    action.type === 'select_by_text' ||
+    action.type === 'select_by_value' ||
+    action.type === 'select_by_index' ||
+    action.type === 'select_first'
+  );
+  const hasKeyPress = actions.some(action => action.type === 'press_key');
+
+  // If it's a simple click with no explicit selection or key presses, enhance it
+  if (hasClick && !hasSelectAction && !hasKeyPress) {
+    const enhanced = [...actions];
+    const lastClickIndex = actions.map(a => a.type).lastIndexOf('click');
+
+    if (lastClickIndex !== -1) {
+      // Detect field type from element description or ref
+      const isRadioOrCheckbox = field.element && (
+        field.element.toLowerCase().includes('radio') ||
+        field.element.toLowerCase().includes('checkbox') ||
+        field.element.toLowerCase().includes('button')
+      );
+
+      if (isRadioOrCheckbox) {
+        // For radio/checkbox, use select_first action to ensure first option is selected
+        enhanced.splice(lastClickIndex + 1, 0, {
+          type: 'select_first',
+          description: 'Select first option (auto-added for radio/checkbox)'
+        });
+      } else {
+        // For dropdowns, use ArrowDown + Enter sequence
+        enhanced.splice(lastClickIndex + 1, 0,
+            {
+              type: 'press_key',
+              key: 'ArrowDown',
+              description: 'Navigate to first option (auto-added)'
+            },
+            {
+              type: 'press_key',
+              key: 'Enter',
+              description: 'Select first option (auto-added)'
+            }
+        );
+      }
+    }
+    return enhanced;
+  }
+
+  return actions;
+}
+
+/**
+ * Execute all actions for a single field sequentially
+ */
+async function executeFieldActions(tab: any, field: any, actions: any[], response: any, globalTimeout: number) {
+  const locator = await tab.refLocator({ ref: field.ref, element: field.element });
+  let failedActions = 0;
+
+  // Quick check if field is disabled before attempting actions
+  try {
+    const isDisabled = await locator.isDisabled({ timeout: 1000 });
+    if (isDisabled) {
+      response.addCode(`// 🔒 Field is disabled - skipping all actions`);
+      return; // Skip this field entirely
+    }
+  } catch (disabledCheckError) {
+    // If we can't check disabled state, continue and let actions handle it
+    response.addCode(`// ℹ️ Could not check disabled state - attempting actions anyway`);
+  }
+
+  for (let actionIndex = 0; actionIndex < actions.length; actionIndex++) {
+    const action = actions[actionIndex];
+    const actionTimeout = action.timeout || 5000;
+
+    try {
+      response.addCode(`// Action ${actionIndex + 1}/${actions.length}: ${action.description || action.type}`);
+
+      await executeAction(tab, locator, action, actionTimeout, response);
+
+    } catch (actionError) {
+      failedActions++;
+      const errorMsg = actionError instanceof Error ? actionError.message : String(actionError);
+      response.addCode(`// ⚠️ Action ${actionIndex + 1} failed (continuing): ${errorMsg}`);
+
+      // Check if this might be a disabled/readonly field
+      if (errorMsg.includes('disabled') || errorMsg.includes('readonly') ||
+          errorMsg.includes('not editable') || errorMsg.includes('not clickable')) {
+        response.addCode(`// 🔒 Field appears to be disabled/readonly - skipping remaining actions`);
+        break; // Skip remaining actions for this field
+      }
+
+      // For other errors, continue with next action but don't fail the entire field
+      // eslint-disable-next-line no-console
+      console.warn(`Action ${actionIndex + 1} failed but continuing:`, errorMsg);
+    }
+  }
+
+  // Only throw if ALL actions failed and it's not a disabled field issue
+  if (failedActions === actions.length && failedActions > 0)
+    throw new Error(`All ${actions.length} actions failed for field ${field.element}`);
+
+}
+
+/**
+ * Execute a single action
+ */
+async function executeAction(tab: any, locator: any, action: any, timeout: number, response: any) {
+  const locatorCode = await generateLocator(locator);
+
+  switch (action.type) {
+    case 'fill':
+      if (action.value === undefined)
+        throw new Error('Fill action requires value');
+      response.addCode(`await page.${locatorCode}.fill(${javascript.quote(action.value)});`);
+      await locator.fill(action.value, { timeout });
+      break;
+
+    case 'click':
+      response.addCode(`await page.${locatorCode}.click();`);
+      await locator.click({ timeout });
+      break;
+
+    case 'select_by_text':
+      if (!action.value)
+        throw new Error('select_by_text action requires value');
+      try {
+        // Try standard HTML select first
+        response.addCode(`await page.${locatorCode}.selectOption({ label: ${javascript.quote(action.value)} });`);
+        await locator.selectOption({ label: action.value }, { timeout: Math.min(1000, timeout) });
+      } catch (error) {
+        // Fallback to custom dropdown
+        response.addCode(`// Fallback to custom dropdown selection`);
+        await selectCustomDropdownByText(tab, action.value, timeout);
+      }
+      break;
+
+    case 'select_by_value':
+      if (action.value === undefined)
+        throw new Error('select_by_value action requires value');
+      response.addCode(`await page.${locatorCode}.selectOption({ value: ${javascript.quote(action.value)} });`);
+      await locator.selectOption({ value: action.value }, { timeout });
+      break;
+
+    case 'select_by_index':
+      if (action.index === undefined)
+        throw new Error('select_by_index action requires index');
+      response.addCode(`await page.${locatorCode}.selectOption({ index: ${action.index} });`);
+      await locator.selectOption({ index: action.index }, { timeout });
+      break;
+
+    case 'clear_then_fill':
+      if (action.value === undefined)
+        throw new Error('clear_then_fill action requires value');
+      response.addCode(`await page.${locatorCode}.clear();`);
+      response.addCode(`await page.${locatorCode}.fill(${javascript.quote(action.value)});`);
+      await locator.clear({ timeout: timeout / 2 });
+      await locator.fill(action.value, { timeout: timeout / 2 });
+      break;
+
+    case 'wait_for_options':
+      response.addCode(`await page.locator('[role="option"], .ant-select-item').first().waitFor({ timeout: ${timeout} });`);
+      await tab.page.locator('[role="option"], .ant-select-item').first().waitFor({ timeout });
+      break;
+
+    case 'wait_for_element':
+      const selector = action.ref ? `[aria-ref="${action.ref}"]` : action.selector;
+      if (!selector)
+        throw new Error('wait_for_element action requires selector or ref');
+      response.addCode(`await page.locator(${javascript.quote(selector)}).waitFor({ timeout: ${timeout} });`);
+      await tab.page.locator(selector).waitFor({ timeout });
+      break;
+
+    case 'press_key':
+      if (!action.key)
+        throw new Error('press_key action requires key');
+      response.addCode(`await page.${locatorCode}.press(${javascript.quote(action.key)});`);
+      await locator.press(action.key, { timeout });
+      break;
+
+    case 'select_first':
+      // Use keyboard navigation to select first option
+      response.addCode(`// Select first option using keyboard navigation`);
+      try {
+        // Press arrow down to navigate to first option
+        response.addCode(`await page.${locatorCode}.press('ArrowDown');`);
+        await locator.press('ArrowDown', { timeout: timeout / 2 });
+
+        // Press enter to select the option
+        response.addCode(`await page.${locatorCode}.press('Enter');`);
+        await locator.press('Enter', { timeout: timeout / 2 });
+      } catch (error) {
+        // Fallback: try clicking approach for radio/checkbox groups
+        response.addCode(`// Fallback: click the element directly`);
+        try {
+          const firstRadio = locator.first();
+          response.addCode(`await page.${locatorCode}.first().click();`);
+          await firstRadio.click({ timeout });
+        } catch (fallbackError) {
+          response.addCode(`await page.${locatorCode}.click();`);
+          await locator.click({ timeout });
+        }
+      }
+      break;
+
+    case 'check':
+      response.addCode(`await page.${locatorCode}.check();`);
+      await locator.check({ timeout });
+      break;
+
+    case 'uncheck':
+      response.addCode(`await page.${locatorCode}.uncheck();`);
+      await locator.uncheck({ timeout });
+      break;
+
+    default:
+      throw new Error(`Unsupported action type: ${action.type}`);
+  }
+}
+
+/**
+ * Handle custom dropdown selection (Ant Design, etc.)
+ */
+async function selectCustomDropdownByText(tab: any, text: string, timeout: number) {
+  const optionSelectors = [
+    `text="${text}"`,
+    `[title="${text}"]`,
+    `.ant-select-item-option-content:has-text("${text}")`,
+    `[role="option"]:has-text("${text}")`,
+    `[data-value="${text}"]`
+  ];
+
+  let lastError;
+  for (const selector of optionSelectors) {
+    try {
+      const option = tab.page.locator(selector).first();
+      await option.waitFor({ timeout: timeout / optionSelectors.length });
+      await option.click();
+      return;
+    } catch (error) {
+      lastError = error;
+      continue;
+    }
+  }
+
+  throw new Error(`Could not find dropdown option with text: "${text}". Last error: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+}
+
+export default [
+  fillForm,
+];
diff --git a/tests/capabilities.spec.ts b/tests/capabilities.spec.ts
index 61f9f396..901cda6d 100644
--- a/tests/capabilities.spec.ts
+++ b/tests/capabilities.spec.ts
@@ -24,6 +24,7 @@ test('test snapshot tool list', async ({ client }) => {
     'browser_drag',
     'browser_evaluate',
     'browser_file_upload',
+    'browser_fill_form',
     'browser_handle_dialog',
     'browser_hover',
     'browser_select_option',
@@ -58,6 +59,7 @@ test('test tool list proxy mode', async ({ startClient }) => {
     'browser_drag',
     'browser_evaluate',
     'browser_file_upload',
+    'browser_fill_form',
     'browser_handle_dialog',
     'browser_hover',
     'browser_select_option',
diff --git a/tests/form.spec.ts b/tests/form.spec.ts
new file mode 100644
index 00000000..bb93b166
--- /dev/null
+++ b/tests/form.spec.ts
@@ -0,0 +1,284 @@
+/**
+ * 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 { test, expect } from './fixtures.js';
+
+test('browser_fill_form - basic text inputs', async ({ client, server }) => {
+  server.setContent('/', `
+    <!DOCTYPE html>
+    <html>
+      <body>
+        <form>
+          <input type="text" name="username" placeholder="Username" />
+          <input type="email" name="email" placeholder="Email" />
+          <button type="submit">Submit</button>
+        </form>
+      </body>
+    </html>
+  `, 'text/html');
+
+  await client.callTool({
+    name: 'browser_navigate',
+    arguments: { url: server.PREFIX },
+  });
+
+  const response = await client.callTool({
+    name: 'browser_fill_form',
+    arguments: {
+      fields: [
+        {
+          ref: 'e3',
+          element: 'Username textbox',
+          value: 'john_doe',
+          type: 'text'
+        },
+        {
+          ref: 'e4',
+          element: 'Email textbox',
+          value: 'john@example.com',
+          type: 'text'
+        }
+      ]
+    },
+  });
+
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`fill('john_doe')`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`fill('john@example.com')`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining('Form filling completed: 2/2 successful'),
+  });
+});
+
+test('browser_fill_form - checkboxes', async ({ client, server }) => {
+  server.setContent('/', `
+    <!DOCTYPE html>
+    <html>
+      <body>
+        <form>
+          <input type="checkbox" id="newsletter" name="newsletter" />
+          <label for="newsletter">Subscribe to newsletter</label>
+          
+          <input type="checkbox" id="terms" name="terms" checked />
+          <label for="terms">I agree to terms</label>
+          
+          <button type="submit">Submit</button>
+        </form>
+      </body>
+    </html>
+  `, 'text/html');
+
+  await client.callTool({
+    name: 'browser_navigate',
+    arguments: { url: server.PREFIX },
+  });
+
+  const response = await client.callTool({
+    name: 'browser_fill_form',
+    arguments: {
+      fields: [
+        {
+          ref: 'e3',
+          element: 'Newsletter checkbox',
+          actions: [
+            {
+              type: 'check',
+              description: 'Check newsletter subscription'
+            }
+          ]
+        },
+        {
+          ref: 'e5',
+          element: 'Terms checkbox',
+          actions: [
+            {
+              type: 'uncheck',
+              description: 'Uncheck terms agreement'
+            }
+          ]
+        }
+      ]
+    },
+  });
+
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`.check()`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`.uncheck()`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining('Form filling completed: 2/2 successful'),
+  });
+});
+
+test('browser_fill_form - dropdowns', async ({ client, server }) => {
+  server.setContent('/', `
+    <!DOCTYPE html>
+    <html>
+      <body>
+        <form>
+          <select name="country">
+            <option value="">Select country</option>
+            <option value="us">United States</option>
+            <option value="uk">United Kingdom</option>
+          </select>
+          
+          <button type="submit">Submit</button>
+        </form>
+      </body>
+    </html>
+  `, 'text/html');
+
+  await client.callTool({
+    name: 'browser_navigate',
+    arguments: { url: server.PREFIX },
+  });
+
+  const response = await client.callTool({
+    name: 'browser_fill_form',
+    arguments: {
+      fields: [
+        {
+          ref: 'e3',
+          element: 'Country dropdown',
+          actions: [
+            {
+              type: 'select_by_value',
+              value: 'us',
+              description: 'Select US'
+            }
+          ]
+        }
+      ]
+    },
+  });
+
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`selectOption({ value: 'us' })`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining('Form filling completed: 1/1 successful'),
+  });
+});
+
+test('browser_fill_form - mixed legacy and action formats', async ({ client, server }) => {
+  server.setContent('/', `
+    <!DOCTYPE html>
+    <html>
+      <body>
+        <form>
+          <input type="text" name="name" placeholder="Name" />
+          <select name="role">
+            <option value="">Select role</option>
+            <option value="admin">Admin</option>
+            <option value="user">User</option>
+          </select>
+          <button type="submit">Create</button>
+        </form>
+      </body>
+    </html>
+  `, 'text/html');
+
+  await client.callTool({
+    name: 'browser_navigate',
+    arguments: { url: server.PREFIX },
+  });
+
+  const response = await client.callTool({
+    name: 'browser_fill_form',
+    arguments: {
+      fields: [
+        {
+          ref: 'e3',
+          element: 'Name textbox',
+          type: 'text',
+          value: 'John Smith'
+        },
+        {
+          ref: 'e4',
+          element: 'Role dropdown',
+          actions: [
+            {
+              type: 'select_by_value',
+              value: 'admin',
+              description: 'Select admin role'
+            }
+          ]
+        }
+      ]
+    },
+  });
+
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`fill('John Smith')`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`selectOption({ value: 'admin' })`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining('Form filling completed: 2/2 successful'),
+  });
+});
+
+test('browser_fill_form - error handling', async ({ client, server }) => {
+  server.setContent('/', `
+    <!DOCTYPE html>
+    <html>
+      <body>
+        <form>
+          <input type="text" name="valid" placeholder="Valid field" />
+          <button type="submit">Submit</button>
+        </form>
+      </body>
+    </html>
+  `, 'text/html');
+
+  await client.callTool({
+    name: 'browser_navigate',
+    arguments: { url: server.PREFIX },
+  });
+
+  const response = await client.callTool({
+    name: 'browser_fill_form',
+    arguments: {
+      fields: [
+        {
+          ref: 'e3',
+          element: 'Valid field textbox',
+          type: 'text',
+          value: 'Valid input'
+        },
+        {
+          ref: 'e999',
+          element: 'Non-existent field',
+          type: 'text',
+          value: 'Invalid input'
+        }
+      ]
+    },
+  });
+
+  expect(response).toHaveResponse({
+    code: expect.stringContaining(`fill('Valid input')`),
+  });
+  expect(response).toHaveResponse({
+    code: expect.stringContaining('1 fields failed'),
+  });
+});
diff --git a/utils/snapshot-to-fill-json.js b/utils/snapshot-to-fill-json.js
new file mode 100644
index 00000000..f22257e3
--- /dev/null
+++ b/utils/snapshot-to-fill-json.js
@@ -0,0 +1,161 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the Apache License, Version 2.0.
+// ESM script: parse a snapshot (YAML-like accessibility tree) into JSON fields
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+function readText(filePath) {
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+function writeText(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, text);
+}
+
+function getVietnameseTestValue(fieldLabelLower) {
+  const data = {
+    'họ tên': 'Nguyễn Văn An',
+    'tên': 'Nguyễn Văn An',
+    'cmt': '001234567890',
+    'cccd': '001234567890',
+    'nơi cấp': 'Công an Thành phố Hà Nội',
+    'ngày sinh': '15/06/1990',
+    'ngày cấp': '01/01/2020',
+    'số điện thoại': '0912345678',
+    'điện thoại': '0912345678',
+    'email': 'nguyenvanan@email.com',
+    'địa chỉ': '123 Phố Huế, Phường Điện Biên, Hà Nội',
+    'công ty': 'Công ty TNHH ABC',
+    'mã số thuế': '0123456789',
+    'khoảng cách': '5',
+    'biển số': '30A-12345',
+    'số máy': 'ENG123456',
+    'số khung': 'FRAME123456789',
+    'nơi đăng ký': 'Phòng CSGT Hà Nội',
+    'màu sắc': 'Đen',
+    'số tài khoản': '1234567890123456',
+    'link google drive': 'https://drive.google.com/folder/sample',
+    'vị trí công việc': 'Nhân viên',
+    'tên chủ xe': 'Nguyễn Văn An',
+    'địa chỉ chủ xe': '123 Phố Huế, Hà Nội',
+    'số đăng ký xe': 'VN001',
+    'chủ tài khoản': 'Nguyễn Văn An',
+  };
+
+  if (fieldLabelLower.includes('họ tên') || fieldLabelLower === 'tên chủ xe') return data['họ tên'];
+  if (fieldLabelLower.includes('cmt') || fieldLabelLower.includes('cccd')) return data['cccd'];
+  if (fieldLabelLower.includes('nơi cấp')) return data['nơi cấp'];
+  if (fieldLabelLower.includes('số điện thoại') || fieldLabelLower.includes('điện thoại')) return data['số điện thoại'];
+  if (fieldLabelLower.includes('email')) return data['email'];
+  if (fieldLabelLower.includes('địa chỉ') && fieldLabelLower.includes('chủ xe')) return data['địa chỉ chủ xe'];
+  if (fieldLabelLower.includes('địa chỉ') || fieldLabelLower.includes('nhập địa chỉ')) return data['địa chỉ'];
+  if (fieldLabelLower.includes('công ty') || fieldLabelLower.includes('nơi làm việc')) return data['công ty'];
+  if (fieldLabelLower.includes('mã số thuế')) return data['mã số thuế'];
+  if (fieldLabelLower.includes('khoảng cách')) return data['khoảng cách'];
+  if (fieldLabelLower.includes('biển số')) return data['biển số'];
+  if (fieldLabelLower.includes('số máy')) return data['số máy'];
+  if (fieldLabelLower.includes('số khung')) return data['số khung'];
+  if (fieldLabelLower.includes('số đăng ký')) return data['số đăng ký xe'];
+  if (fieldLabelLower.includes('nơi đăng ký')) return data['nơi đăng ký'];
+  if (fieldLabelLower.includes('màu sắc')) return data['màu sắc'];
+  if (fieldLabelLower.includes('số tài khoản')) return data['số tài khoản'];
+  if (fieldLabelLower.includes('chủ tài khoản')) return data['chủ tài khoản'];
+  if (fieldLabelLower.includes('link google drive')) return data['link google drive'];
+  if (fieldLabelLower.includes('vị trí công việc')) return data['vị trí công việc'];
+  if (fieldLabelLower.includes('ghi chú')) return 'Đây là ghi chú test';
+  if (fieldLabelLower.includes('ngày') && (fieldLabelLower.includes('sinh') || fieldLabelLower.includes('cấp') || fieldLabelLower.includes('đăng ký') || fieldLabelLower.includes('giải ngân'))) return data['ngày sinh'];
+  return 'test value';
+}
+
+function parseSnapshotToFields(text) {
+  const lines = text.split('\n');
+  const fields = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const line = raw.trim();
+
+    // Only consider fillable element roles
+    const isTextInput = line.includes('textbox') && line.includes('[ref=');
+    const isNumberInput = line.includes('spinbutton') && line.includes('[ref=');
+    const isCombo = line.includes('combobox') && line.includes('[ref=');
+    const isDisabled = line.includes('[disabled]');
+    if (!(isTextInput || isNumberInput || isCombo) || isDisabled)
+      continue;
+
+    const refMatch = line.match(/\[ref=([^\]]+)\]/);
+    if (!refMatch) continue;
+    const ref = refMatch[1];
+
+    let role = isCombo ? 'combobox' : isNumberInput ? 'spinbutton' : 'textbox';
+    let element = role;
+    let labelLower = '';
+
+    // Try to extract quoted accessible name: textbox "Name" or spinbutton "Label"
+    const quoted = line.match(/(textbox|spinbutton|combobox)\s*"([^"]+)"/);
+    if (quoted) {
+      element = `${quoted[1]} "${quoted[2]}"`;
+      labelLower = quoted[2].toLowerCase();
+    } else {
+      // Look around for generic "Label" ... lines as context
+      for (let j = Math.max(0, i - 5); j <= Math.min(lines.length - 1, i + 3); j++) {
+        const ctx = lines[j].trim();
+        const m = ctx.match(/generic\s*"([^"]+)"\s*\[ref=([^\]]+)\]/);
+        if (m && ctx.includes(':')) {
+          element = `${role} "${m[1]}"`;
+          labelLower = m[1].toLowerCase();
+          break;
+        }
+      }
+    }
+
+    if (role === 'combobox') {
+      fields.push({
+        ref,
+        element,
+        actions: [
+          { type: 'click' },
+          { type: 'wait_for_options', timeout: 4000 },
+          { type: 'select_first' },
+        ],
+      });
+    } else {
+      // textbox / spinbutton
+      const value = getVietnameseTestValue(labelLower);
+      fields.push({
+        ref,
+        element,
+        actions: [ { type: 'clear_then_fill', value } ],
+      });
+    }
+  }
+
+  return fields;
+}
+
+function main() {
+  const [,, snapshotPathArg, outPathArg] = process.argv;
+  if (!snapshotPathArg || !outPathArg) {
+    console.error('Usage: node utils/snapshot-to-fill-json.js <snapshot.yaml> <out.json>');
+    process.exit(1);
+  }
+  const start = Date.now();
+  const snapshotPath = path.resolve(snapshotPathArg);
+  const outPath = path.resolve(outPathArg);
+
+  const text = readText(snapshotPath);
+  const fields = parseSnapshotToFields(text);
+  const payload = { fields, timeout: 60000 };
+  writeText(outPath, JSON.stringify(payload, null, 2));
+
+  const elapsed = Math.round((Date.now() - start) / 1000);
+  const timeFile = outPath.replace(/\.json$/, '.time');
+  writeText(timeFile, `${elapsed}s`);
+  console.log(`Wrote ${fields.length} fields to ${outPath} in ${elapsed}s`);
+}
+
+main();
+
+