viyv-browser-mcp 0.2.0 → 0.3.0

package/dist/index.js

@@ -3,14 +3,8 @@
 // src/index.ts
 import { existsSync as existsSync3, readdirSync } from "fs";
 
-// src/server.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync, unlinkSync } from "fs";
-import http from "http";
-import { createServer } from "net";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+// src/native-host/bridge.ts
+import { createConnection } from "net";
 
 // ../shared/dist/constants.js
 var PROTOCOL_VERSION = "1.0.0";
@@ -45,7 +39,7 @@ var LIMITS = {
   /** A11y tree max elements */
   A11Y_MAX_ELEMENTS: 5e3,
   /** A11y tree default depth */
-  A11Y_DEFAULT_DEPTH: 8,
+  A11Y_DEFAULT_DEPTH: 15,
   /** A11y tree default max chars */
   A11Y_DEFAULT_MAX_CHARS: 5e4,
   /** Event buffer max entries */
@@ -78,6 +72,214 @@ var MCP_SERVER = {
   SOCKET_PATH_TEMPLATE: "/tmp/viyv-browser-{pid}.sock"
 };
 
+// src/native-host/compression.ts
+import { gunzipSync, gzipSync } from "zlib";
+var CHUNK_SIZE = 768 * 1024;
+function compressPayload(data) {
+  const original = Buffer.from(data, "utf-8");
+  const gzipped = gzipSync(original);
+  if (gzipped.length < original.length) {
+    return { compressed: gzipped.toString("base64"), wasCompressed: true };
+  }
+  return { compressed: data, wasCompressed: false };
+}
+function decompressPayload(data, isCompressed) {
+  if (!isCompressed) return data;
+  const buf = Buffer.from(data, "base64");
+  return gunzipSync(buf).toString("utf-8");
+}
+
+// src/native-host/transport.ts
+var MAX_MESSAGE_SIZE = 1024 * 1024;
+function encodeMessage(message) {
+  const json = JSON.stringify(message);
+  const body = Buffer.from(json, "utf-8");
+  if (body.length > MAX_MESSAGE_SIZE) {
+    throw new Error(`Message too large: ${body.length} bytes (max ${MAX_MESSAGE_SIZE})`);
+  }
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(body.length, 0);
+  return Buffer.concat([header, body]);
+}
+function createMessageReader(stream, onMessage, onError, onClose) {
+  let buffer = Buffer.alloc(0);
+  let expectedLength = null;
+  stream.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      if (expectedLength === null) {
+        if (buffer.length < 4) break;
+        expectedLength = buffer.readUInt32LE(0);
+        buffer = buffer.subarray(4);
+        if (expectedLength > MAX_MESSAGE_SIZE) {
+          onError?.(new Error(`Message too large: ${expectedLength} bytes`));
+          expectedLength = null;
+          buffer = Buffer.alloc(0);
+          break;
+        }
+      }
+      if (buffer.length < expectedLength) break;
+      const jsonBuffer = buffer.subarray(0, expectedLength);
+      buffer = buffer.subarray(expectedLength);
+      expectedLength = null;
+      try {
+        const message = JSON.parse(jsonBuffer.toString("utf-8"));
+        onMessage(message);
+      } catch (error) {
+        onError?.(new Error(`Invalid JSON: ${error.message}`));
+      }
+    }
+  });
+  stream.on("error", (error) => {
+    onError?.(new Error(`Stream error: ${error.message}`));
+  });
+  stream.on("end", () => {
+    onClose?.();
+  });
+  stream.on("close", () => {
+    onClose?.();
+  });
+}
+function writeMessage(stream, message) {
+  const encoded = encodeMessage(message);
+  stream.write(encoded);
+}
+
+// src/native-host/bridge.ts
+var MAX_BUFFER_SIZE = 1e3;
+function startBridge(options) {
+  const { socketPath, onError } = options;
+  let socket = null;
+  let reconnecting = false;
+  let retryCount = 0;
+  const pendingMessages = [];
+  function flushBuffer() {
+    if (!socket || socket.destroyed) return;
+    while (pendingMessages.length > 0) {
+      const msg = pendingMessages[0];
+      try {
+        const written = socket.write(`${JSON.stringify(msg)}
+`);
+        pendingMessages.shift();
+        if (!written) {
+          socket.once("drain", () => flushBuffer());
+          return;
+        }
+      } catch (error) {
+        onError?.(error);
+        return;
+      }
+    }
+  }
+  function connectSocket() {
+    socket = createConnection(socketPath);
+    socket.on("connect", () => {
+      process.stderr.write(`[viyv-browser:native-host] Connected to MCP server at ${socketPath}
+`);
+      retryCount = 0;
+      flushBuffer();
+    });
+    let lineBuffer = "";
+    socket.on("data", (data) => {
+      lineBuffer += data.toString("utf-8");
+      const lines = lineBuffer.split("\n");
+      lineBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line) continue;
+        try {
+          let message = JSON.parse(line);
+          if (message.type === "compressed" && typeof message.data === "string") {
+            const decompressed = decompressPayload(message.data, true);
+            message = JSON.parse(decompressed);
+          }
+          writeMessage(process.stdout, message);
+        } catch (error) {
+          onError?.(error);
+        }
+      }
+    });
+    socket.on("error", (error) => {
+      process.stderr.write(`[viyv-browser:native-host] Socket error: ${error.message}
+`);
+      onError?.(error);
+    });
+    socket.on("close", () => {
+      process.stderr.write("[viyv-browser:native-host] Socket closed\n");
+      socket = null;
+      if (!reconnecting) {
+        reconnecting = true;
+        const delay = Math.min(
+          RECONNECT.INITIAL_DELAY * RECONNECT.MULTIPLIER ** retryCount,
+          RECONNECT.MAX_DELAY
+        );
+        retryCount++;
+        process.stderr.write(
+          `[viyv-browser:native-host] Reconnecting in ${delay}ms (attempt ${retryCount})
+`
+        );
+        setTimeout(() => {
+          reconnecting = false;
+          connectSocket();
+        }, delay);
+      }
+    });
+  }
+  createMessageReader(
+    process.stdin,
+    (message) => {
+      if (socket && !socket.destroyed) {
+        const json = JSON.stringify(message);
+        if (json.length > LIMITS.CHUNK_SIZE) {
+          const { compressed, wasCompressed } = compressPayload(json);
+          if (wasCompressed) {
+            socket.write(`${JSON.stringify({ type: "compressed", data: compressed })}
+`);
+          } else {
+            socket.write(`${json}
+`);
+          }
+        } else {
+          socket.write(`${json}
+`);
+        }
+      } else {
+        if (pendingMessages.length < MAX_BUFFER_SIZE) {
+          pendingMessages.push(message);
+        } else {
+          process.stderr.write("[viyv-browser:native-host] Message buffer full, dropping message\n");
+        }
+      }
+    },
+    onError
+  );
+  connectSocket();
+  process.on("SIGINT", () => {
+    socket?.destroy();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    socket?.destroy();
+    process.exit(0);
+  });
+  process.stdin.on("end", () => {
+    process.stderr.write("[viyv-browser:native-host] stdin closed, shutting down\n");
+    socket?.destroy();
+    process.exit(0);
+  });
+}
+
+// src/server.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync, statSync, unlinkSync } from "fs";
+import http from "http";
+import { createServer } from "net";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { z as z2 } from "zod";
+
 // src/agent-session.ts
 import { randomUUID } from "crypto";
 var sessions = /* @__PURE__ */ new Map();
@@ -130,10 +332,8 @@ function cleanupStaleSessions() {
     }
   }
   if (cleaned > 0) {
-    process.stderr.write(
-      `[viyv-browser:mcp] Cleaned up ${cleaned} stale session(s)
-`
-    );
+    process.stderr.write(`[viyv-browser:mcp] Cleaned up ${cleaned} stale session(s)
+`);
   }
   return cleaned;
 }
@@ -201,26 +401,15 @@ function isExtensionConnected() {
   return true;
 }
 
-// src/native-host/compression.ts
-import { gzipSync, gunzipSync } from "zlib";
-var CHUNK_SIZE = 768 * 1024;
-function compressPayload(data) {
-  const original = Buffer.from(data, "utf-8");
-  const gzipped = gzipSync(original);
-  if (gzipped.length < original.length) {
-    return { compressed: gzipped.toString("base64"), wasCompressed: true };
-  }
-  return { compressed: data, wasCompressed: false };
-}
-function decompressPayload(data, isCompressed) {
-  if (!isCompressed) return data;
-  const buf = Buffer.from(data, "base64");
-  return gunzipSync(buf).toString("utf-8");
-}
-
 // src/tools/index.ts
 import { z } from "zod";
 
+// src/tools/advanced/file-upload.ts
+var FILE_UPLOAD_DESCRIPTION = `Upload local files to a file input element on the page using absolute file paths.
+Do not click on file input elements \u2014 clicking opens a native file picker dialog.
+Instead, use read_page or find to locate the file input, then use this tool with its ref.
+The paths must be absolute paths accessible from the machine running Chrome.`;
+
 // src/tools/advanced/gif-creator.ts
 var GIF_CREATOR_DESCRIPTION = `Record a GIF of browser activity.
 Captures a sequence of screenshots over a specified duration
@@ -261,10 +450,10 @@ allowing the user to approve, modify, or reject the plan before
 execution begins.`;
 
 // src/tools/advanced/upload-image.ts
-var UPLOAD_IMAGE_DESCRIPTION = `Upload an image to a file input element on the page.
-Accepts a local file path or base64-encoded image data and
-programmatically sets it on the target file input. Supports
-common image formats including PNG, JPEG, GIF, and WebP.`;
+var UPLOAD_IMAGE_DESCRIPTION = `Upload a previously captured screenshot or user-uploaded image to a file input or drag & drop target.
+Provide imageId from a prior screenshot action. Supports targeting by
+element ref (for file inputs) or coordinate (for drag & drop).
+Supports common image formats including PNG, JPEG, GIF, and WebP.`;
 
 // src/tools/core/click.ts
 var CLICK_DESCRIPTION = `Click at coordinates or on a referenced element.
@@ -305,13 +494,15 @@ is actively displayed on the page.`;
 // src/tools/core/hover.ts
 var HOVER_DESCRIPTION = `Move mouse to coordinates or element without clicking.
 
+Provide either coordinate [x, y] or ref (element reference from read_page/find).
 Useful for revealing tooltips, dropdown menus, or triggering hover states.`;
 
 // src/tools/core/javascript-exec.ts
 var JAVASCRIPT_EXEC_DESCRIPTION = `Execute arbitrary JavaScript code in the page context.
 The script runs in the main world of the active page and can access
 the DOM, window object, and any page-level APIs. Returns the
-serialized result of the last evaluated expression.`;
+serialized result of the last evaluated expression.
+Supports top-level await (e.g., "await fetch('/api').then(r => r.json())").`;
 
 // src/tools/core/key.ts
 var KEY_DESCRIPTION = `Press keyboard key(s).
