@atlisp/mcp 1.4.2 → 1.4.4

package/dist/atlisp-mcp.js

@@ -36,7 +36,8 @@ var SessionTransport = class {
     this._started = true;
   }
   async send(message) {
-    if (this._closed) return;
+    if (this._closed)
+      return;
     if (this._pendingRequest) {
       const { resolve, reject, timeout } = this._pendingRequest;
       clearTimeout(timeout);
@@ -45,7 +46,8 @@ var SessionTransport = class {
     }
   }
   async close() {
-    if (this._closed) return;
+    if (this._closed)
+      return;
     this._closed = true;
     if (this._pendingRequest) {
       const { reject, timeout } = this._pendingRequest;
@@ -119,7 +121,7 @@ var FILE_EXTENSIONS = {
   "BricsCAD": [".des"]
 };
 var SERVER_NAME = "atlisp-mcp-server";
-var SERVER_VERSION = "1.4.1";
+var SERVER_VERSION = "1.4.4";
 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" },
@@ -237,7 +239,8 @@ function setupStdoutHandler(w) {
       const lines = buffer.split("\n");
       buffer = lines.pop() || "";
       for (const line of lines) {
-        if (!line.trim()) continue;
+        if (!line.trim())
+          continue;
         try {
           const result = JSON.parse(line);
           const rid = result.requestId;
@@ -263,7 +266,8 @@ function setupStdoutHandler(w) {
 }
 function getWorker(force = false) {
   if (!worker || !worker.connected || force) {
-    if (worker) worker.kill();
+    if (worker)
+      worker.kill();
     worker = spawn("node", [workerPath], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -271,7 +275,8 @@ function getWorker(force = false) {
     const w = worker;
     w.on("exit", (code) => {
       console.error("worker exited with code:", code);
-      if (w !== worker) return;
+      if (w !== worker)
+        return;
       w.connected = false;
       for (const [id, { reject, timeout }] of pendingRequests) {
         clearTimeout(timeout);
@@ -292,7 +297,8 @@ function getWorker(force = false) {
   return worker;
 }
 function startHeartbeat() {
-  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  if (heartbeatTimer)
+    clearInterval(heartbeatTimer);
   heartbeatTimer = setInterval(async () => {
     try {
       const result = await sendMessage({ type: "ping" });
@@ -337,7 +343,8 @@ var CadConnection = class {
     return process.platform === "win32";
   }
   async connect(platform = null) {
-    if (!this.isAvailable()) return false;
+    if (!this.isAvailable())
+      return false;
     try {
       const msg = platform ? { type: "connect", platform } : { type: "connect" };
       const result = await sendMessage(msg);
@@ -354,13 +361,16 @@ var CadConnection = class {
     return false;
   }
   async sendCommand(code) {
-    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected)
+      throw new Error("\u672A\u8FDE\u63A5 CAD");
     const result = await sendMessage({ type: "send", code, platform: _platform });
-    if (result.success) return true;
+    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");
+    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 || "";
@@ -374,7 +384,8 @@ var CadConnection = class {
     return this.product;
   }
   async isBusy() {
-    if (!this.connected) return false;
+    if (!this.connected)
+      return false;
     try {
       const result = await sendMessage({ type: "isBusy", platform: _platform });
       return result && result.isBusy;
@@ -383,7 +394,8 @@ var CadConnection = class {
     }
   }
   async hasDoc() {
-    if (!this.connected) return { hasDoc: false, docCount: 0 };
+    if (!this.connected)
+      return { hasDoc: false, docCount: 0 };
     try {
       const result = await sendMessage({ type: "hasdoc", platform: _platform });
       return result || { hasDoc: false, docCount: 0 };
@@ -392,7 +404,8 @@ var CadConnection = class {
     }
   }
   async newDoc() {
-    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected)
+      throw new Error("\u672A\u8FDE\u63A5 CAD");
     try {
       const result = await sendMessage({ type: "newdoc", platform: _platform });
       return result && result.success;
@@ -401,7 +414,8 @@ var CadConnection = class {
     }
   }
   async bringToFront() {
-    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected)
+      throw new Error("\u672A\u8FDE\u63A5 CAD");
     try {
       const result = await sendMessage({ type: "bringToFront", platform: _platform });
       return result && result.success;
@@ -410,7 +424,8 @@ var CadConnection = class {
     }
   }
   async getInfo() {
-    if (!this.connected) return "CAD \u672A\u8FDE\u63A5";
+    if (!this.connected)
+      return "CAD \u672A\u8FDE\u63A5";
     return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
   }
   async disconnect() {
@@ -447,9 +462,11 @@ var MAX_LOG_SIZE = 10 * 1024 * 1024;
 var MAX_LOG_FILES = 5;
 var stream = null;
 function rotateLog() {
-  if (!fs.existsSync(DEBUG_FILE)) return;
+  if (!fs.existsSync(DEBUG_FILE))
+    return;
   const stat = fs.statSync(DEBUG_FILE);
-  if (stat.size < MAX_LOG_SIZE) return;
+  if (stat.size < MAX_LOG_SIZE)
+    return;
   if (stream) {
     stream.end();
     stream = null;
@@ -511,7 +528,8 @@ async function evalLisp(code, withResult = false, encoding = null) {
     return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   }
   const trimmed = (code || "").trim();
-  if (!trimmed) return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
+  if (!trimmed)
+    return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
   try {
     if (withResult) {
       const result = await cad.sendCommandWithResult(trimmed, encoding);
@@ -531,14 +549,17 @@ async function getCadInfo() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "CAD \u672A\u8FDE\u63A5" }] };
+  if (!cad.connected)
+    return { content: [{ type: "text", text: "CAD \u672A\u8FDE\u63A5" }] };
   const info = await cad.getInfo();
   return { content: [{ type: "text", text: info }] };
 }
 async function atCommand(command) {
-  if (!cad.connected) return { content: [{ type: "text", text: "\u8BF7\u5148\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected)
+    return { content: [{ type: "text", text: "\u8BF7\u5148\u8FDE\u63A5 CAD" }], isError: true };
   const trimmed = (command || "").trim();
-  if (!trimmed) return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
+  if (!trimmed)
+    return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
   await cad.sendCommand(trimmed + "\n");
   return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001\u547D\u4EE4" }] };
 }
@@ -546,7 +567,8 @@ async function newDocument() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected)
+    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const result = await cad.newDoc();
   if (result) {
     return { content: [{ type: "text", text: "\u5DF2\u5728 CAD \u4E2D\u65B0\u5EFA\u7A7A\u767D\u6587\u6863" }] };
@@ -557,7 +579,8 @@ async function bringToFront() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected)
+    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const result = await cad.bringToFront();
   if (result) {
     return { content: [{ type: "text", text: "\u5DF2\u5C06 CAD \u7A97\u53E3\u5207\u6362\u5230\u524D\u53F0" }] };
@@ -568,7 +591,8 @@ async function installAtlisp() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected)
+    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const installCode = `(progn(vl-load-com)(setq s strcat h "http" o(vlax-create-object (s"win"h".win"h"request.5.1"))v vlax-invoke e eval r read)(v o'open "get" (s h"://atlisp.""cn/@"):vlax-true)(v o'send)(v o'WaitforResponse 1000)(e(r(vlax-get-property o'ResponseText))))`;
   await cad.sendCommand(installCode + "\n");
   return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001 @lisp \u5B89\u88C5\u4EE3\u7801\u5230 CAD" }] };
@@ -577,10 +601,12 @@ async function listFunctionsInCad() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected)
+    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   try {
     const result = await cad.sendCommandWithResult("(atoms-family 0)", null);
-    if (result) return { content: [{ type: "text", text: result }] };
+    if (result)
+      return { content: [{ type: "text", text: result }] };
     return { content: [{ type: "text", text: "CAD \u51FD\u6570\u5217\u8868\u4E3A\u7A7A" }] };
   } catch (e) {
     return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
@@ -635,7 +661,8 @@ async function initAtlisp() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected)
+    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const code = `(if (null @::load-module)
 	   (progn
 	     (vl-load-com)
@@ -675,12 +702,15 @@ async function fetchPackages() {
   return cachedPackages || MOCK_PACKAGES;
 }
 function flattenPackages(data) {
-  if (Array.isArray(data)) return data;
-  if (data && Array.isArray(data.packages)) return data.packages;
+  if (Array.isArray(data))
+    return data;
+  if (data && Array.isArray(data.packages))
+    return data.packages;
   return [];
 }
 async function listPackages() {
-  if (!cad.connected) await cad.connect();
+  if (!cad.connected)
+    await cad.connect();
   if (!cad.connected) {
     const data2 = await fetchPackages();
     const items2 = flattenPackages(data2);
@@ -688,7 +718,8 @@ async function listPackages() {
     return { content: [{ type: "text", text: text2 }] };
   }
   const result = await cad.sendCommandWithResult("(@::package-list-in-local)");
-  if (result && result !== "nil") return { content: [{ type: "text", text: result }] };
+  if (result && result !== "nil")
+    return { content: [{ type: "text", text: result }] };
   const data = await fetchPackages();
   const items = flattenPackages(data);
   const text = items.length ? `\u4ECE\u6CE8\u518C\u8868\u83B7\u53D6\u7684 @lisp \u5305:
@@ -708,10 +739,12 @@ async function searchPackages(query) {
     for (const p of items) {
       const name = (p.name || "").toLowerCase();
       const desc = (p.description || "").toLowerCase();
-      if (name.includes(q) || desc.includes(q)) results.push(p);
+      if (name.includes(q) || desc.includes(q))
+        results.push(p);
     }
   } else {
-    for (const p of items) results.push(p);
+    for (const p of items)
+      results.push(p);
   }
   if (results.length === 0) {
     return { content: [{ type: "text", text: `\u672A\u627E\u5230\u5305\u542B "${query}" \u7684\u5305` }] };
@@ -763,7 +796,8 @@ function writeCacheToDisk(data) {
 }
 async function fetchFunctions() {
   const diskCache = readCacheFromDisk();
-  if (diskCache) return diskCache;
+  if (diskCache)
+    return diskCache;
   try {
     const response = await fetch(FUNCTIONS_URL, { headers: { "User-Agent": "atlisp-mcp" } });
     if (response.ok) {
@@ -783,7 +817,8 @@ async function getFunctionUsage(funcName, packageName) {
     if (data) {
       const funcs = Object.values(data.all_functions || {});
       const func = funcs.find((f2) => f2.name === funcName || f2.name === `${packageName}:${funcName}`);
-      if (func) results.push(func);
+      if (func)
+        results.push(func);
     }
     if (results.length === 0 && FUNCTIONS_DIR) {
       try {
@@ -792,7 +827,8 @@ async function getFunctionUsage(funcName, packageName) {
           const raw = fs2.readFileSync(path3.join(FUNCTIONS_DIR, file), "utf-8");
           const data2 = JSON.parse(raw);
           const func = data2.functions?.find((f2) => f2.name === funcName);
-          if (func) results.push(func);
+          if (func)
+            results.push(func);
         }
       } catch {
       }
@@ -886,11 +922,14 @@ function clearCache(uri) {
   }
 }
 function parseLispList(str) {
-  if (!str || typeof str !== "string") return null;
+  if (!str || typeof str !== "string")
+    return null;
   const trimmed = str.trim();
-  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) return null;
+  if (!trimmed.startsWith("(") || !trimmed.endsWith(")"))
+    return null;
   const content = trimmed.slice(1, -1).trim();
-  if (!content) return [];
+  if (!content)
+    return [];
   const result = [];
   let depth = 0;
   let current = "";
@@ -932,32 +971,44 @@ function parseLispList(str) {
     }
     current += ch;
   }
-  if (current.trim()) result.push(current.trim());
+  if (current.trim())
+    result.push(current.trim());
   return result.map((item) => {
     const t = item.trim();
-    if (t === "nil") return null;
-    if (t === "t") return true;
-    if (t === "T") return true;
+    if (t === "nil")
+      return null;
+    if (t === "t")
+      return true;
+    if (t === "T")
+      return true;
     const num = Number(t);
-    if (!isNaN(num) && t !== "") return num;
-    if (t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
+    if (!isNaN(num) && t !== "")
+      return num;
+    if (t.startsWith('"') && t.endsWith('"'))
+      return t.slice(1, -1);
     return t;
   });
 }
 function parseLispRecursive(str) {
-  if (!str || typeof str !== "string") return null;
+  if (!str || typeof str !== "string")
+    return null;
   str = str.trim();
-  if (!str) return null;
+  if (!str)
+    return null;
   let pos = 0;
   function skipWs() {
-    while (pos < str.length && /\s/.test(str[pos])) pos++;
+    while (pos < str.length && /\s/.test(str[pos]))
+      pos++;
   }
   function parseValue() {
     skipWs();
-    if (pos >= str.length) return null;
+    if (pos >= str.length)
+      return null;
     const ch = str[pos];
-    if (ch === "(") return parseList();
-    if (ch === '"') return parseString();
+    if (ch === "(")
+      return parseList();
+    if (ch === '"')
+      return parseString();
     if (ch === "'") {
       pos++;
       return parseValue();
@@ -970,11 +1021,16 @@ function parseLispRecursive(str) {
     while (pos < str.length && str[pos] !== '"') {
       if (str[pos] === "\\" && pos + 1 < str.length) {
         pos++;
-        if (str[pos] === '"') r += '"';
-        else if (str[pos] === "n") r += "\n";
-        else if (str[pos] === "t") r += "	";
-        else if (str[pos] === "\\") r += "\\";
-        else r += str[pos];
+        if (str[pos] === '"')
+          r += '"';
+        else if (str[pos] === "n")
+          r += "\n";
+        else if (str[pos] === "t")
+          r += "	";
+        else if (str[pos] === "\\")
+          r += "\\";
+        else
+          r += str[pos];
       } else {
         r += str[pos];
       }
@@ -985,12 +1041,16 @@ function parseLispRecursive(str) {
   }
   function parseAtom() {
     const start = pos;
-    while (pos < str.length && !/\s/.test(str[pos]) && str[pos] !== ")" && str[pos] !== "(") pos++;
+    while (pos < str.length && !/\s/.test(str[pos]) && str[pos] !== ")" && str[pos] !== "(")
+      pos++;
     const atom = str.slice(start, pos);
-    if (atom === "nil" || atom === "NIL") return null;
-    if (atom === "t" || atom === "T") return true;
+    if (atom === "nil" || atom === "NIL")
+      return null;
+    if (atom === "t" || atom === "T")
+      return true;
     const num = Number(atom);
-    if (!isNaN(num) && atom !== "") return num;
+    if (!isNaN(num) && atom !== "")
+      return num;
     return atom;
   }
   function parseList() {
@@ -998,13 +1058,15 @@ function parseLispRecursive(str) {
     const items = [];
     while (pos < str.length) {
       skipWs();
-      if (pos >= str.length) break;
+      if (pos >= str.length)
+        break;
       if (str[pos] === ")") {
         pos++;
         return items;
       }
       const left = parseValue();
-      if (left === void 0) break;
+      if (left === void 0)
+        break;
       skipWs();
       if (str[pos] === "." && (pos + 1 >= str.length || /\s/.test(str[pos + 1]) || str[pos + 1] === ")")) {
         pos++;
@@ -1025,7 +1087,8 @@ function parseLispRecursive(str) {
   return parseValue();
 }
 function lispPairsToObject(pairs) {
-  if (!Array.isArray(pairs)) return pairs;
+  if (!Array.isArray(pairs))
+    return pairs;
   const obj = {};
   for (let i = 0; i < pairs.length - 1; i += 2) {
     const key = pairs[i];
@@ -1036,36 +1099,18 @@ function lispPairsToObject(pairs) {
   }
   return obj;
 }
-var ENTITY_SCHEMAS = {
-  LINE: { fields: ["x1", "y1", "z1", "x2", "y2", "z2", "length"], strings: [] },
-  CIRCLE: { fields: ["cx", "cy", "cz", "radius"], strings: [] },
-  ARC: { fields: ["cx", "cy", "cz", "radius", "startAngle", "endAngle"], strings: [] },
-  LWPOLYLINE: { fields: ["vertices", "closed"], strings: [] },
-  TEXT: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
-  MTEXT: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
-  ATTRIB: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
-  TCH_TEXT: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
-  INSERT: { fields: ["x", "y", "z", "blockName", "rotation", "scaleX", "scaleY"], strings: ["blockName"] },
-  POINT: { fields: ["x", "y", "z"], strings: [] }
-};
 function parseEntity(arr) {
-  if (!Array.isArray(arr) || arr.length < 5) return null;
-  const [type, handle, layer, color, linetype, ...rest] = arr;
-  const schema = ENTITY_SCHEMAS[String(type)] || { fields: [], strings: [] };
-  const props = {};
-  schema.fields.forEach((name, i) => {
-    if (i < rest.length) {
-      let val = rest[i];
-      if (schema.strings.includes(name) && val !== null && val !== void 0) val = String(val);
-      props[name] = val;
-    }
-  });
-  return { type: String(type), handle: String(handle), layer: String(layer), color, linetype: String(linetype), ...props };
+  if (!Array.isArray(arr) || arr.length < 5)
+    return null;
+  const [type, handle, layer, color, linetype] = arr;
+  return { type: String(type), handle: String(handle), layer: String(layer), color, linetype: String(linetype) };
 }
-function buildEntityCode({ type, layer, bbox, offset, limit }) {
+function buildEntityCode({ type, layer, bbox }) {
   const items = [];
-  if (type) items.push(`(cons 0 "${type.replace(/"/g, '\\"')}")`);
-  if (layer) items.push(`(cons 8 "${layer.replace(/"/g, '\\"')}")`);
+  if (type)
+    items.push(`(cons 0 "${type.replace(/"/g, '\\"')}")`);
+  if (layer)
+    items.push(`(cons 8 "${layer.replace(/"/g, '\\"')}")`);
   if (bbox) {
     const parts = bbox.split(",").map((s) => parseFloat(s.trim()));
     if (parts.length === 4) {
@@ -1081,55 +1126,22 @@ function buildEntityCode({ type, layer, bbox, offset, limit }) {
   const filterExpr = items.length ? `(list ${items.join(" ")})` : "nil";
   const ssgetExpr = items.length ? `(ssget "_X" ${filterExpr})` : '(ssget "_X")';
   return `(progn
-(defun @e:props (ent / ed typ result item s e c verts closed ins)
-  (setq ed (entget ent) typ (cdr (assoc 0 ed)))
-  (setq result (list (vl-prin1-to-string (cdr (assoc 5 ed))) (vl-prin1-to-string (cdr (assoc 8 ed)))
-    (if (setq item (assoc 62 ed)) (cdr item) "ByLayer")
-    (vl-prin1-to-string (if (setq item (assoc 6 ed)) (cdr item) "ByLayer"))))
-  (cond
-    ((= typ "LINE")
-      (setq s (cdr (assoc 10 ed)) e (cdr (assoc 11 ed)))
-      (append result (list (car s) (cadr s) (caddr s) (car e) (cadr e) (caddr e) (distance s e))))
-    ((= typ "CIRCLE")
-      (setq c (cdr (assoc 10 ed)))
-      (append result (list (car c) (cadr c) (caddr c) (cdr (assoc 40 ed)))))
-    ((= typ "ARC")
-      (setq c (cdr (assoc 10 ed)))
-      (append result (list (car c) (cadr c) (caddr c) (cdr (assoc 40 ed)) (cdr (assoc 50 ed)) (cdr (assoc 51 ed)))))
-    ((= typ "LWPOLYLINE")
-      (setq verts nil closed nil)
-      (foreach g ed
-        (if (= (car g) 10) (setq verts (append verts (list (list (cadr g) (caddr g))))))
-        (if (= (car g) 70) (setq closed (= (logand (cdr g) 1) 1))))
-      (append result (list verts (if closed "T" nil))))
-    ((= typ "TEXT")
-      (setq ins (cdr (assoc 10 ed)))
-      (append result (list (car ins) (cadr ins) (caddr ins) (vl-prin1-to-string (cdr (assoc 1 ed))) (cdr (assoc 40 ed)) (cdr (assoc 50 ed))))))
-    ((= typ "MTEXT")
-      (setq ins (cdr (assoc 10 ed)))
-      (append result (list (car ins) (cadr ins) (caddr ins) (vl-prin1-to-string (cdr (assoc 1 ed))) (cdr (assoc 40 ed)) (cdr (assoc 50 ed))))))
-    ((= typ "INSERT")
-      (setq ins (cdr (assoc 10 ed)))
-      (append result (list (car ins) (cadr ins) (caddr ins) (vl-prin1-to-string (cdr (assoc 2 ed))) (cdr (assoc 50 ed)) (cdr (assoc 41 ed)) (cdr (assoc 42 ed))))))
-    ((= typ "POINT")
-      (setq p (cdr (assoc 10 ed)))
-      (append result (list (car p) (cadr p) (caddr p))))
-    (t result)))
-(defun @e:run nil
-  (setq ss ${ssgetExpr})
-  (if (null ss)
-    (list "total" 0 "offset" ${offset} "limit" ${limit})
-    (progn
-      (setq total (sslength ss) entities nil i ${offset})
-      (while (and (< i total) (< (length entities) ${limit}))
-        (setq entities (append entities (list (@e:props (ssname ss i)))) i (1+ i)))
-      (list "total" total "offset" ${offset} "limit" ${limit} "entities" entities))))
-(@e:run))
-`;
+(vl-load-com)
+(defun @e:dp (ent / ed typ gc is)
+  (setq ed (entget ent) typ (cdr (assoc 0 ed)) gc (assoc 62 ed) is (assoc 6 ed))
+  (list typ (cdr (assoc 5 ed)) (cdr (assoc 8 ed))
+    (if gc (cdr gc) 256)
+    (if is (cdr is) "ByLayer")))
+(setq @e:total (if (setq @e:ss ${ssgetExpr}) (sslength @e:ss) 0)
+      @e:ents nil @e:i 0)
+(while (and @e:ss (< @e:i @e:total)(< (length @e:ents) 100))
+  (setq @e:ents (cons (@e:dp (ssname @e:ss @e:i)) @e:ents) @e:i (1+ @e:i)))
+(vl-prin1-to-string (list @e:total (reverse @e:ents))))`;
 }
 function buildTextCode({ layer, bbox, offset, limit }) {
   const items = [`'(0 . "TEXT,MTEXT,ATTRIB,TCH_TEXT")`];
-  if (layer) items.push(`(cons 8 "${layer.replace(/"/g, '\\"')}")`);
+  if (layer)
+    items.push(`(cons 8 "${layer.replace(/"/g, '\\"')}")`);
   if (bbox) {
     const parts = bbox.split(",").map((s) => parseFloat(s.trim()));
     if (parts.length === 4) {
@@ -1168,8 +1180,8 @@ function buildTextCode({ layer, bbox, offset, limit }) {
 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: "\u5B9E\u4F53\u5C5E\u6027\u5217\u8868\uFF0C\u652F\u6301 ?type=LINE&layer=0&bbox=0,0,100,100&limit=100&offset=0", 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=500&offset=0", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://dwg/entities", name: "Entities", description: "\u56FE\u5143\u5217\u8868\uFF0C\u8FD4\u56DE\u603B\u6570\u548C\u524D100\u4E2A\u56FE\u5143\uFF08\u7C7B\u578B\u3001\u53E5\u67C4\u3001\u56FE\u5C42\u3001\u989C\u8272\u3001\u7EBF\u578B\uFF09\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 },
@@ -1180,14 +1192,16 @@ var RESOURCES = [
 ];
 function parseQuery(uri) {
   const qIdx = uri.indexOf("?");
-  if (qIdx === -1) return { base: uri, params: {} };
+  if (qIdx === -1)
+    return { base: uri, params: {} };
   const base = uri.substring(0, qIdx);
   const params = {};
   uri.substring(qIdx + 1).split("&").forEach((p) => {
     const eqIdx = p.indexOf("=");
     const k = eqIdx === -1 ? p : p.substring(0, eqIdx);
     const v = eqIdx === -1 ? "" : p.substring(eqIdx + 1);
-    if (k) params[k] = decodeURIComponent(v);
+    if (k)
+      params[k] = decodeURIComponent(v);
   });
   return { base, params };
 }
@@ -1231,7 +1245,8 @@ async function readResource(uri) {
 }
 async function getCadInfo2() {
   const cached = getCached("cad:info");
-  if (cached) return cached;
+  if (cached)
+    return cached;
   if (!cad.connected) {
     await cad.connect();
   }
@@ -1258,11 +1273,14 @@ async function getCadInfo2() {
 async function getLayers(filterName = null) {
   const cacheKey = filterName ? `dwg:layers:${filterName}` : "dwg:layers:all";
   const cached = getCached(cacheKey);
-  if (cached) return cached;
-  if (!cad.connected) await cad.connect();
-  if (!cad.connected) return [];
+  if (cached)
+    return cached;
+  if (!cad.connected)
+    await cad.connect();
+  if (!cad.connected)
+    return [];
   try {
-    const code = filterName ? `(tblnext "LAYER" T)` : `(progn (setq res nil)(while (setq e (tblnext "LAYER" (null res)))(setq res (cons (list (cdr (assoc 2 e)) (cdr (assoc 62 e)) (cdr (assoc 70 e))) res))) (reverse res))`;
+    const code = filterName ? `(vl-prin1-to-string (cdr (assoc 2 (tblnext "LAYER" T))))` : `(progn (setq res nil)(while (setq e (tblnext "LAYER" (null res)))(setq res (cons (list (vl-prin1-to-string (cdr (assoc 2 e))) (cdr (assoc 62 e)) (cdr (assoc 70 e))) res))) (reverse res))`;
     const result = await cad.sendCommandWithResult(code);
     if (!result || result === "" || result === "nil") {
       setCache(cacheKey, []);
@@ -1307,46 +1325,42 @@ async function getLayers(filterName = null) {
 async function getEntities(params = {}) {
   const cacheKey = `dwg:entities:${JSON.stringify(params)}`;
   const cached = getCached(cacheKey);
-  if (cached) return cached;
-  if (!cad.connected) await cad.connect();
+  if (cached)
+    return cached;
+  if (!cad.connected)
+    await cad.connect();
   if (!cad.connected) {
     const result = { total: 0, entities: [] };
     setCache(cacheKey, result);
     return result;
   }
-  const offset = Math.max(0, parseInt(params.offset) || 0);
-  const limit = Math.min(Math.max(1, parseInt(params.limit) || 100), 1e3);
   try {
     const code = buildEntityCode({
       type: params.type || null,
       layer: params.layer || null,
-      bbox: params.bbox || null,
-      offset,
-      limit
+      bbox: params.bbox || null
     });
     const resultStr = await cad.sendCommandWithResult(code);
-    if (!resultStr || resultStr === "" || resultStr === "nil" || resultStr === "0") {
-      const result = { total: 0, offset, limit, entities: [] };
-      setCache(cacheKey, result);
-      return result;
+    if (!resultStr || resultStr === "" || resultStr === "nil") {
+      const result2 = { total: 0, entities: [] };
+      setCache(cacheKey, result2);
+      return result2;
     }
+    let total = 0;
+    let entities = [];
     const parsed = parseLispRecursive(resultStr);
-    if (!parsed || !Array.isArray(parsed)) {
-      const result = { total: 0, offset, limit, entities: [] };
-      setCache(cacheKey, result);
-      return result;
+    if (parsed && Array.isArray(parsed) && parsed.length >= 2) {
+      total = typeof parsed[0] === "number" ? parsed[0] : 0;
+      const rawEntities = Array.isArray(parsed[1]) ? parsed[1] : [];
+      entities = rawEntities.map(parseEntity).filter(Boolean);
     }
-    const entitiesIdx = parsed.indexOf("entities");
-    const rawEntities = entitiesIdx !== -1 && Array.isArray(parsed[entitiesIdx + 1]) ? parsed[entitiesIdx + 1] : [];
-    const data = lispPairsToObject(parsed);
-    data.entities = rawEntities.length > 0 ? rawEntities.map(parseEntity).filter(Boolean) : [];
-    data.offset = offset;
-    data.limit = limit;
-    setCache(cacheKey, data);
-    return data;
+    const result = { total, entities };
+    log(`getEntities: total=${total}, returned=${entities.length}`);
+    setCache(cacheKey, result);
+    return result;
   } catch (e) {
     log(`getEntities error: ${e.message}`);
-    const result = { total: 0, offset, limit, entities: [] };
+    const result = { total: 0, entities: [] };
     setCache(cacheKey, result);
     return result;
   }
@@ -1354,15 +1368,17 @@ async function getEntities(params = {}) {
 async function getTexts(params = {}) {
   const cacheKey = `dwg:texts:${JSON.stringify(params)}`;
   const cached = getCached(cacheKey);
-  if (cached) return cached;
-  if (!cad.connected) await cad.connect();
+  if (cached)
+    return cached;
+  if (!cad.connected)
+    await cad.connect();
   if (!cad.connected) {
     const result = { total: 0, texts: [] };
     setCache(cacheKey, result);
     return result;
   }
   const offset = Math.max(0, parseInt(params.offset) || 0);
-  const limit = Math.min(Math.max(1, parseInt(params.limit) || 500), 5e3);
+  const limit = Math.min(Math.max(1, parseInt(params.limit) || 5e3), 5e3);
   try {
     const code = buildTextCode({
       layer: params.layer || null,
@@ -1393,8 +1409,10 @@ async function getTexts(params = {}) {
   }
 }
 async function getDwgName() {
-  if (!cad.connected) await cad.connect();
-  if (!cad.connected) return { name: null };
+  if (!cad.connected)
+    await cad.connect();
+  if (!cad.connected)
+    return { name: null };
   try {
     const code = `(vl-princ-to-string (getvar "dwgname"))`;
     const name = await cad.sendCommandWithResult(code);
@@ -1404,8 +1422,10 @@ async function getDwgName() {
   }
 }
 async function getDwgPath() {
-  if (!cad.connected) await cad.connect();
-  if (!cad.connected) return { path: null, name: null };
+  if (!cad.connected)
+    await cad.connect();
+  if (!cad.connected)
+    return { path: null, name: null };
   try {
     const code = `(progn
           (setq prefix (vl-princ-to-string (getvar "dwgprefix")))
@@ -1423,7 +1443,8 @@ async function getDwgPath() {
     }
     if (!parsed) {
       const listResult = parseLispList(result);
-      if (listResult && listResult.length >= 2) parsed = listResult;
+      if (listResult && listResult.length >= 2)
+        parsed = listResult;
     }
     if (parsed && Array.isArray(parsed) && parsed.length >= 2) {
       return { path: String(parsed[0]), name: String(parsed[1]) };
@@ -1436,9 +1457,12 @@ async function getDwgPath() {
 async function getPackages(filterName = null) {
   const cacheKey = filterName ? `packages:${filterName}` : "packages:all";
   const cached = getCached(cacheKey);
-  if (cached) return cached;
-  if (!cad.connected) await cad.connect();
-  if (!cad.connected) return [];
+  if (cached)
+    return cached;
+  if (!cad.connected)
+    await cad.connect();
+  if (!cad.connected)
+    return [];
   try {
     const code = `(mapcar 'cdr @::*local-pkgs*)`;
     const result = await cad.sendCommandWithResult(code);
@@ -1452,7 +1476,8 @@ async function getPackages(filterName = null) {
     } catch {
       raw = parseLispList(result) || [];
     }
-    if (!Array.isArray(raw)) raw = [];
+    if (!Array.isArray(raw))
+      raw = [];
     const packages = raw.map((item) => {
       if (Array.isArray(item)) {
         const pkg = { name: "", version: "0.0.0", description: "", loaded: true };
@@ -1461,13 +1486,20 @@ async function getPackages(filterName = null) {
             const [[key, val]] = Object.entries(entry);
             const k = String(key);
             const v = String(val);
-            if (k === ":NAME") pkg.name = v;
-            else if (k === ":VERSION") pkg.version = v;
-            else if (k === ":DESCRIPTION") pkg.description = v;
-            else if (k === ":FULL-NAME") pkg.fullName = v;
-            else if (k === ":AUTHOR") pkg.author = v;
-            else if (k === ":CATEGORY") pkg.category = v;
-            else if (k === ":URL") pkg.url = v;
+            if (k === ":NAME")
+              pkg.name = v;
+            else if (k === ":VERSION")
+              pkg.version = v;
+            else if (k === ":DESCRIPTION")
+              pkg.description = v;
+            else if (k === ":FULL-NAME")
+              pkg.fullName = v;
+            else if (k === ":AUTHOR")
+              pkg.author = v;
+            else if (k === ":CATEGORY")
+              pkg.category = v;
+            else if (k === ":URL")
+              pkg.url = v;
           }
         }
         return pkg;
@@ -1478,15 +1510,22 @@ async function getPackages(filterName = null) {
       if (item && typeof item === "object") {
         const pkg = { name: "", version: "0.0.0", description: "", loaded: true };
         const nameVal = item.name || item.Name || item.NAME || item[":NAME"];
-        if (nameVal) pkg.name = String(nameVal);
+        if (nameVal)
+          pkg.name = String(nameVal);
         const verVal = item.version || item.Version || item.VERSION || item[":VERSION"];
-        if (verVal) pkg.version = String(verVal);
+        if (verVal)
+          pkg.version = String(verVal);
         const descVal = item.description || item.Description || item.DESCRIPTION || item[":DESCRIPTION"];
-        if (descVal) pkg.description = String(descVal);
-        if (item.fullName || item.full_name) pkg.fullName = String(item.fullName || item.full_name);
-        if (item.author || item.Author) pkg.author = String(item.author || item.Author);
-        if (item.category || item.Category) pkg.category = String(item.category || item.Category);
-        if (item.url || item.Url || item.URL) pkg.url = String(item.url || item.Url || item.URL);
+        if (descVal)
+          pkg.description = String(descVal);
+        if (item.fullName || item.full_name)
+          pkg.fullName = String(item.fullName || item.full_name);
+        if (item.author || item.Author)
+          pkg.author = String(item.author || item.Author);
+        if (item.category || item.Category)
+          pkg.category = String(item.category || item.Category);
+        if (item.url || item.Url || item.URL)
+          pkg.url = String(item.url || item.Url || item.URL);
         return pkg;
       }
       return null;
@@ -1512,9 +1551,12 @@ function getPlatforms() {
 async function getDwgList() {
   const cacheKey = "cad:dwgs";
   const cached = getCached(cacheKey);
-  if (cached) return cached;
-  if (!cad.connected) await cad.connect();
-  if (!cad.connected) return [];
+  if (cached)
+    return cached;
+  if (!cad.connected)
+    await cad.connect();
+  if (!cad.connected)
+    return [];
   try {
     const code = `(progn
           (vl-load-com)
@@ -1538,7 +1580,8 @@ async function getDwgList() {
         parsed = listResult;
       }
     }
-    if (!Array.isArray(parsed)) parsed = [];
+    if (!Array.isArray(parsed))
+      parsed = [];
     const dwgList = parsed.map((item) => {
       if (Array.isArray(item) && item.length >= 2) {
         return { name: String(item[0]), path: String(item[1]) };
@@ -1565,7 +1608,8 @@ function loadStandardsFile(filename) {
 var standardsCache = /* @__PURE__ */ new Map();
 function getCachedStandards(key) {
   const entry = standardsCache.get(key);
-  if (entry && Date.now() - entry.timestamp < 3e4) return entry.data;
+  if (entry && Date.now() - entry.timestamp < 3e4)
+    return entry.data;
   standardsCache.delete(key);
   return null;
 }
@@ -1574,16 +1618,20 @@ function setCachedStandards(key, data) {
 }
 function getDraftingStandards() {
   const cached = getCachedStandards("drafting");
-  if (cached) return cached;
+  if (cached)
+    return cached;
   const data = loadStandardsFile("drafting.json");
-  if (data) setCachedStandards("drafting", data);
+  if (data)
+    setCachedStandards("drafting", data);
   return data || { error: "\u5236\u56FE\u89C4\u8303\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25" };
 }
 function getCodingStandards() {
   const cached = getCachedStandards("coding");
-  if (cached) return cached;
+  if (cached)
+    return cached;
   const data = loadStandardsFile("coding.json");
-  if (data) setCachedStandards("coding", data);
+  if (data)
+    setCachedStandards("coding", data);
   return data || { error: "\u7F16\u7801\u89C4\u8303\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25" };
 }
 
@@ -1837,10 +1885,14 @@ ${generateSuggestions(entities, layers)}`
 }
 function generateSuggestions(entities, layers) {
   const suggestions = [];
-  if (entities.total > 1e3) suggestions.push("- \u56FE\u7EB8\u5B9E\u4F53\u8F83\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u56FE\u5C42\u5206\u7C7B\u7BA1\u7406");
-  if (layers.length > 20) suggestions.push("- \u56FE\u5C42\u8F83\u591A\uFF0C\u5EFA\u8BAE\u6E05\u7406\u672A\u4F7F\u7528\u7684\u56FE\u5C42");
-  if (entities.byType.LINE && entities.byType.LINE > 500) suggestions.push("- \u7EBF\u6761\u8F83\u591A\uFF0C\u53EF\u8003\u8651\u4F7F\u7528 BLOCK \u51CF\u5C11\u5B9E\u4F53\u6570\u91CF");
-  if (!entities.byType.DIMENSION) suggestions.push("- \u672A\u53D1\u73B0\u5C3A\u5BF8\u6807\u6CE8\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u6807\u6CE8");
+  if (entities.total > 1e3)
+    suggestions.push("- \u56FE\u7EB8\u5B9E\u4F53\u8F83\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u56FE\u5C42\u5206\u7C7B\u7BA1\u7406");
+  if (layers.length > 20)
+    suggestions.push("- \u56FE\u5C42\u8F83\u591A\uFF0C\u5EFA\u8BAE\u6E05\u7406\u672A\u4F7F\u7528\u7684\u56FE\u5C42");
+  if (entities.byType.LINE && entities.byType.LINE > 500)
+    suggestions.push("- \u7EBF\u6761\u8F83\u591A\uFF0C\u53EF\u8003\u8651\u4F7F\u7528 BLOCK \u51CF\u5C11\u5B9E\u4F53\u6570\u91CF");
+  if (!entities.byType.DIMENSION)
+    suggestions.push("- \u672A\u53D1\u73B0\u5C3A\u5BF8\u6807\u6CE8\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u6807\u6CE8");
   return suggestions.length ? suggestions.join("\n") : "- \u56FE\u7EB8\u7ED3\u6784\u826F\u597D";
 }
 async function generateBatchLinesPrompt(args) {
@@ -2568,9 +2620,11 @@ var SseSession = class {
     return lines.join("\n") + "\n\n";
   }
   _setupDrain() {
-    if (typeof this.#res.on !== "function") return;
+    if (typeof this.#res.on !== "function")
+      return;
     this.#drainHandler = () => {
-      if (!this.#active) return;
+      if (!this.#active)
+        return;
       if (this.#backpressureBuffer.length > 0) {
         this._drainBuffer();
       }
@@ -2592,7 +2646,8 @@ var SseSession = class {
     }
   }
   _write(content) {
-    if (!this.#active) return false;
+    if (!this.#active)
+      return false;
     try {
       if (this.#backpressureBuffer.length > 0) {
         this.#backpressureBuffer.push(content);
@@ -2720,7 +2775,8 @@ function persistSessionData(clientId, sessionData) {
 function loadPersistedSessionData(clientId) {
   try {
     const filePath = getSessionStorePath(clientId);
-    if (!fs5.existsSync(filePath)) return null;
+    if (!fs5.existsSync(filePath))
+      return null;
     const raw = fs5.readFileSync(filePath, "utf-8");
     const store = JSON.parse(raw);
     if (Date.now() - store.savedAt > SESSION_STORE_TTL) {
@@ -2909,7 +2965,8 @@ var SERVER_CAPABILITIES = {
   prompts: {}
 };
 var { port, host, transport, apiKey, rateLimitWindow, rateLimitMax } = config_default;
-if (apiKey) log("API Key authentication enabled");
+if (apiKey)
+  log("API Key authentication enabled");
 var mcpLimiter = rateLimit({
   windowMs: rateLimitWindow,
   max: rateLimitMax,
@@ -2994,7 +3051,8 @@ ${CAD_PLATFORMS.join("\n")}
   },
   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 (!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") }] };
@@ -3183,7 +3241,8 @@ var tools = [
 ];
 async function handleToolCall(name, args) {
   const handler = TOOL_HANDLERS[name];
-  if (!handler) return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
+  if (!handler)
+    return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
   try {
     const result = await handler(args || {});
     notifyResourceChanges(name);
@@ -3306,7 +3365,8 @@ async function startServer() {
     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();
+      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);
@@ -3327,9 +3387,11 @@ async function startServer() {
     const PUBLIC_PATHS = ["/health"];
     if (apiKey) {
       app.use((req, res, next) => {
-        if (PUBLIC_PATHS.includes(req.path)) return next();
+        if (PUBLIC_PATHS.includes(req.path))
+          return next();
         const auth = req.get("Authorization");
-        if (auth === `Bearer ${apiKey}`) return next();
+        if (auth === `Bearer ${apiKey}`)
+          return next();
         res.status(401).json({ error: "Unauthorized" });
       });
     }
@@ -3344,7 +3406,8 @@ async function startServer() {
         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();
+        if (req.method === "OPTIONS")
+          return res.status(204).end();
         next();
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.4.2",
+    "version": "1.4.4",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {