Share secret-backed credential values (#454)

Rhys Sullivan committed 6 months ago

Commit 9639a681 parent 899a99e17 files · +768 −954Browse files

Unified · Split

17 files

packages/core/api/src/handlers/oauth.ts +31 −39
packages/core/api/src/oauth/api.ts +3 −15
packages/core/sdk/src/index.ts +10 −15
packages/core/sdk/src/secret-backed-value.ts +72 −0
packages/plugins/google-discovery/src/api/group.ts +2 −13
packages/plugins/google-discovery/src/sdk/plugin.ts +61 −120
packages/plugins/google-discovery/src/sdk/types.ts +4 −11
packages/plugins/graphql/src/sdk/invoke.ts +8 −26
packages/plugins/graphql/src/sdk/types.ts +14 −37
packages/plugins/mcp/src/api/group.ts +7 −16
packages/plugins/mcp/src/sdk/plugin.ts +521 −587
packages/plugins/mcp/src/sdk/types.ts +3 −10
packages/plugins/openapi/src/api/group.ts +1 −9
packages/plugins/openapi/src/sdk/plugin.ts +18 −25
packages/plugins/openapi/src/sdk/types.ts +6 −16
packages/react/src/plugins/http-credentials.tsx +2 −7
packages/react/src/plugins/oauth-sign-in.tsx +5 −8

packages/core/api/src/handlers/oauth.ts+31−39

   OAuthProbeError,
   OAuthSessionNotFoundError,
   OAuthStartError,
+  resolveSecretBackedMap,
   type Executor,
   type OAuthStrategy,
+  type SecretBackedValue,
 } from "@executor/sdk";
 import { ExecutorApi } from "../api";
 const OAUTH_POPUP_CHANNEL = OAUTH_POPUP_MESSAGE_TYPE;