@@ -320,62 +511,690 @@ Space-separated key names. Supports keyboard shortcuts.
 Examples: "Enter", "Tab", "Backspace", "ctrl+a", "cmd+c".
 Use repeat parameter for repeated presses (e.g., arrow keys).`;
 
-// src/tools/core/navigate.ts
-var NAVIGATE_DESCRIPTION = `Navigate to a URL, or go forward/back in browser history.
+// src/tools/core/navigate.ts
+var NAVIGATE_DESCRIPTION = `Navigate to a URL, or go forward/back in browser history.
+
+Use "back" to go back in history, "forward" to go forward.
+Provide a full URL (with protocol) to navigate to a new page.
+Waits for page load to complete before returning.`;
+
+// src/tools/core/read-page.ts
+var READ_PAGE_DESCRIPTION = `Get accessibility tree representation of page elements.
+
+Supports:
+- filter: "interactive" for buttons/links/inputs only, "all" for everything
+- depth: max tree depth (1-20, default 8)
+- refId: focus on a specific element subtree
+- maxChars: limit output size (default 50000)
+
+Returns elements with ref IDs that can be used with click, form_input, etc.`;
+
+// src/tools/core/screenshot.ts
+var SCREENSHOT_DESCRIPTION = `Take a screenshot of a tab.
+
+Returns image as an MCP ImageContent block, plus metadata (imageId) as text.
+Default format is JPEG with quality 80.
+
+IMPORTANT - Token-efficient alternatives (prefer these when possible):
+- read_page: Get accessibility tree with element text, values, and states
+- get_page_text: Extract all readable text from the page
+- find: Locate elements by natural language description
+Use screenshot only when visual verification is needed (layout, styling, images, charts).
+
+For example: to verify text was typed into an input, use read_page to check the
+input's value \u2014 don't take a screenshot. To confirm a page loaded, check the
+accessibility tree for expected headings or elements.
+
+Use ref to capture just a specific element (with padding) instead of the full page.
+This dramatically reduces image size. If both ref and region are provided, region
+takes precedence. The response includes an imageId for use with upload_image.`;
+
+// src/tools/core/scroll.ts
+var SCROLL_DESCRIPTION = `Scroll in a direction at given coordinates, or scroll an element into view by ref.
+
+Two modes:
+1. Directional scroll: provide coordinate + direction (+ optional amount 1-10, default 3).
+2. Scroll to element: provide ref (element reference ID from read_page/find). Scrolls the element into view using smooth scrolling.`;
+
+// src/tools/core/type.ts
+var TYPE_DESCRIPTION = `Type text into the currently focused element.
+
+Each character is typed individually with keyDown/keyUp events.
+For special keys (Enter, Tab, etc.), use the 'key' tool instead.`;
+
+// src/tools/core/wait-for.ts
+var WAIT_FOR_DESCRIPTION = `Wait for a specified condition before proceeding.
+Supports waiting for a CSS selector to appear in the DOM,
+for a navigation event to complete, or for a fixed timeout duration.
+Useful for synchronizing with asynchronous page updates.
+At least one of selector, navigation, or timeout must be specified.`;
+
+// src/tools/debug/read-console-messages.ts
+var READ_CONSOLE_MESSAGES_DESCRIPTION = `Read console messages captured from the page.
+Returns log, warning, error, and info messages that have been
+emitted by page scripts. Supports filtering by log level
+and limiting the number of returned entries.
+Use the pattern parameter to filter messages by regex, and
+the clear parameter to remove messages after reading.`;
+
+// src/tools/debug/read-network-requests.ts
+var READ_NETWORK_REQUESTS_DESCRIPTION = `Read network requests captured from the page.
+Returns details of HTTP requests and responses including URL, method,
+status code, headers, and timing information. Supports filtering
+by URL pattern or resource type.`;
+
+// src/tools/semantic/sm-add-action.ts
+var SM_ADD_ACTION_DESCRIPTION = `Define a semantic action (step sequence) for a registered page.
+
+Creates an executable action with typed parameters and ordered steps.
+Steps reference targets by target_id and support param_ref for dynamic values.
+
+Parameters:
+- page_id: the page this action belongs to
+- label: action name (e.g., "Login")
+- verb: action verb (e.g., "login", "submit", "search")
+- description (optional): LLM-facing description for discovery via sm_capabilities
+- params[]: parameter definitions [{name, type, required, secret, description, default_value}]
+- steps[]: ordered step sequence (minimum 1):
+  - type: 'click' | 'type' | 'select' | 'wait' | 'scroll' | 'key' | 'navigate'
+  - target_id: target to act on
+  - params: {text, value, keys, direction, amount, url, param_ref}
+  - pre_wait: {strategy, selector, timeout_ms}
+  - description: step description
+- retry_policy (optional): {max_retries:0-5, backoff, base_delay_ms, jitter}
+
+Returns:
+- action_id, step_count
+- validation: {valid, warnings[]} with target/param reference checks`;
+
+// src/tools/semantic/sm-add-fetch.ts
+var SM_ADD_FETCH_DESCRIPTION = `Define a data extraction rule (fetch) for a registered page.
+
+Creates a structured data extraction definition that maps DOM elements to typed output fields.
+Supports text, attribute, list, count, and existence extraction types.
+
+Parameters:
+- page_id: the page this fetch belongs to
+- label: fetch name (e.g., "Get Posts")
+- type_name: output type name (e.g., "posts", "profile")
+- description (optional): LLM-facing description for discovery via sm_capabilities
+- fields[]: extraction field definitions (minimum 1):
+  - name: output field name
+  - target_id: target element to extract from
+  - extraction_type: 'text' | 'attribute' | 'list' | 'count' | 'exists'
+  - attribute: attribute name (for 'attribute' type)
+  - item_selector: CSS selector for list items (for 'list' type)
+  - item_fields[]: structured extraction for each list item (for 'list' type):
+    - name: output field name
+    - selector: CSS selector relative to each list item (use ":scope" for item element itself)
+    - extraction_type: 'text' | 'attribute' | 'exists'
+    - attribute: attribute name (for 'attribute' type)
+- limits (optional): {max_chars:1000-200000, max_items:1-1000}
+
+Returns:
+- fetch_id, field_count
+- validation: {valid, warnings[]} with target reference checks`;
+
+// src/tools/semantic/sm-add-target.ts
+var SM_ADD_TARGET_DESCRIPTION = `Create or update semantic targets (element locators) for a registered page.
+
+Supports batch creation and re-binding of existing targets.
+Use ref from read_page/find to auto-generate locators, or provide locators explicitly.
+
+Parameters:
+- tabId: target tab where elements are present
+- page_id: the page these targets belong to
+- targets[]: array of target definitions:
+  - target_id (optional): specify to re-bind an existing target's locators
+  - label: target name (e.g., "Username Input")
+  - role: semantic role (e.g., "textbox", "button")
+  - ref (optional): element ref from read_page/find for auto-locator generation
+  - locators (optional): explicit locator array [{type, value, stability}]
+
+Each target must have either ref or locators.
+When target_id is provided, only locators are updated (label/role preserved).
+
+Returns per target:
+- target_id, label, locators, resolve_test (live element check), updated (true = re-bind)`;
+
+// src/tools/semantic/sm-capabilities.ts
+var SM_CAPABILITIES_DESCRIPTION = `Query semantic capabilities available for the current page.
+
+Returns the matched page definition, available actions, and fetches for the active tab.
+Uses page signature matching (URL pattern + DOM markers) to identify the current page state.
+
+Returns:
+- ok: whether a page match was found
+- domain: hostname of the current tab
+- page_id / page_type / variant_id: matched page and variant
+- match_score: confidence score of the match
+- actions[]: available actions with their parameters
+- fetches[]: available data extractions with their parameters
+- other_pages[]: other registered pages on the same domain (for cross-page navigation)
+- hint: guidance message when no page matches
+
+Use this before sm_invoke or sm_fetch to discover what operations are available.
+If no page matches (ok: false), use sm_register_page to register the current page,
+then sm_add_target and sm_add_action/sm_add_fetch to configure automation.
+Use sm_status to review all existing configurations.`;
+
+// src/tools/semantic/sm-custom-view.ts
+var SM_CUSTOM_VIEW_CREATE_DESCRIPTION = `Create a custom HTML view that can be opened in a new tab.
+
+Use this to build dashboards, charts, or reports using HTML/CSS/JS. The HTML can reference external CDN libraries (e.g., Chart.js, D3) and access bound data via window.__VIYV_DATA__.
+
+Parameters:
+- label: view name (max 100 chars)
+- description: optional description (max 500 chars)
+- html: full HTML document (max 200KB)
+- data_bindings: optional array of data source references (max 10)
+  - binding_id: unique ID within this view (e.g., "b1")
+  - source_type: "job_report" | "report" | "job" | "scenario"
+  - source_id: entity ID (e.g., "JRP_xxxx")
+  - projection: optional {fields, max_entries} to limit injected data
+
+The HTML should reference data as window.__VIYV_DATA__[binding_id]. Data is injected when the user opens the view.
+
+Returns: {ok, view_id, html_size, binding_count}`;
+var SM_CUSTOM_VIEW_UPDATE_DESCRIPTION = `Update an existing custom view.
+
+Use this to refresh HTML after data structure changes (stale bindings) or to modify the view content.
+
+Parameters:
+- view_id: view to update
+- label: new label (optional)
+- description: new description (optional)
+- html: new HTML content (optional, max 200KB)
+- data_bindings: new bindings array (optional, replaces all bindings)
+
+Returns: {ok, view_id, html_size, binding_count}`;
+var SM_CUSTOM_VIEW_DELETE_DESCRIPTION = `Delete a custom view.
+
+Parameters:
+- view_id: view to delete
+
+Returns: {ok, view_id}`;
+var SM_CUSTOM_VIEW_LIST_DESCRIPTION = `List all custom views with binding health status.
+
+Use this to check which views exist and whether their data bindings are still valid. Each view includes binding_status for every binding:
+- "ok": source exists and structure matches
+- "stale": source exists but structure changed (stale_reason: "schema_changed", includes current vs saved fingerprint)
+- "missing": source has been deleted
+
+When bindings are stale, use sm_custom_view_get with include_data=true to fetch current data, then sm_custom_view_update to refresh the HTML.
+
+Returns: {ok, views[]: {view_id, label, description, html_size, binding_count, binding_status[], created_at, updated_at}}`;
+var SM_CUSTOM_VIEW_GET_DESCRIPTION = `Get a custom view with optional data injection.
+
+Parameters:
+- view_id: view to retrieve
+- include_data: if true, resolve all bindings and return actual data in injected_data (default: false)
+
+When include_data=true:
+- injected_data maps binding_id to resolved data from the source
+- Data is filtered by projection (fields, max_entries) if specified
+- Secret parameter values are masked
+
+binding_status shows current health of each binding (ok/stale/missing).
+
+Returns: {ok, view, binding_status[], injected_data?}`;
+
+// src/tools/semantic/sm-delete.ts
+var SM_DELETE_DESCRIPTION = `Delete a semantic entity (page, target, action, or fetch).
+
+Supports dry_run mode to preview deletion impact before committing.
+Page deletion cascades to all dependent targets, actions, and fetches.
+Target deletion warns about referencing actions and fetches.
+
+Parameters:
+- entity_type: 'page' | 'target' | 'action' | 'fetch'
+- entity_id: the entity ID to delete
+- dry_run (optional): if true, return impact preview without deleting
+
+Returns:
+- entity_type, entity_id, label
+- dry_run: whether this was a preview
+- cascaded: (page deletion) lists of deleted targets, actions, fetches
+- warnings: (target deletion) referencing actions/fetches that may break`;
+
+// src/tools/semantic/sm-export.ts
+var SM_EXPORT_DESCRIPTION = `Export semantic configuration as JSON.
+
+Exports pages, targets, actions, and fetches. Optionally filter by domain.
+Secret parameter default values are stripped from the export.
+Includes a SHA-256 checksum for integrity verification on import.
+
+Parameters:
+- domain (optional): export only pages matching this domain (subdomain-aware). If omitted, exports all.
+
+Returns:
+- SemanticExport JSON with schema_version, checksum, pages[], targets[], actions[], fetches[]`;
+
+// src/tools/semantic/sm-fetch.ts
+var SM_FETCH_DESCRIPTION = `Extract structured data from the current page using predefined extraction rules.
+
+Resolves target elements and extracts text, attributes, lists, counts, or existence checks.
+Applies output limits (max_chars, max_items) to prevent oversized responses.
+
+Parameters:
+- tabId: target tab
+- fetch_id: the fetch definition to execute (from sm_capabilities)
+- params: optional parameters for the fetch
+
+Returns:
+- ok: whether extraction succeeded
+- data: extracted key-value data matching the fetch's return_schema
+- page_id_before / page_id_after: page state tracking
+- needs_rebind: true if any targets could not be resolved
+- missing_targets[]: list of target IDs that failed to resolve
+- hint: recovery guidance when errors occur
+
+When needs_rebind is true, use sm_test_target to diagnose each failing target,
+then sm_add_target with target_id to re-bind locators.
+When fetch_id is not found, use sm_capabilities to discover available fetches.`;
+
+// src/tools/semantic/sm-import.ts
+var SM_IMPORT_DESCRIPTION = `Import semantic configuration from JSON.
+
+Imports pages, targets, actions, and fetches from a SemanticExport JSON object.
+Verifies checksum integrity before importing.
+
+Parameters:
+- data (required): SemanticExport JSON object (from sm_export)
+- strategy (optional): "merge" (default) adds new entities, skips existing IDs.
+  "replace-domain" deletes all existing pages matching the import's domains
+  (with cascade to targets/actions/fetches), then inserts all import entities.
+
+Returns:
+- ok: whether import succeeded
+- imported: number of entities imported
+- skipped: number of entities skipped (existing IDs in merge mode)
+- errors[]: any error messages`;
+
+// src/tools/semantic/sm-invoke.ts
+var SM_INVOKE_DESCRIPTION = `Execute a semantic action on the current page.
+
+Runs a predefined sequence of steps (click, type, select, wait, etc.) using
+stable element locators with automatic fallback. Handles navigation detection,
+retry with jitter, and template parameter substitution.
+
+Parameters:
+- tabId: target tab
+- action_id: the action to execute (from sm_capabilities)
+- params: key-value parameters for template substitution (e.g., { username: "..." })
+
+Returns:
+- ok: whether all steps completed successfully
+- completed_steps / total_steps: execution progress
+- page_id_before / page_id_after: page state tracking (navigation detection)
+- observations[]: human-readable log of what happened (secrets redacted)
+- needs_rebind: true if any targets could not be resolved
+- missing_targets[]: list of target IDs that failed to resolve
+- hint: recovery guidance when errors occur
+
+When needs_rebind is true, use sm_test_target to diagnose each failing target,
+then sm_add_target with target_id to re-bind locators.
+When action_id is not found, use sm_capabilities to discover available actions.`;
+
+// src/tools/semantic/sm-job-cancel.ts
+var SM_JOB_CANCEL_DESCRIPTION = `Cancel a running job and its currently executing scenario.
+
+Remaining unexecuted entries are marked as skipped.
+
+Parameters:
+- tabId: tab where the job is running
+
+Returns:
+- ok: success status
+- cancelled: true if a job was found and cancelled`;
+
+// src/tools/semantic/sm-job-create.ts
+var SM_JOB_CREATE_DESCRIPTION = `Create a reusable job that groups multiple scenarios for sequential batch execution.
+
+Each entry specifies a scenario_id and optional parameter overrides. When executed, scenarios
+run one after another on the same tab, each producing its own Report.
+
+Parameters:
+- label: job name (e.g., "Print Price Collection")
+- description: optional description
+- entries: ordered list of scenarios to execute
+  - scenario_id: existing scenario ID
+  - label: display label override (uses scenario label if omitted)
+  - params: parameter overrides for this scenario execution
+- on_error: 'stop' (default) halts on first failure, 'skip_and_continue' skips failed and continues
+
+Returns:
+- job_id: the created job ID (JOB_xxxx)
+- entry_count: number of entries`;
+
+// src/tools/semantic/sm-job-delete.ts
+var SM_JOB_DELETE_DESCRIPTION = `Delete a job definition.
+
+Running executions are not affected \u2014 only the job definition is removed.
+
+Parameters:
+- job_id: job to delete
+
+Returns:
+- ok: success status
+- job_id: deleted job ID`;
+
+// src/tools/semantic/sm-job-history.ts
+var SM_JOB_HISTORY_DESCRIPTION = `Get execution history for a job. Returns condensed snapshots that persist beyond report pruning.
+
+Use this to review past executions, track trends over time (e.g. price changes), or select snapshots for comparison.
+
+Parameters:
+- job_id: job to get history for
+- limit: max snapshots to return (default: 20, most recent first)
+
+Returns:
+- job_id, job_label
+- snapshots[]: list of {snapshot_id, status, started_at, completed_at, duration_ms, scenario_count}`;
+var SM_JOB_COMPARE_DESCRIPTION = `Compare two job executions to see data changes between them.
+
+Matches scenarios by scenario_id, data groups by result_key, and rows by loop_params. Computes per-cell diffs with numeric deltas.
+
+Parameters:
+- job_id: the job to compare
+- base_snapshot_id: older snapshot (optional, defaults to second-most-recent)
+- compare_snapshot_id: newer snapshot (optional, defaults to most-recent)
+- changed_only: if true, omit unchanged rows (default: false)
+
+Returns:
+- diffs[]: per-scenario, per-result_key diff with rows showing added/removed/modified/unchanged
+- summary: total counts of changes`;
+var SM_JOB_SNAPSHOT_GET_DESCRIPTION = `Get detailed data from a specific job snapshot.
+
+Use this to inspect the full captured data for a single execution, including all scenario results and data groups.
+
+Parameters:
+- snapshot_id: the snapshot to retrieve (SNP_xxxx)
+
+Returns:
+- snapshot: full JobSnapshot with scenario_snapshots and data_groups`;
+
+// src/tools/semantic/sm-job-list.ts
+var SM_JOB_LIST_DESCRIPTION = `List all defined jobs with entry counts and configuration.
+
+Returns:
+- jobs: array of job summaries
+  - job_id, label, description, entry_count, on_error, created_at`;
+
+// src/tools/semantic/sm-job-report-export.ts
+var SM_JOB_REPORT_EXPORT_DESCRIPTION = `Export all scenario results from a job execution as aggregated JSON or CSV.
+
+Combines data from all linked scenario reports into a single file.
+CSV includes a job_entry column to distinguish scenarios.
+
+Parameters:
+- job_report_id: job report ID (JRP_xxxx)
+- format: 'json' (default) or 'csv'
+
+Returns:
+- data: export content string
+- filename: suggested filename`;
+
+// src/tools/semantic/sm-job-report-get.ts
+var SM_JOB_REPORT_GET_DESCRIPTION = `Get job execution status and results.
+
+Shows overall progress and per-scenario report summaries.
+Use sm_report_get with individual report_ids for detailed scenario data.
+
+Parameters:
+- job_report_id: job report ID (JRP_xxxx)
+
+Returns:
+- job_report: full JobReport with entry statuses
+- scenario_summaries: per-scenario report summaries (entry_count, error_count)`;
+
+// src/tools/semantic/sm-job-run.ts
+var SM_JOB_RUN_DESCRIPTION = `Execute a job on a browser tab. Scenarios run sequentially.
+
+Returns job_report_id immediately by default. Poll with sm_job_report_get to check progress.
+Set wait_for_completion=true to block until all scenarios finish.
+
+Only one job or scenario can run per tab at a time.
+
+Parameters:
+- tabId: target tab for execution
+- job_id: the job to execute
+- params: optional per-scenario param overrides keyed by scenario_id
+- wait_for_completion: if true, wait for all scenarios to complete (default: false)
+
+Returns:
+- job_report_id: ID of the created job report (JRP_xxxx)
+- job_id: the executed job
+- status: 'running' (async) or 'completed'/'failed' (when wait_for_completion=true)`;
+
+// src/tools/semantic/sm-job-update.ts
+var SM_JOB_UPDATE_DESCRIPTION = `Update an existing job definition.
+
+Supports partial updates \u2014 only specified fields are changed.
+
+Parameters:
+- job_id: job to update
+- label: new name (optional)
+- description: new description (optional)
+- entries: new entry list (optional, replaces all entries)
+- on_error: new error handling strategy (optional)
+
+Returns:
+- job_id: updated job ID
+- entry_count: number of entries after update`;
+
+// src/tools/semantic/sm-register-page.ts
+var SM_REGISTER_PAGE_DESCRIPTION = `Register a page for semantic automation.
+
+Creates a page definition with URL pattern matching and DOM markers.
+Idempotent: if a registered page already matches the current tab, returns the existing page_id.
+When page_type is specified on an already-registered page, it updates the page_type.
+
+Pages are grouped by domain. Use page_type to distinguish different page types
+within the same domain (e.g., "profile", "compose", "search").
+
+Parameters:
+- tabId: target tab (used to auto-derive url_pattern and domains if omitted)
+- label: human-readable page name (e.g., "GitHub Login")
+- page_type: page type within the domain (e.g., "profile", "compose", "search")
+- url_pattern: URL regex (auto-derived from tab URL if omitted)
+- domains: domain scope array (auto-derived from tab hostname if omitted)
+- auth_state: 'logged_in' | 'logged_out' | 'any' (default: 'any')
+- must_exist: CSS selectors that must be present on the page
+- must_not_exist: CSS selectors that must not be present
+- title_regex: regex to match page title
+
+Returns:
+- page_id, page_type, variant_id, label
+- already_registered: true if an existing page matched
+- match_test: result of matching the current tab against the page definition`;
+
+// src/tools/semantic/sm-report-delete.ts
+var SM_REPORT_DELETE_DESCRIPTION = `Delete an execution report.
+
+Permanently removes a report and its data.
+
+Parameters:
+- report_id: the report to delete
+
+Returns:
+- ok: whether deletion succeeded
+- report_id: the deleted report ID`;
+
+// src/tools/semantic/sm-report-export.ts
+var SM_REPORT_EXPORT_DESCRIPTION = `Export a report as JSON or CSV.
+
+JSON format includes the complete report structure.
+CSV format flattens entries into rows with columns for loop parameters and data fields.
+CSV uses UTF-8 BOM for Excel compatibility with non-ASCII characters.
+
+Parameters:
+- report_id: the report to export
+- format: 'json' (default) or 'csv'
+
+Returns:
+- format: the export format used
+- data: the exported content as a string
+- filename: suggested filename for download`;
+
+// src/tools/semantic/sm-report-get.ts
+var SM_REPORT_GET_DESCRIPTION = `Get detailed execution report.
+
+Returns the full report including all data entries, observations, errors,
+and grouped data (entries organized by result_key).
+
+Use this to poll running scenarios for progress updates.
+
+Parameters:
+- report_id: the report to retrieve
+
+Returns:
+- report: full Report object with entries[], grouped_data, observations[], errors[]
+- report.status: 'running' | 'completed' | 'failed' | 'cancelled'
+- report.entries[]: collected data with loop_params and extracted data
+- report.grouped_data: entries grouped by result_key for easy access`;
+
+// src/tools/semantic/sm-report-list.ts
+var SM_REPORT_LIST_DESCRIPTION = `List execution reports.
+
+Returns summaries of scenario execution reports, sorted by most recent first.
+Optionally filter by scenario_id.
+
+Parameters:
+- scenario_id (optional): filter reports for a specific scenario
+
+Returns:
+- reports[]: array of report summaries with status, timing, and entry/error counts`;
+
+// src/tools/semantic/sm-scenario-create.ts
+var SM_SCENARIO_CREATE_DESCRIPTION = `Create a scenario for multi-page workflow automation.
+
+Scenarios define sequences of steps (navigate, action, fetch, loop, wait) that execute
+across multiple pages. Loop steps support cartesian product iteration over variables
+(static values, select options, or previous fetch results).
+
+Parameters:
+- label: scenario name (e.g., "Price Table Collection")
+- description: optional LLM-facing description
+- params: global parameter definitions (available as {{param_name}} templates)
+- steps: ordered step sequence
+- max_duration_ms: timeout (default: 300000ms = 5min)
+- on_error: 'stop' (default) or 'skip_and_continue'
+
+Step types:
+- navigate: { url, wait_for_load } - navigate to URL (supports {{templates}})
+- action: { action_id, params } - execute an existing semantic action
+- fetch: { fetch_id, result_key, params } - extract data, stored in report under result_key
+- loop: { variables, steps, delay_between_ms, max_iterations } - iterate combinations
+- wait: { strategy, selector, timeout_ms } - wait for condition
+
+Loop variables:
+- static: explicit value list
+- target_options: auto-extract all <option> values from a <select> target
+- previous_fetch: extract values from prior fetch results
+
+Inside loops, use {{loop.variable_name}} to reference loop variables.
+
+Returns:
+- scenario_id: the created scenario ID (SCN_xxxx)
+- step_count: total step count
+- validation: { valid, warnings[] } referential integrity check`;
+
+// src/tools/semantic/sm-scenario-delete.ts
+var SM_SCENARIO_DELETE_DESCRIPTION = `Delete a scenario by ID.
+
+Associated reports become orphaned but are not deleted.
+
+Parameters:
+- scenario_id: the scenario to delete
+
+Returns:
+- ok: whether deletion succeeded
+- scenario_id: the deleted scenario ID`;
+
+// src/tools/semantic/sm-scenario-list.ts
+var SM_SCENARIO_LIST_DESCRIPTION = `List all registered scenarios.
+
+Returns a summary of each scenario including ID, label, step count,
+parameter names, and creation timestamp.
+
+No parameters required.
+
+Returns:
+- scenarios[]: array of scenario summaries`;
+
+// src/tools/semantic/sm-scenario-run.ts
+var SM_SCENARIO_RUN_DESCRIPTION = `Execute a scenario on a tab.
+
+Starts scenario execution and returns immediately with a report_id.
+Use sm_report_get to poll for progress and final results.
+
+Only one scenario can run per tab at a time.
 
-Use "back" to go back in history, "forward" to go forward.
-Provide a full URL (with protocol) to navigate to a new page.
-Waits for page load to complete before returning.`;
+Parameters:
+- tabId: target tab for execution
+- scenario_id: the scenario to execute
+- params: parameter values for template substitution
+- wait_for_completion: if true, wait for scenario to finish (up to max_duration_ms)
 
