@executor-js/plugin-mcp 0.0.1 → 0.1.0

package/dist/react/client.d.ts

@@ -1,3 +1,104 @@
-import { AtomHttpApi } from "@effect-atom/atom-react";
-import { McpGroup } from "../api/group";
-export declare const McpClient: AtomHttpApi.AtomHttpApiClient<"McpClient", "McpClient", typeof McpGroup | typeof import("@executor/api").ToolsApi | typeof import("@executor/api").SourcesApi | typeof import("@executor/api").SecretsApi | typeof import("@executor/api").ExecutionsApi | typeof import("@executor/api").ScopeApi, import("@effect/platform/HttpApiError").HttpApiDecodeError, never>;
+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", "/scopes/:scopeId/mcp/probe", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+}>>, 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").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: 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").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: 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 connected: import("effect/Schema").Boolean;
+    readonly requiresOAuth: import("effect/Schema").Boolean;
+    readonly name: import("effect/Schema").String;
+    readonly namespace: 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/api").InternalError | typeof import("../sdk/errors").McpConnectionError | typeof import("../sdk/errors").McpToolDiscoveryError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"addSource", "POST", "/scopes/:scopeId/mcp/sources", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+}>>, 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").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 namespace: 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").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: 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").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: import("effect/Schema").optional<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 secretId: 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">;
+        readonly connectionId: import("effect/Schema").String;
+        readonly clientIdSecretId: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly clientSecretSecretId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+    }>]>>;
+}>, 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 namespace: 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 toolCount: import("effect/Schema").Number;
+    readonly namespace: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof import("../sdk/errors").McpConnectionError | typeof import("../sdk/errors").McpToolDiscoveryError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"removeSource", "POST", "/scopes/:scopeId/mcp/sources/remove", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly namespace: import("effect/Schema").String;
+}>>, 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/api").InternalError | typeof import("../sdk/errors").McpConnectionError | typeof import("../sdk/errors").McpToolDiscoveryError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"refreshSource", "POST", "/scopes/:scopeId/mcp/sources/refresh", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly namespace: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly toolCount: import("effect/Schema").Number;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof import("../sdk/errors").McpConnectionError | typeof import("../sdk/errors").McpToolDiscoveryError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getSource", "GET", "/scopes/:scopeId/mcp/sources/:namespace", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+    namespace: import("effect/Schema").String;
+}>>, 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<typeof import("../sdk/stored-source").McpStoredSourceSchema>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof import("../sdk/errors").McpConnectionError | typeof import("../sdk/errors").McpToolDiscoveryError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"updateSource", "PATCH", "/scopes/:scopeId/mcp/sources/:namespace", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    scopeId: import("effect/Schema").brand<import("effect/Schema").String, "ScopeId">;
+    namespace: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly name: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly endpoint: 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").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: 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").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+        readonly secretId: import("effect/Schema").String;
+        readonly prefix: import("effect/Schema").optional<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 secretId: 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">;
+        readonly connectionId: import("effect/Schema").String;
+        readonly clientIdSecretId: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly clientSecretSecretId: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+    }>]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly updated: import("effect/Schema").Boolean;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof import("../sdk/errors").McpConnectionError | typeof import("../sdk/errors").McpToolDiscoveryError>, never, never>, false>>;

package/dist/react/index.d.ts

@@ -1,3 +1,4 @@
-export { mcpSourcePlugin } from "./source-plugin";
+export { mcpSourcePlugin, createMcpSourcePlugin } from "./source-plugin";
+export type { McpSourcePluginOptions } from "./source-plugin";
 export { McpClient } from "./client";
-export { probeMcpEndpoint, addMcpSource, removeMcpSource, refreshMcpSource, startMcpOAuth, completeMcpOAuth, } from "./atoms";
+export { probeMcpEndpoint, addMcpSource, removeMcpSource, refreshMcpSource, } from "./atoms";

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

@@ -0,0 +1,2 @@
+declare const _default: import("@executor-js/sdk/client").ClientPluginSpec<"mcp">;
+export default _default;

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

