@atlisp/mcp 1.5.0 → 1.5.1

package/dist/atlisp-mcp.js

@@ -1,138 +1,43 @@
 #!/usr/bin/env node
-
-// src/atlisp-mcp.js
-import path7 from "path";
-import fs6 from "fs";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { createRequire } from "module";
-import os4 from "os";
-import express from "express";
-import rawBody from "raw-body";
-import iconv from "iconv-lite";
-import rateLimit from "express-rate-limit";
-import { randomUUID as randomUUID4 } from "crypto";
-import { AsyncLocalStorage } from "async_hooks";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/session-transport.js
-import { randomUUID } from "crypto";
-var SESSION_TIMEOUT = 30 * 60 * 1e3;
-var SessionTransport = class {
-  constructor(sessionId) {
-    this.sessionId = sessionId || randomUUID();
-    this.onclose = null;
-    this.onerror = null;
-    this.onmessage = null;
-    this._pendingRequest = null;
-    this._started = false;
-    this._closed = false;
-    this._cleanupTimer = null;
-  }
-  async start() {
-    if (this._started) {
-      throw new Error("Transport already started");
-    }
-    this._started = true;
-  }
-  async send(message) {
-    if (this._closed) return;
-    if (this._pendingRequest) {
-      const { resolve, reject, timeout } = this._pendingRequest;
-      clearTimeout(timeout);
-      this._pendingRequest = null;
-      resolve(message);
-    }
-  }
-  async close() {
-    if (this._closed) return;
-    this._closed = true;
-    if (this._pendingRequest) {
-      const { reject, timeout } = this._pendingRequest;
-      clearTimeout(timeout);
-      this._pendingRequest = null;
-      reject(new Error("Transport closed"));
-    }
-    this._clearCleanupTimer();
-    this.onclose?.();
-  }
-  async handleRequest(message, timeoutMs = 6e4) {
-    if (this._closed) {
-      throw new Error("Transport closed");
-    }
-    if (!message || !message.method) {
-      throw new Error("Invalid message");
-    }
-    if (!message.id) {
-      this.onmessage?.(message);
-      return null;
-    }
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        if (this._pendingRequest?.resolve === resolve) {
-          this._pendingRequest = null;
-          reject(new Error("Request timeout"));
-        }
-      }, timeoutMs);
-      this._pendingRequest = { resolve, reject, timeout };
-      this.onmessage?.(message);
-    });
-  }
-  resetCleanupTimer() {
-    this._clearCleanupTimer();
-    this._cleanupTimer = setTimeout(() => {
-      this.close();
-    }, SESSION_TIMEOUT);
-  }
-  _clearCleanupTimer() {
-    if (this._cleanupTimer) {
-      clearTimeout(this._cleanupTimer);
-      this._cleanupTimer = null;
-    }
-  }
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-
-// src/atlisp-mcp.js
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  SubscribeRequestSchema,
-  UnsubscribeRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-
-// src/cad.js
-import { spawn } from "child_process";
-import path from "path";
-import { fileURLToPath } from "url";
-import { randomUUID as randomUUID2 } from "crypto";
 
 // src/constants.js
-var CAD_PLATFORMS = ["AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD"];
-var FILE_EXTENSIONS = {
-  "AutoCAD": [".fas", ".vlx"],
-  "ZWCAD": [".zelx", ".vls"],
-  "GStarCAD": [".fas", ".vlx"],
-  "BricsCAD": [".des"]
-};
-var SERVER_NAME = "atlisp-mcp-server";
-var SERVER_VERSION = "1.5.0";
-var MOCK_PACKAGES = [
-  { name: "base", description: "\u57FA\u7840\u51FD\u6570\u5E93", version: "1.0.0" },
-  { name: "at-pm", description: "\u5DE5\u7A0B\u9879\u76EE\u7BA1\u7406", version: "2.1.0" },
-  { name: "network", description: "\u7F51\u7EDC\u529F\u80FD\u6A21\u5757", version: "1.5.0" },
-  { name: "userman", description: "\u7528\u6237\u7BA1\u7406", version: "1.2.0" },
-  { name: "pkgman", description: "\u5305\u7BA1\u7406\u5668", version: "2.0.0" },
-  { name: "sidebar", description: "\u4FA7\u8FB9\u680F\u5DE5\u5177", version: "1.0.0" },
-  { name: "aibot", description: "AI \u52A9\u624B", version: "0.9.0" },
-  { name: "tips", description: "\u6BCF\u65E5\u63D0\u793A", version: "1.0.0" },
-  { name: "function", description: "\u51FD\u6570\u5E93", version: "3.0.0" }
-];
+var CAD_PLATFORMS, FILE_EXTENSIONS, SERVER_NAME, SERVER_VERSION, MOCK_PACKAGES;
+var init_constants = __esm({
+  "src/constants.js"() {
+    CAD_PLATFORMS = ["AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD"];
+    FILE_EXTENSIONS = {
+      "AutoCAD": [".fas", ".vlx"],
+      "ZWCAD": [".zelx", ".vls"],
+      "GStarCAD": [".fas", ".vlx"],
+      "BricsCAD": [".des"]
+    };
+    SERVER_NAME = "atlisp-mcp-server";
+    SERVER_VERSION = "1.5.0";
+    MOCK_PACKAGES = [
+      { name: "base", description: "\u57FA\u7840\u51FD\u6570\u5E93", version: "1.0.0" },
+      { name: "at-pm", description: "\u5DE5\u7A0B\u9879\u76EE\u7BA1\u7406", version: "2.1.0" },
+      { name: "network", description: "\u7F51\u7EDC\u529F\u80FD\u6A21\u5757", version: "1.5.0" },
+      { name: "userman", description: "\u7528\u6237\u7BA1\u7406", version: "1.2.0" },
+      { name: "pkgman", description: "\u5305\u7BA1\u7406\u5668", version: "2.0.0" },
+      { name: "sidebar", description: "\u4FA7\u8FB9\u680F\u5DE5\u5177", version: "1.0.0" },
+      { name: "aibot", description: "AI \u52A9\u624B", version: "0.9.0" },
+      { name: "tips", description: "\u6BCF\u65E5\u63D0\u793A", version: "1.0.0" },
+      { name: "function", description: "\u51FD\u6570\u5E93", version: "3.0.0" }
+    ];
+  }
+});
 
 // src/config.js
+import { z } from "zod";
 function parseArgs() {
   const args = process.argv.slice(2);
   const result = { transport: "http", port: "8110", host: "0.0.0.0" };
@@ -152,42 +57,65 @@ function parseArgs() {
   }
   return result;
 }
-var cliArgs = parseArgs();
-var config = {
-  port: parseInt(process.env.PORT || cliArgs.port, 10),
-  host: process.env.HOST || cliArgs.host,
-  transport: process.env.TRANSPORT || cliArgs.transport,
-  apiKey: process.env.MCP_API_KEY || "",
-  enableSse: process.env.ENABLE_SSE !== "false",
-  messageTimeout: parseInt(process.env.MESSAGE_TIMEOUT || "60000", 10),
-  heartbeatInterval: parseInt(process.env.HEARTBEAT_INTERVAL || "30000", 10),
-  busyRetries: parseInt(process.env.BUSY_RETRIES || "10", 10),
-  busyDelay: parseInt(process.env.BUSY_DELAY || "500", 10),
-  enableCors: process.env.ENABLE_CORS !== "false",
-  corsOrigin: process.env.CORS_ORIGIN || "*",
-  rateLimitWindow: parseInt(process.env.RATE_LIMIT_WINDOW || "60000", 10),
-  rateLimitMax: parseInt(process.env.RATE_LIMIT_MAX || "100", 10),
-  resourceCacheTtl: parseInt(process.env.RESOURCE_CACHE_TTL || "5000", 10),
-  debug: process.env.DEBUG === "true",
-  debugFile: process.env.DEBUG_FILE || ""
-};
-var config_default = config;
+var envSchema, cliArgs, envResult, env, config, config_default;
+var init_config = __esm({
+  "src/config.js"() {
+    envSchema = z.object({
+      PORT: z.string().optional().default("8110"),
+      HOST: z.string().optional().default("0.0.0.0"),
+      TRANSPORT: z.enum(["http", "stdio"]).optional().default("http"),
+      MCP_API_KEY: z.string().optional().default(""),
+      ENABLE_SSE: z.string().optional().default("true"),
+      MESSAGE_TIMEOUT: z.string().optional().default("60000"),
+      HEARTBEAT_INTERVAL: z.string().optional().default("30000"),
+      BUSY_RETRIES: z.string().optional().default("10"),
+      BUSY_DELAY: z.string().optional().default("500"),
+      ENABLE_CORS: z.string().optional().default("true"),
+      CORS_ORIGIN: z.string().optional().default("*"),
+      RATE_LIMIT_WINDOW: z.string().optional().default("60000"),
+      RATE_LIMIT_MAX: z.string().optional().default("100"),
+      RESOURCE_CACHE_TTL: z.string().optional().default("5000"),
+      FUNCTION_LIB_CACHE_TTL: z.string().optional().default("300000"),
+      DEBUG: z.string().optional().default("false"),
+      DEBUG_FILE: z.string().optional().default(""),
+      FUNCTION_LIB_URL: z.string().optional().default("http://s3.atlisp.cn/json/functions.json")
+    });
+    cliArgs = parseArgs();
+    envResult = envSchema.safeParse(process.env);
+    if (!envResult.success) {
+      console.error("\u73AF\u5883\u53D8\u91CF\u914D\u7F6E\u9519\u8BEF:", envResult.error.flatten().fieldErrors);
+      process.exit(1);
+    }
+    env = envResult.data;
+    config = {
+      port: parseInt(env.PORT || cliArgs.port, 10),
+      host: env.HOST || cliArgs.host,
+      transport: process.env.TRANSPORT ? env.TRANSPORT : cliArgs.transport,
+      apiKey: env.MCP_API_KEY,
+      enableSse: env.ENABLE_SSE === "true",
+      messageTimeout: parseInt(env.MESSAGE_TIMEOUT, 10),
+      heartbeatInterval: parseInt(env.HEARTBEAT_INTERVAL, 10),
+      busyRetries: parseInt(env.BUSY_RETRIES, 10),
+      busyDelay: parseInt(env.BUSY_DELAY, 10),
+      enableCors: env.ENABLE_CORS === "true",
+      corsOrigin: env.CORS_ORIGIN,
+      rateLimitWindow: parseInt(env.RATE_LIMIT_WINDOW, 10),
+      rateLimitMax: parseInt(env.RATE_LIMIT_MAX, 10),
+      resourceCacheTtl: parseInt(env.RESOURCE_CACHE_TTL, 10),
+      functionLibCacheTtl: parseInt(env.FUNCTION_LIB_CACHE_TTL, 10),
+      debug: env.DEBUG === "true",
+      debugFile: env.DEBUG_FILE,
+      functionLibUrl: env.FUNCTION_LIB_URL
+    };
+    config_default = config;
+  }
+});
 
 // src/cad.js
-var MESSAGE_TIMEOUT = config_default.messageTimeout;
-var HEARTBEAT_INTERVAL = config_default.heartbeatInterval;
-var MAX_RESTART_ATTEMPTS = 5;
-var RESTART_BACKOFF_BASE = 1e3;
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
-var workerPath = path.join(__dirname, "cad-worker.js");
-var worker = null;
-var _platform = null;
-var heartbeatTimer = null;
-var pendingRequests = /* @__PURE__ */ new Map();
-var stdoutHandlerSetup = false;
-var MAX_BUFFER_SIZE = 1024 * 1024;
-var restartCount = 0;
-var restartTimer = null;
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { randomUUID } from "crypto";
 function resetWorker() {
   for (const [id, { reject, timeout }] of pendingRequests) {
     clearTimeout(timeout);
@@ -308,7 +236,7 @@ function startHeartbeat() {
 }
 function sendMessage(msg) {
   const w = getWorker();
-  const requestId = randomUUID2();
+  const requestId = randomUUID();
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
       const pending = pendingRequests.get(requestId);
@@ -327,125 +255,142 @@ function sendMessage(msg) {
     }
   });
 }
