@executor-js/plugin-mcp 1.5.6 → 1.5.8

package/dist/react/atoms.d.ts

@@ -5,23 +5,32 @@ export declare const mcpServerAtom: (slug: IntegrationSlug) => import("effect/un
     readonly kind: string;
     readonly config: {
         readonly endpoint: string;
-        readonly auth: {
-            readonly kind: "none";
+        readonly transport: "remote";
+        readonly authenticationTemplate: readonly ({
+            readonly slug: string;
+            readonly kind: "apikey";
+            readonly placements: readonly {
+                readonly name: string;
+                readonly carrier: "header" | "query";
+                readonly variable?: string | undefined;
+                readonly prefix?: string | undefined;
+                readonly literal?: string | undefined;
+            }[];
+            readonly label?: string | undefined;
         } | {
-            readonly kind: "header";
-            readonly headerName: string;
-            readonly prefix?: string | undefined;
+            readonly slug: string;
+            readonly kind: "none";
         } | {
+            readonly slug: string;
             readonly kind: "oauth2";
-        };
-        readonly transport: "remote";
+        })[];
         readonly headers?: {
             readonly [x: string]: string;
         } | undefined;
-        readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
         readonly queryParams?: {
             readonly [x: string]: string;
         } | undefined;
+        readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
     } | {
         readonly transport: "stdio";
         readonly command: string;
@@ -73,11 +82,34 @@ export declare const addMcpServer: import("effect/unstable/reactivity/Atom").Ato
         readonly headers?: {
             readonly [x: string]: string;
         } | undefined;
-        readonly transport?: "remote" | undefined;
-        readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
         readonly queryParams?: {
             readonly [x: string]: string;
         } | undefined;
+        readonly transport?: "remote" | undefined;
+        readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
+        readonly authenticationTemplate?: readonly ({
+            readonly type: "apiKey";
+            readonly slug?: string | undefined;
+            readonly label?: string | undefined;
+            readonly headers?: {
+                readonly [x: string]: string | readonly (string | {
+                    readonly type: "variable";
+                    readonly name: string;
+                })[];
+            } | undefined;
+            readonly queryParams?: {
+                readonly [x: string]: string | readonly (string | {
+                    readonly type: "variable";
+                    readonly name: string;
+                })[];
+            } | undefined;
+        } | {
+            readonly kind: "none";
+            readonly slug?: string | undefined;
+        } | {
+            readonly kind: "oauth2";
+            readonly slug?: string | undefined;
+        })[] | undefined;
     };
     readonly responseMode?: "decoded-only" | undefined;
     readonly reactivityKeys?: readonly unknown[] | import("effect/Record").ReadonlyRecord<string, readonly unknown[]> | undefined;
@@ -114,23 +146,32 @@ export declare const configureMcpServer: import("effect/unstable/reactivity/Atom
     readonly payload: {
         readonly config: {
             readonly endpoint: string;
-            readonly auth: {
-                readonly kind: "none";
+            readonly transport: "remote";
+            readonly authenticationTemplate: readonly ({
+                readonly slug: string;
+                readonly kind: "apikey";
+                readonly placements: readonly {
+                    readonly name: string;
+                    readonly carrier: "header" | "query";
+                    readonly variable?: string | undefined;
+                    readonly prefix?: string | undefined;
+                    readonly literal?: string | undefined;
+                }[];
+                readonly label?: string | undefined;
             } | {
-                readonly kind: "header";
-                readonly headerName: string;
-                readonly prefix?: string | undefined;
+                readonly slug: string;
+                readonly kind: "none";
             } | {
+                readonly slug: string;
                 readonly kind: "oauth2";
-            };
-            readonly transport: "remote";
+            })[];
             readonly headers?: {
                 readonly [x: string]: string;
             } | undefined;
-            readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
             readonly queryParams?: {
                 readonly [x: string]: string;
             } | undefined;
+            readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
         } | {
             readonly transport: "stdio";
             readonly command: string;
@@ -146,23 +187,32 @@ export declare const configureMcpServer: import("effect/unstable/reactivity/Atom
 }, {
     readonly config: {
         readonly endpoint: string;
-        readonly auth: {
-            readonly kind: "none";
+        readonly transport: "remote";
+        readonly authenticationTemplate: readonly ({
+            readonly slug: string;
+            readonly kind: "apikey";
+            readonly placements: readonly {
+                readonly name: string;
+                readonly carrier: "header" | "query";
+                readonly variable?: string | undefined;
+                readonly prefix?: string | undefined;
+                readonly literal?: string | undefined;
+            }[];
+            readonly label?: string | undefined;
         } | {
-            readonly kind: "header";
-            readonly headerName: string;
-            readonly prefix?: string | undefined;
+            readonly slug: string;
+            readonly kind: "none";
         } | {
+            readonly slug: string;
             readonly kind: "oauth2";
-        };
-        readonly transport: "remote";
+        })[];
         readonly headers?: {
             readonly [x: string]: string;
         } | undefined;
-        readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
         readonly queryParams?: {
             readonly [x: string]: string;
         } | undefined;
+        readonly remoteTransport?: "auto" | "streamable-http" | "sse" | undefined;
     } | {
         readonly transport: "stdio";
         readonly command: string;
@@ -173,3 +223,55 @@ export declare const configureMcpServer: import("effect/unstable/reactivity/Atom
         } | undefined;
     };
 }, import("@executor-js/sdk").InternalError | import("../sdk").McpConnectionError | import("../sdk").McpToolDiscoveryError>;
+export declare const configureMcpAuth: import("effect/unstable/reactivity/Atom").AtomResultFn<{
+    readonly params: {
+        readonly slug: string & import("effect/Brand").Brand<"IntegrationSlug">;
+    };
+    readonly payload: {
+        readonly authenticationTemplate: readonly ({
+            readonly type: "apiKey";
+            readonly slug?: string | undefined;
+            readonly label?: string | undefined;
+            readonly headers?: {
+                readonly [x: string]: string | readonly (string | {
+                    readonly type: "variable";
+                    readonly name: string;
+                })[];
+            } | undefined;
+            readonly queryParams?: {
+                readonly [x: string]: string | readonly (string | {
+                    readonly type: "variable";
+                    readonly name: string;
+                })[];
+            } | undefined;
+        } | {
+            readonly kind: "none";
+            readonly slug?: string | undefined;
+        } | {
+            readonly kind: "oauth2";
+            readonly slug?: string | undefined;
+        })[];
+        readonly mode?: "replace" | "merge" | undefined;
+    };
+    readonly responseMode?: "decoded-only" | undefined;
+    readonly reactivityKeys?: readonly unknown[] | import("effect/Record").ReadonlyRecord<string, readonly unknown[]> | undefined;
+}, {
+    readonly authenticationTemplate: readonly ({
+        readonly slug: string;
+        readonly kind: "apikey";
+        readonly placements: readonly {
+            readonly name: string;
+            readonly carrier: "header" | "query";
+            readonly variable?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly literal?: string | undefined;
+        }[];
+        readonly label?: string | undefined;
+    } | {
+        readonly slug: string;
+        readonly kind: "none";
+    } | {
+        readonly slug: string;
+        readonly kind: "oauth2";
+    })[];
+}, import("@executor-js/sdk").InternalError | import("../sdk").McpConnectionError | import("../sdk").McpToolDiscoveryError>;

package/dist/react/auth-method-config.d.ts

@@ -1,8 +1,23 @@
 import type { AuthTemplateEditorValue } from "@executor-js/react/components/auth-template-editor";
-import type { McpAuthTemplate } from "../sdk/types";
-/** Convert a generic editor value into MCP's single `McpAuthTemplate`. An
- *  apiKey method maps to a `header` template using its FIRST header placement
- *  (MCP carries a single header, not an array); a header placement's prefix is
- *  preserved. OAuth maps to `oauth2`; `none` to `none`. An apiKey value with no
- *  usable header placement falls back to `none`. */
-export declare function mcpAuthTemplateFromEditorValue(value: AuthTemplateEditorValue): McpAuthTemplate;
+import type { AuthMethod, Placement } from "@executor-js/react/lib/auth-placements";
+import type { McpAuthMethod, McpAuthMethodInput, McpCanonicalAuthMethodInput } from "../sdk/types";
+/** Serialize a canonical method into the wire input union (apikey → the
+ *  request-shaped dialect; none/oauth2 pass through). */
+export declare const mcpWireAuthInput: (method: McpAuthMethod | McpCanonicalAuthMethodInput) => McpAuthMethodInput;
+/** Convert a generic editor value into one MCP auth-method input (no slug —
+ *  the backend assigns carrier-derived slugs). An apikey value keeps every
+ *  named placement (headers and query params mix freely); one with no usable
+ *  placement falls back to `none`. */
+export declare function mcpAuthMethodInputFromEditorValue(value: AuthTemplateEditorValue): McpCanonicalAuthMethodInput;
+/** Convert one stored MCP method into the generic editor value. */
+export declare function editorValueFromMcpAuthMethod(method: McpAuthMethod): AuthTemplateEditorValue;
+/** Project the stored methods into the generic `AuthMethod[]` the hub renders.
+ *  Mirrors the server's `describeMcpAuthMethods`; `custom_` slugs mark
+ *  user-created methods (removable from the hub). `endpoint` feeds the oauth
+ *  method's probe-at-connect `discoveryUrl`. */
+export declare function authMethodsFromConfig(methods: readonly McpAuthMethod[], endpoint: string): AuthMethod[];
+/** Build the MCP method input for a custom method from generic placements —
+ *  ONE method carrying every named placement (header + query mix in a single
+ *  method; each placement renders from its own input variable, or shares one).
+ *  Empty when no placement is usable. */
+export declare function mcpAuthMethodInputsFromPlacements(placements: readonly Placement[]): McpCanonicalAuthMethodInput[];

package/dist/react/client.d.ts

@@ -19,6 +19,25 @@ export declare const McpClient: import("effect/unstable/reactivity/AtomHttpApi")
     readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
     readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
     readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+    readonly authenticationTemplate: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly kind: import("effect/Schema").Literal<"none">;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly type: import("effect/Schema").Literal<"apiKey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+        readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+    }>]>>>;
     readonly auth: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
         readonly kind: import("effect/Schema").Literal<"none">;
     }>, import("effect/Schema").Struct<{
@@ -56,15 +75,24 @@ export declare const McpClient: import("effect/unstable/reactivity/AtomHttpApi")
         readonly remoteTransport: import("effect/Schema").withConstructorDefault<import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["streamable-http", "sse", "auto"]>>>;
         readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
         readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
-        readonly auth: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly slug: import("effect/Schema").String;
             readonly kind: import("effect/Schema").Literal<"none">;
         }>, import("effect/Schema").Struct<{
-            readonly kind: import("effect/Schema").Literal<"header">;
-            readonly headerName: import("effect/Schema").String;
-            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly slug: import("effect/Schema").String;
+            readonly kind: import("effect/Schema").Literal<"apikey">;
+            readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+                readonly name: import("effect/Schema").String;
+                readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>>;
         }>, import("effect/Schema").Struct<{
+            readonly slug: import("effect/Schema").String;
             readonly kind: import("effect/Schema").Literal<"oauth2">;
-        }>]>;
+        }>]>>;
     }>, import("effect/Schema").Struct<{
         readonly transport: import("effect/Schema").Literal<"stdio">;
         readonly command: import("effect/Schema").String;
@@ -81,15 +109,24 @@ export declare const McpClient: import("effect/unstable/reactivity/AtomHttpApi")
         readonly remoteTransport: import("effect/Schema").withConstructorDefault<import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["streamable-http", "sse", "auto"]>>>;
         readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
         readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
-        readonly auth: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly slug: import("effect/Schema").String;
             readonly kind: import("effect/Schema").Literal<"none">;
         }>, import("effect/Schema").Struct<{
-            readonly kind: import("effect/Schema").Literal<"header">;
-            readonly headerName: import("effect/Schema").String;
-            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly slug: import("effect/Schema").String;
+            readonly kind: import("effect/Schema").Literal<"apikey">;
+            readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+                readonly name: import("effect/Schema").String;
+                readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>>;
         }>, import("effect/Schema").Struct<{
+            readonly slug: import("effect/Schema").String;
             readonly kind: import("effect/Schema").Literal<"oauth2">;
-        }>]>;
+        }>]>>;
     }>, import("effect/Schema").Struct<{
         readonly transport: import("effect/Schema").Literal<"stdio">;
         readonly command: import("effect/Schema").String;
@@ -104,15 +141,24 @@ export declare const McpClient: import("effect/unstable/reactivity/AtomHttpApi")
         readonly remoteTransport: import("effect/Schema").withConstructorDefault<import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["streamable-http", "sse", "auto"]>>>;
         readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
         readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
-        readonly auth: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly slug: import("effect/Schema").String;
             readonly kind: import("effect/Schema").Literal<"none">;
         }>, import("effect/Schema").Struct<{
-            readonly kind: import("effect/Schema").Literal<"header">;
-            readonly headerName: import("effect/Schema").String;
-            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly slug: import("effect/Schema").String;
+            readonly kind: import("effect/Schema").Literal<"apikey">;
+            readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+                readonly name: import("effect/Schema").String;
+                readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>>;
         }>, import("effect/Schema").Struct<{
+            readonly slug: import("effect/Schema").String;
             readonly kind: import("effect/Schema").Literal<"oauth2">;
-        }>]>;
+        }>]>>;
     }>, import("effect/Schema").Struct<{
         readonly transport: import("effect/Schema").Literal<"stdio">;
         readonly command: import("effect/Schema").String;
@@ -120,4 +166,46 @@ export declare const McpClient: import("effect/unstable/reactivity/AtomHttpApi")
         readonly env: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
         readonly cwd: import("effect/Schema").optional<import("effect/Schema").String>;
     }>]>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/sdk").InternalError | typeof import("../sdk").McpConnectionError | typeof import("../sdk").McpToolDiscoveryError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"configureAuth", "POST", "/mcp/servers/:slug/auth", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly kind: import("effect/Schema").Literal<"none">;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly type: import("effect/Schema").Literal<"apiKey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+        readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+    }>]>>;