@@ -1,2 +1,14 @@
-import type { SourcePlugin } from "@executor/react/plugins/source-plugin";
+import type { SourcePlugin } from "@executor-js/sdk/client";
+export interface McpSourcePluginOptions {
+    /**
+     * 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 createMcpSourcePlugin: (options?: McpSourcePluginOptions) => SourcePlugin;
+/** @deprecated Use `createMcpSourcePlugin({ allowStdio })` instead. */
 export declare const mcpSourcePlugin: SourcePlugin;

package/dist/sdk/binding-store.d.ts

@@ -1,28 +1,86 @@
 import { Effect } from "effect";
-import { type Kv, type ToolId } from "@executor-js/sdk";
-import { McpToolBinding } from "./types";
-import type { McpStoredSourceData } from "./types";
-import { McpOAuthSession } from "./oauth";
-import { McpStoredSourceSchema } from "./stored-source";
-export declare const MCP_OAUTH_SESSION_TTL_MS: number;
-export type McpStoredSource = McpStoredSourceSchema;
+import { type StorageDeps, type StorageFailure } from "@executor-js/sdk/core";
+import { McpToolBinding, McpStoredSourceData } from "./types";
+export declare const mcpSchema: {
+    readonly mcp_source: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly config: {
+                readonly type: "json";
+                readonly required: true;
+            };
+            readonly created_at: {
+                readonly type: "date";
+                readonly required: true;
+            };
+        };
+    };
+    readonly mcp_binding: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly binding: {
+                readonly type: "json";
+                readonly required: true;
+            };
+            readonly created_at: {
+                readonly type: "date";
+                readonly required: true;
+            };
+        };
+    };
+};
+export type McpSchema = typeof mcpSchema;
+export interface McpStoredSource {
+    readonly namespace: string;
+    /** Executor scope id this source row lives in. Writes stamp this on
+     *  `scope_id`; reads return whichever scope's row the adapter's
+     *  fall-through walk surfaced first. */
+    readonly scope: string;
+    readonly name: string;
+    readonly config: McpStoredSourceData;
+}
 export interface McpBindingStore {
-    readonly get: (toolId: ToolId) => Effect.Effect<{
-        binding: McpToolBinding;
-        namespace: string;
-    } | null>;
-    readonly put: (toolId: ToolId, namespace: string, binding: McpToolBinding) => Effect.Effect<void>;
-    readonly remove: (toolId: ToolId) => Effect.Effect<void>;
-    readonly listByNamespace: (namespace: string) => Effect.Effect<readonly ToolId[]>;
-    readonly removeByNamespace: (namespace: string) => Effect.Effect<readonly ToolId[]>;
-    readonly putSource: (source: McpStoredSource) => Effect.Effect<void>;
-    readonly removeSource: (namespace: string) => Effect.Effect<void>;
-    readonly listSources: () => Effect.Effect<readonly McpStoredSource[]>;
-    readonly getSource: (namespace: string) => Effect.Effect<McpStoredSource | null>;
-    readonly getSourceConfig: (namespace: string) => Effect.Effect<McpStoredSourceData | null>;
-    readonly putOAuthSession: (sessionId: string, session: McpOAuthSession) => Effect.Effect<void>;
-    readonly getOAuthSession: (sessionId: string) => Effect.Effect<McpOAuthSession | null>;
-    readonly deleteOAuthSession: (sessionId: string) => Effect.Effect<void>;
+    readonly listBindingsBySource: (namespace: string, scope: string) => Effect.Effect<ReadonlyArray<{
+        readonly toolId: string;
+        readonly binding: McpToolBinding;
+    }>, StorageFailure>;
+    readonly getBinding: (toolId: string, scope: string) => Effect.Effect<{
+        readonly binding: McpToolBinding;
+        readonly namespace: string;
+    } | null, StorageFailure>;
+    readonly putBindings: (namespace: string, scope: string, entries: ReadonlyArray<{
+        readonly toolId: string;
+        readonly binding: McpToolBinding;
+    }>) => Effect.Effect<void, StorageFailure>;
+    readonly removeBindingsByNamespace: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
+    readonly getSource: (namespace: string, scope: string) => Effect.Effect<McpStoredSource | null, StorageFailure>;
+    readonly getSourceConfig: (namespace: string, scope: string) => Effect.Effect<McpStoredSourceData | null, StorageFailure>;
+    readonly putSource: (source: McpStoredSource) => Effect.Effect<void, StorageFailure>;
+    readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
 }