-var CadConnection = class {
-  constructor() {
-    this.connected = false;
-    this.version = null;
-    this.product = null;
-  }
-  isAvailable() {
-    return process.platform === "win32";
-  }
-  async connect(platform = null) {
-    if (!this.isAvailable()) return false;
-    try {
-      const msg = platform ? { type: "connect", platform } : { type: "connect" };
-      const result = await sendMessage(msg);
-      if (result && result.success) {
-        this.version = result.version;
-        this.product = result.platform;
-        _platform = result.platform;
-        this.connected = true;
-        return true;
-      }
-    } catch (e) {
-      console.error("CAD connect error:", e.message);
-    }
-    return false;
-  }
-  async sendCommand(code) {
-    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
-    const result = await sendMessage({ type: "send", code, platform: _platform });
-    if (result.success) return true;
-    throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
-  }
-  async sendCommandWithResult(code, encoding = null) {
-    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
-    const result = await sendMessage({ type: "sendResult", code, platform: _platform, encoding: encoding || "" });
-    if (result.success) {
-      return result.result || "";
-    }
-    throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
-  }
-  getVersion() {
-    return this.version;
-  }
-  getPlatform() {
-    return this.product;
-  }
-  async isBusy() {
-    if (!this.connected) return false;
-    try {
-      const result = await sendMessage({ type: "isBusy", platform: _platform });
-      return result && result.isBusy;
-    } catch (e) {
-      return false;
-    }
-  }
-  async hasDoc() {
-    if (!this.connected) return { hasDoc: false, docCount: 0 };
-    try {
-      const result = await sendMessage({ type: "hasdoc", platform: _platform });
-      return result || { hasDoc: false, docCount: 0 };
-    } catch (e) {
-      return { hasDoc: false, docCount: 0 };
-    }
-  }
-  async newDoc() {
-    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
-    try {
-      const result = await sendMessage({ type: "newdoc", platform: _platform });
-      return result && result.success;
-    } catch (e) {
-      return false;
-    }
-  }
-  async bringToFront() {
-    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
-    try {
-      const result = await sendMessage({ type: "bringToFront", platform: _platform });
-      return result && result.success;
-    } catch (e) {
-      return false;
-    }
-  }
-  async getInfo() {
-    if (!this.connected) return "CAD \u672A\u8FDE\u63A5";
-    return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
-  }
-  async disconnect() {
-    this.connected = false;
-    this.version = null;
-    this.product = null;
-    _platform = null;
-    resetWorker();
-  }
-  async ping() {
-    try {
-      const result = await sendMessage({ type: "ping" });
-      return result && result.pong;
-    } catch (e) {
-      return false;
-    }
-  }
-  _reset() {
-    this.connected = false;
-    this.version = null;
-    this.product = null;
+var MESSAGE_TIMEOUT, HEARTBEAT_INTERVAL, MAX_RESTART_ATTEMPTS, RESTART_BACKOFF_BASE, __dirname, workerPath, worker, _platform, heartbeatTimer, pendingRequests, stdoutHandlerSetup, MAX_BUFFER_SIZE, restartCount, restartTimer, CadConnection, cad;
+var init_cad = __esm({
+  "src/cad.js"() {
+    init_constants();
+    init_config();
+    MESSAGE_TIMEOUT = config_default.messageTimeout;
+    HEARTBEAT_INTERVAL = config_default.heartbeatInterval;
+    MAX_RESTART_ATTEMPTS = 5;
+    RESTART_BACKOFF_BASE = 1e3;
+    __dirname = path.dirname(fileURLToPath(import.meta.url));
+    workerPath = path.join(__dirname, "cad-worker.js");
+    worker = null;
     _platform = null;
-    resetWorker();
+    heartbeatTimer = null;
+    pendingRequests = /* @__PURE__ */ new Map();
+    stdoutHandlerSetup = false;
+    MAX_BUFFER_SIZE = 1024 * 1024;
+    restartCount = 0;
+    restartTimer = null;
+    CadConnection = class {
+      constructor() {
+        this.connected = false;
+        this.version = null;
+        this.product = null;
+      }
+      isAvailable() {
+        return process.platform === "win32";
+      }
+      async connect(platform = null) {
+        if (!this.isAvailable()) return false;
+        try {
+          const msg = platform ? { type: "connect", platform } : { type: "connect" };
+          const result = await sendMessage(msg);
+          if (result && result.success) {
+            this.version = result.version;
+            this.product = result.platform;
+            _platform = result.platform;
+            this.connected = true;
+            return true;
+          }
+        } catch (e) {
+          console.error("CAD connect error:", e.message);
+        }
+        return false;
+      }
+      async sendCommand(code) {
+        if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+        const result = await sendMessage({ type: "send", code, platform: _platform });
+        if (result.success) return true;
+        throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
+      }
+      async sendCommandWithResult(code, encoding = null) {
+        if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+        const result = await sendMessage({ type: "sendResult", code, platform: _platform, encoding: encoding || "" });
+        if (result.success) {
+          return result.result || "";
+        }
+        throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
+      }
+      getVersion() {
+        return this.version;
+      }
+      getPlatform() {
+        return this.product;
+      }
+      async isBusy() {
+        if (!this.connected) return false;
+        try {
+          const result = await sendMessage({ type: "isBusy", platform: _platform });
+          return result && result.isBusy;
+        } catch (e) {
+          return false;
+        }
+      }
+      async hasDoc() {
+        if (!this.connected) return { hasDoc: false, docCount: 0 };
+        try {
+          const result = await sendMessage({ type: "hasdoc", platform: _platform });
+          return result || { hasDoc: false, docCount: 0 };
+        } catch (e) {
+          return { hasDoc: false, docCount: 0 };
+        }
+      }
+      async newDoc() {
+        if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+        try {
+          const result = await sendMessage({ type: "newdoc", platform: _platform });
+          return result && result.success;
+        } catch (e) {
+          return false;
+        }
+      }
+      async bringToFront() {
+        if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+        try {
+          const result = await sendMessage({ type: "bringToFront", platform: _platform });
+          return result && result.success;
+        } catch (e) {
+          return false;
+        }
+      }
+      async getInfo() {
+        if (!this.connected) return "CAD \u672A\u8FDE\u63A5";
+        return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
+      }
+      async disconnect() {
+        this.connected = false;
+        this.version = null;
+        this.product = null;
+        _platform = null;
+        resetWorker();
+      }
+      async ping() {
+        try {
+          const result = await sendMessage({ type: "ping" });
+          return result && result.pong;
+        } catch (e) {
+          return false;
+        }
+      }
+      _reset() {
+        this.connected = false;
+        this.version = null;
+        this.product = null;
+        _platform = null;
+        resetWorker();
+      }
+    };
+    cad = new CadConnection();
   }
-};
-var cad = new CadConnection();
+});
 
 // src/logger.js
 import fs from "fs";
 import path2 from "path";
 import os from "os";
-var DEBUG_FILE = process.env.DEBUG_FILE || path2.join(os.tmpdir(), "mcp-server-debug.log");
-var MAX_LOG_SIZE = 10 * 1024 * 1024;
-var MAX_LOG_FILES = 5;
-var stream = null;
 function rotateLog() {
   if (!fs.existsSync(DEBUG_FILE)) return;
   const stat = fs.statSync(DEBUG_FILE);
@@ -476,10 +421,27 @@ function getStream() {
   }
   return stream;
 }
-function log(msg) {
-  const entry = `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
-`;
-  getStream().write(entry);
+function formatMessage(level, message, meta = {}) {
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    message,
+    ...meta,
+    pid: process.pid,
+    hostname: os.hostname()
+  };
+  return JSON.stringify(entry);
+}
+function log(message, meta = {}) {
+  if (config_default.debug) {
+    getStream().write(formatMessage("INFO", message, meta) + "\n");
+  }
+}
+function error(message, meta = {}) {
+  getStream().write(formatMessage("ERROR", message, meta) + "\n");
+  if (config_default.debug) {
+    console.error(`[ERROR] ${message}`, meta);
+  }
 }
 function closeLog() {
   if (stream) {
@@ -487,6 +449,16 @@ function closeLog() {
     stream = null;
   }
 }
+var DEBUG_FILE, MAX_LOG_SIZE, MAX_LOG_FILES, stream;
+var init_logger = __esm({
+  "src/logger.js"() {
+    init_config();
+    DEBUG_FILE = config_default.debugFile || path2.join(os.tmpdir(), "mcp-server-debug.log");
+    MAX_LOG_SIZE = 10 * 1024 * 1024;
+    MAX_LOG_FILES = 5;
+    stream = null;
+  }
+});
 
 // src/handlers/cad-handlers.js
 async function connectCad(platform = null) {
@@ -651,12 +623,14 @@ async function initAtlisp() {
     return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
   }
 }
+var init_cad_handlers = __esm({
+  "src/handlers/cad-handlers.js"() {
+    init_cad();
+    init_logger();
+  }
+});
 
 // src/handlers/package-handlers.js
-var PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || "http://s3.atlisp.cn/packages-list?fmt=json";
-var cachedPackages = null;
-var cachedAt = null;
-var CACHE_TTL = 10 * 60 * 1e3;
 async function fetchPackages() {
   const now = Date.now();
   if (cachedPackages && cachedAt && now - cachedAt < CACHE_TTL) {
@@ -732,16 +706,22 @@ async function installPackage(packageName) {
   }
   return { content: [{ type: "text", text: `\u5305 "${packageName}" \u5B89\u88C5\u547D\u4EE4\u5DF2\u53D1\u9001\uFF01` }] };
 }
+var PACKAGES_LIST_URL, cachedPackages, cachedAt, CACHE_TTL;
+var init_package_handlers = __esm({
+  "src/handlers/package-handlers.js"() {
+    init_cad();
+    init_constants();
+    PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || "http://s3.atlisp.cn/packages-list?fmt=json";
+    cachedPackages = null;
+    cachedAt = null;
+    CACHE_TTL = 10 * 60 * 1e3;
+  }
+});
 
 // src/handlers/function-handlers.js
 import fs2 from "fs";
 import path3 from "path";
 import os2 from "os";
-var FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || "";
-var FUNCTIONS_URL = process.env.FUNCTIONS_URL || "http://s3.atlisp.cn/json/functions.json";
-var CACHE_DIR = path3.join(os2.homedir(), ".atlisp", "cache");
-var FUNCLIB_CACHE_FILE = path3.join(CACHE_DIR, "functions.json");
-var FUNCLIB_CACHE_TTL = 24 * 60 * 60 * 1e3;
 function readCacheFromDisk() {
   try {
     const stat = fs2.statSync(FUNCLIB_CACHE_FILE);
@@ -854,15 +834,23 @@ ${allFuncs.map((f) => f.name).join("\n")}` }] };
     return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
   }
 }
+var FUNCTIONS_DIR, FUNCTIONS_URL, CACHE_DIR, FUNCLIB_CACHE_FILE, FUNCLIB_CACHE_TTL;
+var init_function_handlers = __esm({
+  "src/handlers/function-handlers.js"() {
+    init_logger();
+    init_cad_handlers();
+    FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || "";
+    FUNCTIONS_URL = process.env.FUNCTIONS_URL || "http://s3.atlisp.cn/json/functions.json";
+    CACHE_DIR = path3.join(os2.homedir(), ".atlisp", "cache");
+    FUNCLIB_CACHE_FILE = path3.join(CACHE_DIR, "functions.json");
+    FUNCLIB_CACHE_TTL = 24 * 60 * 60 * 1e3;
+  }
+});
 
 // src/handlers/resource-handlers.js
 import fs3 from "fs";
 import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
-var STANDARDS_DIR = path4.join(__dirname2, "..", "standards");
-var CACHE_TTL2 = config_default.resourceCacheTtl;
-var resourceCache = /* @__PURE__ */ new Map();
 function getCached(key) {
   const entry = resourceCache.get(key);
   if (entry && Date.now() - entry.timestamp < CACHE_TTL2) {
@@ -1143,19 +1131,6 @@ function buildTextCode({ layer, bbox, offset, limit }) {
 (@t:run))
 `;
 }
-var RESOURCES = [
-  { uri: "atlisp://cad/info", name: "CAD Info", description: "CAD \u8FDE\u63A5\u4FE1\u606F", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://dwg/layers", name: "Layers", description: "\u56FE\u5C42\u5217\u8868", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://dwg/entities", name: "Entities", description: "\u56FE\u5143\u5217\u8868\uFF0C\u8FD4\u56DE\u603B\u6570\u548C\u524D3000\u4E2A\u56FE\u5143\uFF0C\u6587\u672C\u9644\u52A0 text \u5B57\u6BB5\uFF0C\u66F2\u7EBF\u9644\u52A0 points \u6570\u7EC4\uFF0CINSERT \u9644\u52A0 blockName\uFF0C\u652F\u6301 ?type=LINE&layer=0&bbox=0,0,100,100 \u8FC7\u6EE4", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://dwg/texts", name: "Texts", description: "\u6587\u672C\u5B9E\u4F53\u5185\u5BB9\u5217\u8868 (TEXT/MTEXT/ATTRIB/TCH_TEXT)\uFF0C\u652F\u6301 ?layer=0&bbox=0,0,100,100&limit=5000&offset=0", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://dwg/name", name: "DWG Name", description: "\u5F53\u524D DWG \u6587\u4EF6\u540D", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://dwg/path", name: "DWG Path", description: "\u6587\u4EF6\u5B8C\u6574\u8DEF\u5F84", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://cad/dwgs", name: "DWG List", description: "\u6240\u6709\u6253\u5F00\u7684 DWG \u6587\u4EF6\u5217\u8868", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://packages", name: "Packages", description: "\u5DF2\u5B89\u88C5\u5305\u5217\u8868", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://platforms", name: "Platforms", description: "\u652F\u6301\u7684\u5E73\u53F0\u4FE1\u606F", mimeType: "application/json", subscribable: false },
-  { uri: "atlisp://standards/drafting", name: "Drafting Standards", description: "CAD \u5236\u56FE\u89C4\u8303", mimeType: "application/json", subscribable: false },
-  { uri: "atlisp://standards/coding", name: "Coding Standards", description: "@lisp \u7F16\u7801\u89C4\u8303", mimeType: "application/json", subscribable: false }
-];
 function parseQuery(uri) {
   const qIdx = uri.indexOf("?");
   if (qIdx === -1) return { base: uri, params: {} };
@@ -1534,7 +1509,6 @@ function loadStandardsFile(filename) {
     return null;
   }
 }
-var standardsCache = /* @__PURE__ */ new Map();
 function getCachedStandards(key) {
   const entry = standardsCache.get(key);
   if (entry && Date.now() - entry.timestamp < 3e4) return entry.data;
@@ -1558,16 +1532,38 @@ function getCodingStandards() {
   if (data) setCachedStandards("coding", data);
   return data || { error: "\u7F16\u7801\u89C4\u8303\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25" };
 }
+var __dirname2, STANDARDS_DIR, CACHE_TTL2, resourceCache, RESOURCES, standardsCache;
+var init_resource_handlers = __esm({
+  "src/handlers/resource-handlers.js"() {
+    init_cad();
+    init_constants();
+    init_logger();
+    init_config();
+    __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+    STANDARDS_DIR = path4.join(__dirname2, "..", "standards");
+    CACHE_TTL2 = config_default.resourceCacheTtl;
+    resourceCache = /* @__PURE__ */ new Map();
+    RESOURCES = [
+      { uri: "atlisp://cad/info", name: "CAD Info", description: "CAD \u8FDE\u63A5\u4FE1\u606F", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://dwg/layers", name: "Layers", description: "\u56FE\u5C42\u5217\u8868", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://dwg/entities", name: "Entities", description: "\u56FE\u5143\u5217\u8868\uFF0C\u8FD4\u56DE\u603B\u6570\u548C\u524D3000\u4E2A\u56FE\u5143\uFF0C\u6587\u672C\u9644\u52A0 text \u5B57\u6BB5\uFF0C\u66F2\u7EBF\u9644\u52A0 points \u6570\u7EC4\uFF0CINSERT \u9644\u52A0 blockName\uFF0C\u652F\u6301 ?type=LINE&layer=0&bbox=0,0,100,100 \u8FC7\u6EE4", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://dwg/texts", name: "Texts", description: "\u6587\u672C\u5B9E\u4F53\u5185\u5BB9\u5217\u8868 (TEXT/MTEXT/ATTRIB/TCH_TEXT)\uFF0C\u652F\u6301 ?layer=0&bbox=0,0,100,100&limit=5000&offset=0", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://dwg/name", name: "DWG Name", description: "\u5F53\u524D DWG \u6587\u4EF6\u540D", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://dwg/path", name: "DWG Path", description: "\u6587\u4EF6\u5B8C\u6574\u8DEF\u5F84", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://cad/dwgs", name: "DWG List", description: "\u6240\u6709\u6253\u5F00\u7684 DWG \u6587\u4EF6\u5217\u8868", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://packages", name: "Packages", description: "\u5DF2\u5B89\u88C5\u5305\u5217\u8868", mimeType: "application/json", subscribable: true },
+      { uri: "atlisp://platforms", name: "Platforms", description: "\u652F\u6301\u7684\u5E73\u53F0\u4FE1\u606F", mimeType: "application/json", subscribable: false },
+      { uri: "atlisp://standards/drafting", name: "Drafting Standards", description: "CAD \u5236\u56FE\u89C4\u8303", mimeType: "application/json", subscribable: false },
+      { uri: "atlisp://standards/coding", name: "Coding Standards", description: "@lisp \u7F16\u7801\u89C4\u8303", mimeType: "application/json", subscribable: false }
+    ];
+    standardsCache = /* @__PURE__ */ new Map();
+  }
+});
 
 // src/handlers/prompt-handlers.js
 import fs4 from "fs";
 import path5 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
-var PROMPTS_DIR = path5.join(__dirname3, "..", "prompts");
-var externalPrompts = null;
-var externalPromptsAt = 0;
-var EXTERNAL_PROMPTS_TTL = 3e4;
 function loadExternalPrompts() {
   const now = Date.now();
   if (externalPrompts && now - externalPromptsAt < EXTERNAL_PROMPTS_TTL) {
@@ -1597,121 +1593,6 @@ function loadExternalPrompts() {
   externalPromptsAt = now;
   return externalPrompts;
 }
-var PROMPTS = [
-  {
-    name: "analyze-drawing",
-    description: "\u5206\u6790\u5F53\u524D\u56FE\u7EB8\u7EDF\u8BA1\u4FE1\u606F",
-    arguments: []
-  },
-  {
-    name: "batch-draw-lines",
-    description: "\u6279\u91CF\u7ED8\u5236\u7EBF\u6BB5",
-    arguments: [
-      { name: "count", description: "\u7EBF\u6BB5\u6570\u91CF", required: true },
-      { name: "length", description: "\u7EBF\u6BB5\u957F\u5EA6", required: false }
-    ]
-  },
-  {
-    name: "generate-dimension",
-    description: "\u751F\u6210\u5C3A\u5BF8\u6807\u6CE8",
-    arguments: [
-      { name: "style", description: "\u6807\u6CE8\u6837\u5F0F (horizontal/vertical/aligned)", required: false }
-    ]
-  },
-  {
-    name: "export-entities",
-    description: "\u5BFC\u51FA\u56FE\u7EB8\u5B9E\u4F53\u7EDF\u8BA1",
-    arguments: [
-      { name: "format", description: "\u5BFC\u51FA\u683C\u5F0F (json/list)", required: false }
-    ]
-  },
-  {
-    name: "manage-layers",
-    description: "\u56FE\u5C42\u7BA1\u7406\uFF1A\u521B\u5EFA\u3001\u51BB\u7ED3\u3001\u9501\u5B9A\u3001\u5220\u9664\u56FE\u5C42",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/freeze/lock/off/make/delete)", required: true },
-      { name: "layers", description: "\u56FE\u5C42\u540D\uFF0C\u591A\u4E2A\u7528\u9017\u53F7\u5206\u9694", required: false },
-      { name: "color", description: '\u56FE\u5C42\u989C\u8272 (ACI\u53F7\u6216RGB\u5982 "1,2,3")', required: false }
-    ]
-  },
-  {
-    name: "manage-blocks",
-    description: "\u5757\u64CD\u4F5C\uFF1A\u63D2\u5165\u5757\u3001\u5217\u51FA\u5757\u3001\u83B7\u53D6/\u8BBE\u7F6E\u5C5E\u6027",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/insert/attributes/dynprops)", required: true },
-      { name: "blockName", description: "\u5757\u540D", required: false },
-      { name: "insertPoint", description: '\u63D2\u5165\u70B9 "x,y"', required: false },
-      { name: "scale", description: "\u7F29\u653E\u6BD4\u4F8B", required: false }
-    ]
-  },
-  {
-    name: "curve-analysis",
-    description: "\u66F2\u7EBF\u5206\u6790\uFF1A\u4EA4\u70B9\u3001\u6700\u8FD1\u70B9\u3001\u5B50\u6BB5\u3001\u7F13\u51B2\u533A",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C (inters/subsegments/closestpoint/join)", required: true },
-      { name: "distance", description: "\u8FDE\u63A5\u5BB9\u5DEE/\u504F\u79FB\u8DDD\u79BB", required: false }
-    ]
-  },
-  {
-    name: "geometry-calc",
-    description: "\u51E0\u4F55\u8BA1\u7B97\uFF1A\u51F8\u5305\u3001\u70B9\u5230\u7EBF\u8DDD\u79BB\u3001\u9762\u5185\u6D4B\u8BD5\u3001\u53D8\u6362",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C (convexhull/dist-point-line/in-curve-p/transform/centroid)", required: true },
-      { name: "points", description: '\u70B9\u96C6 "x1,y1;x2,y2;..."', required: false }
-    ]
-  },
-  {
-    name: "text-process",
-    description: "\u6587\u672C\u5904\u7406\uFF1AMTEXT\u89E3\u6790\u3001Markdown\u8F6CMTEXT\u3001\u53BB\u683C\u5F0F",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C (parse-mtext/remove-fmt/from-markdown/mtext2text)", required: true },
-      { name: "markdown", description: "Markdown\u6587\u672C\uFF08from-markdown\u64CD\u4F5C\u65F6\u7528\uFF09", required: false }
-    ]
-  },
-  {
-    name: "pickset-filter",
-    description: "\u9009\u62E9\u96C6\u64CD\u4F5C\uFF1A\u8FC7\u6EE4\u3001\u8F6C\u6362\u3001\u6279\u91CF\u64CD\u4F5C",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C (by-layer/by-type/by-box/erase/zoom)", required: true },
-      { name: "dxfType", description: 'DXF\u7C7B\u578B "LINE, CIRCLE, LWPOLYLINE, INSERT, TEXT"', required: false },
-      { name: "layerName", description: "\u56FE\u5C42\u540D", required: false }
-    ]
-  },
-  {
-    name: "color-convert",
-    description: "\u989C\u8272\u8F6C\u6362\uFF1AACI/RGB/TrueColor/CSS\u4E92\u8F6C",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C (aci2rgb/rgb2css/truecolor2rgb/rgb2truecolor)", required: true },
-      { name: "value", description: "\u989C\u8272\u503C", required: true }
-    ]
-  },
-  {
-    name: "json-exchange",
-    description: "JSON\u6570\u636E\u4EA4\u6362\uFF1A\u4ECE\u5B57\u7B26\u4E32\u89E3\u6790JSON alist\uFF0C\u4ECEalist\u751F\u6210JSON",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C (encode/decode)", required: true },
-      { name: "data", description: "JSON\u5B57\u7B26\u4E32\u6216Lisp alist\u6587\u672C", required: true }
-    ]
-  },
-  {
-    name: "excel-report",
-    description: "Excel\u62A5\u8868\uFF1A\u5BFC\u51FACAD\u5B9E\u4F53\u6570\u636E\u5230Excel",
-    arguments: [
-      { name: "visible", description: "\u662F\u5426\u663E\u793AExcel\u7A97\u53E3 (true/false)", required: false },
-      { name: "savePath", description: "\u4FDD\u5B58\u8DEF\u5F84\uFF0C\u4E0D\u586B\u5219\u4E0D\u4FDD\u5B58", required: false }
-    ]
-  },
-  {
-    name: "string-process",
-    description: "\u5B57\u7B26\u4E32\u5904\u7406\uFF1A\u683C\u5F0F\u5316\u3001\u62C6\u5206\u3001\u66FF\u6362\u3001\u6B63\u5219",
-    arguments: [
-      { name: "action", description: "\u64CD\u4F5C (format/split/subst-all/regexp/trim/number2chinese)", required: true },
-      { name: "input", description: "\u8F93\u5165\u5B57\u7B26\u4E32", required: true },
-      { name: "arg1", description: "\u53C2\u65701\uFF08\u683C\u5F0F\u53C2\u6570/\u5206\u9694\u7B26/\u65E7\u4E32\uFF09", required: false },
-      { name: "arg2", description: "\u53C2\u65702\uFF08\u65B0\u4E32/\u6B63\u5219\u6A21\u5F0F\uFF09", required: false }
-    ]
-  }
-];
 function findExternalPrompt(name) {
   const ext = loadExternalPrompts();
   return ext.find((p) => p.name === name);
@@ -2328,86 +2209,215 @@ ${code}
     }]
   };
 }
