genkitx-mcp/lib/client/tools.js

A Genkit plugin that provides interoperability between Genkit and Model Context Protocol (MCP). Both client and server use cases are supported.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};
var tools_exports = {};
__export(tools_exports, {
  registerAllTools: () => registerAllTools
});
module.exports = __toCommonJS(tools_exports);
var import_genkit = require("genkit");
var import_logging = require("genkit/logging");
const toText = (c) => c.map((p) => p.text || "").join("");
function processResult(result) {
  if (result.isError) return { error: toText(result.content) };
  if (result.content.every((c) => !!c.text)) {
    const text = toText(result.content);
    if (text.trim().startsWith("{") || text.trim().startsWith("[")) {
      try {
        return JSON.parse(text);
      } catch (e) {
        return text;
      }
    }
    return text;
  }
  if (result.content.length === 1) return result.content[0];
  return result;
}
function registerTool(ai, client, tool, params) {
  import_logging.logger.debug(
    `[@genkit-ai/mcp] Registering MCP tool ${params.name}/${tool.name}`
  );
  ai.defineTool(
    {
      name: `${params.name}/${tool.name}`,
      description: tool.description || "",
      inputJsonSchema: tool.inputSchema,
      outputSchema: import_genkit.z.any()
    },
    (args) => __async(this, null, function* () {
      import_logging.logger.debug(
        `[@genkit-ai/mcp] Calling MCP tool ${params.name}/${tool.name} with arguments`,
        JSON.stringify(args)
      );
      const result = yield client.callTool({
        name: tool.name,
        arguments: args
      });
      import_logging.logger.debug(
        `MCP tool ${tool.name} result:`,
        JSON.stringify(result, null, 2)
      );
      if (params.rawToolResponses) return result;
      return processResult(result);
    })
  );
}
function registerAllTools(ai, client, params) {
  return __async(this, null, function* () {
    let cursor;
    while (true) {
      const { nextCursor, tools } = yield client.listTools({ cursor });
      tools.forEach((t) => registerTool(ai, client, t, params));
      cursor = nextCursor;
      if (!cursor) break;
    }
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  registerAllTools
});
//# sourceMappingURL=tools.js.map