@executor-js/plugin-mcp 0.0.1-beta.6 → 0.0.2

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

@@ -1,26 +1,82 @@
 import { Effect } from "effect";
-import { type Kv, type ToolId } from "@executor-js/sdk";
-import { McpToolBinding } from "./types";
-import type { McpStoredSourceData } from "./types";
+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;
-        sourceData: McpStoredSourceData;
-    } | null>;
-    readonly put: (toolId: ToolId, namespace: string, binding: McpToolBinding, sourceData: McpStoredSourceData) => 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 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

@@ -13,6 +13,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 {};

package/dist/sdk/plugin.d.ts

@@ -1,18 +1,29 @@
 import { Effect } from "effect";
-import { type ExecutorPlugin } from "@executor-js/sdk";
-import { type McpConnectionAuth } from "./types";
+import { type StorageFailure } from "@executor-js/sdk/core";
 import { type McpBindingStore, type McpStoredSource } from "./binding-store";
-export interface McpRemoteSourceConfig {
+import { McpConnectionError, McpToolDiscoveryError } from "./errors";
+import { type McpConnectionAuth, type SecretBackedValue } from "./types";
+import { type ConfigFileSink } from "@executor-js/config";
+/**
+ * Executor scope id that owns a newly-added MCP source row. Must be one
+ * of the executor's configured scopes. Admins adding a shared server at
+ * org scope pin here; per-user stdio sources can pin at the inner
+ * scope.
+ */
+type McpSourceScopeField = {
+    readonly scope: string;
+};
+export interface McpRemoteSourceConfig extends McpSourceScopeField {
     readonly transport: "remote";
     readonly name: string;
     readonly endpoint: string;
     readonly remoteTransport?: "streamable-http" | "sse" | "auto";
-    readonly queryParams?: Record<string, string>;
-    readonly headers?: Record<string, string>;
+    readonly queryParams?: Record<string, SecretBackedValue>;
+    readonly headers?: Record<string, SecretBackedValue>;
     readonly namespace?: string;
     readonly auth?: McpConnectionAuth;
 }
-export interface McpStdioSourceConfig {
+export interface McpStdioSourceConfig extends McpSourceScopeField {
     readonly transport: "stdio";
     readonly name: string;
     readonly command: string;
@@ -22,27 +33,6 @@ export interface McpStdioSourceConfig {
     readonly namespace?: string;
 }
 export type McpSourceConfig = McpRemoteSourceConfig | McpStdioSourceConfig;
-export interface McpOAuthStartInput {
-    readonly endpoint: string;
-    readonly redirectUrl: string;
-    readonly queryParams?: Record<string, string> | null;
-}
-export interface McpOAuthStartResponse {
-    readonly sessionId: string;
-    readonly authorizationUrl: string;
-}
-export interface McpOAuthCompleteInput {
-    readonly state: string;
-    readonly code?: string;
-    readonly error?: string;
-}
-export interface McpOAuthCompleteResponse {
-    readonly accessTokenSecretId: string;
-    readonly refreshTokenSecretId: string | null;
-    readonly tokenType: string;
-    readonly expiresAt: number | null;
-    readonly scope: string | null;
-}
 export interface McpProbeResult {
     readonly connected: boolean;
     readonly requiresOAuth: boolean;
@@ -52,28 +42,104 @@ export interface McpProbeResult {
     readonly serverName: string | null;
 }
 export interface McpUpdateSourceInput {
+    readonly name?: string;
     readonly endpoint?: string;
-    readonly headers?: Record<string, string>;
-    readonly queryParams?: Record<string, string>;
+    readonly headers?: Record<string, SecretBackedValue>;
+    readonly queryParams?: Record<string, SecretBackedValue>;
     readonly auth?: McpConnectionAuth;
 }
+export interface McpProbeEndpointInput {
+    readonly endpoint: string;
+    readonly headers?: Record<string, SecretBackedValue>;
+    readonly queryParams?: Record<string, SecretBackedValue>;
+}
+export interface McpPluginOptions {
+    /**
+     * Allow configuring stdio-transport MCP sources. Off by default.
+     *
+     * Stdio sources spawn a local subprocess that inherits the parent
+     * `process.env`. Only enable for trusted single-user contexts.
+     */
+    readonly dangerouslyAllowStdioMCP?: boolean;
+    /** If provided, source add/remove is mirrored to executor.jsonc
+     *  (best-effort — file errors are logged, not raised). */
+    readonly configFile?: ConfigFileSink;
+}
+export declare const mcpPlugin: import("@executor-js/sdk/core").ConfiguredPlugin<"mcp", McpPluginExtension, McpBindingStore, McpPluginOptions, {
+    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;
+            };
+        };
+    };
+}>;
+/**
+ * Errors any MCP extension method may surface. The first four are
+ * plugin-domain tagged errors that flow directly to clients (4xx, each
+ * carrying its own `HttpApiSchema` status). `StorageFailure` covers
+ * raw backend failures (`StorageError`) plus `UniqueViolationError`;
+ * the HTTP edge (`@executor-js/api`'s `withCapture`) translates
+ * `StorageError` to the opaque `InternalError({ traceId })` at Layer
+ * composition. `UniqueViolationError` passes through — plugins can
+ * `Effect.catchTag` it if they want a friendlier user-facing error.
+ */
+export type McpExtensionFailure = McpConnectionError | McpToolDiscoveryError | StorageFailure;
 export interface McpPluginExtension {
-    readonly probeEndpoint: (endpoint: string) => Effect.Effect<McpProbeResult, Error>;
+    readonly probeEndpoint: (input: string | McpProbeEndpointInput) => Effect.Effect<McpProbeResult, McpExtensionFailure>;
     readonly addSource: (config: McpSourceConfig) => Effect.Effect<{
         readonly toolCount: number;
         readonly namespace: string;
-    }, Error>;
-    readonly removeSource: (namespace: string) => Effect.Effect<void>;
-    readonly refreshSource: (namespace: string) => Effect.Effect<{
+    }, McpExtensionFailure>;
+    readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, McpExtensionFailure>;
+    readonly refreshSource: (namespace: string, scope: string) => Effect.Effect<{
         readonly toolCount: number;
-    }, Error>;
-    readonly startOAuth: (input: McpOAuthStartInput) => Effect.Effect<McpOAuthStartResponse, Error>;
-    readonly completeOAuth: (input: McpOAuthCompleteInput) => Effect.Effect<McpOAuthCompleteResponse, Error>;
-    /** Fetch the full stored source by namespace (or null if missing) */
-    readonly getSource: (namespace: string) => Effect.Effect<McpStoredSource | null>;
-    /** Update config for an existing remote MCP source */
-    readonly updateSource: (namespace: string, input: McpUpdateSourceInput) => Effect.Effect<void>;
+    }, McpExtensionFailure>;
+    readonly getSource: (namespace: string, scope: string) => Effect.Effect<McpStoredSource | null, McpExtensionFailure>;
+    readonly updateSource: (namespace: string, scope: string, input: McpUpdateSourceInput) => Effect.Effect<void, McpExtensionFailure>;
 }
