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

package/README.md

@@ -48,10 +48,10 @@ const result = await executor.tools.invoke(
 
 ## Using with Effect
 
-If you're building on `@executor/sdk/core` (the raw Effect entry), import this plugin from its `/core` subpath instead:
+If you're building on `@executor/sdk` (the raw Effect entry), import this plugin from its `/core` subpath instead:
 
 ```ts
-import { mcpPlugin } from "@executor/plugin-mcp/core";
+import { mcpPlugin } from "@executor/plugin-mcp";
 ```
 
 ## Status

package/dist/api/group.d.ts

@@ -1,4 +1,5 @@
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "@effect/platform";
+import { McpStoredSourceSchema } from "../sdk/stored-source";
 export { HttpApiSchema };
 declare const McpGroup_base: HttpApiGroup.HttpApiGroup<"mcp", HttpApiEndpoint.HttpApiEndpoint<"probeEndpoint", "POST", {
     readonly scopeId: string & import("effect/Brand").Brand<"ScopeId">;
@@ -107,6 +108,41 @@ declare const McpGroup_base: HttpApiGroup.HttpApiGroup<"mcp", HttpApiEndpoint.Ht
     readonly error_description?: string | undefined;
 }, never, never, string, {
     readonly message: string;
+}, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSource", "GET", {
+    readonly scopeId: string & import("effect/Brand").Brand<"ScopeId">;
+    readonly namespace: string;
+}, never, never, never, McpStoredSourceSchema | null, {
+    readonly message: string;
+}, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updateSource", "PATCH", {
+    readonly scopeId: string & import("effect/Brand").Brand<"ScopeId">;
+    readonly namespace: string;
+}, never, {
+    readonly endpoint?: string | undefined;
+    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 | undefined;
+        readonly expiresAt: number | null;
+    } | undefined;
+}, never, {
+    readonly updated: boolean;
+}, {
+    readonly message: string;
 }, never, never>, never, never, false>;
 export declare class McpGroup extends McpGroup_base {
 }

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

@@ -1,9 +1,6 @@
 // src/sdk/binding-store.ts
 import { Effect, Schema as Schema2 } from "effect";
-import {
-  makeInMemoryScopedKv,
-  scopeKv
-} from "@executor-js/sdk/core";
+import { makeInMemoryScopedKv, scopeKv } from "@executor-js/sdk";
 
 // src/sdk/types.ts
 import { Schema } from "effect";
@@ -51,13 +48,8 @@ var McpStdioSourceData = Schema.Struct({
   /** Working directory */
   cwd: Schema.optional(Schema.String)
 });