-export declare const makeKvBindingStore: (kv: Kv, namespace: string) => McpBindingStore;
-export declare const makeInMemoryBindingStore: () => McpBindingStore;
+export declare const makeMcpStore: ({ adapter: db, }: StorageDeps<McpSchema>) => McpBindingStore;

package/dist/sdk/connection-pool.test.d.ts

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

package/dist/sdk/connection.d.ts

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

package/dist/sdk/cross-user-isolation.test.d.ts

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

package/dist/sdk/errors.d.ts

@@ -1,33 +1,25 @@
 import { Schema } from "effect";
-declare const McpConnectionError_base: Schema.TaggedErrorClass<McpConnectionError, "McpConnectionError", {
-    readonly _tag: Schema.tag<"McpConnectionError">;
-} & {
-    transport: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+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.TaggedErrorClass<McpToolDiscoveryError, "McpToolDiscoveryError", {
-    readonly _tag: Schema.tag<"McpToolDiscoveryError">;
-} & {
-    stage: Schema.Literal<["connect", "list_tools"]>;
-    message: typeof Schema.String;
-}>;
+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.TaggedErrorClass<McpInvocationError, "McpInvocationError", {
-    readonly _tag: Schema.tag<"McpInvocationError">;
-} & {
-    toolName: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+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.TaggedErrorClass<McpOAuthError, "McpOAuthError", {
-    readonly _tag: Schema.tag<"McpOAuthError">;
-} & {
-    message: typeof Schema.String;
-}>;
+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,3 +1,3 @@
-export { mcpPlugin, type McpPluginExtension } from "./plugin";
-export { makeKvBindingStore, type McpBindingStore, type McpStoredSource } from "./binding-store";
-export { withConfigFile } from "./config-file-store";
+export { mcpPlugin, type McpPluginExtension, type McpPluginOptions, type McpSourceConfig, type McpRemoteSourceConfig, type McpStdioSourceConfig, type McpProbeResult, type McpUpdateSourceInput, } from "./plugin";
+export { makeMcpStore, mcpSchema, type McpBindingStore, type McpSchema, type McpStoredSource, } from "./binding-store";
+export { McpConnectionAuth } from "./types";

package/dist/sdk/invoke.d.ts

@@ -1,19 +1,20 @@
-import { Effect, type ScopedCache } from "effect";
-import { type ToolInvoker, type ScopeId, type SecretId } from "@executor-js/sdk";
-import type { McpBindingStore } from "./binding-store";
-import { McpConnectionError } from "./errors";
-import { type McpConnection } from "./connection";
-type Secrets = {
-    readonly resolve: (secretId: SecretId, scopeId: ScopeId) => Effect.Effect<string, unknown>;
-};
-export declare const makeMcpInvoker: (opts: {
-    readonly bindingStore: McpBindingStore;
-    readonly secrets: Secrets;
-    readonly scopeId: ScopeId;
+import { Effect, ScopedCache } from "effect";
+import { type Elicit } from "@executor-js/sdk/core";
+import { McpConnectionError, McpInvocationError } from "./errors";
+import type { McpConnection } from "./connection";
+import type { McpStoredSourceData } from "./types";
+export interface InvokeMcpToolInput {
+    readonly toolId: string;
+    readonly toolName: string;
+    readonly args: unknown;
+    readonly sourceData: McpStoredSourceData;
+    /** Innermost executor scope id at invoke time. Mixed into the
+     *  connection cache key so per-user OAuth/secret resolution doesn't
+     *  collapse multiple users onto one shared connection. */
+    readonly invokerScope: string;
+    readonly resolveConnector: () => Effect.Effect<McpConnection, McpConnectionError>;
     readonly connectionCache: ScopedCache.ScopedCache<string, McpConnection, McpConnectionError>;
-    /** Shared map between cache lookup and invoker — set connector before cache.get */
     readonly pendingConnectors: Map<string, Effect.Effect<McpConnection, McpConnectionError>>;
-}) => ToolInvoker & {
-    readonly closeConnections: () => Effect.Effect<void>;
-};
-export {};
+    readonly elicit: Elicit;
+}
+export declare const invokeMcpTool: (input: InvokeMcpToolInput) => Effect.Effect<unknown, McpConnectionError | McpInvocationError>;

package/dist/sdk/manifest.d.ts

@@ -1,9 +1,11 @@
+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;
@@ -13,6 +15,7 @@ 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;

package/dist/sdk/per-user-auth-isolation.test.d.ts

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