-export declare const mcpPlugin: (options?: {
-    readonly bindingStore?: McpBindingStore;
-}) => ExecutorPlugin<"mcp", McpPluginExtension>;
+export {};

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

@@ -0,0 +1,39 @@
+import { Effect } from "effect";
+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;
+}
+/** Transport-level failure (DNS, TLS, timeout, abort, ...). */
+ | {
+    readonly kind: "unreachable";
+    readonly reason: string;
+};
+export interface ProbeOptions {
+    /** Injected for tests. Defaults to the global `fetch`. */
+    readonly fetch?: typeof fetch;
+    /** Abort the request after this many ms. Default 8000. */
+    readonly timeoutMs?: number;
+    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

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

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

@@ -0,0 +1,8 @@
+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/stored-source.d.ts

@@ -1,114 +1,40 @@
 import { Schema } from "effect";
-declare const McpStoredSourceSchema_base: Schema.Class<McpStoredSourceSchema, {
-    namespace: typeof Schema.String;
-    name: typeof Schema.String;
-    config: Schema.Union<[Schema.Struct<{
-        transport: Schema.Literal<["remote"]>;
-        endpoint: typeof Schema.String;
-        remoteTransport: Schema.optionalWith<Schema.Literal<["streamable-http", "sse", "auto"]>, {
-            default: () => "auto";
-        }>;
-        queryParams: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-        headers: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-        auth: Schema.Union<[Schema.Struct<{
-            kind: Schema.Literal<["none"]>;
+declare const McpStoredSourceSchema_base: Schema.Class<McpStoredSourceSchema, Schema.Struct<{
+    readonly namespace: Schema.String;
+    readonly name: Schema.String;
+    readonly config: Schema.Union<readonly [Schema.Struct<{
+        readonly transport: Schema.Literal<"remote">;
+        readonly endpoint: Schema.String;
+        readonly remoteTransport: Schema.withConstructorDefault<Schema.optionalKey<Schema.Literals<readonly ["streamable-http", "sse", "auto"]>>>;
+        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+        }>]>>>;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+        }>]>>>;
+        readonly auth: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"none">;
         }>, Schema.Struct<{
-            kind: Schema.Literal<["header"]>;
-            headerName: typeof Schema.String;
-            secretId: typeof Schema.String;
-            prefix: Schema.optional<typeof Schema.String>;
+            readonly kind: Schema.Literal<"header">;
+            readonly headerName: Schema.String;
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
         }>, Schema.Struct<{
-            kind: Schema.Literal<["oauth2"]>;
-            accessTokenSecretId: typeof Schema.String;
-            refreshTokenSecretId: Schema.NullOr<typeof Schema.String>;
-            tokenType: Schema.optionalWith<typeof Schema.String, {
-                default: () => string;
-            }>;
-            expiresAt: Schema.NullOr<typeof Schema.Number>;
-            scope: Schema.NullOr<typeof Schema.String>;
+            readonly kind: Schema.Literal<"oauth2">;
+            readonly connectionId: Schema.String;
+            readonly clientIdSecretId: Schema.optional<Schema.String>;
+            readonly clientSecretSecretId: Schema.optional<Schema.NullOr<Schema.String>>;
         }>]>;
     }>, Schema.Struct<{
-        transport: Schema.Literal<["stdio"]>;
-        command: typeof Schema.String;
-        args: Schema.optional<Schema.Array$<typeof Schema.String>>;
-        env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-        cwd: Schema.optional<typeof Schema.String>;
+        readonly transport: Schema.Literal<"stdio">;
+        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>;
     }>]>;
-}, Schema.Struct.Encoded<{
-    namespace: typeof Schema.String;
-    name: typeof Schema.String;
-    config: Schema.Union<[Schema.Struct<{
-        transport: Schema.Literal<["remote"]>;
-        endpoint: typeof Schema.String;
-        remoteTransport: Schema.optionalWith<Schema.Literal<["streamable-http", "sse", "auto"]>, {
-            default: () => "auto";
-        }>;
-        queryParams: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-        headers: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-        auth: Schema.Union<[Schema.Struct<{
-            kind: Schema.Literal<["none"]>;
-        }>, Schema.Struct<{
-            kind: Schema.Literal<["header"]>;
-            headerName: typeof Schema.String;
-            secretId: typeof Schema.String;
-            prefix: Schema.optional<typeof Schema.String>;
-        }>, Schema.Struct<{
-            kind: Schema.Literal<["oauth2"]>;
-            accessTokenSecretId: typeof Schema.String;
-            refreshTokenSecretId: Schema.NullOr<typeof Schema.String>;
-            tokenType: Schema.optionalWith<typeof Schema.String, {
-                default: () => string;
-            }>;
-            expiresAt: Schema.NullOr<typeof Schema.Number>;
-            scope: Schema.NullOr<typeof Schema.String>;
-        }>]>;
-    }>, Schema.Struct<{
-        transport: Schema.Literal<["stdio"]>;
-        command: typeof Schema.String;
-        args: Schema.optional<Schema.Array$<typeof Schema.String>>;
-        env: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-        cwd: Schema.optional<typeof Schema.String>;
-    }>]>;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly namespace: string;
-} & {
-    readonly config: {
-        readonly endpoint: string;
-        readonly transport: "remote";
-        readonly remoteTransport: "streamable-http" | "sse" | "auto";
-        readonly queryParams?: {
-            readonly [x: string]: string;
-        } | undefined;
-        readonly headers?: {
-            readonly [x: string]: string;
-        } | undefined;
-        readonly auth: {
-            readonly kind: "none";
-        } | {
-            readonly secretId: string;
-            readonly kind: "header";
-            readonly headerName: string;
-            readonly prefix?: string | undefined;
-        } | {
-            readonly kind: "oauth2";
-            readonly scope: string | null;
-            readonly accessTokenSecretId: string;
-            readonly refreshTokenSecretId: string | null;
-            readonly tokenType: string;
-            readonly expiresAt: number | null;
-        };
-    } | {
-        readonly transport: "stdio";
-        readonly command: string;
-        readonly args?: readonly string[] | undefined;
-        readonly env?: {
-            readonly [x: string]: string;
-        } | undefined;
-        readonly cwd?: string | undefined;
-    };
-}, {}, {}>;
+}>, {}>;
 export declare class McpStoredSourceSchema extends McpStoredSourceSchema_base {
 }
 export type McpStoredSourceSchemaType = typeof McpStoredSourceSchema.Type;