-// src/tools/core/read-page.ts
-var READ_PAGE_DESCRIPTION = `Get accessibility tree representation of page elements.
+Returns:
+- report_id: ID of the created report (RPT_xxxx)
+- scenario_id: the executed scenario
+- status: 'running' (async) or 'completed'/'failed' (when wait_for_completion=true)
+- error: error message if startup failed`;
 
-Supports:
-- filter: "interactive" for buttons/links/inputs only, "all" for everything
-- depth: max tree depth (1-20, default 8)
-- refId: focus on a specific element subtree
-- maxChars: limit output size (default 50000)
+// src/tools/semantic/sm-scenario-update.ts
+var SM_SCENARIO_UPDATE_DESCRIPTION = `Update an existing scenario.
 
-Returns elements with ref IDs that can be used with click, form_input, etc.`;
+Supports partial updates - only provide fields you want to change.
 
-// src/tools/core/screenshot.ts
-var SCREENSHOT_DESCRIPTION = `Take a screenshot of a tab.
+Parameters:
+- scenario_id: the scenario to update
+- label: new name
+- description: new description
+- params: new parameter definitions
+- steps: new step sequence
+- max_duration_ms: new timeout
+- on_error: new error handling strategy
 
-Returns base64-encoded image data.
-Default format is JPEG with quality 80 (optimized for Native Messaging 1MB limit).
-Use PNG for lossless screenshots when needed.
-Optionally capture a specific region [x0, y0, x1, y1].`;
+Returns:
+- scenario_id, step_count, validation`;
 
-// src/tools/core/scroll.ts
-var SCROLL_DESCRIPTION = `Scroll in a direction at given coordinates, or scroll an element into view by ref.
+// src/tools/semantic/sm-status.ts
+var SM_STATUS_DESCRIPTION = `View all semantic configuration (pages, targets, actions, fetches).
 
-Two modes:
-1. Directional scroll: provide coordinate + direction (+ optional amount 1-10, default 3).
-2. Scroll to element: provide ref (element reference ID from read_page/find). Scrolls the element into view using smooth scrolling.`;
+Returns a summary and detailed listing of all registered entities.
+Optionally test-resolve all targets against the current tab.
 