-type SecretBackedValue =
+const resolveOAuthSecretBackedMap = (
-  | string
-  | { readonly secretId: string; readonly prefix?: string };
-const resolveSecretBackedMap = (
   executor: Executor,
   values: Record<string, SecretBackedValue> | undefined,
   makeError: (message: string) => OAuthProbeError | OAuthStartError,
 ) =>
-  Effect.gen(function* () {
+  resolveSecretBackedMap({
-    const resolved: Record<string, string> = {};
+    values,
-    for (const [name, value] of Object.entries(values ?? {})) {
+    getSecret: executor.secrets.get,
-      if (typeof value === "string") {
+    onMissing: (name) => makeError(`Secret not found for "${name}"`),
-        resolved[name] = value;
+    onError: (_error, name) => makeError(`Secret not found for "${name}"`),
-        continue;
+  }).pipe(
-      }
+    Effect.mapError((error) =>
-      const secret = yield* executor.secrets.get(value.secretId).pipe(
+      error instanceof OAuthProbeError || error instanceof OAuthStartError
-        Effect.mapError(() => makeError(`Secret not found for "${name}"`)),
+        ? error
-      );
+        : makeError("Secret resolution failed"),
-      if (secret === null) {
+    ),
-        return yield* Effect.fail(makeError(`Secret not found for "${name}"`));
+  );
-      }
-      resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
-    }
-    return Object.keys(resolved).length > 0 ? resolved : undefined;
-  });
 const toPopupErrorMessage = (error: unknown): string => {
   if (error instanceof OAuthStartError) return error.message;
       capture(
         Effect.gen(function* () {
           const executor = yield* ExecutorService;
-          const headers = yield* resolveSecretBackedMap(
+          const headers = yield* resolveOAuthSecretBackedMap(
             executor,
             payload.headers,
             (message) => new OAuthProbeError({ message }),
           );
-          const queryParams = yield* resolveSecretBackedMap(
+          const queryParams = yield* resolveOAuthSecretBackedMap(
             executor,
             payload.queryParams,
             (message) => new OAuthProbeError({ message }),
       capture(
         Effect.gen(function* () {
           const executor = yield* ExecutorService;
-          const tokenScope =
+          const tokenScope = payload.tokenScope ?? (executor.scopes[0]!.id as unknown as string);
-            payload.tokenScope ?? (executor.scopes[0]!.id as unknown as string);
+          const headers = yield* resolveOAuthSecretBackedMap(
-          const headers = yield* resolveSecretBackedMap(
             executor,
             payload.headers,
             (message) => new OAuthStartError({ message }),
           );
-          const queryParams = yield* resolveSecretBackedMap(
+          const queryParams = yield* resolveOAuthSecretBackedMap(
             executor,
             payload.queryParams,
             (message) => new OAuthStartError({ message }),
           const executor = yield* ExecutorService;
           const html = yield* runOAuthCallback({
             complete: ({ state, code, error }) =>
-              executor.oauth.complete({
+              executor.oauth
-                state,
+                .complete({
-                code: code ?? undefined,
+                  state,
-                error: error ?? undefined,
+                  code: code ?? undefined,
-              }).pipe(
+                  error: error ?? undefined,
-                Effect.tapErrorCause((cause) =>
+                })
-                  Effect.logError("OAuth callback completion failed", cause),
+                .pipe(
-                ),
+                  Effect.tapErrorCause((cause) =>
-                Effect.catchAllCause(() =>
+                    Effect.logError("OAuth callback completion failed", cause),
-                  Effect.fail(new Error("Authentication failed")),
+                  ),
+                  Effect.catchAllCause(() => Effect.fail(new Error("Authentication failed"))),
                 ),
-              ),
             urlParams,
             toErrorMessage: toPopupErrorMessage,
             channelName: OAUTH_POPUP_CHANNEL,

packages/core/api/src/oauth/api.ts+3−15

   OAuthStartError,
   OAuthStrategySchema,
   ScopeId,
+  SecretBackedMap,
 } from "@executor/sdk";
 import { InternalError } from "../observability";
 const scopeIdParam = HttpApiSchema.param("scopeId", ScopeId);
-const SecretBackedValue = Schema.Union(
-  Schema.String,
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
-const SecretBackedMap = Schema.Record({ key: Schema.String, value: SecretBackedValue });
 // ---------------------------------------------------------------------------
 // Probe — decide between dynamic-DCR and paste-your-credentials flows
 // ---------------------------------------------------------------------------
 });
 const ProbeResponse = Schema.Struct({
-  resourceMetadata: Schema.NullOr(
+  resourceMetadata: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
-    Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-  ),
   resourceMetadataUrl: Schema.NullOr(Schema.String),
   authorizationServerMetadata: Schema.NullOr(
     Schema.Record({ key: Schema.String, value: Schema.Unknown }),
    *  `client-credentials` (no redirect). */
   authorizationUrl: Schema.NullOr(Schema.String),
   /** Filled for strategies that mint the Connection inline. */
-  completedConnection: Schema.NullOr(
+  completedConnection: Schema.NullOr(Schema.Struct({ connectionId: Schema.String })),
-    Schema.Struct({ connectionId: Schema.String }),
-  ),
 });
 // ---------------------------------------------------------------------------

packages/core/sdk/src/index.ts+10−15

 } from "./policies";
 // Secrets
+export { SecretRef, SetSecretInput, type SecretProvider } from "./secrets";
 export {
-  SecretRef,
+  SecretBackedMap,
-  SetSecretInput,
+  SecretBackedValue,
-  type SecretProvider,
+  isSecretBackedRef,
-} from "./secrets";
+  resolveSecretBackedMap,
+  type ResolveSecretBackedMapOptions,
+} from "./secret-backed-value";
 // Connections
 export {
 } from "./executor";
 // CLI config
-export {
+export { defineExecutorConfig, type ExecutorCliConfig, type ExecutorDialect } from "./config";
-  defineExecutorConfig,
-  type ExecutorCliConfig,
-  type ExecutorDialect,
-} from "./config";
 // Test helper
 export { makeTestConfig } from "./testing";
 // JSON schema $ref helpers (used by openapi for $defs handling)
-export {
+export { hoistDefinitions, collectRefs, reattachDefs, normalizeRefs } from "./schema-refs";
-  hoistDefinitions,
-  collectRefs,
-  reattachDefs,
-  normalizeRefs,
-} from "./schema-refs";
 // TypeScript preview generation from JSON schemas
 export {

packages/core/sdk/src/secret-backed-value.ts+72−0

@@ -0,0 +1,72 @@
	1	import { Effect, Schema } from "effect";
	2
	3	export const SecretBackedValue = Schema.Union(
	4	Schema.String,
	5	Schema.Struct({
	6	secretId: Schema.String,
	7	prefix: Schema.optional(Schema.String),
	8	}),
	9	);
	10	export type SecretBackedValue = typeof SecretBackedValue.Type;
	11
	12	export const SecretBackedMap = Schema.Record({
	13	key: Schema.String,
	14	value: SecretBackedValue,
	15	});
	16	export type SecretBackedMap = typeof SecretBackedMap.Type;
	17
	18	export const isSecretBackedRef = (
	19	value: SecretBackedValue,
	20	): value is Extract<SecretBackedValue, { readonly secretId: string }> => typeof value !== "string";
	21
	22	export type ResolveSecretBackedMapOptions<E, E2> = {
	23	readonly values: Record<string, SecretBackedValue> \| undefined;
	24	readonly getSecret: (secretId: string) => Effect.Effect<string \| null, E>;
	25	readonly onMissing: (
	26	name: string,
	27	value: Extract<SecretBackedValue, { readonly secretId: string }>,
	28	) => E2;
	29	readonly onError?: (
	30	error: E,
	31	name: string,
	32	value: Extract<SecretBackedValue, { readonly secretId: string }>,
	33	) => E \| E2;
	34	readonly missing?: "fail" \| "drop";
	35	};
	36
	37	export const resolveSecretBackedMap = <E, E2 = E>({
	38	values,
	39	getSecret,
	40	onMissing,
	41	onError,
	42	missing = "fail",
	43	}: ResolveSecretBackedMapOptions<E, E2>): Effect.Effect<
	44	Record<string, string> \| undefined,
	45	E \| E2
	46	> => {
	47	const entries = Object.entries(values ?? {});
	48	if (entries.length === 0) return Effect.succeed(undefined);
	49
	50	return Effect.gen(function* () {
	51	const resolved: Record<string, string> = {};
	52
	53	for (const [name, value] of entries) {
	54	if (typeof value === "string") {
	55	resolved[name] = value;
	56	continue;
	57	}
	58
	59	const secret = yield* getSecret(value.secretId).pipe(
	60	Effect.mapError((error) => onError?.(error, name, value) ?? error),
	61	);
	62	if (secret === null) {
	63	if (missing === "drop") continue;
	64	return yield* Effect.fail(onMissing(name, value));
	65	}
	66
	67	resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
	68	}
	69
	70	return Object.keys(resolved).length > 0 ? resolved : undefined;
	71	});
	72	};

packages/plugins/google-discovery/src/api/group.ts+2−13

 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "@effect/platform";
 import { Schema } from "effect";
-import { ScopeId } from "@executor/sdk";
+import { ScopeId, SecretBackedValue } from "@executor/sdk";
 import { InternalError } from "@executor/api";
-import {
+import { GoogleDiscoveryParseError, GoogleDiscoverySourceError } from "../sdk/errors";
-  GoogleDiscoveryParseError,
-  GoogleDiscoverySourceError,
-} from "../sdk/errors";
 import { GoogleDiscoveryStoredSourceSchema } from "../sdk/stored-source";
 export { HttpApiSchema };
 const scopeIdParam = HttpApiSchema.param("scopeId", ScopeId);
 const namespaceParam = HttpApiSchema.param("namespace", Schema.String);
-const SecretBackedValue = Schema.Union(
-  Schema.String,
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
 const DiscoveryCredentialsPayload = Schema.Struct({
   headers: Schema.optional(Schema.Record({ key: Schema.String, value: SecretBackedValue })),
   queryParams: Schema.optional(Schema.Record({ key: Schema.String, value: SecretBackedValue })),

packages/plugins/google-discovery/src/sdk/plugin.ts+61−120

 import {
   SourceDetectionResult,
   definePlugin,
+  resolveSecretBackedMap,
   type PluginCtx,
   type StorageFailure,
   type ToolAnnotations,
 } from "./binding-store";
 import { extractGoogleDiscoveryManifest } from "./document";
 import { annotationsForOperation, invokeGoogleDiscoveryTool } from "./invoke";
-import {
+import { GoogleDiscoveryParseError, GoogleDiscoverySourceError } from "./errors";
-  GoogleDiscoveryParseError,
-  GoogleDiscoverySourceError,
-} from "./errors";
 import type {
   GoogleDiscoveryAuth,
   GoogleDiscoveryFetchCredentials,
     { readonly toolCount: number; readonly namespace: string },
     GoogleDiscoveryParseError | GoogleDiscoverySourceError | StorageFailure
   >;
-  readonly removeSource: (
+  readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
-    namespace: string,
-    scope: string,
-  ) => Effect.Effect<void, StorageFailure>;
   readonly getSource: (
     namespace: string,
     scope: string,
   credentials: GoogleDiscoveryFetchCredentials | undefined,
   ctx: PluginCtx<GoogleDiscoveryStore>,
 ): Effect.Effect<
-  | { headers?: Record<string, string>; queryParams?: Record<string, string> }
+  { headers?: Record<string, string>; queryParams?: Record<string, string> } | undefined,
-  | undefined,
   GoogleDiscoverySourceError
 > =>
   Effect.gen(function* () {
     if (!credentials) return undefined;
-    const headers: Record<string, string> = {};
+    const headers = yield* resolveSecretBackedMap({
-    for (const [name, value] of Object.entries(credentials.headers ?? {})) {
+      values: credentials.headers,
-      if (typeof value === "string") {
+      getSecret: ctx.secrets.get,
-        headers[name] = value;
+      onMissing: (name) =>
-        continue;
+        new GoogleDiscoverySourceError({
-      }
-      const secret = yield* ctx.secrets.get(value.secretId).pipe(
-        Effect.mapError(
-          () =>
-            new GoogleDiscoverySourceError({
-              message: `Secret not found for header "${name}"`,
-            }),
-        ),
-      );
-      if (secret === null) {
-        return yield* new GoogleDiscoverySourceError({
           message: `Secret not found for header "${name}"`,
-        });
+        }),
-      }
+      onError: (_error, name) =>
-      headers[name] = value.prefix ? `${value.prefix}${secret}` : secret;
+        new GoogleDiscoverySourceError({
-    }
+          message: `Secret not found for header "${name}"`,
-    const queryParams: Record<string, string> = {};
+        }),
-    for (const [name, value] of Object.entries(credentials.queryParams ?? {})) {
+    }).pipe(
-      if (typeof value === "string") {
+      Effect.mapError((err) =>
-        queryParams[name] = value;
+        err instanceof GoogleDiscoverySourceError
-        continue;
+          ? err
-      }
+          : new GoogleDiscoverySourceError({ message: "Secret resolution failed" }),
-      const secret = yield* ctx.secrets.get(value.secretId).pipe(
+      ),
-        Effect.mapError(
+    );
-          () =>
+    const queryParams = yield* resolveSecretBackedMap({
-            new GoogleDiscoverySourceError({
+      values: credentials.queryParams,
-              message: `Secret not found for query parameter "${name}"`,
+      getSecret: ctx.secrets.get,
-            }),
+      onMissing: (name) =>
-        ),
+        new GoogleDiscoverySourceError({
-      );
-      if (secret === null) {
-        return yield* new GoogleDiscoverySourceError({
           message: `Secret not found for query parameter "${name}"`,
-        });
+        }),
-      }
+      onError: (_error, name) =>
-      queryParams[name] = value.prefix ? `${value.prefix}${secret}` : secret;
+        new GoogleDiscoverySourceError({
-    }
+          message: `Secret not found for query parameter "${name}"`,
+        }),
+    }).pipe(
+      Effect.mapError((err) =>
+        err instanceof GoogleDiscoverySourceError
+          ? err
+          : new GoogleDiscoverySourceError({ message: "Secret resolution failed" }),
+      ),
+    );
     return {
-      ...(Object.keys(headers).length > 0 ? { headers } : {}),
+      ...(headers ? { headers } : {}),
-      ...(Object.keys(queryParams).length > 0 ? { queryParams } : {}),
+      ...(queryParams ? { queryParams } : {}),
     };
   });
   Effect.tryPromise({
     try: async () => {
       const url = new URL(normalizeDiscoveryUrl(discoveryUrl));
-      for (const [key, value] of Object.entries(
+      for (const [key, value] of Object.entries(credentials?.queryParams ?? {})) {
-        credentials?.queryParams ?? {},
-      )) {
         url.searchParams.set(key, value);
       }
       const response = await fetch(url.toString(), {
     .replace(/[^a-z0-9]+/g, "_")
     .replace(/^_+|_+$/g, "");
-const deriveNamespace = (input: {
+const deriveNamespace = (input: { name: string; service: string; version: string }): string =>
-  name: string;
-  service: string;
-  version: string;
-}): string =>
   normalizeSlug(
-    input.name ||
+    input.name || `google_${input.service}_${input.version.replace(/[^a-zA-Z0-9]+/g, "_")}`,
-      `google_${input.service}_${input.version.replace(/[^a-zA-Z0-9]+/g, "_")}`,
   ) || `google_${input.service}`;
 // Connection refresh state is owned by the canonical `"oauth2"`
         name: method.toolPath,
         description: Option.getOrElse(
           method.description,
-          () =>
+          () => `${method.binding.method.toUpperCase()} ${method.binding.pathTemplate}`,
-            `${method.binding.method.toUpperCase()} ${method.binding.pathTemplate}`,
         ),
         inputSchema: Option.getOrUndefined(method.inputSchema),
         outputSchema: Option.getOrUndefined(method.outputSchema),
     yield* Effect.forEach(
       manifest.methods,
       (method) =>
-        ctx.storage.putBinding(
+        ctx.storage.putBinding(`${namespace}.${method.toolPath}`, namespace, scope, method.binding),
-          `${namespace}.${method.toolPath}`,
-          namespace,
-          scope,
-          method.binding,
-        ),
       { discard: true },
     );
     ({
       probeDiscovery: (input) =>
         Effect.gen(function* () {
-          const discoveryUrl =
+          const discoveryUrl = typeof input === "string" ? input : input.discoveryUrl;
-            typeof input === "string" ? input : input.discoveryUrl;
           const credentials =
             typeof input === "string"
               ? undefined
-              : yield* resolveGoogleDiscoveryCredentials(
+              : yield* resolveGoogleDiscoveryCredentials(input.credentials, ctx);
-                  input.credentials,
-                  ctx,
-                );
           const text = yield* fetchDiscoveryDocument(discoveryUrl, credentials);
           const manifest = yield* extractGoogleDiscoveryManifest(text);
           const scopes = Object.keys(
-            manifest.oauthScopes._tag === "Some"
+            manifest.oauthScopes._tag === "Some" ? manifest.oauthScopes.value : {},
-              ? manifest.oauthScopes.value
-              : {},
           ).sort();
           const operations = manifest.methods.map((method) => ({
             toolPath: method.toolPath,
             method: method.binding.method,
             pathTemplate: method.binding.pathTemplate,
-            description:
+            description: method.description._tag === "Some" ? method.description.value : null,
-              method.description._tag === "Some"
-                ? method.description.value
-                : null,
           }));
           return {
             name:
       addSource: (input) =>
         ctx.transaction(
           Effect.gen(function* () {
-            const credentials = yield* resolveGoogleDiscoveryCredentials(
+            const credentials = yield* resolveGoogleDiscoveryCredentials(input.credentials, ctx);
-              input.credentials,
+            const text = yield* fetchDiscoveryDocument(input.discoveryUrl, credentials);
-              ctx,
-            );
-            const text = yield* fetchDiscoveryDocument(
-              input.discoveryUrl,
-              credentials,
-            );
             const manifest = yield* extractGoogleDiscoveryManifest(text);
             const namespace =
               input.namespace ??
       const typedCtx = ctx as PluginCtx<GoogleDiscoveryStore>;
       const scopes = new Set<string>();
       for (const row of toolRows) scopes.add(row.scope_id as string);
-      const byScope = new Map<
+      const byScope = new Map<string, ReadonlyMap<string, GoogleDiscoveryMethodBinding>>();
-        string,
-        ReadonlyMap<string, GoogleDiscoveryMethodBinding>
-      >();
       for (const scope of scopes) {
-        const bindings = yield* typedCtx.storage.getBindingsForSource(
+        const bindings = yield* typedCtx.storage.getBindingsForSource(sourceId, scope);
-          sourceId,
-          scope,
-        );
         byScope.set(scope, bindings);
       }
       const out: Record<string, ToolAnnotations> = {};
       for (const row of toolRows) {
         const binding = byScope.get(row.scope_id as string)?.get(row.id);
         if (binding) {
-          out[row.id] = annotationsForOperation(
+          out[row.id] = annotationsForOperation(binding.method, binding.pathTemplate);
-            binding.method,
-            binding.pathTemplate,
-          );
         }
       }
       return out;
     Effect.gen(function* () {
       const trimmed = url.trim();
       if (!trimmed) return null;
-      const parsed = yield* Effect.try(() => new URL(trimmed)).pipe(
+      const parsed = yield* Effect.try(() => new URL(trimmed)).pipe(Effect.option);
-        Effect.option,
-      );
       if (parsed._tag === "None") return null;
       const isGoogleUrl = trimmed.includes("googleapis.com");
-      const isDiscoveryPath =
+      const isDiscoveryPath = trimmed.includes("/discovery/") || trimmed.includes("$discovery");
-        trimmed.includes("/discovery/") || trimmed.includes("$discovery");
       if (!isGoogleUrl && !isDiscoveryPath) return null;
       const discoveryText = yield* fetchDiscoveryDocument(trimmed).pipe(
       );
       if (!discoveryText) return null;
-      const manifest = yield* extractGoogleDiscoveryManifest(
+      const manifest = yield* extractGoogleDiscoveryManifest(discoveryText).pipe(
-        discoveryText,
+        Effect.catchAll(() => Effect.succeed(null)),
-      ).pipe(Effect.catchAll(() => Effect.succeed(null)));
+      );
       if (!manifest) return null;
       const name = Option.getOrElse(
         existing.config.credentials,
         typedCtx,
       );
-      const text = yield* fetchDiscoveryDocument(
+      const text = yield* fetchDiscoveryDocument(existing.config.discoveryUrl, credentials);
-        existing.config.discoveryUrl,
-        credentials,
-      );
       const manifest = yield* extractGoogleDiscoveryManifest(text);
       const next = new GoogleDiscoveryStoredSourceDataSchema({
         ...existing.config,
         servicePath: manifest.servicePath,
       });
       yield* registerManifest(typedCtx, sourceId, scope, manifest, next);
-    }).pipe(
+    }).pipe(Effect.mapError((err) => (err instanceof Error ? err : new Error(String(err))))),
-      Effect.mapError((err) =>
-        err instanceof Error ? err : new Error(String(err)),
-      ),
-    ),
   // Connection refresh is owned by the canonical `"oauth2"`
   // ConnectionProvider registered by core — no plugin-specific handler

packages/plugins/google-discovery/src/sdk/types.ts+4−11

 import { Schema } from "effect";
+import { SecretBackedValue } from "@executor/sdk";
 export const GoogleDiscoveryHttpMethod = Schema.Literal(
   "get",
 );
 export type GoogleDiscoveryAuth = typeof GoogleDiscoveryAuth.Type;
-export const GoogleDiscoveryCredentialValue = Schema.Union(
+export const GoogleDiscoveryCredentialValue = SecretBackedValue;
-  Schema.String,
+export type GoogleDiscoveryCredentialValue = typeof GoogleDiscoveryCredentialValue.Type;
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
-export type GoogleDiscoveryCredentialValue =
-  typeof GoogleDiscoveryCredentialValue.Type;
 export const GoogleDiscoveryFetchCredentials = Schema.Struct({
   headers: Schema.optional(
     Schema.Record({ key: Schema.String, value: GoogleDiscoveryCredentialValue }),
   ),
 });
-export type GoogleDiscoveryFetchCredentials =
+export type GoogleDiscoveryFetchCredentials = typeof GoogleDiscoveryFetchCredentials.Type;
-  typeof GoogleDiscoveryFetchCredentials.Type;
 export class GoogleDiscoveryStoredSourceData extends Schema.Class<GoogleDiscoveryStoredSourceData>(
   "GoogleDiscoveryStoredSourceData",

packages/plugins/graphql/src/sdk/invoke.ts+8−26

 import { Effect, Layer, Option } from "effect";
 import { HttpClient, HttpClientRequest } from "@effect/platform";
+import { resolveSecretBackedMap } from "@executor/sdk";
 import { GraphqlInvocationError } from "./errors";
 import { type HeaderValue, type OperationBinding, InvocationResult } from "./types";
     (acc, [, value]) => (typeof value === "string" ? acc : acc + 1),
     0,
   );
-  return Effect.gen(function* () {
+  return resolveSecretBackedMap({
-    // Resolve secret-backed headers in parallel. Missing / failing
+    values: headers,
-    // lookups drop the header rather than fail the invocation, same
+    getSecret: (secretId) =>
-    // as the serial version.
+      secrets.get(secretId).pipe(Effect.catchAll(() => Effect.succeed(null))),
-    const values = yield* Effect.all(
+    missing: "drop",
-      entries.map(([name, value]) =>
+    onMissing: () => undefined as never,
-        typeof value === "string"
-          ? Effect.succeed<{ readonly name: string; readonly value: string | null }>({
-              name,
-              value,
-            })
-          : secrets.get(value.secretId).pipe(
-              Effect.catchAll(() => Effect.succeed<string | null>(null)),
-              Effect.map((secret) => ({
-                name,
-                value: secret === null ? null : value.prefix ? `${value.prefix}${secret}` : secret,
-              })),
-            ),
-      ),
-      { concurrency: "unbounded" },
-    );
-    const resolved: Record<string, string> = {};
-    for (const { name, value } of values) {
-      if (value !== null) resolved[name] = value;
-    }
-    return resolved;
   }).pipe(
+    Effect.map((resolved) => resolved ?? {}),
     Effect.withSpan("plugin.graphql.secret.resolve", {
       attributes: {
         "plugin.graphql.headers.total": entries.length,

packages/plugins/graphql/src/sdk/types.ts+14−37

 import { Schema } from "effect";
+import { SecretBackedValue } from "@executor/sdk";
 // ---------------------------------------------------------------------------
 // GraphQL operation kind
 // Extracted field (becomes a tool)
 // ---------------------------------------------------------------------------
-export class GraphqlArgument extends Schema.Class<GraphqlArgument>(
+export class GraphqlArgument extends Schema.Class<GraphqlArgument>("GraphqlArgument")({
-  "GraphqlArgument",
-)({
   name: Schema.String,
   typeName: Schema.String,
   required: Schema.Boolean,
   description: Schema.optionalWith(Schema.String, { as: "Option" }),
 }) {}
-export class ExtractedField extends Schema.Class<ExtractedField>(
+export class ExtractedField extends Schema.Class<ExtractedField>("ExtractedField")({
-  "ExtractedField",
-)({
   /** e.g. "user", "createUser" */
   fieldName: Schema.String,
   /** "query" or "mutation" */
   returnTypeName: Schema.String,
 }) {}
-export class ExtractionResult extends Schema.Class<ExtractionResult>(
+export class ExtractionResult extends Schema.Class<ExtractionResult>("ExtractionResult")({
-  "ExtractionResult",
-)({
   /** Schema name from introspection */
   schemaName: Schema.optionalWith(Schema.String, { as: "Option" }),
   fields: Schema.Array(ExtractedField),
 // Operation binding — minimal data needed to invoke
 // ---------------------------------------------------------------------------
-export class OperationBinding extends Schema.Class<OperationBinding>(
+export class OperationBinding extends Schema.Class<OperationBinding>("OperationBinding")({
-  "OperationBinding",
-)({
   kind: GraphqlOperationKind,
   fieldName: Schema.String,
   /** The full GraphQL query/mutation string */
 // Invocation
 // ---------------------------------------------------------------------------
-export const HeaderValue = Schema.Union(
+export const HeaderValue = SecretBackedValue;
-  Schema.String,
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
 export type HeaderValue = typeof HeaderValue.Type;
 export const QueryParamValue = HeaderValue;
 export type QueryParamValue = typeof QueryParamValue.Type;
 );
 export type GraphqlSourceAuth = typeof GraphqlSourceAuth.Type;
-export class InvocationConfig extends Schema.Class<InvocationConfig>(
+export class InvocationConfig extends Schema.Class<InvocationConfig>("InvocationConfig")({
-  "InvocationConfig",
-)({
   /** The GraphQL endpoint URL */
   endpoint: Schema.String,
   /** Headers applied to every request. Values can reference secrets. */
-  headers: Schema.optionalWith(
+  headers: Schema.optionalWith(Schema.Record({ key: Schema.String, value: HeaderValue }), {
-    Schema.Record({ key: Schema.String, value: HeaderValue }),
+    default: () => ({}),
-    {
+  }),
-      default: () => ({}),
-    },
-  ),
   /** Query parameters applied to every request. Values can reference secrets. */
-  queryParams: Schema.optionalWith(
+  queryParams: Schema.optionalWith(Schema.Record({ key: Schema.String, value: QueryParamValue }), {
-    Schema.Record({ key: Schema.String, value: QueryParamValue }),
+    default: () => ({}),
-    {
+  }),
-      default: () => ({}),
-    },
-  ),
 }) {}
-export class InvocationResult extends Schema.Class<InvocationResult>(
+export class InvocationResult extends Schema.Class<InvocationResult>("InvocationResult")({
-  "InvocationResult",
-)({
   status: Schema.Number,
   data: Schema.NullOr(Schema.Unknown),
   errors: Schema.NullOr(Schema.Unknown),

packages/plugins/mcp/src/api/group.ts+7−16

 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "@effect/platform";
 import { Schema } from "effect";
-import { ScopeId } from "@executor/sdk";
+import { ScopeId, SecretBackedMap } from "@executor/sdk";
 import { InternalError } from "@executor/api";
-import {
+import { McpConnectionError, McpToolDiscoveryError } from "../sdk/errors";
-  McpConnectionError,
-  McpToolDiscoveryError,
-} from "../sdk/errors";
 import { McpStoredSourceSchema } from "../sdk/stored-source";
 // Re-export for handler use
 );
 const StringMap = Schema.Record({ key: Schema.String, value: Schema.String });
-const SecretBackedValue = Schema.Union(
-  Schema.String,
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
-const SecretBackedMap = Schema.Record({ key: Schema.String, value: SecretBackedValue });
 // ---------------------------------------------------------------------------
 // Add source — discriminated union on transport
 // ---------------------------------------------------------------------------
       .addSuccess(RefreshSourceResponse),
   )
   .add(
-    HttpApiEndpoint.get("getSource")`/scopes/${scopeIdParam}/mcp/sources/${namespaceParam}`
+    HttpApiEndpoint.get(
-      .addSuccess(Schema.NullOr(McpStoredSourceSchema)),
+      "getSource",
+    )`/scopes/${scopeIdParam}/mcp/sources/${namespaceParam}`.addSuccess(
+      Schema.NullOr(McpStoredSourceSchema),
+    ),
   )
   .add(
     HttpApiEndpoint.patch("updateSource")`/scopes/${scopeIdParam}/mcp/sources/${namespaceParam}`

packages/plugins/mcp/src/sdk/plugin.ts+521−587

@@ -5,6 +5,7 @@ import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth. · 4 unmodified lines
5	import {	5	import {
6	SourceDetectionResult,	6	SourceDetectionResult,
7	definePlugin,	7	definePlugin,
		8	resolveSecretBackedMap as resolveSharedSecretBackedMap,
8	type PluginCtx,	9	type PluginCtx,
9	type StorageFailure,	10	type StorageFailure,
10	} from "@executor/sdk";	11	} from "@executor/sdk";
@@ -15,21 +16,11 @@ import { · 4 unmodified lines
15	type McpBindingStore,	16	type McpBindingStore,
16	type McpStoredSource,	17	type McpStoredSource,
17	} from "./binding-store";	18	} from "./binding-store";
18	import {	19	import { createMcpConnector, type ConnectorInput, type McpConnection } from "./connection";
19	createMcpConnector,
20	type ConnectorInput,
21	type McpConnection,
22	} from "./connection";
23	import { discoverTools } from "./discover";	20	import { discoverTools } from "./discover";
24	import {	21	import { McpConnectionError, McpToolDiscoveryError } from "./errors";
25	McpConnectionError,
26	McpToolDiscoveryError,
27	} from "./errors";
28	import { invokeMcpTool } from "./invoke";	22	import { invokeMcpTool } from "./invoke";
29	import {	23	import { deriveMcpNamespace, type McpToolManifestEntry } from "./manifest";
30	deriveMcpNamespace,
31	type McpToolManifestEntry,
32	} from "./manifest";
33	import { probeMcpEndpointShape } from "./probe-shape";	24	import { probeMcpEndpointShape } from "./probe-shape";
34	import {	25	import {
35	McpToolBinding,	26	McpToolBinding,
@@ -200,38 +191,26 @@ const remoteConnectionError = (message: string) => · 164 unmodified lines
200	const mcpDiscoveryError = (message: string) =>	191	const mcpDiscoveryError = (message: string) =>
201	new McpToolDiscoveryError({ stage: "list_tools", message });	192	new McpToolDiscoveryError({ stage: "list_tools", message });
202		193
203	const resolveSecretBackedValue = (	194	const resolveSecretBackedMap = (
204	value: SecretBackedValue,	195	values: Record<string, SecretBackedValue> \| undefined,
205	ctx: PluginCtx<McpBindingStore>,	196	ctx: PluginCtx<McpBindingStore>,
206	): Effect.Effect<string, McpConnectionError \| StorageFailure> => {	197	): Effect.Effect<Record<string, string> \| undefined, McpConnectionError \| StorageFailure> =>
207	if (typeof value === "string") return Effect.succeed(value);	198	resolveSharedSecretBackedMap({
208	return ctx.secrets.get(value.secretId).pipe(	199	values,
209	Effect.mapError((err) =>	200	getSecret: ctx.secrets.get,
		201	onMissing: (_name, value) =>
		202	remoteConnectionError(`Failed to resolve secret "${value.secretId}"`),
		203	onError: (err, _name, value) =>
210	"_tag" in err && err._tag === "SecretOwnedByConnectionError"	204	"_tag" in err && err._tag === "SecretOwnedByConnectionError"
211	? remoteConnectionError(`Failed to resolve secret "${value.secretId}"`)	205	? remoteConnectionError(`Failed to resolve secret "${value.secretId}"`)
212	: err,	206	: err,
213	),	207	}).pipe(
214	Effect.flatMap((secret) =>	208	Effect.mapError((err) =>
215	secret === null	209	"_tag" in err && err._tag === "SecretOwnedByConnectionError"
216	? Effect.fail(remoteConnectionError(`Failed to resolve secret "${value.secretId}"`))	210	? remoteConnectionError("Failed to resolve secret")
217	: Effect.succeed(value.prefix ? `${value.prefix}${secret}` : secret),	211	: err,
218	),
219	);
220	};
221
222	const resolveSecretBackedMap = (
223	values: Record<string, SecretBackedValue> \| undefined,
224	ctx: PluginCtx<McpBindingStore>,
225	): Effect.Effect<Record<string, string> \| undefined, McpConnectionError \| StorageFailure> => {
226	if (!values) return Effect.succeed(undefined);
227	return Effect.forEach(Object.entries(values), ([key, value]) =>
228	Effect.map(resolveSecretBackedValue(value, ctx), (resolved) => [key, resolved] as const),
229	).pipe(
230	Effect.map((entries) =>
231	entries.length > 0 ? Object.fromEntries(entries) : undefined,
232	),	212	),
233	);	213	);
234	};
235		214
236	const plainStringMap = (	215	const plainStringMap = (
237	values: Record<string, SecretBackedValue> \| undefined,	216	values: Record<string, SecretBackedValue> \| undefined,
@@ -279,13 +258,15 @@ const resolveConnectorInput = ( · 41 unmodified lines
279		258
280	const auth = sd.auth;	259	const auth = sd.auth;
281	if (auth.kind === "header") {	260	if (auth.kind === "header") {
282	const val = yield* ctx.secrets.get(auth.secretId).pipe(	261	const val = yield* ctx.secrets
283	Effect.mapError((err) =>	262	.get(auth.secretId)
284	"_tag" in err && err._tag === "SecretOwnedByConnectionError"	263	.pipe(
285	? remoteConnectionError(`Failed to resolve secret "${auth.secretId}"`)	264	Effect.mapError((err) =>
286	: err,	265	"_tag" in err && err._tag === "SecretOwnedByConnectionError"
287	),	266	? remoteConnectionError(`Failed to resolve secret "${auth.secretId}"`)
288	);	267	: err,
		268	),
		269	);
289	if (val === null) {	270	if (val === null) {
290	return yield* Effect.fail(	271	return yield* Effect.fail(
291	remoteConnectionError(`Failed to resolve secret "${auth.secretId}"`),	272	remoteConnectionError(`Failed to resolve secret "${auth.secretId}"`),
@@ -304,9 +285,7 @@ const resolveConnectorInput = ( · 12 unmodified lines
304	Effect.mapError((err) =>	285	Effect.mapError((err) =>
305	remoteConnectionError(	286	remoteConnectionError(
306	`Failed to resolve OAuth connection "${auth.connectionId}": ${	287	`Failed to resolve OAuth connection "${auth.connectionId}": ${
307	"message" in err	288	"message" in err ? (err as { message: string }).message : String(err)
308	? (err as { message: string }).message
309	: String(err)
310	}`,	289	}`,
311	),	290	),
312	),	291	),
@@ -332,25 +311,15 @@ const resolveConnectorInput = ( · 19 unmodified lines
332	// ---------------------------------------------------------------------------	311	// ---------------------------------------------------------------------------
333		312
334	interface McpRuntime {	313	interface McpRuntime {
335	readonly connectionCache: ScopedCache.ScopedCache<	314	readonly connectionCache: ScopedCache.ScopedCache<string, McpConnection, McpConnectionError>;
336	string,	315	readonly pendingConnectors: Map<string, Effect.Effect<McpConnection, McpConnectionError>>;
337	McpConnection,
338	McpConnectionError
339	>;
340	readonly pendingConnectors: Map<
341	string,
342	Effect.Effect<McpConnection, McpConnectionError>
343	>;
344	readonly cacheScope: Scope.CloseableScope;	316	readonly cacheScope: Scope.CloseableScope;
345	}	317	}
346		318
347	const makeRuntime = (): Effect.Effect<McpRuntime, never> =>	319	const makeRuntime = (): Effect.Effect<McpRuntime, never> =>
348	Effect.gen(function* () {	320	Effect.gen(function* () {
349	const cacheScope = yield* Scope.make();	321	const cacheScope = yield* Scope.make();
350	const pendingConnectors = new Map<	322	const pendingConnectors = new Map<string, Effect.Effect<McpConnection, McpConnectionError>>();
351	string,
352	Effect.Effect<McpConnection, McpConnectionError>
353	>();
354	const connectionCache = yield* ScopedCache.make({	323	const connectionCache = yield* ScopedCache.make({
355	lookup: (key: string) =>	324	lookup: (key: string) =>
356	Effect.acquireRelease(	325	Effect.acquireRelease(
@@ -366,8 +335,7 @@ const makeRuntime = (): Effect.Effect<McpRuntime, never> => · 9 unmodified lines
366	}	335	}
367	return connector;	336	return connector;
368	}),	337	}),
369	(connection) =>	338	(connection) => Effect.promise(() => connection.close().catch(() => {})),
370	Effect.promise(() => connection.close().catch(() => {})),
371	),	339	),
372	capacity: 64,	340	capacity: 64,
373	timeToLive: Duration.minutes(5),	341	timeToLive: Duration.minutes(5),
@@ -444,540 +412,484 @@ const toMcpConfigEntry = ( · 70 unmodified lines
444	return entry;	412	return entry;
445	};	413	};
446		414
447	export const mcpPlugin = definePlugin(	415	export const mcpPlugin = definePlugin((options?: McpPluginOptions) => {
448	(options?: McpPluginOptions) => {	416	const allowStdio = options?.dangerouslyAllowStdioMCP ?? false;
449	const allowStdio = options?.dangerouslyAllowStdioMCP ?? false;	417	// Per-plugin-instance runtime holder. Captured by closures in
450	// Per-plugin-instance runtime holder. Captured by closures in	418	// `extension`, `invokeTool`, and `close`, so all three see the same
451	// `extension`, `invokeTool`, and `close`, so all three see the same	419	// connection cache across a single createExecutor lifecycle.
452	// connection cache across a single createExecutor lifecycle.	420	const runtimeRef: { current: McpRuntime \| null } = { current: null };
453	const runtimeRef: { current: McpRuntime \| null } = { current: null };	421
454		422	const ensureRuntime = (): Effect.Effect<McpRuntime, never> =>
455	const ensureRuntime = (): Effect.Effect<McpRuntime, never> =>	423	runtimeRef.current
456	runtimeRef.current	424	? Effect.succeed(runtimeRef.current)
457	? Effect.succeed(runtimeRef.current)	425	: makeRuntime().pipe(
458	: makeRuntime().pipe(	426	Effect.tap((rt) =>
459	Effect.tap((rt) =>	427	Effect.sync(() => {
460	Effect.sync(() => {	428	runtimeRef.current = rt;
461	runtimeRef.current = rt;	429	}),
462	}),	430	),
463	),	431	);
464	);
465		432
466	return {	433	return {
467	id: "mcp" as const,	434	id: "mcp" as const,
468	schema: mcpSchema,	435	schema: mcpSchema,
469	storage: (deps): McpBindingStore => makeMcpStore(deps),	436	storage: (deps): McpBindingStore => makeMcpStore(deps),
470
471	extension: (ctx) => {
472	const probeEndpoint = (input: string \| McpProbeEndpointInput) =>
473	Effect.gen(function* () {
474	const endpoint = typeof input === "string" ? input : input.endpoint;
475	const trimmed = endpoint.trim();
476	if (!trimmed) {
477	return yield* Effect.fail(
478	remoteConnectionError("Endpoint URL is required"),
479	);
480	}
481		437
482	const name = yield* Effect.try(	438	extension: (ctx) => {
483	() => new URL(trimmed).hostname,	439	const probeEndpoint = (input: string \| McpProbeEndpointInput) =>
484	).pipe(Effect.orElseSucceed(() => "mcp"));	440	Effect.gen(function* () {
485	const namespace = deriveMcpNamespace({ endpoint: trimmed });	441	const endpoint = typeof input === "string" ? input : input.endpoint;
486		442	const trimmed = endpoint.trim();
487	const probeHeaders =	443	if (!trimmed) {
488	typeof input === "string"	444	return yield* Effect.fail(remoteConnectionError("Endpoint URL is required"));
489	? undefined	445	}
490	: yield* resolveSecretBackedMap(input.headers, ctx);
491	const probeQueryParams =
492	typeof input === "string"
493	? undefined
494	: yield* resolveSecretBackedMap(input.queryParams, ctx);
495
496	const connector = createMcpConnector({
497	transport: "remote",
498	endpoint: trimmed,
499	headers: probeHeaders,
500	queryParams: probeQueryParams,
501	});
502		446
503	const result = yield* discoverTools(connector).pipe(	447	const name = yield* Effect.try(() => new URL(trimmed).hostname).pipe(
504	Effect.map((m) => ({ ok: true as const, manifest: m })),	448	Effect.orElseSucceed(() => "mcp"),
505	Effect.catchAll(() =>	449	);
506	Effect.succeed({ ok: false as const, manifest: null }),	450	const namespace = deriveMcpNamespace({ endpoint: trimmed });
507	),
508	Effect.withSpan("mcp.plugin.discover_tools"),
509	);
510		451
511	if (result.ok && result.manifest) {	452	const probeHeaders =
512	return {	453	typeof input === "string"
513	connected: true,	454	? undefined
514	requiresOAuth: false,	455	: yield* resolveSecretBackedMap(input.headers, ctx);
515	name: result.manifest.server?.name ?? name,	456	const probeQueryParams =
516	namespace,	457	typeof input === "string"
517	toolCount: result.manifest.tools.length,	458	? undefined
518	serverName: result.manifest.server?.name ?? null,	459	: yield* resolveSecretBackedMap(input.queryParams, ctx);
519	} satisfies McpProbeResult;
520	}
521		460
522	// Before asking the core OAuth service to look for metadata,	461	const connector = createMcpConnector({
523	// confirm the endpoint actually speaks MCP. An OAuth-protected	462	transport: "remote",
524	// non-MCP service (e.g. a GraphQL API whose host publishes	463	endpoint: trimmed,
525	// RFC 9728 + 8414 metadata) would otherwise pass the OAuth	464	headers: probeHeaders,
526	// probe and be misclassified as MCP. The shape probe rejects	465	queryParams: probeQueryParams,
527	// anything whose initialize response isn't 2xx or 401+Bearer.	466	});
528	const shape = yield* probeMcpEndpointShape(trimmed, {
529	headers: probeHeaders,
530	queryParams: probeQueryParams,
531	});
532	if (shape.kind !== "mcp") {
533	return yield* Effect.fail(
534	remoteConnectionError(
535	shape.kind === "not-mcp"
536	? `Endpoint does not look like an MCP server: ${shape.reason}`
537	: `Could not reach endpoint: ${shape.reason}`,
538	),
539	);
540	}
541		467
542	const probeResult = yield* ctx.oauth	468	const result = yield* discoverTools(connector).pipe(
543	.probe({	469	Effect.map((m) => ({ ok: true as const, manifest: m })),
544	endpoint: trimmed,	470	Effect.catchAll(() => Effect.succeed({ ok: false as const, manifest: null })),
545	headers: probeHeaders,	471	Effect.withSpan("mcp.plugin.discover_tools"),
546	queryParams: probeQueryParams,	472	);
547	})
548	.pipe(
549	Effect.map(() => true),
550	Effect.catchAll(() => Effect.succeed(false)),
551	Effect.withSpan("mcp.plugin.probe_oauth"),
552	);
553		473
554	if (probeResult) {	474	if (result.ok && result.manifest) {
555	return {	475	return {
556	connected: false,	476	connected: true,
557	requiresOAuth: true,	477	requiresOAuth: false,
558	name,	478	name: result.manifest.server?.name ?? name,
559	namespace,	479	namespace,
560	toolCount: null,	480	toolCount: result.manifest.tools.length,
561	serverName: null,	481	serverName: result.manifest.server?.name ?? null,
562	} satisfies McpProbeResult;	482	} satisfies McpProbeResult;
563	}	483	}
564		484
		485	// Before asking the core OAuth service to look for metadata,
		486	// confirm the endpoint actually speaks MCP. An OAuth-protected
		487	// non-MCP service (e.g. a GraphQL API whose host publishes
		488	// RFC 9728 + 8414 metadata) would otherwise pass the OAuth
		489	// probe and be misclassified as MCP. The shape probe rejects
		490	// anything whose initialize response isn't 2xx or 401+Bearer.
		491	const shape = yield* probeMcpEndpointShape(trimmed, {
		492	headers: probeHeaders,
		493	queryParams: probeQueryParams,
		494	});
		495	if (shape.kind !== "mcp") {
565	return yield* Effect.fail(	496	return yield* Effect.fail(
566	remoteConnectionError(	497	remoteConnectionError(
567	"MCP server requires authentication but OAuth discovery failed",	498	shape.kind === "not-mcp"
		499	? `Endpoint does not look like an MCP server: ${shape.reason}`
		500	: `Could not reach endpoint: ${shape.reason}`,
568	),	501	),
569	);	502	);
570	}).pipe(	503	}
571	Effect.withSpan("mcp.plugin.probe_endpoint", {
572	attributes: { "mcp.endpoint": typeof input === "string" ? input : input.endpoint },
573	}),
574	);
575		504
576	const configFile = options?.configFile;	505	const probeResult = yield* ctx.oauth
577		506	.probe({
578	const addSource = (config: McpSourceConfig) =>	507	endpoint: trimmed,
579	Effect.gen(function* () {	508	headers: probeHeaders,
580	const namespace = normalizeNamespace(config);	509	queryParams: probeQueryParams,
581	const sd = toStoredSourceData(config);	510	})
582		511	.pipe(
583	// Stdio sources are gated — a resolver failure there is a	512	Effect.map(() => true),
584	// config error the admin must fix before the source makes	513	Effect.catchAll(() => Effect.succeed(false)),
585	// sense to persist at all. For remote sources we defer the	514	Effect.withSpan("mcp.plugin.probe_oauth"),
586	// resolver failure: auth might not be ready yet (oauth2
587	// connection awaiting per-user sign-in, header secret
588	// awaiting upload) but the source row should still land so
589	// it shows up in the list and exposes a Sign-in affordance.
590	const resolved = yield* resolveConnectorInput(sd, ctx, allowStdio).pipe(
591	Effect.either,
592	Effect.withSpan("mcp.plugin.resolve_connector", {
593	attributes: {
594	"mcp.source.namespace": namespace,
595	"mcp.source.transport": sd.transport,
596	},
597	}),
598	);	515	);
599		516
600	if (resolved._tag === "Left" && sd.transport === "stdio") {	517	if (probeResult) {
601	return yield* Effect.fail(resolved.left);	518	return {
602	}	519	connected: false,
		520	requiresOAuth: true,
		521	name,
		522	namespace,
		523	toolCount: null,
		524	serverName: null,
		525	} satisfies McpProbeResult;
		526	}
603		527
604	// Try discovery only if we have a live connector input.	528	return yield* Effect.fail(
605	// Otherwise fall straight through to the persist step with	529	remoteConnectionError("MCP server requires authentication but OAuth discovery failed"),
606	// an empty manifest and surface the resolver failure to	530	);
607	// the caller at the end.	531	}).pipe(
608	const discovery =	532	Effect.withSpan("mcp.plugin.probe_endpoint", {
609	resolved._tag === "Right"	533	attributes: { "mcp.endpoint": typeof input === "string" ? input : input.endpoint },
610	? yield* discoverTools(createMcpConnector(resolved.right)).pipe(	534	}),
611	Effect.mapError((err) =>	535	);
612	mcpDiscoveryError(`MCP discovery failed: ${err.message}`),
613	),
614	Effect.either,
615	Effect.withSpan("mcp.plugin.discover_tools", {
616	attributes: { "mcp.source.namespace": namespace },
617	}),
618	)
619	: ({ _tag: "Left", left: resolved.left } as const);
620	const manifest =
621	discovery._tag === "Right"
622	? discovery.right
623	: { server: undefined, tools: [] as const };
624
625	const sourceName = config.name ?? manifest.server?.name ?? namespace;
626
627	yield* ctx
628	.transaction(
629	Effect.gen(function* () {
630	// Remove stale rows at the target scope (plugin-owned).
631	// Pinning scope keeps a shadowed outer-scope row intact
632	// when a per-user addSource re-uses the same namespace.
633	yield* ctx.storage.removeBindingsByNamespace(
634	namespace,
635	config.scope,
636	);
637	yield* ctx.storage.removeSource(namespace, config.scope);
638
639	yield* ctx.storage.putSource({
640	namespace,
641	scope: config.scope,
642	name: sourceName,
643	config: sd,
644	});
645
646	yield* ctx.storage.putBindings(
647	namespace,
648	config.scope,
649	manifest.tools.map((e) => ({
650	toolId: `${namespace}.${e.toolId}`,
651	binding: toBinding(e),
652	})),
653	);
654
655	yield* ctx.core.sources.register({
656	id: namespace,
657	scope: config.scope,
658	kind: "mcp",
659	name: sourceName,
660	url: sd.transport === "remote" ? sd.endpoint : undefined,
661	canRemove: true,
662	canRefresh: true,
663	canEdit: sd.transport === "remote",
664	tools: manifest.tools.map((e) => ({
665	name: e.toolId,
666	description: e.description ?? `MCP tool: ${e.toolName}`,
667	inputSchema: e.inputSchema,
668	outputSchema: e.outputSchema,
669	})),
670	});
671	}),
672	)
673	.pipe(
674	Effect.withSpan("mcp.plugin.persist_source", {
675	attributes: {
676	"mcp.source.namespace": namespace,
677	"mcp.source.tool_count": manifest.tools.length,
678	},
679	}),
680	);
681		536
682	if (configFile) {	537	const configFile = options?.configFile;
683	yield* configFile
684	.upsertSource(toMcpConfigEntry(namespace, sourceName, config))
685	.pipe(Effect.withSpan("mcp.plugin.config_file.upsert"));
686	}
687		538
688	if (discovery._tag === "Left") {	539	const addSource = (config: McpSourceConfig) =>
689	return yield* Effect.fail(discovery.left);	540	Effect.gen(function* () {
690	}	541	const namespace = normalizeNamespace(config);
691	return { toolCount: manifest.tools.length, namespace };	542	const sd = toStoredSourceData(config);
692	}).pipe(	543
693	Effect.withSpan("mcp.plugin.add_source", {	544	// Stdio sources are gated — a resolver failure there is a
		545	// config error the admin must fix before the source makes
		546	// sense to persist at all. For remote sources we defer the
		547	// resolver failure: auth might not be ready yet (oauth2
		548	// connection awaiting per-user sign-in, header secret
		549	// awaiting upload) but the source row should still land so
		550	// it shows up in the list and exposes a Sign-in affordance.
		551	const resolved = yield* resolveConnectorInput(sd, ctx, allowStdio).pipe(
		552	Effect.either,
		553	Effect.withSpan("mcp.plugin.resolve_connector", {
694	attributes: {	554	attributes: {
695	"mcp.source.transport": config.transport,	555	"mcp.source.namespace": namespace,
696	"mcp.source.name": config.name,	556	"mcp.source.transport": sd.transport,
697	},	557	},
698	}),	558	}),
699	);	559	);
700		560
701	const removeSource = (namespace: string, scope: string) =>	561	if (resolved._tag === "Left" && sd.transport === "stdio") {
702	Effect.gen(function* () {	562	return yield* Effect.fail(resolved.left);
703	yield* ctx	563	}
704	.transaction(
705	Effect.gen(function* () {
706	yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
707	yield* ctx.storage.removeSource(namespace, scope);
708	yield* ctx.core.sources.unregister(namespace);
709	}),
710	)
711	.pipe(Effect.withSpan("mcp.plugin.persist_remove"));
712	if (configFile) {
713	yield* configFile
714	.removeSource(namespace)
715	.pipe(Effect.withSpan("mcp.plugin.config_file.remove"));
716	}
717	}).pipe(
718	Effect.withSpan("mcp.plugin.remove_source", {
719	attributes: { "mcp.source.namespace": namespace },
720	}),
721	);
722		564
723	const refreshSource = (namespace: string, scope: string) =>	565	// Try discovery only if we have a live connector input.
724	Effect.gen(function* () {	566	// Otherwise fall straight through to the persist step with
725	const sd = yield* ctx.storage.getSourceConfig(namespace, scope).pipe(	567	// an empty manifest and surface the resolver failure to
726	Effect.withSpan("mcp.plugin.load_source_config", {	568	// the caller at the end.
727	attributes: { "mcp.source.namespace": namespace },	569	const discovery =
		570	resolved._tag === "Right"
		571	? yield* discoverTools(createMcpConnector(resolved.right)).pipe(
		572	Effect.mapError((err) =>
		573	mcpDiscoveryError(`MCP discovery failed: ${err.message}`),
		574	),
		575	Effect.either,
		576	Effect.withSpan("mcp.plugin.discover_tools", {
		577	attributes: { "mcp.source.namespace": namespace },
		578	}),
		579	)
		580	: ({ _tag: "Left", left: resolved.left } as const);
		581	const manifest =
		582	discovery._tag === "Right"
		583	? discovery.right
		584	: { server: undefined, tools: [] as const };
		585
		586	const sourceName = config.name ?? manifest.server?.name ?? namespace;
		587
		588	yield* ctx
		589	.transaction(
		590	Effect.gen(function* () {
		591	// Remove stale rows at the target scope (plugin-owned).
		592	// Pinning scope keeps a shadowed outer-scope row intact
		593	// when a per-user addSource re-uses the same namespace.
		594	yield* ctx.storage.removeBindingsByNamespace(namespace, config.scope);
		595	yield* ctx.storage.removeSource(namespace, config.scope);
		596
		597	yield* ctx.storage.putSource({
		598	namespace,
		599	scope: config.scope,
		600	name: sourceName,
		601	config: sd,
		602	});
		603
		604	yield* ctx.storage.putBindings(
		605	namespace,
		606	config.scope,
		607	manifest.tools.map((e) => ({
		608	toolId: `${namespace}.${e.toolId}`,
		609	binding: toBinding(e),
		610	})),
		611	);
		612
		613	yield* ctx.core.sources.register({
		614	id: namespace,
		615	scope: config.scope,
		616	kind: "mcp",
		617	name: sourceName,
		618	url: sd.transport === "remote" ? sd.endpoint : undefined,
		619	canRemove: true,
		620	canRefresh: true,
		621	canEdit: sd.transport === "remote",
		622	tools: manifest.tools.map((e) => ({
		623	name: e.toolId,
		624	description: e.description ?? `MCP tool: ${e.toolName}`,
		625	inputSchema: e.inputSchema,
		626	outputSchema: e.outputSchema,
		627	})),
		628	});
728	}),	629	}),
729	);	630	)
730	if (!sd) {	631	.pipe(
731	return yield* Effect.fail(	632	Effect.withSpan("mcp.plugin.persist_source", {
732	remoteConnectionError(
733	`No stored config for MCP source "${namespace}"`,
734	),
735	);
736	}
737
738	const ci = yield* resolveConnectorInput(sd, ctx, allowStdio).pipe(
739	Effect.withSpan("mcp.plugin.resolve_connector", {
740	attributes: {	633	attributes: {
741	"mcp.source.namespace": namespace,	634	"mcp.source.namespace": namespace,
742	"mcp.source.transport": sd.transport,	635	"mcp.source.tool_count": manifest.tools.length,
743	},	636	},
744	}),	637	}),
745	);	638	);
746	const manifest = yield* discoverTools(createMcpConnector(ci)).pipe(
747	Effect.mapError((err) =>
748	mcpDiscoveryError(`MCP refresh failed: ${err.message}`),
749	),
750	Effect.withSpan("mcp.plugin.discover_tools", {
751	attributes: { "mcp.source.namespace": namespace },
752	}),
753	);
754		639
755	const existing = yield* ctx.storage.getSource(namespace, scope);	640	if (configFile) {
756	const sourceName =	641	yield* configFile
757	manifest.server?.name ?? existing?.name ?? namespace;	642	.upsertSource(toMcpConfigEntry(namespace, sourceName, config))
758		643	.pipe(Effect.withSpan("mcp.plugin.config_file.upsert"));
759	yield* ctx	644	}
760	.transaction(
761	Effect.gen(function* () {
762	yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
763	yield* ctx.core.sources.unregister(namespace);
764
765	yield* ctx.storage.putBindings(
766	namespace,
767	scope,
768	manifest.tools.map((e) => ({
769	toolId: `${namespace}.${e.toolId}`,
770	binding: toBinding(e),
771	})),
772	);
773	yield* ctx.core.sources.register({
774	id: namespace,
775	scope,
776	kind: "mcp",
777	name: sourceName,
778	url: sd.transport === "remote" ? sd.endpoint : undefined,
779	canRemove: true,
780	canRefresh: true,
781	canEdit: sd.transport === "remote",
782	tools: manifest.tools.map((e) => ({
783	name: e.toolId,
784	description: e.description ?? `MCP tool: ${e.toolName}`,
785	inputSchema: e.inputSchema,
786	outputSchema: e.outputSchema,
787	})),
788	});
789	}),
790	)
791	.pipe(
792	Effect.withSpan("mcp.plugin.persist_source", {
793	attributes: {
794	"mcp.source.namespace": namespace,
795	"mcp.source.tool_count": manifest.tools.length,
796	},
797	}),
798	);
799
800	return { toolCount: manifest.tools.length };
801	}).pipe(
802	Effect.withSpan("mcp.plugin.refresh_source", {
803	attributes: { "mcp.source.namespace": namespace },
804	}),
805	);
806		645
807	const updateSource = (	646	if (discovery._tag === "Left") {
808	namespace: string,	647	return yield* Effect.fail(discovery.left);
809	scope: string,	648	}
810	input: McpUpdateSourceInput,	649	return { toolCount: manifest.tools.length, namespace };
811	) =>	650	}).pipe(
812	Effect.gen(function* () {	651	Effect.withSpan("mcp.plugin.add_source", {
813	const existing = yield* ctx.storage.getSource(namespace, scope);	652	attributes: {
814	if (!existing \|\| existing.config.transport !== "remote") return;	653	"mcp.source.transport": config.transport,
815		654	"mcp.source.name": config.name,
816	const remote = existing.config;	655	},
817	const updatedConfig: McpStoredSourceData = {	656	}),
818	...remote,	657	);
819	...(input.endpoint !== undefined ? { endpoint: input.endpoint } : {}),
820	...(input.headers !== undefined ? { headers: input.headers } : {}),
821	...(input.auth !== undefined ? { auth: input.auth } : {}),
822	...(input.queryParams !== undefined
823	? { queryParams: input.queryParams }
824	: {}),
825	};
826
827	yield* ctx.storage.putSource({
828	namespace,
829	scope,
830	name: input.name?.trim() \|\| existing.name,
831	config: updatedConfig,
832	});
833	}).pipe(
834	Effect.withSpan("mcp.plugin.update_source", {
835	attributes: { "mcp.source.namespace": namespace },
836	}),
837	);
838		658
839	const getSource = (namespace: string, scope: string) =>	659	const removeSource = (namespace: string, scope: string) =>
840	ctx.storage.getSource(namespace, scope).pipe(	660	Effect.gen(function* () {
841	Effect.withSpan("mcp.plugin.get_source", {	661	yield* ctx
842	attributes: { "mcp.source.namespace": namespace },	662	.transaction(
843	}),	663	Effect.gen(function* () {
844	);	664	yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
		665	yield* ctx.storage.removeSource(namespace, scope);
		666	yield* ctx.core.sources.unregister(namespace);
		667	}),
		668	)
		669	.pipe(Effect.withSpan("mcp.plugin.persist_remove"));
		670	if (configFile) {
		671	yield* configFile
		672	.removeSource(namespace)
		673	.pipe(Effect.withSpan("mcp.plugin.config_file.remove"));
		674	}
		675	}).pipe(
		676	Effect.withSpan("mcp.plugin.remove_source", {
		677	attributes: { "mcp.source.namespace": namespace },
		678	}),
		679	);
845		680
846	return {	681	const refreshSource = (namespace: string, scope: string) =>
847	probeEndpoint,
848	addSource,
849	removeSource,
850	refreshSource,
851	getSource,
852	updateSource,
853	} satisfies McpPluginExtension;
854	},
855
856	invokeTool: ({ ctx, toolRow, args, elicit }) =>
857	Effect.gen(function* () {	682	Effect.gen(function* () {
858	const runtime = yield* ensureRuntime();	683	const sd = yield* ctx.storage.getSourceConfig(namespace, scope).pipe(
859		684	Effect.withSpan("mcp.plugin.load_source_config", {
860	// toolRow.scope_id is the resolved owning scope of the tool	685	attributes: { "mcp.source.namespace": namespace },
861	// (innermost-wins from the executor's stack). The matching
862	// mcp_binding + mcp_source rows live at the same scope, so
863	// pin every store lookup to it instead of relying on the
864	// scoped adapter's stack-wide fall-through.
865	const toolScope = toolRow.scope_id as string;
866	const entry = yield* ctx.storage.getBinding(toolRow.id, toolScope).pipe(
867	Effect.withSpan("mcp.plugin.load_binding", {
868	attributes: { "mcp.tool.name": toolRow.id },
869	}),	686	}),
870	);	687	);
871	if (!entry) {	688	if (!sd) {
872	return yield* Effect.fail(	689	return yield* Effect.fail(
873	new Error(`No MCP binding found for tool "${toolRow.id}"`),	690	remoteConnectionError(`No stored config for MCP source "${namespace}"`),
874	);	691	);
875	}	692	}
876		693
877	const sd = yield* ctx.storage.getSourceConfig(entry.namespace, toolScope).pipe(	694	const ci = yield* resolveConnectorInput(sd, ctx, allowStdio).pipe(
878	Effect.withSpan("mcp.plugin.load_source_config", {	695	Effect.withSpan("mcp.plugin.resolve_connector", {
879	attributes: { "mcp.source.namespace": entry.namespace },	696	attributes: {
		697	"mcp.source.namespace": namespace,
		698	"mcp.source.transport": sd.transport,
		699	},
880	}),	700	}),
881	);	701	);
882	if (!sd) {	702	const manifest = yield* discoverTools(createMcpConnector(ci)).pipe(
883	return yield* Effect.fail(	703	Effect.mapError((err) => mcpDiscoveryError(`MCP refresh failed: ${err.message}`)),
884	new Error(	704	Effect.withSpan("mcp.plugin.discover_tools", {
885	`No MCP source config for namespace "${entry.namespace}"`,	705	attributes: { "mcp.source.namespace": namespace },
886	),	706	}),
		707	);
		708
		709	const existing = yield* ctx.storage.getSource(namespace, scope);
		710	const sourceName = manifest.server?.name ?? existing?.name ?? namespace;
		711
		712	yield* ctx
		713	.transaction(
		714	Effect.gen(function* () {
		715	yield* ctx.storage.removeBindingsByNamespace(namespace, scope);
		716	yield* ctx.core.sources.unregister(namespace);
		717
		718	yield* ctx.storage.putBindings(
		719	namespace,
		720	scope,
		721	manifest.tools.map((e) => ({
		722	toolId: `${namespace}.${e.toolId}`,
		723	binding: toBinding(e),
		724	})),
		725	);
		726	yield* ctx.core.sources.register({
		727	id: namespace,
		728	scope,
		729	kind: "mcp",
		730	name: sourceName,
		731	url: sd.transport === "remote" ? sd.endpoint : undefined,
		732	canRemove: true,
		733	canRefresh: true,
		734	canEdit: sd.transport === "remote",
		735	tools: manifest.tools.map((e) => ({
		736	name: e.toolId,
		737	description: e.description ?? `MCP tool: ${e.toolName}`,
		738	inputSchema: e.inputSchema,
		739	outputSchema: e.outputSchema,
		740	})),
		741	});
		742	}),
		743	)
		744	.pipe(
		745	Effect.withSpan("mcp.plugin.persist_source", {
		746	attributes: {
		747	"mcp.source.namespace": namespace,
		748	"mcp.source.tool_count": manifest.tools.length,
		749	},
		750	}),
887	);	751	);
888	}
889		752
890	return yield* invokeMcpTool({	753	return { toolCount: manifest.tools.length };
891	toolId: toolRow.id,
892	toolName: entry.binding.toolName,
893	args,
894	sourceData: sd,
895	invokerScope: ctx.scopes[0]!.id as string,
896	resolveConnector: () =>
897	resolveConnectorInput(sd, ctx, allowStdio).pipe(
898	Effect.flatMap((ci) => createMcpConnector(ci)),
899	Effect.mapError((err) =>
900	err instanceof McpConnectionError
901	? err
902	: new McpConnectionError({
903	transport: "auto",
904	message:
905	err instanceof Error ? err.message : String(err),
906	}),
907	),
908	Effect.withSpan("mcp.plugin.resolve_connector", {
909	attributes: {
910	"mcp.source.namespace": entry.namespace,
911	"mcp.source.transport": sd.transport,
912	},
913	}),
914	),
915	connectionCache: runtime.connectionCache,
916	pendingConnectors: runtime.pendingConnectors,
917	elicit,
918	});
919	}).pipe(	754	}).pipe(
920	Effect.withSpan("mcp.plugin.invoke_tool", {	755	Effect.withSpan("mcp.plugin.refresh_source", {
921	attributes: {	756	attributes: { "mcp.source.namespace": namespace },
922	"mcp.tool.name": toolRow.id,
923	"mcp.tool.source_id": toolRow.source_id,
924	},
925	}),	757	}),
926	),	758	);
927		759
928	detect: ({ ctx, url }) =>	760	const updateSource = (namespace: string, scope: string, input: McpUpdateSourceInput) =>
929	Effect.gen(function* () {	761	Effect.gen(function* () {
930	const trimmed = url.trim();	762	const existing = yield* ctx.storage.getSource(namespace, scope);
931	if (!trimmed) return null;	763	if (!existing \|\| existing.config.transport !== "remote") return;
		764
		765	const remote = existing.config;
		766	const updatedConfig: McpStoredSourceData = {
		767	...remote,
		768	...(input.endpoint !== undefined ? { endpoint: input.endpoint } : {}),
		769	...(input.headers !== undefined ? { headers: input.headers } : {}),
		770	...(input.auth !== undefined ? { auth: input.auth } : {}),
		771	...(input.queryParams !== undefined ? { queryParams: input.queryParams } : {}),
		772	};
		773
		774	yield* ctx.storage.putSource({
		775	namespace,
		776	scope,
		777	name: input.name?.trim() \|\| existing.name,
		778	config: updatedConfig,
		779	});
		780	}).pipe(
		781	Effect.withSpan("mcp.plugin.update_source", {
		782	attributes: { "mcp.source.namespace": namespace },
		783	}),
		784	);
		785
		786	const getSource = (namespace: string, scope: string) =>
		787	ctx.storage.getSource(namespace, scope).pipe(
		788	Effect.withSpan("mcp.plugin.get_source", {
		789	attributes: { "mcp.source.namespace": namespace },
		790	}),
		791	);
		792
		793	return {
		794	probeEndpoint,
		795	addSource,
		796	removeSource,
		797	refreshSource,
		798	getSource,
		799	updateSource,
		800	} satisfies McpPluginExtension;
		801	},
		802
		803	invokeTool: ({ ctx, toolRow, args, elicit }) =>
		804	Effect.gen(function* () {
		805	const runtime = yield* ensureRuntime();
		806
		807	// toolRow.scope_id is the resolved owning scope of the tool
		808	// (innermost-wins from the executor's stack). The matching
		809	// mcp_binding + mcp_source rows live at the same scope, so
		810	// pin every store lookup to it instead of relying on the
		811	// scoped adapter's stack-wide fall-through.
		812	const toolScope = toolRow.scope_id as string;
		813	const entry = yield* ctx.storage.getBinding(toolRow.id, toolScope).pipe(
		814	Effect.withSpan("mcp.plugin.load_binding", {
		815	attributes: { "mcp.tool.name": toolRow.id },
		816	}),
		817	);
		818	if (!entry) {
		819	return yield* Effect.fail(new Error(`No MCP binding found for tool "${toolRow.id}"`));
		820	}
932		821
933	const parsed = yield* Effect.try(() => new URL(trimmed)).pipe(	822	const sd = yield* ctx.storage.getSourceConfig(entry.namespace, toolScope).pipe(
934	Effect.option,	823	Effect.withSpan("mcp.plugin.load_source_config", {
		824	attributes: { "mcp.source.namespace": entry.namespace },
		825	}),
		826	);
		827	if (!sd) {
		828	return yield* Effect.fail(
		829	new Error(`No MCP source config for namespace "${entry.namespace}"`),
935	);	830	);
936	if (parsed._tag === "None") return null;	831	}
		832
		833	return yield* invokeMcpTool({
		834	toolId: toolRow.id,
		835	toolName: entry.binding.toolName,
		836	args,
		837	sourceData: sd,
		838	invokerScope: ctx.scopes[0]!.id as string,
		839	resolveConnector: () =>
		840	resolveConnectorInput(sd, ctx, allowStdio).pipe(
		841	Effect.flatMap((ci) => createMcpConnector(ci)),
		842	Effect.mapError((err) =>
		843	err instanceof McpConnectionError
		844	? err
		845	: new McpConnectionError({
		846	transport: "auto",
		847	message: err instanceof Error ? err.message : String(err),
		848	}),
		849	),
		850	Effect.withSpan("mcp.plugin.resolve_connector", {
		851	attributes: {
		852	"mcp.source.namespace": entry.namespace,
		853	"mcp.source.transport": sd.transport,
		854	},
		855	}),
		856	),
		857	connectionCache: runtime.connectionCache,
		858	pendingConnectors: runtime.pendingConnectors,
		859	elicit,
		860	});
		861	}).pipe(
		862	Effect.withSpan("mcp.plugin.invoke_tool", {
		863	attributes: {
		864	"mcp.tool.name": toolRow.id,
		865	"mcp.tool.source_id": toolRow.source_id,
		866	},
		867	}),
		868	),
937		869
938	const name = parsed.value.hostname \|\| "mcp";	870	detect: ({ ctx, url }) =>
939	const namespace = deriveMcpNamespace({ endpoint: trimmed });	871	Effect.gen(function* () {
		872	const trimmed = url.trim();
		873	if (!trimmed) return null;
940		874
941	const connector = createMcpConnector({	875	const parsed = yield* Effect.try(() => new URL(trimmed)).pipe(Effect.option);
942	transport: "remote",	876	if (parsed._tag === "None") return null;
943	endpoint: trimmed,
944	});
945		877
946	const connected = yield* discoverTools(connector).pipe(	878	const name = parsed.value.hostname \|\| "mcp";
947	Effect.map(() => true),	879	const namespace = deriveMcpNamespace({ endpoint: trimmed });
948	Effect.catchAll(() => Effect.succeed(false)),
949	Effect.withSpan("mcp.plugin.discover_tools"),
950	);
951		880
952	if (connected) {	881	const connector = createMcpConnector({
953	return new SourceDetectionResult({	882	transport: "remote",
954	kind: "mcp",	883	endpoint: trimmed,
955	confidence: "high",	884	});
956	endpoint: trimmed,
957	name,
958	namespace,
959	});
960	}
961		885
962	// host publishes RFC 9728 + 8414 metadata) would be classified	886	const connected = yield* discoverTools(connector).pipe(
963	// as MCP whenever the cross-plugin detector fans out to us.	887	Effect.map(() => true),
964	const shape = yield* probeMcpEndpointShape(trimmed);	888	Effect.catchAll(() => Effect.succeed(false)),
965	if (shape.kind !== "mcp") return null;	889	Effect.withSpan("mcp.plugin.discover_tools"),
966		890	);
967	// Confirm OAuth metadata is actually reachable. The shape
968	// probe already found a Bearer challenge; the core OAuth
969	// service's probe verifies the AS metadata resolves so we
970	// don't classify endpoints that challenge but have no
971	// discovery.
972	const probeOk = yield* ctx.oauth
973	.probe({ endpoint: trimmed })
974	.pipe(
975	Effect.map(() => true),
976	Effect.catchAll(() => Effect.succeed(false)),
977	Effect.withSpan("mcp.plugin.probe_oauth"),
978	);
979	if (!probeOk) return null;
980		891
		892	if (connected) {
981	return new SourceDetectionResult({	893	return new SourceDetectionResult({
982	kind: "mcp",	894	kind: "mcp",
983	confidence: "high",	895	confidence: "high",
@@ -985,49 +897,74 @@ export const mcpPlugin = definePlugin( · 1 unmodified line
985	name,	897	name,
986	namespace,	898	namespace,
987	});	899	});
988	}).pipe(	900	}
989	Effect.catchAll(() => Effect.succeed(null)),	901
990	Effect.withSpan("mcp.plugin.detect", {	902	// host publishes RFC 9728 + 8414 metadata) would be classified
991	attributes: { "mcp.endpoint": url },	903	// as MCP whenever the cross-plugin detector fans out to us.
992	}),	904	const shape = yield* probeMcpEndpointShape(trimmed);
993	),	905	if (shape.kind !== "mcp") return null;
994		906
995	// MCP tools never require approval at the tool level — elicitation is	907	// Confirm OAuth metadata is actually reachable. The shape
996	// handled mid-invocation by the server via the elicit capability.	908	// probe already found a Bearer challenge; the core OAuth
997	resolveAnnotations: ({ toolRows }) =>	909	// service's probe verifies the AS metadata resolves so we
998	Effect.sync(() => {	910	// don't classify endpoints that challenge but have no
999	const out: Record<string, { requiresApproval: boolean }> = {};	911	// discovery.
1000	for (const row of toolRows) {	912	const probeOk = yield* ctx.oauth.probe({ endpoint: trimmed }).pipe(
1001	out[row.id] = { requiresApproval: false };	913	Effect.map(() => true),
1002	}	914	Effect.catchAll(() => Effect.succeed(false)),
1003	return out;	915	Effect.withSpan("mcp.plugin.probe_oauth"),
1004	}),	916	);
1005		917	if (!probeOk) return null;
1006	removeSource: ({ ctx, sourceId, scope }) =>	918
1007	Effect.gen(function* () {	919	return new SourceDetectionResult({
1008	yield* ctx.storage.removeBindingsByNamespace(sourceId, scope);	920	kind: "mcp",
1009	yield* ctx.storage.removeSource(sourceId, scope);	921	confidence: "high",
		922	endpoint: trimmed,
		923	name,
		924	namespace,
		925	});
		926	}).pipe(
		927	Effect.catchAll(() => Effect.succeed(null)),
		928	Effect.withSpan("mcp.plugin.detect", {
		929	attributes: { "mcp.endpoint": url },
1010	}),	930	}),
1011		931	),
1012	refreshSource: () => Effect.void,	932
1013		933	// MCP tools never require approval at the tool level — elicitation is
1014	// Connection refresh for oauth2-minted sources is owned by the	934	// handled mid-invocation by the server via the elicit capability.
1015	// canonical `"oauth2"` ConnectionProvider that core registers via	935	resolveAnnotations: ({ toolRows }) =>
1016	// `makeOAuth2Service`. No MCP-specific provider needed.	936	Effect.sync(() => {
1017		937	const out: Record<string, { requiresApproval: boolean }> = {};
1018	close: () =>	938	for (const row of toolRows) {
1019	Effect.gen(function* () {	939	out[row.id] = { requiresApproval: false };
1020	const runtime = runtimeRef.current;	940	}
1021	if (runtime) {	941	return out;
1022	runtime.pendingConnectors.clear();	942	}),
1023	yield* runtime.connectionCache.invalidateAll;	943
1024	yield* Scope.close(runtime.cacheScope, Exit.void);	944	removeSource: ({ ctx, sourceId, scope }) =>
1025	runtimeRef.current = null;	945	Effect.gen(function* () {
1026	}	946	yield* ctx.storage.removeBindingsByNamespace(sourceId, scope);
1027	}).pipe(Effect.withSpan("mcp.plugin.close")),	947	yield* ctx.storage.removeSource(sourceId, scope);
1028	};	948	}),
1029	},	949
1030	);	950	refreshSource: () => Effect.void,
		951
		952	// Connection refresh for oauth2-minted sources is owned by the
		953	// canonical `"oauth2"` ConnectionProvider that core registers via
		954	// `makeOAuth2Service`. No MCP-specific provider needed.
		955
		956	close: () =>
		957	Effect.gen(function* () {
		958	const runtime = runtimeRef.current;
		959	if (runtime) {
		960	runtime.pendingConnectors.clear();
		961	yield* runtime.connectionCache.invalidateAll;
		962	yield* Scope.close(runtime.cacheScope, Exit.void);
		963	runtimeRef.current = null;
		964	}
		965	}).pipe(Effect.withSpan("mcp.plugin.close")),
		966	};
		967	});
1031		968
1032	// ---------------------------------------------------------------------------	969	// ---------------------------------------------------------------------------
1033	// McpPluginExtension — shape of `executor.mcp` for consumers that want	970	// McpPluginExtension — shape of `executor.mcp` for consumers that want
@@ -1045,10 +982,7 @@ export const mcpPlugin = definePlugin( · 11 unmodified lines
1045	* composition. `UniqueViolationError` passes through — plugins can	982	* composition. `UniqueViolationError` passes through — plugins can
1046	* `Effect.catchTag` it if they want a friendlier user-facing error.	983	* `Effect.catchTag` it if they want a friendlier user-facing error.
1047	*/	984	*/
1048	export type McpExtensionFailure =	985	export type McpExtensionFailure = McpConnectionError \| McpToolDiscoveryError \| StorageFailure;
1049	\| McpConnectionError
1050	\| McpToolDiscoveryError
1051	\| StorageFailure;
1052		986
1053	export interface McpPluginExtension {	987	export interface McpPluginExtension {
1054	readonly probeEndpoint: (	988	readonly probeEndpoint: (

packages/plugins/mcp/src/sdk/types.ts+3−10

 import { Schema } from "effect";
+import { SecretBackedMap, SecretBackedValue } from "@executor/sdk";
+export { SecretBackedMap, SecretBackedValue };
 // ---------------------------------------------------------------------------
 // Remote transport type
 // Stored source data — discriminated union on transport
 // ---------------------------------------------------------------------------
-export const SecretBackedValue = Schema.Union(
-  Schema.String,
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
-export type SecretBackedValue = typeof SecretBackedValue.Type;
 /** Common fields for remote string map schemas */
 const StringMap = Schema.Record({ key: Schema.String, value: Schema.String });
-const SecretBackedMap = Schema.Record({ key: Schema.String, value: SecretBackedValue });
 export const McpRemoteSourceData = Schema.Struct({
   transport: Schema.Literal("remote"),

packages/plugins/openapi/src/api/group.ts+1−9

 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "@effect/platform";
 import { Schema } from "effect";
-import { ScopeId } from "@executor/sdk";
+import { ScopeId, SecretBackedValue } from "@executor/sdk";
 import { InternalError } from "@executor/api";
 import { OpenApiParseError, OpenApiExtractionError, OpenApiOAuthError } from "../sdk/errors";
 const namespaceParam = HttpApiSchema.param("namespace", Schema.String);
 const sourceScopeIdParam = HttpApiSchema.param("sourceScopeId", ScopeId);
-const SecretBackedValue = Schema.Union(
-  Schema.String,
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
 const SpecFetchCredentialsPayload = Schema.Struct({
   headers: Schema.optional(Schema.Record({ key: Schema.String, value: SecretBackedValue })),
   queryParams: Schema.optional(Schema.Record({ key: Schema.String, value: SecretBackedValue })),

packages/plugins/openapi/src/sdk/plugin.ts+18−25

   SecretId,
   SourceDetectionResult,
   definePlugin,
+  resolveSecretBackedMap,
   type PluginCtx,
   type StorageFailure,
   type ToolAnnotations,
     return resolved;
   });
-const resolveHeaderValue = (
+const resolveHeaderValues = (
   ctx: PluginCtx<OpenapiStore>,
-  name: string,
+  values: Record<string, HeaderValue> | undefined,
-  value: HeaderValue,
+): Effect.Effect<Record<string, string>, OpenApiOAuthError | StorageFailure> =>
-): Effect.Effect<string, OpenApiOAuthError | StorageFailure> => {
+  resolveSecretBackedMap({
-  if (typeof value === "string") return Effect.succeed(value);
+    values,
-  return ctx.secrets.get(value.secretId).pipe(
+    getSecret: ctx.secrets.get,
-    Effect.mapError((err) =>
+    onMissing: (name) =>
+      new OpenApiOAuthError({
+        message: `Secret not found for "${name}"`,
+      }),
+    onError: (err, name) =>
       "_tag" in err && err._tag === "SecretOwnedByConnectionError"
         ? new OpenApiOAuthError({
             message: `Secret not found for "${name}"`,
           })
         : err,
+  }).pipe(
+    Effect.mapError((err) =>
+      "_tag" in err && err._tag === "SecretOwnedByConnectionError"
+        ? new OpenApiOAuthError({ message: "Secret resolution failed" })
+        : err,
     ),
-    Effect.flatMap((secret) =>
+    Effect.map((resolved) => resolved ?? {}),
-      secret === null
-        ? Effect.fail(
-            new OpenApiOAuthError({
-              message: `Secret not found for "${name}"`,
-            }),
-          )
-        : Effect.succeed(value.prefix ? `${value.prefix}${secret}` : secret),
-    ),
   );
-};
-const resolveHeaderValues = (
-  ctx: PluginCtx<OpenapiStore>,
-  values: Record<string, HeaderValue> | undefined,
-): Effect.Effect<Record<string, string>, OpenApiOAuthError | StorageFailure> =>
-  Effect.forEach(Object.entries(values ?? {}), ([name, value]) =>
-    Effect.map(resolveHeaderValue(ctx, name, value), (resolved) => [name, resolved] as const),
-  ).pipe(Effect.map((entries) => Object.fromEntries(entries)));
 const resolveOAuthConnectionId = (
   ctx: PluginCtx<OpenapiStore>,

packages/plugins/openapi/src/sdk/types.ts+6−16

 import { Schema } from "effect";
-import { ConnectionId, ScopeId, SecretId } from "@executor/sdk";
+import { ConnectionId, ScopeId, SecretBackedValue, SecretId } from "@executor/sdk";
 // ---------------------------------------------------------------------------
 // Branded IDs
 export class MediaBinding extends Schema.Class<MediaBinding>("MediaBinding")({
   contentType: Schema.String,
   schema: Schema.optionalWith(Schema.Unknown, { as: "Option" }),
-  encoding: Schema.optionalWith(
+  encoding: Schema.optionalWith(Schema.Record({ key: Schema.String, value: EncodingObject }), {
-    Schema.Record({ key: Schema.String, value: EncodingObject }),
+    as: "Option",
-    { as: "Option" },
+  }),
-  ),
 }) {}
 export class OperationRequestBody extends Schema.Class<OperationRequestBody>(
  * A header value — either a static string or a reference to a secret.
  * Stored as JSON-serializable data.
  */
-export const HeaderValue = Schema.Union(
+export const HeaderValue = SecretBackedValue;
-  Schema.String,
-  Schema.Struct({
-    secretId: Schema.String,
-    prefix: Schema.optional(Schema.String),
-  }),
-);
 export type HeaderValue = typeof HeaderValue.Type;
 export class ConfiguredHeaderBinding extends Schema.Class<ConfiguredHeaderBinding>(
   prefix: Schema.optional(Schema.String),
 }) {}
-export const ConfiguredHeaderValue = Schema.Union(
+export const ConfiguredHeaderValue = Schema.Union(Schema.String, ConfiguredHeaderBinding);
-  Schema.String,
-  ConfiguredHeaderBinding,
-);
 export type ConfiguredHeaderValue = typeof ConfiguredHeaderValue.Type;
 export const OpenApiSourceBindingValue = Schema.Union(

packages/react/src/plugins/http-credentials.tsx+2−7

 import { useId } from "react";
 import { PlusIcon } from "lucide-react";
-import type { ScopeId } from "@executor/sdk";
+import type { ScopeId, SecretBackedValue } from "@executor/sdk";
 import { Button } from "../components/button";
 import { CardStack, CardStackContent, CardStackEntry } from "../components/card-stack";
 } from "./secret-header-auth";
 import type { SecretPickerSecret } from "./secret-picker";
-export type SecretBackedValue =
+export type { SecretBackedValue };
-  | string
-  | {
-      readonly secretId: string;
-      readonly prefix?: string;
-    };
 export type QueryParamState = {
   name: string;

packages/react/src/plugins/oauth-sign-in.tsx+5−8

@@ -5,14 +5,11 @@ import { cancelOAuth, startOAuth } from "../api/atoms"; · 4 unmodified lines
5	import { openOAuthPopup, type OAuthPopupResult } from "../api/oauth-popup";	5	import { openOAuthPopup, type OAuthPopupResult } from "../api/oauth-popup";
6	import { useScope } from "../api/scope-context";	6	import { useScope } from "../api/scope-context";
7	import { Button } from "../components/button";	7	import { Button } from "../components/button";
8	import { OAUTH_POPUP_MESSAGE_TYPE, type OAuthStrategy } from "@executor/sdk";	8	import {
9		9	OAUTH_POPUP_MESSAGE_TYPE,
10	type SecretBackedValue =	10	type OAuthStrategy,
11	\| string	11	type SecretBackedValue,
12	\| {	12	} from "@executor/sdk";
13	readonly secretId: string;
14	readonly prefix?: string;
15	};
16		13
17	export type OAuthCompletionPayload = {	14	export type OAuthCompletionPayload = {
18	readonly connectionId: string;	15	readonly connectionId: string;