@modelcontextprotocol/inspector 2.0.0-rc.3 → 2.1.0

package/README.md

@@ -14,7 +14,7 @@ npx @modelcontextprotocol/inspector --cli    # CLI
 npx @modelcontextprotocol/inspector --tui    # TUI
 ```
 
-> **Repo status.** This is the **v2** line of the Inspector (branch `v2/main`). The `main` branch is the legacy v1 implementation (bug fixes only). v2 will eventually replace `main`. See [`AGENTS.md`](./AGENTS.md) for branch/board conventions.
+> **Repo status.** This is the **v2** line of the Inspector. Active development happens on **`v2/main`** (the develop branch — all v2 PRs target it), which is merged into **`main`** at milestone releases; `main` is the default branch and holds the latest released v2, published to the npm `latest` tag. The legacy **v1** line lives on **`v1/main`** — security fixes only, published straight from that branch to the npm `v1-latest` tag (`npx @modelcontextprotocol/inspector@v1-latest`). See [`AGENTS.md`](./AGENTS.md) for branch/board conventions.
 
 ## Project layout
 
@@ -29,6 +29,7 @@ inspector/
 │   └── launcher/     # Shared launcher — provides the `mcp-inspector` bin, dispatches to web/cli/tui
 ├── core/             # Shared code consumed via the `@inspector/core` alias (no package.json)
 │   ├── auth/         # OAuth: providers, discovery, storage, mid-session recovery (browser/node/remote backends)
+│   ├── client/       # Install-level client config (`client.json`): browser-safe parse/validate + Node load/save, remote backend, secrets
 │   ├── json/         # JSON + parameter/argument conversion utilities
 │   ├── logging/      # Silent pino logger singleton
 │   ├── mcp/          # InspectorClient runtime, state stores, transports, config import
@@ -37,6 +38,7 @@ inspector/
 │   └── storage/      # File I/O helpers for the OAuth persist backends
 ├── test-servers/     # Composable MCP test servers + fixtures used by integration tests
 ├── scripts/          # Root build/verify tooling (install cascade, smokes, verify-build-gate, verify-format-coverage, pack:verify)
+├── docs/             # Task-oriented guides (server configuration, MCP App review, launcher/config plan)
 ├── specification/    # Design/build specifications
 ├── AGENTS.md         # Contribution rules for agents AND humans (see below)
 └── README.md         # You are here
@@ -174,7 +176,7 @@ It also serves four `trigger_*` tools that the modern leg's spec-error injector
 
 Open the Network tab to see the mirrored `Mcp-*` headers highlighted, sentinel values decoded, and each error rendered distinctly.
 
-> **`Mcp-Param-*` mirroring is skipped by the SDK in the browser** (`detectProbeEnvironment() !== "browser"`). So calling `get_weather` from the **web** client omits `Mcp-Param-City` and the strict server answers `-32020`. The same tool is callable from the Node CLI/TUI, where mirroring is active.
+> **`Mcp-Param-*` mirroring is built by the Inspector, not the SDK.** The SDK only mirrors inside `client.callTool()`, and skips it in the browser (`detectProbeEnvironment() !== "browser"`). The Inspector routes `tools/call` through `client.request()` to drive MRTR manually, so it builds the mirrored headers itself ([#1846](https://github.com/modelcontextprotocol/inspector/issues/1846)) — on **every** client, web included, since the web client's upstream request is issued by the Node backend rather than the browser. So `get_weather` is callable from web, CLI, and TUI alike, in both the plain and "Run as task" forms.
 
 #### `x-mcp-header` in the Tools tab
 
@@ -250,17 +252,17 @@ Individual clients: `build:web`, `build:cli`, `build:tui`, `build:launcher`. The
 
 Each client self-validates from its own folder; the root scripts chain them. There is **no** aggregate root `test` script — use `validate` (fast) or `coverage` (the gate).
 
-| Script                              | What it does                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `npm run validate`                  | Runs `verify:format-coverage` (asserts every tracked source file is format-gated) first, then `validate:core` (the shared `core/` `format:check` + `lint` gate), then per client: `format:check` + `lint` + **`typecheck`** (cli/tui only) + `build` + fast unit tests. The quick inner-loop check.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `npm run coverage`                  | The **per-file ≥90% gate** (lines/statements/functions/branches) under v8 instrumentation, per client. CI-enforced. For web this also runs the integration project and covers the shared `core/` runtime (including `core/json` and `core/client`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `npm run smoke`                     | End-to-end smokes through the built launcher (`--help` dispatch + prod cli/tui/web), plus a headless-Chromium boot smoke that runs the prod web bundle and asserts a clean first render (no uncaught error — sync exception or unhandled rejection, how a Node built-in reaching the browser bundle manifests).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `npm run verify:build-gate`         | Runs a real `vite build` with a Node built-in forced into the browser graph and asserts the build **fails** via the #1769 gate (which turns Vite's browser-externalization warning into a hard error). Guards against the warning phrasing drifting in a Vite bump and silently disabling the gate. Part of `npm run ci`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `npm run verify:format-coverage`    | Parses the `format:check` globs out of every `package.json` (only those reachable from `validate`), enumerates all tracked source files, and **fails** listing any not covered by a glob — the durable guard for the "every first-party source file is format-gated" invariant (#1792). Runs first in `validate`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `npm run test:scripts`              | Table-driven unit tests (`node --test`) for the guard's own pure parsers (`scripts/lib/npm-scripts.mjs` + the exported helpers of `verify-typecheck-coverage.mjs`), one case per rule they encode. Runs in `validate` — and `verify:typecheck-coverage` guards _this_ gate in turn (reachable from `validate`, non-empty test set, every test file matched by the `test:scripts` glob), since `node --test` silently skips a file its glob misses and still exits 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `npm run verify:typecheck-coverage` | The typecheck-coverage analog of the above (#1791): for each Node client (auto-discovered from disk — enrolled via its `typecheck` script's projects, or for a `tsc -b` client like `clients/web` via its `tsconfig.json` `references`) it runs those projects with `tsc --listFilesOnly`, unions them, and **fails** listing any tracked `.ts`/`.tsx`/`.mts`/`.cts` under the client that lands in no project (so a new top-level config/helper can't silently go untypechecked). It also requires, deny-by-default, the first-party TS no client owns (`test-servers/src`, the root `vitest.shared.mts`, all of `core/`, and any new top-level location) to land in some client project's tsc pass — so a `core` `*.tsx` web's projects don't reach is caught too. Also asserts the gate is wired (each client's typecheck pass — its `typecheck` script, or web's `tsc -b` — is reachable from its `validate`, and the root chain runs each client's `validate`). Runs in `validate`. |
-| `npm run ci`                        | **Mandatory pre-push command.** `validate` → `coverage` → `verify:build-gate` → `smoke` → Storybook. A true superset of GitHub CI.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `npm run pack:verify`               | Publish smoke — see [Publishing](#publishing).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| Script                | What it does                                                                                                                                                                                                                                              |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `npm run validate`    | Runs `verify:format-coverage` (asserts every tracked source file is format-gated) first, then `validate:core` (the shared `core/` `format:check` + `lint` gate), then per client: `format:check` + `lint` + **`typecheck`** (cli/tui only) + `build` + fast unit tests. The quick inner-loop check.                                          |
+| `npm run coverage`    | The **per-file ≥90% gate** (lines/statements/functions/branches) under v8 instrumentation, per client. CI-enforced. For web this also runs the integration project and covers the shared `core/` runtime (including `core/json` and `core/client`).       |
+| `npm run smoke`       | End-to-end smokes through the built launcher (`--help` dispatch + prod cli/tui/web), plus a headless-Chromium boot smoke that runs the prod web bundle and asserts a clean first render (no uncaught error — sync exception or unhandled rejection, how a Node built-in reaching the browser bundle manifests).                               |
+| `npm run verify:build-gate` | Runs a real `vite build` with a Node built-in forced into the browser graph and asserts the build **fails** via the #1769 gate (which turns Vite's browser-externalization warning into a hard error). Guards against the warning phrasing drifting in a Vite bump and silently disabling the gate. Part of `npm run ci`.                        |
+| `npm run verify:format-coverage` | Parses the `format:check` globs out of every `package.json` (only those reachable from `validate`), enumerates all tracked source files, and **fails** listing any not covered by a glob — the durable guard for the "every first-party source file is format-gated" invariant (#1792). Runs first in `validate`.                        |
+| `npm run test:scripts` | Table-driven unit tests (`node --test`) for the guard's own pure parsers (`scripts/lib/npm-scripts.mjs` + the exported helpers of `verify-typecheck-coverage.mjs`), one case per rule they encode. Runs in `validate` — and `verify:typecheck-coverage` guards *this* gate in turn (reachable from `validate`, non-empty test set, every test file matched by the `test:scripts` glob), since `node --test` silently skips a file its glob misses and still exits 0. |
+| `npm run verify:typecheck-coverage` | The typecheck-coverage analog of the above (#1791): for each Node client (auto-discovered from disk — enrolled via its `typecheck` script's projects, or for a `tsc -b` client like `clients/web` via its `tsconfig.json` `references`) it runs those projects with `tsc --listFilesOnly`, unions them, and **fails** listing any tracked `.ts`/`.tsx`/`.mts`/`.cts` under the client that lands in no project (so a new top-level config/helper can't silently go untypechecked). It also requires, deny-by-default, the first-party TS no client owns (`test-servers/src`, the root `vitest.shared.mts`, all of `core/`, and any new top-level location) to land in some client project's tsc pass — so a `core` `*.tsx` web's projects don't reach is caught too. Also asserts the gate is wired (each client's typecheck pass — its `typecheck` script, or web's `tsc -b` — is reachable from its `validate`, and the root chain runs each client's `validate`). Runs in `validate`.                        |
+| `npm run ci`          | **Mandatory pre-push command.** `validate` → `coverage` → `verify:build-gate` → `smoke` → Storybook. A true superset of GitHub CI.                                                                                                                        |
+| `npm run pack:verify` | Publish smoke — see [Publishing](#publishing).                                                                                                                                                                                                          |
 
 Per-client scripts exist too (`validate:web`, `coverage:cli`, `smoke:tui`, …), plus root `validate:core` / `format:core` for the shared `core/` package, `format:scripts` for the root `scripts/` tooling, and `format:shared` / `lint:shared` for the root "shared" surface (`test-servers/src/**`, `vitest.shared.mts`, the root `eslint.config.js`). Run `npm run format` before committing — the root `format` fixes `core/`, the root `scripts/`, the shared surface, and every client; `validate` runs the non-fixing `format:check` and fails CI on any unformatted file.
 
@@ -286,9 +288,11 @@ The `smoke:*` scripts run against the in-repo build tree, which is **not** the p
 
 Publishing is automated by two release-gated jobs in [`.github/workflows/main.yml`](.github/workflows/main.yml) (`github.event_name == 'release'`, both `needs: build`):
 
-- **`publish`** — the npm package. Runs `npm run pack:verify` as the pre-publish gate, asserts the release tag matches the root `package.json` version, then `npm publish --access public --provenance` — a single `npm publish` (v2 is not an npm workspace, so there is no v1-style `publish-all`/`--workspaces`), with a signed provenance attestation via GitHub OIDC (`id-token: write`, `environment: release`). Authentication is npm **trusted publishing** — there is no `NPM_TOKEN` secret, and adding one would break the publish (an empty `NODE_AUTH_TOKEN` makes npm fail `ENEEDAUTH` before OIDC is attempted). The job upgrades the npm CLI to `>=11.5.1` first, since trusted publishing requires it and Node 22 bundles npm 10.x.
+- **`publish`** — the npm package. Runs `npm run pack:verify` as the pre-publish gate, asserts the release tag matches the root `package.json` version, then `npm publish --access public --provenance` — a single `npm publish` (v2 is not an npm workspace, so there is no v1-style `publish-all`/`--workspaces`), with a signed provenance attestation via GitHub OIDC (`id-token: write`, `environment: release`, `NPM_TOKEN`).
 - **`publish-github-container-registry`** — the container image (see [Docker](#docker)).
 
+A v2 release is cut from **`main`**, after the milestone's work has been merged there from `v2/main` — not from `v2/main` itself. (The v1 line releases independently from `v1/main` to the `v1-latest` tag and never touches `main`; see [Repo status](#mcp-inspector).)
+
 Because there is **one version number** (only the root `package.json` has one — the clients carry none, so there is nothing to keep in sync and no `check-version` step), the release flow is just:
 
 ```bash

package/clients/cli/build/index.js

@@ -536,9 +536,13 @@ function loadMcpServersConfig(configPath, writable) {
     return { ...config, mcpServers: normalizedServers };
   } catch (error) {
     if (error instanceof Error) {
-      throw new Error(`Error loading configuration: ${error.message}`);
+      throw new Error(`Error loading configuration: ${error.message}`, {
+        cause: error
+      });
     }
-    throw new Error("Error loading configuration: Unknown error");
+    throw new Error("Error loading configuration: Unknown error", {
+      cause: error
+    });
   }
 }
 function loadServerFromConfig(configPath, serverName, writable) {
@@ -1067,7 +1071,9 @@ function parseHttpUrl(value, label) {
     return new URL(trimmed);
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
-    throw new Error(`Invalid ${label}: "${trimmed}" (${detail})`);
+    throw new Error(`Invalid ${label}: "${trimmed}" (${detail})`, {
+      cause: err
+    });
   }
 }
 var parseOAuthCallbackParams = (location) => {
@@ -2100,6 +2106,7 @@ import { Client } from "@modelcontextprotocol/client";
 
 // ../../core/json/xMcpHeader.ts
 var X_MCP_HEADER_KEY = "x-mcp-header";
+var MCP_PARAM_HEADER_PREFIX = "Mcp-Param-";
 var RFC9110_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 var PERMITTED_X_MCP_HEADER_TYPES = /* @__PURE__ */ new Set([
   "string",
@@ -2189,6 +2196,66 @@ function scanXMcpHeaderDeclarations(inputSchema) {
   const fault = visit(inputSchema, [], true);
   return fault === void 0 ? { valid: true, declarations } : { valid: false, reason: fault };
 }
+var BASE64_SENTINEL_PREFIX = "=?base64?";
+var BASE64_SENTINEL_SUFFIX = "?=";
+function mcpParamPrimitiveToString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return void 0;
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      return void 0;
+    }
+    return String(value);
+  }
+  return void 0;
+}
+function needsBase64(s2) {
+  if (s2.length === 0) return true;
+  if (s2.startsWith(BASE64_SENTINEL_PREFIX) && s2.endsWith(BASE64_SENTINEL_SUFFIX)) {
+    return true;
+  }
+  if (s2 !== s2.trim()) return true;
+  for (let i2 = 0; i2 < s2.length; i2++) {
+    const c = s2.codePointAt(i2);
+    if (c === 9 || c >= 32 && c <= 126) continue;
+    return true;
+  }
+  return false;
+}
+function utf8ToBase64(s2) {
+  const bytes = new TextEncoder().encode(s2);
+  let bin = "";
+  for (const b2 of bytes) bin += String.fromCodePoint(b2);
+  return btoa(bin);
+}
+function encodeMcpParamValue(value) {
+  return needsBase64(value) ? `${BASE64_SENTINEL_PREFIX}${utf8ToBase64(value)}${BASE64_SENTINEL_SUFFIX}` : value;
+}
+function valueAtPath(root, path2) {
+  let node = root;
+  for (const key of path2) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[key];
+  }
+  return node;
+}
+function buildMcpParamHeaders(declarations, args) {
+  const out = {};
+  for (const decl of declarations) {
+    const raw = valueAtPath(args, decl.path);
+    if (raw === void 0 || raw === null) continue;
+    const stringValue = mcpParamPrimitiveToString(raw);
+    if (stringValue === void 0) continue;
+    out[`${MCP_PARAM_HEADER_PREFIX}${decl.headerName}`] = encodeMcpParamValue(stringValue);
+  }
+  return out;
+}
+function mcpParamHeadersForTool(tool, args) {
+  const scan = scanXMcpHeaderDeclarations(tool.inputSchema);
+  if (!scan.valid || scan.declarations.length === 0) return {};
+  return buildMcpParamHeaders(scan.declarations, args);
+}
 
 // ../../core/mcp/messageTrackingTransport.ts
 var MessageTrackingTransport = class {
@@ -3285,7 +3352,9 @@ function getAuthorizationServerUrl(serverUrl, resourceMetadata) {
     return new URL("/", serverUrl);
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
-    throw new Error(`Invalid MCP server URL: "${serverUrl}" (${detail})`);
+    throw new Error(`Invalid MCP server URL: "${serverUrl}" (${detail})`, {
+      cause: err
+    });
   }
 }
 
