@agimon-ai/browse-tool 0.2.0 → 0.2.2

package/dist/extension/background.js

@@ -1,3 +1,382 @@
+async function screenshotHandler(args, _context, tabId) {
+  if (!tabId) {
+    return {
+      content: [{ type: "text", text: "No active tab" }],
+      isError: true
+    };
+  }
+  try {
+    const format = args.format || "png";
+    const quality = args.quality;
+    const tab = await globalThis.chrome.tabs.get(tabId);
+    if (!tab.windowId) {
+      return {
+        content: [{ type: "text", text: "Tab has no window" }],
+        isError: true
+      };
+    }
+    await globalThis.chrome.tabs.update(tabId, { active: true });
+    const dataUrl = await globalThis.chrome.tabs.captureVisibleTab(tab.windowId, {
+      format,
+      quality: format === "jpeg" ? quality : void 0
+    });
+    const base64 = dataUrl.split(",")[1];
+    const mimeType = format === "png" ? "image/png" : "image/jpeg";
+    return {
+      content: [
+        {
+          type: "image",
+          data: base64,
+          mimeType
+        }
+      ]
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Screenshot failed";
+    return {
+      content: [{ type: "text", text: message }],
+      isError: true
+    };
+  }
+}
+async function snapshotHandler(args, _context, tabId) {
+  if (!tabId) {
+    return {
+      content: [{ type: "text", text: "No active tab" }],
+      isError: true
+    };
+  }
+  try {
+    const root = typeof args.root === "string" && args.root.trim() ? args.root.trim() : "body";
+    const [result] = await globalThis.chrome.scripting.executeScript({
+      target: { tabId },
+      world: "ISOLATED",
+      args: [root],
+      func: (rootSelector) => {
+        let uidCounter = 0;
+        const uidMap = /* @__PURE__ */ new WeakMap();
+        const assignUid = (element) => {
+          const existing = uidMap.get(element);
+          if (existing) {
+            return existing;
+          }
+          const uid = `ax-${++uidCounter}`;
+          uidMap.set(element, uid);
+          return uid;
+        };
+        const isVisible = (element) => {
+          const style = window.getComputedStyle(element);
+          return style.display !== "none" && style.visibility !== "hidden";
+        };
+        const getInputRole = (input) => {
+          const type = (input.type || "text").toLowerCase();
+          const inputRoles = {
+            button: "button",
+            checkbox: "checkbox",
+            email: "textbox",
+            number: "spinbutton",
+            password: "textbox",
+            radio: "radio",
+            range: "slider",
+            search: "searchbox",
+            submit: "button",
+            tel: "textbox",
+            text: "textbox",
+            url: "textbox"
+          };
+          return inputRoles[type] || "textbox";
+        };
+        const getRole = (element) => {
+          const ariaRole = element.getAttribute("role");
+          if (ariaRole) {
+            return ariaRole;
+          }
+          const tagName = element.tagName.toLowerCase();
+          const roleMap = {
+            a: element.hasAttribute("href") ? "link" : "none",
+            article: "article",
+            aside: "complementary",
+            button: "button",
+            footer: "contentinfo",
+            form: "form",
+            h1: "heading",
+            h2: "heading",
+            h3: "heading",
+            h4: "heading",
+            h5: "heading",
+            h6: "heading",
+            header: "banner",
+            img: "img",
+            input: getInputRole(element),
+            li: "listitem",
+            main: "main",
+            nav: "navigation",
+            ol: "list",
+            option: "option",
+            progress: "progressbar",
+            section: element.hasAttribute("aria-label") ? "region" : "none",
+            select: "combobox",
+            table: "table",
+            tbody: "rowgroup",
+            td: "cell",
+            textarea: "textbox",
+            th: "columnheader",
+            tr: "row",
+            ul: "list"
+          };
+          return roleMap[tagName] || "none";
+        };
+        const getAccessibleName = (element) => {
+          const ariaLabel = element.getAttribute("aria-label");
+          if (ariaLabel) {
+            return ariaLabel;
+          }
+          const labelledBy = element.getAttribute("aria-labelledby");
+          if (labelledBy) {
+            const labels = labelledBy.split(" ").map((id) => document.getElementById(id)?.textContent).filter(Boolean).join(" ");
+            if (labels) {
+              return labels;
+            }
+          }
+          if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+            if (element.id) {
+              const label = document.querySelector(`label[for="${element.id}"]`);
+              if (label?.textContent) {
+                return label.textContent.trim();
+              }
+            }
+            if (element.placeholder) {
+              return element.placeholder;
+            }
+          }
+          const tagName = element.tagName.toLowerCase();
+          if (["button", "a", "h1", "h2", "h3", "h4", "h5", "h6", "label", "option"].includes(tagName)) {
+            const text = element.textContent?.trim();
+            if (text && text.length < 100) {
+              return text;
+            }
+          }
+          if (element instanceof HTMLImageElement && element.alt) {
+            return element.alt;
+          }
+          return void 0;
+        };
+        const addState = (element, node) => {
+          if (document.activeElement === element) {
+            node.focused = true;
+          }
+          if (element.disabled) {
+            node.disabled = true;
+          }
+          if (element instanceof HTMLInputElement && (element.type === "checkbox" || element.type === "radio")) {
+            node.checked = element.indeterminate ? "mixed" : element.checked;
+          }
+          if (element instanceof HTMLOptionElement) {
+            node.selected = element.selected;
+          }
+          const expanded = element.getAttribute("aria-expanded");
+          if (expanded) {
+            node.expanded = expanded === "true";
+          }
+          const headingMatch = element.tagName.match(/^H([1-6])$/);
+          if (headingMatch) {
+            node.level = Number.parseInt(headingMatch[1], 10);
+          }
+          const pressed = element.getAttribute("aria-pressed");
+          if (pressed) {
+            node.pressed = pressed === "mixed" ? "mixed" : pressed === "true";
+          }
+        };
+        const buildNode = (element) => {
+          if (!isVisible(element)) {
+            return null;
+          }
+          const children = [];
+          for (const child of element.children) {
+            const childNode = buildNode(child);
+            if (childNode) {
+              children.push(childNode);
+            }
+          }
+          const role = getRole(element);
+          const name = getAccessibleName(element);
+          if (role === "none" && !name && children.length === 1) {
+            return children[0];
+          }
+          const node = {
+            uid: assignUid(element),
+            role
+          };
+          if (name) {
+            node.name = name;
+          }
+          if (children.length > 0) {
+            node.children = children;
+          }
+          addState(element, node);
+          return node;
+        };
+        const rootElement = document.querySelector(rootSelector) ?? document.body;
+        if (!(rootElement instanceof Element)) {
+          throw new Error(`Root element not found: ${rootSelector}`);
+        }
+        return buildNode(rootElement) ?? { uid: "root", role: "none", name: "Empty page" };
+      }
+    });
+    if (!result) {
+      return {
+        content: [{ type: "text", text: `Snapshot failed: executeScript returned no result (tabId=${tabId})` }],
+        isError: true
+      };
+    }
+    const snapshot = JSON.stringify(result.result ?? { uid: "root", role: "none", name: "Empty page" }, null, 2);
+    return {
+      content: [
+        {
+          type: "text",
+          text: snapshot || "No accessibility tree available"
+        }
+      ]
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Snapshot error (tabId=${tabId}): ${message}` }],
+      isError: true
+    };
+  }
+}
+
+async function resizePageHandler(args, _context, tabId) {
+  if (!tabId) {
+    return {
+      content: [{ type: "text", text: "No active tab" }],
+      isError: true
+    };
+  }
+  const width = args.width;
+  const height = args.height;
+  if (!width || !height) {
+    return {
+      content: [{ type: "text", text: "width and height are required" }],
+      isError: true
+    };
+  }
+  try {
+    const tab = await globalThis.chrome.tabs.get(tabId);
+    if (!tab.windowId) {
+      return {
+        content: [{ type: "text", text: "Cannot find window for tab" }],
+        isError: true
+      };
+    }
+    await globalThis.chrome.windows.update(tab.windowId, {
+      width,
+      height
+    });
+    return {
+      content: [{ type: "text", text: `Page resized to ${width}x${height}` }]
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Resize failed";
+    return {
+      content: [{ type: "text", text: message }],
+      isError: true
+    };
+  }
+}
+async function handleDialogHandler(args, _context, tabId) {
+  if (!tabId) {
+    return {
+      content: [{ type: "text", text: "No active tab" }],
+      isError: true
+    };
+  }
+  const accept = args.accept !== false;
+  const promptText = args.promptText;
+  try {
+    await globalThis.chrome.debugger.attach({ tabId }, "1.3");
+    await globalThis.chrome.debugger.sendCommand({ tabId }, "Page.handleJavaScriptDialog", {
+      accept,
+      promptText
+    });
+    await globalThis.chrome.debugger.detach({ tabId });
+    return {
+      content: [{ type: "text", text: `Dialog ${accept ? "accepted" : "dismissed"}` }]
+    };
+  } catch (error) {
+    try {
+      await globalThis.chrome.debugger.detach({ tabId });
+    } catch {
+    }
+    const message = error instanceof Error ? error.message : "Handle dialog failed";
+    return {
+      content: [{ type: "text", text: message }],
+      isError: true
+    };
+  }
+}
+async function emulateHandler(args, _context, tabId) {
+  if (!tabId) {
+    return {
+      content: [{ type: "text", text: "No active tab" }],
+      isError: true
+    };
+  }
+  try {
+    await globalThis.chrome.debugger.attach({ tabId }, "1.3");
+    const commands = [];
+    if (args.geolocation) {
+      const geo = args.geolocation;
+      commands.push({
+        method: "Emulation.setGeolocationOverride",
+        params: {
+          latitude: geo.latitude,
+          longitude: geo.longitude,
+          accuracy: geo.accuracy || 100
+        }
+      });
+    }
+    if (args.timezone) {
+      commands.push({
+        method: "Emulation.setTimezoneOverride",
+        params: { timezoneId: args.timezone }
+      });
+    }
+    if (args.locale) {
+      commands.push({
+        method: "Emulation.setLocaleOverride",
+        params: { locale: args.locale }
+      });
+    }
+    if (args.colorScheme) {
+      commands.push({
+        method: "Emulation.setEmulatedMedia",
+        params: {
+          features: [{ name: "prefers-color-scheme", value: args.colorScheme }]
+        }
+      });
+    }
+    for (const cmd of commands) {
+      await globalThis.chrome.debugger.sendCommand({ tabId }, cmd.method, cmd.params);
+    }
+    await globalThis.chrome.debugger.detach({ tabId });
+    return {
+      content: [{ type: "text", text: "Emulation settings applied" }]
+    };
+  } catch (error) {
+    try {
+      await globalThis.chrome.debugger.detach({ tabId });
+    } catch {
+    }
+    const message = error instanceof Error ? error.message : "Emulation failed";
+    return {
+      content: [{ type: "text", text: message }],
+      isError: true
+    };
+  }
+}
+
 /** A special constant with type `never` */
 function $constructor(name, initializer, params) {
     function init(inst, def) {
@@ -4786,17 +5165,60 @@ object({
 function createContentMessage(action, params = {}) {
   return { action, params };
 }
+function attachTelemetryToParams(source, params) {
+  const telemetry = source.__browseToolTelemetry;
+  if (!telemetry || typeof telemetry !== "object") {
+    return params;
+  }
+  return {
+    ...params,
+    __browseToolTelemetry: telemetry
+  };
+}
 
+const POST_INJECTION_RETRY_COUNT = 5;
+const POST_INJECTION_RETRY_DELAY_MS = 100;
+function isContentResponse(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.success === "boolean";
+}
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function sendValidatedMessage(tabId, message) {
+  const response = await globalThis.chrome.tabs.sendMessage(tabId, message);
+  if (!isContentResponse(response)) {
+    throw new Error(`Content script returned an invalid response (tabId=${tabId})`);
+  }
+  return response;
+}
 async function sendMessageToContentScript(tabId, message) {
   try {
-    const response = await globalThis.chrome.tabs.sendMessage(tabId, message);
-    return response;
+    return await sendValidatedMessage(tabId, message);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("Could not establish connection") || errorMessage.includes("Receiving end does not exist")) {
+    if (errorMessage.includes("Could not establish connection") || errorMessage.includes("Receiving end does not exist") || errorMessage.includes("invalid response")) {
       await injectContentScript(tabId);
-      const response = await globalThis.chrome.tabs.sendMessage(tabId, message);
-      return response;
+      let lastError;
+      for (let attempt = 1; attempt <= POST_INJECTION_RETRY_COUNT; attempt += 1) {
+        try {
+          return await sendValidatedMessage(tabId, message);
+        } catch (retryError) {
+          lastError = retryError instanceof Error ? retryError : new Error(String(retryError));
+          if (attempt < POST_INJECTION_RETRY_COUNT) {
+            await delay(POST_INJECTION_RETRY_DELAY_MS);
+          }
+        }
+      }
+      throw new Error(
+        `Content script returned an invalid response after injection (tabId=${tabId}): ${lastError?.message ?? "unknown error"}`,
+        {
+          cause: error
+        }
+      );
     }
     throw error;
   }
@@ -4810,218 +5232,15 @@ async function injectContentScript(tabId) {
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     if (errorMessage.includes("Cannot access")) {
-      throw new Error(`Cannot inject content script into restricted page (tabId=${tabId}): ${errorMessage}`);
+      throw new Error(`Cannot inject content script into restricted page (tabId=${tabId}): ${errorMessage}`, {
+        cause: error
+      });
     }
-    throw new Error(`Content script injection failed (tabId=${tabId}): ${errorMessage}`);
+    throw new Error(`Content script injection failed (tabId=${tabId}): ${errorMessage}`, { cause: error });
   }
 }
 
-async function screenshotHandler(args, _context, tabId) {
-  if (!tabId) {
-    return {
-      content: [{ type: "text", text: "No active tab" }],
-      isError: true
-    };
-  }
-  try {
-    const format = args.format || "png";
-    const quality = args.quality;
-    const tab = await globalThis.chrome.tabs.get(tabId);
-    if (!tab.windowId) {
-      return {
-        content: [{ type: "text", text: "Tab has no window" }],
-        isError: true
-      };
-    }
-    await globalThis.chrome.tabs.update(tabId, { active: true });
-    const dataUrl = await globalThis.chrome.tabs.captureVisibleTab(tab.windowId, {
-      format,
-      quality: format === "jpeg" ? quality : void 0
-    });
-    const base64 = dataUrl.split(",")[1];
-    const mimeType = format === "png" ? "image/png" : "image/jpeg";
-    return {
-      content: [
-        {
-          type: "image",
-          data: base64,
-          mimeType
-        }
-      ]
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Screenshot failed";
-    return {
-      content: [{ type: "text", text: message }],
-      isError: true
-    };
-  }
-}
-async function snapshotHandler(_args, _context, tabId) {
-  if (!tabId) {
-    return {
-      content: [{ type: "text", text: "No active tab" }],
-      isError: true
-    };
-  }
-  try {
-    const message = createContentMessage(ContentAction.GET_SNAPSHOT, {});
-    const response = await sendMessageToContentScript(tabId, message);
-    if (!response.success) {
-      return {
-        content: [{ type: "text", text: `Snapshot failed: ${response.error || "unknown error from content script"}` }],
-        isError: true
-      };
-    }
-    const snapshot = typeof response.result === "string" ? response.result : JSON.stringify(response.result, null, 2);
-    return {
-      content: [
-        {
-          type: "text",
-          text: snapshot || "No accessibility tree available"
-        }
-      ]
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      content: [{ type: "text", text: `Snapshot error (tabId=${tabId}): ${message}` }],
-      isError: true
-    };
-  }
-}
-
-async function resizePageHandler(args, _context, tabId) {
-  if (!tabId) {
-    return {
-      content: [{ type: "text", text: "No active tab" }],
-      isError: true
-    };
-  }
-  const width = args.width;
-  const height = args.height;
-  if (!width || !height) {
-    return {
-      content: [{ type: "text", text: "width and height are required" }],
-      isError: true
-    };
-  }
-  try {
-    const tab = await globalThis.chrome.tabs.get(tabId);
-    if (!tab.windowId) {
-      return {
-        content: [{ type: "text", text: "Cannot find window for tab" }],
-        isError: true
-      };
-    }
-    await globalThis.chrome.windows.update(tab.windowId, {
-      width,
-      height
-    });
-    return {
-      content: [{ type: "text", text: `Page resized to ${width}x${height}` }]
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Resize failed";
-    return {
-      content: [{ type: "text", text: message }],
-      isError: true
-    };
-  }
-}
-async function handleDialogHandler(args, _context, tabId) {
-  if (!tabId) {
-    return {
-      content: [{ type: "text", text: "No active tab" }],
-      isError: true
-    };
-  }
-  const accept = args.accept !== false;
-  const promptText = args.promptText;
-  try {
-    await globalThis.chrome.debugger.attach({ tabId }, "1.3");
-    await globalThis.chrome.debugger.sendCommand({ tabId }, "Page.handleJavaScriptDialog", {
-      accept,
-      promptText
-    });
-    await globalThis.chrome.debugger.detach({ tabId });
-    return {
-      content: [{ type: "text", text: `Dialog ${accept ? "accepted" : "dismissed"}` }]
-    };
-  } catch (error) {
-    try {
-      await globalThis.chrome.debugger.detach({ tabId });
-    } catch {
-    }
-    const message = error instanceof Error ? error.message : "Handle dialog failed";
-    return {
-      content: [{ type: "text", text: message }],
-      isError: true
-    };
-  }
-}
-async function emulateHandler(args, _context, tabId) {
-  if (!tabId) {
-    return {
-      content: [{ type: "text", text: "No active tab" }],
-      isError: true
-    };
-  }
-  try {
-    await globalThis.chrome.debugger.attach({ tabId }, "1.3");
-    const commands = [];
-    if (args.geolocation) {
-      const geo = args.geolocation;
-      commands.push({
-        method: "Emulation.setGeolocationOverride",
-        params: {
-          latitude: geo.latitude,
-          longitude: geo.longitude,
-          accuracy: geo.accuracy || 100
-        }
-      });
-    }
-    if (args.timezone) {
-      commands.push({
-        method: "Emulation.setTimezoneOverride",
-        params: { timezoneId: args.timezone }
-      });
-    }
-    if (args.locale) {
-      commands.push({
-        method: "Emulation.setLocaleOverride",
-        params: { locale: args.locale }
-      });
-    }
-    if (args.colorScheme) {
-      commands.push({
-        method: "Emulation.setEmulatedMedia",
-        params: {
-          features: [{ name: "prefers-color-scheme", value: args.colorScheme }]
-        }
-      });
-    }
-    for (const cmd of commands) {
-      await globalThis.chrome.debugger.sendCommand({ tabId }, cmd.method, cmd.params);
-    }
-    await globalThis.chrome.debugger.detach({ tabId });
-    return {
-      content: [{ type: "text", text: "Emulation settings applied" }]
-    };
-  } catch (error) {
-    try {
-      await globalThis.chrome.debugger.detach({ tabId });
-    } catch {
-    }
-    const message = error instanceof Error ? error.message : "Emulation failed";
-    return {
-      content: [{ type: "text", text: message }],
-      isError: true
-    };
-  }
-}
-
-async function selectHandler(args, _context, tabId) {
+async function selectHandler(args, _context, tabId) {
   if (!tabId) {
     return {
       content: [{ type: "text", text: "No active tab" }],
@@ -5030,10 +5249,12 @@ async function selectHandler(args, _context, tabId) {
   }
   try {
     const message = createContentMessage(ContentAction.SELECT, {
-      selector: args.selector,
-      xpath: args.xpath,
-      uid: args.uid,
-      value: args.values || args.value
+      ...attachTelemetryToParams(args, {
+        selector: args.selector,
+        xpath: args.xpath,
+        uid: args.uid,
+        value: args.values || args.value
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5062,10 +5283,12 @@ async function hoverHandler(args, _context, tabId) {
   }
   try {
     const message = createContentMessage(ContentAction.HOVER, {
-      selector: args.selector,
-      xpath: args.xpath,
-      text: args.text,
-      uid: args.uid
+      ...attachTelemetryToParams(args, {
+        selector: args.selector,
+        xpath: args.xpath,
+        text: args.text,
+        uid: args.uid
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5094,16 +5317,18 @@ async function dragHandler(args, _context, tabId) {
   }
   try {
     const message = createContentMessage(ContentAction.DRAG, {
-      source: {
-        selector: args.selector,
-        xpath: args.xpath,
-        uid: args.uid
-      },
-      target: {
-        selector: args.targetSelector,
-        xpath: args.targetXpath,
-        uid: args.targetUid
-      }
+      ...attachTelemetryToParams(args, {
+        source: {
+          selector: args.selector,
+          xpath: args.xpath,
+          uid: args.uid
+        },
+        target: {
+          selector: args.targetSelector,
+          xpath: args.targetXpath,
+          uid: args.targetUid
+        }
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5139,8 +5364,10 @@ async function pressKeyHandler(args, _context, tabId) {
   }
   try {
     const message = createContentMessage(ContentAction.PRESS_KEY, {
-      key,
-      modifiers: args.modifiers
+      ...attachTelemetryToParams(args, {
+        key,
+        modifiers: args.modifiers
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5170,13 +5397,15 @@ async function clickHandler(args, _context, tabId) {
   }
   try {
     const message = createContentMessage(ContentAction.CLICK, {
-      selector: args.selector,
-      xpath: args.xpath,
-      text: args.text,
-      uid: args.uid,
-      button: args.button,
-      clickCount: args.clickCount,
-      modifiers: args.modifiers
+      ...attachTelemetryToParams(args, {
+        selector: args.selector,
+        xpath: args.xpath,
+        text: args.text,
+        uid: args.uid,
+        button: args.button,
+        clickCount: args.clickCount,
+        modifiers: args.modifiers
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5212,12 +5441,14 @@ async function fillHandler(args, _context, tabId) {
   }
   try {
     const message = createContentMessage(ContentAction.FILL, {
-      selector: args.selector,
-      xpath: args.xpath,
-      text: args.text,
-      uid: args.uid,
-      value,
-      force: args.force
+      ...attachTelemetryToParams(args, {
+        selector: args.selector,
+        xpath: args.xpath,
+        text: args.text,
+        uid: args.uid,
+        value,
+        force: args.force
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5253,11 +5484,13 @@ async function typeHandler(args, _context, tabId) {
   }
   try {
     const message = createContentMessage(ContentAction.TYPE, {
-      selector: args.selector,
-      xpath: args.xpath,
-      uid: args.uid,
-      text,
-      delay: args.delay
+      ...attachTelemetryToParams(args, {
+        selector: args.selector,
+        xpath: args.xpath,
+        uid: args.uid,
+        text,
+        delay: args.delay
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5277,6 +5510,159 @@ async function typeHandler(args, _context, tabId) {
     };
   }
 }
+async function uploadFileHandler(args, _context, tabId) {
+  if (!tabId) {
+    return {
+      content: [{ type: "text", text: "No active tab" }],
+      isError: true
+    };
+  }
+  const filesInput = args.files;
+  const files = Array.isArray(filesInput) ? filesInput : typeof filesInput === "string" ? [filesInput] : [];
+  if (files.length === 0 || files.some((file) => typeof file !== "string" || !file)) {
+    return {
+      content: [{ type: "text", text: "files is required and must be a string or string[]" }],
+      isError: true
+    };
+  }
+  const markerAttr = "data-browse-tool-upload-id";
+  const markerValue = `upload-${crypto.randomUUID()}`;
+  try {
+    const [markerResult] = await globalThis.chrome.scripting.executeScript({
+      target: { tabId },
+      world: "ISOLATED",
+      args: [
+        {
+          selector: args.selector,
+          xpath: args.xpath,
+          text: args.text,
+          uid: args.uid
+        },
+        markerAttr,
+        markerValue
+      ],
+      func: (locator, attrName, attrValue) => {
+        const findByText = (text) => {
+          const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT, {
+            acceptNode(node) {
+              const element = node;
+              return element.textContent?.includes(text) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+            }
+          });
+          const match = walker.nextNode();
+          return match instanceof Element ? match : null;
+        };
+        const locateElement = () => {
+          if (typeof locator.selector === "string" && locator.selector) {
+            const element = document.querySelector(locator.selector);
+            if (element) {
+              return element;
+            }
+          }
+          if (typeof locator.xpath === "string" && locator.xpath) {
+            const result = document.evaluate(locator.xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+            if (result.singleNodeValue instanceof Element) {
+              return result.singleNodeValue;
+            }
+          }
+          if (typeof locator.text === "string" && locator.text) {
+            const element = findByText(locator.text);
+            if (element) {
+              return element;
+            }
+          }
+          if (typeof locator.uid === "string" && locator.uid) {
+            const element = document.querySelector(`[data-browse-tool-uid="${locator.uid}"]`);
+            if (element) {
+              return element;
+            }
+          }
+          return document.querySelector('input[type="file"]');
+        };
+        const resolveFileInput = (element) => {
+          if (!element) {
+            return null;
+          }
+          if (element instanceof HTMLInputElement && element.type === "file") {
+            return element;
+          }
+          if (element instanceof HTMLLabelElement && element.htmlFor) {
+            const labelled = document.getElementById(element.htmlFor);
+            if (labelled instanceof HTMLInputElement && labelled.type === "file") {
+              return labelled;
+            }
+          }
+          const nested = element.querySelector('input[type="file"]');
+          return nested instanceof HTMLInputElement ? nested : null;
+        };
+        const input = resolveFileInput(locateElement());
+        if (!input) {
+          throw new Error("File input element not found");
+        }
+        input.setAttribute(attrName, attrValue);
+        return {
+          ok: true,
+          multiple: input.multiple
+        };
+      }
+    });
+    if (!markerResult?.result || typeof markerResult.result !== "object") {
+      return {
+        content: [{ type: "text", text: "Failed to resolve file input element" }],
+        isError: true
+      };
+    }
+    await globalThis.chrome.debugger.attach({ tabId }, "1.3");
+    try {
+      const documentRoot = await globalThis.chrome.debugger.sendCommand({ tabId }, "DOM.getDocument", {
+        depth: -1
+      });
+      const rootNodeId = documentRoot.root?.nodeId;
+      if (!rootNodeId) {
+        throw new Error("Failed to resolve document root");
+      }
+      const queryResult = await globalThis.chrome.debugger.sendCommand({ tabId }, "DOM.querySelector", {
+        nodeId: rootNodeId,
+        selector: `input[${markerAttr}="${markerValue}"]`
+      });
+      if (!queryResult.nodeId) {
+        throw new Error("Failed to resolve file input node");
+      }
+      await globalThis.chrome.debugger.sendCommand({ tabId }, "DOM.setFileInputFiles", {
+        nodeId: queryResult.nodeId,
+        files
+      });
+    } finally {
+      try {
+        await globalThis.chrome.debugger.detach({ tabId });
+      } catch {
+      }
+      try {
+        await globalThis.chrome.scripting.executeScript({
+          target: { tabId },
+          world: "ISOLATED",
+          args: [markerAttr, markerValue],
+          func: (attrName, attrValue) => {
+            const element = document.querySelector(`input[${attrName}="${attrValue}"]`);
+            if (element instanceof HTMLInputElement) {
+              element.removeAttribute(attrName);
+            }
+          }
+        });
+      } catch {
+      }
+    }
+    return {
+      content: [{ type: "text", text: `Uploaded ${files.length} file(s) successfully` }]
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Upload failed";
+    return {
+      content: [{ type: "text", text: errorMessage }],
+      isError: true
+    };
+  }
+}
 
 async function navigateHandler(args, _context, tabId) {
   const url = args.url;
@@ -5325,7 +5711,9 @@ async function navigateHandler(args, _context, tabId) {
   }
 }
 
-async function waitForNavigation(tabId, timeout = 3e4) {
+const DEFAULT_TOOL_TIMEOUT_MS = 18e4;
+
+async function waitForNavigation(tabId, timeout = DEFAULT_TOOL_TIMEOUT_MS) {
   return new Promise((resolve) => {
     const listener = (updatedTabId, changeInfo) => {
       if (updatedTabId === tabId && changeInfo.status === "complete") {
@@ -5450,7 +5838,7 @@ async function pdfHandler(args, _context, tabId) {
 }
 
 let activeRecordingTabId;
-async function startRecordingHandler(_args, _context, tabId) {
+async function startRecordingHandler(args, context, tabId) {
   if (!tabId) {
     return {
       content: [{ type: "text", text: "No active tab" }],
@@ -5493,7 +5881,7 @@ async function startRecordingHandler(_args, _context, tabId) {
     };
   }
 }
-async function stopRecordingHandler(_args, _context, _tabId) {
+async function stopRecordingHandler(args, context, tabId) {
   if (activeRecordingTabId === void 0) {
     return {
       content: [{ type: "text", text: "No recording in progress" }],
@@ -5544,47 +5932,38 @@ async function evaluateScriptHandler(args, _context, tabId) {
     };
   }
   try {
-    const results = await globalThis.chrome.scripting.executeScript({
-      target: { tabId },
-      world: "MAIN",
-      func: (code) => {
-        const resultId = `__playwright_mcp_result_${Date.now()}`;
-        const script2 = document.createElement("script");
-        script2.textContent = `
-          try {
-            const __result = (function() { return ${code}; })();
-            document.body.setAttribute('${resultId}', JSON.stringify({ success: true, result: __result }));
-          } catch (e) {
-            document.body.setAttribute('${resultId}', JSON.stringify({ success: false, error: e.message }));
-          }
-        `;
-        document.body.appendChild(script2);
-        script2.remove();
-        const resultStr = document.body.getAttribute(resultId);
-        document.body.removeAttribute(resultId);
-        if (resultStr) {
-          return JSON.parse(resultStr);
-        }
-        return { success: false, error: "No result returned" };
-      },
-      args: [script]
+    const arg = args.arg;
+    const functionLikePattern = /^\s*(?:async\s+)?(?:function\b|\(?\s*[\w$,\s]*\)?\s*=>)/;
+    const expression = arg !== void 0 && functionLikePattern.test(script) ? `(${script})(${JSON.stringify(arg)})` : script;
+    await globalThis.chrome.debugger.attach({ tabId }, "1.3");
+    const response = await globalThis.chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+      awaitPromise: true,
+      allowUnsafeEvalBlockedByCSP: true
     });
-    const result = results[0]?.result;
-    if (!result?.success) {
+    await globalThis.chrome.debugger.detach({ tabId });
+    if (response.exceptionDetails) {
+      const errorMessage = response.exceptionDetails.exception?.description || response.exceptionDetails.exception?.value || response.exceptionDetails.text || "Script execution failed";
       return {
-        content: [{ type: "text", text: result?.error || "Script execution failed" }],
+        content: [{ type: "text", text: errorMessage }],
         isError: true
       };
     }
+    const value = response.result?.value ?? response.result?.unserializableValue ?? null;
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(result.result, null, 2)
+          text: JSON.stringify(value, null, 2)
         }
       ]
     };
   } catch (error) {
+    try {
+      await globalThis.chrome.debugger.detach({ tabId });
+    } catch {
+    }
     const message = error instanceof Error ? error.message : "Script execution failed";
     return {
       content: [{ type: "text", text: message }],
@@ -5599,13 +5978,23 @@ async function waitForHandler(args, _context, tabId) {
       isError: true
     };
   }
-  const timeout = args.timeout || 3e4;
+  const timeout = args.timeout || DEFAULT_TOOL_TIMEOUT_MS;
+  const selector = args.selector;
+  const text = args.text;
+  if (!selector && !text) {
+    await new Promise((resolve) => setTimeout(resolve, timeout));
+    return {
+      content: [{ type: "text", text: `Waited for ${timeout}ms` }]
+    };
+  }
   try {
     const message = createContentMessage(ContentAction.WAIT_FOR, {
-      selector: args.selector,
-      text: args.text,
-      state: args.state || "visible",
-      timeout
+      ...attachTelemetryToParams(args, {
+        selector,
+        text,
+        state: args.state || "visible",
+        timeout
+      })
     });
     const response = await sendMessageToContentScript(tabId, message);
     if (!response.success) {
@@ -5641,7 +6030,7 @@ async function waitForResponseHandler(args, _context, tabId) {
       isError: true
     };
   }
-  const timeout = typeof args.timeout === "number" ? args.timeout : 3e4;
+  const timeout = typeof args.timeout === "number" ? args.timeout : DEFAULT_TOOL_TIMEOUT_MS;
   const url = typeof args.url === "string" ? args.url : void 0;
   const method = typeof args.method === "string" ? args.method : void 0;
   const status = typeof args.status === "number" ? args.status : void 0;
@@ -5793,12 +6182,12 @@ async function clearStorageStateHandler(_args, _context, tabId) {
   }
 }
 
-async function listPagesHandler(_args, context, _tabId) {
+async function listPagesHandler(args, context, tabId) {
   try {
     const chromeTabs = await globalThis.chrome.tabs.query({});
     const tabList = chromeTabs.filter((tab) => tab.id !== void 0).map((tab) => {
-      const tabId = tab.id;
-      const pageId = context.tabRegistry.getByTabId(tabId)?.id || `tab-${tabId}`;
+      const tabId2 = tab.id;
+      const pageId = context.tabRegistry.getByTabId(tabId2)?.id || `tab-${tabId2}`;
       return {
         id: pageId,
         url: tab.url || "",
@@ -5822,7 +6211,7 @@ async function listPagesHandler(_args, context, _tabId) {
     };
   }
 }
-async function newPageHandler(args, context, _tabId) {
+async function newPageHandler(args, context, tabId) {
   try {
     const url = args.url || "about:blank";
     const tab = await globalThis.chrome.tabs.create({ url });
@@ -5850,7 +6239,7 @@ async function newPageHandler(args, context, _tabId) {
     };
   }
 }
-async function selectPageHandler(args, context, _tabId) {
+async function selectPageHandler(args, context, tabId) {
   const pageId = args.pageId;
   if (!pageId) {
     return {
@@ -5884,7 +6273,7 @@ async function selectPageHandler(args, context, _tabId) {
     };
   }
 }
-async function closePageHandler(args, context, _tabId) {
+async function closePageHandler(args, context, tabId) {
   const pageId = args.pageId;
   if (!pageId) {
     return {
@@ -5934,6 +6323,7 @@ const toolHandlers = {
   browser_click: clickHandler,
   browser_fill: fillHandler,
   browser_type: typeHandler,
+  browser_upload_file: uploadFileHandler,
   // Extended input
   browser_select: selectHandler,
   browser_hover: hoverHandler,
@@ -5987,6 +6377,226 @@ async function executeToolRequest(request, context) {
   }
 }
 
+const SCOPE_NAME = "browse-tool-extension";
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "0.0.0.0"]);
+function randomHex(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+function nowUnixNano() {
+  return `${BigInt(Date.now()) * 1000000n}`;
+}
+function sanitizeAttributes(attributes) {
+  if (!attributes) {
+    return [];
+  }
+  return Object.entries(attributes).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => ({
+    key,
+    value: toOtlpAnyValue(value)
+  }));
+}
+function toOtlpAnyValue(value) {
+  if (typeof value === "boolean") {
+    return { boolValue: value };
+  }
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
+  }
+  if (Array.isArray(value)) {
+    return {
+      arrayValue: {
+        values: value.map((item) => toOtlpAnyValue(item))
+      }
+    };
+  }
+  if (typeof value === "object" && value !== null) {
+    return { stringValue: JSON.stringify(value) };
+  }
+  return { stringValue: String(value) };
+}
+function severityNumber(level) {
+  switch (level) {
+    case "trace":
+      return 1;
+    case "debug":
+      return 5;
+    case "info":
+      return 9;
+    case "warn":
+      return 13;
+    case "error":
+      return 17;
+    case "fatal":
+      return 21;
+  }
+}
+function safeRequestOrigin(serverUrl) {
+  try {
+    return new URL(serverUrl).origin;
+  } catch {
+    return void 0;
+  }
+}
+function isLoopbackHost(hostname) {
+  return LOOPBACK_HOSTS.has(hostname);
+}
+class ExtensionTelemetryClient {
+  config = {
+    enabled: false,
+    serviceName: "browse-tool-extension"
+  };
+  configuredServerOrigin;
+  async configure(serverUrl) {
+    const requestOrigin = safeRequestOrigin(serverUrl);
+    if (!requestOrigin || this.configuredServerOrigin === requestOrigin) {
+      return;
+    }
+    try {
+      const response = await fetch(`${requestOrigin}/extension/telemetry-config`, {
+        method: "GET",
+        headers: {
+          Accept: "application/json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const config = await response.json();
+      this.config = config;
+      this.configuredServerOrigin = requestOrigin;
+    } catch {
+      this.config = {
+        enabled: false,
+        serviceName: this.config.serviceName
+      };
+      this.configuredServerOrigin = requestOrigin;
+    }
+  }
+  getConfig() {
+    return this.config;
+  }
+  startSpan(name, parentContext, options = {}) {
+    const context = {
+      traceId: parentContext?.traceId ?? randomHex(16),
+      spanId: randomHex(8),
+      ...parentContext?.spanId ? { parentSpanId: parentContext.spanId } : {}
+    };
+    const startTimeUnixNano = nowUnixNano();
+    return {
+      context,
+      end: async (status) => {
+        if (!this.config.enabled || !this.config.tracesEndpoint) {
+          return;
+        }
+        await this.postJson(this.config.tracesEndpoint, {
+          resourceSpans: [
+            {
+              resource: {
+                attributes: [
+                  {
+                    key: "service.name",
+                    value: { stringValue: this.config.serviceName }
+                  },
+                  {
+                    key: "telemetry.sdk.language",
+                    value: { stringValue: "webjs" }
+                  }
+                ]
+              },
+              scopeSpans: [
+                {
+                  scope: { name: SCOPE_NAME },
+                  spans: [
+                    {
+                      traceId: context.traceId,
+                      spanId: context.spanId,
+                      parentSpanId: context.parentSpanId,
+                      name,
+                      kind: 1,
+                      startTimeUnixNano,
+                      endTimeUnixNano: nowUnixNano(),
+                      attributes: sanitizeAttributes(options.attributes),
+                      ...status ? {
+                        status: {
+                          code: status.code ?? 1,
+                          ...status.message ? { message: status.message } : {}
+                        }
+                      } : {}
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        });
+      }
+    };
+  }
+  async log(level, message, options = {}) {
+    if (!this.config.enabled || !this.config.logsEndpoint) {
+      return;
+    }
+    await this.postJson(this.config.logsEndpoint, {
+      resourceLogs: [
+        {
+          resource: {
+            attributes: [
+              {
+                key: "service.name",
+                value: { stringValue: this.config.serviceName }
+              },
+              {
+                key: "telemetry.sdk.language",
+                value: { stringValue: "webjs" }
+              }
+            ]
+          },
+          scopeLogs: [
+            {
+              scope: { name: SCOPE_NAME },
+              logRecords: [
+                {
+                  timeUnixNano: nowUnixNano(),
+                  observedTimeUnixNano: nowUnixNano(),
+                  severityText: level.toUpperCase(),
+                  severityNumber: severityNumber(level),
+                  body: { stringValue: message },
+                  attributes: sanitizeAttributes(options.attributes),
+                  ...options.context ? {
+                    traceId: options.context.traceId,
+                    spanId: options.context.spanId
+                  } : {}
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    });
+  }
+  async postJson(url, body) {
+    try {
+      const parsed = new URL(url);
+      if (this.configuredServerOrigin) {
+        const serverOrigin = new URL(this.configuredServerOrigin);
+        if (isLoopbackHost(parsed.hostname) && !isLoopbackHost(serverOrigin.hostname)) {
+          parsed.hostname = serverOrigin.hostname;
+        }
+      }
+      await fetch(parsed.toString(), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+    } catch {
+    }
+  }
+}
+const extensionTelemetryClient = new ExtensionTelemetryClient();
+
 class ExtensionHttpClient {
   serverUrl;
   connected = false;
@@ -6365,6 +6975,10 @@ const ContentItemSchema = object({
   data: string().optional(),
   mimeType: string().optional()
 });
+const TaskTelemetryContextSchema = object({
+  traceId: string().regex(/^[0-9a-f]{32}$/i).optional(),
+  parentSpanId: string().regex(/^[0-9a-f]{16}$/i).optional()
+});
 const TaskResultContentSchema = object({
   content: array(ContentItemSchema),
   isError: boolean().optional()
@@ -6376,7 +6990,8 @@ const TaskPushSchema = object({
     taskId: string(),
     tool: string(),
     arguments: record(string(), unknown()),
-    pageId: string().optional()
+    pageId: string().optional(),
+    telemetry: TaskTelemetryContextSchema.optional()
   })
 });
 const PageCreatedSchema = object({
@@ -6711,6 +7326,7 @@ class TaskPollerService {
     if (serverUrl) {
       this.serverUrl = serverUrl;
     }
+    await extensionTelemetryClient.configure(this.serverUrl);
     this.browserId = browserId ?? `browser-${Date.now()}`;
     this.useWebSocket = true;
     this.status = "registering";
@@ -6751,10 +7367,23 @@ class TaskPollerService {
     });
     try {
       await this.wsClient.connect();
+      void extensionTelemetryClient.log("info", "extension websocket connected", {
+        attributes: {
+          "browse_tool.browser.id": this.browserId,
+          "browse_tool.server.url": this.serverUrl
+        }
+      });
     } catch (error) {
       this.lastError = error instanceof Error ? error.message : String(error);
       this.status = "error";
       this.useWebSocket = false;
+      void extensionTelemetryClient.log("error", "extension websocket connect failed", {
+        attributes: {
+          "browse_tool.browser.id": this.browserId,
+          "browse_tool.server.url": this.serverUrl,
+          "error.message": this.lastError
+        }
+      });
     }
   }
   handleWebSocketTask(task) {
@@ -6767,7 +7396,15 @@ class TaskPollerService {
     const serverTask = {
       id: task.payload.taskId,
       tool: task.payload.tool,
-      arguments: task.payload.arguments
+      arguments: {
+        ...task.payload.arguments,
+        ...task.payload.telemetry ? {
+          __browseToolTelemetry: {
+            traceId: task.payload.telemetry.traceId,
+            parentSpanId: task.payload.telemetry.parentSpanId
+          }
+        } : {}
+      }
     };
     this.executeTaskWithWebSocket(serverTask).then(() => {
       this.taskCount++;
@@ -6780,30 +7417,7 @@ class TaskPollerService {
     });
   }
   async executeTaskWithWebSocket(task) {
-    let result;
-    try {
-      const { pageId, ...restArgs } = task.arguments;
-      result = await executeToolRequest(
-        {
-          id: task.id,
-          type: "request",
-          tool: task.tool,
-          arguments: restArgs,
-          pageId
-        },
-        this.toolContext
-      );
-    } catch (error) {
-      result = {
-        content: [
-          {
-            type: "text",
-            text: `Tool execution error: ${error instanceof Error ? error.message : String(error)}`
-          }
-        ],
-        isError: true
-      };
-    }
+    const result = await this.executeTaskCore(task);
     const resultContent = {
       content: result.content.map((c) => ({
         type: c.type,
@@ -6823,6 +7437,7 @@ class TaskPollerService {
       this.serverUrl = serverUrl;
       this.client.setServerUrl(serverUrl);
     }
+    await extensionTelemetryClient.configure(this.serverUrl);
     this.browserId = browserId ?? `browser-${Date.now()}`;
     this.useWebSocket = false;
     this.status = "registering";
@@ -6912,6 +7527,15 @@ class TaskPollerService {
       if (!task) {
         return;
       }
+      if (task.telemetry) {
+        task.arguments = {
+          ...task.arguments,
+          __browseToolTelemetry: {
+            traceId: task.telemetry.traceId,
+            parentSpanId: task.telemetry.parentSpanId
+          }
+        };
+      }
       this.isExecuting = true;
       this.status = "executing";
       await this.executeTask(task);
@@ -6926,47 +7550,92 @@ class TaskPollerService {
     }
   }
   async executeTask(task) {
+    const result = await this.executeTaskCore(task);
+    const taskResult = {
+      taskId: task.id,
+      success: !result.isError,
+      result: {
+        content: result.content.map((c) => ({
+          type: c.type,
+          text: "text" in c ? c.text : void 0,
+          data: "data" in c ? c.data : void 0,
+          mimeType: "mimeType" in c ? c.mimeType : void 0
+        })),
+        isError: result.isError
+      }
+    };
+    try {
+      await this.client.submitResult(taskResult);
+    } catch {
+    }
+  }
+  async executeTaskCore(task) {
+    const parentContext = extractTelemetryContext(task.arguments);
+    const taskSpan = extensionTelemetryClient.startSpan("browse_tool.extension.task.execute", parentContext, {
+      attributes: {
+        "browse_tool.task.id": task.id,
+        "browse_tool.tool.name": task.tool
+      }
+    });
+    void extensionTelemetryClient.log("info", "extension task execution started", {
+      context: taskSpan.context,
+      attributes: {
+        "browse_tool.task.id": task.id,
+        "browse_tool.tool.name": task.tool
+      }
+    });
     let result;
     try {
-      const { pageId, ...restArgs } = task.arguments;
+      const {
+        pageId,
+        __browseToolTelemetry: _unusedTelemetry,
+        ...restArgs
+      } = task.arguments;
+      void _unusedTelemetry;
       result = await executeToolRequest(
         {
           id: task.id,
           type: "request",
           tool: task.tool,
-          arguments: restArgs,
+          arguments: {
+            ...restArgs,
+            __browseToolTelemetry: {
+              traceId: taskSpan.context.traceId,
+              spanId: taskSpan.context.spanId
+            }
+          },
           pageId
         },
         this.toolContext
       );
     } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
       result = {
         content: [
           {
             type: "text",
-            text: `Tool execution error: ${error instanceof Error ? error.message : String(error)}`
+            text: `Tool execution error: ${message}`
           }
         ],
         isError: true
       };
     }
-    const taskResult = {
-      taskId: task.id,
-      success: !result.isError,
-      result: {
-        content: result.content.map((c) => ({
-          type: c.type,
-          text: "text" in c ? c.text : void 0,
-          data: "data" in c ? c.data : void 0,
-          mimeType: "mimeType" in c ? c.mimeType : void 0
-        })),
-        isError: result.isError
+    void extensionTelemetryClient.log(result.isError ? "error" : "info", "extension task execution completed", {
+      context: taskSpan.context,
+      attributes: {
+        "browse_tool.task.id": task.id,
+        "browse_tool.tool.name": task.tool,
+        "browse_tool.result.error": Boolean(result.isError),
+        ...result.isError ? { "error.message": extractResultError(result) ?? "Extension tool execution failed" } : {}
       }
-    };
-    try {
-      await this.client.submitResult(taskResult);
-    } catch {
-    }
+    });
+    await taskSpan.end(
+      result.isError ? {
+        code: 2,
+        message: extractResultError(result) ?? "Extension tool execution failed"
+      } : { code: 1 }
+    );
+    return result;
   }
   getState() {
     const connectionStatus = this.client.getConnectionStatus();
@@ -6995,6 +7664,29 @@ class TaskPollerService {
   }
 }
 const taskPollerService = new TaskPollerService();
+function extractTelemetryContext(args) {
+  const telemetry = args.__browseToolTelemetry;
+  if (!telemetry || typeof telemetry !== "object") {
+    return void 0;
+  }
+  const traceId = typeof telemetry.traceId === "string" ? telemetry.traceId : void 0;
+  const spanId = typeof telemetry.spanId === "string" ? telemetry.spanId : void 0;
+  const parentSpanId = typeof telemetry.parentSpanId === "string" ? telemetry.parentSpanId : void 0;
+  if (!traceId) {
+    return void 0;
+  }
+  return {
+    traceId,
+    spanId: spanId ?? parentSpanId ?? "0000000000000000"
+  };
+}
+function extractResultError(result) {
+  if (!result.isError) {
+    return void 0;
+  }
+  const firstContent = result.content[0];
+  return firstContent?.type === "text" ? firstContent.text : void 0;
+}
 
 const toolContext = {
   tabRegistry
@@ -7211,6 +7903,14 @@ chrome.alarms.onAlarm.addListener((alarm) => {
   }
 });
 chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+  if (message.type === "BROWSER_TELEMETRY_EVENT") {
+    void extensionTelemetryClient.log(message.level || "info", message.message || "browser telemetry event", {
+      attributes: typeof message.attributes === "object" && message.attributes !== null ? message.attributes : void 0,
+      context: typeof message.context === "object" && message.context !== null ? message.context : void 0
+    });
+    sendResponse({ success: true });
+    return true;
+  }
   if (message.type === "CONNECT_TO_SERVER") {
     const serverUrl = message.serverUrl || "http://localhost:3200";
     const browserId = message.browserId;