@kolmopdf/mcp-server 1.0.0

package/packages/mcp-server/dist/index.cjs

@@ -0,0 +1,1004 @@
+#!/usr/bin/env node
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createServer: () => createServer,
+  jsonResult: () => jsonResult
+});
+module.exports = __toCommonJS(index_exports);
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/client.ts
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
+
+// src/errors.ts
+var ERROR_SPECS = {
+  // --- API codes ---
+  invalid_api_key: {
+    message: "API key is missing or invalid.",
+    remediation: "Create a key at https://www.kolmopdf.com/api-keys (requires Plus/Pro).",
+    httpStatus: 401,
+    source: "api"
+  },
+  insufficient_points: {
+    message: "Not enough credits.",
+    remediation: "Top up at https://www.kolmopdf.com/subscription.",
+    httpStatus: 402,
+    source: "api"
+  },
+  points_deduction_failed: {
+    message: "Credit deduction failed.",
+    remediation: "Retry; if it persists contact support.",
+    httpStatus: 402,
+    source: "api"
+  },
+  no_file_found: {
+    message: "Request missing file field.",
+    remediation: "(internal) MCP server bug, please report.",
+    httpStatus: 400,
+    source: "api"
+  },
+  parse_file_too_large: {
+    message: "PDF exceeds 300MB.",
+    remediation: "Split the PDF locally.",
+    httpStatus: 400,
+    source: "api"
+  },
+  parse_page_limit_exceeded: {
+    message: "PDF exceeds 800 pages.",
+    remediation: "Split the PDF locally.",
+    httpStatus: 400,
+    source: "api"
+  },
+  parse_file_not_pdf: {
+    message: "File is not a valid PDF.",
+    remediation: "Upload a .pdf file.",
+    httpStatus: 400,
+    source: "api"
+  },
+  translate_pdf_file_too_large: {
+    message: "PDF exceeds 300MB.",
+    remediation: "Split the PDF locally.",
+    httpStatus: 400,
+    source: "api"
+  },
+  translate_pdf_file_not_pdf: {
+    message: "File is not a valid PDF.",
+    remediation: "Upload a .pdf file.",
+    httpStatus: 400,
+    source: "api"
+  },
+  translate_pdf_page_limit_exceeded: {
+    message: "PDF exceeds 800 pages.",
+    remediation: "Split the PDF locally.",
+    httpStatus: 400,
+    source: "api"
+  },
+  convert_file_too_large: {
+    message: "File exceeds 300MB.",
+    remediation: "Reduce file size.",
+    httpStatus: 400,
+    source: "api"
+  },
+  convert_file_type_unsupported: {
+    message: "File must be .md / .markdown / .zip.",
+    remediation: "Convert source to markdown first.",
+    httpStatus: 400,
+    source: "api"
+  },
+  convert_target_format_unsupported: {
+    message: "Target format unsupported.",
+    remediation: "Use word/docx/html/pdf/latex/tex.",
+    httpStatus: 400,
+    source: "api"
+  },
+  file_upload_failed: {
+    message: "Upload to storage failed.",
+    remediation: "Check network and retry.",
+    httpStatus: 500,
+    source: "api"
+  },
+  task_creation_failed: {
+    message: "Task creation failed.",
+    remediation: "Retry.",
+    httpStatus: 500,
+    source: "api"
+  },
+  parse_error: {
+    message: "Parsing failed.",
+    remediation: "Retry; if it persists, split and try again.",
+    httpStatus: 500,
+    source: "api"
+  },
+  parse_file_invalid: {
+    message: "PDF is malformed.",
+    remediation: "Re-export the PDF.",
+    httpStatus: 500,
+    source: "api"
+  },
+  parse_timeout: {
+    message: "Server-side timeout.",
+    remediation: "Split into smaller PDFs.",
+    httpStatus: 500,
+    source: "api"
+  },
+  api_task_error: {
+    message: "Generic task error.",
+    remediation: "Retry; if it persists contact support.",
+    httpStatus: 500,
+    source: "api"
+  },
+  // --- client codes ---
+  client_polling_timeout: {
+    message: "Local polling exceeded KOLMOPDF_MAX_POLL_MINUTES.",
+    remediation: "Task may still be running. Use kolmopdf_get_task_status with task_id.",
+    httpStatus: null,
+    source: "client"
+  },
+  client_network_error: {
+    message: "Network error after retries.",
+    remediation: "Check network.",
+    httpStatus: null,
+    source: "client"
+  },
+  client_local_validation: {
+    message: "Local pre-check failed (page count / file size).",
+    remediation: "See message for the specific limit that was exceeded.",
+    httpStatus: null,
+    source: "client"
+  },
+  client_extract_failed: {
+    message: "ZIP extraction failed.",
+    remediation: "Check disk permissions on output dir.",
+    httpStatus: null,
+    source: "client"
+  }
+};
+var UNKNOWN_SPEC = {
+  message: "Unknown error.",
+  remediation: "Retry; if it persists contact https://www.kolmopdf.com/contact.",
+  httpStatus: null,
+  source: "client"
+};
+var KolmoPdfError = class extends Error {
+  errorCode;
+  httpStatus;
+  remediation;
+  pointsRequired;
+  currentPoints;
+  source;
+  constructor(errorCode, opts = {}) {
+    const spec = ERROR_SPECS[errorCode] ?? UNKNOWN_SPEC;
+    super(opts.message ?? spec.message);
+    this.name = "KolmoPdfError";
+    this.errorCode = errorCode;
+    this.httpStatus = opts.httpStatus !== void 0 ? opts.httpStatus : spec.httpStatus;
+    this.remediation = opts.remediation ?? spec.remediation;
+    this.pointsRequired = opts.pointsRequired;
+    this.currentPoints = opts.currentPoints;
+    this.source = spec.source;
+  }
+};
+function toMcpErrorResult(err) {
+  const kerr = err instanceof KolmoPdfError ? err : new KolmoPdfError("api_task_error", {
+    message: err instanceof Error ? err.message : String(err)
+  });
+  const payload = {
+    error_code: kerr.errorCode,
+    message: kerr.message,
+    http_status: kerr.httpStatus,
+    remediation: kerr.remediation
+  };
+  if (kerr.pointsRequired !== void 0) payload.points_required = kerr.pointsRequired;
+  if (kerr.currentPoints !== void 0) payload.current_points = kerr.currentPoints;
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(payload) }]
+  };
+}
+function errorFromApiBody(body, httpStatus) {
+  const code = body.error_code ?? "api_task_error";
+  return new KolmoPdfError(code, {
+    message: body.message,
+    httpStatus: httpStatus ?? null,
+    pointsRequired: body.points_required,
+    currentPoints: body.current_points
+  });
+}
+
+// src/client.ts
+var KolmoPdfClient = class {
+  apiKey;
+  baseUrl;
+  httpTimeoutMs;
+  uploadTimeoutMs;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl;
+    this.httpTimeoutMs = opts.httpTimeoutMs;
+    this.uploadTimeoutMs = opts.uploadTimeoutMs;
+  }
+  get apiBase() {
+    return `${this.baseUrl}/api/pdf-to-markdown-proxy`;
+  }
+  headers() {
+    return { "X-API-Key": this.apiKey };
+  }
+  async jsonRequest(url, init) {
+    const res = await fetch(url, init);
+    const body = await res.json();
+    if (!res.ok || body.success === false) {
+      throw errorFromApiBody(
+        body,
+        res.status
+      );
+    }
+    return body;
+  }
+  async buildFileForm(file, filename) {
+    const form = new FormData();
+    let blob;
+    if (Buffer.isBuffer(file)) {
+      blob = new Blob([file]);
+    } else {
+      const chunks = [];
+      for await (const chunk of file) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      blob = new Blob([Buffer.concat(chunks)]);
+    }
+    form.append("file", blob, filename);
+    return form;
+  }
+  async parse(file, form, filename) {
+    const fd = await this.buildFileForm(file, filename);
+    if (form.table_mode) fd.append("table_mode", form.table_mode);
+    if (form.formula_format) fd.append("formula_format", form.formula_format);
+    if (form.enable_translation !== void 0)
+      fd.append("enable_translation", String(form.enable_translation));
+    if (form.target_language) fd.append("target_language", form.target_language);
+    if (form.output_options?.length) fd.append("output_options", form.output_options.join(","));
+    if (form.images_as_url !== void 0) fd.append("images_as_url", String(form.images_as_url));
+    if (form.skip_rotation_detection !== void 0)
+      fd.append("skip_rotation_detection", String(form.skip_rotation_detection));
+    if (form.enable_cross_page_merge !== void 0)
+      fd.append("enable_cross_page_merge", String(form.enable_cross_page_merge));
+    const body = await this.jsonRequest(`${this.apiBase}/parse`, {
+      method: "POST",
+      headers: this.headers(),
+      body: fd,
+      signal: AbortSignal.timeout(this.uploadTimeoutMs)
+    });
+    return body;
+  }
+  async translatePdf(file, form, filename) {
+    const fd = await this.buildFileForm(file, filename);
+    if (form.source_language) fd.append("sourceLanguage", form.source_language);
+    if (form.target_language) fd.append("targetLanguage", form.target_language);
+    if (form.layout_modes?.length) fd.append("layoutModes", form.layout_modes.join(","));
+    if (form.enable_image_translation !== void 0)
+      fd.append("enableImageTranslation", String(form.enable_image_translation));
+    if (form.enable_table_translation !== void 0)
+      fd.append("enableTableTranslation", String(form.enable_table_translation));
+    const body = await this.jsonRequest(`${this.apiBase}/translate-pdf`, {
+      method: "POST",
+      headers: this.headers(),
+      body: fd,
+      signal: AbortSignal.timeout(this.uploadTimeoutMs)
+    });
+    return body;
+  }
+  async convert(file, form, filename) {
+    const fd = await this.buildFileForm(file, filename);
+    if (form.target_format) fd.append("targetFormat", form.target_format);
+    const body = await this.jsonRequest(`${this.apiBase}/convert`, {
+      method: "POST",
+      headers: this.headers(),
+      body: fd,
+      signal: AbortSignal.timeout(this.uploadTimeoutMs)
+    });
+    return body;
+  }
+  async getStatus(taskId) {
+    const body = await this.jsonRequest(`${this.apiBase}/status/${taskId}`, {
+      method: "GET",
+      headers: this.headers(),
+      signal: AbortSignal.timeout(this.httpTimeoutMs)
+    });
+    return body;
+  }
+  async download(taskId, dest) {
+    const res = await fetch(`${this.apiBase}/download/${taskId}`, {
+      method: "GET",
+      headers: this.headers(),
+      signal: AbortSignal.timeout(this.uploadTimeoutMs)
+    });
+    if (!res.ok) {
+      throw new KolmoPdfError("api_task_error", {
+        message: `Download failed with HTTP ${res.status}`,
+        httpStatus: res.status
+      });
+    }
+    const contentType = res.headers.get("content-type");
+    const isZip = contentType?.includes("zip") || contentType?.includes("octet-stream") || false;
+    const body = res.body;
+    if (!body) {
+      throw new KolmoPdfError("api_task_error", { message: "Empty download response body" });
+    }
+    const reader = body.getReader();
+    let bytesWritten = 0;
+    async function* generate() {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        bytesWritten += value.byteLength;
+        yield Buffer.from(value);
+      }
+    }
+    const readable = import_node_stream.Readable.from(generate());
+    await (0, import_promises.pipeline)(readable, dest);
+    return { contentType, isZip, bytesWritten };
+  }
+  async getBalance() {
+    const body = await this.jsonRequest(`${this.apiBase}/balance`, {
+      method: "GET",
+      headers: this.headers(),
+      signal: AbortSignal.timeout(this.httpTimeoutMs)
+    });
+    return body;
+  }
+};
+
+// src/config.ts
+var DEFAULTS = {
+  baseUrl: "https://www.kolmopdf.com",
+  outputDir: "./kolmopdf-output",
+  pollIntervalMs: 2e3,
+  maxPollMinutes: 30,
+  httpTimeoutMs: 6e4,
+  uploadTimeoutMs: 6e5
+};
+function intFromEnv(value, fallback) {
+  if (value === void 0 || value.trim() === "") return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function loadConfig(env = process.env) {
+  const apiKeyRaw = env.KOLMOPDF_API_KEY?.trim();
+  return {
+    apiKey: apiKeyRaw && apiKeyRaw.length > 0 ? apiKeyRaw : void 0,
+    baseUrl: trimTrailingSlash(env.KOLMOPDF_BASE_URL?.trim() || DEFAULTS.baseUrl),
+    outputDir: env.KOLMOPDF_OUTPUT_DIR?.trim() || DEFAULTS.outputDir,
+    pollIntervalMs: intFromEnv(env.KOLMOPDF_POLL_INTERVAL_MS, DEFAULTS.pollIntervalMs),
+    maxPollMinutes: intFromEnv(env.KOLMOPDF_MAX_POLL_MINUTES, DEFAULTS.maxPollMinutes),
+    httpTimeoutMs: intFromEnv(env.KOLMOPDF_HTTP_TIMEOUT_MS, DEFAULTS.httpTimeoutMs),
+    uploadTimeoutMs: intFromEnv(env.KOLMOPDF_UPLOAD_TIMEOUT_MS, DEFAULTS.uploadTimeoutMs)
+  };
+}
+function maskApiKey(apiKey) {
+  if (apiKey.length <= 10) return "***";
+  return `${apiKey.slice(0, 6)}***${apiKey.slice(-4)}`;
+}
+
+// src/context.ts
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
+}
+
+// src/tools/check-balance.ts
+var import_zod = require("zod");
+var checkBalanceName = "kolmopdf_check_balance";
+var checkBalanceDescription = "Show the current KolmoPDF credit balance for the configured API key.";
+var checkBalanceInputSchema = import_zod.z.object({});
+async function checkBalanceHandler(_args, ctx) {
+  const client = ctx.getClient();
+  const balance = await client.getBalance();
+  const output = {
+    points: balance.points,
+    api_key_masked: maskApiKey(ctx.config.apiKey || "")
+  };
+  return jsonResult(output);
+}
+
+// src/tools/convert.ts
+var import_node_fs = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path = require("path");
+var import_zod2 = require("zod");
+
+// src/pages.ts
+var import_promises2 = require("fs/promises");
+var import_pdf_lib = require("pdf-lib");
+var MAX_PAGES = 800;
+var MAX_FILE_BYTES = 300 * 1024 * 1024;
+async function readPageCount(filePath) {
+  const data = await (0, import_promises2.readFile)(filePath);
+  const doc = await import_pdf_lib.PDFDocument.load(data, { ignoreEncryption: true });
+  return doc.getPageCount();
+}
+async function readFileSize(filePath) {
+  const s = await (0, import_promises2.stat)(filePath);
+  return s.size;
+}
+
+// src/progress.ts
+function humanizeStatus(status, aheadTasks) {
+  if (status === "waiting" && typeof aheadTasks === "number") {
+    return `[waiting] ${aheadTasks} tasks ahead`;
+  }
+  return `[${status}]`;
+}
+
+// src/polling.ts
+var TERMINAL_OK = "completed";
+var TERMINAL_FAIL = "failed";
+var RETRY_POLICY = {
+  maxAttempts: 3,
+  baseDelayMs: 1e3,
+  factor: 2
+};
+function backoffDelayMs(attempt) {
+  return RETRY_POLICY.baseDelayMs * RETRY_POLICY.factor ** (attempt - 1);
+}
+function isRetryable(err) {
+  const transientCodes = ["ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "EAI_AGAIN"];
+  if (err.code && transientCodes.includes(err.code)) return true;
+  if (typeof err.httpStatus === "number" && err.httpStatus >= 500) return true;
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function fetchStatusWithRetry(client, taskId) {
+  for (let attempt = 1; attempt <= RETRY_POLICY.maxAttempts; attempt++) {
+    try {
+      return await client.getStatus(taskId);
+    } catch (err) {
+      const retryable = err instanceof KolmoPdfError ? isRetryable(err) : isRetryable({ code: err.code });
+      if (!retryable || attempt === RETRY_POLICY.maxAttempts) throw err;
+      await sleep(backoffDelayMs(attempt));
+    }
+  }
+  throw new KolmoPdfError("client_network_error");
+}
+async function pollUntilComplete(ctx) {
+  const { client, taskId, options, progress } = ctx;
+  const deadline = Date.now() + options.maxPollMinutes * 6e4;
+  while (true) {
+    if (Date.now() > deadline) {
+      throw new KolmoPdfError("client_polling_timeout");
+    }
+    const result = await fetchStatusWithRetry(client, taskId);
+    if (result.status === TERMINAL_OK) {
+      await progress?.report(`[completed] Task ${taskId} done`);
+      return result;
+    }
+    if (result.status === TERMINAL_FAIL) {
+      throw new KolmoPdfError(result.error_code || "api_task_error", {
+        message: result.message || "Task failed"
+      });
+    }
+    const aheadTasks = result.queue_info?.ahead_tasks;
+    await progress?.report(humanizeStatus(result.status, aheadTasks));
+    await sleep(options.pollIntervalMs);
+  }
+}
+
+// src/tools/convert.ts
+var convertName = "kolmopdf_convert_markdown";
+var convertDescription = "Convert a Markdown file (or a ZIP of markdown + images) to DOCX, HTML, PDF, or LaTeX via KolmoPDF.";
+var convertInputSchema = import_zod2.z.object({
+  file_path: import_zod2.z.string().describe("Path to a .md/.markdown file or .zip containing markdown + images."),
+  target_format: import_zod2.z.enum(["word", "docx", "html", "pdf", "latex", "tex"]).optional().default("word"),
+  output_subdir: import_zod2.z.string().optional()
+});
+function formatToExtension(targetFormat) {
+  switch (targetFormat) {
+    case "word":
+    case "docx":
+      return ".docx";
+    case "html":
+      return ".html";
+    case "pdf":
+      return ".pdf";
+    case "latex":
+    case "tex":
+      return ".tex";
+    default:
+      return ".out";
+  }
+}
+function normalizeFormat(targetFormat) {
+  switch (targetFormat) {
+    case "word":
+    case "docx":
+      return "docx";
+    case "latex":
+    case "tex":
+      return "tex";
+    default:
+      return targetFormat;
+  }
+}
+async function convertHandler(args, ctx) {
+  const client = ctx.getClient();
+  const filePath = (0, import_node_path.resolve)(args.file_path);
+  const filename = (0, import_node_path.basename)(filePath);
+  const fileSize = await readFileSize(filePath);
+  if (fileSize > MAX_FILE_BYTES) {
+    throw new KolmoPdfError("convert_file_too_large");
+  }
+  const ext = filePath.toLowerCase();
+  if (!ext.endsWith(".md") && !ext.endsWith(".markdown") && !ext.endsWith(".zip")) {
+    throw new KolmoPdfError("convert_file_type_unsupported");
+  }
+  await ctx.progress?.report("[uploading] Sending file for conversion...");
+  const fileBuffer = await (0, import_promises3.readFile)(filePath);
+  const submitResult = await client.convert(
+    fileBuffer,
+    {
+      target_format: args.target_format
+    },
+    filename
+  );
+  const taskId = submitResult.task_id;
+  await ctx.progress?.report(`[submitted] Task ${taskId} created`);
+  await pollUntilComplete({
+    client,
+    taskId,
+    options: {
+      pollIntervalMs: ctx.config.pollIntervalMs,
+      maxPollMinutes: ctx.config.maxPollMinutes
+    },
+    progress: ctx.progress
+  });
+  await ctx.progress?.report("[downloading] Fetching converted file...");
+  const subdir = args.output_subdir || taskId;
+  const outputRoot = (0, import_node_path.resolve)(ctx.config.outputDir, subdir);
+  (0, import_node_fs.mkdirSync)(outputRoot, { recursive: true });
+  const outExt = formatToExtension(args.target_format);
+  const outputPath = (0, import_node_path.join)(outputRoot, `result${outExt}`);
+  const ws = (0, import_node_fs.createWriteStream)(outputPath);
+  await client.download(taskId, ws);
+  const output = {
+    task_id: taskId,
+    points_deducted: submitResult.points_deducted,
+    remaining_points: submitResult.remaining_points,
+    output: {
+      output_path: outputPath,
+      target_format: normalizeFormat(args.target_format)
+    }
+  };
+  return jsonResult(output);
+}
+
+// src/tools/estimate-cost.ts
+var import_node_path2 = require("path");
+var import_zod3 = require("zod");
+var estimateCostName = "kolmopdf_estimate_cost";
+var estimateCostDescription = "Estimate the credit cost of a KolmoPDF operation before running it. Reads page count locally and checks the current balance. Does not spend credits.";
+var estimateCostInputSchema = import_zod3.z.object({
+  file_path: import_zod3.z.string(),
+  operation: import_zod3.z.enum(["parse", "parse_translate", "translate", "convert"]),
+  options: import_zod3.z.object({
+    images_as_url: import_zod3.z.boolean().optional()
+  }).optional()
+});
+function estimateCredits(operation, pages) {
+  switch (operation) {
+    case "parse":
+      return pages * 2;
+    case "parse_translate":
+      return pages * 3;
+    case "translate":
+      return pages * 2;
+    case "convert":
+      return 1;
+  }
+}
+function buildRecommendation(shortfall) {
+  return shortfall > 0 ? `Need top-up at https://www.kolmopdf.com/subscription (short by ${shortfall} credits).` : "Sufficient";
+}
+async function estimateCostHandler(args, ctx) {
+  const client = ctx.getClient();
+  let pages = null;
+  if (args.operation !== "convert") {
+    const filePath = (0, import_node_path2.resolve)(args.file_path);
+    pages = await readPageCount(filePath);
+  }
+  const estimatedCredits = estimateCredits(args.operation, pages ?? 1);
+  const balance = await client.getBalance();
+  const currentBalance = balance.points;
+  const shortfall = Math.max(0, estimatedCredits - currentBalance);
+  const output = {
+    pages,
+    estimated_credits: estimatedCredits,
+    current_balance: currentBalance,
+    sufficient: shortfall === 0,
+    shortfall,
+    recommendation: buildRecommendation(shortfall)
+  };
+  return jsonResult(output);
+}
+
+// src/tools/get-task-status.ts
+var import_zod4 = require("zod");
+var getTaskStatusName = "kolmopdf_get_task_status";
+var getTaskStatusDescription = "Advanced/debug tool. Returns raw status for a KolmoPDF task. Use only when explicitly asked to inspect a task by ID, or when troubleshooting a stuck task.";
+var getTaskStatusInputSchema = import_zod4.z.object({
+  task_id: import_zod4.z.string()
+});
+async function getTaskStatusHandler(args, ctx) {
+  const client = ctx.getClient();
+  const status = await client.getStatus(args.task_id);
+  return jsonResult(status);
+}
+
+// src/tools/parse-pdf.ts
+var import_node_fs3 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_path4 = require("path");
+var import_zod5 = require("zod");
+
+// src/extract.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var import_promises4 = require("stream/promises");
+var import_yauzl = require("yauzl");
+async function extractZip(zipPath, destDir) {
+  (0, import_node_fs2.mkdirSync)(destDir, { recursive: true });
+  const zipFile = await openZip(zipPath);
+  const files = [];
+  let markdownPath = null;
+  let imagesDir = null;
+  for await (const entry of iterEntries(zipFile)) {
+    const entryPath = (0, import_node_path3.join)(destDir, entry.fileName);
+    if (entry.fileName.endsWith("/")) {
+      (0, import_node_fs2.mkdirSync)(entryPath, { recursive: true });
+      if (entry.fileName.includes("images")) {
+        imagesDir = entryPath;
+      }
+      continue;
+    }
+    (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)(entryPath), { recursive: true });
+    const readStream = await openReadStream(zipFile, entry);
+    const writeStream = (0, import_node_fs2.createWriteStream)(entryPath);
+    await (0, import_promises4.pipeline)(readStream, writeStream);
+    files.push(entryPath);
+    if (!markdownPath && /\.md$/i.test(entry.fileName)) {
+      markdownPath = entryPath;
+    }
+    if (!imagesDir && /images\//i.test(entry.fileName)) {
+      const prefix = entry.fileName.split("images/")[0] ?? "";
+      imagesDir = (0, import_node_path3.join)(destDir, prefix, "images");
+    }
+  }
+  return { markdownPath, imagesDir, outputRoot: destDir, files };
+}
+function openZip(path) {
+  return new Promise((resolve5, reject) => {
+    (0, import_yauzl.open)(path, { lazyEntries: true }, (err, zf) => {
+      if (err || !zf) return reject(err ?? new Error("Failed to open zip"));
+      resolve5(zf);
+    });
+  });
+}
+async function* iterEntries(zipFile) {
+  let resolve5 = null;
+  const queue = [];
+  zipFile.on("entry", (entry) => {
+    if (resolve5) {
+      const r = resolve5;
+      resolve5 = null;
+      r(entry);
+    } else {
+      queue.push(entry);
+    }
+  });
+  zipFile.on("end", () => {
+    if (resolve5) {
+      const r = resolve5;
+      resolve5 = null;
+      r(null);
+    } else {
+      queue.push(null);
+    }
+  });
+  zipFile.readEntry();
+  while (true) {
+    const entry = queue.length > 0 ? queue.shift() : await new Promise((r) => {
+      resolve5 = r;
+    });
+    if (entry === null) break;
+    yield entry;
+    zipFile.readEntry();
+  }
+}
+function openReadStream(zipFile, entry) {
+  return new Promise((resolve5, reject) => {
+    zipFile.openReadStream(entry, (err, stream) => {
+      if (err || !stream) return reject(err ?? new Error("Failed to open entry stream"));
+      resolve5(stream);
+    });
+  });
+}
+
+// src/tools/parse-pdf.ts
+var parsePdfName = "kolmopdf_parse_pdf";
+var parsePdfDescription = "Parse a local PDF into Markdown via KolmoPDF. Handles formulas, tables, multi-column layouts, and code blocks. Optionally translates while parsing.";
+var parsePdfInputSchema = import_zod5.z.object({
+  file_path: import_zod5.z.string().describe("Absolute or cwd-relative path to a local PDF file."),
+  table_mode: import_zod5.z.enum(["markdown", "image"]).optional(),
+  formula_format: import_zod5.z.enum(["dollar", "bracket"]).optional(),
+  enable_translation: import_zod5.z.boolean().optional(),
+  target_language: import_zod5.z.enum(["zh", "en", "ja", "ko", "fr", "de", "es", "ru"]).optional(),
+  output_options: import_zod5.z.array(import_zod5.z.enum(["original", "translated", "bilingual"])).optional(),
+  images_as_url: import_zod5.z.boolean().optional(),
+  skip_rotation_detection: import_zod5.z.boolean().optional(),
+  enable_cross_page_merge: import_zod5.z.boolean().optional(),
+  output_subdir: import_zod5.z.string().optional().describe("Subdirectory name under KOLMOPDF_OUTPUT_DIR. Defaults to <task_id>.")
+});
+async function parsePdfHandler(args, ctx) {
+  const client = ctx.getClient();
+  const filePath = (0, import_node_path4.resolve)(args.file_path);
+  const filename = (0, import_node_path4.basename)(filePath);
+  const fileSize = await readFileSize(filePath);
+  if (fileSize > MAX_FILE_BYTES) {
+    throw new KolmoPdfError("parse_file_too_large");
+  }
+  const pageCount = await readPageCount(filePath);
+  if (pageCount > MAX_PAGES) {
+    throw new KolmoPdfError("parse_page_limit_exceeded");
+  }
+  await ctx.progress?.report("[uploading] Sending PDF to KolmoPDF...");
+  const fileBuffer = await (0, import_promises5.readFile)(filePath);
+  const submitResult = await client.parse(
+    fileBuffer,
+    {
+      table_mode: args.table_mode,
+      formula_format: args.formula_format,
+      enable_translation: args.enable_translation,
+      target_language: args.target_language,
+      output_options: args.output_options,
+      images_as_url: args.images_as_url,
+      skip_rotation_detection: args.skip_rotation_detection,
+      enable_cross_page_merge: args.enable_cross_page_merge
+    },
+    filename
+  );
+  const taskId = submitResult.task_id;
+  await ctx.progress?.report(`[submitted] Task ${taskId} created`);
+  await pollUntilComplete({
+    client,
+    taskId,
+    options: {
+      pollIntervalMs: ctx.config.pollIntervalMs,
+      maxPollMinutes: ctx.config.maxPollMinutes
+    },
+    progress: ctx.progress
+  });
+  await ctx.progress?.report("[downloading] Fetching result...");
+  const subdir = args.output_subdir || taskId;
+  const outputRoot = (0, import_node_path4.resolve)(ctx.config.outputDir, subdir);
+  (0, import_node_fs3.mkdirSync)(outputRoot, { recursive: true });
+  const isUrlMode = args.images_as_url === true;
+  let markdownPath;
+  let imagesDir = null;
+  let outputType;
+  if (isUrlMode) {
+    markdownPath = (0, import_node_path4.join)(outputRoot, "result.md");
+    const ws = (0, import_node_fs3.createWriteStream)(markdownPath);
+    await client.download(taskId, ws);
+    outputType = "markdown_file";
+  } else {
+    const zipPath = (0, import_node_path4.join)(outputRoot, "result.zip");
+    const ws = (0, import_node_fs3.createWriteStream)(zipPath);
+    await client.download(taskId, ws);
+    const extracted = await extractZip(zipPath, outputRoot);
+    markdownPath = extracted.markdownPath || (0, import_node_path4.join)(outputRoot, "result.md");
+    imagesDir = extracted.imagesDir;
+    outputType = "zip_extracted";
+  }
+  const mdContent = await (0, import_promises5.readFile)(markdownPath, "utf-8").catch(() => "");
+  const preview = mdContent.slice(0, 500);
+  const ptsPerPage = args.enable_translation ? 3 : 2;
+  const pagesParsed = Math.round(submitResult.points_deducted / ptsPerPage);
+  const output = {
+    task_id: taskId,
+    pages_parsed: pagesParsed,
+    points_deducted: submitResult.points_deducted,
+    remaining_points: submitResult.remaining_points,
+    output: {
+      type: outputType,
+      markdown_path: markdownPath,
+      images_dir: imagesDir,
+      output_root: outputRoot
+    },
+    preview
+  };
+  return jsonResult(output);
+}
+
+// src/tools/translate-pdf.ts
+var import_node_fs4 = require("fs");
+var import_promises6 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_zod6 = require("zod");
+var translatePdfName = "kolmopdf_translate_pdf";
+var translatePdfDescription = "Translate a PDF while preserving its original layout via KolmoPDF. Produces a translated PDF (optionally side-by-side bilingual).";
+var translatePdfInputSchema = import_zod6.z.object({
+  file_path: import_zod6.z.string(),
+  source_language: import_zod6.z.string().optional().default("en"),
+  target_language: import_zod6.z.string().optional().default("zh"),
+  layout_modes: import_zod6.z.array(import_zod6.z.enum(["translated_only", "side_by_side"])).optional().default(["translated_only"]),
+  enable_image_translation: import_zod6.z.boolean().optional().default(false),
+  enable_table_translation: import_zod6.z.boolean().optional().default(false),
+  output_subdir: import_zod6.z.string().optional()
+});
+async function translatePdfHandler(args, ctx) {
+  const client = ctx.getClient();
+  const filePath = (0, import_node_path5.resolve)(args.file_path);
+  const filename = (0, import_node_path5.basename)(filePath);
+  const fileSize = await readFileSize(filePath);
+  if (fileSize > MAX_FILE_BYTES) {
+    throw new KolmoPdfError("translate_pdf_file_too_large");
+  }
+  const pageCount = await readPageCount(filePath);
+  if (pageCount > MAX_PAGES) {
+    throw new KolmoPdfError("translate_pdf_page_limit_exceeded");
+  }
+  await ctx.progress?.report("[uploading] Sending PDF for translation...");
+  const fileBuffer = await (0, import_promises6.readFile)(filePath);
+  const submitResult = await client.translatePdf(
+    fileBuffer,
+    {
+      source_language: args.source_language,
+      target_language: args.target_language,
+      layout_modes: args.layout_modes,
+      enable_image_translation: args.enable_image_translation,
+      enable_table_translation: args.enable_table_translation
+    },
+    filename
+  );
+  const taskId = submitResult.task_id;
+  await ctx.progress?.report(`[submitted] Task ${taskId} created`);
+  await pollUntilComplete({
+    client,
+    taskId,
+    options: {
+      pollIntervalMs: ctx.config.pollIntervalMs,
+      maxPollMinutes: ctx.config.maxPollMinutes
+    },
+    progress: ctx.progress
+  });
+  await ctx.progress?.report("[downloading] Fetching translated PDF...");
+  const subdir = args.output_subdir || taskId;
+  const outputRoot = (0, import_node_path5.resolve)(ctx.config.outputDir, subdir);
+  (0, import_node_fs4.mkdirSync)(outputRoot, { recursive: true });
+  const pdfPath = (0, import_node_path5.join)(outputRoot, "translated.pdf");
+  const ws = (0, import_node_fs4.createWriteStream)(pdfPath);
+  await client.download(taskId, ws);
+  const pagesTranslated = Math.round(submitResult.points_deducted / 2);
+  const output = {
+    task_id: taskId,
+    pages_translated: pagesTranslated,
+    points_deducted: submitResult.points_deducted,
+    remaining_points: submitResult.remaining_points,
+    output: {
+      translated_pdf_path: pdfPath
+    }
+  };
+  return jsonResult(output);
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+function buildContext() {
+  const config = loadConfig();
+  return {
+    config,
+    getClient() {
+      if (!config.apiKey) {
+        throw new KolmoPdfError("invalid_api_key");
+      }
+      return new KolmoPdfClient({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        httpTimeoutMs: config.httpTimeoutMs,
+        uploadTimeoutMs: config.uploadTimeoutMs
+      });
+    }
+  };
+}
+function guard(handler) {
+  return async (args) => {
+    try {
+      return await handler(args, buildContext());
+    } catch (err) {
+      return toMcpErrorResult(err);
+    }
+  };
+}
+function createServer() {
+  const server = new import_mcp.McpServer({ name: "kolmopdf", version: VERSION });
+  server.registerTool(
+    parsePdfName,
+    { description: parsePdfDescription, inputSchema: parsePdfInputSchema.shape },
+    guard(parsePdfHandler)
+  );
+  server.registerTool(
+    translatePdfName,
+    { description: translatePdfDescription, inputSchema: translatePdfInputSchema.shape },
+    guard(translatePdfHandler)
+  );
+  server.registerTool(
+    convertName,
+    { description: convertDescription, inputSchema: convertInputSchema.shape },
+    guard(convertHandler)
+  );
+  server.registerTool(
+    estimateCostName,
+    { description: estimateCostDescription, inputSchema: estimateCostInputSchema.shape },
+    guard(estimateCostHandler)
+  );
+  server.registerTool(
+    checkBalanceName,
+    { description: checkBalanceDescription, inputSchema: checkBalanceInputSchema.shape },
+    guard(checkBalanceHandler)
+  );
+  server.registerTool(
+    getTaskStatusName,
+    { description: getTaskStatusDescription, inputSchema: getTaskStatusInputSchema.shape },
+    guard(getTaskStatusHandler)
+  );
+  return server;
+}
+async function main() {
+  if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  const server = createServer();
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  const detail = err instanceof Error ? err.stack : String(err);
+  process.stderr.write(`[kolmopdf-mcp] fatal: ${detail}
+`);
+  process.exit(1);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer,
+  jsonResult
+});
+//# sourceMappingURL=index.cjs.map