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

package/dist/{chunk-NJ4CITCV.js → chunk-X3JTTDWJ.js}

@@ -1,5 +1,5 @@
 // src/sdk/binding-store.ts
-import { Effect, Schema as Schema2 } from "effect";
+import { Effect as Effect2, Schema as Schema5 } from "effect";
 import { makeInMemoryScopedKv, scopeKv } from "@executor-js/sdk";
 
 // src/sdk/types.ts
@@ -58,191 +58,58 @@ var McpToolBinding = class extends Schema.Class("McpToolBinding")({
 }) {
 };
 
-// src/sdk/binding-store.ts
-var StoredBindingEntry = Schema2.Struct({
-  namespace: Schema2.String,
-  binding: McpToolBinding,
-  sourceData: Schema2.Unknown
-});
-var encodeBindingEntry = Schema2.encodeSync(Schema2.parseJson(StoredBindingEntry));
-var decodeBindingEntry = Schema2.decodeUnknownSync(Schema2.parseJson(StoredBindingEntry));
-var makeStore = (bindings, sources) => ({
-  // ---- Bindings ----
-  get: (toolId) => Effect.gen(function* () {
-    const raw = yield* bindings.get(toolId);
-    if (!raw) return null;
-    const entry = decodeBindingEntry(raw);
-    return {
-      binding: entry.binding,
-      sourceData: entry.sourceData
-    };
-  }),
-  put: (toolId, namespace, binding, sourceData) => bindings.set([{ key: toolId, value: encodeBindingEntry({ namespace, binding, sourceData }) }]),
-  remove: (toolId) => bindings.delete([toolId]).pipe(Effect.asVoid),
-  listByNamespace: (namespace) => Effect.gen(function* () {
-    const entries = yield* bindings.list();
-    const ids = [];
-    for (const e of entries) {
-      const entry = decodeBindingEntry(e.value);
-      if (entry.namespace === namespace) ids.push(e.key);
-    }
-    return ids;
-  }),
-  removeByNamespace: (namespace) => Effect.gen(function* () {
-    const entries = yield* bindings.list();
-    const ids = [];
-    for (const e of entries) {
-      const entry = decodeBindingEntry(e.value);
-      if (entry.namespace === namespace) ids.push(e.key);
-    }
-    if (ids.length > 0) yield* bindings.delete(ids);
-    return ids;
-  }),
-  // ---- Sources (meta + config combined) ----
-  putSource: (source) => sources.set([{ key: source.namespace, value: JSON.stringify(source) }]),
-  removeSource: (namespace) => sources.delete([namespace]).pipe(Effect.asVoid),
-  listSources: () => Effect.gen(function* () {
-    const entries = yield* sources.list();
-    return entries.map((e) => JSON.parse(e.value));
-  }),
-  getSource: (namespace) => Effect.gen(function* () {
-    const raw = yield* sources.get(namespace);
-    if (!raw) return null;
-    return JSON.parse(raw);
-  }),
-  getSourceConfig: (namespace) => Effect.gen(function* () {
-    const raw = yield* sources.get(namespace);
-    if (!raw) return null;
-    const source = JSON.parse(raw);
-    return source.config;
-  })
-});
-var makeKvBindingStore = (kv, namespace) => makeStore(scopeKv(kv, `${namespace}.bindings`), scopeKv(kv, `${namespace}.sources`));
-var makeInMemoryBindingStore = () => makeStore(makeInMemoryScopedKv(), makeInMemoryScopedKv());
-
-// src/sdk/plugin.ts
-import { Effect as Effect6, Exit, ScopedCache, Duration, Scope } from "effect";
+// src/sdk/oauth.ts
 import {
-  Source,
-  SourceDetectionResult,
-  definePlugin,
-  ToolId,
-  SecretId
-} from "@executor-js/sdk";
-
-// src/sdk/connection.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { Effect as Effect2 } from "effect";
+  auth
+} from "@modelcontextprotocol/sdk/client/auth.js";
+import { Effect, Schema as Schema3 } from "effect";
 
 // src/sdk/errors.ts
