@executor-js/plugin-mcp 1.4.28 → 1.4.30

package/dist/{chunk-NQT7NAGE.js → chunk-H5PLTEMB.js}

@@ -1,94 +1,30 @@
 import {
-  MCP_HEADER_AUTH_SLOT,
+  mcpPresets
+} from "./chunk-TW44CBXJ.js";
+import {
   MCP_OAUTH_CLIENT_ID_SLOT,
   MCP_OAUTH_CLIENT_SECRET_SLOT,
   MCP_OAUTH_CONNECTION_SLOT,
+  McpConfiguredValueInput,
+  McpConnectionAuthInput,
   McpConnectionError,
+  McpCredentialInput,
   McpInvocationError,
-  McpSourceBindingRef,
+  McpRemoteTransport,
   McpStoredSourceData,
   McpToolAnnotations,
   McpToolBinding,
   McpToolDiscoveryError,
+  SecretBackedValue,
   mcpHeaderSlot,
   mcpQueryParamSlot
-} from "./chunk-M6REVU6O.js";
+} from "./chunk-3TGDWTNE.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 }
-    }
-  }
-});
+import { Effect, Option, Predicate, Schema } from "effect";
+var mcpSchema = {};
+var SOURCE_COLLECTION = "source";
+var BINDING_COLLECTION = "binding";
 var decodeSourceData = Schema.decodeUnknownSync(McpStoredSourceData);
 var encodeSourceData = Schema.encodeSync(McpStoredSourceData);
 var decodeBinding = Schema.decodeUnknownSync(McpToolBinding);
@@ -98,279 +34,109 @@ 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
-    };
+var sourceData = (source) => ({
+  namespace: source.namespace,
+  scope: source.scope,
+  name: source.name,
+  config: encodeSourceData(source.config)
+});
+var bindingData = (namespace, entry) => ({
+  namespace,
+  toolId: entry.toolId,
+  binding: encodeBinding(entry.binding)
+});
+var rowToSource = (row) => {
+  const raw = coerceJson(row.data);
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw;
+  if (typeof record.namespace !== "string" || typeof record.scope !== "string" || typeof record.name !== "string") {
+    return null;
   }
-  return { auth_kind: "none" };
+  return {
+    namespace: record.namespace,
+    scope: record.scope,
+    name: record.name,
+    config: decodeSourceData(coerceJson(record.config))
+  };
 };
-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 rowToBinding = (row) => {
+  const raw = coerceJson(row.data);
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw;
+  if (typeof record.toolId !== "string" || typeof record.namespace !== "string") return null;
+  return {
+    toolId: record.toolId,
+    namespace: record.namespace,
+    binding: decodeBinding(coerceJson(record.binding))
+  };
 };
-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
-      };
+var makeMcpStore = ({ pluginStorage }) => {
+  const listBindingRowsForSourceScope = (namespace, scope) => pluginStorage.list({
+    collection: BINDING_COLLECTION,
+    keyPrefix: `${namespace}.`
+  }).pipe(
+    Effect.map(
+      (rows) => rows.filter((row) => {
+        if (String(row.scopeId) !== scope) return false;
+        return rowToBinding(row)?.namespace === namespace;
+      })
+    )
+  );
+  const removeBindingsForSourceScope = (namespace, scope) => Effect.gen(function* () {
+    const rows = yield* listBindingRowsForSourceScope(namespace, scope);
+    for (const row of rows) {
+      yield* pluginStorage.remove({
+        scope,
+        collection: BINDING_COLLECTION,
+        key: row.key
+      });
     }
-    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 ? ConfiguredCredentialBinding.make({ kind: "binding", slot: row.slot_key, prefix }) : ConfiguredCredentialBinding.make({ 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 };
-    }),
+    listBindingsBySource: (namespace, scope) => listBindingRowsForSourceScope(namespace, scope).pipe(
+      Effect.map(
+        (rows) => rows.map(rowToBinding).filter(Predicate.isNotNull).map((row) => ({ toolId: row.toolId, binding: row.binding }))
+      )
+    ),
+    getBinding: (toolId, scope) => pluginStorage.getAtScope({ scope, collection: BINDING_COLLECTION, key: toolId }).pipe(
+      Effect.map((row) => {
+        const binding = row ? rowToBinding(row) : null;
+        return binding ? { binding: binding.binding, namespace: binding.namespace } : null;
+      })
+    ),
     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
+      for (const entry of entries) {
+        yield* pluginStorage.put({
+          scope,
+          collection: BINDING_COLLECTION,
+          key: entry.toolId,
+          data: bindingData(namespace, entry)
         });
       }
     }),
+    removeBindingsByNamespace: (namespace, scope) => removeBindingsForSourceScope(namespace, scope),
+    getSource: (namespace, scope) => pluginStorage.getAtScope({ scope, collection: SOURCE_COLLECTION, key: namespace }).pipe(Effect.map((row) => row ? rowToSource(row) : null)),
+    getSourceConfig: (namespace, scope) => pluginStorage.getAtScope({ scope, collection: SOURCE_COLLECTION, key: namespace }).pipe(
+      Effect.map((row) => {
+        const source = row ? rowToSource(row) : null;
+        return source?.config ?? null;
+      })
+    ),
+    putSource: (source) => pluginStorage.put({
+      scope: source.scope,
+      collection: SOURCE_COLLECTION,
+      key: source.namespace,
+      data: sourceData(source)
+    }).pipe(Effect.asVoid),
     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 }
-        ]
+      yield* removeBindingsForSourceScope(namespace, scope);
+      yield* pluginStorage.remove({
+        scope,
+        collection: SOURCE_COLLECTION,
+        key: namespace
       });
     })
   };
