@executor-js/plugin-mcp 1.5.0 → 1.5.2

package/dist/react/client.d.ts

@@ -1,123 +0,0 @@
-export declare const McpClient: import("effect/unstable/reactivity/AtomHttpApi").AtomHttpApiClient<"Plugin_mcpClient", `Plugin_${string}Client`, import("effect/unstable/httpapi/HttpApiGroup").HttpApiGroup<"mcp", import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"probeEndpoint", "POST", "/mcp/probe", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
-    readonly endpoint: import("effect/Schema").String;
-    readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
-    readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
-}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
-    readonly connected: import("effect/Schema").Boolean;
-    readonly requiresAuthentication: import("effect/Schema").Boolean;
-    readonly requiresOAuth: import("effect/Schema").Boolean;
-    readonly supportsDynamicRegistration: import("effect/Schema").Boolean;
-    readonly name: import("effect/Schema").String;
-    readonly slug: import("effect/Schema").String;
-    readonly toolCount: import("effect/Schema").NullOr<import("effect/Schema").Number>;
-    readonly serverName: import("effect/Schema").NullOr<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<"addServer", "POST", "/mcp/servers", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
-    readonly transport: import("effect/Schema").optional<import("effect/Schema").Literal<"remote">>;
-    readonly name: import("effect/Schema").String;
-    readonly endpoint: import("effect/Schema").String;
-    readonly remoteTransport: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["streamable-http", "sse", "auto"]>>;
-    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 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<{
-        readonly kind: import("effect/Schema").Literal<"header">;
-        readonly headerName: import("effect/Schema").String;
-        readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
-    }>, import("effect/Schema").Struct<{
-        readonly kind: import("effect/Schema").Literal<"oauth2">;
-    }>]>>;
-}>, import("effect/Schema").Struct<{
-    readonly transport: import("effect/Schema").Literal<"stdio">;
-    readonly name: import("effect/Schema").String;
-    readonly command: import("effect/Schema").String;
-    readonly args: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
-    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>;
-    readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
-}>]>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
-    readonly slug: import("effect/Schema").String;
-}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/sdk").IntegrationAlreadyExistsError | typeof import("@executor-js/sdk").InternalError | typeof import("../sdk").McpConnectionError | typeof import("../sdk").McpToolDiscoveryError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"removeServer", "DELETE", "/mcp/servers/:slug", 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<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
-    readonly removed: import("effect/Schema").Boolean;
-}>>, 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<"getServer", "GET", "/mcp/servers/:slug", 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").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
-    readonly slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
-    readonly description: import("effect/Schema").String;
-    readonly kind: import("effect/Schema").String;
-    readonly canRemove: import("effect/Schema").Boolean;
-    readonly canRefresh: import("effect/Schema").Boolean;
-    readonly config: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
-        readonly transport: import("effect/Schema").Literal<"remote">;
-        readonly endpoint: import("effect/Schema").String;
-        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 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>;
-        }>, import("effect/Schema").Struct<{
-            readonly kind: import("effect/Schema").Literal<"oauth2">;
-        }>]>;
-    }>, import("effect/Schema").Struct<{
-        readonly transport: import("effect/Schema").Literal<"stdio">;
-        readonly command: import("effect/Schema").String;
-        readonly args: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
-        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<"configureServer", "POST", "/mcp/servers/:slug/config", 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 config: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
-        readonly transport: import("effect/Schema").Literal<"remote">;
-        readonly endpoint: import("effect/Schema").String;
-        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 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>;
-        }>, import("effect/Schema").Struct<{
-            readonly kind: import("effect/Schema").Literal<"oauth2">;
-        }>]>;
-    }>, import("effect/Schema").Struct<{
-        readonly transport: import("effect/Schema").Literal<"stdio">;
-        readonly command: import("effect/Schema").String;
-        readonly args: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
-        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").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
-    readonly config: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
-        readonly transport: import("effect/Schema").Literal<"remote">;
-        readonly endpoint: import("effect/Schema").String;
-        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 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>;
-        }>, import("effect/Schema").Struct<{
-            readonly kind: import("effect/Schema").Literal<"oauth2">;
-        }>]>;
-    }>, import("effect/Schema").Struct<{
-        readonly transport: import("effect/Schema").Literal<"stdio">;
-        readonly command: import("effect/Schema").String;
-        readonly args: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
-        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>, false>>;

package/dist/react/index.d.ts

@@ -1,4 +0,0 @@
-export { mcpIntegrationPlugin, createMcpIntegrationPlugin } from "./source-plugin";
-export type { McpIntegrationPluginOptions } from "./source-plugin";
-export { McpClient } from "./client";
-export { probeMcpEndpoint, addMcpServer, removeMcpServer, configureMcpServer, mcpServerAtom, } from "./atoms";

package/dist/react/plugin-client.d.ts

@@ -1,9 +0,0 @@
-export interface McpClientConfig {
-    /**
-     * Mirrors `dangerouslyAllowStdioMCP` on the server-side plugin. When
-     * false, the AddMcpSource UI hides the stdio tab and stdio presets.
-     * Defaults to false — same default as the server flag.
-     */
-    readonly allowStdio?: boolean;
-}
-export default function createMcpClientPlugin(config?: McpClientConfig): import("@executor-js/sdk/client").ClientPluginSpec<"mcp">;

package/dist/react/source-plugin.d.ts

@@ -1,14 +0,0 @@
-import type { IntegrationPlugin } from "@executor-js/sdk/client";
-export interface McpIntegrationPluginOptions {
-    /**
-     * Enable the stdio transport in the add-source UI (tab + presets).
-     *
-     * Off by default — stdio is a high-risk transport on any server deployment
-     * (see `dangerouslyAllowStdioMCP` on the server-side plugin). Only enable in
-     * trusted local contexts where the server has the matching flag set.
-     */
-    readonly allowStdio?: boolean;
-}
-export declare const createMcpIntegrationPlugin: (options?: McpIntegrationPluginOptions) => IntegrationPlugin;
-/** @deprecated Use `createMcpIntegrationPlugin({ allowStdio })` instead. */
-export declare const mcpIntegrationPlugin: IntegrationPlugin;

package/dist/sdk/connection.d.ts

@@ -1,19 +0,0 @@
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { Effect } from "effect";
-import type { McpRemoteIntegrationConfig, McpStdioIntegrationConfig } from "./types";
-import { McpConnectionError } from "./errors";
-export type McpConnection = {
-    readonly client: Client;
-    readonly close: () => Promise<void>;
-};
-export type McpConnector = Effect.Effect<McpConnection, McpConnectionError>;
-export type RemoteConnectorInput = Omit<McpRemoteIntegrationConfig, "auth" | "remoteTransport" | "headers" | "queryParams"> & {
-    readonly remoteTransport?: McpRemoteIntegrationConfig["remoteTransport"];
-    readonly headers?: Record<string, string>;
-    readonly queryParams?: Record<string, string>;
-    readonly authProvider?: OAuthClientProvider;
-};
-export type StdioConnectorInput = McpStdioIntegrationConfig;
-export type ConnectorInput = RemoteConnectorInput | StdioConnectorInput;
-export declare const createMcpConnector: (input: ConnectorInput) => McpConnector;

package/dist/sdk/describe-auth-methods.test.d.ts

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

package/dist/sdk/discover.d.ts

@@ -1,9 +0,0 @@
-import { Effect } from "effect";
-import type { McpConnector } from "./connection";
-import { McpToolDiscoveryError } from "./errors";
-import { type McpToolManifest } from "./manifest";
-/**
- * Connect to an MCP server and discover all available tools.
- * Returns the parsed manifest containing server metadata and tool entries.
- */
-export declare const discoverTools: (connector: McpConnector) => Effect.Effect<McpToolManifest, McpToolDiscoveryError>;

package/dist/sdk/elicitation.test.d.ts

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

package/dist/sdk/errors.d.ts

@@ -1,25 +0,0 @@
-import { Schema } from "effect";
-declare const McpConnectionError_base: Schema.Class<McpConnectionError, Schema.TaggedStruct<"McpConnectionError", {
-    readonly transport: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class McpConnectionError extends McpConnectionError_base {
-}
-declare const McpToolDiscoveryError_base: Schema.Class<McpToolDiscoveryError, Schema.TaggedStruct<"McpToolDiscoveryError", {
-    readonly stage: Schema.Literals<readonly ["connect", "list_tools"]>;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class McpToolDiscoveryError extends McpToolDiscoveryError_base {
-}
-declare const McpInvocationError_base: Schema.Class<McpInvocationError, Schema.TaggedStruct<"McpInvocationError", {
-    readonly toolName: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class McpInvocationError extends McpInvocationError_base {
-}
-declare const McpOAuthError_base: Schema.Class<McpOAuthError, Schema.TaggedStruct<"McpOAuthError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class McpOAuthError extends McpOAuthError_base {
-}
-export {};

package/dist/sdk/index.d.ts

@@ -1,4 +0,0 @@
-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 { McpConnectionError, McpToolDiscoveryError, McpInvocationError, McpOAuthError, } from "./errors";
-export { deriveMcpNamespace, joinToolPath, extractManifestFromListToolsResult } from "./manifest";

package/dist/sdk/invoke.d.ts

@@ -1,15 +0,0 @@
-import { Effect } from "effect";
-import { type Elicit } from "@executor-js/sdk";
-import { McpConnectionError, McpInvocationError } from "./errors";
-import type { McpConnector } from "./connection";
-export interface InvokeMcpToolInput {
-    readonly toolId: string;
-    /** The real MCP tool name advertised by the server. */
-    readonly toolName: string;
-    readonly args: unknown;
-    readonly transport: string;
-    /** Dials a fresh connection. The connection is closed after the call. */
-    readonly connector: McpConnector;
-    readonly elicit: Elicit;
-}
-export declare const invokeMcpTool: (input: InvokeMcpToolInput) => Effect.Effect<unknown, McpConnectionError | McpInvocationError>;

package/dist/sdk/manifest.d.ts

@@ -1,27 +0,0 @@
-import { McpToolAnnotations } from "./types";
-export interface McpToolManifestEntry {
-    readonly toolId: string;
-    readonly toolName: string;
-    readonly description: string | null;
-    readonly inputSchema?: unknown;
-    readonly outputSchema?: unknown;
-    readonly annotations?: McpToolAnnotations;
-}
-export interface McpServerMetadata {
-    readonly name: string | null;
-    readonly version: string | null;
-}
-export interface McpToolManifest {
-    readonly server: McpServerMetadata | null;
-    readonly tools: readonly McpToolManifestEntry[];
-}
-export declare const isListToolsResult: (value: unknown) => boolean;
-export declare const joinToolPath: (namespace: string | undefined, toolId: string) => string;
-export declare const extractManifestFromListToolsResult: (listToolsResult: unknown, metadata?: {
-    serverInfo?: unknown;
-}) => McpToolManifest;
-export declare const deriveMcpNamespace: (input: {
-    name?: string | null;
-    endpoint?: string | null;
-    command?: string | null;
-}) => string;

package/dist/sdk/owner-isolation.test.d.ts

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

package/dist/sdk/plugin.d.ts

@@ -1,151 +0,0 @@
-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";
-import { McpConnectionError, McpToolDiscoveryError } from "./errors";
-import { type McpShapeProbeResult } from "./probe-shape";
-import { type McpIntegrationConfig as McpIntegrationConfigType } from "./types";
-declare const McpRemoteServerInputSchema: Schema.Struct<{
-    readonly transport: Schema.optional<Schema.Literal<"remote">>;
-    readonly name: Schema.String;
-    readonly endpoint: Schema.String;
-    readonly remoteTransport: Schema.optional<Schema.Literals<readonly ["streamable-http", "sse", "auto"]>>;
-    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. */
-    readonly auth: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"none">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"header">;
-        readonly headerName: Schema.String;
-        readonly prefix: Schema.optional<Schema.String>;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"oauth2">;
-    }>]>>;
-}>;
-declare const McpStdioServerInputSchema: Schema.Struct<{
-    readonly transport: Schema.Literal<"stdio">;
-    readonly name: Schema.String;
-    readonly command: Schema.String;
-    readonly args: Schema.optional<Schema.$Array<Schema.String>>;
-    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
-    readonly cwd: Schema.optional<Schema.String>;
-    readonly slug: Schema.optional<Schema.String>;
-}>;
-declare const McpAddServerInputSchema: Schema.Union<readonly [Schema.Struct<{
-    readonly transport: Schema.optional<Schema.Literal<"remote">>;
-    readonly name: Schema.String;
-    readonly endpoint: Schema.String;
-    readonly remoteTransport: Schema.optional<Schema.Literals<readonly ["streamable-http", "sse", "auto"]>>;
-    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. */
-    readonly auth: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"none">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"header">;
-        readonly headerName: Schema.String;
-        readonly prefix: Schema.optional<Schema.String>;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"oauth2">;
-    }>]>>;
-}>, Schema.Struct<{
-    readonly transport: Schema.Literal<"stdio">;
-    readonly name: Schema.String;
-    readonly command: Schema.String;
-    readonly args: Schema.optional<Schema.$Array<Schema.String>>;
-    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
-    readonly cwd: Schema.optional<Schema.String>;
-    readonly slug: Schema.optional<Schema.String>;
-}>]>;
-declare const McpProbeEndpointInputSchema: Schema.Struct<{
-    readonly endpoint: Schema.String;
-    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
-    readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
-}>;
-declare const McpProbeEndpointOutputSchema: Schema.Struct<{
-    readonly connected: Schema.Boolean;
-    readonly requiresAuthentication: Schema.Boolean;
-    readonly requiresOAuth: Schema.Boolean;
-    readonly supportsDynamicRegistration: Schema.Boolean;
-    readonly name: Schema.String;
-    readonly slug: Schema.String;
-    readonly toolCount: Schema.NullOr<Schema.Number>;
-    readonly serverName: Schema.NullOr<Schema.String>;
-}>;
-export type McpRemoteServerInput = typeof McpRemoteServerInputSchema.Type;
-export type McpStdioServerInput = typeof McpStdioServerInputSchema.Type;
-export type McpServerInput = typeof McpAddServerInputSchema.Type;
-export type McpProbeResult = typeof McpProbeEndpointOutputSchema.Type;
-export type McpProbeEndpointInput = typeof McpProbeEndpointInputSchema.Type;
-/** Translate a non-MCP probe outcome into a message a user can act on.
- *  Exported for tests. */
-export declare const userFacingProbeMessage: (shape: Extract<McpShapeProbeResult, {
-    kind: "not-mcp";
-} | {
-    kind: "unreachable";
-}>) => string;
-export declare const describeMcpAuthMethods: (record: IntegrationRecord) => readonly AuthMethodDescriptor[];
-export declare const describeMcpIntegrationDisplay: (record: IntegrationRecord) => {
-    readonly url?: string;
-};
-export interface McpPluginOptions {
-    /**
-     * Allow configuring stdio-transport MCP servers. Off by default.
-     *
-     * Stdio servers spawn a local subprocess that inherits the parent
-     * `process.env`. Only enable for trusted single-user contexts.
-     */
-    readonly dangerouslyAllowStdioMCP?: boolean;
-    readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient>;
-}
-export declare const mcpPlugin: import("@executor-js/sdk").ConfiguredPlugin<"mcp", {
-    probeEndpoint: (input: string | McpProbeEndpointInput) => Effect.Effect<{
-        connected: true;
-        requiresAuthentication: false;
-        requiresOAuth: false;
-        supportsDynamicRegistration: false;
-        name: string;
-        slug: string;
-        toolCount: number;
-        serverName: string | null;
-    } | {
-        connected: false;
-        requiresAuthentication: true;
-        requiresOAuth: true;
-        supportsDynamicRegistration: boolean;
-        name: string;
-        slug: string;
-        toolCount: null;
-        serverName: null;
-    } | {
-        connected: false;
-        requiresAuthentication: true;
-        requiresOAuth: false;
-        supportsDynamicRegistration: false;
-        name: string;
-        slug: string;
-        toolCount: null;
-        serverName: null;
-    }, McpConnectionError, never>;
-    addServer: (input: McpServerInput) => Effect.Effect<{
-        slug: string;
-    }, StorageFailure | IntegrationAlreadyExistsError, never>;
-    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>;
-}, {}, McpPluginOptions, undefined, Layer.Layer<unknown, never, never>, import("effect/unstable/httpapi/HttpApiGroup").Any>;
-export type McpExtensionFailure = McpConnectionError | McpToolDiscoveryError | StorageFailure;
-export interface McpPluginExtension {
-    readonly probeEndpoint: (input: string | McpProbeEndpointInput) => Effect.Effect<McpProbeResult, McpExtensionFailure>;
-    readonly addServer: (input: McpServerInput) => Effect.Effect<{
-        readonly slug: string;
-    }, McpExtensionFailure | IntegrationAlreadyExistsError>;
-    readonly removeServer: (slug: string) => Effect.Effect<void, McpExtensionFailure>;
-    readonly getServer: (slug: string) => Effect.Effect<(Integration & {
-        readonly config: IntegrationConfig;
-    }) | null, McpExtensionFailure>;
-    readonly configureServer: (slug: string, config: McpIntegrationConfigType) => Effect.Effect<void, McpExtensionFailure>;
-}
-export {};

