@shun-js/aibaiban-server 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shun-js/aibaiban-server",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "aibaiban.com server",
   "keywords": [
     "ai aibaiban"
@@ -37,7 +37,7 @@
     "qiao-z-nuser": "^6.0.0",
     "qiao-z-service": "^6.0.0",
     "qiao-z-sms": "^6.0.0",
-    "viho-llm": "^1.0.8",
+    "viho-llm": "^1.0.9",
     "zod": "^4.3.6",
     "zod-to-json-schema": "^3.25.1"
   },
@@ -45,5 +45,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "gitHead": "7b094023fede487784f42ca71277997906841cb1"
+  "gitHead": "9f171abf1a9b47fa0c4d33d38852e1778c533fdb"
 }

package/server/controller/LLMController.js

@@ -1,18 +1,12 @@
 // service
 const service = require('../service/LLMService.js');
-const service2 = require('../service/LLMServiceV2.js');
 
 /**
  * controller
  */
 module.exports = (app) => {
-  // draw agent
-  app.post('/chat-streaming', (req, res) => {
-    service.drawAgent(req, res);
-  });
-
   // draw agent
   app.post('/draw-agent', (req, res) => {
-    service2.drawAgent(req, res);
+    service.drawAgent(req, res);
   });
 };

package/server/service/LLMService.js

