@caidazi/mcp 0.2.0

package/src/rest-client.js

@@ -0,0 +1,137 @@
+import { isAllowedTool } from "./allowed-tools.js";
+
+const DEFAULT_REGISTRY_PATH = "/api/tools/registered";
+const DEFAULT_CALL_PATH = "/api/tools/call";
+
+export class CaidaziRestClient {
+  constructor({
+    baseUrl,
+    apiKey,
+    fetchImpl = globalThis.fetch,
+    timeoutMs = 30000,
+    registryPath = DEFAULT_REGISTRY_PATH,
+    callPath = DEFAULT_CALL_PATH,
+  }) {
+    if (!baseUrl) {
+      throw new Error("baseUrl is required");
+    }
+    if (!apiKey) {
+      throw new Error("apiKey is required");
+    }
+    if (typeof fetchImpl !== "function") {
+      throw new Error("fetch implementation is required");
+    }
+
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = timeoutMs;
+    this.registryPath = registryPath;
+    this.callPath = callPath;
+  }
+
+  async listTools() {
+    const body = await this.request(this.registryPath, {
+      method: "GET",
+      headers: this.headers(),
+    });
+
+    if (!Array.isArray(body.tools)) {
+      throw new Error("Tool registry response did not include a tools array");
+    }
+
+    return body.tools.filter((tool) => isAllowedTool(tool.name));
+  }
+
+  async callTool(toolName, parameters = {}) {
+    if (!isAllowedTool(toolName)) {
+      throw new Error(`Tool ${toolName} is not exposed by @caidazi/mcp`);
+    }
+
+    const body = await this.request(this.callPath, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify({
+        tool_name: toolName,
+        parameters,
+      }),
+    });
+
+    if (body.success === false) {
+      throw new Error(body.error || `Tool ${toolName} failed`);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(body, "result")) {
+      return body.result;
+    }
+
+    return body;
+  }
+
+  headers(extra = {}) {
+    return {
+      Accept: "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...extra,
+    };
+  }
+
+  async request(path, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+
+    try {
+      const response = await this.fetchImpl(this.url(path), {
+        ...init,
+        signal: controller.signal,
+      });
+      const text = await response.text();
+      const body = parseResponseBody(text);
+
+      if (!response.ok) {
+        throw new Error(`Caidazi API request failed with HTTP ${response.status}: ${stringifyBody(body)}`);
+      }
+
+      return body;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(redactSecret(message, this.apiKey));
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  url(path) {
+    return `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+}
+
+export function redactSecret(text, apiKey) {
+  let redacted = String(text);
+
+  if (apiKey) {
+    redacted = redacted.split(apiKey).join("[REDACTED]");
+  }
+
+  return redacted.replace(/cdz_live_[A-Za-z0-9_-]+/g, "[REDACTED]");
+}
+
+function parseResponseBody(text) {
+  if (!text) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function stringifyBody(body) {
+  if (typeof body === "string") {
+    return body;
+  }
+
+  return JSON.stringify(body);
+}

package/src/tool-schema.js

@@ -0,0 +1,109 @@
+export function createMcpTool(toolInfo) {
+  return {
+    name: toolInfo.name,
+    description: toolInfo.description || toolInfo.name,
+    inputSchema: parseInputDetailToSchema(toolInfo.input_detail),
+  };
+}
+
+export function parseInputDetailToSchema(inputDetail) {
+  const properties = {};
+  const required = [];
+
+  for (const row of parseMarkdownRows(inputDetail)) {
+    const [rawName, rawType, rawRequired, rawDescription] = row;
+    const name = cleanCell(rawName).replace(/^`|`$/g, "");
+
+    if (!name || name === "参数" || /^-+$/.test(name)) {
+      continue;
+    }
+
+    properties[name] = {
+      ...typeToSchema(cleanCell(rawType)),
+      description: cleanCell(rawDescription),
+    };
+
+    if (isRequired(cleanCell(rawRequired))) {
+      required.push(name);
+    }
+  }
+
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: true,
+  };
+}
+
+export function resultToContent(result) {
+  if (typeof result === "string") {
+    return [{ type: "text", text: result }];
+  }
+
+  return [
+    {
+      type: "text",
+      text: JSON.stringify(result, null, 2),
+    },
+  ];
+}
+
+function parseMarkdownRows(inputDetail = "") {
+  return String(inputDetail)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("|") && line.endsWith("|"))
+    .map((line) =>
+      line
+        .slice(1, -1)
+        .split("|")
+        .map((cell) => cell.trim()),
+    )
+    .filter((cells) => cells.length >= 4 && !cells.every((cell) => /^-+$/.test(cell)));
+}
+
+function cleanCell(value = "") {
+  return String(value)
+    .replace(/<br\s*\/?>/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function isRequired(value) {
+  return /^(是|必填|required|true|yes)$/i.test(value);
+}
+
+function typeToSchema(type) {
+  const normalized = type.toLowerCase().replace(/\s+/g, "");
+
+  if (/^array\[(.+)\]$/.test(normalized)) {
+    const itemType = normalized.match(/^array\[(.+)\]$/)[1];
+    return {
+      type: "array",
+      items: typeToSchema(itemType),
+    };
+  }
+
+  if (["array", "list"].includes(normalized)) {
+    return { type: "array" };
+  }
+
+  if (["int", "integer"].includes(normalized)) {
+    return { type: "integer" };
+  }
+
+  if (["number", "float", "double"].includes(normalized)) {
+    return { type: "number" };
+  }
+
+  if (["bool", "boolean"].includes(normalized)) {
+    return { type: "boolean" };
+  }
+
+  if (["object", "dict", "map"].includes(normalized)) {
+    return { type: "object" };
+  }
+
+  return { type: "string" };
+}