@executor-js/plugin-mcp 0.0.2 → 0.1.0

package/dist/{chunk-DJANY5EU.js → chunk-C2GNZGFJ.js}

@@ -48,12 +48,20 @@ var McpStdioSourceData = Schema.Struct({
   cwd: Schema.optional(Schema.String)
 });
 var McpStoredSourceData = Schema.Union([McpRemoteSourceData, McpStdioSourceData]);
+var McpToolAnnotations = Schema.Struct({
+  title: Schema.optional(Schema.String),
+  readOnlyHint: Schema.optional(Schema.Boolean),
+  destructiveHint: Schema.optional(Schema.Boolean),
+  idempotentHint: Schema.optional(Schema.Boolean),
+  openWorldHint: Schema.optional(Schema.Boolean)
+});
 var McpToolBinding = class extends Schema.Class("McpToolBinding")({
   toolId: Schema.String,
   toolName: Schema.String,
   description: Schema.NullOr(Schema.String),
   inputSchema: Schema.optional(Schema.Unknown),
-  outputSchema: Schema.optional(Schema.Unknown)
+  outputSchema: Schema.optional(Schema.Unknown),
+  annotations: Schema.optional(McpToolAnnotations)
 }) {
 };
 
@@ -98,6 +106,19 @@ var makeMcpStore = ({
   adapter: db
 }) => {
   return {
+    listBindingsBySource: (namespace, scope) => Effect2.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) => Effect2.gen(function* () {
       const row = yield* db.findOne({
         model: "mcp_binding",
@@ -200,18 +221,13 @@ var makeMcpStore = ({
 };
 
 // src/sdk/plugin.ts
-import { Duration, Effect as Effect7, Exit as Exit2, Result, Scope, ScopedCache as ScopedCache2 } from "effect";
-import {
-  SourceDetectionResult,
-  definePlugin,
-  resolveSecretBackedMap as resolveSharedSecretBackedMap
-} from "@executor-js/sdk/core";
+import { Duration, Effect as Effect8, Exit as Exit2, Result, Scope, ScopedCache as ScopedCache2 } from "effect";
 
-// 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 { Effect as Effect3 } from "effect";
+// src/api/group.ts
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Schema as Schema5 } from "effect";
+import { ScopeId, SecretBackedMap as SecretBackedMap2 } from "@executor-js/sdk/core";
+import { InternalError } from "@executor-js/api";
 
 // src/sdk/errors.ts
 import { Schema as Schema3 } from "effect";
@@ -251,7 +267,252 @@ var McpOAuthError = class extends Schema3.TaggedErrorClass()(
 ) {
 };
 
+// src/sdk/stored-source.ts
+import { Schema as Schema4 } from "effect";
+var McpStoredSourceSchema = class extends Schema4.Class("McpStoredSource")({
+  namespace: Schema4.String,
+  name: Schema4.String,
+  config: McpStoredSourceData
+}) {
+};
+
+// src/api/group.ts
+var ScopeParams = { scopeId: ScopeId };
+var SourceParams = { scopeId: ScopeId, namespace: Schema5.String };
+var AuthPayload = Schema5.Union([
+  Schema5.Struct({ kind: Schema5.Literal("none") }),
+  Schema5.Struct({
+    kind: Schema5.Literal("header"),
+    headerName: Schema5.String,
+    secretId: Schema5.String,
+    prefix: Schema5.optional(Schema5.String)
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("oauth2"),
+    /** Stable id of the SDK Connection minted by `completeOAuth`. The
+     *  backing access/refresh secrets live on the connection row; the
+     *  source only needs this pointer. */
+    connectionId: Schema5.String,
+    clientIdSecretId: Schema5.optional(Schema5.String),
+    clientSecretSecretId: Schema5.optional(Schema5.NullOr(Schema5.String))
+  })
+]);
+var StringMap2 = Schema5.Record(Schema5.String, Schema5.String);
+var AddRemoteSourcePayload = Schema5.Struct({
+  transport: Schema5.Literal("remote"),
+  name: Schema5.String,
+  endpoint: Schema5.String,
+  remoteTransport: Schema5.optional(Schema5.Literals(["streamable-http", "sse", "auto"])),
+  namespace: Schema5.optional(Schema5.String),
+  queryParams: Schema5.optional(SecretBackedMap2),
+  headers: Schema5.optional(SecretBackedMap2),
+  auth: Schema5.optional(AuthPayload)
+});
+var AddStdioSourcePayload = Schema5.Struct({
+  transport: Schema5.Literal("stdio"),
+  name: Schema5.String,
+  command: Schema5.String,
+  args: Schema5.optional(Schema5.Array(Schema5.String)),
+  env: Schema5.optional(StringMap2),
+  cwd: Schema5.optional(Schema5.String),
+  namespace: Schema5.optional(Schema5.String)
+});
+var AddSourcePayload = Schema5.Union([AddRemoteSourcePayload, AddStdioSourcePayload]);
+var UpdateSourcePayload = Schema5.Struct({
+  name: Schema5.optional(Schema5.String),
+  endpoint: Schema5.optional(Schema5.String),
+  headers: Schema5.optional(SecretBackedMap2),
+  queryParams: Schema5.optional(SecretBackedMap2),
+  auth: Schema5.optional(AuthPayload)
+});
+var UpdateSourceResponse = Schema5.Struct({
+  updated: Schema5.Boolean
+});
+var ProbeEndpointPayload = Schema5.Struct({
+  endpoint: Schema5.String,
+  headers: Schema5.optional(SecretBackedMap2),
+  queryParams: Schema5.optional(SecretBackedMap2)
+});
+var ProbeEndpointResponse = Schema5.Struct({
+  connected: Schema5.Boolean,
+  requiresOAuth: Schema5.Boolean,
+  name: Schema5.String,
+  namespace: Schema5.String,
+  toolCount: Schema5.NullOr(Schema5.Number),
+  serverName: Schema5.NullOr(Schema5.String)
+});
+var NamespacePayload = Schema5.Struct({
+  namespace: Schema5.String
+});
+var AddSourceResponse = Schema5.Struct({
+  toolCount: Schema5.Number,
+  namespace: Schema5.String
+});
+var RefreshSourceResponse = Schema5.Struct({
+  toolCount: Schema5.Number
+});
+var RemoveSourceResponse = Schema5.Struct({
+  removed: Schema5.Boolean
+});
+var McpGroup = HttpApiGroup.make("mcp").add(
+  HttpApiEndpoint.post("probeEndpoint", "/scopes/:scopeId/mcp/probe", {
+    params: ScopeParams,
+    payload: ProbeEndpointPayload,
+    success: ProbeEndpointResponse,
+    error: [InternalError, McpConnectionError, McpToolDiscoveryError]
+  })
+).add(
+  HttpApiEndpoint.post("addSource", "/scopes/:scopeId/mcp/sources", {
+    params: ScopeParams,
+    payload: AddSourcePayload,
+    success: AddSourceResponse,
+    error: [InternalError, McpConnectionError, McpToolDiscoveryError]
+  })
+).add(
+  HttpApiEndpoint.post("removeSource", "/scopes/:scopeId/mcp/sources/remove", {
+    params: ScopeParams,
+    payload: NamespacePayload,
+    success: RemoveSourceResponse,
+    error: [InternalError, McpConnectionError, McpToolDiscoveryError]
+  })
+).add(
+  HttpApiEndpoint.post("refreshSource", "/scopes/:scopeId/mcp/sources/refresh", {
+    params: ScopeParams,
+    payload: NamespacePayload,
+    success: RefreshSourceResponse,
+    error: [InternalError, McpConnectionError, McpToolDiscoveryError]
+  })
+).add(
+  HttpApiEndpoint.get("getSource", "/scopes/:scopeId/mcp/sources/:namespace", {
+    params: SourceParams,
+    success: Schema5.NullOr(McpStoredSourceSchema),
+    error: [InternalError, McpConnectionError, McpToolDiscoveryError]
+  })
+).add(
+  HttpApiEndpoint.patch("updateSource", "/scopes/:scopeId/mcp/sources/:namespace", {
+    params: SourceParams,
+    payload: UpdateSourcePayload,
+    success: UpdateSourceResponse,
+    error: [InternalError, McpConnectionError, McpToolDiscoveryError]
+  })
+);
+
+// src/api/handlers.ts
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Context, Effect as Effect3 } from "effect";
+import { addGroup, capture } from "@executor-js/api";
+var McpExtensionService = class extends Context.Service()("McpExtensionService") {
+};
+var ExecutorApiWithMcp = addGroup(McpGroup);
+var toSourceConfig = (payload, scope) => {
+  if (payload.transport === "stdio") {
+    const p2 = payload;
+    return {
+      transport: "stdio",
+      scope,
+      name: p2.name,
+      command: p2.command,
+      args: p2.args ? [...p2.args] : void 0,
+      env: p2.env,
+      cwd: p2.cwd,
+      namespace: p2.namespace
+    };
+  }
+  const p = payload;
+  return {
+    transport: "remote",
+    scope,
+    name: p.name,
+    endpoint: p.endpoint,
+    remoteTransport: p.remoteTransport,
+    queryParams: p.queryParams,
+    headers: p.headers,
+    namespace: p.namespace,
+    auth: p.auth
+  };
+};
+var McpHandlers = HttpApiBuilder.group(
+  ExecutorApiWithMcp,
+  "mcp",
+  (handlers) => handlers.handle(
+    "probeEndpoint",
+    ({ payload }) => capture(
+      Effect3.gen(function* () {
+        const ext = yield* McpExtensionService;
+        return yield* ext.probeEndpoint(payload);
+      })
+    )
+  ).handle(
+    "addSource",
+    ({ params: path, payload }) => capture(
+      Effect3.gen(function* () {
+        const ext = yield* McpExtensionService;
+        return yield* ext.addSource(
+          toSourceConfig(payload, path.scopeId)
+        );
+      })
+    )
+  ).handle(
+    "removeSource",
+    ({ params: path, payload }) => capture(
+      Effect3.gen(function* () {
+        const ext = yield* McpExtensionService;
+        yield* ext.removeSource(payload.namespace, path.scopeId);
+        return { removed: true };
+      })
+    )
+  ).handle(
+    "refreshSource",
+    ({ params: path, payload }) => capture(
+      Effect3.gen(function* () {
+        const ext = yield* McpExtensionService;
+        return yield* ext.refreshSource(payload.namespace, path.scopeId);
+      })
+    )
+  ).handle(
+    "getSource",
+    ({ params: path }) => capture(
+      Effect3.gen(function* () {
+        const ext = yield* McpExtensionService;
+        const source = yield* ext.getSource(path.namespace, path.scopeId);
+        return source ? new McpStoredSourceSchema({
+          namespace: source.namespace,
+          name: source.name,
+          config: source.config
+        }) : null;
+      })
+    )
+  ).handle(
+    "updateSource",
+    ({ params: path, payload }) => capture(
+      Effect3.gen(function* () {
+        const ext = yield* McpExtensionService;
+        yield* ext.updateSource(path.namespace, path.scopeId, {
+          name: payload.name,
+          endpoint: payload.endpoint,
+          headers: payload.headers,
+          queryParams: payload.queryParams,
+          auth: payload.auth
+        });
+        return { updated: true };
+      })
+    )
+  )
+);
+
+// src/sdk/plugin.ts
+import {
+  SourceDetectionResult,
+  definePlugin,
+  resolveSecretBackedMap as resolveSharedSecretBackedMap
+} 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 Effect4 } from "effect";
 var buildEndpointUrl = (endpoint, queryParams) => {
   const url = new URL(endpoint);
   for (const [key, value] of Object.entries(queryParams)) {
@@ -261,23 +522,26 @@ var buildEndpointUrl = (endpoint, queryParams) => {
 };
 var createClient = () => new Client(
   { name: "executor-mcp", version: "0.1.0" },
-  { capabilities: { elicitation: { form: {}, url: {} } } }
+  {
+    capabilities: { elicitation: { form: {}, url: {} } },
+    jsonSchemaValidator: new CfWorkerJsonSchemaValidator()
+  }
 );
 var connectionFromClient = (client) => ({
   client,
   close: () => client.close()
 });
-var connectClient = (input) => Effect3.gen(function* () {
+var connectClient = (input) => Effect4.gen(function* () {
   const client = createClient();
   const transportInstance = input.createTransport();
-  yield* Effect3.tryPromise({
+  yield* Effect4.tryPromise({
     try: () => client.connect(transportInstance),
     catch: (cause) => new McpConnectionError({
       transport: input.transport,
       message: `Failed connecting via ${input.transport}: ${cause instanceof Error ? cause.message : String(cause)}`
     })
   }).pipe(
-    Effect3.withSpan("plugin.mcp.connection.handshake", {
+    Effect4.withSpan("plugin.mcp.connection.handshake", {
       attributes: { "plugin.mcp.transport": input.transport }
     })
   );
@@ -287,15 +551,15 @@ var createMcpConnector = (input) => {
   if (input.transport === "stdio") {
     const command = input.command.trim();
     if (!command) {
-      return Effect3.fail(
+      return Effect4.fail(
         new McpConnectionError({
           transport: "stdio",
           message: "MCP stdio transport requires a command"
         })
       );
     }
-    return Effect3.gen(function* () {
-      const { createStdioTransport } = yield* Effect3.tryPromise({
+    return Effect4.gen(function* () {
+      const { createStdioTransport } = yield* Effect4.tryPromise({
         try: () => import("./stdio-connector-KNHLETKM.js"),
         catch: (cause) => new McpConnectionError({
           transport: "stdio",
@@ -333,30 +597,31 @@ var createMcpConnector = (input) => {
   });
   if (remoteTransport === "streamable-http") return connectStreamableHttp;
   if (remoteTransport === "sse") return connectSse;
-  return connectStreamableHttp.pipe(Effect3.catch(() => connectSse));
+  return connectStreamableHttp.pipe(Effect4.catch(() => connectSse));
 };
 
 // src/sdk/discover.ts
-import { Effect as Effect4 } from "effect";
+import { Effect as Effect5 } from "effect";
 
 // src/sdk/manifest.ts
-import { Schema as Schema4 } from "effect";
-var ListedTool = Schema4.Struct({
-  name: Schema4.String,
-  description: Schema4.optional(Schema4.NullOr(Schema4.String)),
-  inputSchema: Schema4.optional(Schema4.Unknown),
-  parameters: Schema4.optional(Schema4.Unknown),
-  outputSchema: Schema4.optional(Schema4.Unknown)
+import { Schema as Schema6 } from "effect";
+var ListedTool = Schema6.Struct({
+  name: Schema6.String,
+  description: Schema6.optional(Schema6.NullOr(Schema6.String)),
+  inputSchema: Schema6.optional(Schema6.Unknown),
+  parameters: Schema6.optional(Schema6.Unknown),
+  outputSchema: Schema6.optional(Schema6.Unknown),
+  annotations: Schema6.optional(McpToolAnnotations)
 });
-var ListToolsResult = Schema4.Struct({
-  tools: Schema4.Array(ListedTool)
+var ListToolsResult = Schema6.Struct({
+  tools: Schema6.Array(ListedTool)
 });
-var ServerInfo = Schema4.Struct({
-  name: Schema4.optional(Schema4.String),
-  version: Schema4.optional(Schema4.String)
+var ServerInfo = Schema6.Struct({
+  name: Schema6.optional(Schema6.String),
+  version: Schema6.optional(Schema6.String)
 });
-var decodeListToolsResult = Schema4.decodeUnknownOption(ListToolsResult);
-var decodeServerInfo = Schema4.decodeUnknownOption(ServerInfo);
+var decodeListToolsResult = Schema6.decodeUnknownOption(ListToolsResult);
+var decodeServerInfo = Schema6.decodeUnknownOption(ServerInfo);
 var isListToolsResult = (value) => decodeListToolsResult(value)._tag === "Some";
 var sanitize = (value) => {
   const s = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
@@ -385,7 +650,8 @@ var extractManifestFromListToolsResult = (listToolsResult, metadata) => {
         toolName,
         description: tool.description ?? null,
         inputSchema: tool.inputSchema ?? tool.parameters,
-        outputSchema: tool.outputSchema
+        outputSchema: tool.outputSchema,
+        annotations: tool.annotations
       }
     ];
   });
@@ -409,16 +675,16 @@ var deriveMcpNamespace = (input) => {
 };
 
 // src/sdk/discover.ts
-var discoverTools = (connector) => Effect4.gen(function* () {
+var discoverTools = (connector) => Effect5.gen(function* () {
   const connection = yield* connector.pipe(
-    Effect4.mapError(
+    Effect5.mapError(
       (err) => new McpToolDiscoveryError({
         stage: "connect",
         message: `Failed connecting to MCP server: ${err.message}`
       })
     )
   );
-  const listResult = yield* Effect4.tryPromise({
+  const listResult = yield* Effect5.tryPromise({
     try: () => connection.client.listTools(),
     catch: (cause) => new McpToolDiscoveryError({
       stage: "list_tools",
@@ -426,9 +692,9 @@ var discoverTools = (connector) => Effect4.gen(function* () {
     })
   });
   if (!isListToolsResult(listResult)) {
-    yield* Effect4.promise(() => connection.close().catch(() => {
+    yield* Effect5.promise(() => connection.close().catch(() => {
     }));
-    return yield* Effect4.fail(
+    return yield* Effect5.fail(
       new McpToolDiscoveryError({
         stage: "list_tools",
         message: "MCP listTools response did not match the expected schema"
@@ -438,13 +704,13 @@ var discoverTools = (connector) => Effect4.gen(function* () {
   const manifest = extractManifestFromListToolsResult(listResult, {
     serverInfo: connection.client.getServerVersion?.()
   });
-  yield* Effect4.promise(() => connection.close().catch(() => {
+  yield* Effect5.promise(() => connection.close().catch(() => {
   }));
   return manifest;
 });
 
 // src/sdk/invoke.ts
-import { Cause, Effect as Effect5, Exit, Schema as Schema5, ScopedCache } from "effect";
+import { Cause, Effect as Effect6, Exit, Schema as Schema7, ScopedCache } from "effect";
 import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import {
   FormElicitation,
@@ -460,21 +726,21 @@ var connectionCacheKey = (sd, invokerScope) => sd.transport === "stdio" ? `stdio
   // (and user A's tokens).
   `remote:${invokerScope}:${sd.endpoint}`
 );
-var McpElicitParams = Schema5.Union([
-  Schema5.Struct({
-    mode: Schema5.Literal("url"),
-    message: Schema5.String,
-    url: Schema5.String,
-    elicitationId: Schema5.optional(Schema5.String),
-    id: Schema5.optional(Schema5.String)
+var McpElicitParams = Schema7.Union([
+  Schema7.Struct({
+    mode: Schema7.Literal("url"),
+    message: Schema7.String,
+    url: Schema7.String,
+    elicitationId: Schema7.optional(Schema7.String),
+    id: Schema7.optional(Schema7.String)
   }),
-  Schema5.Struct({
-    mode: Schema5.optional(Schema5.Literal("form")),
-    message: Schema5.String,
-    requestedSchema: Schema5.Record(Schema5.String, Schema5.Unknown)
+  Schema7.Struct({
+    mode: Schema7.optional(Schema7.Literal("form")),
+    message: Schema7.String,
+    requestedSchema: Schema7.Record(Schema7.String, Schema7.Unknown)
   })
 ]);
-var decodeElicitParams = Schema5.decodeUnknownSync(McpElicitParams);
+var decodeElicitParams = Schema7.decodeUnknownSync(McpElicitParams);
 var toElicitationRequest = (params) => params.mode === "url" ? new UrlElicitation({
   message: params.message,
   url: params.url,
@@ -489,7 +755,7 @@ var installElicitationHandler = (client, elicit) => {
     async (request) => {
       const params = decodeElicitParams(request.params);
       const req = toElicitationRequest(params);
-      const exit = await Effect5.runPromiseExit(elicit(req));
+      const exit = await Effect6.runPromiseExit(elicit(req));
       if (Exit.isSuccess(exit)) {
         const response = exit.value;
         return {
@@ -508,30 +774,30 @@ var installElicitationHandler = (client, elicit) => {
     }
   );
 };
-var useConnection = (connection, toolName, args, elicit) => Effect5.gen(function* () {
+var useConnection = (connection, toolName, args, elicit) => Effect6.gen(function* () {
   installElicitationHandler(connection.client, elicit);
-  return yield* Effect5.tryPromise({
+  return yield* Effect6.tryPromise({
     try: () => connection.client.callTool({ name: toolName, arguments: args }),
     catch: (cause) => new McpInvocationError({
       toolName,
       message: `MCP tool call failed for ${toolName}: ${cause instanceof Error ? cause.message : String(cause)}`
     })
   }).pipe(
-    Effect5.withSpan("plugin.mcp.client.call_tool", {
+    Effect6.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 Effect5.gen(function* () {
+  return Effect6.gen(function* () {
     const cacheKey = connectionCacheKey(input.sourceData, input.invokerScope);
     const args = asRecord(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(
-      Effect5.withSpan("plugin.mcp.connection.acquire", {
+      Effect6.withSpan("plugin.mcp.connection.acquire", {
         attributes: {
           "plugin.mcp.transport": transport,
           "plugin.mcp.cache_key": cacheKey,
@@ -548,8 +814,8 @@ var invokeMcpTool = (input) => {
     ).pipe(
       // On failure, invalidate the cache and retry once with a fresh
       // connection. Matches the old invoker's retry-once semantics.
-      Effect5.catch(
-        () => Effect5.gen(function* () {
+      Effect6.catch(
+        () => Effect6.gen(function* () {
           yield* ScopedCache.invalidate(input.connectionCache, cacheKey);
           input.pendingConnectors.set(cacheKey, connector);
           const fresh = yield* ScopedCache.get(input.connectionCache, cacheKey);
@@ -560,7 +826,7 @@ var invokeMcpTool = (input) => {
             input.elicit
           );
         }).pipe(
-          Effect5.withSpan("plugin.mcp.invoke.retry", {
+          Effect6.withSpan("plugin.mcp.invoke.retry", {
             attributes: {
               "plugin.mcp.transport": transport,
               "plugin.mcp.cache_key": cacheKey,
@@ -571,8 +837,8 @@ var invokeMcpTool = (input) => {
       )
     );
   }).pipe(
-    Effect5.scoped,
-    Effect5.withSpan("plugin.mcp.invoke", {
+    Effect6.scoped,
+    Effect6.withSpan("plugin.mcp.invoke", {
       attributes: {
         "mcp.tool.name": input.toolName,
         "plugin.mcp.tool_id": input.toolId,
@@ -583,7 +849,7 @@ var invokeMcpTool = (input) => {
 };
 
 // src/sdk/probe-shape.ts
-import { Effect as Effect6 } from "effect";
+import { Effect as Effect7 } from "effect";
 var INITIALIZE_BODY = JSON.stringify({
   jsonrpc: "2.0",
   id: 1,
@@ -603,10 +869,10 @@ var readHeader = (headers, name) => {
   }
   return null;
 };
-var probeMcpEndpointShape = (endpoint, options = {}) => Effect6.gen(function* () {
+var probeMcpEndpointShape = (endpoint, options = {}) => Effect7.gen(function* () {
   const fetchImpl = options.fetch ?? globalThis.fetch;
   const timeoutMs = options.timeoutMs ?? 8e3;
-  const outcome = yield* Effect6.tryPromise({
+  const outcome = yield* Effect7.tryPromise({
     try: async () => {
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -672,15 +938,15 @@ var probeMcpEndpointShape = (endpoint, options = {}) => Effect6.gen(function* ()
     },
     catch: (cause) => cause
   }).pipe(
-    Effect6.catch(
-      (cause) => Effect6.succeed({
+    Effect7.catch(
+      (cause) => Effect7.succeed({
         kind: "unreachable",
         reason: cause instanceof Error ? cause.message : String(cause)
       })
     )
   );
   return outcome;
-}).pipe(Effect6.withSpan("mcp.plugin.probe_shape"));
+}).pipe(Effect7.withSpan("mcp.plugin.probe_shape"));
 
 // src/sdk/plugin.ts
 import {
@@ -715,7 +981,8 @@ var toBinding = (entry) => new McpToolBinding({
   toolName: entry.toolName,
   description: entry.description,
   inputSchema: entry.inputSchema,
-  outputSchema: entry.outputSchema
+  outputSchema: entry.outputSchema,
+  annotations: entry.annotations
 });
 var makeOAuthProvider = (accessToken) => ({
   get redirectUrl() {
@@ -752,7 +1019,7 @@ var resolveSecretBackedMap = (values, ctx) => resolveSharedSecretBackedMap({
   onMissing: (_name, value) => remoteConnectionError(`Failed to resolve secret "${value.secretId}"`),
   onError: (err, _name, value) => "_tag" in err && err._tag === "SecretOwnedByConnectionError" ? remoteConnectionError(`Failed to resolve secret "${value.secretId}"`) : err
 }).pipe(
-  Effect7.mapError(
+  Effect8.mapError(
     (err) => "_tag" in err && err._tag === "SecretOwnedByConnectionError" ? remoteConnectionError("Failed to resolve secret") : err
   )
 );
@@ -766,14 +1033,14 @@ var plainStringMap = (values) => {
 var resolveConnectorInput = (sd, ctx, allowStdio) => {
   if (sd.transport === "stdio") {
     if (!allowStdio) {
-      return Effect7.fail(
+      return Effect8.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 Effect7.succeed({
+    return Effect8.succeed({
       transport: "stdio",
       command: sd.command,
       args: sd.args,
@@ -781,7 +1048,7 @@ var resolveConnectorInput = (sd, ctx, allowStdio) => {
       cwd: sd.cwd
     });
   }
-  return Effect7.gen(function* () {
+  return Effect8.gen(function* () {
     const resolvedHeaders = yield* resolveSecretBackedMap(sd.headers, ctx);
     const resolvedQueryParams = yield* resolveSecretBackedMap(sd.queryParams, ctx);
     const headers = { ...resolvedHeaders ?? {} };
@@ -789,19 +1056,19 @@ var resolveConnectorInput = (sd, ctx, allowStdio) => {
     const auth = sd.auth;
     if (auth.kind === "header") {
       const val = yield* ctx.secrets.get(auth.secretId).pipe(
-        Effect7.mapError(
+        Effect8.mapError(
           (err) => "_tag" in err && err._tag === "SecretOwnedByConnectionError" ? remoteConnectionError(`Failed to resolve secret "${auth.secretId}"`) : err
         )
       );
       if (val === null) {
-        return yield* Effect7.fail(
+        return yield* Effect8.fail(
           remoteConnectionError(`Failed to resolve secret "${auth.secretId}"`)
         );
       }
       headers[auth.headerName] = auth.prefix ? `${auth.prefix}${val}` : val;
     } else if (auth.kind === "oauth2") {
       const accessToken = yield* ctx.connections.accessToken(auth.connectionId).pipe(
-        Effect7.mapError(
+        Effect8.mapError(
           (err) => remoteConnectionError(
             `Failed to resolve OAuth connection "${auth.connectionId}": ${"message" in err ? err.message : String(err)}`
           )
@@ -819,15 +1086,15 @@ var resolveConnectorInput = (sd, ctx, allowStdio) => {
     };
   });
 };
-var makeRuntime = () => Effect7.gen(function* () {
+var makeRuntime = () => Effect8.gen(function* () {
   const cacheScope = yield* Scope.make();
   const pendingConnectors = /* @__PURE__ */ new Map();
   const connectionCache = yield* ScopedCache2.make({
-    lookup: (key) => Effect7.acquireRelease(
-      Effect7.suspend(() => {
+    lookup: (key) => Effect8.acquireRelease(
+      Effect8.suspend(() => {
         const connector = pendingConnectors.get(key);
         if (!connector) {
-          return Effect7.fail(
+          return Effect8.fail(
             new McpConnectionError({
               transport: "auto",
               message: `No pending connector for key: ${key}`
@@ -836,7 +1103,7 @@ var makeRuntime = () => Effect7.gen(function* () {
         }
         return connector;
       }),
-      (connection) => Effect7.promise(() => connection.close().catch(() => {
+      (connection) => Effect8.promise(() => connection.close().catch(() => {
       }))
     ),
     capacity: 64,
@@ -891,29 +1158,30 @@ var toMcpConfigEntry = (namespace, sourceName, config) => {
 var mcpPlugin = definePlugin((options) => {
   const allowStdio = options?.dangerouslyAllowStdioMCP ?? false;
   const runtimeRef = { current: null };
-  const ensureRuntime = () => runtimeRef.current ? Effect7.succeed(runtimeRef.current) : makeRuntime().pipe(
-    Effect7.tap(
-      (rt) => Effect7.sync(() => {
+  const ensureRuntime = () => runtimeRef.current ? Effect8.succeed(runtimeRef.current) : makeRuntime().pipe(
+    Effect8.tap(
+      (rt) => Effect8.sync(() => {
         runtimeRef.current = rt;
       })
     )
   );
   return {
     id: "mcp",
+    packageName: "@executor-js/plugin-mcp",
     schema: mcpSchema,
     storage: (deps) => makeMcpStore(deps),
     extension: (ctx) => {
-      const probeEndpoint = (input) => Effect7.gen(function* () {
+      const probeEndpoint = (input) => Effect8.gen(function* () {
         const endpoint = typeof input === "string" ? input : input.endpoint;
         const trimmed = endpoint.trim();
         if (!trimmed) {
-          return yield* Effect7.fail(remoteConnectionError("Endpoint URL is required"));
+          return yield* Effect8.fail(remoteConnectionError("Endpoint URL is required"));
         }
-        const name = yield* Effect7.try({
+        const name = yield* Effect8.try({
           try: () => new URL(trimmed).hostname,
           catch: () => "mcp"
         }).pipe(
-          Effect7.orElseSucceed(() => "mcp")
+          Effect8.orElseSucceed(() => "mcp")
         );
         const namespace = deriveMcpNamespace({ endpoint: trimmed });
         const probeHeaders = typeof input === "string" ? void 0 : yield* resolveSecretBackedMap(input.headers, ctx);
@@ -925,9 +1193,9 @@ var mcpPlugin = definePlugin((options) => {
           queryParams: probeQueryParams
         });
         const result = yield* discoverTools(connector).pipe(
-          Effect7.map((m) => ({ ok: true, manifest: m })),
-          Effect7.catch(() => Effect7.succeed({ ok: false, manifest: null })),
-          Effect7.withSpan("mcp.plugin.discover_tools")
+          Effect8.map((m) => ({ ok: true, manifest: m })),
+          Effect8.catch(() => Effect8.succeed({ ok: false, manifest: null })),
+          Effect8.withSpan("mcp.plugin.discover_tools")
         );
         if (result.ok && result.manifest) {
           return {
@@ -944,7 +1212,7 @@ var mcpPlugin = definePlugin((options) => {
           queryParams: probeQueryParams
         });
         if (shape.kind !== "mcp") {
-          return yield* Effect7.fail(
+          return yield* Effect8.fail(
             remoteConnectionError(
               shape.kind === "not-mcp" ? `Endpoint does not look like an MCP server: ${shape.reason}` : `Could not reach endpoint: ${shape.reason}`
             )
@@ -955,9 +1223,9 @@ var mcpPlugin = definePlugin((options) => {
           headers: probeHeaders,
           queryParams: probeQueryParams
         }).pipe(
-          Effect7.map(() => true),
-          Effect7.catch(() => Effect7.succeed(false)),
-          Effect7.withSpan("mcp.plugin.probe_oauth")
+          Effect8.map(() => true),
+          Effect8.catch(() => Effect8.succeed(false)),
+          Effect8.withSpan("mcp.plugin.probe_oauth")
         );
         if (probeResult) {
           return {
@@ -969,21 +1237,21 @@ var mcpPlugin = definePlugin((options) => {
             serverName: null
           };
         }
-        return yield* Effect7.fail(
+        return yield* Effect8.fail(
           remoteConnectionError("MCP server requires authentication but OAuth discovery failed")
         );
       }).pipe(
-        Effect7.withSpan("mcp.plugin.probe_endpoint", {
+        Effect8.withSpan("mcp.plugin.probe_endpoint", {
           attributes: { "mcp.endpoint": typeof input === "string" ? input : input.endpoint }
         })
       );
       const configFile = options?.configFile;
-      const addSource = (config) => Effect7.gen(function* () {
+      const addSource = (config) => Effect8.gen(function* () {
         const namespace = normalizeNamespace(config);
         const sd = toStoredSourceData(config);
         const resolved = yield* resolveConnectorInput(sd, ctx, allowStdio).pipe(
-          Effect7.result,
-          Effect7.withSpan("mcp.plugin.resolve_connector", {
+          Effect8.result,
+          Effect8.withSpan("mcp.plugin.resolve_connector", {
             attributes: {
               "mcp.source.namespace": namespace,
               "mcp.source.transport": sd.transport
@@ -991,21 +1259,21 @@ var mcpPlugin = definePlugin((options) => {
           })
         );
         if (Result.isFailure(resolved) && sd.transport === "stdio") {
-          return yield* Effect7.fail(resolved.failure);
+          return yield* Effect8.fail(resolved.failure);
         }
         const discovery = Result.isSuccess(resolved) ? yield* discoverTools(createMcpConnector(resolved.success)).pipe(
-          Effect7.mapError(
+          Effect8.mapError(
             (err) => mcpDiscoveryError(`MCP discovery failed: ${err.message}`)
           ),
-          Effect7.result,
-          Effect7.withSpan("mcp.plugin.discover_tools", {
+          Effect8.result,
+          Effect8.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(
-          Effect7.gen(function* () {
+          Effect8.gen(function* () {
             yield* ctx.storage.removeBindingsByNamespace(namespace, config.scope);
             yield* ctx.storage.removeSource(namespace, config.scope);
             yield* ctx.storage.putSource({
@@ -1040,7 +1308,7 @@ var mcpPlugin = definePlugin((options) => {
             });
           })
         ).pipe(
-          Effect7.withSpan("mcp.plugin.persist_source", {
+          Effect8.withSpan("mcp.plugin.persist_source", {
             attributes: {
               "mcp.source.namespace": namespace,
               "mcp.source.tool_count": manifest.tools.length
@@ -1048,49 +1316,49 @@ var mcpPlugin = definePlugin((options) => {
           })
         );
         if (configFile) {
-          yield* configFile.upsertSource(toMcpConfigEntry(namespace, sourceName, config)).pipe(Effect7.withSpan("mcp.plugin.config_file.upsert"));
+          yield* configFile.upsertSource(toMcpConfigEntry(namespace, sourceName, config)).pipe(Effect8.withSpan("mcp.plugin.config_file.upsert"));
         }
         if (Result.isFailure(discovery)) {
-          return yield* Effect7.fail(discovery.failure);
+          return yield* Effect8.fail(discovery.failure);
         }
         return { toolCount: manifest.tools.length, namespace };
       }).pipe(
-        Effect7.withSpan("mcp.plugin.add_source", {
+        Effect8.withSpan("mcp.plugin.add_source", {
           attributes: {
             "mcp.source.transport": config.transport,
             "mcp.source.name": config.name
           }
         })
       );
-      const removeSource = (namespace, scope) => Effect7.gen(function* () {
+      const removeSource = (namespace, scope) => Effect8.gen(function* () {
         yield* ctx.transaction(
-          Effect7.gen(function* () {
+          Effect8.gen(function* () {
             yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
             yield* ctx.storage.removeSource(namespace, scope);
             yield* ctx.core.sources.unregister(namespace);
           })
-        ).pipe(Effect7.withSpan("mcp.plugin.persist_remove"));
+        ).pipe(Effect8.withSpan("mcp.plugin.persist_remove"));
         if (configFile) {
-          yield* configFile.removeSource(namespace).pipe(Effect7.withSpan("mcp.plugin.config_file.remove"));
+          yield* configFile.removeSource(namespace).pipe(Effect8.withSpan("mcp.plugin.config_file.remove"));
         }
       }).pipe(
-        Effect7.withSpan("mcp.plugin.remove_source", {
+        Effect8.withSpan("mcp.plugin.remove_source", {
           attributes: { "mcp.source.namespace": namespace }
         })
       );
-      const refreshSource = (namespace, scope) => Effect7.gen(function* () {
+      const refreshSource = (namespace, scope) => Effect8.gen(function* () {
         const sd = yield* ctx.storage.getSourceConfig(namespace, scope).pipe(
-          Effect7.withSpan("mcp.plugin.load_source_config", {
+          Effect8.withSpan("mcp.plugin.load_source_config", {
             attributes: { "mcp.source.namespace": namespace }
           })
         );
         if (!sd) {
-          return yield* Effect7.fail(
+          return yield* Effect8.fail(
             remoteConnectionError(`No stored config for MCP source "${namespace}"`)
           );
         }
         const ci = yield* resolveConnectorInput(sd, ctx, allowStdio).pipe(
-          Effect7.withSpan("mcp.plugin.resolve_connector", {
+          Effect8.withSpan("mcp.plugin.resolve_connector", {
             attributes: {
               "mcp.source.namespace": namespace,
               "mcp.source.transport": sd.transport
@@ -1098,15 +1366,15 @@ var mcpPlugin = definePlugin((options) => {
           })
         );
         const manifest = yield* discoverTools(createMcpConnector(ci)).pipe(
-          Effect7.mapError((err) => mcpDiscoveryError(`MCP refresh failed: ${err.message}`)),
-          Effect7.withSpan("mcp.plugin.discover_tools", {
+          Effect8.mapError((err) => mcpDiscoveryError(`MCP refresh failed: ${err.message}`)),
+          Effect8.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(
-          Effect7.gen(function* () {
+          Effect8.gen(function* () {
             yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
             yield* ctx.core.sources.unregister(namespace);
             yield* ctx.storage.putBindings(
@@ -1135,7 +1403,7 @@ var mcpPlugin = definePlugin((options) => {
             });
           })
         ).pipe(
-          Effect7.withSpan("mcp.plugin.persist_source", {
+          Effect8.withSpan("mcp.plugin.persist_source", {
             attributes: {
               "mcp.source.namespace": namespace,
               "mcp.source.tool_count": manifest.tools.length
@@ -1144,11 +1412,11 @@ var mcpPlugin = definePlugin((options) => {
         );
         return { toolCount: manifest.tools.length };
       }).pipe(
-        Effect7.withSpan("mcp.plugin.refresh_source", {
+        Effect8.withSpan("mcp.plugin.refresh_source", {
           attributes: { "mcp.source.namespace": namespace }
         })
       );
-      const updateSource = (namespace, scope, input) => Effect7.gen(function* () {
+      const updateSource = (namespace, scope, input) => Effect8.gen(function* () {
         const existing = yield* ctx.storage.getSource(namespace, scope);
         if (!existing || existing.config.transport !== "remote") return;
         const remote = existing.config;
@@ -1166,12 +1434,12 @@ var mcpPlugin = definePlugin((options) => {
           config: updatedConfig
         });
       }).pipe(
-        Effect7.withSpan("mcp.plugin.update_source", {
+        Effect8.withSpan("mcp.plugin.update_source", {
           attributes: { "mcp.source.namespace": namespace }
         })
       );
       const getSource = (namespace, scope) => ctx.storage.getSource(namespace, scope).pipe(
-        Effect7.withSpan("mcp.plugin.get_source", {
+        Effect8.withSpan("mcp.plugin.get_source", {
           attributes: { "mcp.source.namespace": namespace }
         })
       );
@@ -1184,24 +1452,24 @@ var mcpPlugin = definePlugin((options) => {
         updateSource
       };
     },
-    invokeTool: ({ ctx, toolRow, args, elicit }) => Effect7.gen(function* () {
+    invokeTool: ({ ctx, toolRow, args, elicit }) => Effect8.gen(function* () {
       const runtime = yield* ensureRuntime();
       const toolScope = toolRow.scope_id;
       const entry = yield* ctx.storage.getBinding(toolRow.id, toolScope).pipe(
-        Effect7.withSpan("mcp.plugin.load_binding", {
+        Effect8.withSpan("mcp.plugin.load_binding", {
           attributes: { "mcp.tool.name": toolRow.id }
         })
       );
       if (!entry) {
-        return yield* Effect7.fail(new Error(`No MCP binding found for tool "${toolRow.id}"`));
+        return yield* Effect8.fail(new Error(`No MCP binding found for tool "${toolRow.id}"`));
       }
       const sd = yield* ctx.storage.getSourceConfig(entry.namespace, toolScope).pipe(
-        Effect7.withSpan("mcp.plugin.load_source_config", {
+        Effect8.withSpan("mcp.plugin.load_source_config", {
           attributes: { "mcp.source.namespace": entry.namespace }
         })
       );
       if (!sd) {
-        return yield* Effect7.fail(
+        return yield* Effect8.fail(
           new Error(`No MCP source config for namespace "${entry.namespace}"`)
         );
       }
@@ -1212,14 +1480,14 @@ var mcpPlugin = definePlugin((options) => {
         sourceData: sd,
         invokerScope: ctx.scopes[0].id,
         resolveConnector: () => resolveConnectorInput(sd, ctx, allowStdio).pipe(
-          Effect7.flatMap((ci) => createMcpConnector(ci)),
-          Effect7.mapError(
+          Effect8.flatMap((ci) => createMcpConnector(ci)),
+          Effect8.mapError(
             (err) => err instanceof McpConnectionError ? err : new McpConnectionError({
               transport: "auto",
               message: err instanceof Error ? err.message : String(err)
             })
           ),
-          Effect7.withSpan("mcp.plugin.resolve_connector", {
+          Effect8.withSpan("mcp.plugin.resolve_connector", {
             attributes: {
               "mcp.source.namespace": entry.namespace,
               "mcp.source.transport": sd.transport
@@ -1231,20 +1499,20 @@ var mcpPlugin = definePlugin((options) => {
         elicit
       });
     }).pipe(
-      Effect7.withSpan("mcp.plugin.invoke_tool", {
+      Effect8.withSpan("mcp.plugin.invoke_tool", {
         attributes: {
           "mcp.tool.name": toolRow.id,
           "mcp.tool.source_id": toolRow.source_id
         }
       })
     ),
-    detect: ({ ctx, url }) => Effect7.gen(function* () {
+    detect: ({ ctx, url }) => Effect8.gen(function* () {
       const trimmed = url.trim();
       if (!trimmed) return null;
-      const parsed = yield* Effect7.try({
+      const parsed = yield* Effect8.try({
         try: () => new URL(trimmed),
         catch: (cause) => cause
-      }).pipe(Effect7.option);
+      }).pipe(Effect8.option);
       if (parsed._tag === "None") return null;
       const name = parsed.value.hostname || "mcp";
       const namespace = deriveMcpNamespace({ endpoint: trimmed });
@@ -1253,9 +1521,9 @@ var mcpPlugin = definePlugin((options) => {
         endpoint: trimmed
       });
       const connected = yield* discoverTools(connector).pipe(
-        Effect7.map(() => true),
-        Effect7.catch(() => Effect7.succeed(false)),
-        Effect7.withSpan("mcp.plugin.discover_tools")
+        Effect8.map(() => true),
+        Effect8.catch(() => Effect8.succeed(false)),
+        Effect8.withSpan("mcp.plugin.discover_tools")
       );
       if (connected) {
         return new SourceDetectionResult({
@@ -1269,9 +1537,9 @@ var mcpPlugin = definePlugin((options) => {
       const shape = yield* probeMcpEndpointShape(trimmed);
       if (shape.kind !== "mcp") return null;
       const probeOk = yield* ctx.oauth.probe({ endpoint: trimmed }).pipe(
-        Effect7.map(() => true),
-        Effect7.catch(() => Effect7.succeed(false)),
-        Effect7.withSpan("mcp.plugin.probe_oauth")
+        Effect8.map(() => true),
+        Effect8.catch(() => Effect8.succeed(false)),
+        Effect8.withSpan("mcp.plugin.probe_oauth")
       );
       if (!probeOk) return null;
       return new SourceDetectionResult({
@@ -1282,29 +1550,52 @@ var mcpPlugin = definePlugin((options) => {
         namespace
       });
     }).pipe(
-      Effect7.catch(() => Effect7.succeed(null)),
-      Effect7.withSpan("mcp.plugin.detect", {
+      Effect8.catch(() => Effect8.succeed(null)),
+      Effect8.withSpan("mcp.plugin.detect", {
         attributes: { "mcp.endpoint": url }
       })
     ),
-    // MCP tools never require approval at the tool level — elicitation is
-    // handled mid-invocation by the server via the elicit capability.
-    resolveAnnotations: ({ toolRows }) => Effect7.sync(() => {
+    // 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 }) => Effect8.gen(function* () {
+      const scopes = new Set(toolRows.map((row) => row.scope_id));
+      const entries = yield* Effect8.forEach(
+        [...scopes],
+        (scope) => Effect8.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) {
-        out[row.id] = { requiresApproval: false };
+        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 }) => Effect7.gen(function* () {
+    removeSource: ({ ctx, sourceId, scope }) => Effect8.gen(function* () {
       yield* ctx.storage.removeBindingsByNamespace(sourceId, scope);
       yield* ctx.storage.removeSource(sourceId, scope);
     }),
-    refreshSource: () => Effect7.void,
+    refreshSource: () => Effect8.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: () => Effect7.gen(function* () {
+    close: () => Effect8.gen(function* () {
       const runtime = runtimeRef.current;
       if (runtime) {
         runtime.pendingConnectors.clear();
@@ -1312,7 +1603,13 @@ var mcpPlugin = definePlugin((options) => {
         yield* Scope.close(runtime.cacheScope, Exit2.void);
         runtimeRef.current = null;
       }
-    }).pipe(Effect7.withSpan("mcp.plugin.close"))
+    }).pipe(Effect8.withSpan("mcp.plugin.close")),
+    // HTTP transport. `McpHandlers` requires `McpExtensionService`; the
+    // host satisfies it via the `extensionService` Tag — at boot for
+    // local, per request for cloud.
+    routes: () => McpGroup,
+    handlers: () => McpHandlers,
+    extensionService: McpExtensionService
   };
 });
 
@@ -1322,4 +1619,4 @@ export {
   makeMcpStore,
   mcpPlugin
 };
-//# sourceMappingURL=chunk-DJANY5EU.js.map
+//# sourceMappingURL=chunk-C2GNZGFJ.js.map