-  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
@@ -380,21 +146,27 @@ import {
   Exit as Exit2,
   Match,
   Option as Option5,
-  Predicate as Predicate2,
+  Predicate as Predicate3,
   Result,
   Scope,
+  Schema as Schema5,
   ScopedCache as ScopedCache2
 } from "effect";
 import {
-  ConfiguredCredentialBinding as ConfiguredCredentialBinding2,
-  ConnectionId,
   ScopeId,
-  SecretId,
   SourceDetectionResult,
+  ToolResult,
+  defaultSourceInstallScopeId,
   definePlugin,
+  tool,
   resolveSecretBackedMap as resolveSharedSecretBackedMap,
   StorageError
 } from "@executor-js/sdk/core";
+import {
+  compileHttpNamedCredentialMap,
+  OAuth2SourceConfig,
+  httpCredentialInputToBindingValue
+} from "@executor-js/sdk/http-source";
 
 // src/sdk/connection.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -449,7 +221,7 @@ var createMcpConnector = (input) => {
     }
     return Effect2.gen(function* () {
       const { createStdioTransport } = yield* Effect2.tryPromise({
-        try: () => import("./stdio-connector-AA5S6UUJ.js"),
+        try: () => import("./stdio-connector-MDW6PW36.js"),
         catch: () => new McpConnectionError({
           transport: "stdio",
           message: "Failed to load stdio transport module"
@@ -537,17 +309,17 @@ var extractManifestFromListToolsResult = (listToolsResult, metadata) => {
     ),
     Option2.getOrNull
   );
-  const tools = listed.flatMap((tool) => {
-    const toolName = tool.name.trim();
+  const tools = listed.flatMap((tool2) => {
+    const toolName = tool2.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
+        description: tool2.description ?? null,
+        inputSchema: tool2.inputSchema ?? tool2.parameters,
+        outputSchema: tool2.outputSchema,
+        annotations: tool2.annotations
       }
     ];
   });
@@ -608,7 +380,7 @@ var closeConnection = (connection) => Effect3.ignore(
 );
 
 // src/sdk/invoke.ts
-import { Cause, Effect as Effect4, Exit, Option as Option3, Predicate, Schema as Schema3, ScopedCache } from "effect";
+import { Cause, Effect as Effect4, Exit, Option as Option3, Predicate as Predicate2, Schema as Schema3, ScopedCache } from "effect";
 import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import {
   FormElicitation,
@@ -691,8 +463,8 @@ var installElicitationHandler = (client, elicit) => {
     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";
+      if (Predicate2.isTagged(err, "ElicitationDeclinedError")) {
+        const action = Predicate2.hasProperty(err, "action") && err.action === "cancel" ? "cancel" : "decline";
         return { action };
       }
     }
@@ -808,6 +580,41 @@ var isOAuthErrorBody = (body) => {
   if (Array.isArray(obj.errors)) return false;
   return typeof obj.error === "string";
 };
+var ProtectedResourceMetadata = Schema4.Struct({
+  resource: Schema4.String,
+  authorization_servers: Schema4.Array(Schema4.String)
+});
+var decodeProtectedResourceMetadata = Schema4.decodeUnknownOption(
+  Schema4.fromJsonString(ProtectedResourceMetadata)
+);
+var protectedResourceMetadataUrl = (endpoint) => {
+  const path = endpoint.pathname === "/" ? "" : endpoint.pathname;
+  return `${endpoint.origin}/.well-known/oauth-protected-resource${path}`;
+};
+var resourceMatchesEndpoint = (resource, endpoint) => {
+  if (!URL.canParse(resource)) return false;
+  const parsed = new URL(resource);
+  if (parsed.origin !== endpoint.origin) return false;
+  const resourcePath = parsed.pathname.replace(/\/+$/, "");
+  const endpointPath = endpoint.pathname.replace(/\/+$/, "");
+  return endpointPath === resourcePath || endpointPath.startsWith(`${resourcePath}/`);
+};
+var probeProtectedResourceMetadata = (client, endpoint, timeoutMs) => Effect5.gen(function* () {
+  const response = yield* client.execute(
+    HttpClientRequest.get(protectedResourceMetadataUrl(endpoint)).pipe(
+      HttpClientRequest.setHeader("accept", "application/json")
+    )
+  ).pipe(Effect5.timeout(Duration.millis(timeoutMs)));
+  if (response.status < 200 || response.status >= 300) return false;
+  const body = yield* response.text.pipe(
+    Effect5.timeout(Duration.millis(timeoutMs)),
+    Effect5.catch(() => Effect5.succeed(""))
+  );
+  const metadata = decodeProtectedResourceMetadata(body);
+  if (Option4.isNone(metadata)) return false;
+  if (metadata.value.authorization_servers.length === 0) return false;
+  return resourceMatchesEndpoint(metadata.value.resource, endpoint);
+}).pipe(Effect5.catch(() => Effect5.succeed(false)));
 var ErrorMessageShape = Schema4.Struct({ message: Schema4.String });
 var decodeErrorMessageShape = Schema4.decodeUnknownOption(ErrorMessageShape);
 var reasonFromBoundaryCause = (cause) => {
@@ -836,6 +643,9 @@ var probeMcpEndpointShape = (endpoint, options = {}) => Effect5.gen(function* ()
       if (response.status === 401) {
         const wwwAuth = readHeader(response.headers, "www-authenticate");
         if (!wwwAuth || !/^\s*bearer\b/i.test(wwwAuth)) {
+          if (yield* probeProtectedResourceMetadata(client, url, timeoutMs)) {
+            return { kind: "mcp", requiresAuth: true };
+          }
           return {
             kind: "not-mcp",
             category: "auth-required",
@@ -851,6 +661,9 @@ var probeMcpEndpointShape = (endpoint, options = {}) => Effect5.gen(function* ()
         if (isSse) return { kind: "mcp", requiresAuth: true };
         const body = yield* readBody(response);
         if (!isJsonRpcEnvelope(body) && !isOAuthErrorBody(body)) {
+          if (yield* probeProtectedResourceMetadata(client, url, timeoutMs)) {
+            return { kind: "mcp", requiresAuth: true };
+          }
           return {
             kind: "not-mcp",
             category: "auth-required",
@@ -934,8 +747,117 @@ var probeMcpEndpointShape = (endpoint, options = {}) => Effect5.gen(function* ()
 
 // src/sdk/plugin.ts
 import {
-  SECRET_REF_PREFIX
+  headerToConfigValue
 } from "@executor-js/config";
+var McpConfigureSourcePayloadSchema = Schema5.Struct({
+  name: Schema5.optional(Schema5.String),
+  endpoint: Schema5.optional(Schema5.String),
+  headers: Schema5.optional(Schema5.Record(Schema5.String, McpCredentialInput)),
+  queryParams: Schema5.optional(Schema5.Record(Schema5.String, McpCredentialInput)),
+  auth: Schema5.optional(McpConnectionAuthInput)
+});
+var McpConfigureSourceInputSchema = Schema5.Struct({
+  scope: Schema5.String,
+  ...McpConfigureSourcePayloadSchema.fields
+});
+var McpInitialCredentialsInputSchema = Schema5.Struct({
+  scope: Schema5.String,
+  headers: Schema5.optional(Schema5.Record(Schema5.String, McpCredentialInput)),
+  queryParams: Schema5.optional(Schema5.Record(Schema5.String, McpCredentialInput)),
+  auth: Schema5.optional(McpConnectionAuthInput)
+});
+var McpRemoteAddSourceInputSchema = Schema5.Struct({
+  transport: Schema5.Literal("remote"),
+  name: Schema5.String,
+  endpoint: Schema5.String,
+  remoteTransport: Schema5.optional(McpRemoteTransport),
+  queryParams: Schema5.optional(Schema5.Record(Schema5.String, McpConfiguredValueInput)),
+  headers: Schema5.optional(Schema5.Record(Schema5.String, McpConfiguredValueInput)),
+  namespace: Schema5.optional(Schema5.String),
+  oauth2: Schema5.optional(OAuth2SourceConfig),
+  credentials: Schema5.optional(McpInitialCredentialsInputSchema)
+});
+var McpStdioAddSourceInputSchema = Schema5.Struct({
+  transport: Schema5.Literal("stdio"),
+  name: Schema5.String,
+  command: Schema5.String,
+  args: Schema5.optional(Schema5.Array(Schema5.String)),
+  env: Schema5.optional(Schema5.Record(Schema5.String, Schema5.String)),
+  cwd: Schema5.optional(Schema5.String),
+  namespace: Schema5.optional(Schema5.String)
+});
+var McpAddSourceInputSchema = Schema5.Union([
+  McpRemoteAddSourceInputSchema,
+  McpStdioAddSourceInputSchema
+]);
+var McpAddSourceOutputSchema = Schema5.Struct({
+  namespace: Schema5.String,
+  source: Schema5.Struct({
+    id: Schema5.String,
+    scope: Schema5.String
+  }),
+  toolCount: Schema5.Number,
+  discovery: Schema5.optional(
+    Schema5.Struct({
+      status: Schema5.Literals(["ok", "failed"]),
+      message: Schema5.optional(Schema5.String),
+      stage: Schema5.optional(Schema5.String)
+    })
+  )
+});
+var McpProbeEndpointInputSchema = Schema5.Struct({
+  endpoint: Schema5.String,
+  headers: Schema5.optional(Schema5.Record(Schema5.String, SecretBackedValue)),
+  queryParams: Schema5.optional(Schema5.Record(Schema5.String, SecretBackedValue))
+});
+var McpProbeEndpointOutputSchema = Schema5.Struct({
+  connected: Schema5.Boolean,
+  requiresOAuth: Schema5.Boolean,
+  supportsDynamicRegistration: Schema5.Boolean,
+  name: Schema5.String,
+  namespace: Schema5.String,
+  toolCount: Schema5.NullOr(Schema5.Number),
+  serverName: Schema5.NullOr(Schema5.String)
+});
+var McpGetSourceInputSchema = Schema5.Struct({
+  namespace: Schema5.String,
+  scope: Schema5.String
+});
+var McpGetSourceOutputSchema = Schema5.Struct({
+  source: Schema5.NullOr(Schema5.Unknown)
+});
+var McpStaticConfigureSourceInputSchema = Schema5.Struct({
+  source: Schema5.Struct({
+    id: Schema5.String,
+    scope: Schema5.String
+  }),
+  scope: Schema5.String,
+  ...McpConfigureSourcePayloadSchema.fields
+});
+var McpStaticConfigureSourceOutputSchema = Schema5.Struct({
+  configured: Schema5.Boolean
+});
+var schemaToStaticToolSchema = (schema) => Schema5.toStandardSchemaV1(Schema5.toStandardJSONSchemaV1(schema));
+var mcpToolFailure = (code, message, details) => ToolResult.fail({
+  code,
+  message,
+  ...details === void 0 ? {} : { details }
+});
+var McpAddSourceInputStandardSchema = schemaToStaticToolSchema(McpAddSourceInputSchema);
+var McpAddSourceOutputStandardSchema = schemaToStaticToolSchema(McpAddSourceOutputSchema);
+var McpProbeEndpointInputStandardSchema = schemaToStaticToolSchema(McpProbeEndpointInputSchema);
+var McpProbeEndpointOutputStandardSchema = schemaToStaticToolSchema(McpProbeEndpointOutputSchema);
+var McpGetSourceInputStandardSchema = schemaToStaticToolSchema(McpGetSourceInputSchema);
+var McpGetSourceOutputStandardSchema = schemaToStaticToolSchema(McpGetSourceOutputSchema);
+var McpStaticConfigureSourceInputStandardSchema = schemaToStaticToolSchema(
+  McpStaticConfigureSourceInputSchema
+);
+var McpStaticConfigureSourceOutputStandardSchema = schemaToStaticToolSchema(
+  McpStaticConfigureSourceOutputSchema
+);
+var resolveStaticScopeInput = (ctx, value) => String(
+  ctx.scopes.find((scope) => scope.name === value || String(scope.id) === value)?.id ?? value
+);
 var toStoredSourceData = (config, remoteCredentials) => {
   if (config.transport === "stdio") {
     return {
@@ -969,6 +891,22 @@ var toBinding = (entry) => McpToolBinding.make({
   annotations: entry.annotations
 });
 var MCP_PLUGIN_ID = "mcp";
+var McpTextContent = Schema5.Struct({ type: Schema5.Literal("text"), text: Schema5.String });
+var McpToolCallEnvelope = Schema5.Struct({
+  isError: Schema5.optional(Schema5.Boolean),
+  content: Schema5.optional(Schema5.Array(Schema5.Unknown))
+});
+var decodeMcpTextContent = Schema5.decodeUnknownOption(McpTextContent);
+var decodeMcpToolCallEnvelope = Schema5.decodeUnknownOption(McpToolCallEnvelope);
+var extractMcpErrorMessage = (content) => {
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      const decoded = Option5.getOrUndefined(decodeMcpTextContent(item));
+      if (decoded !== void 0 && decoded.text.length > 0) return decoded.text;
+    }
+  }
+  return "MCP tool returned an error";
+};
 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);
@@ -991,26 +929,6 @@ var userFacingProbeMessage = (shape) => {
 };
 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) => McpSourceBindingRef.make({
-  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);
@@ -1023,7 +941,7 @@ var resolveMcpSourceBinding = (ctx, sourceId, sourceScope, slot) => Effect6.gen(
   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;
+  return binding ?? null;
 });
 var validateMcpBindingTarget = (ctx, input) => Effect6.gen(function* () {
   const ranks = scopeRanks(ctx);
@@ -1049,108 +967,64 @@ var validateMcpBindingTarget = (ctx, input) => Effect6.gen(function* () {
     });
   }
 });
-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 = [];
+var canonicalizeCredentialMap = compileHttpNamedCredentialMap;
+var canonicalizeConfiguredValueMap = (values, slotForName) => {
+  const next = {};
   for (const [name, value] of Object.entries(values ?? {})) {
     if (typeof value === "string") {
-      nextValues[name] = value;
+      next[name] = value;
       continue;
     }
-    if ("kind" in value) {
-      nextValues[name] = value;
-      continue;
-    }
-    const slot = slotForName(name);
-    nextValues[name] = ConfiguredCredentialBinding2.make({
+    next[name] = {
       kind: "binding",
-      slot,
+      slot: slotForName(name),
       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 };
+  return next;
 };
-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 } : {}
-          }
-        }
-      ]
-    };
+var resolveConfiguredValueMap = (values) => {
+  if (!values) return void 0;
+  const resolved = {};
+  for (const [name, value] of Object.entries(values)) {
+    if (typeof value === "string") resolved[name] = value;
   }
-  if ("connectionSlot" in auth) return { auth, bindings: [] };
-  const bindings = [
-    {
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+};
+var authFromOAuth2Source = (oauth2) => oauth2 ? {
+  kind: "oauth2",
+  connectionSlot: oauth2.connectionSlot,
+  clientIdSlot: oauth2.clientIdSlot,
+  ...oauth2.clientSecretSlot ? { clientSecretSlot: oauth2.clientSecretSlot } : {}
+} : { kind: "none" };
+var canonicalizeAuth = (auth) => {
+  if (!auth || "kind" in auth || !auth.oauth2) return { auth: { kind: "none" }, bindings: [] };
+  const oauth = auth.oauth2;
+  const bindings = [];
+  if (oauth.connection) {
+    bindings.push({
       slot: MCP_OAUTH_CONNECTION_SLOT,
-      value: {
-        kind: "connection",
-        connectionId: ConnectionId.make(auth.connectionId)
-      }
-    }
-  ];
-  if (auth.clientIdSecretId) {
+      value: httpCredentialInputToBindingValue(oauth.connection)
+    });
+  }
+  if (oauth.clientId) {
     bindings.push({
       slot: MCP_OAUTH_CLIENT_ID_SLOT,
-      value: { kind: "secret", secretId: SecretId.make(auth.clientIdSecretId) }
+      value: httpCredentialInputToBindingValue(oauth.clientId)
     });
   }
-  if (auth.clientSecretSecretId) {
+  if (oauth.clientSecret) {
     bindings.push({
       slot: MCP_OAUTH_CLIENT_SECRET_SLOT,
-      value: { kind: "secret", secretId: SecretId.make(auth.clientSecretSecretId) }
+      value: httpCredentialInputToBindingValue(oauth.clientSecret)
     });
   }
   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 } : {}
+      ...oauth.clientId ? { clientIdSlot: MCP_OAUTH_CLIENT_ID_SLOT } : {},
+      ...oauth.clientSecret ? { clientSecretSlot: MCP_OAUTH_CLIENT_SECRET_SLOT } : {}
     },
     bindings
   };
@@ -1189,21 +1063,32 @@ var resolveSecretBackedMap = (values, ctx) => resolveSharedSecretBackedMap({
     transport: "remote",
     message: `Failed to resolve secret "${value.secretId}"`
   }),
-  onError: (err, _name, value) => Predicate2.isTagged("SecretOwnedByConnectionError")(err) ? new McpConnectionError({
+  onError: (err, _name, value) => Predicate3.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
+    (err) => Predicate3.isTagged("SecretOwnedByConnectionError")(err) ? new McpConnectionError({ transport: "remote", message: "Failed to resolve secret" }) : err
   )
 );
-var plainStringMap = (values) => {
+var credentialInputMapToConfigValues = (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;
+  const out = {};
+  for (const [name, value] of Object.entries(values)) {
+    if (typeof value === "string") {
+      out[name] = value;
+      continue;
+    }
+    if (value.kind === "secret" && "secretId" in value) {
+      out[name] = headerToConfigValue({ secretId: value.secretId, prefix: value.prefix });
+      continue;
+    }
+    if (value.kind === "text") {
+      out[name] = value.prefix ? `${value.prefix}${value.text}` : value.text;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
 };
 var resolveMcpBindingValueMap = (ctx, values, params) => Effect6.gen(function* () {
   if (!values) return void 0;
@@ -1251,49 +1136,58 @@ var resolveMcpBindingValueMap = (ctx, values, params) => Effect6.gen(function* (
   }
   return Object.keys(resolved).length > 0 ? resolved : void 0;
 });
-var resolveMcpCredentialInputMap = (ctx, values, params) => Effect6.gen(function* () {
-  if (!values) return void 0;
+var resolveInitialMcpCredentialValueMap = (ctx, values, bindings, targetScope, missingLabel) => Effect6.gen(function* () {
+  const bySlot = new Map(bindings.map((binding) => [binding.slot, binding.value]));
   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
-        }
+    const binding = bySlot.get(value.slot);
+    if (binding?.kind === "secret") {
+      const secret = yield* ctx.secrets.getAtScope(binding.secretId, binding.secretScopeId ?? ScopeId.make(targetScope)).pipe(
+        Effect6.catchTag(
+          "SecretOwnedByConnectionError",
+          () => Effect6.fail(
+            new McpConnectionError({
+              transport: "remote",
+              message: `Failed to resolve secret for ${missingLabel} "${name}"`
+            })
+          )
+        )
       );
-      if (slotResolved?.[name] !== void 0) resolved[name] = slotResolved[name];
+      if (secret === null) {
+        return yield* new McpConnectionError({
+          transport: "remote",
+          message: `Missing secret "${binding.secretId}" for ${missingLabel} "${name}"`
+        });
+      }
+      resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
       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}"`
-      });
+    if (binding?.kind === "text") {
+      resolved[name] = value.prefix ? `${value.prefix}${binding.text}` : binding.text;
     }
-    resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
   }
   return Object.keys(resolved).length > 0 ? resolved : void 0;
 });
+var resolveInitialMcpOauthProvider = (ctx, bindings, targetScope) => Effect6.gen(function* () {
+  const connection = bindings.find(
+    (binding) => binding.slot === MCP_OAUTH_CONNECTION_SLOT && binding.value.kind === "connection"
+  );
+  if (!connection || connection.value.kind !== "connection") return void 0;
+  const connectionId = connection.value.connectionId;
+  const accessToken = yield* ctx.connections.accessTokenAtScope(connectionId, ScopeId.make(targetScope)).pipe(
+    Effect6.mapError(
+      ({ message }) => new McpConnectionError({
+        transport: "remote",
+        message: `Failed to resolve OAuth connection "${connectionId}": ${message}`
+      })
+    )
+  );
+  return makeOAuthProvider(accessToken);
+});
 var resolveMcpHeaderAuth = (ctx, sourceId, sourceScope, auth) => Effect6.gen(function* () {
   if (auth.kind !== "header") return {};
   const binding = yield* resolveMcpSourceBinding(ctx, sourceId, sourceScope, auth.secretSlot);
@@ -1347,60 +1241,6 @@ var resolveMcpStoredOauthProvider = (ctx, sourceId, sourceScope, auth) => Effect
   );
   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) {
@@ -1478,23 +1318,16 @@ var makeRuntime = () => Effect6.gen(function* () {
   }).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 ("kind" in auth) return { kind: "none" };
+  const connection = auth.oauth2?.connection;
+  if (!connection || typeof connection === "string" || connection.kind !== "connection") {
+    return void 0;
   }
-  if (!("connectionId" in auth)) return void 0;
   return {
     kind: "oauth2",
-    connectionId: auth.connectionId
+    connectionId: connection.connectionId
   };
 };
 var toCredentialInput = (bySlot, configured) => {
@@ -1503,7 +1336,9 @@ var toCredentialInput = (bySlot, configured) => {
   if (!value) return void 0;
   if (value.kind === "secret") {
     return {
+      kind: "secret",
       secretId: value.secretId,
+      ...value.secretScopeId ? { secretScope: value.secretScopeId } : {},
       ...configured.prefix ? { prefix: configured.prefix } : {}
     };
   }
@@ -1525,15 +1360,15 @@ var toAuthInput = (bySlot, auth) => {
     const value = bySlot.get(auth.secretSlot);
     if (value?.kind !== "secret") return void 0;
     return {
-      kind: "header",
-      headerName: auth.headerName,
-      secretId: value.secretId,
-      prefix: auth.prefix
+      kind: "none"
     };
   }
   const connection = bySlot.get(auth.connectionSlot);
-  if (connection?.kind !== "connection") return void 0;
-  return { kind: "oauth2", connectionId: connection.connectionId };
+  return {
+    oauth2: {
+      ...connection?.kind === "connection" ? { connection: { kind: "connection", connectionId: connection.connectionId } } : {}
+    }
+  };
 };
 var inputFormFromStored = (bindings, stored, scope, sourceName, namespace) => {
   if (stored.transport === "stdio") {
@@ -1581,8 +1416,8 @@ var toMcpConfigEntry = (namespace, sourceName, config) => {
     name: sourceName,
     endpoint: config.endpoint,
     remoteTransport: config.remoteTransport,
-    queryParams: plainStringMap(config.queryParams),
-    headers: plainStringMap(config.headers),
+    queryParams: credentialInputMapToConfigValues(config.queryParams),
+    headers: credentialInputMapToConfigValues(config.headers),
     namespace,
     auth: authToConfig(config.auth)
   };
@@ -1601,6 +1436,13 @@ var mcpPlugin = definePlugin((options) => {
   return {
     id: "mcp",
     packageName: "@executor-js/plugin-mcp",
+    sourcePresets: allowStdio ? mcpPresets.map((preset) => ({
+      ...preset,
+      transport: "transport" in preset ? preset.transport : "remote"
+    })) : mcpPresets.filter((preset) => !("transport" in preset && preset.transport === "stdio")).map((preset) => ({
+      ...preset,
+      transport: "remote"
+    })),
     // 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 —
@@ -1693,72 +1535,72 @@ var mcpPlugin = definePlugin((options) => {
       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)
+          headers: canonicalizeConfiguredValueMap(config.headers, mcpHeaderSlot),
+          queryParams: canonicalizeConfiguredValueMap(
+            config.queryParams,
+            mcpQueryParamSlot
+          )
         } : 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
-          );
+        const initialRemote = config.transport === "remote" && config.credentials ? {
+          scope: config.credentials.scope,
+          headers: config.credentials.headers !== void 0 ? canonicalizeCredentialMap(config.credentials.headers, mcpHeaderSlot) : null,
+          queryParams: config.credentials.queryParams !== void 0 ? canonicalizeCredentialMap(config.credentials.queryParams, mcpQueryParamSlot) : null,
+          auth: config.credentials.auth !== void 0 ? canonicalizeAuth(config.credentials.auth) : null
+        } : null;
+        const remoteAuth = config.transport === "remote" ? config.oauth2 ? authFromOAuth2Source(config.oauth2) : initialRemote?.auth?.auth ?? { kind: "none" } : null;
+        const remoteCredentials = canonicalRemote && remoteAuth ? {
+          headers: canonicalRemote.headers,
+          queryParams: canonicalRemote.queryParams,
+          auth: remoteAuth
+        } : void 0;
+        const initialBindings = [
+          ...initialRemote?.headers?.bindings ?? [],
+          ...initialRemote?.queryParams?.bindings ?? [],
+          ...initialRemote?.auth?.bindings ?? []
+        ];
+        if (initialRemote && initialBindings.length > 0) {
           yield* validateMcpBindingTarget(ctx, {
             sourceId: namespace,
             sourceScope: config.scope,
-            targetScope: bindingTargetScope2
+            targetScope: initialRemote.scope
           });
         }
-        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(
+        const sd = toStoredSourceData(config, remoteCredentials);
+        const initialQueryParams = initialRemote?.queryParams && (yield* resolveInitialMcpCredentialValueMap(
+          ctx,
+          canonicalRemote?.queryParams ?? initialRemote.queryParams.values,
+          initialRemote.queryParams.bindings,
+          initialRemote.scope,
+          "query parameter"
+        ));
+        const initialHeaders = initialRemote?.headers && (yield* resolveInitialMcpCredentialValueMap(
+          ctx,
+          canonicalRemote?.headers ?? initialRemote.headers.values,
+          initialRemote.headers.bindings,
+          initialRemote.scope,
+          "header"
+        ));
+        const remoteQueryParams = {
+          ...config.transport === "remote" ? resolveConfiguredValueMap(config.queryParams) ?? {} : {},
+          ...initialQueryParams || {}
+        };
+        const remoteHeaders = {
+          ...config.transport === "remote" ? resolveConfiguredValueMap(config.headers) ?? {} : {},
+          ...initialHeaders || {}
+        };
+        const initialAuthProvider = initialRemote?.auth !== null && initialRemote?.auth !== void 0 ? yield* resolveInitialMcpOauthProvider(
+          ctx,
+          initialRemote.auth.bindings,
+          initialRemote.scope
+        ) : void 0;
+        const resolved = config.transport === "remote" ? Result.succeed({
+          transport: "remote",
+          endpoint: config.endpoint,
+          remoteTransport: config.remoteTransport ?? "auto",
+          queryParams: Object.keys(remoteQueryParams).length > 0 ? remoteQueryParams : void 0,
+          headers: Object.keys(remoteHeaders).length > 0 ? remoteHeaders : void 0,
+          authProvider: initialAuthProvider
+        }) : yield* resolveConnectorInput(namespace, config.scope, sd, ctx, allowStdio).pipe(
           Effect6.result,
           Effect6.withSpan("mcp.plugin.resolve_connector", {
             attributes: {
@@ -1818,21 +1660,22 @@ var mcpPlugin = definePlugin((options) => {
                 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),
+            if (initialRemote && initialBindings.length > 0) {
+              yield* ctx.credentialBindings.replaceForSource({
+                targetScope: ScopeId.make(initialRemote.scope),
+                pluginId: MCP_PLUGIN_ID,
+                sourceId: namespace,
+                sourceScope: ScopeId.make(config.scope),
+                slotPrefixes: [
+                  ...initialRemote.headers !== null ? ["header:"] : [],
+                  ...initialRemote.queryParams !== null ? ["query_param:"] : [],
+                  ...initialRemote.auth !== null ? ["auth:"] : []
+                ],
+                bindings: initialBindings.map((binding) => ({
                   slotKey: binding.slot,
                   value: binding.value
-                });
-              }
+                }))
+              });
             }
           })
         ).pipe(
@@ -1955,8 +1798,25 @@ var mcpPlugin = definePlugin((options) => {
           attributes: { "mcp.source.namespace": namespace }
         })
       );
-      const updateSource = (namespace, scope, input) => Effect6.gen(function* () {
-        const existing = yield* ctx.storage.getSource(namespace, scope);
+      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
+      };
+    },
+    sourceConfigure: {
+      type: "mcp",
+      schema: McpConfigureSourcePayloadSchema,
+      configure: ({ ctx, sourceId, sourceScope, targetScope, config }) => Effect6.gen(function* () {
+        const input = config;
+        const existing = yield* ctx.storage.getSource(sourceId, sourceScope);
         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;
@@ -1966,46 +1826,40 @@ var mcpPlugin = definePlugin((options) => {
           ...canonicalQueryParams?.bindings ?? [],
           ...canonicalAuth?.bindings ?? []
         ];
-        const targetScope = yield* bindingTargetScope(
-          input.credentialTargetScope,
-          directBindings
-        );
-        if (targetScope) {
+        if (directBindings.length > 0) {
           yield* validateMcpBindingTarget(ctx, {
-            sourceId: namespace,
-            sourceScope: scope,
+            sourceId,
+            sourceScope,
             targetScope
           });
         }
-        const remote = existing.config;
         const updatedConfig = {
-          ...remote,
+          ...existing.config,
           ...input.endpoint !== void 0 ? { endpoint: input.endpoint } : {},
           ...canonicalHeaders ? { headers: canonicalHeaders.values } : {},
           ...canonicalAuth ? { auth: canonicalAuth.auth } : {},
           ...canonicalQueryParams ? { queryParams: canonicalQueryParams.values } : {}
         };
-        const sourceName = input.name?.trim() || existing.name;
         const affectedPrefixes = [
           ...input.headers !== void 0 ? ["header:"] : [],
           ...input.queryParams !== void 0 ? ["query_param:"] : [],
           ...input.auth !== void 0 ? ["auth:"] : []
         ];
-        const replacementTargetScope = targetScope ?? input.credentialTargetScope ?? scope;
+        const sourceName = input.name?.trim() || existing.name;
         yield* ctx.transaction(
           Effect6.gen(function* () {
             yield* ctx.storage.putSource({
-              namespace,
-              scope,
+              namespace: sourceId,
+              scope: sourceScope,
               name: sourceName,
               config: updatedConfig
             });
             if (affectedPrefixes.length > 0 || directBindings.length > 0) {
               yield* ctx.credentialBindings.replaceForSource({
-                targetScope: ScopeId.make(replacementTargetScope),
+                targetScope: ScopeId.make(targetScope),
                 pluginId: MCP_PLUGIN_ID,
-                sourceId: namespace,
-                sourceScope: ScopeId.make(scope),
+                sourceId,
+                sourceScope: ScopeId.make(sourceScope),
                 slotPrefixes: affectedPrefixes,
                 bindings: directBindings.map((binding) => ({
                   slotKey: binding.slot,
@@ -2015,71 +1869,168 @@ var mcpPlugin = definePlugin((options) => {
             }
           })
         );
-        if (configFile) {
+        if (options?.configFile) {
           const bindings = yield* ctx.credentialBindings.listForSource({
             pluginId: MCP_PLUGIN_ID,
-            sourceId: namespace,
-            sourceScope: ScopeId.make(scope)
+            sourceId,
+            sourceScope: ScopeId.make(sourceScope)
           });
           const inputForm = inputFormFromStored(
             bindings,
             updatedConfig,
-            scope,
+            sourceScope,
             sourceName,
-            namespace
+            sourceId
           );
-          yield* configFile.upsertSource(toMcpConfigEntry(namespace, sourceName, inputForm)).pipe(Effect6.withSpan("mcp.plugin.config_file.upsert"));
+          yield* options.configFile.upsertSource(toMcpConfigEntry(sourceId, sourceName, inputForm)).pipe(Effect6.withSpan("mcp.plugin.config_file.upsert"));
         }
-      }).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
-          });
-        })
-      };
+      })
     },
+    staticSources: (self) => [
+      {
+        id: "mcp",
+        kind: "executor",
+        name: "MCP",
+        tools: [
+          tool({
+            name: "probeEndpoint",
+            description: "Probe a remote MCP endpoint before adding it. If the result requires OAuth, call `executor.coreTools.oauth.probe` and `executor.coreTools.oauth.start` with `credentialScope` set to the user's chosen personal or organization credential scope first, then pass the resulting connection through `addSource` credentials or `mcp.configureSource`.",
+            inputSchema: McpProbeEndpointInputStandardSchema,
+            outputSchema: McpProbeEndpointOutputStandardSchema,
+            execute: (input) => self.probeEndpoint(input).pipe(
+              Effect6.map(ToolResult.ok),
+              Effect6.catchTag(
+                "McpConnectionError",
+                ({ message, transport }) => Effect6.succeed(mcpToolFailure("mcp_connection_failed", message, { transport }))
+              )
+            )
+          }),
+          tool({
+            name: "getSource",
+            description: "Inspect an existing MCP source, including transport, endpoint/command, auth mode, configured headers/query params, and credential slots. Use this before repairing an existing source with `mcp.configureSource`, `secrets.create`, or `oauth.start`.",
+            inputSchema: McpGetSourceInputStandardSchema,
+            outputSchema: McpGetSourceOutputStandardSchema,
+            execute: (input, { ctx }) => {
+              const args = input;
+              return Effect6.map(
+                self.getSource(args.namespace, resolveStaticScopeInput(ctx, args.scope)),
+                (source) => ToolResult.ok({ source })
+              );
+            }
+          }),
+          tool({
+            name: "addSource",
+            description: "Add an MCP source and register its tools. Executor chooses the source install scope (local scope locally, organization scope in cloud) and returns it as `source`. For remote OAuth-protected servers, first use `probeEndpoint` and the core OAuth browser handoff (`oauth.probe`, `oauth.start` with the user's chosen `credentialScope`), then bind the completed connection with `mcp.configureSource` if needed. For header/API-key auth, first call `secrets.create` at the user's chosen credential scope so the value is entered in the browser, then pass the secret reference in `credentials`. Remote sources are still saved if discovery fails; inspect the returned `discovery` field and use `sources.refresh` after credentials or network access are fixed.",
+            annotations: {
+              requiresApproval: true,
+              approvalDescription: "Add an MCP source"
+            },
+            inputSchema: McpAddSourceInputStandardSchema,
+            outputSchema: McpAddSourceOutputStandardSchema,
+            execute: (rawInput, { ctx }) => {
+              const input = rawInput;
+              const sourceScope = defaultSourceInstallScopeId(ctx.scopes);
+              if (sourceScope === null) {
+                return Effect6.succeed(
+                  mcpToolFailure(
+                    "source_scope_unavailable",
+                    "Cannot add an MCP source because this executor has no source install scope."
+                  )
+                );
+              }
+              const normalizedInput = {
+                ...input,
+                scope: sourceScope
+              };
+              const added = self.addSource(normalizedInput).pipe(
+                Effect6.map(
+                  (result) => ToolResult.ok({
+                    ...result,
+                    source: { id: result.namespace, scope: sourceScope },
+                    discovery: { status: "ok" }
+                  })
+                )
+              );
+              if (normalizedInput.transport !== "remote") return added;
+              const savedWithDiscoveryFailure = (failure) => Effect6.succeed(
+                ToolResult.ok({
+                  namespace: normalizedInput.namespace ?? deriveMcpNamespace({
+                    name: normalizedInput.name,
+                    endpoint: normalizedInput.endpoint
+                  }),
+                  source: {
+                    id: normalizedInput.namespace ?? deriveMcpNamespace({
+                      name: normalizedInput.name,
+                      endpoint: normalizedInput.endpoint
+                    }),
+                    scope: sourceScope
+                  },
+                  toolCount: 0,
+                  discovery: {
+                    status: "failed",
+                    message: failure.message,
+                    ...failure.stage ? { stage: failure.stage } : {}
+                  }
+                })
+              );
+              return added.pipe(
+                Effect6.catchTags({
+                  McpToolDiscoveryError: savedWithDiscoveryFailure,
+                  McpConnectionError: ({ message }) => Effect6.succeed(
+                    ToolResult.ok({
+                      namespace: normalizedInput.namespace ?? deriveMcpNamespace({
+                        name: normalizedInput.name,
+                        endpoint: normalizedInput.endpoint
+                      }),
+                      source: {
+                        id: normalizedInput.namespace ?? deriveMcpNamespace({
+                          name: normalizedInput.name,
+                          endpoint: normalizedInput.endpoint
+                        }),
+                        scope: sourceScope
+                      },
+                      toolCount: 0,
+                      discovery: {
+                        status: "failed",
+                        message
+                      }
+                    })
+                  )
+                })
+              );
+            }
+          }),
+          tool({
+            name: "configureSource",
+            description: 'Configure an existing remote MCP source with concrete fields. Use `source` returned by `mcp.addSource` or `sources.list`. The top-level `scope` is the credential target scope for bindings; in cloud, choose the user or organization credential scope deliberately. Pass secret refs as `{kind:"secret", secretId}` and OAuth connections as `{kind:"connection", connectionId}`.',
+            annotations: {
+              requiresApproval: true,
+              approvalDescription: "Configure an MCP source"
+            },
+            inputSchema: McpStaticConfigureSourceInputStandardSchema,
+            outputSchema: McpStaticConfigureSourceOutputStandardSchema,
+            execute: (rawInput, { ctx }) => Effect6.gen(function* () {
+              const { source, ...config } = rawInput;
+              const sourceScope = resolveStaticScopeInput(ctx, source.scope);
+              const targetScope = resolveStaticScopeInput(ctx, config.scope);
+              yield* ctx.core.sources.configure({
+                source: { id: source.id, scope: sourceScope },
+                scope: targetScope,
+                type: "mcp",
+                config: {
+                  ...config.name !== void 0 ? { name: config.name } : {},
+                  ...config.endpoint !== void 0 ? { endpoint: config.endpoint } : {},
+                  ...config.headers !== void 0 ? { headers: config.headers } : {},
+                  ...config.queryParams !== void 0 ? { queryParams: config.queryParams } : {},
+                  ...config.auth !== void 0 ? { auth: config.auth } : {}
+                }
+              });
+              return ToolResult.ok({ configured: true });
+            })
+          })
+        ]
+      }
+    ],
     invokeTool: ({ ctx, toolRow, args, elicit }) => Effect6.gen(function* () {
       const runtime = yield* ensureRuntime();
       const toolScope = toolRow.scope_id;
@@ -2105,7 +2056,7 @@ var mcpPlugin = definePlugin((options) => {
           message: `No MCP source config for namespace "${entry.namespace}"`
         });
       }
-      return yield* invokeMcpTool({
+      const raw = yield* invokeMcpTool({
         toolId: toolRow.id,
         toolName: entry.binding.toolName,
         args,
@@ -2140,6 +2091,15 @@ var mcpPlugin = definePlugin((options) => {
         pendingConnectors: runtime.pendingConnectors,
         elicit
       });
+      const envelope = Option5.getOrUndefined(decodeMcpToolCallEnvelope(raw));
+      if (envelope?.isError === true) {
+        return ToolResult.fail({
+          code: "mcp_tool_error",
+          message: extractMcpErrorMessage(envelope.content),
+          details: { content: envelope.content }
+        });
+      }
+      return ToolResult.ok(raw);
     }).pipe(
       Effect6.withSpan("mcp.plugin.invoke_tool", {
         attributes: {
@@ -2206,8 +2166,8 @@ var mcpPlugin = definePlugin((options) => {
     // 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.
+    // row rather than collapsing onto whichever visible row would otherwise
+    // win first.
     resolveAnnotations: ({ ctx, sourceId, toolRows }) => Effect6.gen(function* () {
       const scopes = new Set(toolRows.map((row) => row.scope_id));
       const entries = yield* Effect6.forEach(
@@ -2274,4 +2234,4 @@ export {
   makeMcpStore,
   mcpPlugin
 };
-//# sourceMappingURL=chunk-NQT7NAGE.js.map
+//# sourceMappingURL=chunk-H5PLTEMB.js.map