@atlisp/agent 0.1.1

package/agent.js

@@ -0,0 +1,215 @@
+import { createProvider } from './providers/index.js';
+import { createMcpClient, connectMcp } from './mcp/index.js';
+import { buildSystemMessage, buildToolsDescription, TOOL_DESCRIPTIONS } from './prompt.js';
+import { getAgentConfig } from './config.js';
+
+export class Agent {
+  constructor(options = {}) {
+    this.llm = options.llm || createProvider(options.llmConfig);
+    this.mcp = options.mcp || createMcpClient(options.mcpConfig);
+    this.config = { ...getAgentConfig(), ...options.agentConfig };
+    this.messages = [];
+    this.tools = null;
+    this.maxSteps = this.config.maxSteps || 10;
+    this.verbose = this.config.verbose || false;
+  }
+
+  async initialize() {
+    console.error('[Agent] 初始化...');
+
+    await connectMcp(this.mcp);
+    console.error('[Agent] MCP 连接成功');
+
+    this.tools = await this.mcp.listTools();
+    console.error(`[Agent] 已加载 ${this.tools?.tools?.length || 0} 个工具`);
+
+    this.messages = [
+      { role: 'system', content: buildSystemMessage() },
+    ];
+
+    return this;
+  }
+
+  async chat(message) {
+    this.messages.push({ role: 'user', content: message });
+
+    let step = 0;
+    let finalResponse = '';
+    let hasToolCalls = false;
+
+    while (step < this.maxSteps) {
+      step++;
+
+      if (this.verbose) {
+        console.error(`[Agent] Step ${step}/${this.maxSteps}`);
+      }
+
+      const response = await this.llm.chat(this.messages, {
+        tools: buildToolsDescription(),
+      });
+
+      if (!response) {
+        finalResponse = '抱歉，我无法理解你的请求。';
+        break;
+      }
+
+      this.messages.push({ role: 'assistant', content: response });
+
+      const toolCalls = this.extractToolCalls(response);
+
+      if (toolCalls.length === 0) {
+        finalResponse = response;
+        break;
+      }
+
+      hasToolCalls = true;
+      for (const toolCall of toolCalls) {
+        const result = await this.executeTool(toolCall);
+        this.messages.push({
+          role: 'user',
+          content: `工具 ${toolCall.name} 执行结果:\n${this.formatToolResult(result)}`,
+        });
+      }
+    }
+
+    if (hasToolCalls && !finalResponse) {
+      const finalReply = await this.llm.chat(this.messages, { tools: [] });
+      finalResponse = finalReply || '任务已完成';
+    }
+
+    return finalResponse || '任务已完成';
+  }
+
+  extractToolCalls(text) {
+    const calls = [];
+
+    const trimmed = text.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+          for (const call of parsed) {
+            if (call.name) {
+              let args = call.arguments || {};
+              if (typeof args === 'string') {
+                try { args = JSON.parse(args); } catch {}
+              }
+              calls.push({ name: call.name, arguments: args });
+            }
+          }
+          if (calls.length > 0) return calls;
+        }
+      } catch (e) {}
+    }
+
+    const callPattern = /call:\s*(\w+)\{(\{[^\}]*\})?\}/g;
+    let match;
+    while ((match = callPattern.exec(text)) !== null) {
+      const name = match[1];
+      let args = {};
+      if (match[2]) {
+        try { args = JSON.parse(match[2]); } catch {}
+      }
+      calls.push({ name, arguments: args });
+    }
+    if (calls.length > 0) return calls;
+
+    try {
+      const toolCallsMatch = text.match(/tool_calls\s*:\s*(\[[\s\S]*?\])/i);
+      if (toolCallsMatch) {
+        const parsed = JSON.parse(toolCallsMatch[1]);
+        for (const call of parsed) {
+          if (call.name || call.function?.name) {
+            let args = call.arguments;
+            if (typeof args === 'string') {
+              try { args = JSON.parse(args); } catch {}
+            }
+            calls.push({
+              name: call.name || call.function.name,
+              arguments: args || {},
+            });
+          }
+        }
+        return calls;
+      }
+    } catch (e) {}
+
+    const jsonMatch = text.match(/```json\s*(\[[\s\S]*?\])\s*```/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[1]);
+        if (Array.isArray(parsed)) {
+          for (const call of parsed) {
+            if (call.name || call.function?.name) {
+              calls.push({
+                name: call.name || call.function.name,
+                arguments: call.arguments || call.function.arguments || {},
+              });
+            }
+          }
+        }
+      } catch (e) {}
+    }
+
+    const toolPattern = /```tool\s*([\s\S]*?)```/g;
+    while ((match = toolPattern.exec(text)) !== null) {
+      try {
+        const tool = JSON.parse(match[1]);
+        if (tool.name) {
+          calls.push(tool);
+        }
+      } catch (e) {}
+    }
+
+    return calls;
+  }
+
+  async executeTool(toolCall) {
+    const { name, arguments: args } = toolCall;
+
+    if (this.verbose) {
+      console.error(`[Agent] 执行工具: ${name}`, args);
+    }
+
+    try {
+      const result = await this.mcp.callTool(name, args);
+
+      if (this.verbose) {
+        console.error(`[Agent] 工具结果:`, result);
+      }
+
+      return result;
+    } catch (error) {
+      return { error: error.message, isError: true };
+    }
+  }
+
+  formatToolResult(result) {
+    if (!result) return '(无返回)';
+
+    if (result.isError) {
+      return `错误: ${result.content?.[0]?.text || result.error || '未知错误'}`;
+    }
+
+    if (result.content && result.content[0]) {
+      return result.content[0].text || JSON.stringify(result.content[0]);
+    }
+
+    return JSON.stringify(result);
+  }
+
+  async getHistory(limit = 10) {
+    const history = this.messages.slice(1);
+    return history.slice(-limit);
+  }
+
+  clearHistory() {
+    this.messages = [this.messages[0]];
+  }
+}
+
+export function createAgent(options = {}) {
+  return new Agent(options);
+}
+
+export default Agent;

