@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-kwh3ary7.js → event-logger-2mqy9ydc.js}

@@ -1,60 +1,70 @@
 import {
-  exports_integration
-} from "./schema-b9bp1awf.js";
+  makeUnsafe2
+} from "./event-logger-y71avatq.js";
 import {
-  exports_form
-} from "./schema-6bwmg5am.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_environment1 as exports_environment
-} from "./schema-qa1y9c59.js";
+  Event16,
+  Service69,
+  node74
+} from "./event-logger-3n6w8qeh.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_state
-} from "./schema-j6s3yjyb.js";
+  Service65,
+  node69
+} from "./event-logger-22drdanb.js";
 import {
-  exports_credential
-} from "./schema-jgzett5g.js";
+  ID12,
+  Service70,
+  node75
+} from "./event-logger-xy8v4fm7.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  reconcile2,
+  create3
+} from "./event-logger-kg06axw8.js";
 import {
-  exports_keyed_mutex
-} from "./schema-66mds5ht.js";
+  ID8,
+  MethodID2,
+  Service68,
+  node73
+} from "./event-logger-r3nfe89y.js";
 import {
-  __export,
-  __require
-} from "./schema-vpjkya7h.js";
+  __export
+} from "./event-logger-9rqn6x4v.js";
 
 // src/mcp/index.ts