-// src/tools/core/type.ts
-var TYPE_DESCRIPTION = `Type text into the currently focused element.
+Parameters:
+- tabId (optional): required when test_resolve is true
+- page_id (optional): filter results to a specific page
+- domain (optional): filter results to pages matching this domain
+- test_resolve (optional): if true, resolve all targets on the current tab
 
-Each character is typed individually with keyDown/keyUp events.
-For special keys (Enter, Tab, etc.), use the 'key' tool instead.`;
+Returns:
+- summary: {total_pages, total_targets, total_actions, total_fetches}
+- pages[]: page definitions with page_type, domains, url_patterns, and counts
+- targets[]: targets with locator info and optional resolve_result
+- actions[]: actions with step count and param names
+- fetches[]: fetches with field count
+- integrity[]: referential integrity warnings`;
 
-// src/tools/core/wait-for.ts
-var WAIT_FOR_DESCRIPTION = `Wait for a specified condition before proceeding.
-Supports waiting for a CSS selector to appear in the DOM,
-for a navigation event to complete, or for a fixed timeout duration.
-Useful for synchronizing with asynchronous page updates.`;
+// src/tools/semantic/sm-test-target.ts
+var SM_TEST_TARGET_DESCRIPTION = `Test a specific target's locators against the current page.
 
-// src/tools/debug/read-console-messages.ts
-var READ_CONSOLE_MESSAGES_DESCRIPTION = `Read console messages captured from the page.
-Returns log, warning, error, and info messages that have been
-emitted by page scripts. Supports filtering by log level
-and limiting the number of returned entries.`;
+Resolves each locator individually and reports which ones matched.
+Useful for diagnosing broken targets and deciding which locators to update.
 
-// src/tools/debug/read-network-requests.ts
-var READ_NETWORK_REQUESTS_DESCRIPTION = `Read network requests captured from the page.
-Returns details of HTTP requests and responses including URL, method,
-status code, headers, and timing information. Supports filtering
-by URL pattern or resource type.`;
+Parameters:
+- tabId: target tab to test against
+- target_id: the target to test
+
+Returns:
+- found: whether any locator resolved successfully
+- locator_results[]: per-locator results {type, value, stability, matched}
+- element: resolved element info {tag, text, rect} if found
+- test_status: updated test status saved to storage`;
 
 // src/tools/tabs/select-tab.ts
 var SELECT_TAB_DESCRIPTION = `Switch focus to a specific tab by its identifier.
@@ -415,7 +1234,7 @@ in each group.`;
 
 // src/tools/viyv/artifact-from-page.ts
 var ARTIFACT_FROM_PAGE_DESCRIPTION = `Save the current page as a persistent artifact.
