@zqagent/core 0.2.16 → 0.3.6

package/dist/internal/mcp/builtin/index.js

@@ -0,0 +1,652 @@
+// src/mcp/builtin/index.ts
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+
+// src/mcp/builtin/ocr.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/builtin/ocrEngine.ts
+import fs from "fs";
+import os from "os";
+import path2 from "path";
+import { execFile } from "child_process";
+import OpenAI from "openai";
+
+// src/tools/shellRuntime.ts
+import * as path from "path";
+var WINDOWS_SUFFIXES = [".exe", ".cmd", ".bat", ".com", ""];
+function pathApi(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function joinPath(platform, ...parts) {
+  return pathApi(platform).join(...parts);
+}
+function findExecutable(name, ctx) {
+  if (name.includes("/") || name.includes("\\")) {
+    return ctx.fileExists(name) ? name : null;
+  }
+  const suffixes = ctx.platform === "win32" ? WINDOWS_SUFFIXES : [""];
+  const delimiter = ctx.platform === "win32" ? ";" : ":";
+  const dirs = (ctx.env.PATH ?? "").split(delimiter).filter((d) => d.length > 0);
+  for (const dir of dirs) {
+    for (const suffix of suffixes) {
+      const candidate = joinPath(ctx.platform, dir, name + suffix);
+      if (ctx.fileExists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// src/mcp/builtin/ocrEngine.ts
+var DEFAULT_MAX_PAGES = 5;
+var MAX_MAX_PAGES = 50;
+var DEFAULT_DPI = 150;
+var MAX_DPI = 400;
+var CMD_TIMEOUT_MS = 12e4;
+var COMPILE_TIMEOUT_MS = 18e4;
+var MAX_BUFFER = 32 * 1024 * 1024;
+var VISION_SOURCE = `import Foundation
+import Vision
+import AppKit
+import PDFKit
+import CoreGraphics
+
+struct PageResult: Codable { let page: Int; let text: String }
+struct Output: Codable { let pages: [PageResult] }
+
+func recognize(_ image: CGImage) -> String {
+    func run(_ langs: [String]?) throws -> [VNRecognizedTextObservation] {
+        let request = VNRecognizeTextRequest()
+        request.recognitionLevel = .accurate
+        request.usesLanguageCorrection = true
+        if let langs = langs { request.recognitionLanguages = langs }
+        let handler = VNImageRequestHandler(cgImage: image, options: [:])
+        try handler.perform([request])
+        return request.results ?? []
+    }
+    let observations = (try? run(["zh-Hans", "zh-Hant", "en-US"])) ?? (try? run(nil)) ?? []
+    let lines = observations.compactMap { $0.topCandidates(1).first?.string }
+    return lines.joined(separator: "\\n")
+}
+
+func imageFromFile(_ p: String) -> CGImage? {
+    guard let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: p) as CFURL, nil) else { return nil }
+    return CGImageSourceCreateImageAtIndex(src, 0, nil)
+}
+
+let args = CommandLine.arguments
+guard args.count >= 2 else {
+    FileHandle.standardError.write("usage: ocr-vision <file> [maxPages] [dpi]\\n".data(using: .utf8)!)
+    exit(2)
+}
+let file = args[1]
+let maxPages = args.count > 2 ? (Int(args[2]) ?? 5) : 5
+let dpi = args.count > 3 ? (Int(args[3]) ?? 150) : 150
+
+var pages: [PageResult] = []
+if file.lowercased().hasSuffix(".pdf"), let doc = PDFDocument(url: URL(fileURLWithPath: file)) {
+    let count = min(doc.pageCount, max(1, maxPages))
+    let scale = CGFloat(dpi) / 72.0
+    for i in 0..<count {
+        guard let page = doc.page(at: i) else { continue }
+        let bounds = page.bounds(for: .mediaBox)
+        let w = Int(bounds.width * scale)
+        let h = Int(bounds.height * scale)
+        guard w > 0, h > 0 else { continue }
+        guard let ctx = CGContext(
+            data: nil, width: w, height: h, bitsPerComponent: 8, bytesPerRow: 0,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        ) else { continue }
+        ctx.setFillColor(CGColor(red: 1, green: 1, blue: 1, alpha: 1))
+        ctx.fill(CGRect(x: 0, y: 0, width: w, height: h))
+        ctx.scaleBy(x: scale, y: scale)
+        page.draw(with: .mediaBox, to: ctx)
+        guard let image = ctx.makeImage() else { continue }
+        pages.append(PageResult(page: i + 1, text: recognize(image)))
+    }
+} else if let image = imageFromFile(file) {
+    pages.append(PageResult(page: 1, text: recognize(image)))
+} else {
+    FileHandle.standardError.write("unsupported or unreadable image: \\(file)\\n".data(using: .utf8)!)
+    exit(3)
+}
+
+let encoder = JSONEncoder()
+encoder.outputFormatting = [.withoutEscapingSlashes]
+if let data = try? encoder.encode(Output(pages: pages)) {
+    FileHandle.standardOutput.write(data)
+} else {
+    exit(4)
+}
+`;
+function defaultRun(command, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      command,
+      args,
+      {
+        timeout: opts.timeoutMs ?? CMD_TIMEOUT_MS,
+        cwd: opts.cwd,
+        maxBuffer: MAX_BUFFER,
+        encoding: "utf8"
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          const e = err;
+          e.message = `${path2.basename(command)} \u6267\u884C\u5931\u8D25: ${e.message}${stderr ? `
+${stderr.trim()}` : ""}`;
+          reject(e);
+        } else {
+          resolve({ stdout, stderr });
+        }
+      }
+    );
+  });
+}
+function makeRuntime(ctx) {
+  const overrides = ctx.ocr ?? {};
+  const platform = overrides.platform ?? process.platform;
+  const env = overrides.env ?? ctx.env ?? process.env;
+  const workspace = ctx.workspace ?? env.WORKSPACE ?? process.cwd();
+  const fileExists = overrides.fileExists ?? ((p) => {
+    try {
+      return fs.statSync(p).isFile();
+    } catch {
+      return false;
+    }
+  });
+  const which = overrides.which ?? ((name) => findExecutable(name, { platform, env, fileExists }));
+  return {
+    platform,
+    env,
+    workspace,
+    llm: ctx.llm,
+    overrides,
+    which,
+    run: overrides.run ?? defaultRun,
+    fileExists
+  };
+}
+function clampInt(value, fallback, min, max) {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, Math.trunc(n)));
+}
+function isPdfFile(file) {
+  if (file.toLowerCase().endsWith(".pdf")) return true;
+  try {
+    const fd = fs.openSync(file, "r");
+    try {
+      const buf = Buffer.alloc(5);
+      const read = fs.readSync(fd, buf, 0, 5, 0);
+      return read >= 5 && buf.toString("latin1") === "%PDF-";
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}
+function detectMime(file) {
+  try {
+    const fd = fs.openSync(file, "r");
+    try {
+      const buf = Buffer.alloc(12);
+      fs.readSync(fd, buf, 0, 12, 0);
+      if (buf[0] === 137 && buf[1] === 80) return "image/png";
+      if (buf[0] === 255 && buf[1] === 216) return "image/jpeg";
+      if (buf.toString("latin1", 0, 4) === "RIFF") return "image/webp";
+      if (buf.toString("latin1", 0, 4) === "GIF8") return "image/gif";
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+  }
+  const ext = path2.extname(file).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".webp") return "image/webp";
+  if (ext === ".gif") return "image/gif";
+  return "image/png";
+}
+function toDataUrl(file) {
+  return `data:${detectMime(file)};base64,${fs.readFileSync(file).toString("base64")}`;
+}
+function dataUrlToBuffer(value) {
+  const m = /^data:([^;,]+);base64,([\s\S]*)$/.exec(value.trim());
+  const mime = m?.[1] ?? "image/png";
+  const b64 = m?.[2] ?? value.trim();
+  const ext = mime === "image/jpeg" ? ".jpg" : mime === "image/webp" ? ".webp" : mime === "image/gif" ? ".gif" : mime === "application/pdf" ? ".pdf" : ".png";
+  return { buffer: Buffer.from(b64, "base64"), ext };
+}
+function naturalCompare(a, b) {
+  return a.localeCompare(b, void 0, { numeric: true });
+}
+async function downloadToFile(url, dest, runtime) {
+  const fetchImpl = runtime.overrides.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) throw new Error("\u5F53\u524D\u8FD0\u884C\u65F6\u4E0D\u652F\u6301 fetch\uFF0C\u65E0\u6CD5\u4E0B\u8F7D imageUrl");
+  const res = await fetchImpl(url);
+  if (!res.ok) throw new Error(`\u4E0B\u8F7D\u56FE\u7247\u5931\u8D25\uFF1AHTTP ${res.status}`);
+  fs.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+}
+async function materializeInput(input, runtime) {
+  const root = runtime.overrides.tmpDir ?? os.tmpdir();
+  const tmpDir = fs.mkdtempSync(path2.join(root, "zqagent-ocr-"));
+  const cleanup = () => {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    if (typeof input.imagePath === "string" && input.imagePath.trim()) {
+      const file = path2.isAbsolute(input.imagePath) ? input.imagePath : path2.resolve(runtime.workspace, input.imagePath);
+      if (!runtime.fileExists(file) && !fs.existsSync(file))
+        throw new Error(`\u56FE\u7247\u4E0D\u5B58\u5728\uFF1A${file}`);
+      return { file, isPdf: isPdfFile(file), tmpDir, cleanup };
+    }
+    if (typeof input.imageBase64 === "string" && input.imageBase64.trim()) {
+      const { buffer, ext } = dataUrlToBuffer(input.imageBase64);
+      const file = path2.join(tmpDir, `input${ext}`);
+      fs.writeFileSync(file, buffer);
+      return { file, isPdf: isPdfFile(file), tmpDir, cleanup };
+    }
+    if (typeof input.imageUrl === "string" && input.imageUrl.trim()) {
+      const url = input.imageUrl.trim();
+      const ext = path2.extname(new URL(url).pathname).toLowerCase() || ".png";
+      const file = path2.join(tmpDir, `input${ext}`);
+      await downloadToFile(url, file, runtime);
+      return { file, isPdf: isPdfFile(file), tmpDir, cleanup };
+    }
+    throw new Error("\u7F3A\u5C11\u8F93\u5165\uFF1A\u8BF7\u63D0\u4F9B imagePath / imageBase64 / imageUrl \u4E4B\u4E00");
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+}
+async function pdfToImages(file, tmpDir, input, runtime) {
+  const pdftoppm = runtime.which("pdftoppm");
+  if (!pdftoppm) {
+    throw new Error(
+      "PDF \u9700\u8981 poppler \u7684 pdftoppm\uFF08macOS \u53EF\u4F7F\u7528\u5185\u7F6E Vision \u5F15\u64CE\uFF0C\u65E0\u9700\u8BE5\u4F9D\u8D56\uFF09"
+    );
+  }
+  const pagesDir = path2.join(tmpDir, "pages");
+  fs.mkdirSync(pagesDir, { recursive: true });
+  const maxPages = clampInt(
+    input.maxPages,
+    DEFAULT_MAX_PAGES,
+    1,
+    MAX_MAX_PAGES
+  );
+  const dpi = clampInt(input.dpi, DEFAULT_DPI, 36, MAX_DPI);
+  await runtime.run(
+    pdftoppm,
+    [
+      "-r",
+      String(dpi),
+      "-png",
+      "-f",
+      "1",
+      "-l",
+      String(maxPages),
+      file,
+      path2.join(pagesDir, "page")
+    ],
+    { timeoutMs: CMD_TIMEOUT_MS }
+  );
+  const images = fs.readdirSync(pagesDir).filter((f) => /^page.*\.png$/i.test(f)).sort(naturalCompare).map((f) => path2.join(pagesDir, f));
+  if (images.length === 0) throw new Error("PDF \u8F6C\u56FE\u7247\u5931\u8D25\uFF08\u672A\u751F\u6210\u9875\u9762\uFF09");
+  return images;
+}
+var visionBuilds = /* @__PURE__ */ new Map();
+function conciseError(err) {
+  const lines = err.message.split("\n").map((l) => l.trim()).filter((l) => /error:|fatal error:/i.test(l));
+  const pick = lines.length > 0 ? lines[lines.length - 1] : err.message;
+  return pick.slice(0, 500);
+}
+async function ensureVisionBinary(runtime) {
+  if (runtime.platform !== "darwin")
+    return { binary: null, error: "\u4EC5 macOS \u53EF\u7528" };
+  const swiftc = runtime.which("swiftc");
+  if (!swiftc)
+    return {
+      binary: null,
+      error: "\u672A\u627E\u5230 swiftc\uFF08\u9700\u8981 Xcode Command Line Tools\uFF09"
+    };
+  const dir = path2.join(runtime.workspace, ".agent", "bin");
+  const srcPath = path2.join(dir, "ocr-vision.swift");
+  const binPath = path2.join(dir, "ocr-vision");
+  const cacheKey = binPath;
+  const cached = visionBuilds.get(cacheKey);
+  if (cached) return cached;
+  const build = (async () => {
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      let changed = true;
+      try {
+        changed = fs.readFileSync(srcPath, "utf8") !== VISION_SOURCE;
+      } catch {
+        changed = true;
+      }
+      if (changed) fs.writeFileSync(srcPath, VISION_SOURCE, "utf8");
+      if (changed || !runtime.fileExists(binPath)) {
+        await runtime.run(swiftc, ["-O", "-o", binPath, srcPath], {
+          timeoutMs: COMPILE_TIMEOUT_MS
+        });
+      }
+      return runtime.fileExists(binPath) ? { binary: binPath } : { binary: null, error: "Vision \u7F16\u8BD1\u672A\u751F\u6210\u53EF\u6267\u884C\u6587\u4EF6" };
+    } catch (err) {
+      return { binary: null, error: `Vision \u7F16\u8BD1\u5931\u8D25: ${conciseError(err)}` };
+    }
+  })();
+  visionBuilds.set(cacheKey, build);
+  return build;
+}
+async function runVision(binary, file, input, runtime) {
+  const maxPages = clampInt(
+    input.maxPages,
+    DEFAULT_MAX_PAGES,
+    1,
+    MAX_MAX_PAGES
+  );
+  const dpi = clampInt(input.dpi, DEFAULT_DPI, 36, MAX_DPI);
+  const { stdout } = await runtime.run(
+    binary,
+    [file, String(maxPages), String(dpi)],
+    { timeoutMs: CMD_TIMEOUT_MS }
+  );
+  const parsed = JSON.parse(stdout);
+  const pages = Array.isArray(parsed.pages) ? parsed.pages : [];
+  if (pages.length === 0) throw new Error("Vision \u672A\u8FD4\u56DE\u8BC6\u522B\u7ED3\u679C");
+  return pages.map((p) => ({
+    page: Number(p.page) || 1,
+    text: typeof p.text === "string" ? p.text : ""
+  }));
+}
+async function runTesseract(file, isPdf, input, runtime, tmpDir) {
+  const tesseract = runtime.which("tesseract");
+  if (!tesseract) throw new Error("\u672A\u627E\u5230 tesseract");
+  const lang = input.lang ?? runtime.env.OCR_LANG ?? "chi_sim+eng";
+  const images = isPdf ? await pdfToImages(file, tmpDir, input, runtime) : [file];
+  const pages = [];
+  for (let i = 0; i < images.length; i += 1) {
+    const { stdout } = await runtime.run(
+      tesseract,
+      [images[i], "stdout", "-l", lang, "--psm", "3"],
+      { timeoutMs: CMD_TIMEOUT_MS }
+    );
+    pages.push({ page: i + 1, text: stdout.trim() });
+  }
+  return pages;
+}
+function resolveLlmConfig(runtime) {
+  const llm = runtime.llm;
+  const apiKey = llm?.apiKey ?? runtime.env.OPENAI_API_KEY ?? runtime.env.OCR_API_KEY ?? "";
+  const model = llm?.model ?? runtime.env.OCR_MODEL ?? runtime.env.OPENAI_MODEL ?? "";
+  const baseURL = llm?.baseURL ?? runtime.env.OPENAI_BASE_URL ?? runtime.env.OCR_BASE_URL;
+  if (!apiKey || !model) return null;
+  return { apiKey, model, baseURL };
+}
+async function defaultLlmComplete(req) {
+  const client = new OpenAI({
+    apiKey: req.apiKey ?? "",
+    ...req.baseURL ? { baseURL: req.baseURL } : {}
+  });
+  const res = await client.chat.completions.create({
+    model: req.model,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: req.prompt },
+          { type: "image_url", image_url: { url: req.imageDataUrl } }
+        ]
+      }
+    ]
+  });
+  return res.choices?.[0]?.message?.content ?? "";
+}
+async function runLlm(file, isPdf, input, runtime, tmpDir) {
+  const cfg = resolveLlmConfig(runtime);
+  if (!cfg) {
+    throw new Error("\u672A\u914D\u7F6E\u591A\u6A21\u6001\u6A21\u578B\uFF08\u7F3A\u5C11 API key \u6216 model\uFF09");
+  }
+  const images = isPdf ? await pdfToImages(file, tmpDir, input, runtime) : [file];
+  const prompt = "\u8BF7\u9010\u5B57\u63D0\u53D6\u8FD9\u5F20\u56FE\u7247\u4E2D\u7684\u5168\u90E8\u6587\u5B57\uFF0C\u4FDD\u6301\u539F\u6709\u6362\u884C\u4E0E\u987A\u5E8F\u3002\u53EA\u8F93\u51FA\u6587\u5B57\uFF0C\u4E0D\u8981\u89E3\u91CA\u3002";
+  const complete = runtime.overrides.llmComplete ?? defaultLlmComplete;
+  const pages = [];
+  for (let i = 0; i < images.length; i += 1) {
+    const text = await complete({
+      model: cfg.model,
+      prompt,
+      imageDataUrl: toDataUrl(images[i]),
+      baseURL: cfg.baseURL,
+      apiKey: cfg.apiKey
+    });
+    pages.push({ page: i + 1, text: text.trim() });
+  }
+  return pages;
+}
+function joinPages(pages) {
+  if (pages.length === 1) return pages[0].text;
+  return pages.map((p) => `--- page ${p.page} ---
+${p.text}`).join("\n\n");
+}
+function howToFix(platform) {
+  if (platform === "darwin")
+    return [
+      "macOS \u53EF\u4EFB\u9009\u5176\u4E00\uFF1A",
+      "1) \u5B89\u88C5 Xcode Command Line Tools \u4EE5\u542F\u7528\u5185\u7F6E Vision\uFF1Axcode-select --install",
+      "2) \u5B89\u88C5 tesseract \u4E0E poppler\uFF1Abrew install tesseract tesseract-lang poppler",
+      "3) \u7528 /connect \u914D\u7F6E\u652F\u6301\u56FE\u7247\u8F93\u5165\u7684\u591A\u6A21\u6001\u6A21\u578B\u540E\u91CD\u8BD5"
+    ].join("\n");
+  if (platform === "win32")
+    return [
+      "Windows \u53EF\u4EFB\u9009\u5176\u4E00\uFF1A",
+      "1) \u5B89\u88C5 tesseract\uFF1Awinget install UB-Mannheim.TesseractOCR",
+      "2) \u5B89\u88C5 poppler\uFF08PDF \u9700\u8981\uFF09\u5E76\u52A0\u5165 PATH",
+      "3) \u7528 /connect \u914D\u7F6E\u652F\u6301\u56FE\u7247\u8F93\u5165\u7684\u591A\u6A21\u6001\u6A21\u578B\u540E\u91CD\u8BD5"
+    ].join("\n");
+  return [
+    "Linux \u53EF\u4EFB\u9009\u5176\u4E00\uFF1A",
+    "1) apt-get install -y tesseract-ocr tesseract-ocr-chi-sim poppler-utils",
+    "2) \u7528 /connect \u914D\u7F6E\u652F\u6301\u56FE\u7247\u8F93\u5165\u7684\u591A\u6A21\u6001\u6A21\u578B\u540E\u91CD\u8BD5"
+  ].join("\n");
+}
+function engineOrder(runtime) {
+  const forced = (runtime.env.OCR_ENGINE ?? "").toLowerCase();
+  if (forced === "vision" || forced === "tesseract" || forced === "llm")
+    return [forced];
+  return ["vision", "tesseract", "llm"];
+}
+async function recognizeOcr(input, ctx = {}) {
+  const runtime = makeRuntime(ctx);
+  let materialized;
+  try {
+    materialized = await materializeInput(input, runtime);
+  } catch (err) {
+    return {
+      ok: false,
+      error: err.message,
+      how_to_fix: howToFix(runtime.platform),
+      attempts: []
+    };
+  }
+  const attempts = [];
+  try {
+    for (const engine of engineOrder(runtime)) {
+      try {
+        let pages;
+        if (engine === "vision") {
+          const build = await ensureVisionBinary(runtime);
+          if (!build.binary) {
+            attempts.push({ engine, error: build.error ?? "\u4E0D\u53EF\u7528" });
+            continue;
+          }
+          pages = await runVision(
+            build.binary,
+            materialized.file,
+            input,
+            runtime
+          );
+        } else if (engine === "tesseract") {
+          pages = await runTesseract(
+            materialized.file,
+            materialized.isPdf,
+            input,
+            runtime,
+            materialized.tmpDir
+          );
+        } else {
+          pages = await runLlm(
+            materialized.file,
+            materialized.isPdf,
+            input,
+            runtime,
+            materialized.tmpDir
+          );
+        }
+        if (pages.length === 0) throw new Error("\u672A\u8BC6\u522B\u5230\u4EFB\u4F55\u9875\u9762");
+        return {
+          ok: true,
+          text: joinPages(pages),
+          engine,
+          pages
+        };
+      } catch (err) {
+        attempts.push({ engine, error: err.message });
+      }
+    }
+    return {
+      ok: false,
+      error: attempts.length > 0 ? `\u6CA1\u6709\u53EF\u7528\u7684 OCR \u5F15\u64CE: ${attempts.map((a) => `${a.engine}: ${a.error}`).join("; ")}` : "\u6CA1\u6709\u53EF\u7528\u7684 OCR \u5F15\u64CE",
+      how_to_fix: howToFix(runtime.platform),
+      attempts
+    };
+  } finally {
+    materialized.cleanup();
+  }
+}
+
+// src/mcp/builtin/ocr.ts
+var TOOL_NAME = "recognize";
+var TOOL_DESCRIPTION = [
+  "\u4ECE\u56FE\u7247\u3001\u626B\u63CF\u4EF6\u6216 PDF \u4E2D\u63D0\u53D6\u6587\u5B57\uFF08OCR\uFF09\u3002",
+  "\u4F18\u5148\u4F20 imagePath\uFF08\u5DE5\u4F5C\u533A\u5185\u7684\u6587\u4EF6\u8DEF\u5F84\uFF09\uFF0C\u4E5F\u652F\u6301 imageBase64\uFF08\u53EF\u5E26 data URL \u524D\u7F00\uFF09\u6216 imageUrl\u3002",
+  "\u4F20\u5165 PDF \u4F1A\u9010\u9875\u8BC6\u522B\uFF08maxPages \u9ED8\u8BA4 5\uFF0Cdpi \u9ED8\u8BA4 150\uFF09\u3002",
+  "\u8BC6\u522B\u5F15\u64CE\u81EA\u52A8\u9009\u62E9\uFF1AmacOS Vision / tesseract+pdftoppm / \u5DF2\u914D\u7F6E\u7684\u591A\u6A21\u6001\u6A21\u578B\u3002"
+].join("\n");
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    imagePath: {
+      type: "string",
+      description: "\u672C\u5730\u56FE\u7247\u6216 PDF \u8DEF\u5F84\uFF08\u76F8\u5BF9\u8DEF\u5F84\u6309\u5DE5\u4F5C\u533A\u89E3\u6790\uFF09"
+    },
+    imageBase64: {
+      type: "string",
+      description: "\u56FE\u7247\u7684 base64 \u7F16\u7801\uFF08\u53EF\u5E26 data URL \u524D\u7F00\uFF09"
+    },
+    imageUrl: {
+      type: "string",
+      description: "\u8FDC\u7A0B\u56FE\u7247\u6216 PDF \u7684 URL"
+    },
+    maxPages: {
+      type: "number",
+      description: "PDF \u6700\u591A\u8BC6\u522B\u9875\u6570\uFF08\u9ED8\u8BA4 5\uFF0C\u4E0A\u9650 50\uFF09"
+    },
+    dpi: {
+      type: "number",
+      description: "PDF \u6E32\u67D3 DPI\uFF08\u9ED8\u8BA4 150\uFF0C\u4E0A\u9650 400\uFF09"
+    },
+    lang: {
+      type: "string",
+      description: "tesseract \u8BED\u8A00\u5305\uFF08\u9ED8\u8BA4 chi_sim+eng\uFF09"
+    }
+  }
+};
+function createOcrServer(ctx = {}) {
+  const server = new Server(
+    { name: "zqagent-ocr", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: TOOL_NAME,
+        description: TOOL_DESCRIPTION,
+        inputSchema: INPUT_SCHEMA
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name !== TOOL_NAME) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `\u672A\u77E5\u5DE5\u5177 "${request.params.name}"\uFF0C\u53EF\u7528\u5DE5\u5177\uFF1A${TOOL_NAME}`
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const args = request.params.arguments ?? {};
+    const result = await recognizeOcr(args, ctx);
+    if (!result.ok) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                error: result.error,
+                how_to_fix: result.how_to_fix,
+                attempts: result.attempts
+              },
+              null,
+              2
+            )
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: result.text }]
+    };
+  });
+  return server;
+}
+
+// src/mcp/builtin/index.ts
+var FACTORIES = {
+  ocr: createOcrServer
+};
+function listBuiltinServers() {
+  return Object.keys(FACTORIES);
+}
+async function createBuiltinTransport(config, ctx) {
+  const id = config.builtin ?? config.name;
+  const factory = FACTORIES[id];
+  if (!factory) {
+    throw new Error(
+      `\u672A\u77E5\u7684\u5185\u7F6E MCP server "${id}"\uFF08\u53EF\u7528: ${listBuiltinServers().join(", ")}\uFF09`
+    );
+  }
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  const server = factory(ctx);
+  await server.connect(serverTransport);
+  return clientTransport;
+}
+export {
+  createBuiltinTransport,
+  listBuiltinServers
+};
+//# sourceMappingURL=index.js.map