-var McpStoredSourceData = Schema.Union(
-  McpRemoteSourceData,
-  McpStdioSourceData
-);
-var McpToolBinding = class extends Schema.Class(
-  "McpToolBinding"
-)({
+var McpStoredSourceData = Schema.Union(McpRemoteSourceData, McpStdioSourceData);
+var McpToolBinding = class extends Schema.Class("McpToolBinding")({
   toolId: Schema.String,
   toolName: Schema.String,
   description: Schema.NullOr(Schema.String),
@@ -72,12 +64,8 @@ var StoredBindingEntry = Schema2.Struct({
   binding: McpToolBinding,
   sourceData: Schema2.Unknown
 });
-var encodeBindingEntry = Schema2.encodeSync(
-  Schema2.parseJson(StoredBindingEntry)
-);
-var decodeBindingEntry = Schema2.decodeUnknownSync(
-  Schema2.parseJson(StoredBindingEntry)
-);
+var encodeBindingEntry = Schema2.encodeSync(Schema2.parseJson(StoredBindingEntry));
+var decodeBindingEntry = Schema2.decodeUnknownSync(Schema2.parseJson(StoredBindingEntry));
 var makeStore = (bindings, sources) => ({
   // ---- Bindings ----
   get: (toolId) => Effect.gen(function* () {
@@ -89,11 +77,8 @@ var makeStore = (bindings, sources) => ({
       sourceData: entry.sourceData
     };
   }),
-  put: (toolId, namespace, binding, sourceData) => bindings.set(
-    toolId,
-    encodeBindingEntry({ namespace, binding, sourceData })
-  ),
-  remove: (toolId) => bindings.delete(toolId).pipe(Effect.asVoid),
+  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 = [];
@@ -108,20 +93,23 @@ var makeStore = (bindings, sources) => ({
     const ids = [];
     for (const e of entries) {
       const entry = decodeBindingEntry(e.value);
-      if (entry.namespace === namespace) {
-        ids.push(e.key);
-        yield* bindings.delete(e.key);
-      }
+      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(source.namespace, JSON.stringify(source)),
-  removeSource: (namespace) => sources.delete(namespace).pipe(Effect.asVoid),
+  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;
@@ -129,14 +117,8 @@ var makeStore = (bindings, sources) => ({
     return source.config;
   })
 });
-var makeKvBindingStore = (kv, namespace) => makeStore(
-  scopeKv(kv, `${namespace}.bindings`),
-  scopeKv(kv, `${namespace}.sources`)
-);
-var makeInMemoryBindingStore = () => makeStore(
-  makeInMemoryScopedKv(),
-  makeInMemoryScopedKv()
-);
+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";
@@ -146,7 +128,7 @@ import {
   definePlugin,
   ToolId,
   SecretId
-} from "@executor-js/sdk/core";
+} from "@executor-js/sdk";
 
 // src/sdk/connection.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -181,12 +163,9 @@ var McpInvocationError = class extends Schema3.TaggedError()(
   }
 ) {
 };
-var McpOAuthError = class extends Schema3.TaggedError()(
-  "McpOAuthError",
-  {
-    message: Schema3.String
-  }
-) {
+var McpOAuthError = class extends Schema3.TaggedError()("McpOAuthError", {
+  message: Schema3.String
+}) {
 };
 
 // src/sdk/connection.ts
@@ -239,10 +218,7 @@ var createMcpConnector = (input) => {
   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 endpoint = buildEndpointUrl(input.endpoint, input.queryParams ?? {});
   const connectStreamableHttp = connectClient({
     transport: "streamable-http",
     createTransport: () => new StreamableHTTPClientTransport(endpoint, {
@@ -490,7 +466,7 @@ import {
   ElicitationResponse,
   FormElicitation,
   UrlElicitation
-} from "@executor-js/sdk/core";
+} from "@executor-js/sdk";
 var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 var makeOAuthProvider = (accessToken, tokenType, refreshToken) => ({
   get redirectUrl() {
@@ -551,19 +527,16 @@ var toElicitationRequest = (params) => params.mode === "url" ? new UrlElicitatio
   requestedSchema: params.requestedSchema
 });
 var installElicitationHandler = (client, toolId, args, handler) => {
-  client.setRequestHandler(
-    ElicitRequestSchema,
-    async (request) => {
-      const params = decodeElicitParams(request.params);
-      const response = await Effect5.runPromise(
-        handler({ toolId, args, request: toElicitationRequest(params) })
-      );
-      return {
-        action: response.action,
-        ...response.action === "accept" && response.content ? { content: response.content } : {}
-      };
-    }
-  );
+  client.setRequestHandler(ElicitRequestSchema, async (request) => {
+    const params = decodeElicitParams(request.params);
+    const response = await Effect5.runPromise(
+      handler({ toolId, args, request: toElicitationRequest(params) })
+    );
+    return {
+      action: response.action,
+      ...response.action === "accept" && response.content ? { content: response.content } : {}
+    };
+  });
 };
 var resolveConnectorInput = (sourceData, secrets, scopeId) => {
   if (sourceData.transport === "stdio") {
@@ -576,7 +549,7 @@ var resolveConnectorInput = (sourceData, secrets, scopeId) => {
     });
   }
   return Effect5.gen(function* () {
-    const headers = { ...sourceData.headers ?? {} };
+    const headers = { ...sourceData.headers };
     let authProvider;
     const auth2 = sourceData.auth;
     if (auth2.kind === "header") {
@@ -607,11 +580,7 @@ var resolveConnectorInput = (sourceData, secrets, scopeId) => {
           Effect5.map((o) => o._tag === "Some" ? o.value : void 0)
         );
       }
-      authProvider = makeOAuthProvider(
-        accessToken,
-        auth2.tokenType ?? "Bearer",
-        refreshToken
-      );
+      authProvider = makeOAuthProvider(accessToken, auth2.tokenType ?? "Bearer", refreshToken);
     }
     return {
       transport: "remote",
@@ -639,9 +608,7 @@ var useMcpConnection = (connection, toolId, toolName, args, handler) => Effect5.
 var makeMcpInvoker = (opts) => {
   const { connectionCache, pendingConnectors } = opts;
   return {
-    resolveAnnotations: () => Effect5.succeed(
-      new ToolAnnotations({ requiresApproval: false })
-    ),
+    resolveAnnotations: () => Effect5.succeed(new ToolAnnotations({ requiresApproval: false })),
     invoke: (toolId, args, options) => Effect5.gen(function* () {
       const entry = yield* opts.bindingStore.get(toolId);
       if (!entry) {
@@ -653,11 +620,7 @@ var makeMcpInvoker = (opts) => {
       }
       const { binding, sourceData } = entry;
       const cacheKey = connectionCacheKey(sourceData);
-      const connector = resolveConnectorInput(
-        sourceData,
-        opts.secrets,
-        opts.scopeId
-      ).pipe(
+      const connector = resolveConnectorInput(sourceData, opts.secrets, opts.scopeId).pipe(
         Effect5.flatMap((ci) => createMcpConnector(ci)),
         Effect5.mapError(
           (err) => new McpConnectionError({
@@ -686,7 +649,7 @@ var makeMcpInvoker = (opts) => {
       ).pipe(
         // On failure, invalidate the cached connection and retry once
         Effect5.catchAll(
-          (err) => Effect5.gen(function* () {
+          () => Effect5.gen(function* () {
             yield* connectionCache.invalidate(cacheKey);
             pendingConnectors.set(cacheKey, connector);
             const freshConnection = yield* connectionCache.get(cacheKey).pipe(
@@ -733,9 +696,7 @@ var makeMcpInvoker = (opts) => {
     ),
     closeConnections: () => Effect5.sync(() => {
       pendingConnectors.clear();
-    }).pipe(
-      Effect5.flatMap(() => connectionCache.invalidateAll)
-    )
+    }).pipe(Effect5.flatMap(() => connectionCache.invalidateAll))
   };
 };
 
@@ -857,9 +818,15 @@ var mcpPlugin = (options) => {
       yield* ctx.tools.registerInvoker("mcp", invoker);
       const savedSources = yield* bindingStore.listSources();
       for (const s of savedSources) {
+        const isRemote = s.config.transport === "remote";
         addedSources.set(
           s.namespace,
-          new Source({ id: s.namespace, name: s.name, kind: "mcp" })
+          new Source({
+            id: s.namespace,
+            name: s.name,
+            kind: "mcp",
+            canEdit: isRemote
+          })
         );
       }
       const resolveConnectorInput2 = (sd) => {
@@ -874,30 +841,26 @@ var mcpPlugin = (options) => {
         }
         return Effect6.gen(function* () {
           const headers = {
-            ...sd.headers ?? {}
+            ...sd.headers
           };
           let authProvider;
           const auth2 = sd.auth;
           if (auth2.kind === "header") {
-            const val = yield* ctx.secrets.resolve(auth2.secretId, ctx.scope.id).pipe(
+            const val = yield* ctx.secrets.resolve(SecretId.make(auth2.secretId), ctx.scope.id).pipe(
               Effect6.mapError(
-                () => remoteConnectionError(
-                  `Failed to resolve secret "${auth2.secretId}"`
-                )
+                () => remoteConnectionError(`Failed to resolve secret "${auth2.secretId}"`)
               )
             );
             headers[auth2.headerName] = auth2.prefix ? `${auth2.prefix}${val}` : val;
           } else if (auth2.kind === "oauth2") {
-            const accessToken = yield* ctx.secrets.resolve(auth2.accessTokenSecretId, ctx.scope.id).pipe(
+            const accessToken = yield* ctx.secrets.resolve(SecretId.make(auth2.accessTokenSecretId), ctx.scope.id).pipe(
               Effect6.mapError(
-                () => remoteConnectionError(
-                  "Failed to resolve OAuth access token"
-                )
+                () => remoteConnectionError("Failed to resolve OAuth access token")
               )
             );
             let refreshToken;
             if (auth2.refreshTokenSecretId) {
-              refreshToken = yield* ctx.secrets.resolve(auth2.refreshTokenSecretId, ctx.scope.id).pipe(
+              refreshToken = yield* ctx.secrets.resolve(SecretId.make(auth2.refreshTokenSecretId), ctx.scope.id).pipe(
                 Effect6.option,
                 Effect6.map((o) => o._tag === "Some" ? o.value : void 0)
               );
@@ -930,9 +893,7 @@ var mcpPlugin = (options) => {
         detect: (url) => Effect6.gen(function* () {
           const trimmed = url.trim();
           if (!trimmed) return null;
-          const parsed = yield* Effect6.try(() => new URL(trimmed)).pipe(
-            Effect6.option
-          );
+          const parsed = yield* Effect6.try(() => new URL(trimmed)).pipe(Effect6.option);
           if (parsed._tag === "None") return null;
           const name = parsed.value.hostname || "mcp";
           const namespace = deriveMcpNamespace({ endpoint: trimmed });
@@ -979,9 +940,9 @@ var mcpPlugin = (options) => {
             Effect6.catchAll(() => Effect6.succeed(null))
           );
           if (!ci) return;
-          const manifest = yield* discoverTools(
-            createMcpConnector(ci)
-          ).pipe(Effect6.catchAll(() => Effect6.succeed(null)));
+          const manifest = yield* discoverTools(createMcpConnector(ci)).pipe(
+            Effect6.catchAll(() => Effect6.succeed(null))
+          );
           if (!manifest) return;
           const oldIds = yield* bindingStore.removeByNamespace(sourceId);
           if (oldIds.length > 0) yield* ctx.tools.unregister(oldIds);
@@ -995,15 +956,12 @@ var mcpPlugin = (options) => {
             ),
             { discard: true }
           );
-          yield* ctx.tools.register(
-            manifest.tools.map((e) => toRegistration(e, sourceId))
-          );
+          yield* ctx.tools.register(manifest.tools.map((e) => toRegistration(e, sourceId)));
         })
       });
       const probeEndpoint = (endpoint) => Effect6.gen(function* () {
         const trimmed = endpoint.trim();
-        if (!trimmed)
-          return yield* remoteConnectionError("Endpoint URL is required");
+        if (!trimmed) return yield* remoteConnectionError("Endpoint URL is required");
         const name = yield* Effect6.try(() => new URL(trimmed).hostname).pipe(
           Effect6.orElseSucceed(() => "mcp")
         );
@@ -1014,9 +972,7 @@ var mcpPlugin = (options) => {
         });
         const result = yield* discoverTools(connector).pipe(
           Effect6.map((m) => ({ ok: true, manifest: m })),
-          Effect6.catchAll(
-            () => Effect6.succeed({ ok: false, manifest: null })
-          )
+          Effect6.catchAll(() => Effect6.succeed({ ok: false, manifest: null }))
         );
         if (result.ok && result.manifest) {
           return {
@@ -1056,13 +1012,9 @@ var mcpPlugin = (options) => {
         const ci = yield* resolveConnectorInput2(sd);
         const connector = createMcpConnector(ci);
         const manifest = yield* discoverTools(connector).pipe(
-          Effect6.mapError(
-            (err) => mcpDiscoveryError(`MCP discovery failed: ${err.message}`)
-          )
-        );
-        const registrations = manifest.tools.map(
-          (e) => toRegistration(e, namespace)
+          Effect6.mapError((err) => mcpDiscoveryError(`MCP discovery failed: ${err.message}`))
         );
+        const registrations = manifest.tools.map((e) => toRegistration(e, namespace));
         yield* Effect6.forEach(
           manifest.tools,
           (e) => bindingStore.put(
@@ -1085,7 +1037,8 @@ var mcpPlugin = (options) => {
           new Source({
             id: namespace,
             name: sourceName,
-            kind: "mcp"
+            kind: "mcp",
+            canEdit: config.transport === "remote"
           })
         );
         return { toolCount: registrations.length, namespace };
@@ -1099,16 +1052,10 @@ var mcpPlugin = (options) => {
       const refreshSource = (namespace) => Effect6.gen(function* () {
         const sd = yield* bindingStore.getSourceConfig(namespace);
         if (!sd)
-          return yield* remoteConnectionError(
-            `No stored config for MCP source "${namespace}"`
-          );
+          return yield* remoteConnectionError(`No stored config for MCP source "${namespace}"`);
         const ci = yield* resolveConnectorInput2(sd);
-        const manifest = yield* discoverTools(
-          createMcpConnector(ci)
-        ).pipe(
-          Effect6.mapError(
-            (err) => mcpDiscoveryError(`MCP refresh failed: ${err.message}`)
-          )
+        const manifest = yield* discoverTools(createMcpConnector(ci)).pipe(
+          Effect6.mapError((err) => mcpDiscoveryError(`MCP refresh failed: ${err.message}`))
         );
         const oldIds = yield* bindingStore.removeByNamespace(namespace);
         if (oldIds.length > 0) yield* ctx.tools.unregister(oldIds);
@@ -1122,20 +1069,16 @@ var mcpPlugin = (options) => {
           ),
           { discard: true }
         );
-        yield* ctx.tools.register(
-          manifest.tools.map((e) => toRegistration(e, namespace))
-        );
+        yield* ctx.tools.register(manifest.tools.map((e) => toRegistration(e, namespace)));
         return { toolCount: manifest.tools.length };
       });
       const startOAuth = (input) => Effect6.gen(function* () {
         const endpoint = input.endpoint.trim();
-        if (!endpoint)
-          return yield* mcpOAuthError("MCP OAuth requires an endpoint");
+        if (!endpoint) return yield* mcpOAuthError("MCP OAuth requires an endpoint");
         let fullEndpoint = endpoint;
         if (input.queryParams && Object.keys(input.queryParams).length > 0) {
           const u = new URL(endpoint);
-          for (const [k, v] of Object.entries(input.queryParams))
-            u.searchParams.set(k, v);
+          for (const [k, v] of Object.entries(input.queryParams)) u.searchParams.set(k, v);
           fullEndpoint = u.toString();
         }
         const sessionId = `mcp_oauth_${crypto.randomUUID()}`;
@@ -1143,11 +1086,7 @@ var mcpPlugin = (options) => {
           endpoint: fullEndpoint,
           redirectUrl: input.redirectUrl,
           state: sessionId
-        }).pipe(
-          Effect6.mapError(
-            (e) => mcpOAuthError(`OAuth start failed: ${e.message}`)
-          )
-        );
+        }).pipe(Effect6.mapError((e) => mcpOAuthError(`OAuth start failed: ${e.message}`)));
         oauthSessions.set(sessionId, {
           endpoint: fullEndpoint,
           redirectUrl: input.redirectUrl,
@@ -1164,51 +1103,34 @@ 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");
+        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);
-        if (!session)
-          return yield* mcpOAuthError(`OAuth session not found: ${input.state}`);
+        if (!session) return yield* mcpOAuthError(`OAuth session not found: ${input.state}`);
         const exchanged = yield* exchangeMcpOAuthCode({
           session,
           code: input.code
-        }).pipe(
-          Effect6.mapError(
-            (e) => mcpOAuthError(`OAuth exchange failed: ${e.message}`)
-          )
-        );
+        }).pipe(Effect6.mapError((e) => mcpOAuthError(`OAuth exchange failed: ${e.message}`)));
         const accessTokenRef = yield* ctx.secrets.set({
-          id: SecretId.make(
-            `mcp-oauth-access-${input.state}`
-          ),
+          id: SecretId.make(`mcp-oauth-access-${input.state}`),
           scopeId: ctx.scope.id,
           name: "MCP OAuth Access Token",
           value: exchanged.tokens.access_token,
           purpose: "oauth_access_token"
         }).pipe(
-          Effect6.mapError(
-            (e) => mcpOAuthError(
-              `Failed to store access token: ${String(e)}`
-            )
-          )
+          Effect6.mapError((e) => mcpOAuthError(`Failed to store access token: ${String(e)}`))
         );
         let refreshTokenSecretId = null;
         if (exchanged.tokens.refresh_token) {
           const ref = yield* ctx.secrets.set({
-            id: SecretId.make(
-              `mcp-oauth-refresh-${input.state}`
-            ),
+            id: SecretId.make(`mcp-oauth-refresh-${input.state}`),
             scopeId: ctx.scope.id,
             name: "MCP OAuth Refresh Token",
             value: exchanged.tokens.refresh_token,
             purpose: "oauth_refresh_token"
           }).pipe(
             Effect6.mapError(
-              (e) => mcpOAuthError(
-                `Failed to store refresh token: ${String(e)}`
-              )
+              (e) => mcpOAuthError(`Failed to store refresh token: ${String(e)}`)
             )
           );
           refreshTokenSecretId = ref.id;
@@ -1223,6 +1145,33 @@ var mcpPlugin = (options) => {
           scope: exchanged.tokens.scope ?? null
         };
       });
+      const updateSource = (namespace, input) => Effect6.gen(function* () {
+        const existingConfig = yield* bindingStore.getSourceConfig(namespace);
+        if (!existingConfig || existingConfig.transport !== "remote") return;
+        const remote = existingConfig;
+        const updatedConfig = {
+          ...remote,
+          ...input.endpoint !== void 0 ? { endpoint: input.endpoint } : {},
+          ...input.headers !== void 0 ? { headers: input.headers } : {},
+          ...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,
+          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 {
         extension: {
           probeEndpoint,
@@ -1230,7 +1179,9 @@ var mcpPlugin = (options) => {
           removeSource,
           refreshSource,
           startOAuth,
-          completeOAuth
+          completeOAuth,
+          getSource,
+          updateSource
         },
         close: () => Effect6.gen(function* () {
           yield* invoker.closeConnections();
@@ -1249,4 +1200,4 @@ export {
   makeKvBindingStore,
   mcpPlugin
 };
-//# sourceMappingURL=chunk-DR65PT4S.js.map
+//# sourceMappingURL=chunk-NJ4CITCV.js.map