package/config.js

@@ -0,0 +1,127 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import YAML from 'yaml';
+
+function getConfigPath() {
+  return path.join(os.homedir(), '.atlisp', 'atlisp.json');
+}
+
+function getYamlPath() {
+  return path.join(os.homedir(), '.atlisp', 'atlisp.yaml');
+}
+
+function loadConfigFile() {
+  const jsonPath = getConfigPath();
+  const yamlPath = getYamlPath();
+
+  if (fs.existsSync(jsonPath)) {
+    try {
+      const content = fs.readFileSync(jsonPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (e) {
+      console.error(`[Config] JSON 解析失败: ${e.message}`);
+    }
+  }
+
+  if (fs.existsSync(yamlPath)) {
+    try {
+      const content = fs.readFileSync(yamlPath, 'utf-8');
+      return YAML.parse(content);
+    } catch (e) {
+      console.error(`[Config] YAML 解析失败: ${e.message}`);
+    }
+  }
+
+  return {};
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] !== null && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(target[key] || {}, source[key]);
+    } else if (source[key] !== undefined) {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+const defaultConfig = {
+  agent: {
+    enabled: true,
+    historyLimit: 50,
+    maxSteps: 10,
+    verbose: false,
+  },
+llm: {
+    provider: process.env.LLM_PROVIDER || 'vllm',
+    baseURL: process.env.VLLM_BASE_URL || '',
+    model: process.env.LLM_MODEL || 'deepseek-chat',
+    apiKey: process.env.DEEPSEEK_API_KEY || '',
+    temperature: parseFloat(process.env.LLM_TEMPERATURE || '0.7'),
+    maxTokens: parseInt(process.env.LLM_MAX_TOKENS || '2048'),
+  },
+  mcp: {
+    mode: 'http',
+    url: 'http://localhost:8110',
+    command: '',
+    args: [],
+  },
+};
+
+let config = null;
+
+function loadConfig() {
+  const fileConfig = loadConfigFile();
+  let merged = deepMerge(defaultConfig, fileConfig);
+
+  merged.agent = {
+    enabled: process.env.AGENT_ENABLED !== 'false',
+    historyLimit: parseInt(process.env.AGENT_HISTORY_LIMIT || String(merged.agent.historyLimit), 10),
+    maxSteps: parseInt(process.env.AGENT_MAX_STEPS || String(merged.agent.maxSteps), 10),
+    verbose: process.env.AGENT_VERBOSE === 'true' || merged.agent.verbose,
+  };
+
+  merged.llm = {
+    provider: process.env.LLM_PROVIDER || merged.llm.provider,
+    baseURL: process.env.VLLM_BASE_URL || merged.llm.baseURL,
+    model: process.env.LLM_MODEL || merged.llm.model,
+    apiKey: process.env.VLLM_API_KEY || merged.llm.apiKey,
+    temperature: parseFloat(process.env.LLM_TEMPERATURE || String(merged.llm.temperature)),
+    maxTokens: parseInt(process.env.LLM_MAX_TOKENS || String(merged.llm.maxTokens)),
+  };
+
+  merged.mcp = {
+    mode: process.env.MCP_MODE || merged.mcp.mode,
+    url: process.env.MCP_URL || merged.mcp.url,
+    command: process.env.MCP_COMMAND || merged.mcp.command,
+    args: process.env.MCP_ARGS ? process.env.MCP_ARGS.split(' ') : merged.mcp.args,
+  };
+
+  return merged;
+}
+
+function getConfig() {
+  if (!config) {
+    config = loadConfig();
+  }
+  return config;
+}
+
+export function getAgentConfig() {
+  return getConfig().agent;
+}
+
+export function getLlmConfig() {
+  return getConfig().llm;
+}
+
+export function getMcpConfig() {
+  return getConfig().mcp;
+}
+
+export { getConfig };
+
+export default getConfig;

package/index.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createAgent } from './agent.js';
+import { getLlmConfig, getMcpConfig, getAgentConfig } from './config.js';
+
+const program = new Command();
+
+program
+  .name('atlisp-agent')
+  .description('AI Agent for @lisp - Connects to MCP Server for CAD operations')
+  .version('1.0.0');
+
+program
+  .option('-m, --mode <mode>', 'MCP mode: http or stdio', 'http')
+  .option('-u, --mcp-url <url>', 'MCP HTTP URL', getMcpConfig().url)
+  .option('-c, --mcp-command <cmd>', 'MCP stdio command', getMcpConfig().command)
+  .option('--mcp-args <args>', 'MCP stdio args', '')
+  .option('-v, --verbose', 'Verbose output', false)
+  .option('--no-color', 'Disable color output', false);
+
+program
+  .command('chat')
+  .description('Start interactive chat session')
+  .argument('[message]', 'Initial message to send')
+  .action(async (message) => {
+    await runChat({ message, interactive: !message });
+  });
+
+program
+  .command('exec')
+  .description('Execute a single command')
+  .argument('<message>', 'Message to send to agent')
+  .action(async (message) => {
+    const result = await runSingle(message);
+    console.log(result);
+  });
+
+program
+  .command('tools')
+  .description('List available MCP tools')
+  .action(async () => {
+    await listTools();
+  });
+
+program.parse(process.argv);
+
+async function getAgent() {
+  const config = program.opts();
+  const mcpConfig = {
+    mode: config.mode,
+    url: config.mcpUrl,
+    command: config.mcpCommand,
+    args: config.mcpArgs ? config.mcpArgs.split(' ') : [],
+  };
+
+  return createAgent({
+    mcpConfig,
+    agentConfig: { verbose: config.verbose },
+  });
+}
+
+async function runChat(options) {
+  const agent = await getAgent();
+  await agent.initialize();
+
+  console.error('atlisp-agent 已启动，输入你的问题（或输入 exit 退出）\n');
+
+  if (options.message) {
+    const response = await agent.chat(options.message);
+    console.log(response);
+  }
+
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '> ',
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+    if (input === 'exit' || input === 'quit') {
+      rl.close();
+      return;
+    }
+
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+
+    try {
+      const response = await agent.chat(input);
+      console.log('\n' + response + '\n');
+    } catch (err) {
+      console.error('\n错误:', err.message);
+    }
+
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    console.error('\n再见!');
+    process.exit(0);
+  });
+}
+
+async function runSingle(message) {
+  const agent = await getAgent();
+  await agent.initialize();
+  return agent.chat(message);
+}
+
+async function listTools() {
+  const agent = await getAgent();
+  await agent.initialize();
+
+  const tools = agent.tools?.tools || [];
+  console.log(`可用工具 (${tools.length}):\n`);
+
+  for (const tool of tools) {
+    console.log(`  ${tool.name}`);
+    console.log(`    ${tool.description}`);
+    console.log();
+  }
+}
+
+if (process.argv.length === 2) {
+  program.help();
+}

