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

package/dist/{chunk-DR65PT4S.js → chunk-X3JTTDWJ.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 { Effect as Effect2, Schema as Schema5 } from "effect";
+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),
@@ -66,207 +58,58 @@ var McpToolBinding = class extends Schema.Class(
 }) {
 };
 
-// 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(
-    toolId,
-    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);
-        yield* bindings.delete(e.key);
-      }
-    }
-    return ids;
-  }),
-  // ---- Sources (meta + config combined) ----
-  putSource: (source) => sources.set(source.namespace, 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));
-  }),
-  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/core";
-
-// 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"],
@@ -281,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;
@@ -333,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 = {
@@ -383,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";
@@ -481,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,
@@ -490,7 +521,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() {
@@ -527,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,
@@ -551,19 +582,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 +604,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 +635,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 +663,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) {
@@ -651,13 +673,17 @@ 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(
+      const connector = resolveConnectorInput(sourceData, opts.secrets, opts.scopeId).pipe(
         Effect5.flatMap((ci) => createMcpConnector(ci)),
         Effect5.mapError(
           (err) => new McpConnectionError({
@@ -686,7 +712,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 +759,7 @@ var makeMcpInvoker = (opts) => {
     ),
     closeConnections: () => Effect5.sync(() => {
       pendingConnectors.clear();
-    }).pipe(
-      Effect5.flatMap(() => connectionCache.invalidateAll)
-    )
+    }).pipe(Effect5.flatMap(() => connectionCache.invalidateAll))
   };
 };
 
@@ -821,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* () {
@@ -857,9 +880,16 @@ 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",
+            url: s.config.transport === "remote" ? s.config.endpoint : void 0,
+            canEdit: isRemote
+          })
         );
       }
       const resolveConnectorInput2 = (sd) => {
@@ -874,30 +904,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 +956,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 +1003,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);
@@ -990,20 +1014,16 @@ var mcpPlugin = (options) => {
             (e) => bindingStore.put(
               ToolId.make(joinToolPath(sourceId, e.toolId)),
               sourceId,
-              toBinding(e),
-              sd
+              toBinding(e)
             ),
             { 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 +1034,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,20 +1074,15 @@ 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(
             ToolId.make(joinToolPath(namespace, e.toolId)),
             namespace,
-            toBinding(e),
-            sd
+            toBinding(e)
           ),
           { discard: true }
         );
@@ -1085,7 +1098,9 @@ var mcpPlugin = (options) => {
           new Source({
             id: namespace,
             name: sourceName,
-            kind: "mcp"
+            kind: "mcp",
+            url: sd.transport === "remote" ? sd.endpoint : void 0,
+            canEdit: config.transport === "remote"
           })
         );
         return { toolCount: registrations.length, namespace };
@@ -1099,16 +1114,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);
@@ -1117,25 +1126,20 @@ var mcpPlugin = (options) => {
           (e) => bindingStore.put(
             ToolId.make(joinToolPath(namespace, e.toolId)),
             namespace,
-            toBinding(e),
-            sd
+            toBinding(e)
           ),
           { 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,12 +1147,8 @@ var mcpPlugin = (options) => {
           endpoint: fullEndpoint,
           redirectUrl: input.redirectUrl,
           state: sessionId
-        }).pipe(
-          Effect6.mapError(
-            (e) => mcpOAuthError(`OAuth start failed: ${e.message}`)
-          )
-        );
-        oauthSessions.set(sessionId, {
+        }).pipe(Effect6.mapError((e) => mcpOAuthError(`OAuth start failed: ${e.message}`)));
+        yield* bindingStore.putOAuthSession(sessionId, {
           endpoint: fullEndpoint,
           redirectUrl: input.redirectUrl,
           codeVerifier: started.codeVerifier,
@@ -1164,56 +1164,39 @@ 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);
-        if (!session)
-          return yield* mcpOAuthError(`OAuth session not found: ${input.state}`);
+        if (input.error) return yield* mcpOAuthError(`OAuth error: ${input.error}`);
+        if (!input.code) return yield* mcpOAuthError("Missing OAuth authorization code");
+        const session = yield* bindingStore.getOAuthSession(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;
         }
-        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,
@@ -1223,6 +1206,24 @@ var mcpPlugin = (options) => {
           scope: exchanged.tokens.scope ?? null
         };
       });
+      const updateSource = (namespace, input) => Effect6.gen(function* () {
+        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 } : {},
+          ...input.headers !== void 0 ? { headers: input.headers } : {},
+          ...input.auth !== void 0 ? { auth: input.auth } : {},
+          ...input.queryParams !== void 0 ? { queryParams: input.queryParams } : {}
+        };
+        yield* bindingStore.putSource({
+          namespace,
+          name: input.name?.trim() || existing.name,
+          config: updatedConfig
+        });
+      });
+      const getSource = (namespace) => bindingStore.getSource(namespace);
       return {
         extension: {
           probeEndpoint,
@@ -1230,7 +1231,9 @@ var mcpPlugin = (options) => {
           removeSource,
           refreshSource,
           startOAuth,
-          completeOAuth
+          completeOAuth,
+          getSource,
+          updateSource
         },
         close: () => Effect6.gen(function* () {
           yield* invoker.closeConnections();
@@ -1249,4 +1252,4 @@ export {
   makeKvBindingStore,
   mcpPlugin
 };
-//# sourceMappingURL=chunk-DR65PT4S.js.map
+//# sourceMappingURL=chunk-X3JTTDWJ.js.map