@executor-js/plugin-mcp 0.1.0 → 0.2.1

package/dist/chunk-OOOH3IO4.js

@@ -0,0 +1,2194 @@
+import {
+  MCP_HEADER_AUTH_SLOT,
+  MCP_OAUTH_CLIENT_ID_SLOT,
+  MCP_OAUTH_CLIENT_SECRET_SLOT,
+  MCP_OAUTH_CONNECTION_SLOT,
+  McpConnectionError,
+  McpInvocationError,
+  McpSourceBindingRef,
+  McpStoredSourceData,
+  McpToolAnnotations,
+  McpToolBinding,
+  McpToolDiscoveryError,
+  mcpHeaderSlot,
+  mcpQueryParamSlot
+} from "./chunk-Z4CRPOLI.js";
+
+// src/sdk/binding-store.ts
+import { Effect, Option, Schema } from "effect";
+import {
+  ConfiguredCredentialBinding,
+  defineSchema
+} from "@executor-js/sdk/core";
+var mcpSchema = defineSchema({
+  mcp_source: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      name: { type: "string", required: true },
+      // Plugin-private structural data minus the ref-bearing fields
+      // (auth, headers, queryParams). For remote sources: transport,
+      // endpoint, remoteTransport. For stdio: transport, command,
+      // args, env, cwd.
+      config: { type: "json", required: true },
+      // Flattened McpConnectionAuth. The stored source only names slots;
+      // concrete per-user/per-workspace values live in core credential_binding.
+      auth_kind: {
+        type: ["none", "header", "oauth2"],
+        required: true,
+        defaultValue: "none"
+      },
+      // Header-auth fields.
+      auth_header_name: { type: "string", required: false },
+      auth_header_slot: { type: "string", required: false },
+      auth_header_prefix: { type: "string", required: false },
+      // OAuth2 auth fields.
+      auth_connection_slot: { type: "string", required: false },
+      auth_client_id_slot: {
+        type: "string",
+        required: false
+      },
+      auth_client_secret_slot: {
+        type: "string",
+        required: false
+      },
+      created_at: { type: "date", required: true }
+    }
+  },
+  mcp_source_header: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      source_id: { type: "string", required: true, index: true },
+      name: { type: "string", required: true },
+      kind: { type: ["text", "binding"], required: true },
+      text_value: { type: "string", required: false },
+      slot_key: { type: "string", required: false },
+      prefix: { type: "string", required: false }
+    }
+  },
+  mcp_source_query_param: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      source_id: { type: "string", required: true, index: true },
+      name: { type: "string", required: true },
+      kind: { type: ["text", "binding"], required: true },
+      text_value: { type: "string", required: false },
+      slot_key: { type: "string", required: false },
+      prefix: { type: "string", required: false }
+    }
+  },
+  mcp_binding: {
+    fields: {
+      id: { type: "string", required: true },
+      scope_id: { type: "string", required: true, index: true },
+      source_id: { type: "string", required: true, index: true },
+      binding: { type: "json", required: true },
+      created_at: { type: "date", required: true }
+    }
+  }
+});
+var decodeSourceData = Schema.decodeUnknownSync(McpStoredSourceData);
+var encodeSourceData = Schema.encodeSync(McpStoredSourceData);
+var decodeBinding = Schema.decodeUnknownSync(McpToolBinding);
+var encodeBinding = Schema.encodeSync(McpToolBinding);
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+var coerceJson = (value) => {
+  if (typeof value !== "string") return value;
+  return Option.getOrElse(decodeJson(value), () => value);
+};
+var authToColumns = (auth) => {
+  if (auth.kind === "header") {
+    return {
+      auth_kind: "header",
+      auth_header_name: auth.headerName,
+      auth_header_slot: auth.secretSlot,
+      auth_header_prefix: auth.prefix
+    };
+  }
+  if (auth.kind === "oauth2") {
+    return {
+      auth_kind: "oauth2",
+      auth_connection_slot: auth.connectionSlot,
+      auth_client_id_slot: auth.clientIdSlot,
+      auth_client_secret_slot: auth.clientSecretSlot
+    };
+  }
+  return { auth_kind: "none" };
+};
+var columnsToAuth = (row) => {
+  const kind = row.auth_kind;
+  if (kind === "header" && typeof row.auth_header_slot === "string") {
+    const prefix = row.auth_header_prefix;
+    return {
+      kind: "header",
+      headerName: row.auth_header_name ?? "",
+      secretSlot: row.auth_header_slot,
+      ...prefix ? { prefix } : {}
+    };
+  }
+  if (kind === "oauth2" && typeof row.auth_connection_slot === "string") {
+    const cid = row.auth_client_id_slot;
+    const csec = row.auth_client_secret_slot;
+    return {
+      kind: "oauth2",
+      connectionSlot: row.auth_connection_slot,
+      ...cid ? { clientIdSlot: cid } : {},
+      ...csec ? { clientSecretSlot: csec } : {}
+    };
+  }
+  return { kind: "none" };
+};
+var valueMapToRows = (sourceId, scope, values) => {
+  if (!values) return [];
+  return Object.entries(values).map(([name, value]) => {
+    const id = JSON.stringify([sourceId, name]);
+    if (typeof value === "string") {
+      return {
+        id,
+        scope_id: scope,
+        source_id: sourceId,
+        name,
+        kind: "text",
+        text_value: value
+      };
+    }
+    return {
+      id,
+      scope_id: scope,
+      source_id: sourceId,
+      name,
+      kind: "binding",
+      slot_key: value.slot,
+      prefix: value.prefix
+    };
+  });
+};
+var rowsToValueMap = (rows) => {
+  const out = {};
+  for (const row of rows) {
+    if (typeof row.name !== "string") continue;
+    const name = row.name;
+    if (row.kind === "binding" && typeof row.slot_key === "string") {
+      const prefix = row.prefix;
+      out[name] = prefix ? new ConfiguredCredentialBinding({ kind: "binding", slot: row.slot_key, prefix }) : new ConfiguredCredentialBinding({ kind: "binding", slot: row.slot_key });
+    } else if (row.kind === "text" && typeof row.text_value === "string") {
+      out[name] = row.text_value;
+    }
+  }
+  return out;
+};
+var makeMcpStore = ({ adapter: db }) => {
+  return {
+    listBindingsBySource: (namespace, scope) => Effect.gen(function* () {
+      const rows = yield* db.findMany({
+        model: "mcp_binding",
+        where: [
+          { field: "source_id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      return rows.map((row) => ({
+        toolId: row.id,
+        binding: decodeBinding(coerceJson(row.binding))
+      }));
+    }),
+    getBinding: (toolId, scope) => Effect.gen(function* () {
+      const row = yield* db.findOne({
+        model: "mcp_binding",
+        where: [
+          { field: "id", value: toolId },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      if (!row) return null;
+      const binding = decodeBinding(coerceJson(row.binding));
+      return { binding, namespace: row.source_id };
+    }),
+    putBindings: (namespace, scope, entries) => Effect.gen(function* () {
+      if (entries.length === 0) return;
+      const now = /* @__PURE__ */ new Date();
+      yield* db.createMany({
+        model: "mcp_binding",
+        data: entries.map((e) => ({
+          id: e.toolId,
+          scope_id: scope,
+          source_id: namespace,
+          binding: encodeBinding(e.binding),
+          created_at: now
+        })),
+        forceAllowId: true
+      });
+    }),
+    removeBindingsByNamespace: (namespace, scope) => db.deleteMany({
+      model: "mcp_binding",
+      where: [
+        { field: "source_id", value: namespace },
+        { field: "scope_id", value: scope }
+      ]
+    }).pipe(Effect.asVoid),
+    getSource: (namespace, scope) => Effect.gen(function* () {
+      const row = yield* db.findOne({
+        model: "mcp_source",
+        where: [
+          { field: "id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      if (!row) return null;
+      return {
+        namespace: row.id,
+        scope: row.scope_id,
+        name: row.name,
+        config: yield* hydrateSourceData(row, namespace, scope)
+      };
+    }),
+    getSourceConfig: (namespace, scope) => Effect.gen(function* () {
+      const row = yield* db.findOne({
+        model: "mcp_source",
+        where: [
+          { field: "id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      if (!row) return null;
+      return yield* hydrateSourceData(row, namespace, scope);
+    }),
+    putSource: (source) => Effect.gen(function* () {
+      const now = /* @__PURE__ */ new Date();
+      yield* db.delete({
+        model: "mcp_source",
+        where: [
+          { field: "id", value: source.namespace },
+          { field: "scope_id", value: source.scope }
+        ]
+      });
+      yield* deleteSourceChildren(source.namespace, source.scope);
+      const auth = source.config.transport === "remote" ? source.config.auth : { kind: "none" };
+      const authCols = authToColumns(auth);
+      const headers = source.config.transport === "remote" ? source.config.headers : void 0;
+      const queryParams = source.config.transport === "remote" ? source.config.queryParams : void 0;
+      const encodedConfig = stripExtractedFields(
+        encodeSourceData(source.config)
+      );
+      yield* db.create({
+        model: "mcp_source",
+        data: {
+          id: source.namespace,
+          scope_id: source.scope,
+          name: source.name,
+          config: encodedConfig,
+          created_at: now,
+          ...authCols
+        },
+        forceAllowId: true
+      });
+      const headerRows = valueMapToRows(source.namespace, source.scope, headers);
+      if (headerRows.length > 0) {
+        yield* db.createMany({
+          model: "mcp_source_header",
+          data: headerRows,
+          forceAllowId: true
+        });
+      }
+      const paramRows = valueMapToRows(source.namespace, source.scope, queryParams);
+      if (paramRows.length > 0) {
+        yield* db.createMany({
+          model: "mcp_source_query_param",
+          data: paramRows,
+          forceAllowId: true
+        });
+      }
+    }),
+    removeSource: (namespace, scope) => Effect.gen(function* () {
+      yield* db.deleteMany({
+        model: "mcp_binding",
+        where: [
+          { field: "source_id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      yield* deleteSourceChildren(namespace, scope);
+      yield* db.delete({
+        model: "mcp_source",
+        where: [
+          { field: "id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+    })
+  };
+  function deleteSourceChildren(namespace, scope) {
+    return Effect.gen(function* () {
+      for (const model of ["mcp_source_header", "mcp_source_query_param"]) {
+        yield* db.deleteMany({
+          model,
+          where: [
+            { field: "source_id", value: namespace },
+            { field: "scope_id", value: scope }
+          ]
+        });
+      }
+    });
+  }
+  function hydrateSourceData(row, namespace, scope) {
+    return Effect.gen(function* () {
+      const partial = coerceJson(row.config);
+      if (partial.transport !== "remote") {
+        return decodeSourceData(partial);
+      }
+      const headerRows = yield* db.findMany({
+        model: "mcp_source_header",
+        where: [
+          { field: "source_id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      const paramRows = yield* db.findMany({
+        model: "mcp_source_query_param",
+        where: [
+          { field: "source_id", value: namespace },
+          { field: "scope_id", value: scope }
+        ]
+      });
+      const headers = rowsToValueMap(headerRows);
+      const queryParams = rowsToValueMap(paramRows);
+      const reassembled = {
+        ...partial,
+        ...Object.keys(headers).length > 0 ? { headers } : {},
+        ...Object.keys(queryParams).length > 0 ? { queryParams } : {},
+        auth: columnsToAuth(row)
+      };
+      return decodeSourceData(reassembled);
+    });
+  }
+};
+var stripExtractedFields = (encoded) => {
+  if (encoded.transport !== "remote") return encoded;
+  const { auth, headers, queryParams, ...rest } = encoded;
+  void auth;
+  void headers;
+  void queryParams;
+  return rest;
+};
+
+// src/sdk/plugin.ts
+import {
+  Duration as Duration2,
+  Effect as Effect6,
+  Exit as Exit2,
+  Match,
+  Option as Option5,
+  Predicate as Predicate2,
+  Result,
+  Scope,
+  ScopedCache as ScopedCache2
+} from "effect";
+import {
+  ConfiguredCredentialBinding as ConfiguredCredentialBinding2,
+  ConnectionId,
+  ScopeId,
+  SecretId,
+  SourceDetectionResult,
+  definePlugin,
+  resolveSecretBackedMap as resolveSharedSecretBackedMap,
+  StorageError
+} from "@executor-js/sdk/core";
+
+// src/sdk/connection.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
+import { Effect as Effect2 } from "effect";
+var buildEndpointUrl = (endpoint, queryParams) => {
+  const url = new URL(endpoint);
+  for (const [key, value] of Object.entries(queryParams)) {
+    url.searchParams.set(key, value);
+  }
+  return url;
+};
+var createClient = () => new Client(
+  { name: "executor-mcp", version: "0.1.0" },
+  {
+    capabilities: { elicitation: { form: {}, url: {} } },
+    jsonSchemaValidator: new CfWorkerJsonSchemaValidator()
+  }
+);
+var connectionFromClient = (client) => ({
+  client,
+  close: () => client.close()
+});
+var connectClient = (input) => Effect2.gen(function* () {
+  const client = createClient();
+  const transportInstance = input.createTransport();
+  yield* Effect2.tryPromise({
+    try: () => client.connect(transportInstance),
+    catch: () => new McpConnectionError({
+      transport: input.transport,
+      message: `Failed connecting via ${input.transport}`
+    })
+  }).pipe(
+    Effect2.withSpan("plugin.mcp.connection.handshake", {
+      attributes: { "plugin.mcp.transport": input.transport }
+    })
+  );
+  return connectionFromClient(client);
+});
+var createMcpConnector = (input) => {
+  if (input.transport === "stdio") {
+    const command = input.command.trim();
+    if (!command) {
+      return Effect2.fail(
+        new McpConnectionError({
+          transport: "stdio",
+          message: "MCP stdio transport requires a command"
+        })
+      );
+    }
+    return Effect2.gen(function* () {
+      const { createStdioTransport } = yield* Effect2.tryPromise({
+        try: () => import("./stdio-connector-AA5S6UUJ.js"),
+        catch: () => new McpConnectionError({
+          transport: "stdio",
+          message: "Failed to load stdio transport module"
+        })
+      });
+      return yield* connectClient({
+        transport: "stdio",
+        createTransport: () => createStdioTransport({
+          command,
+          args: input.args,
+          env: input.env,
+          cwd: input.cwd?.trim().length ? input.cwd.trim() : void 0
+        })
+      });
+    });
+  }
+  const headers = input.headers ?? {};
+  const remoteTransport = input.remoteTransport ?? "auto";
+  const requestInit = Object.keys(headers).length > 0 ? { headers } : void 0;
+  const endpoint = buildEndpointUrl(input.endpoint, input.queryParams ?? {});
+  const connectStreamableHttp = connectClient({
+    transport: "streamable-http",
+    createTransport: () => new StreamableHTTPClientTransport(endpoint, {
+      requestInit,
+      authProvider: input.authProvider
+    })
+  });
+  const connectSse = connectClient({
+    transport: "sse",
+    createTransport: () => new SSEClientTransport(endpoint, {
+      requestInit,
+      authProvider: input.authProvider
+    })
+  });
+  if (remoteTransport === "streamable-http") return connectStreamableHttp;
+  if (remoteTransport === "sse") return connectSse;
+  return connectStreamableHttp.pipe(Effect2.catch(() => connectSse));
+};
+
+// src/sdk/discover.ts
+import { Effect as Effect3 } from "effect";
+
+// src/sdk/manifest.ts
+import { Option as Option2, Schema as Schema2 } from "effect";
+var ListedTool = Schema2.Struct({
+  name: Schema2.String,
+  description: Schema2.optional(Schema2.NullOr(Schema2.String)),
+  inputSchema: Schema2.optional(Schema2.Unknown),
+  parameters: Schema2.optional(Schema2.Unknown),
+  outputSchema: Schema2.optional(Schema2.Unknown),
+  annotations: Schema2.optional(McpToolAnnotations)
+});
+var ListToolsResult = Schema2.Struct({
+  tools: Schema2.Array(ListedTool)
+});
+var ServerInfo = Schema2.Struct({
+  name: Schema2.optional(Schema2.String),
+  version: Schema2.optional(Schema2.String)
+});
+var decodeListToolsResult = Schema2.decodeUnknownOption(ListToolsResult);
+var decodeServerInfo = Schema2.decodeUnknownOption(ServerInfo);
+var isListToolsResult = (value) => Option2.isSome(decodeListToolsResult(value));
+var sanitize = (value) => {
+  const s = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return s || "tool";
+};
+var uniqueId = (value, seen) => {
+  const base = sanitize(value);
+  const n = (seen.get(base) ?? 0) + 1;
+  seen.set(base, n);
+  return n === 1 ? base : `${base}_${n}`;
+};
+var extractManifestFromListToolsResult = (listToolsResult, metadata) => {
+  const seen = /* @__PURE__ */ new Map();
+  const listed = decodeListToolsResult(listToolsResult).pipe(
+    Option2.map((result) => result.tools),
+    Option2.getOrElse(() => [])
+  );
+  const server = decodeServerInfo(metadata?.serverInfo).pipe(
+    Option2.map(
+      (info) => ({
+        name: info.name ?? null,
+        version: info.version ?? null
+      })
+    ),
+    Option2.getOrNull
+  );
+  const tools = listed.flatMap((tool) => {
+    const toolName = tool.name.trim();
+    if (!toolName) return [];
+    return [
+      {
+        toolId: uniqueId(toolName, seen),
+        toolName,
+        description: tool.description ?? null,
+        inputSchema: tool.inputSchema ?? tool.parameters,
+        outputSchema: tool.outputSchema,
+        annotations: tool.annotations
+      }
+    ];
+  });
+  return { server, tools };
+};
+var slugify = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+var hostnameOf = (url) => {
+  if (!URL.canParse(url)) return null;
+  return new URL(url).hostname;
+};
+var basenameOf = (path) => path.trim().split(/[\\/]/).pop() ?? path.trim();
+var deriveMcpNamespace = (input) => {
+  if (input.name?.trim()) return slugify(input.name) || "mcp";
+  const fromEndpoint = input.endpoint?.trim() ? hostnameOf(input.endpoint) : null;
+  if (fromEndpoint) return slugify(fromEndpoint) || "mcp";
+  if (input.command?.trim()) return slugify(basenameOf(input.command)) || "mcp";
+  return "mcp";
+};
+
+// src/sdk/discover.ts
+var discoverTools = (connector) => Effect3.gen(function* () {
+  const connection = yield* connector.pipe(
+    Effect3.mapError(
+      ({ message }) => new McpToolDiscoveryError({
+        stage: "connect",
+        message: `Failed connecting to MCP server: ${message}`
+      })
+    )
+  );
+  const listResult = yield* Effect3.tryPromise({
+    try: () => connection.client.listTools(),
+    catch: () => new McpToolDiscoveryError({
+      stage: "list_tools",
+      message: "Failed listing MCP tools"
+    })
+  });
+  if (!isListToolsResult(listResult)) {
+    yield* closeConnection(connection);
+    return yield* new McpToolDiscoveryError({
+      stage: "list_tools",
+      message: "MCP listTools response did not match the expected schema"
+    });
+  }
+  const manifest = extractManifestFromListToolsResult(listResult, {
+    serverInfo: connection.client.getServerVersion?.()
+  });
+  yield* closeConnection(connection);
+  return manifest;
+});
+var closeConnection = (connection) => Effect3.ignore(
+  Effect3.tryPromise({
+    try: () => connection.close(),
+    catch: () => new McpToolDiscoveryError({
+      stage: "list_tools",
+      message: "Failed closing MCP connection"
+    })
+  })
+);
+
+// src/sdk/invoke.ts
+import { Cause, Effect as Effect4, Exit, Option as Option3, Predicate, Schema as Schema3, ScopedCache } from "effect";
+import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  FormElicitation,
+  UrlElicitation
+} from "@executor-js/sdk/core";
+var ArgsRecord = Schema3.Record(Schema3.String, Schema3.Unknown);
+var decodeArgsRecord = Schema3.decodeUnknownOption(ArgsRecord);
+var argsRecord = (value) => Option3.getOrElse(decodeArgsRecord(value), () => ({}));
+var stableJson = (value) => {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+var fingerprint = (value) => {
+  const input = stableJson(value);
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+};
+var connectionCacheKey = (input) => {
+  const sd = input.sourceData;
+  return sd.transport === "stdio" ? `stdio:${fingerprint({
+    sourceId: input.sourceId,
+    sourceScope: input.sourceScope,
+    command: sd.command,
+    args: sd.args ?? [],
+    env: sd.env ?? {},
+    cwd: sd.cwd ?? null
+  })}` : `remote:${fingerprint({
+    sourceId: input.sourceId,
+    sourceScope: input.sourceScope,
+    invokerScope: input.invokerScope,
+    endpoint: sd.endpoint,
+    remoteTransport: sd.remoteTransport ?? "auto",
+    headers: sd.headers ?? {},
+    queryParams: sd.queryParams ?? {},
+    auth: sd.auth
+  })}`;
+};
+var McpElicitParams = Schema3.Union([
+  Schema3.Struct({
+    mode: Schema3.Literal("url"),
+    message: Schema3.String,
+    url: Schema3.String,
+    elicitationId: Schema3.optional(Schema3.String),
+    id: Schema3.optional(Schema3.String)
+  }),
+  Schema3.Struct({
+    mode: Schema3.optional(Schema3.Literal("form")),
+    message: Schema3.String,
+    requestedSchema: Schema3.Record(Schema3.String, Schema3.Unknown)
+  })
+]);
+var decodeElicitParams = Schema3.decodeUnknownSync(McpElicitParams);
+var toElicitationRequest = (params) => params.mode === "url" ? new UrlElicitation({
+  message: params.message,
+  url: params.url,
+  elicitationId: params.elicitationId ?? params.id ?? ""
+}) : new FormElicitation({
+  message: params.message,
+  requestedSchema: params.requestedSchema
+});
+var installElicitationHandler = (client, elicit) => {
+  client.setRequestHandler(ElicitRequestSchema, async (request) => {
+    const params = decodeElicitParams(request.params);
+    const req = toElicitationRequest(params);
+    const exit = await Effect4.runPromiseExit(elicit(req));
+    if (Exit.isSuccess(exit)) {
+      const response = exit.value;
+      return {
+        action: response.action,
+        ...response.action === "accept" && response.content ? { content: response.content } : {}
+      };
+    }
+    const failure = exit.cause.reasons.find(Cause.isFailReason);
+    if (failure) {
+      const err = failure.error;
+      if (Predicate.isTagged(err, "ElicitationDeclinedError")) {
+        const action = Predicate.hasProperty(err, "action") && err.action === "cancel" ? "cancel" : "decline";
+        return { action };
+      }
+    }
+    throw Cause.squash(exit.cause);
+  });
+};
+var useConnection = (connection, toolName, args, elicit) => Effect4.gen(function* () {
+  installElicitationHandler(connection.client, elicit);
+  return yield* Effect4.tryPromise({
+    try: () => connection.client.callTool({ name: toolName, arguments: args }),
+    catch: () => new McpInvocationError({
+      toolName,
+      message: `MCP tool call failed for ${toolName}`
+    })
+  }).pipe(
+    Effect4.withSpan("plugin.mcp.client.call_tool", {
+      attributes: { "mcp.tool.name": toolName }
+    })
+  );
+});
+var invokeMcpTool = (input) => {
+  const transport = input.sourceData.transport === "stdio" ? "stdio" : input.sourceData.remoteTransport ?? "auto";
+  return Effect4.gen(function* () {
+    const cacheKey = connectionCacheKey(input);
+    const args = argsRecord(input.args);
+    const connector = input.resolveConnector();
+    input.pendingConnectors.set(cacheKey, connector);
+    const cacheHit = yield* ScopedCache.has(input.connectionCache, cacheKey);
+    const firstConnection = yield* ScopedCache.get(input.connectionCache, cacheKey).pipe(
+      Effect4.withSpan("plugin.mcp.connection.acquire", {
+        attributes: {
+          "plugin.mcp.transport": transport,
+          "plugin.mcp.cache_key": cacheKey,
+          "plugin.mcp.attempt": 1,
+          "plugin.mcp.cache_hit": cacheHit
+        }
+      })
+    );
+    return yield* useConnection(firstConnection, input.toolName, args, input.elicit).pipe(
+      // On failure, invalidate the cache and retry once with a fresh
+      // connection. Matches the old invoker's retry-once semantics.
+      Effect4.catch(
+        () => Effect4.gen(function* () {
+          yield* ScopedCache.invalidate(input.connectionCache, cacheKey);
+          input.pendingConnectors.set(cacheKey, connector);
+          const fresh = yield* ScopedCache.get(input.connectionCache, cacheKey);
+          return yield* useConnection(fresh, input.toolName, args, input.elicit);
+        }).pipe(
+          Effect4.withSpan("plugin.mcp.invoke.retry", {
+            attributes: {
+              "plugin.mcp.transport": transport,
+              "plugin.mcp.cache_key": cacheKey,
+              "mcp.tool.name": input.toolName
+            }
+          })
+        )
+      )
+    );
+  }).pipe(
+    Effect4.scoped,
+    Effect4.withSpan("plugin.mcp.invoke", {
+      attributes: {
+        "mcp.tool.name": input.toolName,
+        "plugin.mcp.tool_id": input.toolId,
+        "plugin.mcp.transport": transport
+      }
+    })
+  );
+};
+
+// src/sdk/probe-shape.ts
+import { Data, Duration, Effect as Effect5, Option as Option4, Schema as Schema4 } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+var INITIALIZE_BODY = JSON.stringify({
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: "2025-06-18",
+    capabilities: {},
+    clientInfo: { name: "executor-probe", version: "0" }
+  }
+});
+var readHeader = (headers, name) => {
+  const direct = headers[name];
+  if (direct !== void 0) return direct;
+  const lower = name.toLowerCase();
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === lower) return v;
+  }
+  return null;
+};
+var ProbeTransportError = class extends Data.TaggedError("ProbeTransportError") {
+};
+var decodeJsonString = Schema4.decodeUnknownOption(Schema4.fromJsonString(Schema4.Unknown));
+var asObject = (body) => {
+  if (!body) return null;
+  const parsed = decodeJsonString(body);
+  if (Option4.isNone(parsed)) return null;
+  const value = parsed.value;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return value;
+};
+var isJsonRpcEnvelope = (body) => {
+  const obj = asObject(body);
+  if (!obj) return false;
+  if (obj.jsonrpc !== "2.0") return false;
+  return "result" in obj || "error" in obj || "method" in obj;
+};
+var isOAuthErrorBody = (body) => {
+  const obj = asObject(body);
+  if (!obj) return false;
+  if (Array.isArray(obj.errors)) return false;
+  return typeof obj.error === "string";
+};
+var ErrorMessageShape = Schema4.Struct({ message: Schema4.String });
+var decodeErrorMessageShape = Schema4.decodeUnknownOption(ErrorMessageShape);
+var reasonFromBoundaryCause = (cause) => {
+  const messageShape = decodeErrorMessageShape(cause);
+  if (Option4.isSome(messageShape)) return messageShape.value.message;
+  if (typeof cause === "string") return cause;
+  if (typeof cause === "number" || typeof cause === "boolean" || typeof cause === "bigint") {
+    return `${cause}`;
+  }
+  if (typeof cause === "symbol") return cause.description ?? "symbol";
+  if (cause === null) return "null";
+  if (typeof cause === "undefined") return "undefined";
+  return "fetch failed";
+};
+var probeMcpEndpointShape = (endpoint, options = {}) => Effect5.gen(function* () {
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  const outcome = yield* Effect5.gen(function* () {
+    const client = yield* HttpClient.HttpClient;
+    const readBody = (response) => response.text.pipe(
+      Effect5.timeout(Duration.millis(timeoutMs)),
+      Effect5.catch(() => Effect5.succeed(""))
+    );
+    const classify = (response, method) => Effect5.gen(function* () {
+      const contentType = readHeader(response.headers, "content-type") ?? "";
+      const isSse = /^\s*text\/event-stream\b/i.test(contentType);
+      if (response.status === 401) {
+        const wwwAuth = readHeader(response.headers, "www-authenticate");
+        if (!wwwAuth || !/^\s*bearer\b/i.test(wwwAuth)) {
+          return {
+            kind: "not-mcp",
+            category: "auth-required",
+            reason: "401 without Bearer WWW-Authenticate \u2014 not an MCP auth challenge"
+          };
+        }
+        if (/(?:^|[\s,])resource_metadata\s*=/i.test(wwwAuth)) {
+          return { kind: "mcp", requiresAuth: true };
+        }
+        if (/(?:^|[\s,])error\s*=/i.test(wwwAuth)) {
+          return { kind: "mcp", requiresAuth: true };
+        }
+        if (isSse) return { kind: "mcp", requiresAuth: true };
+        const body = yield* readBody(response);
+        if (!isJsonRpcEnvelope(body) && !isOAuthErrorBody(body)) {
+          return {
+            kind: "not-mcp",
+            category: "auth-required",
+            reason: "401 + Bearer without resource_metadata, JSON-RPC body, or OAuth error body"
+          };
+        }
+        return { kind: "mcp", requiresAuth: true };
+      }
+      if (response.status >= 200 && response.status < 300) {
+        if (method === "GET") {
+          if (!isSse) {
+            return {
+              kind: "not-mcp",
+              category: "wrong-shape",
+              reason: "GET response is not an SSE stream"
+            };
+          }
+          return { kind: "mcp", requiresAuth: false };
+        }
+        if (isSse) return { kind: "mcp", requiresAuth: false };
+        const body = yield* readBody(response);
+        if (!isJsonRpcEnvelope(body)) {
+          return {
+            kind: "not-mcp",
+            category: "wrong-shape",
+            reason: "2xx POST body is not a JSON-RPC envelope"
+          };
+        }
+        return { kind: "mcp", requiresAuth: false };
+      }
+      return null;
+    });
+    const url = new URL(endpoint);
+    for (const [key, value] of Object.entries(options.queryParams ?? {})) {
+      url.searchParams.set(key, value);
+    }
+    let postRequest = HttpClientRequest.post(url.toString()).pipe(
+      HttpClientRequest.setHeader("content-type", "application/json"),
+      HttpClientRequest.setHeader("accept", "application/json, text/event-stream"),
+      HttpClientRequest.bodyText(INITIALIZE_BODY, "application/json")
+    );
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+      postRequest = HttpClientRequest.setHeader(postRequest, name, value);
+    }
+    const postResponse = yield* client.execute(postRequest).pipe(Effect5.timeout(Duration.millis(timeoutMs)));
+    const postResult = yield* classify(postResponse, "POST");
+    if (postResult) return postResult;
+    if ([404, 405, 406, 415].includes(postResponse.status)) {
+      let getRequest = HttpClientRequest.get(url.toString()).pipe(
+        HttpClientRequest.setHeader("accept", "text/event-stream")
+      );
+      for (const [name, value] of Object.entries(options.headers ?? {})) {
+        getRequest = HttpClientRequest.setHeader(getRequest, name, value);
+      }
+      const getResponse = yield* client.execute(getRequest).pipe(Effect5.timeout(Duration.millis(timeoutMs)));
+      const getResult = yield* classify(getResponse, "GET");
+      if (getResult) return getResult;
+    }
+    return {
+      kind: "not-mcp",
+      category: "wrong-shape",
+      reason: `unexpected status ${postResponse.status} for initialize`
+    };
+  }).pipe(
+    Effect5.provide(options.httpClientLayer ?? FetchHttpClient.layer),
+    Effect5.mapError(
+      (cause) => new ProbeTransportError({
+        reason: reasonFromBoundaryCause(cause),
+        cause
+      })
+    ),
+    Effect5.catch(
+      (cause) => Effect5.succeed({
+        kind: "unreachable",
+        reason: cause.reason
+      })
+    )
+  );
+  return outcome;
+}).pipe(Effect5.withSpan("mcp.plugin.probe_shape"));
+
+// src/sdk/plugin.ts
+import {
+  SECRET_REF_PREFIX
+} from "@executor-js/config";
+var toStoredSourceData = (config, remoteCredentials) => {
+  if (config.transport === "stdio") {
+    return {
+      transport: "stdio",
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      cwd: config.cwd
+    };
+  }
+  return {
+    transport: "remote",
+    endpoint: config.endpoint,
+    remoteTransport: config.remoteTransport ?? "auto",
+    queryParams: remoteCredentials?.queryParams,
+    headers: remoteCredentials?.headers,
+    auth: remoteCredentials?.auth ?? { kind: "none" }
+  };
+};
+var normalizeNamespace = (config) => config.namespace ?? deriveMcpNamespace({
+  name: config.name,
+  endpoint: config.transport === "remote" ? config.endpoint : void 0,
+  command: config.transport === "stdio" ? config.command : void 0
+});
+var toBinding = (entry) => new McpToolBinding({
+  toolId: entry.toolId,
+  toolName: entry.toolName,
+  description: entry.description,
+  inputSchema: entry.inputSchema,
+  outputSchema: entry.outputSchema,
+  annotations: entry.annotations
+});
+var MCP_PLUGIN_ID = "mcp";
+var urlMatchesToken = (url, token) => {
+  const re = new RegExp(`(?:^|[^a-z0-9])${token}(?:$|[^a-z0-9])`, "i");
+  return re.test(url.hostname) || re.test(url.pathname);
+};
+var userFacingProbeMessage = (shape) => {
+  if (shape.kind === "unreachable") {
+    return "Couldn't reach this URL. Check the address, your network, and that the server is running.";
+  }
+  return Match.value(shape.category).pipe(
+    Match.when(
+      "auth-required",
+      () => "This server requires authentication. Add credentials (Authorization header, query parameter, or API key) below and retry."
+    ),
+    Match.when(
+      "wrong-shape",
+      () => "This URL doesn't appear to host an MCP server. Double-check the address, including the path."
+    ),
+    Match.exhaustive
+  );
+};
+var scopeRanks = (ctx) => new Map(ctx.scopes.map((scope, index) => [String(scope.id), index]));
+var scopeRank = (ranks, scopeId) => ranks.get(scopeId) ?? Infinity;
+var coreBindingToMcpBinding = (binding) => new McpSourceBindingRef({
+  sourceId: binding.sourceId,
+  sourceScopeId: binding.sourceScopeId,
+  scopeId: binding.scopeId,
+  slot: binding.slotKey,
+  value: binding.value,
+  createdAt: binding.createdAt,
+  updatedAt: binding.updatedAt
+});
+var listMcpSourceBindings = (ctx, sourceId, sourceScope) => Effect6.gen(function* () {
+  const ranks = scopeRanks(ctx);
+  const sourceSourceRank = scopeRank(ranks, sourceScope);
+  if (sourceSourceRank === Infinity) return [];
+  const bindings = yield* ctx.credentialBindings.listForSource({
+    pluginId: MCP_PLUGIN_ID,
+    sourceId,
+    sourceScope: ScopeId.make(sourceScope)
+  });
+  return bindings.filter((binding) => scopeRank(ranks, binding.scopeId) <= sourceSourceRank).map(coreBindingToMcpBinding);
+});
+var resolveMcpSourceBinding = (ctx, sourceId, sourceScope, slot) => Effect6.gen(function* () {
+  const ranks = scopeRanks(ctx);
+  const sourceSourceRank = scopeRank(ranks, sourceScope);
+  if (sourceSourceRank === Infinity) return null;
+  const bindings = yield* ctx.credentialBindings.listForSource({
+    pluginId: MCP_PLUGIN_ID,
+    sourceId,
+    sourceScope: ScopeId.make(sourceScope)
+  });
+  const binding = bindings.filter(
+    (candidate) => candidate.slotKey === slot && scopeRank(ranks, candidate.scopeId) <= sourceSourceRank
+  ).sort((a, b) => scopeRank(ranks, a.scopeId) - scopeRank(ranks, b.scopeId))[0];
+  return binding ? coreBindingToMcpBinding(binding) : null;
+});
+var validateMcpBindingTarget = (ctx, input) => Effect6.gen(function* () {
+  const ranks = scopeRanks(ctx);
+  const sourceSourceRank = scopeRank(ranks, input.sourceScope);
+  const targetRank = scopeRank(ranks, input.targetScope);
+  const scopeList = `[${ctx.scopes.map((s) => s.id).join(", ")}]`;
+  if (sourceSourceRank === Infinity) {
+    return yield* new StorageError({
+      message: `MCP source binding references source scope "${input.sourceScope}" which is not in the executor's scope stack ${scopeList}.`,
+      cause: void 0
+    });
+  }
+  if (targetRank === Infinity) {
+    return yield* new StorageError({
+      message: `MCP source binding targets scope "${input.targetScope}" which is not in the executor's scope stack ${scopeList}.`,
+      cause: void 0
+    });
+  }
+  if (targetRank > sourceSourceRank) {
+    return yield* new StorageError({
+      message: `MCP source bindings for "${input.sourceId}" cannot be written at outer scope "${input.targetScope}" because the base source lives at "${input.sourceScope}"`,
+      cause: void 0
+    });
+  }
+});
+var bindingTargetScope = (targetScope, bindings) => {
+  if (bindings.length === 0) return Effect6.succeed(void 0);
+  if (targetScope) return Effect6.succeed(targetScope);
+  return Effect6.fail(
+    new McpConnectionError({
+      transport: "remote",
+      message: "credentialTargetScope is required when adding direct MCP credentials"
+    })
+  );
+};
+var targetScopeForBinding = (fallbackTargetScope, binding) => {
+  const targetScope = binding.targetScope ?? fallbackTargetScope;
+  if (targetScope) return Effect6.succeed(targetScope);
+  return Effect6.fail(
+    new McpConnectionError({
+      transport: "remote",
+      message: "credentialTargetScope is required when adding direct MCP credentials"
+    })
+  );
+};
+var canonicalizeCredentialMap = (values, slotForName) => {
+  const nextValues = {};
+  const bindings = [];
+  for (const [name, value] of Object.entries(values ?? {})) {
+    if (typeof value === "string") {
+      nextValues[name] = value;
+      continue;
+    }
+    if ("kind" in value) {
+      nextValues[name] = value;
+      continue;
+    }
+    const slot = slotForName(name);
+    nextValues[name] = new ConfiguredCredentialBinding2({
+      kind: "binding",
+      slot,
+      prefix: value.prefix
+    });
+    bindings.push({
+      slot,
+      targetScope: "targetScope" in value ? value.targetScope : void 0,
+      value: {
+        kind: "secret",
+        secretId: SecretId.make(value.secretId),
+        ..."secretScopeId" in value && value.secretScopeId ? { secretScopeId: value.secretScopeId } : {}
+      }
+    });
+  }
+  return { values: nextValues, bindings };
+};
+var canonicalizeAuth = (auth) => {
+  if (!auth || auth.kind === "none") return { auth: { kind: "none" }, bindings: [] };
+  if (auth.kind === "header") {
+    if ("secretSlot" in auth) return { auth, bindings: [] };
+    return {
+      auth: {
+        kind: "header",
+        headerName: auth.headerName,
+        secretSlot: MCP_HEADER_AUTH_SLOT,
+        prefix: auth.prefix
+      },
+      bindings: [
+        {
+          slot: MCP_HEADER_AUTH_SLOT,
+          targetScope: auth.targetScope,
+          value: {
+            kind: "secret",
+            secretId: SecretId.make(auth.secretId),
+            ...auth.secretScopeId ? { secretScopeId: auth.secretScopeId } : {}
+          }
+        }
+      ]
+    };
+  }
+  if ("connectionSlot" in auth) return { auth, bindings: [] };
+  const bindings = [
+    {
+      slot: MCP_OAUTH_CONNECTION_SLOT,
+      value: {
+        kind: "connection",
+        connectionId: ConnectionId.make(auth.connectionId)
+      }
+    }
+  ];
+  if (auth.clientIdSecretId) {
+    bindings.push({
+      slot: MCP_OAUTH_CLIENT_ID_SLOT,
+      value: { kind: "secret", secretId: SecretId.make(auth.clientIdSecretId) }
+    });
+  }
+  if (auth.clientSecretSecretId) {
+    bindings.push({
+      slot: MCP_OAUTH_CLIENT_SECRET_SLOT,
+      value: { kind: "secret", secretId: SecretId.make(auth.clientSecretSecretId) }
+    });
+  }
+  return {
+    auth: {
+      kind: "oauth2",
+      connectionSlot: MCP_OAUTH_CONNECTION_SLOT,
+      ...auth.clientIdSecretId ? { clientIdSlot: MCP_OAUTH_CLIENT_ID_SLOT } : {},
+      ...auth.clientSecretSecretId ? { clientSecretSlot: MCP_OAUTH_CLIENT_SECRET_SLOT } : {}
+    },
+    bindings
+  };
+};
+var makeOAuthProvider = (accessToken) => ({
+  get redirectUrl() {
+    return "http://localhost/oauth/callback";
+  },
+  get clientMetadata() {
+    return {
+      redirect_uris: ["http://localhost/oauth/callback"],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+      client_name: "Executor"
+    };
+  },
+  clientInformation: () => void 0,
+  saveClientInformation: () => void 0,
+  tokens: () => ({ access_token: accessToken, token_type: "Bearer" }),
+  saveTokens: () => void 0,
+  redirectToAuthorization: async () => {
+    throw new Error("MCP OAuth re-authorization required");
+  },
+  saveCodeVerifier: () => void 0,
+  codeVerifier: () => {
+    throw new Error("No active PKCE verifier");
+  },
+  saveDiscoveryState: () => void 0,
+  discoveryState: () => void 0
+});
+var resolveSecretBackedMap = (values, ctx) => resolveSharedSecretBackedMap({
+  values,
+  getSecret: ctx.secrets.get,
+  onMissing: (_name, value) => new McpConnectionError({
+    transport: "remote",
+    message: `Failed to resolve secret "${value.secretId}"`
+  }),
+  onError: (err, _name, value) => Predicate2.isTagged("SecretOwnedByConnectionError")(err) ? new McpConnectionError({
+    transport: "remote",
+    message: `Failed to resolve secret "${value.secretId}"`
+  }) : err
+}).pipe(
+  Effect6.mapError(
+    (err) => Predicate2.isTagged("SecretOwnedByConnectionError")(err) ? new McpConnectionError({ transport: "remote", message: "Failed to resolve secret" }) : err
+  )
+);
+var plainStringMap = (values) => {
+  if (!values) return void 0;
+  const entries = Object.entries(values).filter(
+    (entry) => typeof entry[1] === "string"
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+var resolveMcpBindingValueMap = (ctx, values, params) => Effect6.gen(function* () {
+  if (!values) return void 0;
+  const resolved = {};
+  for (const [name, value] of Object.entries(values)) {
+    if (typeof value === "string") {
+      resolved[name] = value;
+      continue;
+    }
+    const binding = yield* resolveMcpSourceBinding(
+      ctx,
+      params.sourceId,
+      params.sourceScope,
+      value.slot
+    );
+    if (binding?.value.kind === "secret") {
+      const secret = yield* ctx.secrets.getAtScope(binding.value.secretId, binding.scopeId).pipe(
+        Effect6.catchTag(
+          "SecretOwnedByConnectionError",
+          () => Effect6.fail(
+            new McpConnectionError({
+              transport: "remote",
+              message: `Failed to resolve secret for ${params.missingLabel} "${name}"`
+            })
+          )
+        )
+      );
+      if (secret === null) {
+        return yield* new McpConnectionError({
+          transport: "remote",
+          message: `Missing secret "${binding.value.secretId}" for ${params.missingLabel} "${name}"`
+        });
+      }
+      resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
+      continue;
+    }
+    if (binding?.value.kind === "text") {
+      resolved[name] = value.prefix ? `${value.prefix}${binding.value.text}` : binding.value.text;
+      continue;
+    }
+    return yield* new McpConnectionError({
+      transport: "remote",
+      message: `Missing binding for ${params.missingLabel} "${name}"`
+    });
+  }
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+});
+var resolveMcpCredentialInputMap = (ctx, values, params) => Effect6.gen(function* () {
+  if (!values) return void 0;
+  const resolved = {};
+  for (const [name, value] of Object.entries(values)) {
+    if (typeof value === "string") {
+      resolved[name] = value;
+      continue;
+    }
+    if ("kind" in value) {
+      const slotResolved = yield* resolveMcpBindingValueMap(
+        ctx,
+        { [name]: value },
+        {
+          sourceId: params.sourceId,
+          sourceScope: params.sourceScope,
+          missingLabel: params.missingLabel
+        }
+      );
+      if (slotResolved?.[name] !== void 0) resolved[name] = slotResolved[name];
+      continue;
+    }
+    const secretScope = "secretScopeId" in value ? value.secretScopeId ?? value.targetScope : params.targetScope ?? params.sourceScope;
+    const secret = yield* ctx.secrets.getAtScope(SecretId.make(value.secretId), secretScope).pipe(
+      Effect6.catchTag(
+        "SecretOwnedByConnectionError",
+        () => Effect6.fail(
+          new McpConnectionError({
+            transport: "remote",
+            message: `Failed to resolve secret for ${params.missingLabel} "${name}"`
+          })
+        )
+      )
+    );
+    if (secret === null) {
+      return yield* new McpConnectionError({
+        transport: "remote",
+        message: `Missing secret "${value.secretId}" for ${params.missingLabel} "${name}"`
+      });
+    }
+    resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
+  }
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+});
+var resolveMcpHeaderAuth = (ctx, sourceId, sourceScope, auth) => Effect6.gen(function* () {
+  if (auth.kind !== "header") return {};
+  const binding = yield* resolveMcpSourceBinding(ctx, sourceId, sourceScope, auth.secretSlot);
+  if (binding?.value.kind === "secret") {
+    const secret = yield* ctx.secrets.getAtScope(binding.value.secretId, binding.scopeId).pipe(
+      Effect6.catchTag(
+        "SecretOwnedByConnectionError",
+        () => Effect6.fail(
+          new McpConnectionError({
+            transport: "remote",
+            message: `Failed to resolve header auth binding "${auth.secretSlot}"`
+          })
+        )
+      )
+    );
+    if (secret === null) {
+      return yield* new McpConnectionError({
+        transport: "remote",
+        message: `Missing secret for header auth binding "${auth.secretSlot}"`
+      });
+    }
+    return { [auth.headerName]: auth.prefix ? `${auth.prefix}${secret}` : secret };
+  }
+  if (binding?.value.kind === "text") {
+    return {
+      [auth.headerName]: auth.prefix ? `${auth.prefix}${binding.value.text}` : binding.value.text
+    };
+  }
+  return yield* new McpConnectionError({
+    transport: "remote",
+    message: `Missing header auth binding "${auth.secretSlot}"`
+  });
+});
+var resolveMcpStoredOauthProvider = (ctx, sourceId, sourceScope, auth) => Effect6.gen(function* () {
+  if (auth.kind !== "oauth2") return void 0;
+  const binding = yield* resolveMcpSourceBinding(ctx, sourceId, sourceScope, auth.connectionSlot);
+  if (binding?.value.kind !== "connection") {
+    return yield* new McpConnectionError({
+      transport: "remote",
+      message: `Missing OAuth connection binding for MCP source "${sourceId}"`
+    });
+  }
+  const connectionId = binding.value.connectionId;
+  const accessToken = yield* ctx.connections.accessTokenAtScope(connectionId, binding.scopeId).pipe(
+    Effect6.mapError(
+      ({ message }) => new McpConnectionError({
+        transport: "remote",
+        message: `Failed to resolve OAuth connection "${connectionId}": ${message}`
+      })
+    )
+  );
+  return makeOAuthProvider(accessToken);
+});
+var resolveMcpInputAuth = (ctx, sourceId, sourceScope, targetScope, auth) => Effect6.gen(function* () {
+  if (!auth || auth.kind === "none") return { headers: {} };
+  if (auth.kind === "header") {
+    if ("secretSlot" in auth) {
+      const headers = yield* resolveMcpHeaderAuth(ctx, sourceId, sourceScope, auth);
+      return { headers };
+    }
+    const secretScope = auth.secretScopeId ?? auth.targetScope ?? targetScope ?? sourceScope;
+    const secret = yield* ctx.secrets.getAtScope(SecretId.make(auth.secretId), secretScope).pipe(
+      Effect6.catchTag(
+        "SecretOwnedByConnectionError",
+        () => Effect6.fail(
+          new McpConnectionError({
+            transport: "remote",
+            message: `Failed to resolve secret "${auth.secretId}"`
+          })
+        )
+      )
+    );
+    if (secret === null) {
+      return yield* new McpConnectionError({
+        transport: "remote",
+        message: `Failed to resolve secret "${auth.secretId}"`
+      });
+    }
+    return {
+      headers: { [auth.headerName]: auth.prefix ? `${auth.prefix}${secret}` : secret }
+    };
+  }
+  const connection = "connectionId" in auth ? { id: ConnectionId.make(auth.connectionId), scope: targetScope ?? sourceScope } : yield* Effect6.gen(function* () {
+    const binding = yield* resolveMcpSourceBinding(
+      ctx,
+      sourceId,
+      sourceScope,
+      auth.connectionSlot
+    );
+    return binding?.value.kind === "connection" ? { id: binding.value.connectionId, scope: binding.scopeId } : null;
+  });
+  if (connection === null) {
+    return yield* new McpConnectionError({
+      transport: "remote",
+      message: `Missing OAuth connection binding for MCP source "${sourceId}"`
+    });
+  }
+  const accessToken = yield* ctx.connections.accessTokenAtScope(connection.id, connection.scope).pipe(
+    Effect6.mapError(
+      ({ message }) => new McpConnectionError({
+        transport: "remote",
+        message: `Failed to resolve OAuth connection "${connection.id}": ${message}`
+      })
+    )
+  );
+  return { headers: {}, authProvider: makeOAuthProvider(accessToken) };
+});
+var resolveConnectorInput = (sourceId, sourceScope, sd, ctx, allowStdio) => {
+  if (sd.transport === "stdio") {
+    if (!allowStdio) {
+      return Effect6.fail(
+        new McpConnectionError({
+          transport: "stdio",
+          message: "MCP stdio transport is disabled. Enable it by passing `dangerouslyAllowStdioMCP: true` to mcpPlugin() \u2014 only safe for trusted local contexts."
+        })
+      );
+    }
+    return Effect6.succeed({
+      transport: "stdio",
+      command: sd.command,
+      args: sd.args,
+      env: sd.env,
+      cwd: sd.cwd
+    });
+  }
+  return Effect6.gen(function* () {
+    const resolvedHeaders = yield* resolveMcpBindingValueMap(ctx, sd.headers, {
+      sourceId,
+      sourceScope,
+      missingLabel: "header"
+    });
+    const resolvedQueryParams = yield* resolveMcpBindingValueMap(ctx, sd.queryParams, {
+      sourceId,
+      sourceScope,
+      missingLabel: "query parameter"
+    });
+    const headers = { ...resolvedHeaders ?? {} };
+    const auth = sd.auth;
+    if (auth.kind === "header") {
+      Object.assign(headers, yield* resolveMcpHeaderAuth(ctx, sourceId, sourceScope, auth));
+    }
+    const authProvider = yield* resolveMcpStoredOauthProvider(ctx, sourceId, sourceScope, auth);
+    return {
+      transport: "remote",
+      endpoint: sd.endpoint,
+      remoteTransport: sd.remoteTransport,
+      queryParams: resolvedQueryParams,
+      headers: Object.keys(headers).length > 0 ? headers : void 0,
+      authProvider
+    };
+  });
+};
+var makeRuntime = () => Effect6.gen(function* () {
+  const cacheScope = yield* Scope.make();
+  const pendingConnectors = /* @__PURE__ */ new Map();
+  const connectionCache = yield* ScopedCache2.make({
+    lookup: (key) => Effect6.acquireRelease(
+      Effect6.suspend(() => {
+        const connector = pendingConnectors.get(key);
+        if (!connector) {
+          return Effect6.fail(
+            new McpConnectionError({
+              transport: "auto",
+              message: `No pending connector for key: ${key}`
+            })
+          );
+        }
+        return connector;
+      }),
+      (connection) => Effect6.ignore(
+        Effect6.tryPromise({
+          try: () => connection.close(),
+          catch: () => new McpConnectionError({
+            transport: "auto",
+            message: "Failed to close MCP connection"
+          })
+        })
+      )
+    ),
+    capacity: 64,
+    timeToLive: Duration2.minutes(5)
+  }).pipe(Scope.provide(cacheScope));
+  return { connectionCache, pendingConnectors, cacheScope };
+});
+var secretRef = (id) => `${SECRET_REF_PREFIX}${id}`;
+var authToConfig = (auth) => {
+  if (!auth) return void 0;
+  if (auth.kind === "none") return { kind: "none" };
+  if (auth.kind === "header") {
+    if (!("secretId" in auth)) return void 0;
+    return {
+      kind: "header",
+      headerName: auth.headerName,
+      secret: secretRef(auth.secretId),
+      prefix: auth.prefix
+    };
+  }
+  if (!("connectionId" in auth)) return void 0;
+  return {
+    kind: "oauth2",
+    connectionId: auth.connectionId
+  };
+};
+var toMcpConfigEntry = (namespace, sourceName, config) => {
+  if (config.transport === "stdio") {
+    const entry2 = {
+      kind: "mcp",
+      transport: "stdio",
+      name: sourceName,
+      command: config.command,
+      args: config.args,
+      env: config.env,
+      cwd: config.cwd,
+      namespace
+    };
+    return entry2;
+  }
+  const entry = {
+    kind: "mcp",
+    transport: "remote",
+    name: sourceName,
+    endpoint: config.endpoint,
+    remoteTransport: config.remoteTransport,
+    queryParams: plainStringMap(config.queryParams),
+    headers: plainStringMap(config.headers),
+    namespace,
+    auth: authToConfig(config.auth)
+  };
+  return entry;
+};
+var mcpPlugin = definePlugin((options) => {
+  const allowStdio = options?.dangerouslyAllowStdioMCP ?? false;
+  const runtimeRef = { current: null };
+  const ensureRuntime = () => runtimeRef.current ? Effect6.succeed(runtimeRef.current) : makeRuntime().pipe(
+    Effect6.tap(
+      (rt) => Effect6.sync(() => {
+        runtimeRef.current = rt;
+      })
+    )
+  );
+  return {
+    id: "mcp",
+    packageName: "@executor-js/plugin-mcp",
+    // Surfaced to the client bundle via the Vite plugin (see
+    // `@executor-js/vite-plugin`). The MCP `./client` factory reads
+    // `allowStdio` and gates the stdio tab + presets in AddMcpSource —
+    // so the server's `dangerouslyAllowStdioMCP` flag is the single
+    // source of truth for both runtime and UI.
+    clientConfig: { allowStdio },
+    schema: mcpSchema,
+    storage: (deps) => makeMcpStore(deps),
+    extension: (ctx) => {
+      const httpClientLayer = options?.httpClientLayer ?? ctx.httpClientLayer;
+      const probeEndpoint = (input) => Effect6.gen(function* () {
+        const endpoint = typeof input === "string" ? input : input.endpoint;
+        const trimmed = endpoint.trim();
+        if (!trimmed) {
+          return yield* new McpConnectionError({
+            transport: "remote",
+            message: "Endpoint URL is required"
+          });
+        }
+        const name = yield* Effect6.try({
+          try: () => new URL(trimmed).hostname,
+          catch: () => "mcp"
+        }).pipe(Effect6.orElseSucceed(() => "mcp"));
+        const namespace = deriveMcpNamespace({ endpoint: trimmed });
+        const probeHeaders = typeof input === "string" ? void 0 : yield* resolveSecretBackedMap(input.headers, ctx);
+        const probeQueryParams = typeof input === "string" ? void 0 : yield* resolveSecretBackedMap(input.queryParams, ctx);
+        const connector = createMcpConnector({
+          transport: "remote",
+          endpoint: trimmed,
+          headers: probeHeaders,
+          queryParams: probeQueryParams
+        });
+        const result = yield* discoverTools(connector).pipe(
+          Effect6.map((m) => ({ ok: true, manifest: m })),
+          Effect6.catch(() => Effect6.succeed({ ok: false, manifest: null })),
+          Effect6.withSpan("mcp.plugin.discover_tools")
+        );
+        if (result.ok && result.manifest) {
+          return {
+            connected: true,
+            requiresOAuth: false,
+            supportsDynamicRegistration: false,
+            name: result.manifest.server?.name ?? name,
+            namespace,
+            toolCount: result.manifest.tools.length,
+            serverName: result.manifest.server?.name ?? null
+          };
+        }
+        const shape = yield* probeMcpEndpointShape(trimmed, {
+          httpClientLayer,
+          headers: probeHeaders,
+          queryParams: probeQueryParams
+        });
+        if (shape.kind !== "mcp") {
+          return yield* new McpConnectionError({
+            transport: "remote",
+            message: userFacingProbeMessage(shape)
+          });
+        }
+        const probeResult = yield* ctx.oauth.probe({
+          endpoint: trimmed,
+          headers: probeHeaders,
+          queryParams: probeQueryParams
+        }).pipe(
+          Effect6.map((oauth) => ({ ok: true, oauth })),
+          Effect6.catch(() => Effect6.succeed({ ok: false, oauth: null })),
+          Effect6.withSpan("mcp.plugin.probe_oauth")
+        );
+        if (probeResult.ok) {
+          return {
+            connected: false,
+            requiresOAuth: true,
+            supportsDynamicRegistration: probeResult.oauth.supportsDynamicRegistration,
+            name,
+            namespace,
+            toolCount: null,
+            serverName: null
+          };
+        }
+        return yield* new McpConnectionError({
+          transport: "remote",
+          message: "This server requires authentication, but OAuth metadata wasn't found. Add credentials (Authorization header, query parameter, or API key) below and retry."
+        });
+      }).pipe(
+        Effect6.withSpan("mcp.plugin.probe_endpoint", {
+          attributes: { "mcp.endpoint": typeof input === "string" ? input : input.endpoint }
+        })
+      );
+      const configFile = options?.configFile;
+      const addSource = (config) => Effect6.gen(function* () {
+        const namespace = normalizeNamespace(config);
+        const canonicalRemote = config.transport === "remote" ? {
+          headers: canonicalizeCredentialMap(config.headers, mcpHeaderSlot),
+          queryParams: canonicalizeCredentialMap(config.queryParams, mcpQueryParamSlot),
+          auth: canonicalizeAuth(config.auth)
+        } : null;
+        const directBindings = canonicalRemote ? [
+          ...canonicalRemote.headers.bindings,
+          ...canonicalRemote.queryParams.bindings,
+          ...canonicalRemote.auth.bindings
+        ] : [];
+        for (const binding of directBindings) {
+          const bindingTargetScope2 = yield* targetScopeForBinding(
+            config.transport === "remote" ? config.credentialTargetScope : void 0,
+            binding
+          );
+          yield* validateMcpBindingTarget(ctx, {
+            sourceId: namespace,
+            sourceScope: config.scope,
+            targetScope: bindingTargetScope2
+          });
+        }
+        const targetScope = config.transport === "remote" && directBindings[0] ? yield* targetScopeForBinding(config.credentialTargetScope, directBindings[0]) : void 0;
+        const sd = toStoredSourceData(
+          config,
+          canonicalRemote ? {
+            headers: canonicalRemote.headers.values,
+            queryParams: canonicalRemote.queryParams.values,
+            auth: canonicalRemote.auth.auth
+          } : void 0
+        );
+        const resolved = yield* (config.transport === "remote" ? Effect6.gen(function* () {
+          const resolvedHeaders = yield* resolveMcpCredentialInputMap(ctx, config.headers, {
+            sourceId: namespace,
+            sourceScope: config.scope,
+            targetScope,
+            missingLabel: "header"
+          });
+          const resolvedQueryParams = yield* resolveMcpCredentialInputMap(
+            ctx,
+            config.queryParams,
+            {
+              sourceId: namespace,
+              sourceScope: config.scope,
+              targetScope,
+              missingLabel: "query parameter"
+            }
+          );
+          const resolvedAuth = yield* resolveMcpInputAuth(
+            ctx,
+            namespace,
+            config.scope,
+            targetScope,
+            config.auth
+          );
+          const headers = {
+            ...resolvedHeaders ?? {},
+            ...resolvedAuth.headers
+          };
+          return {
+            transport: "remote",
+            endpoint: config.endpoint,
+            remoteTransport: config.remoteTransport ?? "auto",
+            queryParams: resolvedQueryParams,
+            headers: Object.keys(headers).length > 0 ? headers : void 0,
+            authProvider: resolvedAuth.authProvider
+          };
+        }) : resolveConnectorInput(namespace, config.scope, sd, ctx, allowStdio)).pipe(
+          Effect6.result,
+          Effect6.withSpan("mcp.plugin.resolve_connector", {
+            attributes: {
+              "mcp.source.namespace": namespace,
+              "mcp.source.transport": sd.transport
+            }
+          })
+        );
+        if (Result.isFailure(resolved) && sd.transport === "stdio") {
+          return yield* Effect6.fail(resolved.failure);
+        }
+        const discovery = Result.isSuccess(resolved) ? yield* discoverTools(createMcpConnector(resolved.success)).pipe(
+          Effect6.mapError(
+            ({ message }) => new McpToolDiscoveryError({
+              stage: "list_tools",
+              message: `MCP discovery failed: ${message}`
+            })
+          ),
+          Effect6.result,
+          Effect6.withSpan("mcp.plugin.discover_tools", {
+            attributes: { "mcp.source.namespace": namespace }
+          })
+        ) : Result.fail(resolved.failure);
+        const manifest = Result.isSuccess(discovery) ? discovery.success : { server: void 0, tools: [] };
+        const sourceName = config.name ?? manifest.server?.name ?? namespace;
+        yield* ctx.transaction(
+          Effect6.gen(function* () {
+            yield* ctx.storage.removeBindingsByNamespace(namespace, config.scope);
+            yield* ctx.storage.removeSource(namespace, config.scope);
+            yield* ctx.storage.putSource({
+              namespace,
+              scope: config.scope,
+              name: sourceName,
+              config: sd
+            });
+            yield* ctx.storage.putBindings(
+              namespace,
+              config.scope,
+              manifest.tools.map((e) => ({
+                toolId: `${namespace}.${e.toolId}`,
+                binding: toBinding(e)
+              }))
+            );
+            yield* ctx.core.sources.register({
+              id: namespace,
+              scope: config.scope,
+              kind: "mcp",
+              name: sourceName,
+              url: sd.transport === "remote" ? sd.endpoint : void 0,
+              canRemove: true,
+              canRefresh: true,
+              canEdit: sd.transport === "remote",
+              tools: manifest.tools.map((e) => ({
+                name: e.toolId,
+                description: e.description ?? `MCP tool: ${e.toolName}`,
+                inputSchema: e.inputSchema,
+                outputSchema: e.outputSchema
+              }))
+            });
+            if (directBindings.length > 0) {
+              for (const binding of directBindings) {
+                const bindingTargetScope2 = yield* targetScopeForBinding(
+                  config.transport === "remote" ? config.credentialTargetScope : void 0,
+                  binding
+                );
+                yield* ctx.credentialBindings.set({
+                  targetScope: ScopeId.make(bindingTargetScope2),
+                  pluginId: MCP_PLUGIN_ID,
+                  sourceId: namespace,
+                  sourceScope: ScopeId.make(config.scope),
+                  slotKey: binding.slot,
+                  value: binding.value
+                });
+              }
+            }
+          })
+        ).pipe(
+          Effect6.withSpan("mcp.plugin.persist_source", {
+            attributes: {
+              "mcp.source.namespace": namespace,
+              "mcp.source.tool_count": manifest.tools.length
+            }
+          })
+        );
+        if (configFile) {
+          yield* configFile.upsertSource(toMcpConfigEntry(namespace, sourceName, config)).pipe(Effect6.withSpan("mcp.plugin.config_file.upsert"));
+        }
+        if (Result.isFailure(discovery)) {
+          return yield* Effect6.fail(discovery.failure);
+        }
+        return { toolCount: manifest.tools.length, namespace };
+      }).pipe(
+        Effect6.withSpan("mcp.plugin.add_source", {
+          attributes: {
+            "mcp.source.transport": config.transport,
+            "mcp.source.name": config.name
+          }
+        })
+      );
+      const removeSource = (namespace, scope) => Effect6.gen(function* () {
+        yield* ctx.transaction(
+          Effect6.gen(function* () {
+            yield* ctx.credentialBindings.removeForSource({
+              pluginId: MCP_PLUGIN_ID,
+              sourceId: namespace,
+              sourceScope: ScopeId.make(scope)
+            });
+            yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
+            yield* ctx.storage.removeSource(namespace, scope);
+            yield* ctx.core.sources.unregister({ id: namespace, targetScope: scope });
+          })
+        ).pipe(Effect6.withSpan("mcp.plugin.persist_remove"));
+        if (configFile) {
+          yield* configFile.removeSource(namespace).pipe(Effect6.withSpan("mcp.plugin.config_file.remove"));
+        }
+      }).pipe(
+        Effect6.withSpan("mcp.plugin.remove_source", {
+          attributes: { "mcp.source.namespace": namespace }
+        })
+      );
+      const refreshSource = (namespace, scope) => Effect6.gen(function* () {
+        const sd = yield* ctx.storage.getSourceConfig(namespace, scope).pipe(
+          Effect6.withSpan("mcp.plugin.load_source_config", {
+            attributes: { "mcp.source.namespace": namespace }
+          })
+        );
+        if (!sd) {
+          return yield* new McpConnectionError({
+            transport: "remote",
+            message: `No stored config for MCP source "${namespace}"`
+          });
+        }
+        const ci = yield* resolveConnectorInput(namespace, scope, sd, ctx, allowStdio).pipe(
+          Effect6.withSpan("mcp.plugin.resolve_connector", {
+            attributes: {
+              "mcp.source.namespace": namespace,
+              "mcp.source.transport": sd.transport
+            }
+          })
+        );
+        const manifest = yield* discoverTools(createMcpConnector(ci)).pipe(
+          Effect6.mapError(
+            ({ message }) => new McpToolDiscoveryError({
+              stage: "list_tools",
+              message: `MCP refresh failed: ${message}`
+            })
+          ),
+          Effect6.withSpan("mcp.plugin.discover_tools", {
+            attributes: { "mcp.source.namespace": namespace }
+          })
+        );
+        const existing = yield* ctx.storage.getSource(namespace, scope);
+        const sourceName = manifest.server?.name ?? existing?.name ?? namespace;
+        yield* ctx.transaction(
+          Effect6.gen(function* () {
+            yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
+            yield* ctx.core.sources.unregister({ id: namespace, targetScope: scope });
+            yield* ctx.storage.putBindings(
+              namespace,
+              scope,
+              manifest.tools.map((e) => ({
+                toolId: `${namespace}.${e.toolId}`,
+                binding: toBinding(e)
+              }))
+            );
+            yield* ctx.core.sources.register({
+              id: namespace,
+              scope,
+              kind: "mcp",
+              name: sourceName,
+              url: sd.transport === "remote" ? sd.endpoint : void 0,
+              canRemove: true,
+              canRefresh: true,
+              canEdit: sd.transport === "remote",
+              tools: manifest.tools.map((e) => ({
+                name: e.toolId,
+                description: e.description ?? `MCP tool: ${e.toolName}`,
+                inputSchema: e.inputSchema,
+                outputSchema: e.outputSchema
+              }))
+            });
+          })
+        ).pipe(
+          Effect6.withSpan("mcp.plugin.persist_source", {
+            attributes: {
+              "mcp.source.namespace": namespace,
+              "mcp.source.tool_count": manifest.tools.length
+            }
+          })
+        );
+        return { toolCount: manifest.tools.length };
+      }).pipe(
+        Effect6.withSpan("mcp.plugin.refresh_source", {
+          attributes: { "mcp.source.namespace": namespace }
+        })
+      );
+      const updateSource = (namespace, scope, input) => Effect6.gen(function* () {
+        const existing = yield* ctx.storage.getSource(namespace, scope);
+        if (!existing || existing.config.transport !== "remote") return;
+        const canonicalHeaders = input.headers !== void 0 ? canonicalizeCredentialMap(input.headers, mcpHeaderSlot) : null;
+        const canonicalQueryParams = input.queryParams !== void 0 ? canonicalizeCredentialMap(input.queryParams, mcpQueryParamSlot) : null;
+        const canonicalAuth = input.auth !== void 0 ? canonicalizeAuth(input.auth) : null;
+        const directBindings = [
+          ...canonicalHeaders?.bindings ?? [],
+          ...canonicalQueryParams?.bindings ?? [],
+          ...canonicalAuth?.bindings ?? []
+        ];
+        const targetScope = yield* bindingTargetScope(
+          input.credentialTargetScope,
+          directBindings
+        );
+        if (targetScope) {
+          yield* validateMcpBindingTarget(ctx, {
+            sourceId: namespace,
+            sourceScope: scope,
+            targetScope
+          });
+        }
+        const remote = existing.config;
+        const updatedConfig = {
+          ...remote,
+          ...input.endpoint !== void 0 ? { endpoint: input.endpoint } : {},
+          ...canonicalHeaders ? { headers: canonicalHeaders.values } : {},
+          ...canonicalAuth ? { auth: canonicalAuth.auth } : {},
+          ...canonicalQueryParams ? { queryParams: canonicalQueryParams.values } : {}
+        };
+        const affectedPrefixes = [
+          ...input.headers !== void 0 ? ["header:"] : [],
+          ...input.queryParams !== void 0 ? ["query_param:"] : [],
+          ...input.auth !== void 0 ? ["auth:"] : []
+        ];
+        const replacementTargetScope = targetScope ?? input.credentialTargetScope ?? scope;
+        yield* ctx.transaction(
+          Effect6.gen(function* () {
+            yield* ctx.storage.putSource({
+              namespace,
+              scope,
+              name: input.name?.trim() || existing.name,
+              config: updatedConfig
+            });
+            if (affectedPrefixes.length > 0 || directBindings.length > 0) {
+              yield* ctx.credentialBindings.replaceForSource({
+                targetScope: ScopeId.make(replacementTargetScope),
+                pluginId: MCP_PLUGIN_ID,
+                sourceId: namespace,
+                sourceScope: ScopeId.make(scope),
+                slotPrefixes: affectedPrefixes,
+                bindings: directBindings.map((binding) => ({
+                  slotKey: binding.slot,
+                  value: binding.value
+                }))
+              });
+            }
+          })
+        );
+      }).pipe(
+        Effect6.withSpan("mcp.plugin.update_source", {
+          attributes: { "mcp.source.namespace": namespace }
+        })
+      );
+      const getSource = (namespace, scope) => ctx.storage.getSource(namespace, scope).pipe(
+        Effect6.withSpan("mcp.plugin.get_source", {
+          attributes: { "mcp.source.namespace": namespace }
+        })
+      );
+      return {
+        probeEndpoint,
+        addSource,
+        removeSource,
+        refreshSource,
+        getSource,
+        updateSource,
+        listSourceBindings: (sourceId, sourceScope) => listMcpSourceBindings(ctx, sourceId, sourceScope),
+        setSourceBinding: (input) => Effect6.gen(function* () {
+          yield* validateMcpBindingTarget(ctx, {
+            sourceId: input.sourceId,
+            sourceScope: input.sourceScope,
+            targetScope: input.scope
+          });
+          const binding = yield* ctx.credentialBindings.set({
+            targetScope: input.scope,
+            pluginId: MCP_PLUGIN_ID,
+            sourceId: input.sourceId,
+            sourceScope: input.sourceScope,
+            slotKey: input.slot,
+            value: input.value
+          });
+          return coreBindingToMcpBinding(binding);
+        }),
+        removeSourceBinding: (sourceId, sourceScope, slot, scope) => Effect6.gen(function* () {
+          yield* validateMcpBindingTarget(ctx, {
+            sourceId,
+            sourceScope,
+            targetScope: scope
+          });
+          yield* ctx.credentialBindings.remove({
+            targetScope: ScopeId.make(scope),
+            pluginId: MCP_PLUGIN_ID,
+            sourceId,
+            sourceScope: ScopeId.make(sourceScope),
+            slotKey: slot
+          });
+        })
+      };
+    },
+    invokeTool: ({ ctx, toolRow, args, elicit }) => Effect6.gen(function* () {
+      const runtime = yield* ensureRuntime();
+      const toolScope = toolRow.scope_id;
+      const entry = yield* ctx.storage.getBinding(toolRow.id, toolScope).pipe(
+        Effect6.withSpan("mcp.plugin.load_binding", {
+          attributes: { "mcp.tool.name": toolRow.id }
+        })
+      );
+      if (!entry) {
+        return yield* new McpInvocationError({
+          toolName: toolRow.id,
+          message: `No MCP binding found for tool "${toolRow.id}"`
+        });
+      }
+      const sd = yield* ctx.storage.getSourceConfig(entry.namespace, toolScope).pipe(
+        Effect6.withSpan("mcp.plugin.load_source_config", {
+          attributes: { "mcp.source.namespace": entry.namespace }
+        })
+      );
+      if (!sd) {
+        return yield* new McpConnectionError({
+          transport: "auto",
+          message: `No MCP source config for namespace "${entry.namespace}"`
+        });
+      }
+      return yield* invokeMcpTool({
+        toolId: toolRow.id,
+        toolName: entry.binding.toolName,
+        args,
+        sourceData: sd,
+        sourceId: entry.namespace,
+        sourceScope: toolScope,
+        invokerScope: ctx.scopes[0].id,
+        resolveConnector: () => resolveConnectorInput(entry.namespace, toolScope, sd, ctx, allowStdio).pipe(
+          Effect6.catchTags({
+            StorageError: () => Effect6.fail(
+              new McpConnectionError({
+                transport: sd.transport,
+                message: "Failed to resolve MCP connector storage state"
+              })
+            ),
+            UniqueViolationError: () => Effect6.fail(
+              new McpConnectionError({
+                transport: sd.transport,
+                message: "Failed to resolve MCP connector storage state"
+              })
+            )
+          }),
+          Effect6.flatMap((ci) => createMcpConnector(ci)),
+          Effect6.withSpan("mcp.plugin.resolve_connector", {
+            attributes: {
+              "mcp.source.namespace": entry.namespace,
+              "mcp.source.transport": sd.transport
+            }
+          })
+        ),
+        connectionCache: runtime.connectionCache,
+        pendingConnectors: runtime.pendingConnectors,
+        elicit
+      });
+    }).pipe(
+      Effect6.withSpan("mcp.plugin.invoke_tool", {
+        attributes: {
+          "mcp.tool.name": toolRow.id,
+          "mcp.tool.source_id": toolRow.source_id
+        }
+      })
+    ),
+    detect: ({ ctx, url }) => Effect6.gen(function* () {
+      const httpClientLayer = options?.httpClientLayer ?? ctx.httpClientLayer;
+      const trimmed = url.trim();
+      if (!trimmed) return null;
+      const parsed = yield* Effect6.try({
+        try: () => new URL(trimmed),
+        catch: (cause) => cause
+      }).pipe(Effect6.option);
+      if (Option5.isNone(parsed)) return null;
+      const name = parsed.value.hostname || "mcp";
+      const namespace = deriveMcpNamespace({ endpoint: trimmed });
+      const connector = createMcpConnector({
+        transport: "remote",
+        endpoint: trimmed
+      });
+      const connected = yield* discoverTools(connector).pipe(
+        Effect6.map(() => true),
+        Effect6.catch(() => Effect6.succeed(false)),
+        Effect6.withSpan("mcp.plugin.discover_tools")
+      );
+      if (connected) {
+        return new SourceDetectionResult({
+          kind: "mcp",
+          confidence: "high",
+          endpoint: trimmed,
+          name,
+          namespace
+        });
+      }
+      const shape = yield* probeMcpEndpointShape(trimmed, { httpClientLayer });
+      if (shape.kind === "mcp") {
+        return new SourceDetectionResult({
+          kind: "mcp",
+          confidence: "high",
+          endpoint: trimmed,
+          name,
+          namespace
+        });
+      }
+      if (urlMatchesToken(parsed.value, "mcp")) {
+        return new SourceDetectionResult({
+          kind: "mcp",
+          confidence: "low",
+          endpoint: trimmed,
+          name,
+          namespace
+        });
+      }
+      return null;
+    }).pipe(
+      Effect6.catch(() => Effect6.succeed(null)),
+      Effect6.withSpan("mcp.plugin.detect", {
+        attributes: { "mcp.endpoint": url }
+      })
+    ),
+    // Honor upstream destructiveHint from MCP ToolAnnotations.
+    // Bindings are fetched per scope so shadowed sources (e.g. an org-level
+    // source overridden per-user) each resolve against their own scope's
+    // row rather than collapsing onto whichever row the scoped adapter
+    // sees first.
+    resolveAnnotations: ({ ctx, sourceId, toolRows }) => Effect6.gen(function* () {
+      const scopes = new Set(toolRows.map((row) => row.scope_id));
+      const entries = yield* Effect6.forEach(
+        [...scopes],
+        (scope) => Effect6.gen(function* () {
+          const list = yield* ctx.storage.listBindingsBySource(sourceId, scope);
+          const byId = new Map(list.map((e) => [e.toolId, e.binding]));
+          return [scope, byId];
+        }),
+        { concurrency: "unbounded" }
+      );
+      const byScope = new Map(entries);
+      const out = {};
+      for (const row of toolRows) {
+        const binding = byScope.get(row.scope_id)?.get(row.id);
+        const ann = binding?.annotations;
+        if (ann?.destructiveHint === true) {
+          out[row.id] = {
+            requiresApproval: true,
+            approvalDescription: ann.title ?? binding?.toolName ?? row.id
+          };
+        } else {
+          out[row.id] = { requiresApproval: false };
+        }
+      }
+      return out;
+    }),
+    removeSource: ({ ctx, sourceId, scope }) => Effect6.gen(function* () {
+      yield* ctx.transaction(
+        Effect6.gen(function* () {
+          yield* ctx.credentialBindings.removeForSource({
+            pluginId: MCP_PLUGIN_ID,
+            sourceId,
+            sourceScope: ScopeId.make(scope)
+          });
+          yield* ctx.storage.removeBindingsByNamespace(sourceId, scope);
+          yield* ctx.storage.removeSource(sourceId, scope);
+        })
+      );
+    }),
+    usagesForSecret: () => Effect6.succeed([]),
+    usagesForConnection: () => Effect6.succeed([]),
+    refreshSource: () => Effect6.void,
+    // Connection refresh for oauth2-minted sources is owned by the
+    // canonical `"oauth2"` ConnectionProvider that core registers via
+    // `makeOAuth2Service`. No MCP-specific provider needed.
+    close: () => Effect6.gen(function* () {
+      const runtime = runtimeRef.current;
+      if (runtime) {
+        runtime.pendingConnectors.clear();
+        yield* ScopedCache2.invalidateAll(runtime.connectionCache);
+        yield* Scope.close(runtime.cacheScope, Exit2.void);
+        runtimeRef.current = null;
+      }
+    }).pipe(Effect6.withSpan("mcp.plugin.close"))
+  };
+});
+
+export {
+  mcpSchema,
+  makeMcpStore,
+  mcpPlugin
+};
+//# sourceMappingURL=chunk-OOOH3IO4.js.map