@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-3yetcf2r.js

@@ -0,0 +1,768 @@
+import {
+  makeUnsafe2
+} from "./repository-y71avatq.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Event19,
+  Service75,
+  node79
+} from "./repository-sztg2hv4.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Service65,
+  node69
+} from "./repository-3mdgf1e2.js";
+import {
+  ID18,
+  Service77,
+  node82
+} from "./repository-yz39bey7.js";
+import {
+  reconcile2,
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  ID13,
+  MethodID2,
+  Service74,
+  node78
+} from "./repository-0zkv00cg.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/mcp/index.ts
+var exports_mcp4 = {};
+__export(exports_mcp4, {
+  Mcp: () => exports_mcp4,
+  NotFoundError: () => NotFoundError4,
+  Options: () => Options5,
+  Prompt: () => Prompt2,
+  PromptArgument: () => PromptArgument2,
+  PromptMessage: () => PromptMessage2,
+  PromptResult: () => PromptResult2,
+  PromptsChanged: () => PromptsChanged2,
+  Resource: () => Resource2,
+  ResourceCatalog: () => ResourceCatalog2,
+  ResourceContent: () => ResourceContent2,
+  ResourceContentPart: () => ResourceContentPart2,
+  ResourceTemplate: () => ResourceTemplate2,
+  ServerInfo: () => ServerInfo2,
+  ServerInstructions: () => ServerInstructions2,
+  ServerName: () => ServerName2,
+  Service: () => Service31,
+  Status: () => Status2,
+  Tool: () => Tool2,
+  ToolCallError: () => ToolCallError2,
+  ToolResult: () => ToolResult2,
+  ToolResultContent: () => ToolResultContent2,
+  configured: () => configured5,
+  layer: () => layer13,
+  node: () => node36
+});
+import { Mcp } from "@opencode/schema/mcp";
+import { McpEvent } from "@opencode/schema/mcp-event";
+import { ephemeral } from "@opencode/schema/event";
+import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { Cause, Context, Effect, Exit, FiberSet, Latch, Layer, Schema, Scope, Semaphore, Stream } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { waitForAbort } from "@opencode/util/process";
+var ServerName2 = Schema.String.pipe(Schema.brand("MCP.ServerName"));
+var PromptsChanged2 = ephemeral({ type: "mcp.prompts.changed", schema: { server: Schema.String } });
+var Status2 = Mcp.Status;
+
+class ServerInfo2 extends Schema.Class("MCP.ServerInfo")({
+  name: ServerName2,
+  status: Status2,
+  integrationID: ID13.pipe(Schema.optional)
+}) {
+}
+
+class ServerInstructions2 extends Schema.Class("MCP.ServerInstructions")({
+  server: ServerName2,
+  instructions: Schema.String
+}) {
+}
+
+class Tool2 extends Schema.Class("MCP.Tool")({
+  server: ServerName2,
+  name: Schema.String,
+  codemode: Schema.Boolean.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  inputSchema: Schema.Unknown.pipe(Schema.optional),
+  outputSchema: Schema.Unknown.pipe(Schema.optional)
+}) {
+}
+var ToolResultContent2 = Schema.Union([
+  Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }),
+  Schema.Struct({ type: Schema.Literal("media"), data: Schema.String, mimeType: Schema.String })
+]).pipe(Schema.toTaggedUnion("type"));
+
+class ToolResult2 extends Schema.Class("MCP.ToolResult")({
+  server: ServerName2,
+  tool: Schema.String,
+  isError: Schema.Boolean,
+  structured: Schema.Unknown.pipe(Schema.optional),
+  content: Schema.Array(ToolResultContent2)
+}) {
+}
+
+class PromptArgument2 extends Schema.Class("MCP.PromptArgument")({
+  name: Schema.String,
+  description: Schema.String.pipe(Schema.optional),
+  required: Schema.Boolean.pipe(Schema.optional)
+}) {
+}
+
+class Prompt2 extends Schema.Class("MCP.Prompt")({
+  server: ServerName2,
+  name: Schema.String,
+  description: Schema.String.pipe(Schema.optional),
+  arguments: Schema.Array(PromptArgument2).pipe(Schema.optional)
+}) {
+}
+
+class PromptMessage2 extends Schema.Class("MCP.PromptMessage")({
+  role: Schema.String,
+  content: Schema.Unknown
+}) {
+}
+
+class PromptResult2 extends Schema.Class("MCP.PromptResult")({
+  server: ServerName2,
+  name: Schema.String,
+  messages: Schema.Array(PromptMessage2)
+}) {
+}
+var Resource2 = Mcp.Resource;
+var ResourceTemplate2 = Mcp.ResourceTemplate;
+var ResourceCatalog2 = Mcp.ResourceCatalog;
+var ResourceContentPart2 = Mcp.ResourceContentPart;
+var ResourceContent2 = Mcp.ResourceContent;
+
+class NotFoundError4 extends Schema.TaggedError()("MCP.NotFoundError", {
+  server: ServerName2
+}) {
+  get message() {
+    return `MCP server not found: ${this.server}`;
+  }
+}
+
+class ToolCallError2 extends Schema.TaggedError()("MCP.ToolCallError", {
+  server: ServerName2,
+  tool: Schema.String,
+  message: Schema.String
+}) {
+}
+var GLOBAL_ELICITATION_SESSION_ID = "global";
+var URL_ELICITATION_FIELD_KEY = "elicitation";
+var cloneConfig = (config) => structuredClone(config);
+
+class Service31 extends Context.Service()("@opencode/MCP") {
+}
+var Options5 = Schema.Struct({
+  clientInfo: Schema.optional(Schema.Struct({
+    name: Schema.String,
+    version: Schema.String
+  }))
+});
+var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
+  const location = yield* Service66;
+  const environment = yield* Service65;
+  const bus = yield* Service78;
+  const forms = yield* Service77;
+  const integration = yield* Service74;
+  const credentials = yield* Service75;
+  const root = yield* Effect.scope;
+  const fork = yield* FiberSet.makeRuntime();
+  const entries = new Map;
+  const locks = makeUnsafe2();
+  const urlElicitations = new Map;
+  const owned = new Set;
+  const register = Effect.fnUntraced(function* (name, entry) {
+    if (entry.config.type !== "remote" || entry.config.oauth === false)
+      return;
+    const remote = entry.config;
+    const suffix = "mcp_" + createHash("sha1").update(name + "\x00" + remote.url).digest("hex").slice(0, 16);
+    const integrationID = ID13.make(suffix);
+    entry.integrationID = integrationID;
+    owned.add(integrationID);
+    const methodID = MethodID2.make(suffix);
+    const scope = yield* Scope.fork(root);
+    entry.registration = { dispose: Scope.close(scope, Exit.void) };
+    yield* integration.transform((editor) => {
+      editor.update(integrationID, (ref) => {
+        ref.name = name;
+        ref.metadata = { source: "mcp" };
+      });
+      editor.method.update({
+        integrationID,
+        method: { id: methodID, type: "oauth", label: name },
+        authorize: () => Effect.gen(function* () {
+          const { McpOAuth } = yield* Effect.promise(() => import("../mcp/oauth.js"));
+          return yield* McpOAuth.authorize({ name, config: remote, methodID });
+        })
+      });
+    }).pipe(Scope.provide(scope));
+  });
+  const requireServer = Effect.fnUntraced(function* (server) {
+    const name = ServerName2.make(server);
+    const entry = entries.get(name);
+    if (!entry)
+      return yield* new NotFoundError4({ server: name });
+    return { name, entry };
+  });
+  const connectProvider = Effect.fnUntraced(function* (entry) {
+    if (entry.config.type !== "remote" || !entry.integrationID)
+      return;
+    const { McpOAuth } = yield* Effect.promise(() => import("../mcp/oauth.js"));
+    const remote = entry.config;
+    const oauth = remote.oauth || undefined;
+    const run = Effect.runPromiseWith(yield* Effect.context());
+    const base = {
+      redirectUrl: oauth?.redirect_uri ?? "http://127.0.0.1/callback",
+      scope: oauth?.scope,
+      client: oauth?.client_id ? { id: oauth.client_id, secret: oauth.client_secret } : undefined,
+      onRedirect: () => run(Effect.logInfo("mcp oauth authorization required"))
+    };
+    const found = (yield* credentials.list(entry.integrationID)).at(-1);
+    if (!found || found.value.type !== "oauth") {
+      yield* Effect.logInfo("mcp oauth credential unavailable", {
+        integrationID: entry.integrationID,
+        reason: found ? "not_oauth" : "missing"
+      });
+      return McpOAuth.provider({ ...base, store: McpOAuth.memoryStore() });
+    }
+    const credentialID = found.id;
+    const methodID = found.value.methodID;
+    const fields = { credentialID, integrationID: entry.integrationID };
+    yield* Effect.logInfo("mcp oauth credential loaded", {
+      ...fields,
+      hasRefreshToken: Boolean(found.value.refresh),
+      hasClientInformation: Boolean(McpOAuth.clientFromCredential(found.value)),
+      expiresAt: found.value.expires,
+      expired: found.value.expires !== 0 && found.value.expires <= Date.now()
+    });
+    let presented = found.value.refresh;
+    const readOAuthCredential = async () => {
+      const stored = await run(credentials.get(credentialID));
+      return stored?.value.type === "oauth" ? stored.value : undefined;
+    };
+    return McpOAuth.provider({
+      ...base,
+      invalidate: async (scope) => {
+        if (scope === "verifier" || scope === "discovery") {
+          await run(Effect.logDebug("mcp oauth invalidation skipped", { ...fields, scope, reason: "not_credentials" }));
+          return;
+        }
+        const oauth = await readOAuthCredential();
+        if (!oauth || oauth.refresh !== presented) {
+          await run(Effect.logInfo("mcp oauth invalidation skipped", {
+            ...fields,
+            scope,
+            reason: oauth ? "token_rotated" : "credential_missing"
+          }));
+          return;
+        }
+        await run(Effect.logWarning("mcp oauth credential invalidation requested", { ...fields, scope }));
+        await run(credentials.remove(credentialID));
+      },
+      store: {
+        tokens: async () => {
+          const oauth = await readOAuthCredential();
+          if (!oauth)
+            return;
+          presented = oauth.refresh;
+          return McpOAuth.toTokens(oauth);
+        },
+        saveTokens: async (tokens) => {
+          const previous = await readOAuthCredential();
+          const value = McpOAuth.toCredential({
+            methodID,
+            serverUrl: remote.url,
+            tokens,
+            client: previous ? McpOAuth.clientFromCredential(previous) : undefined
+          });
+          presented = value.refresh;
+          await run(Effect.logInfo("mcp oauth tokens received", {
+            ...fields,
+            credentialPresent: Boolean(previous),
+            refreshRotated: Boolean(previous && previous.refresh !== value.refresh),
+            hasRefreshToken: Boolean(value.refresh),
+            expiresAt: value.expires
+          }));
+          await run(credentials.update(credentialID, { value }));
+        },
+        clientInformation: async () => {
+          const oauth = await readOAuthCredential();
+          return oauth ? McpOAuth.clientFromCredential(oauth) : undefined;
+        },
+        saveClientInformation: async () => {},
+        codeVerifier: async () => {
+          return;
+        },
+        saveCodeVerifier: async () => {}
+      }
+    });
+  });
+  const elicitation = {
+    create: (input) => Effect.gen(function* () {
+      if (input.params.mode === "url") {
+        const formID = ID18.create();
+        const key = input.server + "\x00" + input.params.elicitationId;
+        urlElicitations.set(key, formID);
+        return yield* forms.ask({
+          id: formID,
+          sessionID: GLOBAL_ELICITATION_SESSION_ID,
+          title: `${input.server} is requesting input`,
+          metadata: {
+            kind: "mcp-elicitation",
+            server: input.server,
+            elicitationID: input.params.elicitationId,
+            message: input.params.message
+          },
+          fields: [{ key: URL_ELICITATION_FIELD_KEY, type: "external", url: input.params.url }]
+        }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.ensuring(Effect.sync(() => urlElicitations.delete(key))), Effect.map((state) => ({
+          action: state.status === "answered" ? "accept" : "cancel"
+        })));
+      }
+      const params = input.params;
+      const [field, ...fields] = Object.entries(params.requestedSchema.properties).map(([key, property]) => toElicitationField(key, property, params.requestedSchema.required?.includes(key) === true));
+      if (!field)
+        return { action: "accept", content: {} };
+      return yield* forms.ask({
+        sessionID: GLOBAL_ELICITATION_SESSION_ID,
+        title: `${input.server} is requesting input`,
+        metadata: { kind: "mcp-elicitation", server: input.server, message: params.message },
+        fields: [field, ...fields]
+      }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.map((state) => {
+        if (state.status !== "answered")
+          return { action: "cancel" };
+        return {
+          action: "accept",
+          content: Object.fromEntries(Object.entries(state.answer).map(([key, value]) => typeof value === "object" ? [key, Array.from(value)] : [key, value]))
+        };
+      }));
+    }),
+    complete: (input) => Effect.gen(function* () {
+      const formID = urlElicitations.get(input.server + "\x00" + input.elicitationID);
+      if (!formID)
+        return;
+      yield* forms.reply({ id: formID, answer: { [URL_ELICITATION_FIELD_KEY]: true } }).pipe(Effect.ignore);
+    })
+  };
+  const toTool = (server, entry, def) => new Tool2({
+    server,
+    name: def.name,
+    codemode: entry.config.codemode,
+    description: def.description,
+    inputSchema: def.inputSchema,
+    outputSchema: def.outputSchema
+  });
+  const toPrompt = (server, def) => new Prompt2({
+    server,
+    name: def.name,
+    description: def.description,
+    arguments: def.arguments?.map((argument) => new PromptArgument2({
+      name: argument.name,
+      description: argument.description,
+      required: argument.required
+    }))
+  });
+  const toResource = (server, def) => Resource2.make({
+    server,
+    name: def.name,
+    uri: def.uri,
+    description: def.description,
+    mimeType: def.mimeType
+  });
+  const toResourceTemplate = (server, def) => ResourceTemplate2.make({
+    server,
+    name: def.name,
+    uriTemplate: def.uriTemplate,
+    description: def.description,
+    mimeType: def.mimeType
+  });
+  const refreshTools = (name, entry, connection) => connection.tools().pipe(Effect.map((defs) => {
+    entry.tools = defs.map((def) => toTool(name, entry, def));
+  }));
+  const refreshPrompts = (name, entry, connection) => connection.prompts().pipe(Effect.orElseSucceed(() => []), Effect.map((defs) => {
+    entry.prompts = defs.map((def) => toPrompt(name, def));
+  }), Effect.andThen(bus.publish(PromptsChanged2, { server: name })));
+  const whenLive = (name, entry, connection) => (effect) => fork(Effect.suspend(() => entry.client === connection ? effect : Effect.void).pipe(locks.withLock(name), Effect.ignore));
+  const watch = (name, entry, connection) => {
+    const live = whenLive(name, entry, connection);
+    connection.onClose(() => live(Effect.gen(function* () {
+      entry.status = { status: "failed", error: "Connection closed" };
+      yield* stopServer(name, entry);
+      yield* bus.publish(McpEvent.StatusChanged, { server: name });
+    })));
+    connection.onLog((message) => fork(serverLog(name, message)));
+    connection.onToolsChanged(() => live(refreshTools(name, entry, connection).pipe(Effect.andThen(bus.publish(McpEvent.ToolsChanged, { server: name })))));
+    connection.onPromptsChanged(() => live(refreshPrompts(name, entry, connection)));
+    connection.onResourcesChanged(() => live(bus.publish(McpEvent.ResourcesChanged, { server: name })));
+  };
+  const serverLog = (server, message) => {
+    const fields = { server, logger: message.logger, level: message.level, data: message.data };
+    switch (message.level) {
+      case "debug":
+        return Effect.logDebug("MCP server log", fields);
+      case "info":
+      case "notice":
+        return Effect.logInfo("MCP server log", fields);
+      case "warning":
+        return Effect.logWarning("MCP server log", fields);
+      case "error":
+      case "critical":
+      case "alert":
+      case "emergency":
+        return Effect.logError("MCP server log", fields);
+    }
+  };
+  const startServer = (name, entry) => Effect.gen(function* () {
+    entry.status = { status: "pending" };
+    yield* bus.publish(McpEvent.StatusChanged, { server: name });
+    const scope = yield* Scope.fork(root);
+    entry.scope = scope;
+    const authProvider = yield* connectProvider(entry);
+    const { McpClient } = yield* Effect.promise(() => import("../mcp/client.js"));
+    const result = yield* McpClient.connect(name, entry.config, location.directory, authProvider, elicitation, options?.clientInfo).pipe(Effect.flatMap((connection) => connection.tools().pipe(Effect.map((tools) => ({ connection, tools })))), Effect.provideService(Service65, environment), Scope.provide(scope), Effect.exit);
+    if (Exit.isSuccess(result)) {
+      entry.client = result.value.connection;
+      entry.tools = result.value.tools.map((def) => toTool(name, entry, def));
+      entry.prompts = [];
+      entry.status = { status: "connected" };
+      watch(name, entry, result.value.connection);
+      yield* Effect.logInfo("mcp connected", { server: name, tools: entry.tools.length });
+      yield* bus.publish(McpEvent.ToolsChanged, { server: name });
+      yield* bus.publish(McpEvent.ResourcesChanged, { server: name });
+      yield* bus.publish(McpEvent.StatusChanged, { server: name });
+      whenLive(name, entry, result.value.connection)(refreshPrompts(name, entry, result.value.connection));
+      return;
+    }
+    yield* Scope.close(scope, Exit.void);
+    entry.scope = undefined;
+    const error = Cause.squash(result.cause);
+    entry.status = error instanceof McpClient.NeedsAuthError ? { status: "needs_auth" } : { status: "failed", error: error instanceof Error ? error.message : String(error) };
+    yield* Effect.logWarning("mcp connect failed", { server: name, status: entry.status });
+    yield* bus.publish(McpEvent.StatusChanged, { server: name });
+  }).pipe(Effect.ensuring(entry.startup.open), Effect.annotateLogs({ server: name, directory: location.directory, connectionID: crypto.randomUUID() }));
+  const stopServer = Effect.fnUntraced(function* (name, entry) {
+    const scope = entry.scope;
+    if (!scope)
+      return;
+    entry.scope = undefined;
+    entry.client = undefined;
+    entry.tools = undefined;
+    entry.prompts = undefined;
+    yield* Scope.close(scope, Exit.void);
+    yield* bus.publish(McpEvent.ToolsChanged, { server: name });
+    yield* bus.publish(McpEvent.ResourcesChanged, { server: name });
+    yield* bus.publish(PromptsChanged2, { server: name });
+  });
+  const disposeServer = Effect.fnUntraced(function* (name, entry) {
+    yield* stopServer(name, entry);
+    if (entry.integrationID)
+      owned.delete(entry.integrationID);
+    if (entry.registration)
+      yield* entry.registration.dispose;
+  });
+  const replaceServer = Effect.fnUntraced(function* (name, serverConfig) {
+    const previous = entries.get(name);
+    if (previous)
+      yield* disposeServer(name, previous);
+    const entry = {
+      config: serverConfig,
+      status: { status: "pending" },
+      startup: Latch.makeUnsafe()
+    };
+    entries.set(name, entry);
+    yield* Effect.gen(function* () {
+      yield* register(name, entry);
+      if (serverConfig.disabled) {
+        entry.status = { status: "disabled" };
+        yield* bus.publish(McpEvent.StatusChanged, { server: name });
+        return;
+      }
+      yield* startServer(name, entry);
+    }).pipe(Effect.ensuring(entry.startup.open));
+  });
+  const removeServer = Effect.fnUntraced(function* (name) {
+    const entry = entries.get(name);
+    if (!entry)
+      return;
+    yield* disposeServer(name, entry);
+    entries.delete(name);
+    yield* bus.publish(McpEvent.StatusChanged, { server: name });
+  });
+  let applied;
+  const overrides = new Map;
+  const reconcileLock = Semaphore.makeUnsafe(1);
+  const reconcile = Effect.fnUntraced(function* () {
+    const servers = state.get().servers;
+    if (!applied && entries.size === 0) {
+      for (const [name, server] of servers) {
+        entries.set(name, {
+          config: server,
+          status: { status: "pending" },
+          startup: Latch.makeUnsafe()
+        });
+      }
+      yield* Effect.forEach(entries, ([name, entry]) => register(name, entry), { discard: true });
+      applied = servers;
+      for (const [name, entry] of entries) {
+        if (entry.config.disabled) {
+          entry.status = { status: "disabled" };
+          entry.startup.openUnsafe();
+          yield* bus.publish(McpEvent.StatusChanged, { server: name });
+          continue;
+        }
+        fork(startServer(name, entry).pipe(locks.withLock(name)));
+      }
+      return;
+    }
+    const names = new Set([...applied?.keys() ?? [], ...servers.keys()]);
+    for (const name of names) {
+      const previous = applied?.get(name);
+      const updated = servers.get(name);
+      if (isDeepStrictEqual(previous, updated))
+        continue;
+      if (!updated) {
+        yield* removeServer(name).pipe(locks.withLock(name));
+        continue;
+      }
+      yield* replaceServer(name, updated).pipe(locks.withLock(name));
+    }
+    applied = servers;
+  });
+  const reconnect = (integrationID) => Effect.gen(function* () {
+    const match = Array.from(entries).find(([, entry]) => entry.integrationID === integrationID);
+    if (!match)
+      return;
+    const name = match[0];
+    yield* Effect.gen(function* () {
+      const entry = entries.get(name);
+      if (!entry || entry.integrationID !== integrationID)
+        return;
+      if (entry.status.status === "disabled")
+        return;
+      yield* stopServer(name, entry);
+      yield* startServer(name, entry);
+    }).pipe(locks.withLock(name));
+  });
+  fork(bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => owned.has(event.data.integrationID)), Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID))))));
+  const state = create3({
+    name: "mcp",
+    initial: () => ({
+      servers: new Map(Array.from(overrides).flatMap(([name, config]) => config === false ? [] : [[name, cloneConfig(config)]])),
+      removed: new Set(Array.from(overrides).flatMap(([name, config]) => config === false ? [name] : []))
+    }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.servers),
+      get: (server) => editor.servers.get(ServerName2.make(server)),
+      set: (server, serverConfig) => {
+        const name = ServerName2.make(server);
+        if (editor.removed.has(name))
+          return;
+        editor.servers.set(name, cloneConfig(serverConfig));
+      },
+      update: (server, update) => {
+        const current = editor.servers.get(ServerName2.make(server));
+        if (!current)
+          return;
+        update(current);
+      },
+      remove: (server) => editor.servers.delete(ServerName2.make(server))
+    }),
+    notify: () => reconcile2(root, fork, () => reconcileLock.withPermit(reconcile()))
+  });
+  const whenAllReady = Effect.suspend(() => Effect.forEach(Array.from(entries.values()), (entry) => entry.startup.await, {
+    concurrency: "unbounded",
+    discard: true
+  }));
+  return Service31.of({
+    transform: state.transform,
+    reload: state.reload,
+    servers: Effect.fn("MCP.servers")(function* () {
+      return Array.from(entries).toSorted(([a], [b]) => a.localeCompare(b)).map(([name, entry]) => new ServerInfo2({ name, status: entry.status, integrationID: entry.integrationID }));
+    }),
+    add: Effect.fn("MCP.add")(function* (server, config) {
+      const name = ServerName2.make(server);
+      overrides.set(name, config);
+      yield* state.reload();
+    }),
+    connect: Effect.fn("MCP.connect")(function* (server) {
+      const name = ServerName2.make(server);
+      yield* Effect.gen(function* () {
+        const target = yield* requireServer(name);
+        yield* stopServer(name, target.entry);
+        yield* startServer(name, target.entry);
+      }).pipe(locks.withLock(name));
+    }),
+    disconnect: Effect.fn("MCP.disconnect")(function* (server) {
+      const name = ServerName2.make(server);
+      yield* Effect.gen(function* () {
+        const target = yield* requireServer(name);
+        yield* stopServer(name, target.entry);
+        target.entry.status = { status: "disabled" };
+        yield* bus.publish(McpEvent.StatusChanged, { server: name });
+      }).pipe(locks.withLock(name));
+    }),
+    remove: Effect.fn("MCP.remove")(function* (server) {
+      const name = ServerName2.make(server);
+      yield* requireServer(name);
+      overrides.set(name, false);
+      yield* state.reload();
+    }),
+    tools: Effect.fn("MCP.tools")(function* () {
+      yield* whenAllReady;
+      return Array.from(entries.values()).flatMap((entry) => entry.tools ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
+    }),
+    callTool: Effect.fn("MCP.callTool")(function* (input) {
+      const target = yield* requireServer(input.server);
+      yield* target.entry.startup.await;
+      if (!target.entry.client)
+        return yield* new ToolCallError2({
+          server: target.name,
+          tool: input.name,
+          message: "MCP server is not connected"
+        });
+      const result = yield* target.entry.client.callTool({ name: input.name, args: input.args, sessionID: input.sessionID }).pipe(Effect.mapError((error) => new ToolCallError2({ server: target.name, tool: input.name, message: error.message })));
+      return new ToolResult2({
+        server: target.name,
+        tool: input.name,
+        isError: result.isError,
+        structured: result.structured,
+        content: result.content
+      });
+    }),
+    instructions: Effect.fn("MCP.instructions")(function* () {
+      yield* whenAllReady;
+      return Array.from(entries).flatMap(([server, entry]) => {
+        const instructions = entry.client?.instructions;
+        if (!instructions)
+          return [];
+        return [new ServerInstructions2({ server, instructions })];
+      }).toSorted((a, b) => a.server.localeCompare(b.server));
+    }),
+    prompts: Effect.fn("MCP.prompts")(function* () {
+      return Array.from(entries.values()).flatMap((entry) => entry.prompts ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
+    }),
+    prompt: Effect.fn("MCP.prompt")(function* (input) {
+      const target = yield* requireServer(input.server);
+      yield* target.entry.startup.await;
+      if (!target.entry.client)
+        return;
+      const result = yield* target.entry.client.prompt({ name: input.name, args: input.args }).pipe(Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (!result)
+        return;
+      return new PromptResult2({
+        server: target.name,
+        name: input.name,
+        messages: result.messages.map((message) => new PromptMessage2({ role: message.role, content: message.content }))
+      });
+    }),
+    resourceCatalog: Effect.fn("MCP.resourceCatalog")(function* () {
+      yield* whenAllReady;
+      const catalogs = yield* Effect.forEach(Array.from(entries), ([name, entry]) => {
+        if (!entry.client)
+          return Effect.succeed({ resources: [], templates: [] });
+        return Effect.all({
+          resources: entry.client.resources().pipe(Effect.orElseSucceed(() => [])),
+          templates: entry.client.resourceTemplates().pipe(Effect.orElseSucceed(() => []))
+        }, { concurrency: "unbounded" }).pipe(Effect.map((catalog) => ({
+          resources: catalog.resources.map((def) => toResource(name, def)),
+          templates: catalog.templates.map((def) => toResourceTemplate(name, def))
+        })));
+      }, { concurrency: "unbounded" });
+      return ResourceCatalog2.make({
+        resources: catalogs.flatMap((catalog) => catalog.resources).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name) || a.uri.localeCompare(b.uri)),
+        templates: catalogs.flatMap((catalog) => catalog.templates).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name) || a.uriTemplate.localeCompare(b.uriTemplate))
+      });
+    }),
+    readResource: Effect.fn("MCP.readResource")(function* (input) {
+      const target = yield* requireServer(input.server);
+      yield* target.entry.startup.await;
+      if (!target.entry.client)
+        return;
+      const result = yield* target.entry.client.readResource({ uri: input.uri }).pipe(Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (!result)
+        return;
+      return ResourceContent2.make({
+        server: target.name,
+        uri: input.uri,
+        contents: result.contents
+      });
+    })
+  });
+}));
+function configured5(options) {
+  return makeLocationNode({
+    service: Service31,
+    layer: layer13(options),
+    deps: [node70, node69, node83, node82, node78, node79]
+  });
+}
+var node36 = configured5();
+function toElicitationField(key, property, required) {
+  const machineTitle = /^(boolean|string|number|integer|array|object)(\s+with\b.*|\s+in\b.*)?$/i;
+  const title = property.title && !machineTitle.test(property.title.trim()) ? property.title : property.description ?? key;
+  const base = {
+    key,
+    title,
+    description: property.description === title ? undefined : property.description,
+    required: required || undefined
+  };
+  switch (property.type) {
+    case "boolean":
+      return { ...base, type: "boolean", default: property.default };
+    case "number":
+    case "integer":
+      return {
+        ...base,
+        type: property.type,
+        minimum: property.minimum,
+        maximum: property.maximum,
+        default: property.default
+      };
+    case "array":
+      return {
+        ...base,
+        type: "multiselect",
+        options: "anyOf" in property.items ? property.items.anyOf.map((option) => ({ value: option.const, label: option.title })) : property.items.enum.map((value) => ({ value, label: value })),
+        custom: false,
+        minItems: property.minItems,
+        maxItems: property.maxItems,
+        default: property.default
+      };
+    case "string": {
+      const options = "oneOf" in property ? property.oneOf.map((option) => ({ value: option.const, label: option.title })) : ("enum" in property) ? property.enum.map((value, index) => ({
+        value,
+        label: ("enumNames" in property ? property.enumNames?.[index] : undefined) ?? value
+      })) : undefined;
+      return {
+        ...base,
+        type: "string",
+        format: "format" in property ? property.format : undefined,
+        minLength: "minLength" in property ? property.minLength : undefined,
+        maxLength: "maxLength" in property ? property.maxLength : undefined,
+        default: property.default,
+        options,
+        custom: options ? false : undefined
+      };
+    }
+  }
+}
+
+export { ServerName2, PromptsChanged2, Status2, ServerInfo2, ServerInstructions2, Tool2, ToolResultContent2, ToolResult2, PromptArgument2, Prompt2, PromptMessage2, PromptResult2, Resource2, ResourceTemplate2, ResourceCatalog2, ResourceContentPart2, ResourceContent2, NotFoundError4, ToolCallError2, Service31, Options5, layer13, configured5, node36, exports_mcp4 };