@@ -13,15 +13,15 @@ const modelName = finalLLMConfig.modelName;
 const thinking = finalLLMConfig.thinking;
 
 /**
- * drawAgent - 流式 Agent 接口
- * 流程：router -> classify -> elaborate -> generate
+ * drawAgent - 对话式 Agent
+ * 1 次决策 LLM → reply / generate(elaborate+generate) / irrelevant
  */
 exports.drawAgent = async (req, res) => {
   const methodName = 'drawAgent';
+  const messages = req.body.messages;
 
-  // check
-  if (!req.body.userPrompt) {
-    const msg = 'need userPrompt';
+  if (!messages?.length) {
+    const msg = 'need messages';
     req.logger.error(methodName, msg);
     res.jsonFail(msg);
     return;
@@ -30,142 +30,122 @@ exports.drawAgent = async (req, res) => {
   // 启动 SSE
   res.streamingStart();
 
-  const input = decodeURIComponent(req.body.userPrompt);
-  req.logger.info(methodName, 'userPrompt', input);
-  chatFeishuMsg(req, `userPrompt-${input}`);
+  const lastUserMsg = messages.filter((m) => m.role === 'user').pop()?.content || '';
+  req.logger.info(methodName, 'lastUserMsg', lastUserMsg);
+  chatFeishuMsg(req, `${lastUserMsg}`);
 
   try {
     const startTime = Date.now();
-    let stepStart = startTime;
 
-    // agent 管线共享状态
-    let diagramType = '';
-    let elaboration = '';
+    // 1. Agent 决策
+    res.streaming(`data: ${JSON.stringify({ type: 'status', step: 'thinking' })}\n\n`);
 
+    let decision = null;
     await runAgents([
-      // 1. router - 意图分类
       {
         agentStartCallback: () => {
-          stepStart = Date.now();
-          res.streaming(`data: ${JSON.stringify({ step: 'router', status: 'start' })}\n\n`);
-          req.logger.info(methodName, 'step: router');
+          req.logger.info(methodName, 'step: agent decision');
         },
         agentRequestOptions: {
           llm,
           modelName,
-          messages: [{ role: 'user', content: prompts.ROUTER_PROMPT.replace('{input}', input) }],
-          thinking: thinking,
+          thinking,
           isJson: true,
+          messages: [{ role: 'system', content: prompts.AGENT_PROMPT }, ...messages],
         },
         agentEndCallback: (result) => {
-          const intent = result.intent;
-          const duration = Date.now() - stepStart;
-          req.logger.info(methodName, 'intent', intent, `${duration}ms`);
-          chatFeishuMsg(req, `intent-${intent}`);
-          res.streaming(`data: ${JSON.stringify({ step: 'router', intent, duration })}\n\n`);
-          return intent === 'irrelevant';
-        },
-        agentBreakCallback: () => {
-          res.streaming(
-            `data: ${JSON.stringify({ step: 'router', result: 'irrelevant', response: prompts.FIXED_REPLY })}\n\n`,
-          );
+          decision = result;
+          const duration = Date.now() - startTime;
+          req.logger.info(methodName, 'decision', JSON.stringify(decision), `${duration}ms`);
+          chatFeishuMsg(req, `decision-${decision.action}`);
         },
       },
-      // 2. classify - 分类图表类型
-      {
-        agentStartCallback: () => {
-          stepStart = Date.now();
-          res.streaming(`data: ${JSON.stringify({ step: 'classify', status: 'start' })}\n\n`);
-          req.logger.info(methodName, 'step: classify');
-        },
-        agentRequestOptions: {
-          llm,
-          modelName,
-          messages: [{ role: 'user', content: prompts.CLASSIFY_PROMPT.replace('{input}', input) }],
-          thinking: thinking,
-          isJson: true,
-        },
-        agentEndCallback: (result) => {
-          diagramType = result.diagramType;
-          const duration = Date.now() - stepStart;
-          req.logger.info(methodName, 'diagramType', diagramType, `${duration}ms`);
-          chatFeishuMsg(req, `diagramType-${diagramType}`);
-          res.streaming(`data: ${JSON.stringify({ step: 'classify', diagramType, duration })}\n\n`);
-        },
-      },
-      // 3. elaborate - 细化内容
-      {
-        agentStartCallback: () => {
-          stepStart = Date.now();
-          res.streaming(`data: ${JSON.stringify({ step: 'elaborate', status: 'start' })}\n\n`);
-          req.logger.info(methodName, 'step: elaborate');
-        },
-        agentRequestOptions: {
-          llm,
-          modelName,
-          get messages() {
-            return [
-              {
-                role: 'user',
-                content: prompts.ELABORATE_PROMPT.replace('{input}', input).replace('{diagramType}', diagramType),
-              },
-            ];
+    ]);
+
+    // 2. 分发
+    if (decision.action === 'reply') {
+      res.streaming(`data: ${JSON.stringify({ type: 'message', content: decision.message })}\n\n`);
+    } else if (decision.action === 'irrelevant') {
+      res.streaming(`data: ${JSON.stringify({ type: 'message', content: prompts.FIXED_REPLY })}\n\n`);
+    } else if (decision.action === 'generate') {
+      let elaboration = '';
+
+      await runAgents([
+        // elaborate
+        {
+          agentStartCallback: () => {
+            res.streaming(`data: ${JSON.stringify({ type: 'status', step: 'elaborate' })}\n\n`);
+            req.logger.info(methodName, 'step: elaborate');
           },
-          thinking: thinking,
-        },
-        agentEndCallback: (result) => {
-          elaboration = result;
-          const duration = Date.now() - stepStart;
-          req.logger.info(methodName, 'elaboration', elaboration.slice(0, 100) + '...', `${duration}ms`);
-          chatFeishuMsg(req, `elaboration-${elaboration}`);
-          res.streaming(`data: ${JSON.stringify({ step: 'elaborate', done: true, duration })}\n\n`);
-        },
-      },
-      // 4. generate - 生成 Mermaid
-      {
-        agentStartCallback: () => {
-          stepStart = Date.now();
-          res.streaming(`data: ${JSON.stringify({ step: 'generate', status: 'start' })}\n\n`);
-          req.logger.info(methodName, 'step: generate');
-        },
-        agentRequestOptions: {
-          llm,
-          modelName,
-          get messages() {
-            return [
-              {
-                role: 'user',
-                content: prompts.GENERATE_PROMPT.replace('{diagramType}', diagramType).replace(
-                  '{elaboration}',
-                  elaboration,
-                ),
-              },
-            ];
+          agentRequestOptions: {
+            llm,
+            modelName,
+            thinking,
+            get messages() {
+              return [
+                {
+                  role: 'user',
+                  content: prompts.ELABORATE_PROMPT.replace('{input}', decision.description).replace(
+                    '{diagramType}',
+                    decision.diagramType,
+                  ),
+                },
+              ];
+            },
+          },
+          agentEndCallback: (result) => {
+            elaboration = result;
+            req.logger.info(methodName, 'elaboration', String(elaboration).slice(0, 100) + '...');
           },
-          thinking: thinking,
         },
-        agentEndCallback: (result) => {
-          const mermaidCode = result;
-          const duration = Date.now() - stepStart;
-          const totalDuration = Date.now() - startTime;
-          req.logger.info(
-            methodName,
-            'mermaidCode',
-            mermaidCode.slice(0, 100) + '...',
-            `${duration}ms`,
-            `total: ${totalDuration}ms`,
-          );
-          chatFeishuMsg(req, `mermaidCode-${mermaidCode}`);
-          res.streaming(`data: ${JSON.stringify({ step: 'generate', mermaidCode, duration, totalDuration })}\n\n`);
+        // generate
+        {
+          agentStartCallback: () => {
+            res.streaming(`data: ${JSON.stringify({ type: 'status', step: 'generate' })}\n\n`);
+            req.logger.info(methodName, 'step: generate');
+          },
+          agentRequestOptions: {
+            llm,
+            modelName,
+            thinking,
+            get messages() {
+              return [
+                {
+                  role: 'user',
+                  content: prompts.GENERATE_PROMPT.replace('{diagramType}', decision.diagramType).replace(
+                    '{elaboration}',
+                    elaboration,
+                  ),
+                },
+              ];
+            },
+          },
+          agentEndCallback: (result) => {
+            const mermaidCode = result;
+            const duration = Date.now() - startTime;
+            req.logger.info(
+              methodName,
+              'mermaidCode',
+              String(mermaidCode).slice(0, 100) + '...',
+              `total: ${duration}ms`,
+            );
+            chatFeishuMsg(req, `mermaid-${mermaidCode}`);
+            res.streaming(`data: ${JSON.stringify({ type: 'mermaid', code: mermaidCode, duration })}\n\n`);
+          },
         },
-      },
-    ]);
+      ]);
+    } else {
+      // 未知 action fallback
+      res.streaming(
+        `data: ${JSON.stringify({ type: 'message', content: decision.message || '可以再说一次吗？' })}\n\n`,
+      );
+    }
 
     res.streamingEnd();
   } catch (error) {
     req.logger.error(methodName, 'error', error);
     errorFeishuMsg(req, error.message);
-    res.streaming(`data: ${JSON.stringify({ step: 'error', message: error.message })}\n\n`);
+    res.streaming(`data: ${JSON.stringify({ type: 'error', message: error.message })}\n\n`);
     res.streamingEnd();
   }
 };

package/server/util/prompt-agent.js

@@ -1,38 +1,44 @@
 /**
  * Agent Prompts
- * 从 test-agent/src/prompts/index.ts 复制
  */
 
 module.exports = {
   /**
-   * 意图分类 - 判断是否与白板相关
+   * Agent 决策 prompt
+   * 一次 LLM 调用完成意图判断 + 决策
    */
-  ROUTER_PROMPT: `你是一个意图分类器。判断用户输入是否与"画图/白板/图表/流程图/时序图/类图/ER图"相关。
+  AGENT_PROMPT: `你是 AI 白板助手，帮用户在白板上画图表。
 
-用户输入: {input}
+## 能力
+支持 4 种图表：flowchart（流程图）、sequence（时序图）、classDiagram（类图）、erDiagram（ER图）。
 
-只回复 JSON: {"intent": "whiteboard"} 或 {"intent": "irrelevant"}`,
+## 决策规则
+收到用户消息后判断，只回复 JSON：
 
-  /**
-   * 图表类型分类
-   */
-  CLASSIFY_PROMPT: `你是一个图表类型分析专家。根据用户需求，判断最适合的图表类型。
+1. 回复文字（追问、确认、引导）：
+   {"action":"reply","message":"你的回复内容"}
 
-可选类型:
-- flowchart: 流程图、步骤图、决策流程、状态图、思维导图等通用图表
-- sequence: 时序图、交互流程、调用链、消息传递
-- classDiagram: 类图、对象关系、继承结构、接口设计
-- erDiagram: ER图、实体关系图、数据库设计、数据模型
+2. 生成图表（信息已足够明确）：
+   {"action":"generate","diagramType":"类型","description":"详细描述，包含所有节点、关系、步骤"}
 
-注意:
-- 只能从以上4种类型中选择
-- 提到"ER图"、"实体关系"、"数据库"、"表结构"时必须选 erDiagram
-- 提到"类"、"继承"、"接口"、"对象"时选 classDiagram
-- 如果不确定，默认选 flowchart
+3. 与画图完全无关：
+   {"action":"irrelevant"}
 
-用户输入: {input}
+## 判断标准
+- 用户说了图表类型 + 具体场景/内容 → generate
+- 用户只说了类型没说内容 → reply 追问具体场景
+- 用户只说了内容没说类型 → 你来判断最合适的类型，直接 generate
+- 用户说"帮我画个图" → reply 追问想画什么
+- 用户要修改已有图表 → 根据对话历史理解上下文，generate 完整新图表
+- 用户闲聊但话题相关 → reply 自然回应并引导回画图
+- 用户闲聊话题无关 → irrelevant
+
+## 回复风格
+- 追问时友好自然，像朋友聊天，不要生硬
+- 可以给建议和示例帮助用户想清楚需求
+- generate 时 description 要尽可能详细完整
 
-只回复 JSON: {"diagramType": "类型"}`,
+只回复 JSON。`,
 
   /**
    * 图表内容细化

package/server/service/LLMServiceV2.js

@@ -1,188 +0,0 @@
-// llm
-const { OpenAIAPI, runAgents } = require('viho-llm');
-const prompts = require('../util/prompt-agent-v2.js');
-
-// util
-const { chatFeishuMsg, errorFeishuMsg } = require('../util/feishu.js');
-
-// LLM 配置
-const llmConfig = global.QZ_CONFIG.llm;
-const finalLLMConfig = llmConfig[llmConfig.default];
-const llm = OpenAIAPI(finalLLMConfig);
-const modelName = finalLLMConfig.modelName;
-const thinking = finalLLMConfig.thinking;
-
-/**
- * 从 LLM 返回文本中提取 JSON（兼容 markdown 代码块、前后有多余文字等情况）
- */
-function extractJSON(text) {
-  if (typeof text === 'object' && text !== null) return text;
-  const str = String(text).trim();
-
-  // 1. 尝试直接解析
-  try {
-    return JSON.parse(str);
-  } catch (_) {
-    /* ignore */
-  }
-
-  // 2. 尝试从 markdown 代码块提取
-  const codeBlockMatch = str.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-  if (codeBlockMatch) {
-    try {
-      return JSON.parse(codeBlockMatch[1].trim());
-    } catch (_) {
-      /* ignore */
-    }
-  }
-
-  // 3. 尝试提取第一个 {...} 块
-  const firstBrace = str.indexOf('{');
-  const lastBrace = str.lastIndexOf('}');
-  if (firstBrace !== -1 && lastBrace > firstBrace) {
-    try {
-      return JSON.parse(str.slice(firstBrace, lastBrace + 1));
-    } catch (_) {
-      /* ignore */
-    }
-  }
-
-  throw new Error(`Cannot parse JSON from LLM response: ${str.slice(0, 200)}`);
-}
-
-/**
- * drawAgentV2 - 对话式 Agent
- * 1 次决策 LLM → reply / generate(elaborate+generate) / irrelevant
- */
-exports.drawAgent = async (req, res) => {
-  const methodName = 'drawAgentV2';
-  const messages = req.body.messages;
-
-  if (!messages?.length) {
-    const msg = 'need messages';
-    req.logger.error(methodName, msg);
-    res.jsonFail(msg);
-    return;
-  }
-
-  // 启动 SSE
-  res.streamingStart();
-
-  const lastUserMsg = messages.filter((m) => m.role === 'user').pop()?.content || '';
-  req.logger.info(methodName, 'lastUserMsg', lastUserMsg);
-  chatFeishuMsg(req, `v2-${lastUserMsg}`);
-
-  try {
-    const startTime = Date.now();
-
-    // 1. Agent 决策
-    res.streaming(`data: ${JSON.stringify({ type: 'status', step: 'thinking' })}\n\n`);
-
-    let decision = null;
-    await runAgents([
-      {
-        agentStartCallback: () => {
-          req.logger.info(methodName, 'step: agent decision');
-        },
-        agentRequestOptions: {
-          llm,
-          modelName,
-          thinking,
-          messages: [{ role: 'system', content: prompts.AGENT_PROMPT }, ...messages],
-        },
-        agentEndCallback: (result) => {
-          decision = extractJSON(result);
-          const duration = Date.now() - startTime;
-          req.logger.info(methodName, 'decision', JSON.stringify(decision), `${duration}ms`);
-          chatFeishuMsg(req, `v2-decision-${decision.action}`);
-        },
-      },
-    ]);
-
-    // 2. 分发
-    if (decision.action === 'reply') {
-      res.streaming(`data: ${JSON.stringify({ type: 'message', content: decision.message })}\n\n`);
-    } else if (decision.action === 'irrelevant') {
-      res.streaming(`data: ${JSON.stringify({ type: 'message', content: prompts.FIXED_REPLY })}\n\n`);
-    } else if (decision.action === 'generate') {
-      let elaboration = '';
-
-      await runAgents([
-        // elaborate
-        {
-          agentStartCallback: () => {
-            res.streaming(`data: ${JSON.stringify({ type: 'status', step: 'elaborate' })}\n\n`);
-            req.logger.info(methodName, 'step: elaborate');
-          },
-          agentRequestOptions: {
-            llm,
-            modelName,
-            thinking,
-            get messages() {
-              return [
-                {
-                  role: 'user',
-                  content: prompts.ELABORATE_PROMPT.replace('{input}', decision.description).replace(
-                    '{diagramType}',
-                    decision.diagramType,
-                  ),
-                },
-              ];
-            },
-          },
-          agentEndCallback: (result) => {
-            elaboration = result;
-            req.logger.info(methodName, 'elaboration', String(elaboration).slice(0, 100) + '...');
-          },
-        },
-        // generate
-        {
-          agentStartCallback: () => {
-            res.streaming(`data: ${JSON.stringify({ type: 'status', step: 'generate' })}\n\n`);
-            req.logger.info(methodName, 'step: generate');
-          },
-          agentRequestOptions: {
-            llm,
-            modelName,
-            thinking,
-            get messages() {
-              return [
-                {
-                  role: 'user',
-                  content: prompts.GENERATE_PROMPT.replace('{diagramType}', decision.diagramType).replace(
-                    '{elaboration}',
-                    elaboration,
-                  ),
-                },
-              ];
-            },
-          },
-          agentEndCallback: (result) => {
-            const mermaidCode = result;
-            const duration = Date.now() - startTime;
-            req.logger.info(
-              methodName,
-              'mermaidCode',
-              String(mermaidCode).slice(0, 100) + '...',
-              `total: ${duration}ms`,
-            );
-            chatFeishuMsg(req, `v2-mermaid-${mermaidCode}`);
-            res.streaming(`data: ${JSON.stringify({ type: 'mermaid', code: mermaidCode, duration })}\n\n`);
-          },
-        },
-      ]);
-    } else {
-      // 未知 action fallback
-      res.streaming(
-        `data: ${JSON.stringify({ type: 'message', content: decision.message || '可以再说一次吗？' })}\n\n`,
-      );
-    }
-
-    res.streamingEnd();
-  } catch (error) {
-    req.logger.error(methodName, 'error', error);
-    errorFeishuMsg(req, error.message);
-    res.streaming(`data: ${JSON.stringify({ type: 'error', message: error.message })}\n\n`);
-    res.streamingEnd();
-  }
-};

package/server/util/prompt-agent-v2.js

@@ -1,43 +0,0 @@
-/**
- * Agent V2 Prompts - 对话式 Agent
- */
-const { ELABORATE_PROMPT, GENERATE_PROMPT, FIXED_REPLY } = require('./prompt-agent.js');
-
-/**
- * Agent 决策 prompt
- * 一次 LLM 调用完成意图判断 + 决策
- */
-const AGENT_PROMPT = `你是 AI 白板助手，帮用户在白板上画图表。
-
-## 能力
-支持 4 种图表：flowchart（流程图）、sequence（时序图）、classDiagram（类图）、erDiagram（ER图）。
-
-## 决策规则
-收到用户消息后判断，只回复 JSON：
-
-1. 回复文字（追问、确认、引导）：
-   {"action":"reply","message":"你的回复内容"}
-
-2. 生成图表（信息已足够明确）：
-   {"action":"generate","diagramType":"类型","description":"详细描述，包含所有节点、关系、步骤"}
-
-3. 与画图完全无关：
-   {"action":"irrelevant"}
-
-## 判断标准
-- 用户说了图表类型 + 具体场景/内容 → generate
-- 用户只说了类型没说内容 → reply 追问具体场景
-- 用户只说了内容没说类型 → 你来判断最合适的类型，直接 generate
-- 用户说"帮我画个图" → reply 追问想画什么
-- 用户要修改已有图表 → 根据对话历史理解上下文，generate 完整新图表
-- 用户闲聊但话题相关 → reply 自然回应并引导回画图
-- 用户闲聊话题无关 → irrelevant
-
-## 回复风格
-- 追问时友好自然，像朋友聊天，不要生硬
-- 可以给建议和示例帮助用户想清楚需求
-- generate 时 description 要尽可能详细完整
-
-只回复 JSON。`;
-
-module.exports = { AGENT_PROMPT, ELABORATE_PROMPT, GENERATE_PROMPT, FIXED_REPLY };