-Captures the page content as HTML, PDF, or screenshot and stores it
+Captures the page content as HTML, text, or screenshot and stores it
 as a named artifact for later reference. Artifacts can be retrieved
 by other tools or returned to the user as output.`;
 
@@ -439,16 +1258,17 @@ diagnostic information useful for troubleshooting connectivity issues.`;
 
 // src/tools/viyv/page-data-extract.ts
 var PAGE_DATA_EXTRACT_DESCRIPTION = `Extract structured data from the current page.
-Parses the page content according to a provided schema or natural
-language description, returning well-formed JSON. Supports extracting
-tables, lists, key-value pairs, and other structured patterns.`;
+Parses the page content according to a provided schema object,
+returning well-formed JSON. Supports extracting tables, lists,
+key-value pairs, and other structured patterns.
+The schema defines CSS selectors for each field to extract.`;
 
 // src/tools/index.ts
 var navigateTool = {
   name: "navigate",
   description: NAVIGATE_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID to navigate"),
+    tabId: z.coerce.number().describe("Tab ID to navigate"),
     url: z.string().describe('URL to navigate to, or "back"/"forward" for history')
   })
 };
@@ -456,18 +1276,21 @@ var screenshotTool = {
   name: "screenshot",
   description: SCREENSHOT_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID to capture"),
+    tabId: z.coerce.number().describe("Tab ID to capture"),
     format: z.enum(["jpeg", "png"]).optional().describe("Image format (default: jpeg)"),
-    quality: z.number().min(1).max(100).optional().describe("JPEG quality (default: 80)"),
-    region: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional().describe("Capture region [x0, y0, x1, y1]")
+    quality: z.coerce.number().min(1).max(100).optional().describe("JPEG quality (default: 80)"),
+    region: z.tuple([z.coerce.number(), z.coerce.number(), z.coerce.number(), z.coerce.number()]).optional().describe("Capture region [x0, y0, x1, y1]"),
+    ref: z.string().optional().describe(
+      "Element reference ID from read_page or find. Captures only that element with padding. Ignored if region is also provided."
+    )
   })
 };
 var clickTool = {
   name: "click",
   description: CLICK_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
-    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Click position [x, y]"),
+    tabId: z.coerce.number().describe("Tab ID"),
+    coordinate: z.tuple([z.coerce.number(), z.coerce.number()]).optional().describe("Click position [x, y]"),
     ref: z.string().optional().describe("Element reference ID"),
     action: z.enum(["left_click", "right_click", "double_click", "triple_click"]).optional().describe("Click type (default: left_click)"),
     modifiers: z.string().optional().describe('Modifier keys (e.g., "ctrl+shift")')
@@ -477,7 +1300,7 @@ var typeTool = {
   name: "type",
   description: TYPE_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     text: z.string().describe("Text to type")
   })
 };
@@ -485,19 +1308,19 @@ var keyTool = {
   name: "key",
   description: KEY_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     keys: z.string().describe('Space-separated keys (e.g., "Enter", "ctrl+a")'),
-    repeat: z.number().min(1).max(100).optional().describe("Repeat count")
+    repeat: z.coerce.number().min(1).max(100).optional().describe("Repeat count")
   })
 };
 var scrollTool = {
   name: "scroll",
   description: SCROLL_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
-    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Scroll position [x, y] (required for directional scroll)"),
+    tabId: z.coerce.number().describe("Tab ID"),
+    coordinate: z.tuple([z.coerce.number(), z.coerce.number()]).optional().describe("Scroll position [x, y] (required for directional scroll)"),
     direction: z.enum(["up", "down", "left", "right"]).optional().describe("Scroll direction (required for directional scroll)"),
-    amount: z.number().min(1).max(10).optional().describe("Scroll amount (default: 3)"),
+    amount: z.coerce.number().min(1).max(10).optional().describe("Scroll amount (default: 3)"),
     ref: z.string().optional().describe("Element reference ID to scroll into view")
   })
 };
@@ -505,8 +1328,8 @@ var hoverTool = {
   name: "hover",
   description: HOVER_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
-    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Hover position [x, y]"),
+    tabId: z.coerce.number().describe("Tab ID"),
+    coordinate: z.tuple([z.coerce.number(), z.coerce.number()]).optional().describe("Hover position [x, y]"),
     ref: z.string().optional().describe("Element reference ID")
   })
 };
@@ -514,27 +1337,27 @@ var dragTool = {
   name: "drag",
   description: DRAG_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
-    startCoordinate: z.tuple([z.number(), z.number()]).describe("Start position [x, y]"),
-    endCoordinate: z.tuple([z.number(), z.number()]).describe("End position [x, y]")
+    tabId: z.coerce.number().describe("Tab ID"),
+    startCoordinate: z.tuple([z.coerce.number(), z.coerce.number()]).describe("Start position [x, y]"),
+    endCoordinate: z.tuple([z.coerce.number(), z.coerce.number()]).describe("End position [x, y]")
   })
 };
 var readPageTool = {
   name: "read_page",
   description: READ_PAGE_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     filter: z.enum(["interactive", "all"]).optional().describe('Filter: "interactive" for buttons/links/inputs, "all" for everything'),
-    depth: z.number().min(1).max(20).optional().describe("Max tree depth (default: 8)"),
+    depth: z.coerce.number().min(1).max(20).optional().describe("Max tree depth (default: 15)"),
     refId: z.string().optional().describe("Focus on a specific element by ref"),
-    maxChars: z.number().optional().describe("Max output characters (default: 50000)")
+    maxChars: z.coerce.number().optional().describe("Max output characters (default: 50000)")
   })
 };
 var findTool = {
   name: "find",
   description: FIND_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     query: z.string().describe("Natural language description of what to find")
   })
 };
@@ -542,16 +1365,16 @@ var formInputTool = {
   name: "form_input",
   description: FORM_INPUT_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     ref: z.string().describe("Element reference ID"),
-    value: z.union([z.string(), z.boolean(), z.number()]).describe("Value to set")
+    value: z.union([z.string(), z.boolean(), z.coerce.number()]).describe("Value to set")
   })
 };
 var javascriptExecTool = {
   name: "javascript_exec",
   description: JAVASCRIPT_EXEC_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     code: z.string().describe("JavaScript code to execute")
   })
 };
@@ -559,24 +1382,24 @@ var waitForTool = {
   name: "wait_for",
   description: WAIT_FOR_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     selector: z.string().optional().describe("CSS selector to wait for"),
     navigation: z.boolean().optional().describe("Wait for navigation to complete"),
-    timeout: z.number().optional().describe("Timeout in ms (default: 30000)")
+    timeout: z.coerce.number().optional().describe("Timeout in ms (default: 30000)")
   })
 };
 var getPageTextTool = {
   name: "get_page_text",
   description: GET_PAGE_TEXT_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID")
+    tabId: z.coerce.number().describe("Tab ID")
   })
 };
 var handleDialogTool = {
   name: "handle_dialog",
   description: HANDLE_DIALOG_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     action: z.enum(["accept", "dismiss"]).describe("Dialog action"),
     text: z.string().optional().describe("Text for prompt dialog")
   })
@@ -599,24 +1422,24 @@ var tabCloseTool = {
   name: "tab_close",
   description: TAB_CLOSE_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID to close")
+    tabId: z.coerce.number().describe("Tab ID to close")
   })
 };
 var selectTabTool = {
   name: "select_tab",
   description: SELECT_TAB_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID to focus")
+    tabId: z.coerce.number().describe("Tab ID to focus")
   })
 };
 var readConsoleMessagesTool = {
   name: "read_console_messages",
   description: READ_CONSOLE_MESSAGES_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     pattern: z.string().optional().describe("Regex pattern to filter messages"),
     onlyErrors: z.boolean().optional().describe("Only return errors"),
-    limit: z.number().optional().describe("Max messages to return (default: 100)"),
+    limit: z.coerce.number().optional().describe("Max messages to return (default: 100)"),
     clear: z.boolean().optional().describe("Clear messages after reading")
   })
 };
@@ -624,9 +1447,9 @@ var readNetworkRequestsTool = {
   name: "read_network_requests",
   description: READ_NETWORK_REQUESTS_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     urlPattern: z.string().optional().describe("URL pattern to filter requests"),
-    limit: z.number().optional().describe("Max requests to return (default: 100)"),
+    limit: z.coerce.number().optional().describe("Max requests to return (default: 100)"),
     clear: z.boolean().optional().describe("Clear requests after reading")
   })
 };
@@ -634,7 +1457,7 @@ var gifCreatorTool = {
   name: "gif_creator",
   description: GIF_CREATOR_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     action: z.enum(["start_recording", "stop_recording", "export", "clear"]).describe("GIF action"),
     filename: z.string().optional().describe("Filename for export"),
     options: z.object({
@@ -643,7 +1466,7 @@ var gifCreatorTool = {
       showActionLabels: z.boolean().optional(),
       showProgressBar: z.boolean().optional(),
       showWatermark: z.boolean().optional(),
-      quality: z.number().min(1).max(30).optional()
+      quality: z.coerce.number().min(1).max(30).optional()
     }).optional().describe("GIF rendering options"),
     download: z.boolean().optional().describe("Download the GIF")
   })
@@ -652,10 +1475,11 @@ var uploadImageTool = {
   name: "upload_image",
   description: UPLOAD_IMAGE_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     imageId: z.string().describe("Image ID from a previous screenshot"),
     ref: z.string().optional().describe("Element reference for file input"),
-    coordinate: z.tuple([z.number(), z.number()]).optional().describe("Coordinates for drag & drop")
+    coordinate: z.tuple([z.coerce.number(), z.coerce.number()]).optional().describe("Coordinates for drag & drop"),
+    filename: z.string().optional().describe('Filename for the uploaded file (default: "image.png")')
   })
 };
 var updatePlanTool = {
@@ -670,23 +1494,23 @@ var resizeWindowTool = {
   name: "resize_window",
   description: RESIZE_WINDOW_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
-    width: z.number().describe("Window width in pixels"),
-    height: z.number().describe("Window height in pixels")
+    tabId: z.coerce.number().describe("Tab ID"),
+    width: z.coerce.number().describe("Window width in pixels"),
+    height: z.coerce.number().describe("Window height in pixels")
   })
 };
 var shortcutsListTool = {
   name: "shortcuts_list",
   description: SHORTCUTS_LIST_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().optional().describe("Tab ID (used to identify the tab group context)")
+    tabId: z.coerce.number().optional().describe("Tab ID (used to identify the tab group context)")
   })
 };
 var shortcutsExecuteTool = {
   name: "shortcuts_execute",
   description: SHORTCUTS_EXECUTE_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID to execute the shortcut on"),
+    tabId: z.coerce.number().describe("Tab ID to execute the shortcut on"),
     command: z.string().optional().describe("Command name of the shortcut"),
     shortcutId: z.string().optional().describe("ID of the shortcut")
   })
@@ -696,6 +1520,15 @@ var switchBrowserTool = {
   description: SWITCH_BROWSER_DESCRIPTION,
   inputSchema: z.object({})
 };
+var fileUploadTool = {
+  name: "file_upload",
+  description: FILE_UPLOAD_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID"),
+    ref: z.string().describe("Element reference ID of the file input"),
+    paths: z.array(z.string()).min(1).describe("Absolute file paths to upload")
+  })
+};
 var agentTabAssignTool = {
   name: "agent_tab_assign",
   description: AGENT_TAB_ASSIGN_DESCRIPTION,
@@ -730,7 +1563,7 @@ var artifactFromPageTool = {
   name: "artifact_from_page",
   description: ARTIFACT_FROM_PAGE_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     type: z.string().describe("Artifact type (text, html, screenshot)"),
     title: z.string().optional().describe("Artifact title")
   })
@@ -739,7 +1572,7 @@ var pageDataExtractTool = {
   name: "page_data_extract",
   description: PAGE_DATA_EXTRACT_DESCRIPTION,
   inputSchema: z.object({
-    tabId: z.number().describe("Tab ID"),
+    tabId: z.coerce.number().describe("Tab ID"),
     schema: z.record(z.unknown()).describe("Data extraction schema"),
     selector: z.string().optional().describe("CSS selector to scope extraction")
   })
@@ -749,6 +1582,489 @@ var browserHealthTool = {
   description: BROWSER_HEALTH_DESCRIPTION,
   inputSchema: z.object({})
 };
+var smCapabilitiesTool = {
+  name: "sm_capabilities",
+  description: SM_CAPABILITIES_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID")
+  })
+};
+var smInvokeTool = {
+  name: "sm_invoke",
+  description: SM_INVOKE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID"),
+    action_id: z.string().describe("Action ID to execute"),
+    params: z.record(z.unknown()).optional().describe("Parameters for template substitution")
+  })
+};
+var smFetchTool = {
+  name: "sm_fetch",
+  description: SM_FETCH_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID"),
+    fetch_id: z.string().describe("Fetch definition ID to execute"),
+    params: z.record(z.unknown()).optional().describe("Optional parameters")
+  })
+};
+var smRegisterPageTool = {
+  name: "sm_register_page",
+  description: SM_REGISTER_PAGE_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Target tab"),
+    label: z.string().describe('Page name (e.g., "GitHub Login")'),
+    page_type: z.string().optional().describe(
+      'Page type within the domain (e.g., "profile", "compose", "search"). Used for grouping pages.'
+    ),
+    url_pattern: z.string().optional().describe("URL regex (auto-derived from tab URL if omitted)"),
+    domains: z.array(z.string()).optional().describe("Domain scope (auto-derived if omitted)"),
+    auth_state: z.enum(["logged_in", "logged_out", "any"]).optional().describe("Auth state (default: any)"),
+    must_exist: z.array(z.string()).optional().describe("Required CSS selectors"),
+    must_not_exist: z.array(z.string()).optional().describe("Forbidden CSS selectors"),
+    title_regex: z.string().optional().describe("Title regex")
+  })
+};
+var smAddTargetTool = {
+  name: "sm_add_target",
+  description: SM_ADD_TARGET_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Target tab where elements are present"),
+    page_id: z.string().describe("Page ID these targets belong to"),
+    targets: z.array(
+      z.object({
+        target_id: z.string().optional().describe("Existing target ID for re-bind"),
+        label: z.string().describe("Target name"),
+        role: z.string().describe('Semantic role (e.g., "textbox", "button")'),
+        ref: z.string().optional().describe("Element ref from read_page/find"),
+        locators: z.array(
+          z.object({
+            type: z.string().describe("Locator type"),
+            value: z.string().describe("Locator value"),
+            stability: z.enum(["high", "medium", "low"]).describe("Stability level")
+          })
+        ).optional().describe("Explicit locators")
+      })
+    ).min(1).describe("Target definitions")
+  })
+};
+var smAddActionTool = {
+  name: "sm_add_action",
+  description: SM_ADD_ACTION_DESCRIPTION,
+  inputSchema: z.object({
+    page_id: z.string().describe("Page ID"),
+    label: z.string().describe("Action name"),
+    verb: z.string().describe('Action verb (e.g., "login", "submit")'),
+    description: z.string().optional().describe("LLM-facing description"),
+    params: z.array(
+      z.object({
+        name: z.string(),
+        type: z.enum(["string", "number", "boolean"]).default("string"),
+        required: z.boolean().default(true),
+        secret: z.boolean().default(false),
+        description: z.string().optional(),
+        default_value: z.union([z.string(), z.coerce.number(), z.boolean()]).optional()
+      })
+    ).optional().describe("Parameter definitions"),
+    steps: z.array(
+      z.object({
+        type: z.enum(["click", "type", "select", "wait", "scroll", "key", "navigate", "file_upload"]).describe("Step type"),
+        target_id: z.string().optional().describe("Target to act on"),
+        params: z.object({
+          text: z.string().optional(),
+          value: z.string().optional(),
+          keys: z.string().optional(),
+          direction: z.enum(["up", "down", "left", "right"]).optional(),
+          amount: z.coerce.number().optional(),
+          url: z.string().optional(),
+          param_ref: z.string().optional(),
+          file_paths: z.array(z.string()).optional().describe("File paths for file_upload step")
+        }).optional().describe("Step parameters"),
+        pre_wait: z.object({
+          strategy: z.enum(["selector", "navigation", "time"]),
+          selector: z.string().optional(),
+          timeout_ms: z.coerce.number().default(5e3)
+        }).optional().describe("Pre-step wait rule"),
+        description: z.string().optional()
+      })
+    ).min(1).describe("Step sequence"),
+    retry_policy: z.object({
+      max_retries: z.coerce.number().min(0).max(5).optional(),
+      backoff: z.enum(["fixed", "exponential"]).optional(),
+      base_delay_ms: z.coerce.number().min(100).max(1e4).optional(),
+      jitter: z.boolean().optional()
+    }).optional().describe("Retry policy")
+  })
+};
+var smAddFetchTool = {
+  name: "sm_add_fetch",
+  description: SM_ADD_FETCH_DESCRIPTION,
+  inputSchema: z.object({
+    page_id: z.string().describe("Page ID"),
+    label: z.string().describe("Fetch name"),
+    type_name: z.string().describe('Output type name (e.g., "posts")'),
+    description: z.string().optional().describe("LLM-facing description for discovery via sm_capabilities"),
+    fields: z.array(
+      z.object({
+        name: z.string().describe("Output field name"),
+        target_id: z.string().describe("Target element"),
+        extraction_type: z.enum(["text", "attribute", "list", "count", "exists"]).describe("Extraction type"),
+        attribute: z.string().optional().describe("Attribute name (for attribute type)"),
+        item_selector: z.string().optional().describe("List item CSS selector"),
+        item_fields: z.array(
+          z.object({
+            name: z.string(),
+            selector: z.string().describe(
+              'CSS selector relative to each list item (use ":scope" for item itself)'
+            ),
+            extraction_type: z.enum(["text", "attribute", "exists"]),
+            attribute: z.string().optional()
+          })
+        ).optional().describe("Nested fields for structured list item extraction")
+      })
+    ).min(1).describe("Extraction fields"),
+    limits: z.object({
+      max_chars: z.coerce.number().min(1e3).max(2e5).optional(),
+      max_items: z.coerce.number().min(1).max(1e3).optional()
+    }).optional().describe("Output limits")
+  })
+};
+var smStatusTool = {
+  name: "sm_status",
+  description: SM_STATUS_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().optional().describe("Tab ID (required for test_resolve)"),
+    page_id: z.string().optional().describe("Filter by page ID"),
+    domain: z.string().optional().describe("Filter results to pages matching this domain"),
+    test_resolve: z.boolean().optional().describe("Test-resolve all targets")
+  })
+};
+var smTestTargetTool = {
+  name: "sm_test_target",
+  description: SM_TEST_TARGET_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID"),
+    target_id: z.string().describe("Target ID to test")
+  })
+};
+var smDeleteTool = {
+  name: "sm_delete",
+  description: SM_DELETE_DESCRIPTION,
+  inputSchema: z.object({
+    entity_type: z.enum(["page", "target", "action", "fetch"]).describe("Entity type"),
+    entity_id: z.string().describe("Entity ID to delete"),
+    dry_run: z.boolean().optional().describe("Preview impact without deleting")
+  })
+};
+var smExportTool = {
+  name: "sm_export",
+  description: SM_EXPORT_DESCRIPTION,
+  inputSchema: z.object({
+    domain: z.string().optional().describe("Export only pages matching this domain (subdomain-aware). Omit for all.")
+  })
+};
+var smImportTool = {
+  name: "sm_import",
+  description: SM_IMPORT_DESCRIPTION,
+  inputSchema: z.object({
+    data: z.object({
+      schema_version: z.string(),
+      checksum: z.string(),
+      exported_at: z.coerce.number().optional(),
+      source: z.record(z.unknown()).optional(),
+      pages: z.array(z.record(z.unknown())),
+      targets: z.array(z.record(z.unknown())).optional(),
+      actions: z.array(z.record(z.unknown())).optional(),
+      fetches: z.array(z.record(z.unknown())).optional()
+    }).passthrough().describe("SemanticExport JSON object from sm_export"),
+    strategy: z.enum(["merge", "replace-domain"]).optional().describe('"merge" (default) or "replace-domain"')
+  })
+};
+var scenarioStepSchema = z.lazy(
+  () => z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("navigate"),
+      label: z.string().optional(),
+      url: z.string(),
+      wait_for_load: z.boolean().optional()
+    }),
+    z.object({
+      type: z.literal("action"),
+      label: z.string().optional(),
+      action_id: z.string(),
+      params: z.record(z.string()).optional()
+    }),
+    z.object({
+      type: z.literal("fetch"),
+      label: z.string().optional(),
+      fetch_id: z.string(),
+      result_key: z.string(),
+      params: z.record(z.string()).optional()
+    }),
+    z.object({
+      type: z.literal("loop"),
+      label: z.string().optional(),
+      variables: z.array(
+        z.object({
+          name: z.string(),
+          source: z.enum(["static", "target_options", "previous_fetch"]),
+          values: z.array(z.string()).optional(),
+          target_id: z.string().optional(),
+          fetch_result_key: z.string().optional(),
+          field_name: z.string().optional()
+        })
+      ),
+      steps: z.array(scenarioStepSchema),
+      delay_between_ms: z.coerce.number().optional(),
+      max_iterations: z.coerce.number().min(1).max(500).optional()
+    }),
+    z.object({
+      type: z.literal("wait"),
+      label: z.string().optional(),
+      strategy: z.enum(["time", "selector", "navigation"]),
+      selector: z.string().optional(),
+      timeout_ms: z.coerce.number()
+    })
+  ])
+);
+var smScenarioCreateTool = {
+  name: "sm_scenario_create",
+  description: SM_SCENARIO_CREATE_DESCRIPTION,
+  inputSchema: z.object({
+    label: z.string().describe("Scenario name"),
+    description: z.string().optional().describe("LLM-facing description"),
+    params: z.array(
+      z.object({
+        name: z.string(),
+        type: z.enum(["string", "number", "boolean"]).default("string"),
+        required: z.boolean().default(true),
+        secret: z.boolean().default(false),
+        description: z.string().optional(),
+        default_value: z.union([z.string(), z.coerce.number(), z.boolean()]).optional()
+      })
+    ).optional().describe("Global parameter definitions"),
+    steps: z.array(scenarioStepSchema).min(1).describe("Step sequence"),
+    max_duration_ms: z.coerce.number().optional().describe("Timeout in ms (default: 300000)"),
+    on_error: z.enum(["stop", "skip_and_continue"]).optional().describe("Error handling (default: stop)")
+  })
+};
+var smScenarioUpdateTool = {
+  name: "sm_scenario_update",
+  description: SM_SCENARIO_UPDATE_DESCRIPTION,
+  inputSchema: z.object({
+    scenario_id: z.string().describe("Scenario ID to update"),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    params: z.array(
+      z.object({
+        name: z.string(),
+        type: z.enum(["string", "number", "boolean"]).default("string"),
+        required: z.boolean().default(true),
+        secret: z.boolean().default(false),
+        description: z.string().optional(),
+        default_value: z.union([z.string(), z.coerce.number(), z.boolean()]).optional()
+      })
+    ).optional(),
+    steps: z.array(scenarioStepSchema).optional(),
+    max_duration_ms: z.coerce.number().optional(),
+    on_error: z.enum(["stop", "skip_and_continue"]).optional()
+  })
+};
+var smScenarioDeleteTool = {
+  name: "sm_scenario_delete",
+  description: SM_SCENARIO_DELETE_DESCRIPTION,
+  inputSchema: z.object({
+    scenario_id: z.string().describe("Scenario ID to delete")
+  })
+};
+var smScenarioListTool = {
+  name: "sm_scenario_list",
+  description: SM_SCENARIO_LIST_DESCRIPTION,
+  inputSchema: z.object({})
+};
+var smScenarioRunTool = {
+  name: "sm_scenario_run",
+  description: SM_SCENARIO_RUN_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID for execution"),
+    scenario_id: z.string().describe("Scenario to execute"),
+    params: z.record(z.unknown()).optional().describe("Parameter values"),
+    wait_for_completion: z.boolean().optional().describe("Wait for completion (default: false, async)")
+  })
+};
+var smReportListTool = {
+  name: "sm_report_list",
+  description: SM_REPORT_LIST_DESCRIPTION,
+  inputSchema: z.object({
+    scenario_id: z.string().optional().describe("Filter by scenario ID")
+  })
+};
+var smReportGetTool = {
+  name: "sm_report_get",
+  description: SM_REPORT_GET_DESCRIPTION,
+  inputSchema: z.object({
+    report_id: z.string().describe("Report ID to retrieve")
+  })
+};
+var smReportDeleteTool = {
+  name: "sm_report_delete",
+  description: SM_REPORT_DELETE_DESCRIPTION,
+  inputSchema: z.object({
+    report_id: z.string().describe("Report ID to delete")
+  })
+};
+var smReportExportTool = {
+  name: "sm_report_export",
+  description: SM_REPORT_EXPORT_DESCRIPTION,
+  inputSchema: z.object({
+    report_id: z.string().describe("Report ID to export"),
+    format: z.enum(["json", "csv"]).optional().describe("Export format (default: json)")
+  })
+};
+var jobEntrySchema = z.object({
+  scenario_id: z.string().describe("Scenario ID to execute"),
+  label: z.string().optional().describe("Display label override"),
+  params: z.record(z.unknown()).optional().default({}).describe("Scenario parameter overrides")
+});
+var smJobCreateTool = {
+  name: "sm_job_create",
+  description: SM_JOB_CREATE_DESCRIPTION,
+  inputSchema: z.object({
+    label: z.string().min(1).describe("Job name"),
+    description: z.string().optional().describe("Job description"),
+    entries: z.array(jobEntrySchema).min(1).describe("Ordered list of scenarios to execute"),
+    on_error: z.enum(["stop", "skip_and_continue"]).optional().describe("How to handle scenario failures (default: stop)")
+  })
+};
+var smJobUpdateTool = {
+  name: "sm_job_update",
+  description: SM_JOB_UPDATE_DESCRIPTION,
+  inputSchema: z.object({
+    job_id: z.string().describe("Job ID to update"),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    entries: z.array(jobEntrySchema).min(1).optional(),
+    on_error: z.enum(["stop", "skip_and_continue"]).optional()
+  })
+};
+var smJobDeleteTool = {
+  name: "sm_job_delete",
+  description: SM_JOB_DELETE_DESCRIPTION,
+  inputSchema: z.object({
+    job_id: z.string().describe("Job ID to delete")
+  })
+};
+var smJobListTool = {
+  name: "sm_job_list",
+  description: SM_JOB_LIST_DESCRIPTION,
+  inputSchema: z.object({})
+};
+var smJobRunTool = {
+  name: "sm_job_run",
+  description: SM_JOB_RUN_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID to execute scenarios on"),
+    job_id: z.string().describe("Job ID to execute"),
+    params: z.record(z.record(z.unknown())).optional().describe("Per-scenario param overrides keyed by scenario_id"),
+    wait_for_completion: z.boolean().optional().describe("Wait for all scenarios to complete (default: false)")
+  })
+};
+var smJobCancelTool = {
+  name: "sm_job_cancel",
+  description: SM_JOB_CANCEL_DESCRIPTION,
+  inputSchema: z.object({
+    tabId: z.coerce.number().describe("Tab ID where the job is running")
+  })
+};
+var smJobReportGetTool = {
+  name: "sm_job_report_get",
+  description: SM_JOB_REPORT_GET_DESCRIPTION,
+  inputSchema: z.object({
+    job_report_id: z.string().describe("Job report ID to retrieve")
+  })
+};
+var smJobReportExportTool = {
+  name: "sm_job_report_export",
+  description: SM_JOB_REPORT_EXPORT_DESCRIPTION,
+  inputSchema: z.object({
+    job_report_id: z.string().describe("Job report ID to export"),
+    format: z.enum(["json", "csv"]).optional().describe("Export format (default: json)")
+  })
+};
+var smJobHistoryTool = {
+  name: "sm_job_history",
+  description: SM_JOB_HISTORY_DESCRIPTION,
+  inputSchema: z.object({
+    job_id: z.string().describe("Job ID to get history for"),
+    limit: z.coerce.number().min(1).max(100).optional().describe("Max snapshots (default: 20)")
+  })
+};
+var smJobCompareTool = {
+  name: "sm_job_compare",
+  description: SM_JOB_COMPARE_DESCRIPTION,
+  inputSchema: z.object({
+    job_id: z.string().describe("Job ID to compare"),
+    base_snapshot_id: z.string().optional().describe("Older snapshot ID (default: second-most-recent)"),
+    compare_snapshot_id: z.string().optional().describe("Newer snapshot ID (default: most-recent)"),
+    changed_only: z.boolean().optional().describe("Omit unchanged rows (default: false)")
+  })
+};
+var smJobSnapshotGetTool = {
+  name: "sm_job_snapshot_get",
+  description: SM_JOB_SNAPSHOT_GET_DESCRIPTION,
+  inputSchema: z.object({
+    snapshot_id: z.string().describe("Snapshot ID to retrieve (SNP_xxxx)")
+  })
+};
+var dataBindingSchema = z.object({
+  binding_id: z.string().min(1).max(20).describe('Unique binding ID within this view (e.g., "b1")'),
+  source_type: z.enum(["job_report", "report", "job", "scenario"]).describe("Data source type"),
+  source_id: z.string().describe('Source entity ID (e.g., "JRP_xxxx")'),
+  projection: z.object({
+    fields: z.array(z.string()).optional().describe("Field whitelist"),
+    max_entries: z.number().min(1).max(1e3).optional().describe("Max array entries")
+  }).optional().describe("Data projection to limit injected data")
+});
+var smCustomViewCreateTool = {
+  name: "sm_custom_view_create",
+  description: SM_CUSTOM_VIEW_CREATE_DESCRIPTION,
+  inputSchema: z.object({
+    label: z.string().min(1).max(100).describe("View name"),
+    description: z.string().max(500).optional().describe("View description"),
+    html: z.string().max(2e5).describe("HTML content (max 200KB)"),
+    data_bindings: z.array(dataBindingSchema).max(10).optional().describe("Data source bindings")
+  })
+};
+var smCustomViewUpdateTool = {
+  name: "sm_custom_view_update",
+  description: SM_CUSTOM_VIEW_UPDATE_DESCRIPTION,
+  inputSchema: z.object({
+    view_id: z.string().describe("View ID to update"),
+    label: z.string().min(1).max(100).optional().describe("New label"),
+    description: z.string().max(500).optional().describe("New description"),
+    html: z.string().max(2e5).optional().describe("New HTML content"),
+    data_bindings: z.array(dataBindingSchema).max(10).optional().describe("New data bindings (replaces all)")
+  })
+};
+var smCustomViewDeleteTool = {
+  name: "sm_custom_view_delete",
+  description: SM_CUSTOM_VIEW_DELETE_DESCRIPTION,
+  inputSchema: z.object({
+    view_id: z.string().describe("View ID to delete")
+  })
+};
+var smCustomViewListTool = {
+  name: "sm_custom_view_list",
+  description: SM_CUSTOM_VIEW_LIST_DESCRIPTION,
+  inputSchema: z.object({})
+};
+var smCustomViewGetTool = {
+  name: "sm_custom_view_get",
+  description: SM_CUSTOM_VIEW_GET_DESCRIPTION,
+  inputSchema: z.object({
+    view_id: z.string().describe("View ID to retrieve"),
+    include_data: z.boolean().optional().describe("Include resolved data in response (default: false)")
+  })
+};
 var allTools = [
   // Core (15)
   navigateTool,
@@ -774,9 +2090,10 @@ var allTools = [
   // Debug (2)
   readConsoleMessagesTool,
   readNetworkRequestsTool,
-  // Advanced (7)
+  // Advanced (8)
   gifCreatorTool,
   uploadImageTool,
+  fileUploadTool,
   updatePlanTool,
   resizeWindowTool,
   shortcutsListTool,
@@ -789,47 +2106,115 @@ var allTools = [
   browserEventUnsubscribeTool,
   artifactFromPageTool,
   pageDataExtractTool,
-  browserHealthTool
+  browserHealthTool,
+  // Semantic (12)
+  smCapabilitiesTool,
+  smInvokeTool,
+  smFetchTool,
+  smRegisterPageTool,
+  smAddTargetTool,
+  smAddActionTool,
+  smAddFetchTool,
+  smStatusTool,
+  smTestTargetTool,
+  smDeleteTool,
+  smExportTool,
+  smImportTool,
+  // Scenario & Report (9)
+  smScenarioCreateTool,
+  smScenarioUpdateTool,
+  smScenarioDeleteTool,
+  smScenarioListTool,
+  smScenarioRunTool,
+  smReportListTool,
+  smReportGetTool,
+  smReportDeleteTool,
+  smReportExportTool,
+  // Job (8)
+  smJobCreateTool,
+  smJobUpdateTool,
+  smJobDeleteTool,
+  smJobListTool,
+  smJobRunTool,
+  smJobCancelTool,
+  smJobReportGetTool,
+  smJobReportExportTool,
+  // Job History (3)
+  smJobHistoryTool,
+  smJobCompareTool,
+  smJobSnapshotGetTool,
+  // Custom View (5)
+  smCustomViewCreateTool,
+  smCustomViewUpdateTool,
+  smCustomViewDeleteTool,
+  smCustomViewListTool,
+  smCustomViewGetTool
 ];
 
 // src/server.ts
 var pendingRequests = /* @__PURE__ */ new Map();
 var extensionSocket = null;
+function coerceValue(v) {
+  if (typeof v !== "string") return v;
+  if (v.startsWith("[") && v.endsWith("]") || v.startsWith("{") && v.endsWith("}")) {
+    try {
+      return JSON.parse(v);
+    } catch {
+    }
+  }
+  if (v === "true") return true;
+  if (v === "false") return false;
+  return v;
+}
+function coerceShape(shape) {
+  const result = {};
+  for (const [key, schema] of Object.entries(shape)) {
+    result[key] = z2.preprocess(coerceValue, schema);
+  }
+  return result;
+}
 function createConfiguredMcpServer() {
   const server = new McpServer({
     name: MCP_SERVER.NAME,
     version: MCP_SERVER.VERSION
   });
   for (const tool of allTools) {
-    const shape = tool.inputSchema._def.shape?.() ?? {};
-    server.tool(tool.name, tool.description, shape, async (params) => {
-      const result = await callExtensionTool(tool.name, params);
-      if (tool.name === "browser_event_subscribe" && result.content[0]) {
-        try {
-          const parsed = JSON.parse(result.content[0].text);
-          if (parsed.subscriptionId) {
-            const p = params;
-            addSubscription({
-              id: parsed.subscriptionId,
-              agentId: getDefaultAgentId(),
-              eventTypes: p.eventTypes ?? [],
-              urlPattern: p.urlPattern,
-              createdAt: Date.now()
-            });
+    const def = tool.inputSchema._def;
+    const shape = def.shape?.() ?? {};
+    server.tool(
+      tool.name,
+      tool.description,
+      coerceShape(shape),
+      async (params) => {
+        const result = await callExtensionTool(tool.name, params);
+        const first = result.content[0];
+        if (tool.name === "browser_event_subscribe" && first?.type === "text") {
+          try {
+            const parsed = JSON.parse(first.text);
+            if (parsed.subscriptionId) {
+              const p = params;
+              addSubscription({
+                id: parsed.subscriptionId,
+                agentId: getDefaultAgentId(),
+                eventTypes: p.eventTypes ?? [],
+                urlPattern: p.urlPattern,
+                createdAt: Date.now()
+              });
+            }
+          } catch {
           }
-        } catch {
-        }
-      } else if (tool.name === "browser_event_unsubscribe" && result.content[0]) {
-        try {
-          const parsed = JSON.parse(result.content[0].text);
-          if (parsed.subscriptionId) {
-            removeSubscription(parsed.subscriptionId);
+        } else if (tool.name === "browser_event_unsubscribe" && first?.type === "text") {
+          try {
+            const parsed = JSON.parse(first.text);
+            if (parsed.subscriptionId) {
+              removeSubscription(parsed.subscriptionId);
+            }
+          } catch {
           }
-        } catch {
         }
+        return result;
       }
-      return result;
-    });
+    );
   }
   const listener = (event) => {
     server.sendLoggingMessage({
@@ -896,6 +2281,75 @@ async function startMcpServer(socketPath, agentName, options) {
     process.on("exit", () => {
       cleanupSocket(socketPath);
     });
+  } else if (options?.transport === "streamable-http") {
+    const sessions2 = /* @__PURE__ */ new Map();
+    const SESSION_TTL = 30 * 60 * 1e3;
+    const SWEEP_INTERVAL = 5 * 60 * 1e3;
+    const sweepTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, session] of sessions2) {
+        if (now - session.lastActivity > SESSION_TTL) {
+          process.stderr.write(`[viyv-browser:mcp] Streamable HTTP session TTL expired: ${id}
+`);
+          sessions2.delete(id);
+          session.server.close().catch(() => {
+          });
+        }
+      }
+    }, SWEEP_INTERVAL);
+    sweepTimer.unref();
+    const httpServer = http.createServer();
+    httpServer.on("request", (req, res) => {
+      handleStreamableHttpRequest(req, res, sessions2).catch((error) => {
+        process.stderr.write(
+          `[viyv-browser:mcp] Streamable HTTP request error: ${error.message}
+`
+        );
+        if (!res.headersSent) {
+          res.writeHead(500).end("Internal server error");
+        }
+      });
+    });
+    const listenPort = options.port ?? 0;
+    httpServer.listen(listenPort, "127.0.0.1", () => {
+      const addr = httpServer.address();
+      const port = typeof addr === "object" ? addr?.port : listenPort;
+      process.stdout.write(`${JSON.stringify({ port })}
+`);
+      process.stderr.write(
+        `[viyv-browser:mcp] Streamable HTTP server listening on 127.0.0.1:${port}
+`
+      );
+    });
+    process.stderr.write(
+      `[viyv-browser:mcp] MCP Server started (streamable-http), socket: ${socketPath}
+`
+    );
+    let shuttingDown = false;
+    const shutdown = async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      clearInterval(sweepTimer);
+      for (const { server: s } of sessions2.values()) {
+        await s.close().catch(() => {
+        });
+      }
+      httpServer.close(() => {
+      });
+      socketServer.close(() => {
+      });
+      cleanupSocket(socketPath);
+      process.exit(0);
+    };
+    process.on("SIGINT", () => {
+      shutdown();
+    });
+    process.on("SIGTERM", () => {
+      shutdown();
+    });
+    process.on("exit", () => {
+      cleanupSocket(socketPath);
+    });
   } else {
     const server = createConfiguredMcpServer();
     const transport = new StdioServerTransport();
@@ -915,28 +2369,168 @@ async function handleSseRequest(req, res, sessions2) {
     const transport = new SSEServerTransport("/message", res);
     const mcpServer = createConfiguredMcpServer();
     transport.onclose = () => {
-      sessions2.delete(transport.sessionId);
+      sessions2.delete(transport.sessionId);
+    };
+    res.on("close", () => {
+      if (sessions2.has(transport.sessionId)) {
+        sessions2.delete(transport.sessionId);
+        transport.close();
+      }
+    });
+    await mcpServer.connect(transport);
+    sessions2.set(transport.sessionId, { transport, server: mcpServer });
+  } else if (req.method === "POST" && req.url?.startsWith("/message")) {
+    const url = new URL(req.url, `http://${req.headers.host ?? "localhost"}`);
+    const sessionId = url.searchParams.get("sessionId");
+    const session = sessionId ? sessions2.get(sessionId) : null;
+    if (session) {
+      await session.transport.handlePostMessage(req, res);
+    } else {
+      res.writeHead(404).end("Session not found");
+    }
+  } else {
+    res.writeHead(404).end();
+  }
+}
+async function handleStreamableHttpRequest(req, res, sessions2) {
+  let url;
+  try {
+    url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  } catch {
+    res.writeHead(400).end("Bad request");
+    return;
+  }
+  if (url.pathname !== "/mcp") {
+    res.writeHead(404).end("Not found");
+    return;
+  }
+  const rawSessionId = req.headers["mcp-session-id"];
+  const sessionId = typeof rawSessionId === "string" ? rawSessionId : void 0;
+  const existingSession = sessionId ? sessions2.get(sessionId) : void 0;
+  if (existingSession) {
+    existingSession.lastActivity = Date.now();
+    if (req.method === "POST") {
+      let body;
+      try {
+        body = await parseJsonBody(req);
+      } catch (parseError) {
+        process.stderr.write(
+          `[viyv-browser:mcp] Streamable HTTP body parse failed: ${parseError.message}
+`
+        );
+        res.writeHead(400, { "Content-Type": "application/json" }).end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32700, message: "Parse error" },
+            id: null
+          })
+        );
+        return;
+      }
+      await existingSession.transport.handleRequest(req, res, body);
+    } else {
+      await existingSession.transport.handleRequest(req, res);
+    }
+    return;
+  }
+  if (!sessionId && req.method === "POST") {
+    let body;
+    try {
+      body = await parseJsonBody(req);
+    } catch (parseError) {
+      process.stderr.write(
+        `[viyv-browser:mcp] Streamable HTTP body parse failed: ${parseError.message}
+`
+      );
+      res.writeHead(400, { "Content-Type": "application/json" }).end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32700, message: "Parse error" },
+          id: null
+        })
+      );
+      return;
+    }
+    if (!isInitializeRequest(body)) {
+      const requestId = body && typeof body === "object" && "id" in body ? body.id : null;
+      res.writeHead(400, { "Content-Type": "application/json" }).end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32600, message: "First request must be an initialize request" },
+          id: requestId ?? null
+        })
+      );
+      return;
+    }
+    const mcpServer = createConfiguredMcpServer();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID2(),
+      onsessioninitialized: (id) => {
+        sessions2.set(id, { transport, server: mcpServer, lastActivity: Date.now() });
+      }
+    });
+    transport.onclose = () => {
+      const id = transport.sessionId;
+      if (id) sessions2.delete(id);
     };