@@ -4948,7 +5017,10 @@ var RemoteClientTransport = class {
       message,
       ...options?.relatedRequestId != null && {
         relatedRequestId: options.relatedRequestId
-      }
+      },
+      // Forward per-send `Mcp-Param-*` headers (SEP-2243) for the backend to
+      // apply to the upstream send; the browser can't set them cross-origin.
+      ...options?.headers != null && { headers: options.headers }
     };
     const res = await this.fetchFn(`${this.baseUrl}/api/mcp/send`, {
       method: "POST",
@@ -7198,6 +7270,43 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       }
     }
   }
+  /**
+   * Coerce the string-valued entries of a tool's arguments to the types its
+   * `inputSchema` declares (the Tools form hands everything over as text).
+   * Shared by the two `tools/call` entry points — {@link attemptToolCall} and
+   * {@link callToolStream} — so both put the SAME arguments on the wire.
+   */
+  convertStringToolArgs(tool, args) {
+    const stringArgs = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (typeof value === "string") {
+        stringArgs[key] = value;
+      }
+    }
+    if (Object.keys(stringArgs).length === 0) return args;
+    return { ...args, ...convertToolParameters(tool, stringArgs) };
+  }
+  /**
+   * SEP-2243: mirror `x-mcp-header`-annotated arguments into `Mcp-Param-*`
+   * headers on a modern connection. The SDK only does this inside
+   * `client.callTool()` (and skips it in the browser), but we route
+   * `tools/call` through `client.request()` for manual MRTR driving (#1704), so
+   * we mirror ourselves. `Protocol.request` forwards `headers` (preserved
+   * across MRTR retry legs) to the transport, and the remote transport relays
+   * them to the backend's upstream send — issued server-side, where the browser
+   * skip doesn't apply. No-op on legacy/stdio (no annotations).
+   *
+   * Applied by BOTH `tools/call` entry points: a plain call
+   * ({@link attemptToolCall}) and a task-augmented one
+   * ({@link callToolStream}) — a strict modern server rejects either with
+   * `-32020` when the mirrored header is missing.
+   */
+  applyMirroredParamHeaders(tool, convertedArgs, requestOptions) {
+    if (this.protocolEra !== "modern") return;
+    const paramHeaders = mcpParamHeadersForTool(tool, convertedArgs);
+    if (Object.keys(paramHeaders).length === 0) return;
+    requestOptions.headers = { ...requestOptions.headers, ...paramHeaders };
+  }
   /**
    * Run a single tools/call attempt: convert args, issue the request, validate,
    * and return a successful {@link ToolCallInvocation}. Throws on any error
@@ -7217,17 +7326,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (!client) {
       throw new Error("Client is not connected");
     }
-    let convertedArgs = args;
-    const stringArgs = {};
-    for (const [key, value] of Object.entries(args)) {
-      if (typeof value === "string") {
-        stringArgs[key] = value;
-      }
-    }
-    if (Object.keys(stringArgs).length > 0) {
-      const convertedStringArgs = convertToolParameters(tool, stringArgs);
-      convertedArgs = { ...args, ...convertedStringArgs };
-    }
+    const convertedArgs = this.convertStringToolArgs(tool, args);
     const callMetadata = generalMetadata || toolSpecificMetadata ? { ...generalMetadata || {}, ...toolSpecificMetadata || {} } : void 0;
     const timestamp = /* @__PURE__ */ new Date();
     const metadata = this.mergeMeta(callMetadata);