package/mcp/http-client.js

@@ -0,0 +1,80 @@
+import { getMcpConfig } from '../config.js';
+
+export class HttpMcpClient {
+  constructor(config = {}) {
+    this.config = { ...getMcpConfig(), ...config };
+    this.baseURL = this.config.url.replace(/\/$/, '') + '/mcp/message';
+    this.apiKey = this.config.apiKey || '';
+    this.requestId = 0;
+  }
+
+  async request(method, params = {}) {
+    const id = ++this.requestId;
+    const body = {
+      jsonrpc: '2.0',
+      id,
+      method,
+      params,
+    };
+
+    const response = await fetch(this.baseURL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.apiKey && { 'Authorization': `Bearer ${this.apiKey}` }),
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`MCP HTTP error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+
+    if (data.error) {
+      throw new Error(`MCP error: ${data.error.message || JSON.stringify(data.error)}`);
+    }
+
+    return data.result;
+  }
+
+  async listTools() {
+    return this.request('tools/list');
+  }
+
+  async callTool(name, args = {}) {
+    return this.request('tools/call', { name, arguments: args });
+  }
+
+  async listResources() {
+    return this.request('resources/list');
+  }
+
+  async readResource(uri) {
+    return this.request('resources/read', { uri });
+  }
+
+  async listPrompts() {
+    return this.request('prompts/list');
+  }
+
+  async getPrompt(name, args = {}) {
+    return this.request('prompts/get', { name, arguments: args });
+  }
+
+  async initialize() {
+    const result = await this.request('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'atlisp-agent', version: '1.0.0' },
+    });
+    return result;
+  }
+
+  getTools() {
+    return this.listTools();
+  }
+}
+
+export default HttpMcpClient;

package/mcp/index.js

@@ -0,0 +1,26 @@
+import { HttpMcpClient } from './http-client.js';
+import { StdioMcpClient } from './stdio-client.js';
+import { getMcpConfig } from '../config.js';
+
+export function createMcpClient(config = {}) {
+  const mcpConfig = { ...getMcpConfig(), ...config };
+  const mode = mcpConfig.mode || 'http';
+
+  if (mode === 'stdio') {
+    return new StdioMcpClient(config);
+  }
+
+  return new HttpMcpClient(config);
+}
+
+export async function connectMcp(client) {
+  if (client.connect) {
+    await client.connect();
+  }
+  if (client.initialize) {
+    await client.initialize();
+  }
+  return client;
+}
+
+export { HttpMcpClient, StdioMcpClient };

package/mcp/stdio-client.js

@@ -0,0 +1,143 @@
+import { spawn } from 'child_process';
+import { getMcpConfig } from '../config.js';
+
+export class StdioMcpClient {
+  constructor(config = {}) {
+    this.config = { ...getMcpConfig(), ...config };
+    this.command = this.config.command;
+    this.args = this.config.args || [];
+    this.proc = null;
+    this.requestId = 0;
+    this.pendingRequests = new Map();
+    this.buffer = '';
+    this.initialized = false;
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.proc = spawn(this.command, this.args, {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        this.proc.stdout.on('data', (data) => {
+          this.handleStdout(data.toString());
+        });
+
+        this.proc.stderr.on('data', (data) => {
+          console.error('[MCP Stderr]:', data.toString());
+        });
+
+        this.proc.on('exit', (code) => {
+          console.error(`[MCP Stdio] Process exited with code ${code}`);
+          this.initialized = false;
+        });
+
+        this.proc.on('error', (err) => {
+          console.error('[MCP Stdio] Process error:', err.message);
+          reject(err);
+        });
+
+        setTimeout(() => {
+          resolve(true);
+        }, 1000);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  handleStdout(data) {
+    this.buffer += data;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        const resolve = this.pendingRequests.get(msg.id);
+        if (resolve) {
+          if (msg.error) {
+            resolve(Promise.reject(new Error(msg.error.message || JSON.stringify(msg.error))));
+          } else {
+            resolve(msg.result);
+          }
+          this.pendingRequests.delete(msg.id);
+        }
+      } catch (e) {
+        console.warn('[MCP Stdio] Parse error:', e.message);
+      }
+    }
+  }
+
+  async request(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.requestId;
+      const body = {
+        jsonrpc: '2.0',
+        id,
+        method,
+        params,
+      };
+
+      this.pendingRequests.set(id, resolve);
+
+      this.proc.stdin.write(JSON.stringify(body) + '\n');
+
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`MCP request timeout: ${method}`));
+        }
+      }, 30000);
+    });
+  }
+
+  async listTools() {
+    return this.request('tools/list');
+  }
+
+  async callTool(name, args = {}) {
+    return this.request('tools/call', { name, arguments: args });
+  }
+
+  async listResources() {
+    return this.request('resources/list');
+  }
+
+  async readResource(uri) {
+    return this.request('resources/read', { uri });
+  }
+
+  async listPrompts() {
+    return this.request('prompts/list');
+  }
+
+  async getPrompt(name, args = {}) {
+    return this.request('prompts/get', { name, arguments: args });
+  }
+
+  async initialize() {
+    const result = await this.request('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'atlisp-agent', version: '1.0.0' },
+    });
+    this.initialized = true;
+    return result;
+  }
+
+  async getTools() {
+    return this.listTools();
+  }
+
+  disconnect() {
+    if (this.proc) {
+      this.proc.kill();
+      this.proc = null;
+    }
+  }
+}
+
+export default StdioMcpClient;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@atlisp/agent",
+  "version": "0.1.1",
+  "description": "AI Agent for @lisp - Connects to MCP Server for CAD operations",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "atlisp-agent": "./index.js",
+    "atlisp-agent-server": "./server.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "server": "node server.js",
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": [
+    "atlisp",
+    "agent",
+    "ai",
+    "cad",
+    "autolisp",
+    "mcp"
+  ],
+  "author": "vitalgg",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "express": "^5.2.1",
+    "yaml": "^2.6.1"
+  }
+}

package/prompt.js

@@ -0,0 +1,165 @@
+export const SYSTEM_PROMPT = `你是一个专业的 @lisp AI 助手，专门帮助用户操作 CAD（AutoCAD/ZWCAD/GStarCAD/BricsCAD）和 AutoLISP 编程。
+
+## 你的能力
+
+1. **CAD 操作**: 通过 MCP 工具执行 CAD 命令、操作图形、管理图层等
+2. **AutoLISP 编程**: 编写、解释、调试 AutoLISP 代码
+3. **包管理**: 搜索、安装、列出 @lisp 包
+4. **函数查询**: 查询 @lisp 函数库中的函数用法
+
+## 重要规则
+
+- 每次回复应简洁明了
+- 执行工具后，将结果格式化呈现给用户
+- 如果工具执行失败，说明错误原因并尝试修复
+- 不要假设 CAD 状态，始终先检查连接状态
+- **当需要执行工具时，必须使用以下 JSON 格式返回**：
+  [{"name": "工具名称", "arguments": {"参数": "值"}}]
+- **不要使用其他格式，只使用这个 JSON 数组格式**
+
+## 可用工具
+
+`;
+
+export const TOOL_DESCRIPTIONS = [
+  {
+    name: 'connect_cad',
+    description: '连接到 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'eval_lisp',
+    description: '在 CAD 中执行 AutoLISP 代码（不返回结果）',
+    inputSchema: {
+      type: 'object',
+      properties: { code: { type: 'string', description: '要执行的 LISP 代码' } },
+      required: ['code'],
+    },
+  },
+  {
+    name: 'eval_lisp_with_result',
+    description: '在 CAD 中执行 AutoLISP 代码并返回结果',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: '要执行的 LISP 代码' },
+        encoding: { type: 'string', description: '结果编码，如 utf-8, gbk, gb2312, gb18030（可选）' },
+      },
+      required: ['code'],
+    },
+  },
+  {
+    name: 'get_cad_info',
+    description: '获取当前 CAD 信息（平台、版本、连接状态）',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'list_packages',
+    description: '列出已安装的 @lisp 包',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'search_packages',
+    description: '搜索 @lisp 包',
+    inputSchema: {
+      type: 'object',
+      properties: { query: { type: 'string', description: '搜索关键词' } },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'install_package',
+    description: '安装 @lisp 包到 CAD',
+    inputSchema: {
+      type: 'object',
+      properties: { packageName: { type: 'string', description: '包名称' } },
+      required: ['packageName'],
+    },
+  },
+  {
+    name: 'get_platform_info',
+    description: '获取 CAD 平台信息',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'get_file_extensions',
+    description: '获取指定平台的文件扩展名',
+    inputSchema: {
+      type: 'object',
+      properties: { platform: { type: 'string', enum: ['AutoCAD', 'ZWCAD', 'GStarCAD', 'BricsCAD'] } },
+      required: ['platform'],
+    },
+  },
+  {
+    name: 'get_install_code',
+    description: '获取 @lisp 安装代码',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'at_command',
+    description: '执行 @lisp 命令（如 @H, @list, @search 等）',
+    inputSchema: {
+      type: 'object',
+      properties: { command: { type: 'string', description: '@lisp 命令' } },
+      required: ['command'],
+    },
+  },
+  {
+    name: 'new_document',
+    description: '在 CAD 中新建空白文档',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'bring_to_front',
+    description: '将 CAD 窗口切换到前台（从后台运行状态唤醒）',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'install_atlisp',
+    description: '在 CAD 中安装 @lisp',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'get_function_usage',
+    description: '获取 @lisp 函数用法（从本地 JSON 库）',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: '函数名，如 string:length' },
+        package: { type: 'string', description: '包名，如 string（可选）' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'list_functions',
+    description: '列出 @lisp 函数库中的所有函数',
+    inputSchema: {
+      type: 'object',
+      properties: { package: { type: 'string', description: '包名，如 string（可选）' } },
+    },
+  },
+];
+
+export function buildToolsDescription() {
+  return TOOL_DESCRIPTIONS.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema,
+    },
+  }));
+}
+
+export function buildSystemMessage() {
+  const toolsDesc = buildToolsDescription()
+    .map((t) => `- ${t.function.name}: ${t.function.description}`)
+    .join('\n');
+
+  return SYSTEM_PROMPT + toolsDesc;
+}
+
+export function buildToolCallRequest(tools) {
+  return buildToolsDescription();
+}

package/providers/deepseek.js

@@ -0,0 +1,107 @@
+import { getLlmConfig } from '../config.js';
+
+export class DeepseekProvider {
+  constructor(config = {}) {
+    this.config = { ...getLlmConfig(), ...config };
+    this.baseURL = this.config.baseURL || 'https://api.deepseek.com/v1';
+    this.model = this.config.model || 'deepseek-chat';
+    this.apiKey = this.config.apiKey;
+    this.temperature = this.config.temperature;
+    this.maxTokens = this.config.maxTokens;
+  }
+
+  async chat(messages, options = {}) {
+    const url = `${this.baseURL}/chat/completions`;
+    const body = {
+      model: this.model,
+      messages: messages,
+      temperature: options.temperature ?? this.temperature,
+      max_tokens: options.maxTokens ?? this.maxTokens,
+      ...(options.stop && { stop: options.stop }),
+    };
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`DeepSeek API error: ${response.status} ${errorText}`);
+      }
+
+      const data = await response.json();
+
+      if (data.choices && data.choices.length > 0) {
+        return data.choices[0].message.content;
+      }
+
+      throw new Error('No response content from DeepSeek');
+    } catch (error) {
+      if (error.message.includes('fetch')) {
+        throw new Error(`无法连接到 DeepSeek: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  async chatStream(messages, onChunk, options = {}) {
+    const url = `${this.baseURL}/chat/completions`;
+    const body = {
+      model: this.model,
+      messages: messages,
+      temperature: options.temperature ?? this.temperature,
+      max_tokens: options.maxTokens ?? this.maxTokens,
+      stream: true,
+    };
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`DeepSeek API error: ${response.status}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') return;
+          try {
+            const obj = JSON.parse(data);
+            const content = obj.choices?.[0]?.delta?.content;
+            if (content) onChunk(content);
+          } catch (e) {}
+        }
+      }
+    }
+  }
+
+  getName() {
+    return 'deepseek';
+  }
+}
+
+export default DeepseekProvider;

package/providers/index.js

@@ -0,0 +1,25 @@
+import { VllmProvider } from './vllm.js';
+import { DeepseekProvider } from './deepseek.js';
+import { getLlmConfig } from '../config.js';
+
+const PROVIDERS = {
+  vllm: VllmProvider,
+  deepseek: DeepseekProvider,
+};
+
+export function createProvider(config = {}) {
+  const llmConfig = { ...getLlmConfig(), ...config };
+  const ProviderClass = PROVIDERS[llmConfig.provider];
+
+  if (!ProviderClass) {
+    throw new Error(`Unknown LLM provider: ${llmConfig.provider}. Available: ${Object.keys(PROVIDERS).join(', ')}`);
+  }
+
+  return new ProviderClass(config);
+}
+
+export function listProviders() {
+  return Object.keys(PROVIDERS);
+}
+
+export { VllmProvider };

package/providers/vllm.js

@@ -0,0 +1,107 @@
+import { getLlmConfig } from '../config.js';
+
+export class VllmProvider {
+  constructor(config = {}) {
+    this.config = { ...getLlmConfig(), ...config };
+    this.baseURL = this.config.baseURL;
+    this.model = this.config.model;
+    this.apiKey = this.config.apiKey;
+    this.temperature = this.config.temperature;
+    this.maxTokens = this.config.maxTokens;
+  }
+
+  async chat(messages, options = {}) {
+    const url = `${this.baseURL}/chat/completions`;
+    const body = {
+      model: this.model,
+      messages: messages,
+      temperature: options.temperature ?? this.temperature,
+      max_tokens: options.maxTokens ?? this.maxTokens,
+      ...(options.stop && { stop: options.stop }),
+    };
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`vLLM API error: ${response.status} ${errorText}`);
+      }
+
+      const data = await response.json();
+
+      if (data.choices && data.choices.length > 0) {
+        return data.choices[0].message.content;
+      }
+
+      throw new Error('No response content from vLLM');
+    } catch (error) {
+      if (error.message.includes('fetch')) {
+        throw new Error(`无法连接到 vLLM: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  async chatStream(messages, onChunk, options = {}) {
+    const url = `${this.baseURL}/chat/completions`;
+    const body = {
+      model: this.model,
+      messages: messages,
+      temperature: options.temperature ?? this.temperature,
+      max_tokens: options.maxTokens ?? this.maxTokens,
+      stream: true,
+    };
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`vLLM API error: ${response.status}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') return;
+          try {
+            const obj = JSON.parse(data);
+            const content = obj.choices?.[0]?.delta?.content;
+            if (content) onChunk(content);
+          } catch (e) {}
+        }
+      }
+    }
+  }
+
+  getName() {
+    return 'vllm';
+  }
+}
+
+export default VllmProvider;

package/server.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+import express from 'express';
+import { createAgent } from './agent.js';
+import { getLlmConfig, getMcpConfig, getAgentConfig } from './config.js';
+
+const app = express();
+
+const PORT = process.env.AGENT_PORT || '8120';
+const HOST = process.env.AGENT_HOST || '0.0.0.0';
+
+app.use(express.json({ limit: '10mb' }));
+
+let agent = null;
+
+async function getAgent() {
+  if (!agent) {
+    const llmConfig = getLlmConfig();
+    const mcpConfig = getMcpConfig();
+    const agentConfig = getAgentConfig();
+
+    agent = createAgent({
+      llmConfig,
+      mcpConfig: { ...mcpConfig, url: process.env.MCP_URL || mcpConfig.url },
+      agentConfig: { ...agentConfig, verbose: process.env.AGENT_VERBOSE === 'true' },
+    });
+
+    await agent.initialize();
+    console.error('[Agent Server] Agent 初始化完成');
+  }
+  return agent;
+}
+
+app.get('/health', async (req, res) => {
+  try {
+    const a = await getAgent();
+    res.json({
+      status: 'ok',
+      tools: a.tools?.tools?.length || 0,
+      provider: a.llm.getName(),
+    });
+  } catch (e) {
+    res.status(500).json({ status: 'error', error: e.message });
+  }
+});
+
+app.get('/tools', async (req, res) => {
+  try {
+    const a = await getAgent();
+    const tools = a.tools?.tools || [];
+    res.json({ tools });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.post('/chat', async (req, res) => {
+  try {
+    const a = await getAgent();
+    const { message, context } = req.body;
+
+    if (!message) {
+      return res.status(400).json({ error: '缺少 message 参数' });
+    }
+
+    if (context) {
+      for (const msg of context) {
+        if (msg.role && msg.content) {
+          a.messages.push({ role: msg.role, content: msg.content });
+        }
+      }
+    }
+
+    const response = await a.chat(message);
+    res.json({ response });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.post('/exec', async (req, res) => {
+  try {
+    const a = await getAgent();
+    const { message } = req.body;
+
+    if (!message) {
+      return res.status(400).json({ error: '缺少 message 参数' });
+    }
+
+    const response = await a.chat(message);
+    res.json({ result: response });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.get('/history', async (req, res) => {
+  try {
+    const a = await getAgent();
+    const limit = parseInt(req.query.limit || '10', 10);
+    const history = await a.getHistory(limit);
+    res.json({ history });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.delete('/history', async (req, res) => {
+  try {
+    const a = await getAgent();
+    a.clearHistory();
+    res.json({ status: 'cleared' });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+async function startServer() {
+  await getAgent();
+
+  app.listen(PORT, HOST, () => {
+    console.error(`atlisp-agent HTTP Server 启动 - http://${HOST}:${PORT}`);
+    console.error(`端点: POST /chat, POST /exec, GET /tools, GET /health`);
+  });
+}
+
+startServer().catch((e) => {
+  console.error('启动失败:', e);
+  process.exit(1);
+});