@effect/ai 0.18.12 → 0.18.13

package/dist/cjs/McpServer.js

@@ -0,0 +1,708 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toolkit = exports.run = exports.resource = exports.registerToolkit = exports.registerResource = exports.registerPrompt = exports.prompt = exports.layerStdio = exports.layerHttp = exports.layer = exports.McpServer = void 0;
+var Headers = _interopRequireWildcard(require("@effect/platform/Headers"));
+var RpcClient = _interopRequireWildcard(require("@effect/rpc/RpcClient"));
+var RpcSerialization = _interopRequireWildcard(require("@effect/rpc/RpcSerialization"));
+var RpcServer = _interopRequireWildcard(require("@effect/rpc/RpcServer"));
+var Arr = _interopRequireWildcard(require("effect/Array"));
+var Cause = _interopRequireWildcard(require("effect/Cause"));
+var Context = _interopRequireWildcard(require("effect/Context"));
+var Effect = _interopRequireWildcard(require("effect/Effect"));
+var Exit = _interopRequireWildcard(require("effect/Exit"));
+var JsonSchema = _interopRequireWildcard(require("effect/JSONSchema"));
+var Layer = _interopRequireWildcard(require("effect/Layer"));
+var Logger = _interopRequireWildcard(require("effect/Logger"));
+var Mailbox = _interopRequireWildcard(require("effect/Mailbox"));
+var Option = _interopRequireWildcard(require("effect/Option"));
+var Schema = _interopRequireWildcard(require("effect/Schema"));
+var AST = _interopRequireWildcard(require("effect/SchemaAST"));
+var FindMyWay = _interopRequireWildcard(require("find-my-way-ts"));
+var AiTool = _interopRequireWildcard(require("./AiTool.js"));
+var _McpSchema = require("./McpSchema.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category McpServer
+ */
+class McpServer extends /*#__PURE__*/Context.Tag("@effect/ai/McpServer")() {
+  /**
+   * @since 1.0.0
+   */
+  static make = /*#__PURE__*/Effect.gen(function* () {
+    const matcher = makeUriMatcher();
+    const tools = Arr.empty();
+    const toolMap = new Map();
+    const resources = [];
+    const resourceTemplates = [];
+    const prompts = [];
+    const promptMap = new Map();
+    const completionsMap = new Map();
+    const notificationsMailbox = yield* Mailbox.make();
+    const listChangedHandles = new Map();
+    const notifications = yield* RpcClient.makeNoSerialization(_McpSchema.ServerNotificationRpcs, {
+      onFromClient(options) {
+        const message = options.message;
+        if (message._tag !== "Request") {
+          return Effect.void;
+        }
+        if (message.tag.includes("list_changed")) {
+          if (!listChangedHandles.has(message.tag)) {
+            listChangedHandles.set(message.tag, setTimeout(() => {
+              notificationsMailbox.unsafeOffer(message);
+              listChangedHandles.delete(message.tag);
+            }, 0));
+          }
+        } else {
+          notificationsMailbox.unsafeOffer(message);
+        }
+        return notifications.write({
+          clientId: 0,
+          requestId: message.id,
+          _tag: "Exit",
+          exit: Exit.void
+        });
+      }
+    });
+    return McpServer.of({
+      notifications: notifications.client,
+      notificationsMailbox,
+      get tools() {
+        return tools;
+      },
+      addTool: options => Effect.suspend(() => {
+        tools.push(options.tool);
+        toolMap.set(options.tool.name, options.handle);
+        return notifications.client["notifications/tools/list_changed"]({});
+      }),
+      callTool: request => Effect.suspend(() => {
+        const handle = toolMap.get(request.name);
+        if (!handle) {
+          return Effect.fail(new _McpSchema.InvalidParams({
+            message: `Tool '${request.name}' not found`
+          }));
+        }
+        return handle(request.arguments);
+      }),
+      get resources() {
+        return resources;
+      },
+      get resourceTemplates() {
+        return resourceTemplates;
+      },
+      addResource: (resource, effect) => Effect.suspend(() => {
+        resources.push(resource);
+        matcher.add(resource.uri, {
+          _tag: "Resource",
+          effect
+        });
+        return notifications.client["notifications/resources/list_changed"]({});
+      }),
+      addResourceTemplate: ({
+        completions,
+        handle,
+        routerPath,
+        template
+      }) => Effect.suspend(() => {
+        resourceTemplates.push(template);
+        matcher.add(routerPath, {
+          _tag: "ResourceTemplate",
+          handle
+        });
+        for (const [param, handle] of Object.entries(completions)) {
+          completionsMap.set(`ref/resource/${template.uriTemplate}/${param}`, handle);
+        }
+        return notifications.client["notifications/resources/list_changed"]({});
+      }),
+      findResource: uri => Effect.suspend(() => {
+        const match = matcher.find(uri);
+        if (!match) {
+          return Effect.succeed(new _McpSchema.ReadResourceResult({
+            contents: []
+          }));
+        } else if (match.handler._tag === "Resource") {
+          return match.handler.effect;
+        }
+        const params = [];
+        for (const key of Object.keys(match.params)) {
+          params[Number(key)] = match.params[key];
+        }
+        return match.handler.handle(uri, params);
+      }),
+      get prompts() {
+        return prompts;
+      },
+      addPrompt: options => Effect.suspend(() => {
+        prompts.push(options.prompt);
+        promptMap.set(options.prompt.name, options.handle);
+        for (const [param, handle] of Object.entries(options.completions)) {
+          completionsMap.set(`ref/prompt/${options.prompt.name}/${param}`, handle);
+        }
+        return notifications.client["notifications/prompts/list_changed"]({});
+      }),
+      getPromptResult: Effect.fnUntraced(function* ({
+        arguments: params,
+        name
+      }) {
+        const handler = promptMap.get(name);
+        if (!handler) {
+          return yield* new _McpSchema.InvalidParams({
+            message: `Prompt '${name}' not found`
+          });
+        }
+        return yield* handler(params ?? {});
+      }),
+      completion: Effect.fnUntraced(function* (complete) {
+        const ref = complete.ref;
+        const key = ref.type === "ref/resource" ? `ref/resource/${ref.uri}/${complete.argument.name}` : `ref/prompt/${ref.name}/${complete.argument.name}`;
+        const handler = completionsMap.get(key);
+        return handler ? yield* handler(complete.argument.value) : _McpSchema.CompleteResult.empty;
+      })
+    });
+  });
+  /**
+   * @since 1.0.0
+   */
+  static layer = /*#__PURE__*/Layer.scoped(McpServer, McpServer.make);
+}
+exports.McpServer = McpServer;
+const LATEST_PROTOCOL_VERSION = "2025-03-26";
+const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2024-11-05", "2024-10-07"];
+/**
+ * @since 1.0.0
+ * @category Constructors
+ */
+const run = exports.run = /*#__PURE__*/Effect.fnUntraced(function* (options) {
+  const protocol = yield* RpcServer.Protocol;
+  const handlers = yield* Layer.build(layerHandlers(options));
+  const server = yield* McpServer;
+  const patchedProtocol = RpcServer.Protocol.of({
+    ...protocol,
+    run: f => protocol.run((clientId, request) => {
+      if (request._tag === "Request" && request.tag.startsWith("notifications/")) {
+        if (request.tag === "notifications/cancelled") {
+          return f(clientId, {
+            _tag: "Interrupt",
+            requestId: String(request.payload.requestId)
+          });
+        }
+        const handler = handlers.unsafeMap.get(request.tag);
+        return handler ? handler.handler(request.payload, Headers.fromInput(request.headers)) : Effect.void;
+      }
+      return f(clientId, request);
+    })
+  });
+  const encodeNotification = Schema.encode(Schema.Union(...Array.from(_McpSchema.ServerNotificationRpcs.requests.values(), rpc => rpc.payloadSchema)));
+  yield* server.notificationsMailbox.take.pipe(Effect.flatMap(Effect.fnUntraced(function* (request) {
+    const encoded = yield* encodeNotification(request.payload);
+    const message = {
+      _tag: "Request",
+      tag: request.tag,
+      payload: encoded
+    };
+    const clientIds = yield* patchedProtocol.clientIds;
+    for (const clientId of clientIds) {
+      yield* patchedProtocol.send(clientId, message);
+    }
+  })), Effect.catchAllCause(() => Effect.void), Effect.forever, Effect.forkScoped);
+  return yield* RpcServer.make(_McpSchema.ClientRpcs, {
+    spanPrefix: "McpServer",
+    disableFatalDefects: true
+  }).pipe(Effect.provideService(RpcServer.Protocol, patchedProtocol), Effect.provide(handlers));
+}, Effect.scoped);
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+const layer = options => Layer.scopedDiscard(Effect.forkScoped(run(options))).pipe(Layer.provideMerge(McpServer.layer));
+/**
+ * Run the McpServer, using stdio for input and output.
+ *
+ * ```ts
+ * import { McpSchema, McpServer } from "@effect/ai"
+ * import { NodeRuntime, NodeSink, NodeStream } from "@effect/platform-node"
+ * import { Effect, Layer, Logger, Schema } from "effect"
+ *
+ * const idParam = McpSchema.param("id", Schema.NumberFromString)
+ *
+ * // Define a resource template for a README file
+ * const ReadmeTemplate = McpServer.resource`file://readme/${idParam}`({
+ *   name: "README Template",
+ *   // You can add auto-completion for the ID parameter
+ *   completion: {
+ *     id: (_) => Effect.succeed([1, 2, 3, 4, 5])
+ *   },
+ *   content: Effect.fn(function*(_uri, id) {
+ *     return `# MCP Server Demo - ID: ${id}`
+ *   })
+ * })
+ *
+ * // Define a test prompt with parameters
+ * const TestPrompt = McpServer.prompt({
+ *   name: "Test Prompt",
+ *   description: "A test prompt to demonstrate MCP server capabilities",
+ *   parameters: Schema.Struct({
+ *     flightNumber: Schema.String
+ *   }),
+ *   completion: {
+ *     flightNumber: () => Effect.succeed(["FL123", "FL456", "FL789"])
+ *   },
+ *   content: ({ flightNumber }) => Effect.succeed(`Get the booking details for flight number: ${flightNumber}`)
+ * })
+ *
+ * // Merge all the resources and prompts into a single server layer
+ * const ServerLayer = Layer.mergeAll(
+ *   ReadmeTemplate,
+ *   TestPrompt
+ * ).pipe(
+ *   // Provide the MCP server implementation
+ *   Layer.provide(McpServer.layerStdio({
+ *     name: "Demo Server",
+ *     version: "1.0.0",
+ *     stdin: NodeStream.stdin,
+ *     stdout: NodeSink.stdout
+ *   })),
+ *   // add a stderr logger
+ *   Layer.provide(Logger.add(Logger.prettyLogger({ stderr: true })))
+ * )
+ *
+ * Layer.launch(ServerLayer).pipe(NodeRuntime.runMain)
+ * ```
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+exports.layer = layer;
+const layerStdio = options => layer(options).pipe(Layer.provide(RpcServer.layerProtocolStdio({
+  stdin: options.stdin,
+  stdout: options.stdout
+})), Layer.provide(RpcSerialization.layerNdJsonRpc()),
+// remove stdout loggers
+Layer.provideMerge(Logger.remove(Logger.defaultLogger)), Layer.provideMerge(Logger.remove(Logger.prettyLoggerDefault)));
+/**
+ * Run the McpServer, using HTTP for input and output.
+ *
+ * ```ts
+ * import { McpSchema, McpServer } from "@effect/ai"
+ * import { HttpRouter } from "@effect/platform"
+ * import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
+ * import { Effect, Layer, Schema } from "effect"
+ * import { createServer } from "node:http"
+ *
+ * const idParam = McpSchema.param("id", Schema.NumberFromString)
+ *
+ * // Define a resource template for a README file
+ * const ReadmeTemplate = McpServer.resource`file://readme/${idParam}`({
+ *   name: "README Template",
+ *   // You can add auto-completion for the ID parameter
+ *   completion: {
+ *     id: (_) => Effect.succeed([1, 2, 3, 4, 5])
+ *   },
+ *   content: Effect.fn(function*(_uri, id) {
+ *     return `# MCP Server Demo - ID: ${id}`
+ *   })
+ * })
+ *
+ * // Define a test prompt with parameters
+ * const TestPrompt = McpServer.prompt({
+ *   name: "Test Prompt",
+ *   description: "A test prompt to demonstrate MCP server capabilities",
+ *   parameters: Schema.Struct({
+ *     flightNumber: Schema.String
+ *   }),
+ *   completion: {
+ *     flightNumber: () => Effect.succeed(["FL123", "FL456", "FL789"])
+ *   },
+ *   content: ({ flightNumber }) => Effect.succeed(`Get the booking details for flight number: ${flightNumber}`)
+ * })
+ *
+ * // Merge all the resources and prompts into a single server layer
+ * const ServerLayer = Layer.mergeAll(
+ *   ReadmeTemplate,
+ *   TestPrompt,
+ *   HttpRouter.Default.serve()
+ * ).pipe(
+ *   // Provide the MCP server implementation
+ *   Layer.provide(McpServer.layerHttp({
+ *     name: "Demo Server",
+ *     version: "1.0.0",
+ *     path: "/mcp"
+ *   })),
+ *   Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 }))
+ * )
+ *
+ * Layer.launch(ServerLayer).pipe(NodeRuntime.runMain)
+ * ```
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+exports.layerStdio = layerStdio;
+const layerHttp = options => layer(options).pipe(Layer.provide(RpcServer.layerProtocolHttp(options)), Layer.provide(RpcSerialization.layerJsonRpc()));
+/**
+ * Register an AiToolkit with the McpServer.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+exports.layerHttp = layerHttp;
+const registerToolkit = exports.registerToolkit = /*#__PURE__*/Effect.fnUntraced(function* (toolkit) {
+  const registry = yield* McpServer;
+  const built = yield* toolkit;
+  const context = yield* Effect.context();
+  for (const tool of built.tools) {
+    const mcpTool = new _McpSchema.Tool({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: makeJsonSchema(tool.parametersSchema.ast),
+      annotations: new _McpSchema.ToolAnnotations({
+        ...Context.getOption(tool.annotations, AiTool.Title).pipe(Option.map(title => ({
+          title
+        })), Option.getOrUndefined),
+        readOnlyHint: Context.get(tool.annotations, AiTool.Readonly),
+        destructiveHint: Context.get(tool.annotations, AiTool.Destructive),
+        idempotentHint: Context.get(tool.annotations, AiTool.Idempotent),
+        openWorldHint: Context.get(tool.annotations, AiTool.OpenWorld)
+      })
+    });
+    yield* registry.addTool({
+      tool: mcpTool,
+      handle(payload) {
+        return built.handle(tool.name, payload).pipe(Effect.provide(context), Effect.match({
+          onFailure: error => new _McpSchema.CallToolResult({
+            isError: true,
+            content: [new _McpSchema.TextContent({
+              text: JSON.stringify(error)
+            })]
+          }),
+          onSuccess: result => new _McpSchema.CallToolResult({
+            isError: false,
+            content: [new _McpSchema.TextContent({
+              text: JSON.stringify(result.encodedResult)
+            })]
+          })
+        }));
+      }
+    });
+  }
+});
+/**
+ * Register an AiToolkit with the McpServer.
+ *
+ * @since 1.0.0
+ * @category Tools
+ */
+const toolkit = toolkit => Layer.effectDiscard(registerToolkit(toolkit));
+/**
+ * Register a resource with the McpServer.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+exports.toolkit = toolkit;
+const registerResource = function () {
+  if (arguments.length === 1) {
+    const options = arguments[0];
+    return Effect.gen(function* () {
+      const context = yield* Effect.context();
+      const registry = yield* McpServer;
+      yield* registry.addResource(new _McpSchema.Resource({
+        ...options,
+        annotations: new _McpSchema.Annotations(options)
+      }), options.content.pipe(Effect.provide(context), Effect.map(content => resolveResourceContent(options.uri, content)), Effect.catchAllCause(cause => {
+        const prettyError = Cause.prettyErrors(cause)[0];
+        return new _McpSchema.InternalError({
+          message: prettyError.message
+        });
+      })));
+    });
+  }
+  const {
+    params,
+    routerPath,
+    schema,
+    uriPath
+  } = compileUriTemplate(...arguments);
+  return Effect.fnUntraced(function* (options) {
+    const context = yield* Effect.context();
+    const registry = yield* McpServer;
+    const decode = Schema.decodeUnknown(schema);
+    const template = new _McpSchema.ResourceTemplate({
+      ...options,
+      uriTemplate: uriPath,
+      annotations: new _McpSchema.Annotations(options)
+    });
+    const completions = {};
+    for (const [param, handle] of Object.entries(options.completion ?? {})) {
+      const encodeArray = Schema.encodeUnknown(Schema.Array(params[param]));
+      const handler = input => handle(input).pipe(Effect.flatMap(encodeArray), Effect.map(values => new _McpSchema.CompleteResult({
+        completion: {
+          values: values,
+          total: values.length,
+          hasMore: false
+        }
+      })), Effect.catchAllCause(cause => {
+        const prettyError = Cause.prettyErrors(cause)[0];
+        return new _McpSchema.InternalError({
+          message: prettyError.message
+        });
+      }), Effect.provide(context));
+      completions[param] = handler;
+    }
+    yield* registry.addResourceTemplate({
+      template,
+      routerPath,
+      completions,
+      handle: (uri, params) => decode(params).pipe(Effect.mapError(error => new _McpSchema.InvalidParams({
+        message: error.message
+      })), Effect.flatMap(params => options.content(uri, ...params).pipe(Effect.map(content => resolveResourceContent(uri, content)), Effect.catchAllCause(cause => {
+        const prettyError = Cause.prettyErrors(cause)[0];
+        return new _McpSchema.InternalError({
+          message: prettyError.message
+        });
+      }))), Effect.provide(context))
+    });
+  });
+};
+/**
+ * Register a resource with the McpServer.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+exports.registerResource = registerResource;
+const resource = function () {
+  if (arguments.length === 1) {
+    return Layer.effectDiscard(registerResource(arguments[0]));
+  }
+  const register = registerResource(...arguments);
+  return options => Layer.effectDiscard(register(options));
+};
+/**
+ * Register a prompt with the McpServer.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+exports.resource = resource;
+const registerPrompt = options => {
+  const args = Arr.empty();
+  const props = {};
+  const propSignatures = options.parameters ? AST.getPropertySignatures(options.parameters.ast) : [];
+  for (const prop of propSignatures) {
+    args.push(new _McpSchema.PromptArgument({
+      name: prop.name,
+      description: Option.getOrUndefined(AST.getDescriptionAnnotation(prop)),
+      required: !prop.isOptional
+    }));
+    props[prop.name] = Schema.make(prop.type);
+  }
+  const prompt = new _McpSchema.Prompt({
+    name: options.name,
+    description: options.description,
+    arguments: args
+  });
+  const decode = options.parameters ? Schema.decodeUnknown(options.parameters) : () => Effect.succeed({});
+  const completion = options.completion ?? {};
+  return Effect.gen(function* () {
+    const registry = yield* McpServer;
+    const context = yield* Effect.context();
+    const completions = {};
+    for (const [param, handle] of Object.entries(completion)) {
+      const encodeArray = Schema.encodeUnknown(Schema.Array(props[param]));
+      const handler = input => handle(input).pipe(Effect.flatMap(encodeArray), Effect.map(values => new _McpSchema.CompleteResult({
+        completion: {
+          values: values,
+          total: values.length,
+          hasMore: false
+        }
+      })), Effect.catchAllCause(cause => {
+        const prettyError = Cause.prettyErrors(cause)[0];
+        return new _McpSchema.InternalError({
+          message: prettyError.message
+        });
+      }), Effect.provide(context));
+      completions[param] = handler;
+    }
+    yield* registry.addPrompt({
+      prompt,
+      completions,
+      handle: params => decode(params).pipe(Effect.mapError(error => new _McpSchema.InvalidParams({
+        message: error.message
+      })), Effect.flatMap(params => options.content(params)), Effect.map(messages => {
+        messages = typeof messages === "string" ? [new _McpSchema.PromptMessage({
+          role: "user",
+          content: new _McpSchema.TextContent({
+            text: messages
+          })
+        })] : messages;
+        return new _McpSchema.GetPromptResult({
+          messages,
+          description: prompt.description
+        });
+      }), Effect.catchAllCause(cause => {
+        const prettyError = Cause.prettyErrors(cause)[0];
+        return new _McpSchema.InternalError({
+          message: prettyError.message
+        });
+      }), Effect.provide(context))
+    });
+  });
+};
+/**
+ * Register a prompt with the McpServer.
+ *
+ * @since 1.0.0
+ * @category Resources
+ */
+exports.registerPrompt = registerPrompt;
+const prompt = options => Layer.effectDiscard(registerPrompt(options));
+// -----------------------------------------------------------------------------
+// Internal
+// -----------------------------------------------------------------------------
+exports.prompt = prompt;
+const makeUriMatcher = () => {
+  const router = FindMyWay.make({
+    ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: true,
+    caseSensitive: true
+  });
+  const add = (uri, value) => {
+    router.on("GET", uri, value);
+  };
+  const find = uri => router.find("GET", uri);
+  return {
+    add,
+    find
+  };
+};
+const compileUriTemplate = (segments, ...schemas) => {
+  let routerPath = segments[0].replace(":", "::");
+  let uriPath = segments[0];
+  const params = {};
+  let pathSchema = Schema.Tuple();
+  if (schemas.length > 0) {
+    const arr = [];
+    for (let i = 0; i < schemas.length; i++) {
+      const schema = schemas[i];
+      const key = String(i);
+      arr.push(schema);
+      routerPath += `:${key}${segments[i + 1].replace(":", "::")}`;
+      const paramName = AST.getAnnotation(_McpSchema.ParamAnnotation)(schema.ast).pipe(Option.getOrElse(() => `param${key}`));
+      params[paramName] = schema;
+      uriPath += `{${paramName}}`;
+    }
+    pathSchema = Schema.Tuple(...arr);
+  }
+  return {
+    routerPath,
+    uriPath,
+    schema: pathSchema,
+    params
+  };
+};
+const layerHandlers = serverInfo => _McpSchema.ClientRpcs.toLayer(Effect.gen(function* () {
+  const server = yield* McpServer;
+  return {
+    // Requests
+    ping: () => Effect.succeed({}),
+    initialize(params) {
+      const requestedVersion = params.protocolVersion;
+      const capabilities = {
+        completions: {}
+      };
+      if (server.tools.length > 0) {
+        capabilities.tools = {
+          listChanged: true
+        };
+      }
+      if (server.resources.length > 0 || server.resourceTemplates.length > 0) {
+        capabilities.resources = {
+          listChanged: true,
+          subscribe: false
+        };
+      }
+      if (server.prompts.length > 0) {
+        capabilities.prompts = {
+          listChanged: true
+        };
+      }
+      return Effect.succeed({
+        capabilities,
+        serverInfo,
+        protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION
+      });
+    },
+    "completion/complete": server.completion,
+    "logging/setLevel": () => _McpSchema.InternalError.notImplemented,
+    "prompts/get": server.getPromptResult,
+    "prompts/list": () => Effect.sync(() => new _McpSchema.ListPromptsResult({
+      prompts: server.prompts
+    })),
+    "resources/list": () => Effect.sync(() => new _McpSchema.ListResourcesResult({
+      resources: server.resources
+    })),
+    "resources/read": ({
+      uri
+    }) => server.findResource(uri),
+    "resources/subscribe": () => _McpSchema.InternalError.notImplemented,
+    "resources/unsubscribe": () => _McpSchema.InternalError.notImplemented,
+    "resources/templates/list": () => Effect.sync(() => new _McpSchema.ListResourceTemplatesResult({
+      resourceTemplates: server.resourceTemplates
+    })),
+    "tools/call": server.callTool,
+    "tools/list": () => Effect.sync(() => new _McpSchema.ListToolsResult({
+      tools: server.tools
+    })),
+    // Notifications
+    "notifications/cancelled": _ => Effect.void,
+    "notifications/initialized": _ => Effect.void,
+    "notifications/progress": _ => Effect.void,
+    "notifications/roots/list_changed": _ => Effect.void
+  };
+}));
+const makeJsonSchema = ast => {
+  const props = AST.getPropertySignatures(ast);
+  if (props.length === 0) {
+    return {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    };
+  }
+  const $defs = {};
+  const schema = JsonSchema.fromAST(ast, {
+    definitions: $defs,
+    topLevelReferenceStrategy: "skip"
+  });
+  if (Object.keys($defs).length === 0) return schema;
+  schema.$defs = $defs;
+  return schema;
+};
+const resolveResourceContent = (uri, content) => {
+  if (typeof content === "string") {
+    return new _McpSchema.ReadResourceResult({
+      contents: [new _McpSchema.TextResourceContents({
+        uri,
+        text: content
+      })]
+    });
+  } else if (content instanceof Uint8Array) {
+    return new _McpSchema.ReadResourceResult({
+      contents: [new _McpSchema.BlobResourceContents({
+        uri,
+        blob: content
+      })]
+    });
+  }
+  return content;
+};
+//# sourceMappingURL=McpServer.js.map