+var __dirname3, PROMPTS_DIR, externalPrompts, externalPromptsAt, EXTERNAL_PROMPTS_TTL, PROMPTS;
+var init_prompt_handlers = __esm({
+  "src/handlers/prompt-handlers.js"() {
+    init_cad();
+    __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+    PROMPTS_DIR = path5.join(__dirname3, "..", "prompts");
+    externalPrompts = null;
+    externalPromptsAt = 0;
+    EXTERNAL_PROMPTS_TTL = 3e4;
+    PROMPTS = [
+      {
+        name: "analyze-drawing",
+        description: "\u5206\u6790\u5F53\u524D\u56FE\u7EB8\u7EDF\u8BA1\u4FE1\u606F",
+        arguments: []
+      },
+      {
+        name: "batch-draw-lines",
+        description: "\u6279\u91CF\u7ED8\u5236\u7EBF\u6BB5",
+        arguments: [
+          { name: "count", description: "\u7EBF\u6BB5\u6570\u91CF", required: true },
+          { name: "length", description: "\u7EBF\u6BB5\u957F\u5EA6", required: false }
+        ]
+      },
+      {
+        name: "generate-dimension",
+        description: "\u751F\u6210\u5C3A\u5BF8\u6807\u6CE8",
+        arguments: [
+          { name: "style", description: "\u6807\u6CE8\u6837\u5F0F (horizontal/vertical/aligned)", required: false }
+        ]
+      },
+      {
+        name: "export-entities",
+        description: "\u5BFC\u51FA\u56FE\u7EB8\u5B9E\u4F53\u7EDF\u8BA1",
+        arguments: [
+          { name: "format", description: "\u5BFC\u51FA\u683C\u5F0F (json/list)", required: false }
+        ]
+      },
+      {
+        name: "manage-layers",
+        description: "\u56FE\u5C42\u7BA1\u7406\uFF1A\u521B\u5EFA\u3001\u51BB\u7ED3\u3001\u9501\u5B9A\u3001\u5220\u9664\u56FE\u5C42",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/freeze/lock/off/make/delete)", required: true },
+          { name: "layers", description: "\u56FE\u5C42\u540D\uFF0C\u591A\u4E2A\u7528\u9017\u53F7\u5206\u9694", required: false },
+          { name: "color", description: '\u56FE\u5C42\u989C\u8272 (ACI\u53F7\u6216RGB\u5982 "1,2,3")', required: false }
+        ]
+      },
+      {
+        name: "manage-blocks",
+        description: "\u5757\u64CD\u4F5C\uFF1A\u63D2\u5165\u5757\u3001\u5217\u51FA\u5757\u3001\u83B7\u53D6/\u8BBE\u7F6E\u5C5E\u6027",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/insert/attributes/dynprops)", required: true },
+          { name: "blockName", description: "\u5757\u540D", required: false },
+          { name: "insertPoint", description: '\u63D2\u5165\u70B9 "x,y"', required: false },
+          { name: "scale", description: "\u7F29\u653E\u6BD4\u4F8B", required: false }
+        ]
+      },
+      {
+        name: "curve-analysis",
+        description: "\u66F2\u7EBF\u5206\u6790\uFF1A\u4EA4\u70B9\u3001\u6700\u8FD1\u70B9\u3001\u5B50\u6BB5\u3001\u7F13\u51B2\u533A",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C (inters/subsegments/closestpoint/join)", required: true },
+          { name: "distance", description: "\u8FDE\u63A5\u5BB9\u5DEE/\u504F\u79FB\u8DDD\u79BB", required: false }
+        ]
+      },
+      {
+        name: "geometry-calc",
+        description: "\u51E0\u4F55\u8BA1\u7B97\uFF1A\u51F8\u5305\u3001\u70B9\u5230\u7EBF\u8DDD\u79BB\u3001\u9762\u5185\u6D4B\u8BD5\u3001\u53D8\u6362",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C (convexhull/dist-point-line/in-curve-p/transform/centroid)", required: true },
+          { name: "points", description: '\u70B9\u96C6 "x1,y1;x2,y2;..."', required: false }
+        ]
+      },
+      {
+        name: "text-process",
+        description: "\u6587\u672C\u5904\u7406\uFF1AMTEXT\u89E3\u6790\u3001Markdown\u8F6CMTEXT\u3001\u53BB\u683C\u5F0F",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C (parse-mtext/remove-fmt/from-markdown/mtext2text)", required: true },
+          { name: "markdown", description: "Markdown\u6587\u672C\uFF08from-markdown\u64CD\u4F5C\u65F6\u7528\uFF09", required: false }
+        ]
+      },
+      {
+        name: "pickset-filter",
+        description: "\u9009\u62E9\u96C6\u64CD\u4F5C\uFF1A\u8FC7\u6EE4\u3001\u8F6C\u6362\u3001\u6279\u91CF\u64CD\u4F5C",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C (by-layer/by-type/by-box/erase/zoom)", required: true },
+          { name: "dxfType", description: 'DXF\u7C7B\u578B "LINE, CIRCLE, LWPOLYLINE, INSERT, TEXT"', required: false },
+          { name: "layerName", description: "\u56FE\u5C42\u540D", required: false }
+        ]
+      },
+      {
+        name: "color-convert",
+        description: "\u989C\u8272\u8F6C\u6362\uFF1AACI/RGB/TrueColor/CSS\u4E92\u8F6C",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C (aci2rgb/rgb2css/truecolor2rgb/rgb2truecolor)", required: true },
+          { name: "value", description: "\u989C\u8272\u503C", required: true }
+        ]
+      },
+      {
+        name: "json-exchange",
+        description: "JSON\u6570\u636E\u4EA4\u6362\uFF1A\u4ECE\u5B57\u7B26\u4E32\u89E3\u6790JSON alist\uFF0C\u4ECEalist\u751F\u6210JSON",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C (encode/decode)", required: true },
+          { name: "data", description: "JSON\u5B57\u7B26\u4E32\u6216Lisp alist\u6587\u672C", required: true }
+        ]
+      },
+      {
+        name: "excel-report",
+        description: "Excel\u62A5\u8868\uFF1A\u5BFC\u51FACAD\u5B9E\u4F53\u6570\u636E\u5230Excel",
+        arguments: [
+          { name: "visible", description: "\u662F\u5426\u663E\u793AExcel\u7A97\u53E3 (true/false)", required: false },
+          { name: "savePath", description: "\u4FDD\u5B58\u8DEF\u5F84\uFF0C\u4E0D\u586B\u5219\u4E0D\u4FDD\u5B58", required: false }
+        ]
+      },
+      {
+        name: "string-process",
+        description: "\u5B57\u7B26\u4E32\u5904\u7406\uFF1A\u683C\u5F0F\u5316\u3001\u62C6\u5206\u3001\u66FF\u6362\u3001\u6B63\u5219",
+        arguments: [
+          { name: "action", description: "\u64CD\u4F5C (format/split/subst-all/regexp/trim/number2chinese)", required: true },
+          { name: "input", description: "\u8F93\u5165\u5B57\u7B26\u4E32", required: true },
+          { name: "arg1", description: "\u53C2\u65701\uFF08\u683C\u5F0F\u53C2\u6570/\u5206\u9694\u7B26/\u65E7\u4E32\uFF09", required: false },
+          { name: "arg2", description: "\u53C2\u65702\uFF08\u65B0\u4E32/\u6B63\u5219\u6A21\u5F0F\uFF09", required: false }
+        ]
+      }
+    ];
+  }
+});
 
 // src/session-manager.js