+    readonly mode: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["merge", "replace"]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"none">;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"apikey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+            readonly name: import("effect/Schema").String;
+            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+    }>]>>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/sdk").InternalError | typeof import("../sdk").McpConnectionError | typeof import("../sdk").McpToolDiscoveryError>, never, never>, false>>;

package/dist/sdk/connection.d.ts

@@ -8,7 +8,7 @@ export type McpConnection = {
     readonly close: () => Promise<void>;
 };
 export type McpConnector = Effect.Effect<McpConnection, McpConnectionError>;
-export type RemoteConnectorInput = Omit<McpRemoteIntegrationConfig, "auth" | "remoteTransport" | "headers" | "queryParams"> & {
+export type RemoteConnectorInput = Omit<McpRemoteIntegrationConfig, "authenticationTemplate" | "remoteTransport" | "headers" | "queryParams"> & {
     readonly remoteTransport?: McpRemoteIntegrationConfig["remoteTransport"];
     readonly headers?: Record<string, string>;
     readonly queryParams?: Record<string, string>;

package/dist/sdk/index.d.ts

@@ -1,4 +1,6 @@
 export { mcpPlugin, userFacingProbeMessage, type McpPluginExtension, type McpPluginOptions, type McpServerInput, type McpRemoteServerInput, type McpStdioServerInput, type McpProbeResult, type McpProbeEndpointInput, type McpExtensionFailure, } from "./plugin";
-export { McpAuthTemplate, McpIntegrationConfig, McpRemoteIntegrationConfig, McpStdioIntegrationConfig, McpRemoteTransport, McpTransport, McpToolAnnotations, McpToolBinding, parseMcpIntegrationConfig, } from "./types";
+export { McpAuthMethod, McpAuthMethodInput, McpAuthShorthand, McpIntegrationConfig, McpRemoteIntegrationConfig, McpStdioIntegrationConfig, McpRemoteTransport, McpTransport, McpToolAnnotations, McpToolBinding, parseMcpIntegrationConfig, } from "./types";
+export { migrateMcpAuthConfig } from "./migrate-config";
+export { variable, type ApiKeyAuthTemplate } from "@executor-js/sdk/http-auth";
 export { McpConnectionError, McpToolDiscoveryError, McpInvocationError, McpOAuthError, } from "./errors";
 export { deriveMcpNamespace, joinToolPath, extractManifestFromListToolsResult } from "./manifest";

package/dist/sdk/invoke.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { type Elicit } from "@executor-js/sdk/core";
+import { type Elicit } from "@executor-js/sdk";
 import { McpConnectionError, McpInvocationError } from "./errors";
 import type { McpConnector } from "./connection";
 export interface InvokeMcpToolInput {

package/dist/sdk/migrate-config.d.ts

@@ -0,0 +1,6 @@
+/** Rewrite a stored MCP integration config blob into the canonical shape.
+ *  Returns the rewritten config, or `null` when no rewrite is needed (already
+ *  canonical, a stdio config, or not this plugin's shape at all). Throws
+ *  nothing: an unmigratable blob also returns `null` and stays untouched.
+ *  Idempotent — feeding the output back returns `null`. */
+export declare const migrateMcpAuthConfig: (config: unknown) => unknown | null;

package/dist/sdk/migrate-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/multi-placement-auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/plugin.d.ts

@@ -1,9 +1,9 @@
 import { Effect, Layer, Schema } from "effect";
 import type { HttpClient } from "effect/unstable/http";
-import { IntegrationAlreadyExistsError, type AuthMethodDescriptor, type Integration, type IntegrationConfig, type IntegrationRecord, type StorageFailure } from "@executor-js/sdk/core";
+import { IntegrationAlreadyExistsError, type AuthMethodDescriptor, type Integration, type IntegrationConfig, type IntegrationRecord, type StorageFailure } from "@executor-js/sdk";
 import { McpConnectionError, McpToolDiscoveryError } from "./errors";
 import { type McpShapeProbeResult } from "./probe-shape";
-import { type McpIntegrationConfig as McpIntegrationConfigType } from "./types";
+import { type McpAuthMethod, type McpIntegrationConfig as McpIntegrationConfigType } from "./types";
 declare const McpRemoteServerInputSchema: Schema.Struct<{
     readonly transport: Schema.optional<Schema.Literal<"remote">>;
     readonly name: Schema.String;
@@ -12,7 +12,28 @@ declare const McpRemoteServerInputSchema: Schema.Struct<{
     readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly slug: Schema.optional<Schema.String>;
-    /** How a connection's value is applied to requests. Defaults to none. */
+    /** Declared auth methods a connection can be applied through. */
+    readonly authenticationTemplate: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly kind: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly type: Schema.Literal<"apiKey">;
+        readonly label: Schema.optional<Schema.String>;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly type: Schema.Literal<"variable">;
+            readonly name: Schema.String;
+        }>]>>]>>>;
+        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly type: Schema.Literal<"variable">;
+            readonly name: Schema.String;
+        }>]>>]>>>;
+    }>]>>>;
+    /** Single-method shorthand (legacy callers). Ignored when
+     *  `authenticationTemplate` is present. Defaults to none. */
     readonly auth: Schema.optional<Schema.Union<readonly [Schema.Struct<{
         readonly kind: Schema.Literal<"none">;
     }>, Schema.Struct<{
@@ -40,7 +61,28 @@ declare const McpAddServerInputSchema: Schema.Union<readonly [Schema.Struct<{
     readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly slug: Schema.optional<Schema.String>;
-    /** How a connection's value is applied to requests. Defaults to none. */
+    /** Declared auth methods a connection can be applied through. */
+    readonly authenticationTemplate: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly kind: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly type: Schema.Literal<"apiKey">;
+        readonly label: Schema.optional<Schema.String>;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly type: Schema.Literal<"variable">;
+            readonly name: Schema.String;
+        }>]>>]>>>;
+        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly type: Schema.Literal<"variable">;
+            readonly name: Schema.String;
+        }>]>>]>>>;
+    }>]>>>;
+    /** Single-method shorthand (legacy callers). Ignored when
+     *  `authenticationTemplate` is present. Defaults to none. */
     readonly auth: Schema.optional<Schema.Union<readonly [Schema.Struct<{
         readonly kind: Schema.Literal<"none">;
     }>, Schema.Struct<{
@@ -59,6 +101,32 @@ declare const McpAddServerInputSchema: Schema.Union<readonly [Schema.Struct<{
     readonly cwd: Schema.optional<Schema.String>;
     readonly slug: Schema.optional<Schema.String>;
 }>]>;
+/** Input for the custom-method-create flow. `merge` (default) appends onto the
+ *  integration's existing `authenticationTemplate`; `replace` swaps the whole
+ *  declared set. Mirrors the OpenAPI/GraphQL `configureAuth` inputs. */
+export declare const McpConfigureAuthInputSchema: Schema.Struct<{
+    readonly authenticationTemplate: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly kind: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly slug: Schema.optional<Schema.String>;
+        readonly type: Schema.Literal<"apiKey">;
+        readonly label: Schema.optional<Schema.String>;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly type: Schema.Literal<"variable">;
+            readonly name: Schema.String;
+        }>]>>]>>>;
+        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly type: Schema.Literal<"variable">;
+            readonly name: Schema.String;
+        }>]>>]>>>;
+    }>]>>;
+    readonly mode: Schema.optional<Schema.Literals<readonly ["merge", "replace"]>>;
+}>;
+export type McpConfigureAuthInput = typeof McpConfigureAuthInputSchema.Type;
 declare const McpProbeEndpointInputSchema: Schema.Struct<{
     readonly endpoint: Schema.String;
     readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
@@ -100,7 +168,7 @@ export interface McpPluginOptions {
     readonly dangerouslyAllowStdioMCP?: boolean;
     readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient>;
 }
-export declare const mcpPlugin: import("@executor-js/sdk/core").ConfiguredPlugin<"mcp", {
+export declare const mcpPlugin: import("@executor-js/sdk").ConfiguredPlugin<"mcp", {
     probeEndpoint: (input: string | McpProbeEndpointInput) => Effect.Effect<{
         connected: true;
         requiresAuthentication: false;
@@ -135,6 +203,24 @@ export declare const mcpPlugin: import("@executor-js/sdk/core").ConfiguredPlugin
     removeServer: (slug: string) => Effect.Effect<void, StorageFailure, never>;
     getServer: (slug: string) => Effect.Effect<IntegrationRecord | null, StorageFailure, never>;
     configureServer: (slug: string, config: McpIntegrationConfigType) => Effect.Effect<void, StorageFailure, never>;
+    configureAuth: (slug: string, input: McpConfigureAuthInput) => Effect.Effect<readonly ({
+        readonly slug: string;
+        readonly kind: "apikey";
+        readonly placements: readonly {
+            readonly name: string;
+            readonly carrier: "header" | "query";
+            readonly variable?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly literal?: string | undefined;
+        }[];
+        readonly label?: string | undefined;
+    } | {
+        readonly slug: string;
+        readonly kind: "none";
+    } | {
+        readonly slug: string;
+        readonly kind: "oauth2";
+    })[], StorageFailure, never>;
 }, {}, McpPluginOptions, undefined, Layer.Layer<unknown, never, never>, import("effect/unstable/httpapi/HttpApiGroup").Any>;
 export type McpExtensionFailure = McpConnectionError | McpToolDiscoveryError | StorageFailure;
 export interface McpPluginExtension {
@@ -147,5 +233,6 @@ export interface McpPluginExtension {
         readonly config: IntegrationConfig;
     }) | null, McpExtensionFailure>;
     readonly configureServer: (slug: string, config: McpIntegrationConfigType) => Effect.Effect<void, McpExtensionFailure>;
+    readonly configureAuth: (slug: string, input: McpConfigureAuthInput) => Effect.Effect<readonly McpAuthMethod[], McpExtensionFailure>;
 }
 export {};