package/dist/sdk/plugin.test.d.ts

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

package/dist/sdk/presets.d.ts

@@ -1,23 +0,0 @@
-export interface McpRemotePreset {
-    readonly id: string;
-    readonly name: string;
-    readonly summary: string;
-    readonly url: string;
-    readonly endpoint: string;
-    readonly icon?: string;
-    readonly featured?: boolean;
-    readonly transport?: undefined;
-}
-export interface McpStdioPreset {
-    readonly id: string;
-    readonly name: string;
-    readonly summary: string;
-    readonly icon?: string;
-    readonly featured?: boolean;
-    readonly transport: "stdio";
-    readonly command: string;
-    readonly args?: readonly string[];
-    readonly env?: Readonly<Record<string, string>>;
-}
-export type McpPreset = McpRemotePreset | McpStdioPreset;
-export declare const mcpPresets: readonly McpPreset[];

package/dist/sdk/probe-shape-real-servers.live.test.d.ts

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

package/dist/sdk/probe-shape.d.ts

@@ -1,53 +0,0 @@
-import { Effect, Layer } from "effect";
-import { HttpClient } from "effect/unstable/http";
-/** Why the probe rejected an endpoint as not-MCP.
- *
- *  - `auth-required` — server returned 401. We don't know for sure it's
- *    an MCP server (no spec-compliant Bearer challenge or the body
- *    isn't JSON-RPC), but the right next step for the user is the same
- *    either way: provide credentials and retry. This is what
- *    misclassifies real MCP servers like cubic.dev (no
- *    resource_metadata) or ref.tools (no WWW-Authenticate at all)
- *    without the URL-token fallback at the detect layer.
- *  - `wrong-shape` — endpoint responded but with a body or status that
- *    doesn't match any MCP shape (200 HTML, 400 GraphQL, 404 from a
- *    static host, etc.). User action: this URL probably isn't MCP. */
-export type McpProbeRejectCategory = "auth-required" | "wrong-shape";
-export type McpShapeProbeResult = 
-/** Server answered initialize successfully — either a 2xx with a
- *  JSON-RPC payload, or a 401 + WWW-Authenticate: Bearer (RFC 6750
- *  challenge) that the MCP auth spec requires. */
-{
-    readonly kind: "mcp";
-    readonly requiresAuth: boolean;
-}
-/** Endpoint is reachable but the response does not look like MCP. */
- | {
-    readonly kind: "not-mcp";
-    readonly reason: string;
-    readonly category: McpProbeRejectCategory;
-}
-/** Transport-level failure (DNS, TLS, timeout, abort, ...). */
- | {
-    readonly kind: "unreachable";
-    readonly reason: string;
-};
-export interface ProbeOptions {
-    /** Abort the request after this many ms. Default 8000. */
-    readonly timeoutMs?: number;
-    readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient>;
-    readonly headers?: Record<string, string>;
-    readonly queryParams?: Record<string, string>;
-}
-/**
- * Hit `endpoint` with a JSON-RPC `initialize` POST and classify the
- * response according to the MCP authorization spec.
- *
- * Returns `{kind: "mcp"}` only when the endpoint either:
- *   - answers with 2xx (unauth-OK MCP server), or
- *   - responds 401 with a `Bearer` WWW-Authenticate challenge.
- *
- * Anything else (400, 404, 200-with-HTML, 200-with-GraphQL-errors, ...)
- * is classified `not-mcp`. Transport errors surface as `unreachable`.
- */
-export declare const probeMcpEndpointShape: (endpoint: string, options?: ProbeOptions) => Effect.Effect<McpShapeProbeResult>;

package/dist/sdk/probe-shape.test.d.ts

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

package/dist/sdk/stdio-connector.d.ts

@@ -1,8 +0,0 @@
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-export type StdioTransportConfig = {
-    readonly command: string;
-    readonly args?: ReadonlyArray<string>;
-    readonly env?: Record<string, string>;
-    readonly cwd?: string;
-};
-export declare const createStdioTransport: (config: StdioTransportConfig) => StdioClientTransport;

package/dist/sdk/testing-fixtures.test.d.ts

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