-var Session = class {
-  constructor(clientId) {
-    this.clientId = clientId;
-    this.subscriptions = /* @__PURE__ */ new Set();
-    this.createdAt = Date.now();
-    this.connected = false;
-  }
-};
-var SessionManager = class {
-  #sessions = /* @__PURE__ */ new Map();
-  createSession(clientId) {
-    let session = this.#sessions.get(clientId);
-    if (!session) {
-      session = new Session(clientId);
-      this.#sessions.set(clientId, session);
-    }
-    return session;
-  }
-  getSession(clientId) {
-    return this.#sessions.get(clientId) || null;
-  }
-  hasSession(clientId) {
-    return this.#sessions.has(clientId);
-  }
-  removeSession(clientId) {
-    return this.#sessions.delete(clientId);
-  }
-  subscribe(clientId, uri) {
-    const session = this.#sessions.get(clientId);
-    if (session) {
-      session.subscriptions.add(uri);
-      return true;
-    }
-    return false;
-  }
-  unsubscribe(clientId, uri) {
-    const session = this.#sessions.get(clientId);
-    if (session) {
-      return session.subscriptions.delete(uri);
-    }
-    return false;
-  }
-  getSubscriptions(clientId) {
-    const session = this.#sessions.get(clientId);
-    return session ? Array.from(session.subscriptions) : [];
-  }
-  isSubscribed(clientId, uri) {
-    const session = this.#sessions.get(clientId);
-    return session ? session.subscriptions.has(uri) : false;
-  }
-  getAllSubscribedUris() {
-    const all = /* @__PURE__ */ new Set();
-    for (const session of this.#sessions.values()) {
-      for (const uri of session.subscriptions) {
-        all.add(uri);
+var Session, SessionManager;
+var init_session_manager = __esm({
+  "src/session-manager.js"() {
+    Session = class {
+      constructor(clientId) {
+        this.clientId = clientId;
+        this.subscriptions = /* @__PURE__ */ new Set();
+        this.createdAt = Date.now();
+        this.connected = false;
       }
-    }
-    return all;
-  }
-  list() {
-    return Array.from(this.#sessions.entries()).map(([id, s]) => ({
-      clientId: id,
-      subscriptions: Array.from(s.subscriptions),
-      createdAt: s.createdAt,
-      connected: s.connected
-    }));
-  }
-  count() {
-    return this.#sessions.size;
-  }
-  clear() {
-    this.#sessions.clear();
+    };
+    SessionManager = class {
+      #sessions = /* @__PURE__ */ new Map();
+      createSession(clientId) {
+        let session = this.#sessions.get(clientId);
+        if (!session) {
+          session = new Session(clientId);
+          this.#sessions.set(clientId, session);
+        }
+        return session;
+      }
+      getSession(clientId) {
+        return this.#sessions.get(clientId) || null;
+      }
+      hasSession(clientId) {
+        return this.#sessions.has(clientId);
+      }
+      removeSession(clientId) {
+        return this.#sessions.delete(clientId);
+      }
+      subscribe(clientId, uri) {
+        const session = this.#sessions.get(clientId);
+        if (session) {
+          session.subscriptions.add(uri);
+          return true;
+        }
+        return false;
+      }
+      unsubscribe(clientId, uri) {
+        const session = this.#sessions.get(clientId);
+        if (session) {
+          return session.subscriptions.delete(uri);
+        }
+        return false;
+      }
+      getSubscriptions(clientId) {
+        const session = this.#sessions.get(clientId);
+        return session ? Array.from(session.subscriptions) : [];
+      }
+      isSubscribed(clientId, uri) {
+        const session = this.#sessions.get(clientId);
+        return session ? session.subscriptions.has(uri) : false;
+      }
+      getAllSubscribedUris() {
+        const all = /* @__PURE__ */ new Set();
+        for (const session of this.#sessions.values()) {
+          for (const uri of session.subscriptions) {
+            all.add(uri);
+          }
+        }
+        return all;
+      }
+      list() {
+        return Array.from(this.#sessions.entries()).map(([id, s]) => ({
+          clientId: id,
+          subscriptions: Array.from(s.subscriptions),
+          createdAt: s.createdAt,
+          connected: s.connected
+        }));
+      }
+      count() {
+        return this.#sessions.size;
+      }
+      clear() {
+        this.#sessions.clear();
+      }
+    };
   }
-};
+});
 
 // src/subscription-manager.js
-var sessionManager = new SessionManager();
-var _notifyFn = null;
 function setNotify(fn) {
   _notifyFn = fn;
 }
@@ -2440,239 +2450,250 @@ function notify(uri, data) {
     _notifyFn(uri, data);
   }
 }
+var sessionManager, _notifyFn;
+var init_subscription_manager = __esm({
+  "src/subscription-manager.js"() {
+    init_session_manager();
+    sessionManager = new SessionManager();
+    _notifyFn = null;
+  }
+});
 
 // src/sse-session.js