-var exports_mcp = {};
-__export(exports_mcp, {
-  Mcp: () => exports_mcp,
-  NotFoundError: () => NotFoundError,
-  Options: () => Options,
-  Prompt: () => Prompt,
-  PromptArgument: () => PromptArgument,
-  PromptMessage: () => PromptMessage,
-  PromptResult: () => PromptResult,
-  PromptsChanged: () => PromptsChanged,
-  Resource: () => Resource,
-  ResourceCatalog: () => ResourceCatalog,
-  ResourceContent: () => ResourceContent,
-  ResourceContentPart: () => ResourceContentPart,
-  ResourceTemplate: () => ResourceTemplate,
-  ServerInfo: () => ServerInfo,
-  ServerInstructions: () => ServerInstructions,
-  ServerName: () => ServerName,
-  Service: () => Service,
-  Status: () => Status,
-  Tool: () => Tool,
-  ToolCallError: () => ToolCallError,
-  ToolResult: () => ToolResult,
-  ToolResultContent: () => ToolResultContent,
-  configured: () => configured,
-  layer: () => layer,
-  node: () => node
+var exports_mcp4 = {};
+__export(exports_mcp4, {
+  Mcp: () => exports_mcp4,
+  NotFoundError: () => NotFoundError3,
+  Options: () => Options4,
+  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: () => Service40,
+  Status: () => Status2,
+  Tool: () => Tool3,
+  ToolCallError: () => ToolCallError2,
+  ToolResult: () => ToolResult2,
+  ToolResultContent: () => ToolResultContent2,
+  configured: () => configured4,
+  layer: () => layer17,
+  node: () => node43
 });
 import { Mcp } from "@opencode-ai/schema/mcp";
 import { McpEvent } from "@opencode-ai/schema/mcp-event";
@@ -64,25 +74,25 @@ import { isDeepStrictEqual } from "node:util";
 import { Cause, Context, Effect, Exit, FiberSet, Latch, Layer, Schema, Scope, Semaphore, Stream } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { waitForAbort } from "@opencode-ai/util/process";
-var ServerName = Schema.String.pipe(Schema.brand("MCP.ServerName"));
-var PromptsChanged = ephemeral({ type: "mcp.prompts.changed", schema: { server: Schema.String } });
-var Status = Mcp.Status;
+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 ServerInfo extends Schema.Class("MCP.ServerInfo")({
-  name: ServerName,
-  status: Status,
-  integrationID: exports_integration.ID.pipe(Schema.optional)
+class ServerInfo2 extends Schema.Class("MCP.ServerInfo")({
+  name: ServerName2,
+  status: Status2,
+  integrationID: ID8.pipe(Schema.optional)
 }) {
 }
 
-class ServerInstructions extends Schema.Class("MCP.ServerInstructions")({
-  server: ServerName,
+class ServerInstructions2 extends Schema.Class("MCP.ServerInstructions")({
+  server: ServerName2,
   instructions: Schema.String
 }) {
 }
 
-class Tool extends Schema.Class("MCP.Tool")({
-  server: ServerName,
+class Tool3 extends Schema.Class("MCP.Tool")({
+  server: ServerName2,
   name: Schema.String,
   codemode: Schema.Boolean.pipe(Schema.optional),
   description: Schema.String.pipe(Schema.optional),
@@ -90,63 +100,63 @@ class Tool extends Schema.Class("MCP.Tool")({
   outputSchema: Schema.Unknown.pipe(Schema.optional)
 }) {
 }
-var ToolResultContent = Schema.Union([
+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 ToolResult extends Schema.Class("MCP.ToolResult")({
-  server: ServerName,
+class ToolResult2 extends Schema.Class("MCP.ToolResult")({
+  server: ServerName2,
   tool: Schema.String,
   isError: Schema.Boolean,
   structured: Schema.Unknown.pipe(Schema.optional),
-  content: Schema.Array(ToolResultContent)
+  content: Schema.Array(ToolResultContent2)
 }) {
 }
 
-class PromptArgument extends Schema.Class("MCP.PromptArgument")({
+class PromptArgument2 extends Schema.Class("MCP.PromptArgument")({
   name: Schema.String,
   description: Schema.String.pipe(Schema.optional),
   required: Schema.Boolean.pipe(Schema.optional)
 }) {
 }
 
-class Prompt extends Schema.Class("MCP.Prompt")({
-  server: ServerName,
+class Prompt2 extends Schema.Class("MCP.Prompt")({
+  server: ServerName2,
   name: Schema.String,
   description: Schema.String.pipe(Schema.optional),
-  arguments: Schema.Array(PromptArgument).pipe(Schema.optional)
+  arguments: Schema.Array(PromptArgument2).pipe(Schema.optional)
 }) {
 }
 
-class PromptMessage extends Schema.Class("MCP.PromptMessage")({
+class PromptMessage2 extends Schema.Class("MCP.PromptMessage")({
   role: Schema.String,
   content: Schema.Unknown
 }) {
 }
 
-class PromptResult extends Schema.Class("MCP.PromptResult")({
-  server: ServerName,
+class PromptResult2 extends Schema.Class("MCP.PromptResult")({
+  server: ServerName2,
   name: Schema.String,
-  messages: Schema.Array(PromptMessage)
+  messages: Schema.Array(PromptMessage2)
 }) {
 }
-var Resource = Mcp.Resource;
-var ResourceTemplate = Mcp.ResourceTemplate;
-var ResourceCatalog = Mcp.ResourceCatalog;
-var ResourceContentPart = Mcp.ResourceContentPart;
-var ResourceContent = Mcp.ResourceContent;
+var Resource2 = Mcp.Resource;
+var ResourceTemplate2 = Mcp.ResourceTemplate;
+var ResourceCatalog2 = Mcp.ResourceCatalog;
+var ResourceContentPart2 = Mcp.ResourceContentPart;
+var ResourceContent2 = Mcp.ResourceContent;
 
-class NotFoundError extends Schema.TaggedError()("MCP.NotFoundError", {
-  server: ServerName
+class NotFoundError3 extends Schema.TaggedError()("MCP.NotFoundError", {
+  server: ServerName2
 }) {
   get message() {
     return `MCP server not found: ${this.server}`;
   }
 }
 
-class ToolCallError extends Schema.TaggedError()("MCP.ToolCallError", {
-  server: ServerName,
+class ToolCallError2 extends Schema.TaggedError()("MCP.ToolCallError", {
+  server: ServerName2,
   tool: Schema.String,
   message: Schema.String
 }) {
@@ -155,25 +165,25 @@ var GLOBAL_ELICITATION_SESSION_ID = "global";
 var URL_ELICITATION_FIELD_KEY = "elicitation";
 var cloneConfig = (config) => structuredClone(config);
 
-class Service extends Context.Service()("@opencode/MCP") {
+class Service40 extends Context.Service()("@opencode/MCP") {
 }
-var Options = Schema.Struct({
+var Options4 = Schema.Struct({
   clientInfo: Schema.optional(Schema.Struct({
     name: Schema.String,
     version: Schema.String
   }))
 });
-var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
-  const location = yield* exports_location.Service;
-  const environment = yield* exports_environment.Service;
-  const bus = yield* exports_bus.Service;
-  const forms = yield* exports_form.Service;
-  const integration = yield* exports_integration.Service;
-  const credentials = yield* exports_credential.Service;
+var layer17 = (options) => Layer.effect(Service40, Effect.gen(function* () {
+  const location = yield* Service75;
+  const environment = yield* Service65;
+  const bus = yield* Service79;
+  const forms = yield* Service70;
+  const integration = yield* Service68;
+  const credentials = yield* Service69;
   const root = yield* Effect.scope;
   const fork = yield* FiberSet.makeRuntime();
   const entries = new Map;
-  const locks = exports_keyed_mutex.makeUnsafe();
+  const locks = makeUnsafe2();
   const urlElicitations = new Map;
   const owned = new Set;
   const register = Effect.fnUntraced(function* (name, entry) {
@@ -181,10 +191,10 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       return;
     const remote = entry.config;
     const suffix = "mcp_" + createHash("sha1").update(name + "\x00" + remote.url).digest("hex").slice(0, 16);
-    const integrationID = exports_integration.ID.make(suffix);
+    const integrationID = ID8.make(suffix);
     entry.integrationID = integrationID;
     owned.add(integrationID);
-    const methodID = exports_integration.MethodID.make(suffix);
+    const methodID = MethodID2.make(suffix);
     const scope = yield* Scope.fork(root);
     entry.registration = { dispose: Scope.close(scope, Exit.void) };
     yield* integration.transform((editor) => {
@@ -203,10 +213,10 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     }).pipe(Scope.provide(scope));
   });
   const requireServer = Effect.fnUntraced(function* (server) {
-    const name = ServerName.make(server);
+    const name = ServerName2.make(server);
     const entry = entries.get(name);
     if (!entry)
-      return yield* new NotFoundError({ server: name });
+      return yield* new NotFoundError3({ server: name });
     return { name, entry };
   });
   const connectProvider = Effect.fnUntraced(function* (entry) {
@@ -236,18 +246,18 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       invalidate: async (scope) => {
         if (scope === "verifier" || scope === "discovery")
           return;
-        const oauth2 = await readOAuthCredential();
-        if (!oauth2 || oauth2.refresh !== presented)
+        const oauth = await readOAuthCredential();
+        if (!oauth || oauth.refresh !== presented)
           return;
         await Effect.runPromise(credentials.remove(credentialID));
       },
       store: {
         tokens: async () => {
-          const oauth2 = await readOAuthCredential();
-          if (!oauth2)
+          const oauth = await readOAuthCredential();
+          if (!oauth)
             return;
-          presented = oauth2.refresh;
-          return McpOAuth.toTokens(oauth2);
+          presented = oauth.refresh;
+          return McpOAuth.toTokens(oauth);
         },
         saveTokens: async (tokens) => {
           const previous = await readOAuthCredential();
@@ -261,8 +271,8 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
           await Effect.runPromise(credentials.update(credentialID, { value }));
         },
         clientInformation: async () => {
-          const oauth2 = await readOAuthCredential();
-          return oauth2 ? McpOAuth.clientFromCredential(oauth2) : undefined;
+          const oauth = await readOAuthCredential();
+          return oauth ? McpOAuth.clientFromCredential(oauth) : undefined;
         },
         saveClientInformation: async () => {},
         codeVerifier: async () => {
@@ -275,7 +285,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
   const elicitation = {
     create: (input) => Effect.gen(function* () {
       if (input.params.mode === "url") {
-        const formID = exports_form.ID.create();
+        const formID = ID12.create();
         const key = input.server + "\x00" + input.params.elicitationId;
         urlElicitations.set(key, formID);
         return yield* forms.ask({
@@ -289,8 +299,8 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
             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((state2) => ({
-          action: state2.status === "answered" ? "accept" : "cancel"
+        }).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;
@@ -302,12 +312,12 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
         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((state2) => {
-        if (state2.status !== "answered")
+      }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.map((state) => {
+        if (state.status !== "answered")
           return { action: "cancel" };
         return {
           action: "accept",
-          content: Object.fromEntries(Object.entries(state2.answer).map(([key, value]) => typeof value === "object" ? [key, Array.from(value)] : [key, value]))
+          content: Object.fromEntries(Object.entries(state.answer).map(([key, value]) => typeof value === "object" ? [key, Array.from(value)] : [key, value]))
         };
       }));
     }),
@@ -318,7 +328,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       yield* forms.reply({ id: formID, answer: { [URL_ELICITATION_FIELD_KEY]: true } }).pipe(Effect.ignore);
     })
   };
-  const toTool = (server, entry, def) => new Tool({
+  const toTool = (server, entry, def) => new Tool3({
     server,
     name: def.name,
     codemode: entry.config.codemode,
@@ -326,24 +336,24 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     inputSchema: def.inputSchema,
     outputSchema: def.outputSchema
   });
-  const toPrompt = (server, def) => new Prompt({
+  const toPrompt = (server, def) => new Prompt2({
     server,
     name: def.name,
     description: def.description,
-    arguments: def.arguments?.map((argument) => new PromptArgument({
+    arguments: def.arguments?.map((argument) => new PromptArgument2({
       name: argument.name,
       description: argument.description,
       required: argument.required
     }))
   });
-  const toResource = (server, def) => Resource.make({
+  const toResource = (server, def) => Resource2.make({
     server,
     name: def.name,
     uri: def.uri,
     description: def.description,
     mimeType: def.mimeType
   });
-  const toResourceTemplate = (server, def) => ResourceTemplate.make({
+  const toResourceTemplate = (server, def) => ResourceTemplate2.make({
     server,
     name: def.name,
     uriTemplate: def.uriTemplate,
@@ -355,7 +365,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
   }));
   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(PromptsChanged, { server: name })));
+  }), 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);
@@ -393,7 +403,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     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(exports_environment.Service, environment), Scope.provide(scope), Effect.exit);
+    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));
@@ -425,7 +435,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     yield* Scope.close(scope, Exit.void);
     yield* bus.publish(McpEvent.ToolsChanged, { server: name });
     yield* bus.publish(McpEvent.ResourcesChanged, { server: name });
-    yield* bus.publish(PromptsChanged, { server: name });
+    yield* bus.publish(PromptsChanged2, { server: name });
   });
   const disposeServer = Effect.fnUntraced(function* (name, entry) {
     yield* stopServer(name, entry);
@@ -517,8 +527,8 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       yield* startServer(name, entry);
     }).pipe(locks.withLock(name));
   });
-  fork(bus.subscribe(exports_credential.Event.Switched).pipe(Stream.filter((event) => owned.has(event.data.integrationID)), Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID))))));
-  const state = exports_state.create({
+  fork(bus.subscribe(Event16.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)]])),
@@ -526,40 +536,40 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     }),
     editor: (editor) => ({
       list: () => Array.from(editor.servers),
-      get: (server) => editor.servers.get(ServerName.make(server)),
+      get: (server) => editor.servers.get(ServerName2.make(server)),
       set: (server, serverConfig) => {
-        const name = ServerName.make(server);
+        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(ServerName.make(server));
+        const current = editor.servers.get(ServerName2.make(server));
         if (!current)
           return;
         update(current);
       },
-      remove: (server) => editor.servers.delete(ServerName.make(server))
+      remove: (server) => editor.servers.delete(ServerName2.make(server))
     }),
-    notify: () => exports_state.reconcile(root, fork, () => reconcileLock.withPermit(reconcile()))
+    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 Service.of({
+  return Service40.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 ServerInfo({ name, status: entry.status, integrationID: entry.integrationID }));
+      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 = ServerName.make(server);
+      const name = ServerName2.make(server);
       overrides.set(name, config);
       yield* state.reload();
     }),
     connect: Effect.fn("MCP.connect")(function* (server) {
-      const name = ServerName.make(server);
+      const name = ServerName2.make(server);
       yield* Effect.gen(function* () {
         const target = yield* requireServer(name);
         yield* stopServer(name, target.entry);
@@ -567,7 +577,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       }).pipe(locks.withLock(name));
     }),
     disconnect: Effect.fn("MCP.disconnect")(function* (server) {
-      const name = ServerName.make(server);
+      const name = ServerName2.make(server);
       yield* Effect.gen(function* () {
         const target = yield* requireServer(name);
         yield* stopServer(name, target.entry);
@@ -576,7 +586,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       }).pipe(locks.withLock(name));
     }),
     remove: Effect.fn("MCP.remove")(function* (server) {
-      const name = ServerName.make(server);
+      const name = ServerName2.make(server);
       yield* requireServer(name);
       overrides.set(name, false);
       yield* state.reload();
@@ -589,13 +599,13 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       const target = yield* requireServer(input.server);
       yield* target.entry.startup.await;
       if (!target.entry.client)
-        return yield* new ToolCallError({
+        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 ToolCallError({ server: target.name, tool: input.name, message: error.message })));
-      return new ToolResult({
+      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,
@@ -609,7 +619,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
         const instructions = entry.client?.instructions;
         if (!instructions)
           return [];
-        return [new ServerInstructions({ server, instructions })];
+        return [new ServerInstructions2({ server, instructions })];
       }).toSorted((a, b) => a.server.localeCompare(b.server));
     }),
     prompts: Effect.fn("MCP.prompts")(function* () {
@@ -625,10 +635,10 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       }));
       if (!result)
         return;
-      return new PromptResult({
+      return new PromptResult2({
         server: target.name,
         name: input.name,
-        messages: result.messages.map((message) => new PromptMessage({ role: message.role, content: message.content }))
+        messages: result.messages.map((message) => new PromptMessage2({ role: message.role, content: message.content }))
       });
     }),
     resourceCatalog: Effect.fn("MCP.resourceCatalog")(function* () {
@@ -644,7 +654,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
           templates: catalog.templates.map((def) => toResourceTemplate(name, def))
         })));
       }, { concurrency: "unbounded" });
-      return ResourceCatalog.make({
+      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))
       });
@@ -659,7 +669,7 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
       }));
       if (!result)
         return;
-      return ResourceContent.make({
+      return ResourceContent2.make({
         server: target.name,
         uri: input.uri,
         contents: result.contents
@@ -667,14 +677,14 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     })
   });
 }));
-function configured(options) {
+function configured4(options) {
   return makeLocationNode({
-    service: Service,
-    layer: layer(options),
-    deps: [exports_location.node, exports_environment.node, exports_bus.node, exports_form.node, exports_integration.node, exports_credential.node]
+    service: Service40,
+    layer: layer17(options),
+    deps: [node80, node69, node84, node75, node73, node74]
   });
 }
-var node = configured();
+var node43 = configured4();
 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;
@@ -725,4 +735,4 @@ function toElicitationField(key, property, required) {
   }
 }
 
-export { ServerName, PromptsChanged, Status, ServerInfo, ServerInstructions, Tool, ToolResultContent, ToolResult, PromptArgument, Prompt, PromptMessage, PromptResult, Resource, ResourceTemplate, ResourceCatalog, ResourceContentPart, ResourceContent, NotFoundError, ToolCallError, Service, Options, layer, configured, node, exports_mcp };
+export { ServerName2, PromptsChanged2, Status2, ServerInfo2, ServerInstructions2, Tool3, ToolResultContent2, ToolResult2, PromptArgument2, Prompt2, PromptMessage2, PromptResult2, Resource2, ResourceTemplate2, ResourceCatalog2, ResourceContentPart2, ResourceContent2, NotFoundError3, ToolCallError2, Service40, Options4, layer17, configured4, node43, exports_mcp4 };