@visual-z/xeno 0.8.4 → 0.9.1

package/src/runtime/lsp-client.ts

@@ -1,201 +0,0 @@
-/** Explicit trusted servers, one lifecycle each; server edits never bypass checkpoint ownership. */
-import { extname } from "node:path";
-import { pathToFileURL } from "node:url";
-import { nextLspFrame, encodeLspFrame, diagnosticFreshness, MAX_LSP_FRAME, MAX_LSP_HEADER } from "../core/lsp-framing.ts";
-import { readLspDocument } from "../store/lsp-document.ts";
-import { presentObservation, type ToolDefinition, type ToolResult } from "./tools.ts";
-
-export interface LspConfig { name: string; command: string[]; extensions: string[]; languageId: string }
-export function parseLspConfig(value: unknown): LspConfig[] {
-  if (value === undefined) return [];
-  if (!Array.isArray(value) || value.length > 16) throw Error("lsp must be an array of at most 16 servers");
-  const names = new Set<string>();
-  return value.map(item => {
-    if (!item || typeof item !== "object" || Array.isArray(item)) throw Error("invalid LSP config");
-    const v = item as Record<string, unknown>;
-    if (Object.keys(v).some(key => !["name", "command", "extensions", "languageId"].includes(key)) || typeof v["name"] !== "string" || !/^[a-zA-Z0-9_-]{1,64}$/.test(v["name"]) || names.has(v["name"]) || typeof v["languageId"] !== "string" || !v["languageId"] || !Array.isArray(v["command"]) || !v["command"].length || v["command"].some(part => typeof part !== "string" || !part || part.includes("\0")) || !Array.isArray(v["extensions"]) || !v["extensions"].length || v["extensions"].some(part => typeof part !== "string" || !/^\.[a-zA-Z0-9]+$/.test(part))) throw Error("invalid or duplicate LSP config");
-    names.add(v["name"]); return { name: v["name"], languageId: v["languageId"], command: v["command"].map(String), extensions: v["extensions"].map(String) };
-  });
-}
-type Pending = { resolve(value: unknown): void; reject(error: Error): void; cancel(): void };
-// Operational limits, not segment thresholds: bound unsolicited traffic and retained server state.
-const MAX_LSP_STREAM_BYTES = 32 * 1024 * 1024;
-const MAX_LSP_DIAGNOSTIC_BYTES = 512 * 1024;
-const MAX_LSP_OPEN_DOCUMENTS = 32;
-class LspConnection {
-  private readonly root: string;
-  private readonly config: LspConfig;
-  private process: ReturnType<typeof Bun.spawn> | undefined;
-  private buffer = new Uint8Array(0);
-  private next = 1;
-  private readonly pending = new Map<number, Pending>();
-  private readonly documents = new Map<string, { sha256: string; version: number }>();
-  private readonly diagnostics = new Map<string, { version?: number; items: unknown[] }>();
-  private ready: Promise<void> | undefined;
-  private closed = false;
-  private failure: string | undefined;
-  private streamBytes = 0;
-  private documentVersion = 0;
-  get usable(): boolean { return !this.closed && this.failure === undefined; }
-  constructor(root: string, config: LspConfig) { this.root = root; this.config = config; }
-  private send(message: unknown): void {
-    if (this.failure) throw Error(this.failure);
-    const stdin = this.process?.stdin;
-    if (!stdin || typeof stdin === "number") throw Error("LSP server is unavailable");
-    stdin.write(encodeLspFrame(message)); stdin.flush();
-  }
-  private notify(method: string, params: unknown): void { this.send({ jsonrpc: "2.0", method, params }); }
-  private request(method: string, params: unknown, signal?: AbortSignal, timeoutMs = 10_000): Promise<unknown> {
-    if (signal?.aborted) return Promise.reject(Error("LSP request cancelled"));
-    const id = this.next++;
-    return new Promise((resolve, reject) => {
-      const stop = (reason: string) => { const pending = this.pending.get(id); if (!pending) return; this.pending.delete(id); pending.cancel(); try { this.notify("$/cancelRequest", { id }); } catch { /* process may be dead */ } reject(Error(reason)); };
-      const aborted = () => stop("LSP request cancelled");
-      const timer = setTimeout(() => stop("LSP request timed out"), timeoutMs);
-      this.pending.set(id, { resolve, reject, cancel: () => { clearTimeout(timer); signal?.removeEventListener("abort", aborted); } });
-      signal?.addEventListener("abort", aborted, { once: true });
-      try { this.streamBytes = 0; this.send({ jsonrpc: "2.0", id, method, params }); } catch (error) { this.pending.delete(id); clearTimeout(timer); signal?.removeEventListener("abort", aborted); reject(error); }
-    });
-  }
-  private fail(reason: string): void {
-    this.failure ??= reason;
-    for (const item of this.pending.values()) { item.cancel(); item.reject(Error(reason)); } this.pending.clear();
-  }
-  private receive(value: unknown): void {
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw Error("invalid LSP envelope");
-    const v = value as Record<string, unknown>;
-    if (v["jsonrpc"] !== "2.0") throw Error("invalid LSP version");
-    if (typeof v["method"] === "string") {
-      const params = v["params"] !== null && typeof v["params"] === "object" && !Array.isArray(v["params"]) ? v["params"] as Record<string, unknown> : undefined;
-      if (v["method"] === "textDocument/publishDiagnostics" && typeof params?.["uri"] === "string" && Array.isArray(params["diagnostics"])) {
-        const version = params["version"];
-        // A server may report a whole workspace; cache only documents opened by this client.
-        if (this.documents.has(params["uri"])) {
-          if (version !== undefined && (typeof version !== "number" || !Number.isInteger(version) || version < 0 || version > 2 ** 31 - 1)) throw Error("invalid LSP diagnostic version");
-          if (new TextEncoder().encode(JSON.stringify(params["diagnostics"])).length > MAX_LSP_DIAGNOSTIC_BYTES) throw Error("LSP diagnostics exceeded");
-          this.diagnostics.set(params["uri"], { ...(typeof version === "number" ? { version } : {}), items: params["diagnostics"] });
-        }
-      }
-      if (v["id"] !== undefined) {
-        if (typeof v["id"] !== "string" && (typeof v["id"] !== "number" || !Number.isSafeInteger(v["id"]))) throw Error("invalid LSP request id");
-        const method = v["method"];
-        if (method === "workspace/configuration") this.send({ jsonrpc: "2.0", id: v["id"], result: Array.isArray(params?.["items"]) ? params["items"].map(() => null) : [] });
-        else if (method === "workspace/workspaceFolders") this.send({ jsonrpc: "2.0", id: v["id"], result: [{ uri: pathToFileURL(this.root).href, name: this.config.name }] });
-        else if (method === "workspace/applyEdit") this.send({ jsonrpc: "2.0", id: v["id"], result: { applied: false, failureReason: "use the owned Patch tool; LSP cannot write files" } });
-        else this.send({ jsonrpc: "2.0", id: v["id"], error: { code: -32601, message: "client capability not supported" } });
-      }
-      return;
-    }
-    if (typeof v["id"] !== "number" || !Number.isSafeInteger(v["id"])) throw Error("invalid LSP response id");
-    const pending = this.pending.get(v["id"]); if (!pending) return;
-    if (Object.hasOwn(v, "result") === Object.hasOwn(v, "error")) throw Error("invalid LSP response result");
-    this.pending.delete(v["id"]); pending.cancel(); this.streamBytes = 0;
-    if (v["error"] !== undefined) pending.reject(Error(JSON.stringify(v["error"]).slice(0, 512))); else pending.resolve(v["result"]);
-  }
-  async start(signal?: AbortSignal): Promise<void> {
-    signal?.throwIfAborted();
-    if (this.closed) throw Error("LSP connection disposed");
-    if (this.failure) throw Error(this.failure);
-    if (this.ready) return this.ready;
-    this.ready = (async () => {
-      this.process = Bun.spawn(this.config.command, { cwd: this.root, stdin: "pipe", stdout: "pipe", stderr: "ignore" });
-      const process = this.process;
-      void (async () => {
-        try {
-          if (!process.stdout || typeof process.stdout === "number") throw Error("missing LSP stdout");
-          for await (const chunk of process.stdout) {
-            this.streamBytes += chunk.length;
-            if (this.streamBytes > MAX_LSP_STREAM_BYTES) throw Error("LSP stream budget exceeded");
-            // Drain complete frames before admitting more bytes; OS chunk boundaries are arbitrary.
-            for (let offset = 0; offset < chunk.length;) {
-              const capacity = MAX_LSP_FRAME + MAX_LSP_HEADER + 4 - this.buffer.length;
-              if (capacity <= 0) throw Error("LSP receive buffer exceeded");
-              const part = chunk.subarray(offset, offset + capacity); offset += part.length;
-              const merged = new Uint8Array(this.buffer.length + part.length); merged.set(this.buffer); merged.set(part, this.buffer.length); this.buffer = merged;
-              for (;;) { const frame = nextLspFrame(this.buffer); if (!frame) break; this.buffer = this.buffer.slice(frame.consumed); this.receive(JSON.parse(new TextDecoder("utf8", { fatal: true }).decode(frame.body))); }
-            }
-          }
-          this.fail("LSP server exited");
-        } catch { this.fail("LSP protocol failed"); process.kill("SIGKILL"); }
-      })();
-      const result = await this.request("initialize", { processId: globalThis.process.pid, rootUri: pathToFileURL(this.root).href,
-        capabilities: { general: { positionEncodings: ["utf-16"] }, workspace: { applyEdit: false }, textDocument: { synchronization: { dynamicRegistration: false }, diagnostic: {} } },
-        workspaceFolders: [{ uri: pathToFileURL(this.root).href, name: this.config.name }] }, signal);
-      if (!result || typeof result !== "object" || Array.isArray(result) || !("capabilities" in result) || !result.capabilities || typeof result.capabilities !== "object") throw Error("invalid LSP initialize result");
-      const encoding = (result.capabilities as Record<string, unknown>)["positionEncoding"];
-      if (encoding !== undefined && encoding !== "utf-16") throw Error("LSP server does not support UTF-16 positions");
-      signal?.throwIfAborted();
-      this.notify("initialized", {});
-    })();
-    try { await this.ready; } catch (error) { this.fail(error instanceof Error ? error.message : "LSP initialization failed"); this.process?.kill("SIGKILL"); throw error; }
-  }
-  async call(action: string, path: string, line: number, character: number, signal?: AbortSignal): Promise<unknown> {
-    const document = await readLspDocument(this.root, path, signal);
-    await this.start(signal); signal?.throwIfAborted();
-    const old = this.documents.get(document.uri);
-    const changed = old !== undefined && old.sha256 !== document.sha256;
-    // Monotonic versions also prevent late diagnostics from an evicted/reopened file matching it.
-    const version = !old || changed ? ++this.documentVersion : old.version;
-    if (!old && this.documents.size >= MAX_LSP_OPEN_DOCUMENTS) {
-      const oldest = this.documents.keys().next().value;
-      if (oldest !== undefined) { this.notify("textDocument/didClose", { textDocument: { uri: oldest } }); this.documents.delete(oldest); this.diagnostics.delete(oldest); }
-    }
-    if (!old) this.notify("textDocument/didOpen", { textDocument: { uri: document.uri, languageId: this.config.languageId, version, text: document.text } });
-    else if (changed) { this.diagnostics.delete(document.uri); this.notify("textDocument/didChange", { textDocument: { uri: document.uri, version }, contentChanges: [{ text: document.text }] }); }
-    const current = version;
-    this.documents.set(document.uri, { sha256: document.sha256, version: current });
-    if (action === "diagnostics") {
-      try {
-        const result = await this.request("textDocument/diagnostic", { textDocument: { uri: document.uri } }, signal);
-        const onDisk = await readLspDocument(this.root, path, signal);
-        return { sha256: document.sha256, version: current, kind: "pull", freshness: onDisk.sha256 === document.sha256 ? "current" : "stale", result };
-      }
-      catch (error) {
-        signal?.throwIfAborted(); if (this.failure) throw Error(this.failure);
-        const observed = this.diagnostics.get(document.uri), onDisk = await readLspDocument(this.root, path, signal);
-        const freshness = onDisk.sha256 !== document.sha256 ? "stale" : observed ? diagnosticFreshness(observed.version, current) : "unavailable";
-        return { sha256: document.sha256, version: current, kind: "push", freshness, observedVersion: observed?.version ?? null,
-          available: freshness === "current", versionConfirmed: freshness === "current", diagnostics: freshness === "current" ? observed?.items ?? [] : [],
-          unconfirmedCount: freshness === "current" ? 0 : observed?.items.length ?? 0, reason: error instanceof Error ? error.message : "pull diagnostics unavailable" };
-      }
-    }
-    const methods: Record<string, string> = { hover: "textDocument/hover", definition: "textDocument/definition", references: "textDocument/references" };
-    const method = methods[action]; if (!method) throw Error("unsupported LSP action");
-    const result = await this.request(method, { textDocument: { uri: document.uri }, position: { line, character }, ...(action === "references" ? { context: { includeDeclaration: true } } : {}) }, signal);
-    const onDisk = await readLspDocument(this.root, path, signal);
-    return { sha256: document.sha256, version: current, freshness: onDisk.sha256 === document.sha256 ? "current" : "stale", result };
-  }
-  async dispose(): Promise<void> {
-    if (this.closed) return; this.closed = true;
-    if (this.process) {
-      try { await this.request("shutdown", null, undefined, 500); this.notify("exit", null); } catch { /* bounded shutdown falls back to kill */ }
-      // This process is client-owned. A server ignoring shutdown cannot leave a resident leak.
-      this.process.kill("SIGKILL"); await this.process.exited;
-    }
-    this.fail("LSP disposed"); this.documents.clear(); this.diagnostics.clear();
-  }
-}
-export class LspManager {
-  private readonly root: string;
-  private readonly configs: LspConfig[];
-  private readonly connections = new Map<string, LspConnection>();
-  private closed = false;
-  constructor(root: string, configs: LspConfig[]) { this.root = root; this.configs = configs.map(config => ({ ...config, command: [...config.command], extensions: [...config.extensions] })); }
-  tool(): ToolDefinition {
-    return { name: "lsp", description: "Read language-server diagnostics, hover, definitions or references for a current workspace file. Positions use zero-based UTF-16 units. Servers come from trusted explicit configuration.",
-      access: "read", branch: "none", execution: "exclusive", input_schema: { type: "object", required: ["action", "path"],
-        properties: { action: { type: "string", enum: ["diagnostics", "hover", "definition", "references"] }, path: { type: "string" }, line: { type: "integer", minimum: 0 }, character: { type: "integer", minimum: 0 }, server: { type: "string" } } },
-      run: async (ctx, input): Promise<ToolResult> => {
-        if (this.closed) throw Error("LSP manager disposed");
-        const selected = this.configs.filter(config => config.extensions.includes(extname(String(input["path"]))) && (input["server"] === undefined || config.name === input["server"]));
-        if (selected.length !== 1) return { ok: false, content: "Select exactly one configured language server for this file." };
-        const config = selected[0]!; let connection = this.connections.get(config.name);
-        if (!connection) { connection = new LspConnection(this.root, config); this.connections.set(config.name, connection); }
-        try {
-          const result = await connection.call(String(input["action"]), String(input["path"]), Number(input["line"] ?? 0), Number(input["character"] ?? 0), ctx.signal);
-          return { ok: true, ...await presentObservation(ctx, JSON.stringify(result)) };
-        } catch (error) { if (!connection.usable) this.connections.delete(config.name); throw error; }
-      } };
-  }
-  async dispose(): Promise<void> { this.closed = true; await Promise.all([...this.connections.values()].map(connection => connection.dispose())); this.connections.clear(); }
-}

