@mcpbr/core/dist/index.cjs

Core functions for mcpbr

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  mcpServerFactory: () => mcpServerFactory,
  toJsonSchema: () => toJsonSchema
});
module.exports = __toCommonJS(index_exports);

// src/mcp-server.ts
var import_server = require("@modelcontextprotocol/sdk/server/index.js");
var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
var import_types = require("@modelcontextprotocol/sdk/types.js");
var import_tinyrainbow = __toESM(require("tinyrainbow"), 1);
var import_zod = require("zod");
function mcpServerFactory(meta, params) {
  let server;
  function make(tools) {
    server = new import_server.Server(
      {
        name: meta.name,
        version: meta.version
      },
      {
        capabilities: {
          tools: {}
        }
      }
    );
    server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
      try {
        const tool = tools.find((tool2) => tool2.definition.name === request.params.name);
        if (!tool) {
          throw new Error(`Unknown tool: ${request.params.name}`);
        }
        return tool.handler(params, request.params.arguments ?? {});
      } catch (error) {
        console.log(error);
        if (error instanceof import_zod.z.ZodError) {
          throw new Error(`Invalid input: ${JSON.stringify(error.errors)}`);
        }
        return {
          content: [
            {
              type: "text",
              text: `Error: ${error instanceof Error ? error.message : String(error)}`
            }
          ],
          isError: true
        };
      }
    });
  }
  function start() {
    if (!server) {
      throw new Error("Server not initialized call make first");
    }
    async function runServer() {
      const transport = new import_stdio.StdioServerTransport();
      await server.connect(transport);
      console.error(import_tinyrainbow.default.green(`\u2705 ${meta.name} running on stdio`));
    }
    runServer().catch((error) => {
      console.error(import_tinyrainbow.default.red(`
\u{1F6A8}  Error initializing ${meta.name} MCP server:
`));
      console.error(import_tinyrainbow.default.yellow(`   ${error.message}
`));
    });
  }
  return { make, start };
}

// src/zod-schema.ts
var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"), 1);
function toJsonSchema(schema) {
  return (0, import_zod_to_json_schema.default)(schema, { target: "jsonSchema7" });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  mcpServerFactory,
  toJsonSchema
});
//# sourceMappingURL=index.cjs.map