-    res.on("close", () => {
-      if (sessions2.has(transport.sessionId)) {
-        sessions2.delete(transport.sessionId);
-        transport.close();
+    let connected = false;
+    try {
+      await mcpServer.connect(transport);
+      connected = true;
+      await transport.handleRequest(req, res, body);
+    } catch (error) {
+      const stage = connected ? "handleRequest" : "connect";
+      process.stderr.write(
+        `[viyv-browser:mcp] Streamable HTTP session ${stage} failed: ${error.message}
+`
+      );
+      try {
+        mcpServer.server.onclose?.();
+      } catch {
+      }
+      await mcpServer.close().catch(() => {
+      });
+      if (!res.headersSent) {
+        res.writeHead(500).end("Internal server error");
       }
-    });
-    await mcpServer.connect(transport);
-    sessions2.set(transport.sessionId, { transport, server: mcpServer });
-  } else if (req.method === "POST" && req.url?.startsWith("/message")) {
-    const url = new URL(req.url, `http://${req.headers.host ?? "localhost"}`);
-    const sessionId = url.searchParams.get("sessionId");
-    const session = sessionId ? sessions2.get(sessionId) : null;
-    if (session) {
-      await session.transport.handlePostMessage(req, res);
-    } else {
-      res.writeHead(404).end("Session not found");
     }
-  } else {
-    res.writeHead(404).end();
+    return;
+  }
+  if (sessionId && !existingSession) {
+    res.writeHead(404).end("Session not found");
+    return;
   }
+  res.writeHead(400).end("Bad request");
+}
+var MAX_BODY_SIZE = 4 * 1024 * 1024;
+function parseJsonBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let size = 0;
+    let destroyed = false;
+    req.on("data", (chunk) => {
+      if (destroyed) return;
+      size += chunk.length;
+      if (size > MAX_BODY_SIZE) {
+        destroyed = true;
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (destroyed) return;
+      try {
+        resolve2(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+      } catch (error) {
+        reject(new Error(`Invalid JSON: ${error.message}`));
+      }
+    });
+    req.on("error", (err) => {
+      if (!destroyed) reject(err);
+    });
+  });
 }
 function createSocketServer(socketPath) {
   cleanupSocket(socketPath);
@@ -1071,7 +2665,39 @@ async function callExtensionTool(tool, input) {
   if (tool === "switch_browser") {
     return handleSwitchBrowser();
   }
-  if (!extensionSocket || extensionSocket.destroyed || !isExtensionConnected()) {
+  if (tool === "file_upload") {
+    const paths = input.paths;
+    if (paths) {
+      for (const p of paths) {
+        try {
+          if (!existsSync(p) || !statSync(p).isFile()) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    error: { code: "FILE_NOT_FOUND", message: `File not found: ${p}` }
+                  })
+                }
+              ]
+            };
+          }
+        } catch {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: { code: "FILE_NOT_FOUND", message: `Cannot access file: ${p}` }
+                })
+              }
+            ]
+          };
+        }
+      }
+    }
+  }
+  if (!extensionSocket || extensionSocket.destroyed) {
     return {
       content: [
         {
@@ -1138,9 +2764,20 @@ async function callExtensionTool(tool, input) {
     pendingRequests.set(requestId, {
       resolve: (result) => {
         removeErrorListener();
-        resolve2({
-          content: [{ type: "text", text: JSON.stringify(result) }]
-        });
+        if (tool === "screenshot" && typeof result.data === "string") {
+          const { data, ...metadata } = result;
+          const mimeType = metadata.format === "png" ? "image/png" : "image/jpeg";
+          resolve2({
+            content: [
+              { type: "image", data, mimeType },
+              { type: "text", text: JSON.stringify(metadata) }
+            ]
+          });
+        } else {
+          resolve2({
+            content: [{ type: "text", text: JSON.stringify(result) }]
+          });
+        }
       },
       reject: (error) => {
         removeErrorListener();
@@ -1228,199 +2865,11 @@ function cleanupSocket(socketPath) {
   }
 }
 
-// src/native-host/bridge.ts
-import { createConnection } from "net";
-
-// src/native-host/transport.ts
-var MAX_MESSAGE_SIZE = 1024 * 1024;
-function encodeMessage(message) {
-  const json = JSON.stringify(message);
-  const body = Buffer.from(json, "utf-8");
-  if (body.length > MAX_MESSAGE_SIZE) {
-    throw new Error(`Message too large: ${body.length} bytes (max ${MAX_MESSAGE_SIZE})`);
-  }
-  const header = Buffer.alloc(4);
-  header.writeUInt32LE(body.length, 0);
-  return Buffer.concat([header, body]);
-}
-function createMessageReader(stream, onMessage, onError, onClose) {
-  let buffer = Buffer.alloc(0);
-  let expectedLength = null;
-  stream.on("data", (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
-    while (true) {
-      if (expectedLength === null) {
-        if (buffer.length < 4) break;
-        expectedLength = buffer.readUInt32LE(0);
-        buffer = buffer.subarray(4);
-        if (expectedLength > MAX_MESSAGE_SIZE) {
-          onError?.(new Error(`Message too large: ${expectedLength} bytes`));
-          expectedLength = null;
-          buffer = Buffer.alloc(0);
-          break;
-        }
-      }
-      if (buffer.length < expectedLength) break;
-      const jsonBuffer = buffer.subarray(0, expectedLength);
-      buffer = buffer.subarray(expectedLength);
-      expectedLength = null;
-      try {
-        const message = JSON.parse(jsonBuffer.toString("utf-8"));
-        onMessage(message);
-      } catch (error) {
-        onError?.(new Error(`Invalid JSON: ${error.message}`));
-      }
-    }
-  });
-  stream.on("error", (error) => {
-    onError?.(new Error(`Stream error: ${error.message}`));
-  });
-  stream.on("end", () => {
-    onClose?.();
-  });
-  stream.on("close", () => {
-    onClose?.();
-  });
-}
-function writeMessage(stream, message) {
-  const encoded = encodeMessage(message);
-  stream.write(encoded);
-}
-
-// src/native-host/bridge.ts
-var MAX_BUFFER_SIZE = 1e3;
-function startBridge(options) {
-  const { socketPath, onError } = options;
-  let socket = null;
-  let reconnecting = false;
-  let retryCount = 0;
-  const pendingMessages = [];
-  function flushBuffer() {
-    if (!socket || socket.destroyed) return;
-    while (pendingMessages.length > 0) {
-      const msg = pendingMessages[0];
-      try {
-        const written = socket.write(`${JSON.stringify(msg)}
-`);
-        pendingMessages.shift();
-        if (!written) {
-          socket.once("drain", () => flushBuffer());
-          return;
-        }
-      } catch (error) {
-        onError?.(error);
-        return;
-      }
-    }
-  }
-  function connectSocket() {
-    socket = createConnection(socketPath);
-    socket.on("connect", () => {
-      process.stderr.write(
-        `[viyv-browser:native-host] Connected to MCP server at ${socketPath}
-`
-      );
-      retryCount = 0;
-      flushBuffer();
-    });
-    let lineBuffer = "";
-    socket.on("data", (data) => {
-      lineBuffer += data.toString("utf-8");
-      const lines = lineBuffer.split("\n");
-      lineBuffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (!line) continue;
-        try {
-          let message = JSON.parse(line);
-          if (message.type === "compressed" && typeof message.data === "string") {
-            const decompressed = decompressPayload(message.data, true);
-            message = JSON.parse(decompressed);
-          }
-          writeMessage(process.stdout, message);
-        } catch (error) {
-          onError?.(error);
-        }
-      }
-    });
-    socket.on("error", (error) => {
-      process.stderr.write(
-        `[viyv-browser:native-host] Socket error: ${error.message}
-`
-      );
-      onError?.(error);
-    });
-    socket.on("close", () => {
-      process.stderr.write("[viyv-browser:native-host] Socket closed\n");
-      socket = null;
-      if (!reconnecting) {
-        reconnecting = true;
-        const delay = Math.min(
-          RECONNECT.INITIAL_DELAY * Math.pow(RECONNECT.MULTIPLIER, retryCount),
-          RECONNECT.MAX_DELAY
-        );
-        retryCount++;
-        process.stderr.write(
-          `[viyv-browser:native-host] Reconnecting in ${delay}ms (attempt ${retryCount})
-`
-        );
-        setTimeout(() => {
-          reconnecting = false;
-          connectSocket();
-        }, delay);
-      }
-    });
-  }
-  createMessageReader(
-    process.stdin,
-    (message) => {
-      if (socket && !socket.destroyed) {
-        const json = JSON.stringify(message);
-        if (json.length > LIMITS.CHUNK_SIZE) {
-          const { compressed, wasCompressed } = compressPayload(json);
-          if (wasCompressed) {
-            socket.write(`${JSON.stringify({ type: "compressed", data: compressed })}
-`);
-          } else {
-            socket.write(`${json}
-`);
-          }
-        } else {
-          socket.write(`${json}
-`);
-        }
-      } else {
-        if (pendingMessages.length < MAX_BUFFER_SIZE) {
-          pendingMessages.push(message);
-        } else {
-          process.stderr.write(
-            "[viyv-browser:native-host] Message buffer full, dropping message\n"
-          );
-        }
-      }
-    },
-    onError
-  );
-  connectSocket();
-  process.on("SIGINT", () => {
-    socket?.destroy();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    socket?.destroy();
-    process.exit(0);
-  });
-  process.stdin.on("end", () => {
-    process.stderr.write("[viyv-browser:native-host] stdin closed, shutting down\n");
-    socket?.destroy();
-    process.exit(0);
-  });
-}
-
 // src/setup.ts
-import { writeFileSync, mkdirSync, chmodSync, existsSync as existsSync2 } from "fs";
-import { resolve, dirname } from "path";
-import { homedir, platform } from "os";
 import { execSync } from "child_process";
+import { chmodSync, existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { dirname, resolve } from "path";
 function runSetup(options = {}) {
   const os = platform();
   const binaryPath = getBinaryPath();
@@ -1481,12 +2930,9 @@ function createNativeHostWrapper(os, binaryPath) {
     return wrapperPath2;
   }
   const wrapperPath = resolve(manifestDir, `${NATIVE_HOST_NAME}.sh`);
-  writeFileSync(
-    wrapperPath,
-    `#!/bin/bash
+  writeFileSync(wrapperPath, `#!/bin/bash
 exec "${nodePath}" "${binaryPath}" --native-host
-`
-  );
+`);
   chmodSync(wrapperPath, 493);
   return wrapperPath;
 }
@@ -1507,11 +2953,7 @@ function getManifestPath(os) {
         `${NATIVE_HOST_NAME}.json`
       );
     case "linux":
-      return resolve(
-        home,
-        ".config/google-chrome/NativeMessagingHosts",
-        `${NATIVE_HOST_NAME}.json`
-      );
+      return resolve(home, ".config/google-chrome/NativeMessagingHosts", `${NATIVE_HOST_NAME}.json`);
     case "win32":
       return resolve(
         home,
@@ -1535,10 +2977,8 @@ if (args.includes("setup")) {
     function poll() {
       const socketPath = findSocketPath();
       if (socketPath) {
-        process.stderr.write(
-          `[viyv-browser:native-host] Found socket at ${socketPath}
-`
-        );
+        process.stderr.write(`[viyv-browser:native-host] Found socket at ${socketPath}
+`);
         startBridge({
           socketPath,
           onError: (error) => {
@@ -1574,9 +3014,9 @@ if (args.includes("setup")) {
   const agentName = agentNameIdx >= 0 ? args[agentNameIdx + 1] : void 0;
   const transportIdx = args.indexOf("--transport");
   const transportMode = transportIdx >= 0 ? args[transportIdx + 1] : "stdio";
-  if (transportMode !== "stdio" && transportMode !== "sse") {
+  if (transportMode !== "stdio" && transportMode !== "sse" && transportMode !== "streamable-http") {
     process.stderr.write(
-      `[viyv-browser:mcp] Invalid transport: "${transportMode}". Must be "stdio" or "sse".
+      `[viyv-browser:mcp] Invalid transport: "${transportMode}". Must be "stdio", "sse", or "streamable-http".
 `
     );
     process.exit(1);