@@ -7243,6 +7342,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       metadata?.progressToken,
       signal
     );
+    this.applyMirroredParamHeaders(tool, convertedArgs, requestOptions);
     const rawResult = await this.invokeMcpClient(
       () => this.requestWithInputRequired(
         "tools/call",
@@ -7646,17 +7746,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       throw new Error("Client is not connected");
     }
     try {
-      let convertedArgs = args;
-      const stringArgs = {};
-      for (const [key, value] of Object.entries(args)) {
-        if (typeof value === "string") {
-          stringArgs[key] = value;
-        }
-      }
-      if (Object.keys(stringArgs).length > 0) {
-        const convertedStringArgs = convertToolParameters(tool, stringArgs);
-        convertedArgs = { ...args, ...convertedStringArgs };
-      }
+      const convertedArgs = this.convertStringToolArgs(tool, args);
       const callMetadata = generalMetadata || toolSpecificMetadata ? { ...generalMetadata || {}, ...toolSpecificMetadata || {} } : void 0;
       const timestamp = /* @__PURE__ */ new Date();
       const metadata = this.mergeMeta(callMetadata);
@@ -7674,6 +7764,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       let taskId;
       let error;
       const requestOptions = this.getRequestOptions(metadata?.progressToken);
+      this.applyMirroredParamHeaders(tool, convertedArgs, requestOptions);
       if (this.progress) {
         const innerOnProgress = requestOptions.onprogress;
         requestOptions.onprogress = (progress) => {
@@ -7779,7 +7870,8 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
           );
         } catch (resultError) {
           throw new Error(
-            `Tool call did not return a result: ${resultError instanceof Error ? resultError.message : String(resultError)}`
+            `Tool call did not return a result: ${resultError instanceof Error ? resultError.message : String(resultError)}`,
+            { cause: resultError }
           );
         }
       }
@@ -7922,7 +8014,8 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       expandedUri = uriTemplate2.expand(params);
     } catch (error) {
       throw new Error(
-        `Failed to expand URI template "${uriTemplate}": ${error instanceof Error ? error.message : String(error)}`
+        `Failed to expand URI template "${uriTemplate}": ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
       );
     }
     const readInvocation = await this.readResource(expandedUri, metadata);
@@ -8120,7 +8213,8 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
         return { values: [] };
       }
       throw new Error(
-        `Failed to get completions: ${error instanceof Error ? error.message : String(error)}`
+        `Failed to get completions: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
       );
     }
   }