-import { randomUUID as randomUUID3 } from "crypto";
-var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
-var DEFAULT_RETRY_INTERVAL = 3e4;
-var MAX_SENT_MESSAGES = 1e3;
-var SSE_EVENTS = {
-  MESSAGE: "message",
-  ENDPOINT: "endpoint",
-  PING: "ping",
-  ERROR: "error",
-  PROGRESS: "progress",
-  CAPABILITIES: "capabilities"
-};
-var SseSession = class {
-  #res;
-  #clientId;
-  #active = true;
-  #heartbeatTimer = null;
-  #lastEventId = 0;
-  #heartbeatInterval;
-  #retryInterval;
-  #sessionData = {};
-  #sentMessages = [];
-  #backpressureBuffer = [];
-  #drainHandler = null;
-  constructor(res, options = {}) {
-    this.#res = res;
-    this.#clientId = options.clientId || randomUUID3();
-    this.#heartbeatInterval = options.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
-    this.#retryInterval = options.retryInterval || DEFAULT_RETRY_INTERVAL;
-    this.#sessionData = options.sessionData || {};
-    if (options.resumeFromId && options.resumeFromId > 0) {
-      this.#lastEventId = options.resumeFromId;
-    }
-    this._setupSseHeaders();
-    this._sendRetry();
-    this._setupDrain();
-  }
-  get clientId() {
-    return this.#clientId;
-  }
-  get isActive() {
-    return this.#active;
-  }
-  get lastEventId() {
-    return this.#lastEventId;
-  }
-  get sessionData() {
-    return this.#sessionData;
-  }
-  get sentMessages() {
-    return [...this.#sentMessages];
-  }
-  getMessagesSince(eventId) {
-    return this.#sentMessages.filter((m) => m.id > eventId);
-  }
-  setSessionData(key, value) {
-    this.#sessionData[key] = value;
-  }
-  getSessionData(key) {
-    return this.#sessionData[key];
-  }
-  get retryInterval() {
-    return this.#retryInterval;
-  }
-  setRetryInterval(ms) {
-    this.#retryInterval = ms;
-  }
-  _sendRetry() {
-    this._write(`retry: ${this.#retryInterval}
-
-`);
-  }
-  _setupSseHeaders() {
-    this.#res.setHeader("Content-Type", "text/event-stream");
-    this.#res.setHeader("Cache-Control", "no-cache");
-    this.#res.setHeader("Connection", "keep-alive");
-    this.#res.setHeader("Transfer-Encoding", "chunked");
-    this.#res.setHeader("X-Accel-Buffering", "no");
-    if (typeof this.#res.flush !== "function") {
-      this.#res.flush = () => {
-      };
-    }
-  }
-  _formatEvent(event, data, id = null) {
-    const lines = [];
-    if (id !== null) {
-      lines.push(`id: ${id}`);
-    }
-    lines.push(`event: ${event}`);
-    if (data !== null && data !== void 0) {
-      const jsonStr = JSON.stringify(data);
-      lines.push(`data: ${jsonStr}`);
-    } else {
-      lines.push("data:");
-    }
-    return lines.join("\n") + "\n\n";
-  }
-  _setupDrain() {
-    if (typeof this.#res.on !== "function") return;
-    this.#drainHandler = () => {
-      if (!this.#active) return;
-      if (this.#backpressureBuffer.length > 0) {
-        this._drainBuffer();
-      }
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_RETRY_INTERVAL, MAX_SENT_MESSAGES, SSE_EVENTS, SseSession;
+var init_sse_session = __esm({
+  "src/sse-session.js"() {
+    DEFAULT_HEARTBEAT_INTERVAL = 3e4;
+    DEFAULT_RETRY_INTERVAL = 3e4;
+    MAX_SENT_MESSAGES = 1e3;
+    SSE_EVENTS = {
+      MESSAGE: "message",
+      ENDPOINT: "endpoint",
+      PING: "ping",
+      ERROR: "error",
+      PROGRESS: "progress",
+      CAPABILITIES: "capabilities"
     };
-    this.#res.on("drain", this.#drainHandler);
-  }
-  _drainBuffer() {
-    const batch = this.#backpressureBuffer.splice(0, 50);
-    for (const item of batch) {
-      const ok = this.#res.write(item);
-      if (!ok) {
-        this.#backpressureBuffer.unshift(...batch.slice(batch.indexOf(item)));
-        return;
+    SseSession = class {
+      #res;
+      #clientId;
+      #active = true;
+      #heartbeatTimer = null;
+      #lastEventId = 0;
+      #heartbeatInterval;
+      #retryInterval;
+      #sessionData = {};
+      #sentMessages = [];
+      #backpressureBuffer = [];
+      #drainHandler = null;
+      constructor(res, options = {}) {
+        this.#res = res;
+        this.#clientId = options.clientId || randomUUID2();
+        this.#heartbeatInterval = options.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
+        this.#retryInterval = options.retryInterval || DEFAULT_RETRY_INTERVAL;
+        this.#sessionData = options.sessionData || {};
+        if (options.resumeFromId && options.resumeFromId > 0) {
+          this.#lastEventId = options.resumeFromId;
+        }
+        this._setupSseHeaders();
+        this._sendRetry();
+        this._setupDrain();
       }
-    }
-    this._flush();
-    if (this.#backpressureBuffer.length > 0) {
-      this._drainBuffer();
-    }
-  }
-  _write(content) {
-    if (!this.#active) return false;
-    try {
-      if (this.#backpressureBuffer.length > 0) {
-        this.#backpressureBuffer.push(content);
-        return true;
+      get clientId() {
+        return this.#clientId;
       }
-      const result = this.#res.write(content);
-      if (typeof this.#res.flush === "function") {
-        this.#res.flush();
+      get isActive() {
+        return this.#active;
       }
-      if (result === false) {
-        this.#backpressureBuffer.push(content);
-        return true;
+      get lastEventId() {
+        return this.#lastEventId;
       }
-      return true;
-    } catch (e) {
-      this.#active = false;
-      this.close();
-      return false;
-    }
-  }
-  _flush() {
-    try {
-      if (typeof this.#res.flush === "function") {
-        this.#res.flush();
+      get sessionData() {
+        return this.#sessionData;
       }
-    } catch (e) {
-    }
-  }
-  flushBackpressure() {
-    if (this.#backpressureBuffer.length > 0) {
-      this._drainBuffer();
-    }
-  }
-  sendEvent(event, data, id = null) {
-    this.#lastEventId++;
-    const eventId = id !== null ? id : this.#lastEventId;
-    const formatted = this._formatEvent(event, data, eventId);
-    this.#sentMessages.push({ event, data, id: eventId, timestamp: Date.now() });
-    if (this.#sentMessages.length > MAX_SENT_MESSAGES) {
-      this.#sentMessages.splice(0, this.#sentMessages.length - MAX_SENT_MESSAGES);
-    }
-    this._write(formatted);
-    this._flush();
-    return true;
-  }
-  sendMessage(data) {
-    return this.sendEvent(SSE_EVENTS.MESSAGE, data);
-  }
-  sendEndpoint(path8) {
-    return this.sendEvent(SSE_EVENTS.ENDPOINT, path8);
-  }
-  sendError(code, message, id = null) {
-    return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
-  }
-  sendPing() {
-    return this.sendEvent(SSE_EVENTS.PING, { timestamp: Date.now() });
-  }
-  sendProgress(current, total, message = "") {
-    return this.sendEvent(SSE_EVENTS.PROGRESS, { current, total, message });
-  }
-  sendCapabilities(capabilities) {
-    return this.sendEvent(SSE_EVENTS.CAPABILITIES, capabilities);
-  }
-  sendResponse(jsonrpcResponse, id = null) {
-    const eventId = id !== null ? id : this.#lastEventId;
-    return this.sendEvent(SSE_EVENTS.MESSAGE, jsonrpcResponse, eventId);
-  }
-  startHeartbeat(interval = null) {
-    this.stopHeartbeat();
-    const ms = interval || this.#heartbeatInterval;
-    this.#heartbeatTimer = setInterval(() => {
-      if (!this.#active) {
+      get sentMessages() {
+        return [...this.#sentMessages];
+      }
+      getMessagesSince(eventId) {
+        return this.#sentMessages.filter((m) => m.id > eventId);
+      }
+      setSessionData(key, value) {
+        this.#sessionData[key] = value;
+      }
+      getSessionData(key) {
+        return this.#sessionData[key];
+      }
+      get retryInterval() {
+        return this.#retryInterval;
+      }
+      setRetryInterval(ms) {
+        this.#retryInterval = ms;
+      }
+      _sendRetry() {
+        this._write(`retry: ${this.#retryInterval}
+
+`);
+      }
+      _setupSseHeaders() {
+        this.#res.setHeader("Content-Type", "text/event-stream");
+        this.#res.setHeader("Cache-Control", "no-cache");
+        this.#res.setHeader("Connection", "keep-alive");
+        this.#res.setHeader("Transfer-Encoding", "chunked");
+        this.#res.setHeader("X-Accel-Buffering", "no");
+        if (typeof this.#res.flush !== "function") {
+          this.#res.flush = () => {
+          };
+        }
+      }
+      _formatEvent(event, data, id = null) {
+        const lines = [];
+        if (id !== null) {
+          lines.push(`id: ${id}`);
+        }
+        lines.push(`event: ${event}`);
+        if (data !== null && data !== void 0) {
+          const jsonStr = JSON.stringify(data);
+          lines.push(`data: ${jsonStr}`);
+        } else {
+          lines.push("data:");
+        }
+        return lines.join("\n") + "\n\n";
+      }
+      _setupDrain() {
+        if (typeof this.#res.on !== "function") return;
+        this.#drainHandler = () => {
+          if (!this.#active) return;
+          if (this.#backpressureBuffer.length > 0) {
+            this._drainBuffer();
+          }
+        };
+        this.#res.on("drain", this.#drainHandler);
+      }
+      _drainBuffer() {
+        const batch = this.#backpressureBuffer.splice(0, 50);
+        for (const item of batch) {
+          const ok = this.#res.write(item);
+          if (!ok) {
+            this.#backpressureBuffer.unshift(...batch.slice(batch.indexOf(item)));
+            return;
+          }
+        }
+        this._flush();
+        if (this.#backpressureBuffer.length > 0) {
+          this._drainBuffer();
+        }
+      }
+      _write(content) {
+        if (!this.#active) return false;
+        try {
+          if (this.#backpressureBuffer.length > 0) {
+            this.#backpressureBuffer.push(content);
+            return true;
+          }
+          const result = this.#res.write(content);
+          if (typeof this.#res.flush === "function") {
+            this.#res.flush();
+          }
+          if (result === false) {
+            this.#backpressureBuffer.push(content);
+            return true;
+          }
+          return true;
+        } catch (e) {
+          this.#active = false;
+          this.close();
+          return false;
+        }
+      }
+      _flush() {
+        try {
+          if (typeof this.#res.flush === "function") {
+            this.#res.flush();
+          }
+        } catch (e) {
+        }
+      }
+      flushBackpressure() {
+        if (this.#backpressureBuffer.length > 0) {
+          this._drainBuffer();
+        }
+      }
+      sendEvent(event, data, id = null) {
+        this.#lastEventId++;
+        const eventId = id !== null ? id : this.#lastEventId;
+        const formatted = this._formatEvent(event, data, eventId);
+        this.#sentMessages.push({ event, data, id: eventId, timestamp: Date.now() });
+        if (this.#sentMessages.length > MAX_SENT_MESSAGES) {
+          this.#sentMessages.splice(0, this.#sentMessages.length - MAX_SENT_MESSAGES);
+        }
+        this._write(formatted);
+        this._flush();
+        return true;
+      }
+      sendMessage(data) {
+        return this.sendEvent(SSE_EVENTS.MESSAGE, data);
+      }
+      sendEndpoint(path8) {
+        return this.sendEvent(SSE_EVENTS.ENDPOINT, path8);
+      }
+      sendError(code, message, id = null) {
+        return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
+      }
+      sendPing() {
+        return this.sendEvent(SSE_EVENTS.PING, { timestamp: Date.now() });
+      }
+      sendProgress(current, total, message = "") {
+        return this.sendEvent(SSE_EVENTS.PROGRESS, { current, total, message });
+      }
+      sendCapabilities(capabilities) {
+        return this.sendEvent(SSE_EVENTS.CAPABILITIES, capabilities);
+      }
+      sendResponse(jsonrpcResponse, id = null) {
+        const eventId = id !== null ? id : this.#lastEventId;
+        return this.sendEvent(SSE_EVENTS.MESSAGE, jsonrpcResponse, eventId);
+      }
+      startHeartbeat(interval = null) {
         this.stopHeartbeat();
-        return;
+        const ms = interval || this.#heartbeatInterval;
+        this.#heartbeatTimer = setInterval(() => {
+          if (!this.#active) {
+            this.stopHeartbeat();
+            return;
+          }
+          if (!this.sendPing()) {
+            this.stopHeartbeat();
+            this.close();
+          }
+        }, ms);
+      }
+      stopHeartbeat() {
+        if (this.#heartbeatTimer) {
+          clearInterval(this.#heartbeatTimer);
+          this.#heartbeatTimer = null;
+        }
       }
-      if (!this.sendPing()) {
+      close() {
+        this.#active = false;
         this.stopHeartbeat();
-        this.close();
+        if (this.#drainHandler) {
+          this.#res.removeListener("drain", this.#drainHandler);
+          this.#drainHandler = null;
+        }
+        this.#backpressureBuffer = [];
+        try {
+          this.#res.end();
+        } catch (e) {
+        }
       }
-    }, ms);
-  }
-  stopHeartbeat() {
-    if (this.#heartbeatTimer) {
-      clearInterval(this.#heartbeatTimer);
-      this.#heartbeatTimer = null;
-    }
-  }
-  close() {
-    this.#active = false;
-    this.stopHeartbeat();
-    if (this.#drainHandler) {
-      this.#res.removeListener("drain", this.#drainHandler);
-      this.#drainHandler = null;
-    }
-    this.#backpressureBuffer = [];
-    try {
-      this.#res.end();
-    } catch (e) {
-    }
+    };
   }
-};
+});
 
 // src/sse-session-manager.js
 import fs5 from "fs";
 import path6 from "path";
 import os3 from "os";
-var SESSION_STORE_DIR = path6.join(os3.homedir(), ".atlisp", "sessions");
-var SESSION_STORE_TTL = 24 * 60 * 60 * 1e3;
 function getSessionStorePath(clientId) {
   return path6.join(SESSION_STORE_DIR, `${clientId}.json`);
 }
@@ -2704,199 +2725,571 @@ function loadPersistedSessionData(clientId) {
     return null;
   }
 }
-var SseSessionManager = class {
-  #sessions = /* @__PURE__ */ new Map();
-  #eventHandlers = /* @__PURE__ */ new Map();
-  constructor() {
-    this.#sessions = /* @__PURE__ */ new Map();
-    this.#eventHandlers = /* @__PURE__ */ new Map();
-  }
-  add(clientId, session) {
-    if (!(session instanceof SseSession)) {
-      throw new Error("session must be an SseSession instance");
-    }
-    const persisted = loadPersistedSessionData(clientId);
-    if (persisted) {
-      for (const [key, value] of Object.entries(persisted)) {
-        session.setSessionData(key, value);
+var SESSION_STORE_DIR, SESSION_STORE_TTL, SseSessionManager;
+var init_sse_session_manager = __esm({
+  "src/sse-session-manager.js"() {
+    init_sse_session();
+    SESSION_STORE_DIR = path6.join(os3.homedir(), ".atlisp", "sessions");
+    SESSION_STORE_TTL = 24 * 60 * 60 * 1e3;
+    SseSessionManager = class {
+      #sessions = /* @__PURE__ */ new Map();
+      #eventHandlers = /* @__PURE__ */ new Map();
+      constructor() {
+        this.#sessions = /* @__PURE__ */ new Map();
+        this.#eventHandlers = /* @__PURE__ */ new Map();
+      }
+      add(clientId, session) {
+        if (!(session instanceof SseSession)) {
+          throw new Error("session must be an SseSession instance");
+        }
+        const persisted = loadPersistedSessionData(clientId);
+        if (persisted) {
+          for (const [key, value] of Object.entries(persisted)) {
+            session.setSessionData(key, value);
+          }
+        }
+        this.#sessions.set(clientId, session);
+        session.startHeartbeat();
+      }
+      remove(clientId) {
+        const session = this.#sessions.get(clientId);
+        if (session) {
+          persistSessionData(clientId, session.sessionData);
+          session.close();
+          this.#sessions.delete(clientId);
+          return true;
+        }
+        return false;
       }
-    }
-    this.#sessions.set(clientId, session);
-    session.startHeartbeat();
-  }
-  remove(clientId) {
-    const session = this.#sessions.get(clientId);
-    if (session) {
-      persistSessionData(clientId, session.sessionData);
-      session.close();
-      this.#sessions.delete(clientId);
-      return true;
-    }
-    return false;
-  }
-  get(clientId) {
-    return this.#sessions.get(clientId) || null;
-  }
-  has(clientId) {
-    return this.#sessions.has(clientId);
-  }
-  list() {
-    return Array.from(this.#sessions.keys()).map((id) => ({
-      clientId: id,
-      isActive: this.#sessions.get(id)?.isActive ?? false
-    }));
-  }
-  listActive() {
-    return this.list().filter((s) => s.isActive);
+      get(clientId) {
+        return this.#sessions.get(clientId) || null;
+      }
+      has(clientId) {
+        return this.#sessions.has(clientId);
+      }
+      list() {
+        return Array.from(this.#sessions.keys()).map((id) => ({
+          clientId: id,
+          isActive: this.#sessions.get(id)?.isActive ?? false
+        }));
+      }
+      listActive() {
+        return this.list().filter((s) => s.isActive);
+      }
+      count() {
+        return this.#sessions.size;
+      }
+      sendToClient(clientId, event, data, id = null) {
+        const session = this.#sessions.get(clientId);
+        if (!session || !session.isActive) {
+          return false;
+        }
+        return session.sendEvent(event, data, id);
+      }
+      sendMessageToClient(clientId, data) {
+        return this.sendToClient(clientId, SSE_EVENTS.MESSAGE, data);
+      }
+      sendErrorToClient(clientId, code, message, id = null) {
+        return this.sendToClient(clientId, SSE_EVENTS.ERROR, { code, message }, id);
+      }
+      sendProgressToClient(clientId, current, total, message = "") {
+        return this.sendToClient(clientId, SSE_EVENTS.PROGRESS, { current, total, message });
+      }
+      broadcast(event, data) {
+        let successCount = 0;
+        for (const [clientId, session] of this.#sessions) {
+          if (session.isActive && session.sendEvent(event, data)) {
+            successCount++;
+          }
+        }
+        return successCount;
+      }
+      broadcastMessage(data) {
+        return this.broadcast(SSE_EVENTS.MESSAGE, data);
+      }
+      broadcastError(code, message) {
+        return this.broadcast(SSE_EVENTS.ERROR, { code, message });
+      }
+      on(event, handler) {
+        if (!this.#eventHandlers.has(event)) {
+          this.#eventHandlers.set(event, /* @__PURE__ */ new Set());
+        }
+        this.#eventHandlers.get(event).add(handler);
+      }
+      off(event, handler) {
+        const handlers = this.#eventHandlers.get(event);
+        if (handlers) {
+          handlers.delete(handler);
+        }
+      }
+      emit(event, data) {
+        const handlers = this.#eventHandlers.get(event);
+        if (handlers) {
+          for (const handler of handlers) {
+            try {
+              handler(data);
+            } catch (e) {
+            }
+          }
+        }
+      }
+      cleanupInactive() {
+        for (const [clientId, session] of this.#sessions) {
+          if (!session.isActive) {
+            session.close();
+            this.#sessions.delete(clientId);
+          }
+        }
+      }
+      closeAll() {
+        for (const [clientId, session] of this.#sessions) {
+          persistSessionData(clientId, session.sessionData);
+          session.close();
+        }
+        this.#sessions.clear();
+      }
+    };
   }
-  count() {
-    return this.#sessions.size;
+});
+
+// src/session-transport.js
+import { randomUUID as randomUUID3 } from "crypto";
+var SESSION_TIMEOUT, SessionTransport;
+var init_session_transport = __esm({
+  "src/session-transport.js"() {
+    SESSION_TIMEOUT = 30 * 60 * 1e3;
+    SessionTransport = class {
+      constructor(sessionId) {
+        this.sessionId = sessionId || randomUUID3();
+        this.onclose = null;
+        this.onerror = null;
+        this.onmessage = null;
+        this._pendingRequest = null;
+        this._started = false;
+        this._closed = false;
+        this._cleanupTimer = null;
+      }
+      async start() {
+        if (this._started) {
+          throw new Error("Transport already started");
+        }
+        this._started = true;
+      }
+      async send(message) {
+        if (this._closed) return;
+        if (this._pendingRequest) {
+          const { resolve, reject, timeout } = this._pendingRequest;
+          clearTimeout(timeout);
+          this._pendingRequest = null;
+          resolve(message);
+        }
+      }
+      async close() {
+        if (this._closed) return;
+        this._closed = true;
+        if (this._pendingRequest) {
+          const { reject, timeout } = this._pendingRequest;
+          clearTimeout(timeout);
+          this._pendingRequest = null;
+          reject(new Error("Transport closed"));
+        }
+        this._clearCleanupTimer();
+        this.onclose?.();
+      }
+      async handleRequest(message, timeoutMs = 6e4) {
+        if (this._closed) {
+          throw new Error("Transport closed");
+        }
+        if (!message || !message.method) {
+          throw new Error("Invalid message");
+        }
+        if (!message.id) {
+          this.onmessage?.(message);
+          return null;
+        }
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            if (this._pendingRequest?.resolve === resolve) {
+              this._pendingRequest = null;
+              reject(new Error("Request timeout"));
+            }
+          }, timeoutMs);
+          this._pendingRequest = { resolve, reject, timeout };
+          this.onmessage?.(message);
+        });
+      }
+      resetCleanupTimer() {
+        this._clearCleanupTimer();
+        this._cleanupTimer = setTimeout(() => {
+          this.close();
+        }, SESSION_TIMEOUT);
+      }
+      _clearCleanupTimer() {
+        if (this._cleanupTimer) {
+          clearTimeout(this._cleanupTimer);
+          this._cleanupTimer = null;
+        }
+      }
+    };
   }
-  sendToClient(clientId, event, data, id = null) {
-    const session = this.#sessions.get(clientId);
-    if (!session || !session.isActive) {
-      return false;
+});
+
+// src/mcp-handlers.js
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+function createMcpServer(handlers = {}) {
+  const { tools: tools2 = [], handleToolCall: handleToolCall2 = () => ({ content: [] }) } = handlers;
+  const server = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: SERVER_CAPABILITIES }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools2 }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return await handleToolCall2(name, args || {});
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
+    const ctx = mcpContext.getStore();
+    const sessionId = ctx?.sessionId;
+    const subscribedUris = sessionId ? list(sessionId) : list();
+    return {
+      resources: await listResources(subscribedUris)
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    try {
+      const data = await readResource(uri);
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(data)
+        }]
+      };
+    } catch (e) {
+      return {
+        contents: [],
+        isError: true,
+        error: { code: -32603, message: e.message }
+      };
     }
-    return session.sendEvent(event, data, id);
-  }
-  sendMessageToClient(clientId, data) {
-    return this.sendToClient(clientId, SSE_EVENTS.MESSAGE, data);
+  });
+  server.setRequestHandler(SubscribeRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const ctx = mcpContext.getStore();
+    subscribe(uri, ctx?.sessionId);
+    return { success: true };
+  });
+  server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const ctx = mcpContext.getStore();
+    unsubscribe(uri, ctx?.sessionId);
+    return { success: true };
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: await listPrompts()
+  }));
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return await getPrompt(name, args || {});
+  });
+  return server;
+}
+var SERVER_CAPABILITIES;
+var init_mcp_handlers = __esm({
+  "src/mcp-handlers.js"() {
+    init_resource_handlers();
+    init_prompt_handlers();
+    init_constants();
+    init_subscription_manager();
+    init_mcp_server_state();
+    SERVER_CAPABILITIES = {
+      tools: {},
+      resources: { subscribe: true, listChanged: true },
+      prompts: {}
+    };
   }
-  sendErrorToClient(clientId, code, message, id = null) {
-    return this.sendToClient(clientId, SSE_EVENTS.ERROR, { code, message }, id);
+});
+
+// src/mcp-server-state.js
+import { AsyncLocalStorage } from "async_hooks";
+async function getOrCreateSessionServer(sessionId) {
+  if (!mcpHandlers) {
+    const { tools: tools2, handleToolCall: handleToolCall2 } = await init_atlisp_mcp().then(() => atlisp_mcp_exports);
+    mcpHandlers = { tools: tools2, handleToolCall: handleToolCall2 };
   }
-  sendProgressToClient(clientId, current, total, message = "") {
-    return this.sendToClient(clientId, SSE_EVENTS.PROGRESS, { current, total, message });
+  let entry = sessionServers.get(sessionId);
+  if (!entry) {
+    const server = createMcpServer(mcpHandlers);
+    const transport = new SessionTransport(sessionId);
+    server.connect(transport);
+    entry = { server, transport };
+    sessionServers.set(sessionId, entry);
+    sessionTransports.set(sessionId, transport);
   }
-  broadcast(event, data) {
-    let successCount = 0;
-    for (const [clientId, session] of this.#sessions) {
-      if (session.isActive && session.sendEvent(event, data)) {
-        successCount++;
-      }
-    }
-    return successCount;
+  return entry;
+}
+function createStdioServer(handlers) {
+  mcpHandlers = handlers;
+  return createMcpServer(handlers);
+}
+function removeSessionServer(sessionId) {
+  const entry = sessionServers.get(sessionId);
+  if (entry) {
+    entry.transport.close().catch(() => {
+    });
+    entry.server.close().catch(() => {
+    });
+    sessionServers.delete(sessionId);
+    sessionTransports.delete(sessionId);
   }
-  broadcastMessage(data) {
-    return this.broadcast(SSE_EVENTS.MESSAGE, data);
+}
+function broadcastToAllSessions(uri) {
+  for (const [sid, entry] of sessionServers) {
+    entry.server.sendResourceUpdated({ uri }).catch((err) => {
+      error(`Failed to send resource update to session ${sid}: ${err.message}`, { sessionId: sid, uri });
+    });
   }
-  broadcastError(code, message) {
-    return this.broadcast(SSE_EVENTS.ERROR, { code, message });
+}
+var mcpContext, sessionServers, sessionTransports, mcpHandlers;
+var init_mcp_server_state = __esm({
+  "src/mcp-server-state.js"() {
+    init_session_transport();
+    init_mcp_handlers();
+    init_logger();
+    mcpContext = new AsyncLocalStorage();
+    sessionServers = /* @__PURE__ */ new Map();
+    sessionTransports = /* @__PURE__ */ new Map();
+    mcpHandlers = null;
   }
-  on(event, handler) {
-    if (!this.#eventHandlers.has(event)) {
-      this.#eventHandlers.set(event, /* @__PURE__ */ new Set());
+});
+
+// src/routes.js
+import express from "express";
+import { randomUUID as randomUUID4 } from "crypto";
+import iconv from "iconv-lite";
+import rateLimit from "express-rate-limit";
+function createJsonBodyParser() {
+  return async (req, res, next) => {
+    const ct = (req.headers["content-type"] || "").toLowerCase();
+    if (!JSON_CONTENT_TYPES.some((t) => ct.startsWith(t))) return next();
+    try {
+      const chunks = [];
+      for await (const chunk of req) {
+        chunks.push(chunk);
+      }
+      const totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+      if (totalLength > 10 * 1024 * 1024) {
+        throw new Error("Request body too large");
+      }
+      const buf = Buffer.concat(chunks);
+      const m = ct.match(/charset\s*=\s*([^\s;]+)/i);
+      let charset = m ? m[1].toLowerCase() : "utf-8";
+      const charsetMap = { "gb2312": "gbk", "gb18030": "gbk", "gbk": "gbk", "936": "gbk" };
+      charset = charsetMap[charset] || charset;
+      const str = iconv.decode(buf, charset);
+      req.body = JSON.parse(str);
+      next();
+    } catch (e) {
+      res.status(400).json({ error: "Invalid JSON body", message: e.message });
     }
-    this.#eventHandlers.get(event).add(handler);
-  }
-  off(event, handler) {
-    const handlers = this.#eventHandlers.get(event);
-    if (handlers) {
-      handlers.delete(handler);
+  };
+}
+function createLoggingMiddleware() {
+  return (req, res, next) => {
+    log(`${req.method} ${req.path}`, { method: req.method, path: req.path, query: req.query });
+    next();
+  };
+}
+function createAuthMiddleware() {
+  const PUBLIC_PATHS = ["/health"];
+  return (req, res, next) => {
+    if (apiKey) {
+      if (PUBLIC_PATHS.includes(req.path)) return next();
+      const auth = req.get("Authorization");
+      if (auth === `Bearer ${apiKey}`) return next();
+      return res.status(401).json({ error: "Unauthorized" });
     }
-  }
-  emit(event, data) {
-    const handlers = this.#eventHandlers.get(event);
-    if (handlers) {
-      for (const handler of handlers) {
-        try {
-          handler(data);
-        } catch (e) {
+    next();
+  };
+}
+function createCorsMiddleware() {
+  return (req, res, next) => {
+    if (!enableCors) return next();
+    res.setHeader("Access-Control-Allow-Origin", corsOrigin);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS, CONNECT");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept, mcp-session-id, last-event-id");
+    res.setHeader("Access-Control-Expose-Headers", "mcp-session-id, content-type, x-accel-buffering");
+    res.setHeader("Access-Control-Max-Age", "86400");
+    res.setHeader("Vary", "Accept");
+    if (req.method === "OPTIONS") return res.status(204).end();
+    next();
+  };
+}
+function createErrorHandler() {
+  return (err, req, res, next) => {
+    error(`Unhandled error: ${err.message}`, { stack: err.stack, path: req.path });
+    res.status(500).json({ error: "Internal server error", message: err.message });
+  };
+}
+function setupRoutes(app) {
+  app.use(createJsonBodyParser());
+  app.use(createLoggingMiddleware());
+  app.use(createAuthMiddleware());
+  app.use(createCorsMiddleware());
+  app.get("/health", (req, res) => {
+    res.json({ status: "ok", cad: cad.connected ? "connected" : "disconnected" });
+  });
+  app.get("/api/docs", (req, res) => {
+    res.json({
+      openapi: "3.0.0",
+      info: { title: "@lisp MCP Server", version: "1.5.0" },
+      paths: {
+        "/mcp": { post: { summary: "MCP JSON-RPC endpoint" } },
+        "/sse": { get: { summary: "Server-Sent Events endpoint" } },
+        "/message": { post: { summary: "SSE message endpoint" } },
+        "/health": { get: { summary: "Health check" } }
+      }
+    });
+  });
+  app.all("/mcp", mcpLimiter, handleMcpPost);
+  app.all("/mcp/:path", mcpLimiter, handleMcpPost);
+  app.get("/mcp/stream", mcpLimiter, handleMcpPost);
+  app.get("/sse", handleSse);
+  app.post("/message", mcpLimiter, handleMessage);
+  app.use(createErrorHandler());
+  return app;
+}
+async function handleMcpPost(req, res) {
+  const sessionId = req.headers["mcp-session-id"] || req.query.sessionId || randomUUID4();
+  sessionManager.createSession(sessionId);
+  const body = req.body;
+  if (!body || !body.method) {
+    return res.status(400).json({ error: "Invalid request" });
+  }
+  const { server, transport } = await getOrCreateSessionServer(sessionId);
+  transport.resetCleanupTimer();
+  await mcpContext.run({ sessionId }, async () => {
+    try {
+      const response = await transport.handleRequest(body);
+      if (response) {
+        const headers = { "Content-Type": "application/json" };
+        if (transport.sessionId) {
+          headers["mcp-session-id"] = transport.sessionId;
+        }
+        res.writeHead(200, headers);
+        res.end(JSON.stringify(response));
+      } else {
+        if (!res.headersSent) {
+          res.status(202).end();
         }
       }
-    }
-  }
-  cleanupInactive() {
-    for (const [clientId, session] of this.#sessions) {
-      if (!session.isActive) {
-        session.close();
-        this.#sessions.delete(clientId);
+    } catch (err) {
+      error(`Transport error [${sessionId}]: ${err.message}`);
+      if (!res.headersSent) {
+        res.status(500).json({ error: "Internal server error", message: err.message });
       }
     }
+  });
+}
+async function handleSse(req, res) {
+  const sessionId = randomUUID4();
+  sessionManager.createSession(sessionId);
+  getOrCreateSessionServer(sessionId);
+  const sseSession = new SseSession(res, { clientId: sessionId });
+  sseSessionManager.add(sessionId, sseSession);
+  sseSession.sendEndpoint(`/message?sessionId=${sessionId}`);
+  req.on("close", () => {
+    sseSessionManager.remove(sessionId);
+    removeSessionServer(sessionId);
+  });
+}
+async function handleMessage(req, res) {
+  const sessionId = req.query.sessionId;
+  if (!sessionId) {
+    return res.status(400).json({ error: "Missing sessionId" });
+  }
+  const sseSession = sseSessionManager.get(sessionId);
+  if (!sseSession) {
+    return res.status(404).json({ error: "Session not found" });
   }
-  closeAll() {
-    for (const [clientId, session] of this.#sessions) {
-      persistSessionData(clientId, session.sessionData);
-      session.close();
+  sessionManager.createSession(sessionId);
+  const { server, transport } = await getOrCreateSessionServer(sessionId);
+  transport.resetCleanupTimer();
+  const body = req.body;
+  if (body && body.method) {
+    try {
+      const response = await transport.handleRequest(body);
+      if (response) {
+        sseSession.sendResponse(response);
+      }
+      if (!res.headersSent) {
+        res.status(202).end();
+      }
+    } catch (err) {
+      error(`SSE message error [${sessionId}]: ${err.message}`);
+      if (!res.headersSent) {
+        res.status(500).json({ error: "Internal server error" });
+      }
     }
-    this.#sessions.clear();
+  } else {
+    res.status(400).json({ error: "Invalid request" });
+  }
+}
+var sseSessionManager, apiKey, enableCors, corsOrigin, rateLimitWindow, rateLimitMax, mcpLimiter, JSON_CONTENT_TYPES;
+var init_routes = __esm({
+  "src/routes.js"() {
+    init_config();
+    init_logger();
+    init_cad();
+    init_subscription_manager();
+    init_sse_session_manager();
+    init_mcp_server_state();
+    init_sse_session();
+    sseSessionManager = new SseSessionManager();
+    ({ apiKey, enableCors, corsOrigin, rateLimitWindow, rateLimitMax } = config_default);
+    mcpLimiter = rateLimit({
+      windowMs: rateLimitWindow,
+      max: rateLimitMax,
+      standardHeaders: true,
+      legacyHeaders: false,
+      message: { error: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5" }
+    });
+    JSON_CONTENT_TYPES = ["application/json", "application/json-rpc", "application/vnd.api+json"];
   }
-};
+});
 
 // src/atlisp-mcp.js
-var __dirname4 = path7.dirname(fileURLToPath4(import.meta.url));
-var require2 = createRequire(import.meta.url);
-var { version } = require2(path7.join(__dirname4, "..", "package.json"));
-var CACHE_DIR2 = path7.join(os4.homedir(), ".atlisp", "cache");
-var FUNCLIB_CACHE_FILE2 = path7.join(CACHE_DIR2, "functions.json");
-var FUNCLIB_CACHE_TTL2 = 24 * 60 * 60 * 1e3;
-var isMcpScript = process.argv[1]?.includes("atlisp-mcp");
-if (isMcpScript) {
-  const args = process.argv.slice(2);
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--version" || args[i] === "-v") {
-      console.log(`atlisp-mcp v${version}`);
-      process.exit(0);
-    } else if (args[i] === "--help" || args[i] === "-h") {
-      console.log(`
-@lisp MCP Server v${version}
-
-Usage: atlisp-mcp [options]
-
-Options:
-  -v, --version         Show version number
-  --transport <type>   Transport type: http or stdio (default: http)
-  --port <port>        HTTP port (default: 8110)
-  --host <host>        HTTP host (default: 0.0.0.0)
-  --stdio              Shorthand for --transport stdio
-  -h, --help           Show this help message
-
-Examples:
-  atlisp-mcp                       # Start HTTP server on port 8110
-  atlisp-mcp --port 3000           # Start HTTP server on port 3000
-  atlisp-mcp --stdio               # Start in stdio mode for MCP clients
-  atlisp-mcp --transport stdio     # Same as --stdio
-`);
-      process.exit(0);
-    } else if (args[i] === "--transport" && args[i + 1]) {
-      process.env.TRANSPORT = args[i + 1];
-      i++;
-    } else if (args[i] === "--stdio") {
-      process.env.TRANSPORT = "stdio";
-    } else if (args[i] === "--port" && args[i + 1]) {
-      process.env.PORT = args[i + 1];
-      i++;
-    } else if (args[i] === "--host" && args[i + 1]) {
-      process.env.HOST = args[i + 1];
-      i++;
-    }
-  }
-}
-var { decode: charsetDecode, encodingExists } = iconv;
-var mcpContext = new AsyncLocalStorage();
-var sseSessionManager = new SseSessionManager();
-var SERVER_CAPABILITIES = {
-  tools: {},
-  resources: { subscribe: true, listChanged: true },
-  prompts: {}
-};
-var { port, host, transport, apiKey, rateLimitWindow, rateLimitMax } = config_default;
-if (apiKey) log("API Key authentication enabled");
-var mcpLimiter = rateLimit({
-  windowMs: rateLimitWindow,
-  max: rateLimitMax,
-  standardHeaders: true,
-  legacyHeaders: false,
-  message: { error: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5" }
+var atlisp_mcp_exports = {};
+__export(atlisp_mcp_exports, {
+  CAD_PLATFORMS: () => CAD_PLATFORMS,
+  FILE_EXTENSIONS: () => FILE_EXTENSIONS,
+  handleToolCall: () => handleToolCall,
+  loadAtlibFunctionLib: () => loadAtlibFunctionLib,
+  startServer: () => startServer,
+  tools: () => tools
 });
-var FUNCTION_LIB_URL = process.env.FUNCTION_LIB_URL || "http://s3.atlisp.cn/json/functions.json";
-var cachedFunctionLib = null;
-var cachedAt2 = null;
-var CACHE_TTL3 = 5 * 60 * 1e3;
+import path7 from "path";
+import fs6 from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { createRequire } from "module";
+import os4 from "os";
+import express2 from "express";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 async function readCacheFromDisk2() {
   try {
     const stat = fs6.statSync(FUNCLIB_CACHE_FILE2);
-    if (Date.now() - stat.mtimeMs < FUNCLIB_CACHE_TTL2) {
+    if (Date.now() - stat.mtimeMs < CACHE_TTL3) {
       const raw = fs6.readFileSync(FUNCLIB_CACHE_FILE2, "utf-8");
       return JSON.parse(raw);
     }
@@ -2909,7 +3302,7 @@ function writeCacheToDisk2(data) {
     fs6.mkdirSync(CACHE_DIR2, { recursive: true });
     fs6.writeFileSync(FUNCLIB_CACHE_FILE2, JSON.stringify(data), "utf-8");
   } catch (e) {
-    log(`writeCacheToDisk error: ${e.message}`);
+    error(`writeCacheToDisk error: ${e.message}`);
   }
 }
 async function loadAtlibFunctionLib() {
@@ -2933,235 +3326,31 @@ async function loadAtlibFunctionLib() {
       return data;
     }
   } catch (e) {
-    log(`loadAtlibFunctionLib error: ${e.message}`);
+    error(`loadAtlibFunctionLib error: ${e.message}`);
   }
   return cachedFunctionLib;
 }
-var TOOL_HANDLERS = {
-  connect_cad: (a) => connectCad(a?.platform),
-  eval_lisp: (a) => evalLisp(a.code),
-  eval_lisp_with_result: (a) => evalLisp(a.code, true, a.encoding),
-  get_cad_info: () => getCadInfo(),
-  list_packages: () => listPackages(),
-  search_packages: (a) => searchPackages(a.query),
-  install_package: (a) => installPackage(a.packageName),
-  get_platform_info: () => ({ content: [{ type: "text", text: `\u652F\u6301\u7684 CAD \u5E73\u53F0:
-${CAD_PLATFORMS.join("\n")}
-\u5F53\u524D\u8FDE\u63A5: ${cad.connected ? "\u5DF2\u8FDE\u63A5" : "\u672A\u8FDE\u63A5"}` }] }),
-  at_command: (a) => atCommand(a.command),
-  new_document: () => newDocument(),
-  bring_to_front: () => bringToFront(),
-  install_atlisp: () => installAtlisp(),
-  init_atlisp: () => initAtlisp(),
-  get_function_usage: (a) => getFunctionUsage(a.name, a.package),
-  list_symbols: (a) => listSymbols(a.package),
-  get_system_status: () => getSystemStatus(),
-  list_prompts: async () => {
-    const prompts = await listPrompts();
-    return { content: [{ type: "text", text: JSON.stringify(prompts) }] };
-  },
-  get_prompt: async (a) => {
-    const prompt = await getPrompt(a.name, a.args || {});
-    return { content: prompt.messages.map((m) => ({ type: "text", text: m.content.text || m.content })) };
-  },
-  import_funlib: async (a) => {
-    const data = await loadAtlibFunctionLib();
-    if (!data) return { content: [{ type: "text", text: "\u52A0\u8F7D\u51FD\u6570\u5E93\u5931\u8D25" }], isError: true };
-    if (a.format === "list") {
-      const items = Object.values(data.all_functions || {}).map((f) => `${f.name}: ${f.description || ""}`);
-      return { content: [{ type: "text", text: items.join("\n") }] };
-    }
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-  }
-};
-function getOrCreateSessionServer(sessionId) {
-  let entry = sessionServers.get(sessionId);
-  if (!entry) {
-    const server = createMcpServer();
-    const transport2 = new SessionTransport(sessionId);
-    server.connect(transport2);
-    entry = { server, transport: transport2 };
-    sessionServers.set(sessionId, entry);
-    sessionTransports.set(sessionId, transport2);
-  }
-  return entry;
-}
-function removeSessionServer(sessionId) {
-  const entry = sessionServers.get(sessionId);
-  if (entry) {
-    entry.transport.close().catch(() => {
-    });
-    entry.server.close().catch(() => {
-    });
-    sessionServers.delete(sessionId);
-    sessionTransports.delete(sessionId);
-  }
-}
-function broadcastToAllSessions(uri) {
-  for (const [sid, entry] of sessionServers) {
-    entry.server.sendResourceUpdated({ uri }).catch((err) => {
-      log(`Failed to send resource update to session ${sid}: ${err.message}`);
-    });
-  }
-}
-var tools = [
-  {
-    name: "connect_cad",
-    description: "\u8FDE\u63A5\u5230 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)",
-    inputSchema: {
-      type: "object",
-      properties: {
-        platform: { type: "string", description: "\u6307\u5B9A CAD \u5E73\u53F0: AutoCAD, ZWCAD, GStarCAD, BricsCAD\uFF08\u53EF\u9009\uFF0C\u81EA\u52A8\u68C0\u6D4B\uFF09" }
-      }
-    }
-  },
-  {
-    name: "eval_lisp",
-    description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\uFF08\u4E0D\u8FD4\u56DE\u7ED3\u679C\uFF09",
-    inputSchema: {
-      type: "object",
-      properties: { code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" } },
-      required: ["code"]
-    }
-  },
-  {
-    name: "eval_lisp_with_result",
-    description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\u5E76\u8FD4\u56DE\u7ED3\u679C",
-    inputSchema: {
-      type: "object",
-      properties: {
-        code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" },
-        encoding: { type: "string", description: "\u7ED3\u679C\u7F16\u7801\uFF0C\u5982 utf-8, gbk, gb2312, gb18030\uFF08\u53EF\u9009\uFF0C\u9ED8\u8BA4\u81EA\u52A8\u68C0\u6D4B\uFF09" }
-      },
-      required: ["code"]
-    }
-  },
-  {
-    name: "get_cad_info",
-    description: "\u83B7\u53D6\u5F53\u524D CAD \u4FE1\u606F",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "list_packages",
-    description: "\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 @lisp \u5305",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "search_packages",
-    description: "\u641C\u7D22 @lisp \u5305",
-    inputSchema: {
-      type: "object",
-      properties: { query: { type: "string", description: "\u641C\u7D22\u5173\u952E\u8BCD" } },
-      required: ["query"]
-    }
-  },
-  {
-    name: "install_package",
-    description: "\u5B89\u88C5 @lisp \u5305\u5230 CAD",
-    inputSchema: {
-      type: "object",
-      properties: { packageName: { type: "string", description: "\u5305\u540D\u79F0" } },
-      required: ["packageName"]
-    }
-  },
-  {
-    name: "get_platform_info",
-    description: "\u83B7\u53D6 CAD \u5E73\u53F0\u4FE1\u606F",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "at_command",
-    description: "\u6267\u884C @lisp \u547D\u4EE4",
-    inputSchema: {
-      type: "object",
-      properties: { command: { type: "string", description: "@lisp \u547D\u4EE4" } },
-      required: ["command"]
-    }
-  },
-  {
-    name: "new_document",
-    description: "\u5728 CAD \u4E2D\u65B0\u5EFA\u7A7A\u767D\u6587\u6863",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "bring_to_front",
-    description: "\u5C06 CAD \u7A97\u53E3\u5207\u6362\u5230\u524D\u53F0\uFF08\u4ECE\u540E\u53F0\u8FD0\u884C\u72B6\u6001\u5524\u9192\uFF09",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "install_atlisp",
-    description: "\u5728 CAD \u4E2D\u5B89\u88C5 @lisp",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "init_atlisp",
-    description: "\u521D\u59CB\u5316 CAD \u4E2D\u7684 @lisp \u73AF\u5883\uFF0C\u52A0\u8F7D\u51FD\u6570\u5E93\u548C\u521D\u59CB\u53D8\u91CF",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "get_function_usage",
-    description: "\u83B7\u53D6 @lisp \u51FD\u6570\u7528\u6CD5",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "\u51FD\u6570\u540D\uFF0C\u5982 string:length" },
-        package: { type: "string", description: "\u5305\u540D\uFF0C\u5982 string\uFF08\u53EF\u9009\uFF0C\u4E0D\u4F20\u5219\u81EA\u52A8\u641C\u7D22\uFF09" }
-      },
-      required: ["name"]
-    }
-  },
-  {
-    name: "list_symbols",
-    description: "\u5217\u51FA @lisp \u6240\u6709\u7B26\u53F7\uFF0C\u7528\u4E8E\u68C0\u67E5\u51FD\u6570\u548C\u53D8\u91CF",
-    inputSchema: {
-      type: "object",
-      properties: {
-        package: { type: "string", description: "\u5305\u540D\uFF0C\u5982 string\uFF08\u53EF\u9009\uFF09" }
-      }
-    }
-  },
-  {
-    name: "import_funlib",
-    description: "\u4ECE\u7F51\u7EDC\u5BFC\u5165 @lisp \u51FD\u6570\u5E93\u6570\u636E\u5230 AI Agent",
-    inputSchema: {
-      type: "object",
-      properties: {
-        format: { type: "string", enum: ["json", "list"], description: "\u8FD4\u56DE\u683C\u5F0F\uFF1Ajson\uFF08\u5B8C\u6574JSON\uFF09\u6216 list\uFF08\u51FD\u6570\u540D:\u63CF\u8FF0 \u5217\u8868\uFF09\uFF0C\u9ED8\u8BA4 json" }
-      }
-    }
-  },
-  {
-    name: "get_system_status",
-    description: "\u83B7\u53D6\u5B8C\u6574\u7CFB\u7EDF\u8BCA\u65AD\u4FE1\u606F\uFF1AMCP \u72B6\u6001\u3001CAD \u8FDE\u63A5\u3001Lisp \u6267\u884C\u3001\u5305\u5217\u8868",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "list_prompts",
-    description: "\u5217\u51FA\u6240\u6709\u53EF\u7528\u7684 @lisp \u63D0\u793A\u6A21\u677F",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "get_prompt",
-    description: "\u83B7\u53D6\u6307\u5B9A\u63D0\u793A\u6A21\u677F\u7684\u5185\u5BB9",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "\u63D0\u793A\u6A21\u677F\u540D\u79F0" },
-        args: { type: "object", description: "\u6A21\u677F\u53C2\u6570\uFF08\u53EF\u9009\uFF09" }
-      },
-      required: ["name"]
+function validateToolArgs(name, args) {
+  const schema = toolInputSchema[name];
+  if (!schema) return true;
+  for (const [key, type] of Object.entries(schema)) {
+    if (type.endsWith("?")) continue;
+    if (!args[key]) {
+      throw new Error(`Missing required argument: ${key}`);
     }
   }
-];
+  return true;
+}
 async function handleToolCall(name, args) {
   const handler = TOOL_HANDLERS[name];
   if (!handler) return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
   try {
+    validateToolArgs(name, args || {});
     const result = await handler(args || {});
     notifyResourceChanges(name);
     return result;
   } catch (e) {
-    log(`Tool call error [${name}]: ${e.message}`);
+    error(`Tool call error [${name}]: ${e.message}`, { tool: name, args });
     return { content: [{ type: "text", text: `\u5DE5\u5177\u6267\u884C\u9519\u8BEF: ${e.message}` }], isError: true };
   }
 }
@@ -3188,222 +3377,38 @@ async function initCadConnection() {
   try {
     const connected = await cad.connect();
     if (connected) {
-      log("Auto-connected to CAD: " + cad.getPlatform() + " " + cad.getVersion());
-      console.error("\u5DF2\u81EA\u52A8\u8FDE\u63A5\u5230 CAD: " + cad.getPlatform() + " " + cad.getVersion());
+      log(`Auto-connected to CAD: ${cad.getPlatform()} ${cad.getVersion()}`);
+      console.error(`\u5DF2\u81EA\u52A8\u8FDE\u63A5\u5230 CAD: ${cad.getPlatform()} ${cad.getVersion()}`);
     } else {
       log("No CAD found on startup");
     }
   } catch (e) {
-    log("Auto-connect failed: " + e.message);
+    error(`Auto-connect failed: ${e.message}`);
   }
 }
-var sessionServers = /* @__PURE__ */ new Map();
-var sessionTransports = /* @__PURE__ */ new Map();
-function createMcpServer() {
-  const server = new Server(
-    { name: SERVER_NAME, version: SERVER_VERSION },
-    { capabilities: SERVER_CAPABILITIES }
-  );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    return await handleToolCall(name, args || {});
-  });
-  server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
-    const ctx = mcpContext.getStore();
-    const sessionId = ctx?.sessionId;
-    const subscribedUris = sessionId ? list(sessionId) : list();
-    return {
-      resources: await listResources(subscribedUris)
-    };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const { uri } = request.params;
-    try {
-      const data = await readResource(uri);
-      return {
-        contents: [{
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(data)
-        }]
-      };
-    } catch (e) {
-      return {
-        contents: [],
-        isError: true,
-        error: { code: -32603, message: e.message }
-      };
-    }
-  });
-  server.setRequestHandler(SubscribeRequestSchema, async (request) => {
-    const { uri } = request.params;
-    const ctx = mcpContext.getStore();
-    subscribe(uri, ctx?.sessionId);
-    return { success: true };
-  });
-  server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
-    const { uri } = request.params;
-    const ctx = mcpContext.getStore();
-    unsubscribe(uri, ctx?.sessionId);
-    return { success: true };
-  });
-  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-    prompts: await listPrompts()
-  }));
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    return await getPrompt(name, args || {});
-  });
-  return server;
-}
 async function startServer() {
   if (config_default.transport === "stdio") {
     await initCadConnection();
-    const mcpServer = createMcpServer();
-    const transport2 = new StdioServerTransport();
+    const mcpServer = createStdioServer({ tools, handleToolCall });
+    const transport = new StdioServerTransport();
     const sessionId = "stdio-session";
     sessionManager.createSession(sessionId);
     await mcpContext.run({ sessionId }, async () => {
-      await mcpServer.connect(transport2);
+      await mcpServer.connect(transport);
     });
     console.error(`${SERVER_NAME} \u8FD0\u884C\u5728 stdio \u6A21\u5F0F`);
     setNotify((uri, data) => {
       mcpServer.sendResourceUpdated({ uri }).catch((err) => {
-        log(`Failed to send resource update: ${err.message}`);
+        error(`Failed to send resource update: ${err.message}`);
       });
     });
   } else {
-    const app = express();
-    const JSON_CONTENT_TYPES = ["application/json", "application/json-rpc", "application/vnd.api+json"];
-    app.use(async (req, res, next) => {
-      const ct = (req.headers["content-type"] || "").toLowerCase();
-      if (!JSON_CONTENT_TYPES.some((t) => ct.startsWith(t))) return next();
-      try {
-        const buf = await rawBody(req, { limit: "10mb" });
-        const m = ct.match(/charset\s*=\s*([^\s;]+)/i);
-        let charset = m ? m[1].toLowerCase() : "utf-8";
-        const charsetMap = { "gb2312": "gbk", "gb18030": "gbk", "gbk": "gbk", "936": "gbk" };
-        charset = charsetMap[charset] || charset;
-        const str = encodingExists(charset) ? charsetDecode(buf, charset) : buf.toString("utf-8");
-        req.body = JSON.parse(str);
-        next();
-      } catch (e) {
-        res.status(400).json({ error: "Invalid JSON body", message: e.message });
-      }
-    });
-    app.use((req, res, next) => {
-      log(`${req.method} ${req.path}`);
-      next();
-    });
-    const PUBLIC_PATHS = ["/health"];
-    if (apiKey) {
-      app.use((req, res, next) => {
-        if (PUBLIC_PATHS.includes(req.path)) return next();
-        const auth = req.get("Authorization");
-        if (auth === `Bearer ${apiKey}`) return next();
-        res.status(401).json({ error: "Unauthorized" });
-      });
-    }
-    app.get("/health", (req, res) => {
-      res.json({ status: "ok", cad: cad.connected ? "connected" : "disconnected" });
-    });
-    if (config_default.enableCors) {
-      app.use((req, res, next) => {
-        res.setHeader("Access-Control-Allow-Origin", config_default.corsOrigin);
-        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS, CONNECT");
-        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept, mcp-session-id, last-event-id");
-        res.setHeader("Access-Control-Expose-Headers", "mcp-session-id, content-type, x-accel-buffering");
-        res.setHeader("Access-Control-Max-Age", "86400");
-        res.setHeader("Vary", "Accept");
-        if (req.method === "OPTIONS") return res.status(204).end();
-        next();
-      });
-    }
+    const app = express2();
+    setupRoutes(app);
     setNotify((uri, data) => {
       broadcastToAllSessions(uri);
-      for (const session of sseSessionManager.listActive()) {
-        sseSessionManager.sendToClient(session.clientId, "resource_updated", { uri });
-      }
-    });
-    async function handleMcpPost(req, res) {
-      const sessionId = req.headers["mcp-session-id"] || req.query.sessionId || randomUUID4();
-      sessionManager.createSession(sessionId);
-      const body = req.body;
-      if (!body || !body.method) {
-        return res.status(400).json({ error: "Invalid request" });
-      }
-      const { server, transport: transport2 } = getOrCreateSessionServer(sessionId);
-      transport2.resetCleanupTimer();
-      await mcpContext.run({ sessionId }, async () => {
-        try {
-          const response = await transport2.handleRequest(body);
-          if (response) {
-            const headers = { "Content-Type": "application/json" };
-            if (transport2.sessionId) {
-              headers["mcp-session-id"] = transport2.sessionId;
-            }
-            res.writeHead(200, headers);
-            res.end(JSON.stringify(response));
-          } else {
-            if (!res.headersSent) {
-              res.status(202).end();
-            }
-          }
-        } catch (error) {
-          log(`Transport error [${sessionId}]: ${error.message}`);
-          if (!res.headersSent) {
-            res.status(500).json({ error: "Internal server error", message: error.message });
-          }
-        }
-      });
-    }
-    app.all("/mcp", mcpLimiter, handleMcpPost);
-    app.all("/mcp/:path", mcpLimiter, handleMcpPost);
-    app.get("/mcp/stream", mcpLimiter, handleMcpPost);
-    const sseEndpoint = "/sse";
-    app.get(sseEndpoint, async (req, res) => {
-      const sessionId = randomUUID4();
-      sessionManager.createSession(sessionId);
-      getOrCreateSessionServer(sessionId);
-      const sseSession = new SseSession(res, { clientId: sessionId });
-      sseSessionManager.add(sessionId, sseSession);
-      sseSession.sendEndpoint(`/message?sessionId=${sessionId}`);
-      req.on("close", () => {
-        sseSessionManager.remove(sessionId);
-        removeSessionServer(sessionId);
-      });
-    });
-    app.post("/message", mcpLimiter, async (req, res) => {
-      const sessionId = req.query.sessionId;
-      if (!sessionId) {
-        return res.status(400).json({ error: "Missing sessionId" });
-      }
-      const sseSession = sseSessionManager.get(sessionId);
-      if (!sseSession) {
-        return res.status(404).json({ error: "Session not found" });
-      }
-      sessionManager.createSession(sessionId);
-      const { server, transport: transport2 } = getOrCreateSessionServer(sessionId);
-      transport2.resetCleanupTimer();
-      const body = req.body;
-      if (body && body.method) {
-        try {
-          const response = await transport2.handleRequest(body);
-          if (response) {
-            sseSession.sendResponse(response);
-          }
-          if (!res.headersSent) {
-            res.status(202).end();
-          }
-        } catch (error) {
-          log(`SSE message error [${sessionId}]: ${error.message}`);
-          if (!res.headersSent) {
-            res.status(500).json({ error: "Internal server error" });
-          }
-        }
-      } else {
-        res.status(400).json({ error: "Invalid request" });
+      for (const session of sseSessionManager2.listActive()) {
+        sseSessionManager2.sendToClient(session.clientId, "resource_updated", { uri });
       }
     });
     const httpServer = app.listen(config_default.port, config_default.host, async () => {
@@ -3413,7 +3418,7 @@ async function startServer() {
     async function shutdown(signal) {
       console.error(`
 \u6536\u5230 ${signal}\uFF0C\u6B63\u5728\u4F18\u96C5\u5173\u95ED...`);
-      sseSessionManager.closeAll();
+      sseSessionManager2.closeAll();
       sessionManager.clear();
       for (const [sid] of sessionServers) {
         removeSessionServer(sid);
@@ -3427,14 +3432,285 @@ async function startServer() {
     process.on("SIGTERM", () => shutdown("SIGTERM"));
   }
 }
-if (!process.env.VITEST) {
-  await startServer();
-}
+var __dirname4, require2, version, sseSessionManager2, isMcpScript, CACHE_DIR2, FUNCLIB_CACHE_FILE2, CACHE_TTL3, FUNCTION_LIB_URL, cachedFunctionLib, cachedAt2, toolInputSchema, TOOL_HANDLERS, tools;
+var init_atlisp_mcp = __esm({
+  async "src/atlisp-mcp.js"() {
+    init_cad();
+    init_constants();
+    init_logger();
+    init_cad_handlers();
+    init_package_handlers();
+    init_function_handlers();
+    init_resource_handlers();
+    init_prompt_handlers();
+    init_subscription_manager();
+    init_subscription_manager();
+    init_sse_session_manager();
+    init_sse_session();
+    init_config();
+    init_routes();
+    init_mcp_server_state();
+    init_constants();
+    __dirname4 = path7.dirname(fileURLToPath4(import.meta.url));
+    require2 = createRequire(import.meta.url);
+    ({ version } = require2(path7.join(__dirname4, "..", "package.json")));
+    sseSessionManager2 = new SseSessionManager();
+    isMcpScript = process.argv[1]?.includes("atlisp-mcp");
+    if (isMcpScript) {
+      const args = process.argv.slice(2);
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--version" || args[i] === "-v") {
+          console.log(`atlisp-mcp v${version}`);
+          process.exit(0);
+        } else if (args[i] === "--help" || args[i] === "-h") {
+          console.log(`
+@lisp MCP Server v${version}
+
+Usage: atlisp-mcp [options]
+
+Options:
+  -v, --version         Show version number
+  --transport <type>   Transport type: http or stdio (default: http)
+  --port <port>        HTTP port (default: 8110)
+  --host <host>        HTTP host (default: 0.0.0.0)
+  --stdio              Shorthand for --transport stdio
+  -h, --help           Show this help message
+
+Examples:
+  atlisp-mcp                       # Start HTTP server on port 8110
+  atlisp-mcp --port 3000           # Start HTTP server on port 3000
+  atlisp-mcp --stdio               # Start in stdio mode for MCP clients
+  atlisp-mcp --transport stdio     # Same as --stdio
+`);
+          process.exit(0);
+        } else if (args[i] === "--transport" && args[i + 1]) {
+          process.env.TRANSPORT = args[i + 1];
+          i++;
+        } else if (args[i] === "--stdio") {
+          process.env.TRANSPORT = "stdio";
+        } else if (args[i] === "--port" && args[i + 1]) {
+          process.env.PORT = args[i + 1];
+          i++;
+        } else if (args[i] === "--host" && args[i + 1]) {
+          process.env.HOST = args[i + 1];
+          i++;
+        }
+      }
+    }
+    if (config_default.apiKey) log("API Key authentication enabled");
+    CACHE_DIR2 = path7.join(os4.homedir(), ".atlisp", "cache");
+    FUNCLIB_CACHE_FILE2 = path7.join(CACHE_DIR2, "functions.json");
+    CACHE_TTL3 = config_default.functionLibCacheTtl || 5 * 60 * 1e3;
+    FUNCTION_LIB_URL = config_default.functionLibUrl || "http://s3.atlisp.cn/json/functions.json";
+    cachedFunctionLib = null;
+    cachedAt2 = null;
+    toolInputSchema = {
+      connect_cad: { platform: "string?" },
+      eval_lisp: { code: "string" },
+      eval_lisp_with_result: { code: "string", encoding: "string?" },
+      search_packages: { query: "string" },
+      install_package: { packageName: "string" },
+      at_command: { command: "string" },
+      get_function_usage: { name: "string", package: "string?" },
+      list_symbols: { package: "string?" },
+      import_funlib: { format: "string?" },
+      get_prompt: { name: "string", args: "object?" }
+    };
+    TOOL_HANDLERS = {
+      connect_cad: (a) => connectCad(a?.platform),
+      eval_lisp: (a) => evalLisp(a.code),
+      eval_lisp_with_result: (a) => evalLisp(a.code, true, a.encoding),
+      get_cad_info: () => getCadInfo(),
+      list_packages: () => listPackages(),
+      search_packages: (a) => searchPackages(a.query),
+      install_package: (a) => installPackage(a.packageName),
+      get_platform_info: () => ({ content: [{ type: "text", text: `\u652F\u6301\u7684 CAD \u5E73\u53F0:
+${CAD_PLATFORMS.join("\n")}
+\u5F53\u524D\u8FDE\u63A5: ${cad.connected ? "\u5DF2\u8FDE\u63A5" : "\u672A\u8FDE\u63A5"}` }] }),
+      at_command: (a) => atCommand(a.command),
+      new_document: () => newDocument(),
+      bring_to_front: () => bringToFront(),
+      install_atlisp: () => installAtlisp(),
+      init_atlisp: () => initAtlisp(),
+      get_function_usage: (a) => getFunctionUsage(a.name, a.package),
+      list_symbols: (a) => listSymbols(a.package),
+      get_system_status: () => getSystemStatus(),
+      list_prompts: async () => {
+        const prompts = await listPrompts();
+        return { content: [{ type: "text", text: JSON.stringify(prompts) }] };
+      },
+      get_prompt: async (a) => {
+        const prompt = await getPrompt(a.name, a.args || {});
+        return { content: prompt.messages.map((m) => ({ type: "text", text: m.content.text || m.content })) };
+      },
+      import_funlib: async (a) => {
+        const data = await loadAtlibFunctionLib();
+        if (!data) return { content: [{ type: "text", text: "\u52A0\u8F7D\u51FD\u6570\u5E93\u5931\u8D25" }], isError: true };
+        if (a.format === "list") {
+          const items = Object.values(data.all_functions || {}).map((f) => `${f.name}: ${f.description || ""}`);
+          return { content: [{ type: "text", text: items.join("\n") }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      }
+    };
+    tools = [
+      {
+        name: "connect_cad",
+        description: "\u8FDE\u63A5\u5230 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            platform: { type: "string", description: "\u6307\u5B9A CAD \u5E73\u53F0: AutoCAD, ZWCAD, GStarCAD, BricsCAD\uFF08\u53EF\u9009\uFF0C\u81EA\u52A8\u68C0\u6D4B\uFF09" }
+          }
+        }
+      },
+      {
+        name: "eval_lisp",
+        description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\uFF08\u4E0D\u8FD4\u56DE\u7ED3\u679C\uFF09",
+        inputSchema: {
+          type: "object",
+          properties: { code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" } },
+          required: ["code"]
+        }
+      },
+      {
+        name: "eval_lisp_with_result",
+        description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\u5E76\u8FD4\u56DE\u7ED3\u679C",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" },
+            encoding: { type: "string", description: "\u7ED3\u679C\u7F16\u7801\uFF0C\u5982 utf-8, gbk, gb2312, gb18030\uFF08\u53EF\u9009\uFF0C\u9ED8\u8BA4\u81EA\u52A8\u68C0\u6D4B\uFF09" }
+          },
+          required: ["code"]
+        }
+      },
+      {
+        name: "get_cad_info",
+        description: "\u83B7\u53D6\u5F53\u524D CAD \u4FE1\u606F",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "list_packages",
+        description: "\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 @lisp \u5305",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "search_packages",
+        description: "\u641C\u7D22 @lisp \u5305",
+        inputSchema: {
+          type: "object",
+          properties: { query: { type: "string", description: "\u641C\u7D22\u5173\u952E\u8BCD" } },
+          required: ["query"]
+        }
+      },
+      {
+        name: "install_package",
+        description: "\u5B89\u88C5 @lisp \u5305\u5230 CAD",
+        inputSchema: {
+          type: "object",
+          properties: { packageName: { type: "string", description: "\u5305\u540D\u79F0" } },
+          required: ["packageName"]
+        }
+      },
+      {
+        name: "get_platform_info",
+        description: "\u83B7\u53D6 CAD \u5E73\u53F0\u4FE1\u606F",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "at_command",
+        description: "\u6267\u884C @lisp \u547D\u4EE4",
+        inputSchema: {
+          type: "object",
+          properties: { command: { type: "string", description: "@lisp \u547D\u4EE4" } },
+          required: ["command"]
+        }
+      },
+      {
+        name: "new_document",
+        description: "\u5728 CAD \u4E2D\u65B0\u5EFA\u7A7A\u767D\u6587\u6863",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "bring_to_front",
+        description: "\u5C06 CAD \u7A97\u53E3\u5207\u6362\u5230\u524D\u53F0\uFF08\u4ECE\u540E\u53F0\u8FD0\u884C\u72B6\u6001\u5524\u9192\uFF09",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "install_atlisp",
+        description: "\u5728 CAD \u4E2D\u5B89\u88C5 @lisp",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "init_atlisp",
+        description: "\u521D\u59CB\u5316 CAD \u4E2D\u7684 @lisp \u73AF\u5883\uFF0C\u52A0\u8F7D\u51FD\u6570\u5E93\u548C\u521D\u59CB\u53D8\u91CF",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_function_usage",
+        description: "\u83B7\u53D6 @lisp \u51FD\u6570\u7528\u6CD5",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "\u51FD\u6570\u540D\uFF0C\u5982 string:length" },
+            package: { type: "string", description: "\u5305\u540D\uFF0C\u5982 string\uFF08\u53EF\u9009\uFF0C\u4E0D\u4F20\u5219\u81EA\u52A8\u641C\u7D22\uFF09" }
+          },
+          required: ["name"]
+        }
+      },
+      {
+        name: "list_symbols",
+        description: "\u5217\u51FA @lisp \u6240\u6709\u7B26\u53F7\uFF0C\u7528\u4E8E\u68C0\u67E5\u51FD\u6570\u548C\u53D8\u91CF",
+        inputSchema: {
+          type: "object",
+          properties: {
+            package: { type: "string", description: "\u5305\u540D\uFF08\u53EF\u9009\uFF09" }
+          }
+        }
+      },
+      {
+        name: "import_funlib",
+        description: "\u4ECE\u7F51\u7EDC\u5BFC\u5165 @lisp \u51FD\u6570\u5E93\u6570\u636E\u5230 AI Agent",
+        inputSchema: {
+          type: "object",
+          properties: {
+            format: { type: "string", enum: ["json", "list"], description: "\u8FD4\u56DE\u683C\u5F0F\uFF1Ajson\uFF08\u5B8C\u6574JSON\uFF09\u6216 list\uFF08\u51FD\u6570\u540D:\u63CF\u8FF0 \u5217\u8868\uFF09\uFF0C\u9ED8\u8BA4 json" }
+          }
+        }
+      },
+      {
+        name: "get_system_status",
+        description: "\u83B7\u53D6\u5B8C\u6574\u7CFB\u7EDF\u8BCA\u65AD\u4FE1\u606F\uFF1AMCP \u72B6\u6001\u3001CAD \u8FDE\u63A5\u3001Lisp \u6267\u884C\u3001\u5305\u5217\u8868",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "list_prompts",
+        description: "\u5217\u51FA\u6240\u6709\u53EF\u7528\u7684 @lisp \u63D0\u793A\u6A21\u677F",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_prompt",
+        description: "\u83B7\u53D6\u6307\u5B9A\u63D0\u793A\u6A21\u677F\u7684\u5185\u5BB9",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "\u63D0\u793A\u6A21\u677F\u540D\u79F0" },
+            args: { type: "object", description: "\u6A21\u677F\u53C2\u6570\uFF08\u53EF\u9009\uFF09" }
+          },
+          required: ["name"]
+        }
+      }
+    ];
+    if (!process.env.VITEST) {
+      await startServer();
+    }
+  }
+});
+await init_atlisp_mcp();
 export {
   CAD_PLATFORMS,
   FILE_EXTENSIONS,
-  MOCK_PACKAGES,
-  createMcpServer,
   handleToolCall,
   loadAtlibFunctionLib,
   startServer,