package/src/runtime/mcp-client.ts

@@ -1,264 +0,0 @@
-/** Standard MCP adapters reuse the existing integration owner; no business request is automatically replayed. */
-import { createHash } from "node:crypto";
-import { pathToFileURL } from "node:url";
-import { Client, StreamableHTTPClientTransport, UnauthorizedError, InsufficientScopeError, SdkError, SdkHttpError, SdkErrorCode, extractWWWAuthenticateParams,
-  type Tool, type Transport, type FetchLike, type ContentBlock, type JsonSchemaType } from "@modelcontextprotocol/client";
-import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/client/stdio";
-import { parseMcpServers, type McpServerConfig, type McpServers } from "../core/mcp-config.ts";
-import { isJsonValue, type JsonValue } from "../core/tool-contract.ts";
-import type { IntegrationFailureCode } from "../core/integration-health.ts";
-import { FileMcpCredentialsStore, type McpCredentialsStore } from "../store/mcp-credentials.ts";
-import type { ExtensionIntegration, IntegrationConnection, IntegrationFailure } from "./integrations.ts";
-import type { ExtensionToolResult } from "./extensions.ts";
-import { McpAuthRequired, McpOAuthProvider } from "./mcp-oauth.ts";
-import { MAX_WEB_RESPONSE_BYTES, type WebFetch } from "./web-http.ts";
-import { McpSchemaError, McpSchemas } from "./mcp-schema.ts";
-import { ToolFault } from "../core/tool-failure.ts";
-
-export interface McpServerStatus { name: string; transport: "stdio" | "http"; state: "ready" | "disabled" | IntegrationFailureCode; tools: number; diagnostic?: string }
-export interface McpManagerOptions { cwd: string; credentialsDirectory: string; credentialsStore?: McpCredentialsStore;
-  env?: Readonly<Record<string, string | undefined>>; fetch?: WebFetch }
-class McpFailure extends Error {
-  readonly code: IntegrationFailureCode;
-  constructor(code: IntegrationFailureCode) { super(`MCP ${code}`); this.name = "McpFailure"; this.code = code; }
-}
-function fault(error: unknown): IntegrationFailure {
-  const code = error instanceof McpFailure ? error.code : error instanceof McpAuthRequired || error instanceof UnauthorizedError || error instanceof InsufficientScopeError ? "auth_required"
-    : error instanceof SdkHttpError ? error.status === 401 || error.status === 403 ? "auth_required" : error.status === 429 ? "rate_limited" : error.status >= 500 ? "offline" : "protocol_error"
-    : error instanceof SdkError && error.code === SdkErrorCode.RequestTimeout ? "timeout" : "protocol_error";
-  return { kind: "integration_failure", code };
-}
-export function mcpToolName(server: string, name: string, kind = "tool"): string {
-  const digest = createHash("sha256").update(JSON.stringify([server, kind, name])).digest("hex").slice(0, 12);
-  return `mcp_${server.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 12)}_${name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 20)}_${digest}`;
-}
-function integrationName(name: string) { return `mcp_${name.slice(0, 48)}_${createHash("sha256").update(name).digest("hex").slice(0, 8)}`; }
-function immutable<T>(value: T): T {
-  if (value && typeof value === "object") { for (const entry of Object.values(value)) immutable(entry); Object.freeze(value); }
-  return value;
-}
-function contentResult(content: readonly ContentBlock[], details: unknown, isError = false): ExtensionToolResult {
-  const mapped: ExtensionToolResult["content"] = [];
-  for (const item of content) {
-    if (item.type === "text") mapped.push({ type: "text", text: item.text });
-    else if (item.type === "image") mapped.push({ type: "image", data: item.data, mimeType: item.mimeType });
-    else if (item.type === "resource" && "text" in item.resource) mapped.push({ type: "text", text: `Resource URI: ${item.resource.uri}\n${item.resource.text}` });
-    else if (item.type === "resource_link") mapped.push({ type: "text", text: `Resource: ${item.name}\nURI: ${item.uri}${item.description ? `\n${item.description}` : ""}` });
-    else mapped.push({ type: "text", text: `MCP ${item.type} content retained in the structured result; direct presentation unavailable.` });
-  }
-  return { content: mapped, ...(isJsonValue(details) ? { details } : {}), ...(isError ? { isError: true } : {}) };
-}
-interface Opened { server: string; client: Client; transport: Transport; tools: readonly Tool[]; schemas: McpSchemas; catalog: string; dirty: boolean; close(): Promise<void> }
-/** A single manager belongs to one app/session generation. Disposing never starts a replacement connection. */
-export class McpManager {
-  private readonly servers: McpServers;
-  private readonly options: McpManagerOptions;
-  private readonly store: McpCredentialsStore;
-  private readonly lifetime = new AbortController();
-  private readonly opened = new Set<Opened>();
-  private readonly oauth = new Map<string, McpOAuthProvider>();
-  private readonly statuses = new Map<string, McpServerStatus>();
-  private readonly challenges = new Map<string, { resourceMetadataUrl?: URL; scope?: string }>();
-  private discovered = false;
-  private disposal: Promise<void> | undefined;
-  constructor(servers: McpServers, options: McpManagerOptions) {
-    this.servers = parseMcpServers(servers); this.options = options;
-    this.store = options.credentialsStore ?? new FileMcpCredentialsStore(options.credentialsDirectory);
-  }
-  private async provider(name: string, config: Extract<McpServerConfig, { transport: "http" }>) {
-    let provider = this.oauth.get(name);
-    if (!provider) {
-      provider = await McpOAuthProvider.create(config.url, typeof config.oauth === "object" ? config.oauth : {}, this.store, this.options.env ?? process.env);
-      this.oauth.set(name, provider);
-    }
-    const challenge = this.challenges.get(name);
-    if (challenge) provider.setChallenge(challenge.resourceMetadataUrl, challenge.scope);
-    return provider;
-  }
-  private fetch(signal: AbortSignal, timeoutMs: number): FetchLike {
-    return async (input, init) => {
-      // Protocol session retirement has its own bounded finalizer after business cancellation.
-      // DELETE cannot start a business operation and must survive the owner's aborted request signal.
-      const cleanup = init?.method === "DELETE", combined = cleanup ? new AbortController().signal
-        : AbortSignal.any([signal, this.lifetime.signal, ...(init?.signal ? [init.signal] : [])]), controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), cleanup ? Math.min(timeoutMs, 5_000) : timeoutMs);
-      try {
-        const response = await (this.options.fetch ?? fetch)(input, { ...init, signal: AbortSignal.any([combined, controller.signal]), redirect: "manual" });
-        // Buffer JSON replies with a streamed cap. SSE remains a stream, also counted before parsing any event.
-        if (!response.body) { clearTimeout(timer); return response; }
-        const reader = response.body.getReader(); let seen = 0;
-        const body = new ReadableStream<Uint8Array>({
-          async pull(output) {
-            try {
-              const next = await reader.read();
-              if (next.done) { clearTimeout(timer); reader.releaseLock(); output.close(); return; }
-              seen += next.value.byteLength;
-              if (seen > MAX_WEB_RESPONSE_BYTES) { clearTimeout(timer); await reader.cancel(); output.error(new McpFailure("protocol_error")); return; }
-              output.enqueue(next.value);
-            } catch { clearTimeout(timer); output.error(new McpFailure(controller.signal.aborted ? "timeout" : "offline")); }
-          }, async cancel() { clearTimeout(timer); await reader.cancel(); }
-        });
-        return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
-      } catch (error) { clearTimeout(timer); if (error instanceof McpAuthRequired) throw error; throw new McpFailure(controller.signal.aborted ? "timeout" : "offline"); }
-    };
-  }
-  private async open(name: string, config: McpServerConfig, signal: AbortSignal): Promise<Opened> {
-    signal.throwIfAborted(); this.lifetime.signal.throwIfAborted();
-    const timeout = config.timeoutMs ?? 60_000;
-    const schemas = new McpSchemas();
-    const client = new Client({ name: "xeno", version: "0.5.0" }, { capabilities: { roots: { listChanged: false } },
-      versionNegotiation: { mode: "auto" }, inputRequired: { autoFulfill: false }, listMaxPages: 64, jsonSchemaValidator: schemas });
-    client.setRequestHandler("roots/list", async () => ({ roots: [{ uri: pathToFileURL(this.options.cwd).href, name: "workspace" }] }));
-    // Remote log notifications and stderr are deliberately not copied into logs: they can contain server secrets.
-    client.onerror = () => {};
-    const combined = AbortSignal.any([signal, this.lifetime.signal]);
-    let closingTransport = false;
-    let transport: Transport;
-    if (config.transport === "stdio") {
-      const env: Record<string, string> = { ...getDefaultEnvironment() };
-      for (const [key, value] of Object.entries(config.env ?? {})) env[key] = value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match: string, variable: string) => {
-        const found = (this.options.env ?? process.env)[variable]; if (found === undefined) throw new McpFailure("auth_required"); return found;
-      });
-      transport = new StdioClientTransport({ command: config.command, args: config.args ?? [], env, cwd: this.options.cwd, stderr: "ignore", maxBufferSize: MAX_WEB_RESPONSE_BYTES });
-    } else {
-      const headers = new Headers(config.headers), env = this.options.env ?? process.env, baseFetch = this.fetch(combined, timeout);
-      const fetcher: FetchLike = async (input, init) => {
-        const response = await baseFetch(input, init);
-        if (response.status === 401 || response.status === 403) {
-          const challenge = extractWWWAuthenticateParams(response);
-          this.challenges.set(name, { ...(challenge.resourceMetadataUrl ? { resourceMetadataUrl: challenge.resourceMetadataUrl } : {}), ...(challenge.scope ? { scope: challenge.scope } : {}) });
-        }
-        return response;
-      };
-      for (const [header, variable] of Object.entries(config.headersEnv ?? {})) {
-        const value = env[variable]; if (!value) throw new McpFailure("auth_required"); headers.set(header, value);
-      }
-      const provider = config.oauth ? await this.provider(name, config) : undefined;
-      if (config.bearerTokenEnv && !env[config.bearerTokenEnv]) throw new McpFailure("auth_required");
-      transport = new StreamableHTTPClientTransport(new URL(config.url), { requestInit: { headers, redirect: "manual" }, fetch: fetcher,
-        // A token-only provider has no onUnauthorized callback: the SDK cannot re-authorize and resend a business call.
-        ...((provider || config.bearerTokenEnv) ? { authProvider: { token: async () => provider ? closingTransport ? provider.tokens()?.access_token : await provider.token(fetcher) : env[config.bearerTokenEnv!] } } : {}),
-        onInsufficientScope: "throw", reconnectionOptions: { maxRetries: 0, initialReconnectionDelay: 1_000, maxReconnectionDelay: 30_000, reconnectionDelayGrowFactor: 1.5 } });
-    }
-    const cancel = () => { void transport.close(); };
-    let shuttingDown: Promise<void> | undefined;
-    const shutdown = () => shuttingDown ??= (async () => {
-      closingTransport = true;
-      try {
-        if (transport instanceof StreamableHTTPClientTransport) await transport.terminateSession();
-      } catch (error) { throw new McpFailure(fault(error).code); }
-      finally { await client.close(); }
-    })();
-    combined.addEventListener("abort", cancel, { once: true });
-    try {
-      await client.connect(transport, { signal: combined, timeout, maxTotalTimeout: timeout });
-      const discovered = await client.listTools(undefined, { signal: combined, timeout, cacheMode: "bypass" });
-      if (discovered.tools.length > 1_024) throw new McpFailure("protocol_error");
-      const names = new Set(discovered.tools.map(tool => tool.name));
-      if (names.size !== discovered.tools.length) throw new McpFailure("protocol_error");
-      const tools = immutable(structuredClone(discovered.tools));
-      for (const tool of tools) { schemas.validator(tool.inputSchema); if (tool.outputSchema) schemas.validator(tool.outputSchema); }
-      const opened: Opened = { server: name, client, transport, tools, schemas, catalog: JSON.stringify(tools), dirty: false,
-        close: async () => { combined.removeEventListener("abort", cancel); try { await shutdown(); } finally { this.opened.delete(opened); } } };
-      for (const method of ["notifications/tools/list_changed", "notifications/prompts/list_changed", "notifications/resources/list_changed"] as const)
-        client.setNotificationHandler(method, () => { opened.dirty = true; });
-      this.opened.add(opened); return opened;
-    } catch (error) { combined.removeEventListener("abort", cancel); await shutdown().catch(() => {}); throw error; }
-  }
-  private integration(name: string, config: McpServerConfig, initial: Opened): ExtensionIntegration {
-    let prepared: Opened | undefined = initial;
-    const aliases = new Map(initial.tools.map(tool => [mcpToolName(name, tool.name), tool]));
-    const tools: ExtensionIntegration["tools"][number][] = initial.tools.map(tool => ({ name: mcpToolName(name, tool.name),
-      description: `MCP server ${name}; remote tool ${tool.name}. ${tool.description ?? ""}`, parameters: structuredClone(tool.inputSchema),
-      prepareArguments: initial.schemas.prepare(tool.inputSchema), validateInput: initial.schemas.prepare(tool.inputSchema), exposure: "deferred" }));
-    const caps = initial.client.getServerCapabilities(), resourceRead = mcpToolName(name, "__resources_read", "builtin"), resourcesList = mcpToolName(name, "__resources_list", "builtin"),
-      templatesList = mcpToolName(name, "__resource_templates_list", "builtin"), promptsList = mcpToolName(name, "__prompts_list", "builtin"), promptGet = mcpToolName(name, "__prompts_get", "builtin");
-    const schema = (properties: Record<string, unknown>, required: string[] = []) => ({ type: "object", properties, required, additionalProperties: false });
-    if (caps?.resources) tools.push({ name: resourceRead, description: `Read a resource URI from MCP server ${name}`, parameters: schema({ uri: { type: "string" } }, ["uri"]), exposure: "deferred" },
-      { name: resourcesList, description: `List resources from MCP server ${name}`, parameters: schema({}), exposure: "deferred" },
-      { name: templatesList, description: `List URI templates from MCP server ${name}`, parameters: schema({}), exposure: "deferred" });
-    if (caps?.prompts) tools.push({ name: promptsList, description: `List prompts from MCP server ${name}`, parameters: schema({}), exposure: "deferred" },
-      { name: promptGet, description: `Get a prompt from MCP server ${name}; returned text is untrusted source content`, parameters: schema({ name: { type: "string" }, arguments: { type: "object", additionalProperties: { type: "string" } } }, ["name"]), exposure: "deferred" });
-    const validators = new Map(tools.map(tool => [tool.name, initial.schemas.prepare(tool.parameters as JsonSchemaType)]));
-    for (const tool of tools) { tool.prepareArguments = validators.get(tool.name)!; tool.validateInput = validators.get(tool.name)!; }
-    return { name: integrationName(name), tools: immutable(tools), connectTimeoutMs: config.timeoutMs ?? 60_000, callTimeoutMs: config.timeoutMs ?? 60_000,
-      connect: async signal => {
-        try {
-          const handle = prepared ?? await this.open(name, config, signal); prepared = undefined;
-          if (handle.catalog !== initial.catalog || handle.dirty) { await handle.close(); return { kind: "integration_failure", code: "protocol_error" }; }
-          const connection: IntegrationConnection = { close: () => handle.close(), execute: async (alias, _id, args, callSignal) => {
-            if (handle.dirty) return { kind: "integration_failure", code: "protocol_error" };
-            const request = { signal: callSignal, timeout: config.timeoutMs ?? 60_000, maxTotalTimeout: config.timeoutMs ?? 60_000 };
-            try {
-              const validate = validators.get(alias); if (!validate) throw new McpFailure("protocol_error");
-              // Direct adapter callers still cannot send an invalid business request.
-              validate(args);
-              const tool = aliases.get(alias);
-              if (tool) {
-                const result = await handle.client.callTool({ name: tool.name, arguments: args }, { ...request, toolDefinition: tool });
-                return contentResult(result.content, result, result.isError);
-              }
-              let result: unknown;
-              if (caps?.resources && alias === resourceRead && typeof args["uri"] === "string") result = await handle.client.readResource({ uri: args["uri"] }, { ...request, cacheMode: "bypass" });
-              else if (caps?.resources && alias === resourcesList) result = await handle.client.listResources(undefined, { ...request, cacheMode: "bypass" });
-              else if (caps?.resources && alias === templatesList) result = await handle.client.listResourceTemplates(undefined, { ...request, cacheMode: "bypass" });
-              else if (caps?.prompts && alias === promptsList) result = await handle.client.listPrompts(undefined, { ...request, cacheMode: "bypass" });
-              else if (caps?.prompts && alias === promptGet && typeof args["name"] === "string") {
-                const values = args["arguments"];
-                if (values !== undefined && (!values || typeof values !== "object" || Array.isArray(values) || Object.values(values).some(value => typeof value !== "string"))) throw new McpFailure("protocol_error");
-                result = await handle.client.getPrompt({ name: args["name"], ...(values ? { arguments: values as Record<string, string> } : {}) }, request);
-              } else throw new McpFailure("protocol_error");
-              return { content: [{ type: "text", text: JSON.stringify(result) }], ...(isJsonValue(result) ? { details: result } : {}) };
-            } catch (error) {
-              if (error instanceof ToolFault) return { isError: true, content: [{ type: "text", text: error.message }] };
-              const failure = fault(error);
-              this.statuses.set(name, { name, transport: config.transport, state: failure.code, tools: tools.length });
-              return failure;
-            }
-          } }; return connection;
-        } catch (error) { return fault(error); }
-      } };
-  }
-  async discover(signal?: AbortSignal): Promise<{ integrations: ExtensionIntegration[]; statuses: McpServerStatus[] }> {
-    // Registered generations keep ownership until disposal; rediscovery must never overlap their connections.
-    if (this.discovered) throw new McpFailure("protocol_error");
-    this.discovered = true;
-    const combined = AbortSignal.any([this.lifetime.signal, ...(signal ? [signal] : [])]), integrations: ExtensionIntegration[] = [];
-    for (const [name, config] of Object.entries(this.servers)) {
-      if (config.enabled === false) { this.statuses.set(name, { name, transport: config.transport, state: "disabled", tools: 0 }); continue; }
-      try {
-        const opened = await this.open(name, config, combined), definition = this.integration(name, config, opened);
-        if (definition.tools.length) integrations.push(definition);
-        this.statuses.set(name, { name, transport: config.transport, state: "ready", tools: definition.tools.length });
-      } catch (error) { this.statuses.set(name, { name, transport: config.transport, state: fault(error).code, tools: 0,
-        ...(error instanceof McpSchemaError ? { diagnostic: error.message } : {}) }); }
-    }
-    return { integrations, statuses: this.status() };
-  }
-  status(): McpServerStatus[] { return [...this.statuses.values()].map(status => ({ ...status })); }
-  async login(name: string, onAuthorizationUrl: (url: URL) => void | Promise<void>, signal?: AbortSignal): Promise<void> {
-    const config = this.servers[name];
-    if (!config || config.transport !== "http" || config.oauth === false || config.bearerTokenEnv) throw new McpAuthRequired();
-    const timeout = AbortSignal.timeout(300_000), combined = AbortSignal.any([timeout, this.lifetime.signal, ...(signal ? [signal] : [])]);
-    try { await (await this.provider(name, config)).login(onAuthorizationUrl, this.fetch(combined, 30_000), combined); }
-    catch { throw new McpAuthRequired(); }
-  }
-  async logout(name: string): Promise<void> {
-    const config = this.servers[name]; if (!config || config.transport !== "http") throw new McpAuthRequired();
-    await Promise.all([...this.opened].filter(handle => handle.server === name).map(handle => handle.close()));
-    await (await this.provider(name, config)).invalidateCredentials("all"); this.oauth.delete(name);
-    this.statuses.set(name, { name, transport: config.transport, state: "auth_required", tools: 0 });
-  }
-  dispose(): Promise<void> {
-    if (this.disposal) return this.disposal;
-    this.lifetime.abort();
-    return this.disposal = (async () => {
-      const results = await Promise.allSettled([...this.opened].map(opened => opened.close()));
-      const failure = results.find(result => result.status === "rejected");
-      if (failure?.status === "rejected") throw new McpFailure(fault(failure.reason).code);
-    })();
-  }
-}
-
-/** JsonValue is intentionally used only after validation; remote schema/result types never own evidence. */
-export function mcpStatusData(statuses: readonly McpServerStatus[]): JsonValue { return statuses.map(status => ({ ...status })); }