-import { Schema as Schema3 } from "effect";
-var McpConnectionError = class extends Schema3.TaggedError()(
+import { Schema as Schema2 } from "effect";
+var McpConnectionError = class extends Schema2.TaggedError()(
   "McpConnectionError",
   {
-    transport: Schema3.String,
-    message: Schema3.String
+    transport: Schema2.String,
+    message: Schema2.String
   }
 ) {
 };
-var McpToolDiscoveryError = class extends Schema3.TaggedError()(
+var McpToolDiscoveryError = class extends Schema2.TaggedError()(
   "McpToolDiscoveryError",
   {
-    stage: Schema3.Literal("connect", "list_tools"),
-    message: Schema3.String
+    stage: Schema2.Literal("connect", "list_tools"),
+    message: Schema2.String
   }
 ) {
 };
-var McpInvocationError = class extends Schema3.TaggedError()(
+var McpInvocationError = class extends Schema2.TaggedError()(
   "McpInvocationError",
   {
-    toolName: Schema3.String,
-    message: Schema3.String
+    toolName: Schema2.String,
+    message: Schema2.String
   }
 ) {
 };
-var McpOAuthError = class extends Schema3.TaggedError()("McpOAuthError", {
-  message: Schema3.String
+var McpOAuthError = class extends Schema2.TaggedError()("McpOAuthError", {
+  message: Schema2.String
 }) {
 };
 
-// src/sdk/connection.ts
-var buildEndpointUrl = (endpoint, queryParams) => {
-  const url = new URL(endpoint);
-  for (const [key, value] of Object.entries(queryParams)) {
-    url.searchParams.set(key, value);
-  }
-  return url;
-};
-var createClient = () => new Client(
-  { name: "executor-mcp", version: "0.1.0" },
-  { capabilities: { elicitation: { form: {}, url: {} } } }
-);
-var connectionFromClient = (client) => ({
-  client,
-  close: () => client.close()
+// src/sdk/oauth.ts
+var JsonObject = Schema3.Record({ key: Schema3.String, value: Schema3.Unknown });
+var McpOAuthDiscoveryState = Schema3.Struct({
+  resourceMetadataUrl: Schema3.NullOr(Schema3.String),
+  authorizationServerUrl: Schema3.NullOr(Schema3.String),
+  resourceMetadata: Schema3.NullOr(JsonObject),
+  authorizationServerMetadata: Schema3.NullOr(JsonObject),
+  clientInformation: Schema3.NullOr(JsonObject)
 });
-var connectClient = (input) => Effect2.gen(function* () {
-  const client = createClient();
-  const transportInstance = input.createTransport();
-  yield* Effect2.tryPromise({
-    try: () => client.connect(transportInstance),
-    catch: (cause) => new McpConnectionError({
-      transport: input.transport,
-      message: `Failed connecting via ${input.transport}: ${cause instanceof Error ? cause.message : String(cause)}`
-    })
-  });
-  return connectionFromClient(client);
+var McpOAuthSession = Schema3.Struct({
+  ...McpOAuthDiscoveryState.fields,
+  endpoint: Schema3.String,
+  redirectUrl: Schema3.String,
+  codeVerifier: Schema3.String
 });
-var createMcpConnector = (input) => {
-  if (input.transport === "stdio") {
-    const command = input.command.trim();
-    if (!command) {
-      return new McpConnectionError({
-        transport: "stdio",
-        message: "MCP stdio transport requires a command"
-      });
-    }
-    return connectClient({
-      transport: "stdio",
-      createTransport: () => new StdioClientTransport({
-        command,
-        args: input.args ? [...input.args] : void 0,
-        env: input.env ? { ...process.env, ...input.env } : void 0,
-        cwd: input.cwd?.trim().length ? input.cwd.trim() : void 0
-      })
-    });
-  }
-  const headers = input.headers ?? {};
-  const remoteTransport = input.remoteTransport ?? "auto";
-  const requestInit = Object.keys(headers).length > 0 ? { headers } : void 0;
-  const endpoint = buildEndpointUrl(input.endpoint, input.queryParams ?? {});
-  const connectStreamableHttp = connectClient({
-    transport: "streamable-http",
-    createTransport: () => new StreamableHTTPClientTransport(endpoint, {
-      requestInit,
-      authProvider: input.authProvider
-    })
-  });
-  const connectSse = connectClient({
-    transport: "sse",
-    createTransport: () => new SSEClientTransport(endpoint, {
-      requestInit,
-      authProvider: input.authProvider
-    })
-  });
-  if (remoteTransport === "streamable-http") return connectStreamableHttp;
-  if (remoteTransport === "sse") return connectSse;
-  return connectStreamableHttp.pipe(Effect2.catchAll(() => connectSse));
-};
-
-// src/sdk/oauth.ts
-import {
-  auth
-} from "@modelcontextprotocol/sdk/client/auth.js";
-import { Effect as Effect3 } from "effect";
 var toJsonObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 var CLIENT_METADATA = {
   grant_types: ["authorization_code", "refresh_token"],
@@ -257,13 +124,13 @@ var extractDiscoveryState = (discoveryState, clientInformation) => ({
   authorizationServerMetadata: toJsonObject(discoveryState?.authorizationServerMetadata),
   clientInformation: toJsonObject(clientInformation)
 });
-var callAuth = (provider, opts) => Effect3.tryPromise({
+var callAuth = (provider, opts) => Effect.tryPromise({
   try: () => auth(provider, opts),
   catch: (cause) => new McpOAuthError({
     message: cause instanceof Error ? cause.message : String(cause)
   })
 });
-var startMcpOAuthAuthorization = (input) => Effect3.gen(function* () {
+var startMcpOAuthAuthorization = (input) => Effect.gen(function* () {
   let authorizationUrl;
   let codeVerifier;
   let discoveryState;
@@ -309,7 +176,7 @@ var startMcpOAuthAuthorization = (input) => Effect3.gen(function* () {
     ...extractDiscoveryState(discoveryState, clientInformation)
   };
 });
-var exchangeMcpOAuthCode = (input) => Effect3.gen(function* () {
+var exchangeMcpOAuthCode = (input) => Effect.gen(function* () {
   const { session } = input;
   let tokens;
   let discoveryState = {
@@ -359,27 +226,215 @@ var exchangeMcpOAuthCode = (input) => Effect3.gen(function* () {
   };
 });
 
+// src/sdk/stored-source.ts
+import { Schema as Schema4 } from "effect";
+var McpStoredSourceSchema = class extends Schema4.Class("McpStoredSource")({
+  namespace: Schema4.String,
+  name: Schema4.String,
+  config: McpStoredSourceData
+}) {
+};
+
+// src/sdk/binding-store.ts
+var MCP_OAUTH_SESSION_TTL_MS = 15 * 60 * 1e3;
+var StoredOAuthSession = Schema5.Struct({
+  session: McpOAuthSession,
+  expiresAt: Schema5.Number
+});
+var encodeOAuthSession = Schema5.encodeSync(Schema5.parseJson(StoredOAuthSession));
+var decodeOAuthSession = Schema5.decodeUnknownSync(Schema5.parseJson(StoredOAuthSession));
+var encodeSource = Schema5.encodeSync(Schema5.parseJson(McpStoredSourceSchema));
+var decodeSource = Schema5.decodeUnknownSync(Schema5.parseJson(McpStoredSourceSchema));
+var StoredBindingEntry = Schema5.Struct({
+  namespace: Schema5.String,
+  binding: McpToolBinding
+});
+var encodeBindingEntry = Schema5.encodeSync(Schema5.parseJson(StoredBindingEntry));
+var decodeBindingEntry = Schema5.decodeUnknownSync(Schema5.parseJson(StoredBindingEntry));
+var makeStore = (bindings, sources, oauthSessions) => ({
+  // ---- Bindings ----
+  get: (toolId) => Effect2.gen(function* () {
+    const raw = yield* bindings.get(toolId);
+    if (!raw) return null;
+    const entry = decodeBindingEntry(raw);
+    return {
+      binding: entry.binding,
+      namespace: entry.namespace
+    };
+  }),
+  put: (toolId, namespace, binding) => bindings.set([{ key: toolId, value: encodeBindingEntry({ namespace, binding }) }]),
+  remove: (toolId) => bindings.delete([toolId]).pipe(Effect2.asVoid),
+  listByNamespace: (namespace) => Effect2.gen(function* () {
+    const entries = yield* bindings.list();
+    const ids = [];
+    for (const e of entries) {
+      const entry = decodeBindingEntry(e.value);
+      if (entry.namespace === namespace) ids.push(e.key);
+    }
+    return ids;
+  }),
+  removeByNamespace: (namespace) => Effect2.gen(function* () {
+    const entries = yield* bindings.list();
+    const ids = [];
+    for (const e of entries) {
+      const entry = decodeBindingEntry(e.value);
+      if (entry.namespace === namespace) ids.push(e.key);
+    }
+    if (ids.length > 0) yield* bindings.delete(ids);
+    return ids;
+  }),
+  // ---- Sources (meta + config combined) ----
+  putSource: (source) => sources.set([{ key: source.namespace, value: encodeSource(source) }]),
+  removeSource: (namespace) => sources.delete([namespace]).pipe(Effect2.asVoid),
+  listSources: () => Effect2.gen(function* () {
+    const entries = yield* sources.list();
+    return entries.map((e) => decodeSource(e.value));
+  }),
+  getSource: (namespace) => Effect2.gen(function* () {
+    const raw = yield* sources.get(namespace);
+    if (!raw) return null;
+    return decodeSource(raw);
+  }),
+  getSourceConfig: (namespace) => Effect2.gen(function* () {
+    const raw = yield* sources.get(namespace);
+    if (!raw) return null;
+    return decodeSource(raw).config;
+  }),
+  // ---- Pending OAuth sessions (short-lived, between startOAuth and completeOAuth) ----
+  putOAuthSession: (sessionId, session) => oauthSessions.set([
+    {
+      key: sessionId,
+      value: encodeOAuthSession({
+        session,
+        expiresAt: Date.now() + MCP_OAUTH_SESSION_TTL_MS
+      })
+    }
+  ]),
+  getOAuthSession: (sessionId) => Effect2.gen(function* () {
+    const raw = yield* oauthSessions.get(sessionId);
+    if (!raw) return null;
+    const entry = decodeOAuthSession(raw);
+    if (entry.expiresAt < Date.now()) {
+      yield* oauthSessions.delete([sessionId]);
+      return null;
+    }
+    return entry.session;
+  }),
+  deleteOAuthSession: (sessionId) => oauthSessions.delete([sessionId]).pipe(Effect2.asVoid)
+});
+var makeKvBindingStore = (kv, namespace) => makeStore(
+  scopeKv(kv, `${namespace}.bindings`),
+  scopeKv(kv, `${namespace}.sources`),
+  scopeKv(kv, `${namespace}.oauth-sessions`)
+);
+var makeInMemoryBindingStore = () => makeStore(makeInMemoryScopedKv(), makeInMemoryScopedKv(), makeInMemoryScopedKv());
+
+// src/sdk/plugin.ts
+import { Effect as Effect6, Exit, ScopedCache, Duration, Scope } from "effect";
+import {
+  Source,
+  SourceDetectionResult,
+  definePlugin,
+  ToolId,
+  SecretId
+} from "@executor-js/sdk";
+
+// src/sdk/connection.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Effect as Effect3 } from "effect";
+var buildEndpointUrl = (endpoint, queryParams) => {
+  const url = new URL(endpoint);
+  for (const [key, value] of Object.entries(queryParams)) {
+    url.searchParams.set(key, value);
+  }
+  return url;
+};
+var createClient = () => new Client(
+  { name: "executor-mcp", version: "0.1.0" },
+  { capabilities: { elicitation: { form: {}, url: {} } } }
+);
+var connectionFromClient = (client) => ({
+  client,
+  close: () => client.close()
+});
+var connectClient = (input) => Effect3.gen(function* () {
+  const client = createClient();
+  const transportInstance = input.createTransport();
+  yield* Effect3.tryPromise({
+    try: () => client.connect(transportInstance),
+    catch: (cause) => new McpConnectionError({
+      transport: input.transport,
+      message: `Failed connecting via ${input.transport}: ${cause instanceof Error ? cause.message : String(cause)}`
+    })
+  });
+  return connectionFromClient(client);
+});
+var createMcpConnector = (input) => {
+  if (input.transport === "stdio") {
+    const command = input.command.trim();
+    if (!command) {
+      return new McpConnectionError({
+        transport: "stdio",
+        message: "MCP stdio transport requires a command"
+      });
+    }
+    return connectClient({
+      transport: "stdio",
+      createTransport: () => new StdioClientTransport({
+        command,
+        args: input.args ? [...input.args] : void 0,
+        env: input.env ? { ...process.env, ...input.env } : void 0,
+        cwd: input.cwd?.trim().length ? input.cwd.trim() : void 0
+      })
+    });
+  }
+  const headers = input.headers ?? {};
+  const remoteTransport = input.remoteTransport ?? "auto";
+  const requestInit = Object.keys(headers).length > 0 ? { headers } : void 0;
+  const endpoint = buildEndpointUrl(input.endpoint, input.queryParams ?? {});
+  const connectStreamableHttp = connectClient({
+    transport: "streamable-http",
+    createTransport: () => new StreamableHTTPClientTransport(endpoint, {
+      requestInit,
+      authProvider: input.authProvider
+    })
+  });
+  const connectSse = connectClient({
+    transport: "sse",
+    createTransport: () => new SSEClientTransport(endpoint, {
+      requestInit,
+      authProvider: input.authProvider
+    })
+  });
+  if (remoteTransport === "streamable-http") return connectStreamableHttp;
+  if (remoteTransport === "sse") return connectSse;
+  return connectStreamableHttp.pipe(Effect3.catchAll(() => connectSse));
+};
+
 // src/sdk/discover.ts
 import { Effect as Effect4 } from "effect";
 
 // src/sdk/manifest.ts
-import { Schema as Schema4 } from "effect";
-var ListedTool = Schema4.Struct({
-  name: Schema4.String,
-  description: Schema4.optional(Schema4.NullOr(Schema4.String)),
-  inputSchema: Schema4.optional(Schema4.Unknown),
-  parameters: Schema4.optional(Schema4.Unknown),
-  outputSchema: Schema4.optional(Schema4.Unknown)
+import { Schema as Schema6 } from "effect";
+var ListedTool = Schema6.Struct({
+  name: Schema6.String,
+  description: Schema6.optional(Schema6.NullOr(Schema6.String)),
+  inputSchema: Schema6.optional(Schema6.Unknown),
+  parameters: Schema6.optional(Schema6.Unknown),
+  outputSchema: Schema6.optional(Schema6.Unknown)
 });
-var ListToolsResult = Schema4.Struct({
-  tools: Schema4.Array(ListedTool)
+var ListToolsResult = Schema6.Struct({
+  tools: Schema6.Array(ListedTool)
 });
-var ServerInfo = Schema4.Struct({
-  name: Schema4.optional(Schema4.String),
-  version: Schema4.optional(Schema4.String)
+var ServerInfo = Schema6.Struct({
+  name: Schema6.optional(Schema6.String),
+  version: Schema6.optional(Schema6.String)
 });
-var decodeListToolsResult = Schema4.decodeUnknownOption(ListToolsResult);
-var decodeServerInfo = Schema4.decodeUnknownOption(ServerInfo);
+var decodeListToolsResult = Schema6.decodeUnknownOption(ListToolsResult);
+var decodeServerInfo = Schema6.decodeUnknownOption(ServerInfo);
 var sanitize = (value) => {
   const s = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   return s || "tool";
@@ -457,7 +512,7 @@ var discoverTools = (connector) => Effect4.gen(function* () {
 });
 
 // src/sdk/invoke.ts
-import { Effect as Effect5, Schema as Schema5 } from "effect";
+import { Effect as Effect5, Schema as Schema7 } from "effect";
 import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import {
   ToolInvocationResult,
@@ -503,21 +558,21 @@ var makeOAuthProvider = (accessToken, tokenType, refreshToken) => ({
   },
   discoveryState: () => void 0
 });
-var McpElicitParams = Schema5.Union(
-  Schema5.Struct({
-    mode: Schema5.Literal("url"),
-    message: Schema5.String,
-    url: Schema5.String,
-    elicitationId: Schema5.optional(Schema5.String),
-    id: Schema5.optional(Schema5.String)
+var McpElicitParams = Schema7.Union(
+  Schema7.Struct({
+    mode: Schema7.Literal("url"),
+    message: Schema7.String,
+    url: Schema7.String,
+    elicitationId: Schema7.optional(Schema7.String),
+    id: Schema7.optional(Schema7.String)
   }),
-  Schema5.Struct({
-    mode: Schema5.optional(Schema5.Literal("form")),
-    message: Schema5.String,
-    requestedSchema: Schema5.Record({ key: Schema5.String, value: Schema5.Unknown })
+  Schema7.Struct({
+    mode: Schema7.optional(Schema7.Literal("form")),
+    message: Schema7.String,
+    requestedSchema: Schema7.Record({ key: Schema7.String, value: Schema7.Unknown })
   })
 );
-var decodeElicitParams = Schema5.decodeUnknownSync(McpElicitParams);
+var decodeElicitParams = Schema7.decodeUnknownSync(McpElicitParams);
 var toElicitationRequest = (params) => params.mode === "url" ? new UrlElicitation({
   message: params.message,
   url: params.url,
@@ -618,7 +673,15 @@ var makeMcpInvoker = (opts) => {
           cause: void 0
         });
       }
-      const { binding, sourceData } = entry;
+      const sourceData = yield* opts.bindingStore.getSourceConfig(entry.namespace);
+      if (!sourceData) {
+        return yield* new ToolInvocationError({
+          toolId,
+          message: `No MCP source config found for namespace "${entry.namespace}"`,
+          cause: void 0
+        });
+      }
+      const { binding } = entry;
       const cacheKey = connectionCacheKey(sourceData);
       const connector = resolveConnectorInput(sourceData, opts.secrets, opts.scopeId).pipe(
         Effect5.flatMap((ci) => createMcpConnector(ci)),
@@ -782,7 +845,6 @@ var mcpDiscoveryError = (message) => new McpToolDiscoveryError({ stage: "list_to
 var mcpPlugin = (options) => {
   const bindingStore = options?.bindingStore ?? makeInMemoryBindingStore();
   const addedSources = /* @__PURE__ */ new Map();
-  const oauthSessions = /* @__PURE__ */ new Map();
   return definePlugin({
     key: "mcp",
     init: (ctx) => Effect6.gen(function* () {
@@ -825,6 +887,7 @@ var mcpPlugin = (options) => {
             id: s.namespace,
             name: s.name,
             kind: "mcp",
+            url: s.config.transport === "remote" ? s.config.endpoint : void 0,
             canEdit: isRemote
           })
         );
@@ -951,8 +1014,7 @@ var mcpPlugin = (options) => {
             (e) => bindingStore.put(
               ToolId.make(joinToolPath(sourceId, e.toolId)),
               sourceId,
-              toBinding(e),
-              sd
+              toBinding(e)
             ),
             { discard: true }
           );
@@ -1020,8 +1082,7 @@ var mcpPlugin = (options) => {
           (e) => bindingStore.put(
             ToolId.make(joinToolPath(namespace, e.toolId)),
             namespace,
-            toBinding(e),
-            sd
+            toBinding(e)
           ),
           { discard: true }
         );
@@ -1038,6 +1099,7 @@ var mcpPlugin = (options) => {
             id: namespace,
             name: sourceName,
             kind: "mcp",
+            url: sd.transport === "remote" ? sd.endpoint : void 0,
             canEdit: config.transport === "remote"
           })
         );
@@ -1064,8 +1126,7 @@ var mcpPlugin = (options) => {
           (e) => bindingStore.put(
             ToolId.make(joinToolPath(namespace, e.toolId)),
             namespace,
-            toBinding(e),
-            sd
+            toBinding(e)
           ),
           { discard: true }
         );
@@ -1087,7 +1148,7 @@ var mcpPlugin = (options) => {
           redirectUrl: input.redirectUrl,
           state: sessionId
         }).pipe(Effect6.mapError((e) => mcpOAuthError(`OAuth start failed: ${e.message}`)));
-        oauthSessions.set(sessionId, {
+        yield* bindingStore.putOAuthSession(sessionId, {
           endpoint: fullEndpoint,
           redirectUrl: input.redirectUrl,
           codeVerifier: started.codeVerifier,
@@ -1105,7 +1166,7 @@ var mcpPlugin = (options) => {
       const completeOAuth = (input) => Effect6.gen(function* () {
         if (input.error) return yield* mcpOAuthError(`OAuth error: ${input.error}`);
         if (!input.code) return yield* mcpOAuthError("Missing OAuth authorization code");
-        const session = oauthSessions.get(input.state);
+        const session = yield* bindingStore.getOAuthSession(input.state);
         if (!session) return yield* mcpOAuthError(`OAuth session not found: ${input.state}`);
         const exchanged = yield* exchangeMcpOAuthCode({
           session,
@@ -1135,7 +1196,7 @@ var mcpPlugin = (options) => {
           );
           refreshTokenSecretId = ref.id;
         }
-        oauthSessions.delete(input.state);
+        yield* bindingStore.deleteOAuthSession(input.state);
         const expiresAt = typeof exchanged.tokens.expires_in === "number" ? Date.now() + exchanged.tokens.expires_in * 1e3 : null;
         return {
           accessTokenSecretId: accessTokenRef.id,
@@ -1146,9 +1207,9 @@ var mcpPlugin = (options) => {
         };
       });
       const updateSource = (namespace, input) => Effect6.gen(function* () {
-        const existingConfig = yield* bindingStore.getSourceConfig(namespace);
-        if (!existingConfig || existingConfig.transport !== "remote") return;
-        const remote = existingConfig;
+        const existing = yield* bindingStore.getSource(namespace);
+        if (!existing || existing.config.transport !== "remote") return;
+        const remote = existing.config;
         const updatedConfig = {
           ...remote,
           ...input.endpoint !== void 0 ? { endpoint: input.endpoint } : {},
@@ -1156,20 +1217,11 @@ var mcpPlugin = (options) => {
           ...input.auth !== void 0 ? { auth: input.auth } : {},
           ...input.queryParams !== void 0 ? { queryParams: input.queryParams } : {}
         };
-        const sources = yield* bindingStore.listSources();
-        const existingMeta = sources.find((s) => s.namespace === namespace);
         yield* bindingStore.putSource({
           namespace,
-          name: existingMeta?.name ?? namespace,
+          name: input.name?.trim() || existing.name,
           config: updatedConfig
         });
-        const toolIds = yield* bindingStore.listByNamespace(namespace);
-        for (const toolId of toolIds) {
-          const entry = yield* bindingStore.get(toolId);
-          if (entry) {
-            yield* bindingStore.put(toolId, namespace, entry.binding, updatedConfig);
-          }
-        }
       });
       const getSource = (namespace) => bindingStore.getSource(namespace);
       return {
@@ -1200,4 +1252,4 @@ export {
   makeKvBindingStore,
   mcpPlugin
 };
-//# sourceMappingURL=chunk-NJ4CITCV.js.map
+//# sourceMappingURL=chunk-X3JTTDWJ.js.map