@@ -8522,7 +8616,8 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.dispatchSubscriptionsChange();
     } catch (error) {
       throw new Error(
-        `Failed to subscribe to resource: ${error instanceof Error ? error.message : String(error)}`
+        `Failed to subscribe to resource: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
       );
     }
   }
@@ -8566,7 +8661,8 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       }
     } catch (error) {
       throw new Error(
-        `Failed to unsubscribe from resource: ${error instanceof Error ? error.message : String(error)}`
+        `Failed to unsubscribe from resource: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
       );
     }
   }
@@ -11567,7 +11663,8 @@ async function runMethod(inspectorClient, args) {
         roots = parsed;
       } catch (e2) {
         throw new Error(
-          `--roots-json is invalid: ${e2 instanceof Error ? e2.message : String(e2)}`
+          `--roots-json is invalid: ${e2 instanceof Error ? e2.message : String(e2)}`,
+          { cause: e2 }
         );
       }
       await inspectorClient.setRoots(roots);
@@ -11846,7 +11943,7 @@ function parseRunnerOAuthCallbackUrl(cliCallbackUrl) {
     url = new URL(raw);
   } catch (err) {
     const reason = err?.message ?? String(err);
-    throw new Error(`Invalid OAuth callback URL: ${reason}`);
+    throw new Error(`Invalid OAuth callback URL: ${reason}`, { cause: err });
   }
   if (url.protocol !== "http:") {
     throw new Error("OAuth callback URL must use http scheme");
@@ -12810,7 +12907,7 @@ async function parseArgs(argv) {
   const scriptArgs = rawArgs.slice(2);
   const dashDashIndex = scriptArgs.indexOf("--");
   let targetArgs = [];
-  let optionArgs = [];
+  let optionArgs;
   if (dashDashIndex >= 0) {
     targetArgs = scriptArgs.slice(0, dashDashIndex);
     optionArgs = scriptArgs.slice(dashDashIndex + 1);
@@ -13120,7 +13217,8 @@ async function parseArgs(argv) {
       parsed = JSON.parse(options.toolArgsJson);
     } catch (e2) {
       throw new Error(
-        `--tool-args-json is not valid JSON: ${e2.message}`
+        `--tool-args-json is not valid JSON: ${e2 instanceof Error ? e2.message : String(e2)}`,
+        { cause: e2 }
       );
     }
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {