@shun-js/aibaiban-server 0.7.7 → 0.8.0

package/server/util/llm-toolcall.js

@@ -0,0 +1,314 @@
+/**
+ * Tool Calling 流程图生成器 - 主流程
+ */
+
+// path
+const path = require('path');
+const { readFile } = require('qiao-file');
+
+// 直接使用 @google/genai，绕过 viho-llm
+const { GoogleGenAI } = require('@google/genai');
+
+// gemini client（直接创建）
+const geminiClient = new GoogleGenAI({
+  vertexai: true,
+  project: global.QZ_CONFIG.gemini.projectId,
+  location: global.QZ_CONFIG.gemini.location,
+});
+
+const modelName = global.QZ_CONFIG.gemini.modelName;
+
+// const
+const chatConfig = {
+  temperature: 0.3,
+  topP: 0.9,
+  topK: 40,
+  maxOutputTokens: 8192,
+};
+
+/**
+ * 使用结构化输出生成流程图
+ * @param {string} userPrompt - 用户需求
+ * @returns {Object} - SimplifiedDiagram
+ */
+exports.generateFlowchartWithTools = async (userPrompt) => {
+  console.log('[ToolCall] Starting flowchart generation');
+  console.log('[ToolCall] User prompt:', userPrompt);
+
+  // 加载系统提示词
+  let systemPromptText = await readFile(path.resolve(__dirname, './prompt-toolcall.md'));
+
+  // 确保是字符串格式
+  if (Buffer.isBuffer(systemPromptText)) {
+    systemPromptText = systemPromptText.toString('utf-8');
+  }
+
+  console.log('[ToolCall] System prompt loaded, length:', systemPromptText.length);
+
+  try {
+    // 调用 AI 生成 JSON
+    const chatOptions = {
+      model: modelName,
+      contents: [
+        {
+          role: 'user',
+          parts: [
+            {
+              text: `${systemPromptText}\n\n---\n\n用户需求：${userPrompt}\n\n请只返回 JSON 对象，不要有任何其他说明文字。`,
+            },
+          ],
+        },
+      ],
+      config: chatConfig,
+    };
+
+    const response = await geminiClient.models.generateContent(chatOptions);
+
+    // 打印原始响应（调试用）
+    console.log('[ToolCall] Raw response:', JSON.stringify(response, null, 2));
+
+    // 检查响应
+    if (!response || !response.candidates || response.candidates.length === 0) {
+      console.error('[ToolCall] Invalid response format');
+      return { type: 'flowchart', nodes: [], connections: [], error: '响应格式错误' };
+    }
+
+    const candidate = response.candidates[0];
+    const content = candidate.content;
+
+    if (!content || !content.parts || content.parts.length === 0) {
+      console.error('[ToolCall] No content parts in response');
+      return { type: 'flowchart', nodes: [], connections: [], error: '无响应内容' };
+    }
+
+    // 提取文本
+    let responseText = '';
+    for (const part of content.parts) {
+      if (part.text) {
+        responseText += part.text;
+      }
+    }
+
+    console.log('[ToolCall] Response text length:', responseText.length);
+
+    // 尝试提取 JSON（可能被包裹在 markdown 代码块中）
+    let jsonText = responseText.trim();
+
+    // 移除可能的 markdown 代码块标记
+    const jsonMatch = jsonText.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (jsonMatch) {
+      jsonText = jsonMatch[1].trim();
+    }
+
+    // 解析 JSON
+    let diagramData;
+    try {
+      diagramData = JSON.parse(jsonText);
+    } catch (parseError) {
+      console.error('[ToolCall] JSON parse error:', parseError);
+      console.error('[ToolCall] JSON text:', jsonText.substring(0, 500));
+      return { type: 'flowchart', nodes: [], connections: [], error: 'JSON 解析失败' };
+    }
+
+    // 验证数据结构
+    if (!diagramData.nodes || !Array.isArray(diagramData.nodes)) {
+      console.error('[ToolCall] Invalid diagram data: missing nodes array');
+      return { type: 'flowchart', nodes: [], connections: [], error: '缺少节点数据' };
+    }
+
+    if (!diagramData.connections || !Array.isArray(diagramData.connections)) {
+      console.error('[ToolCall] Invalid diagram data: missing connections array');
+      return { type: 'flowchart', nodes: [], connections: [], error: '缺少连接数据' };
+    }
+
+    console.log(
+      `[ToolCall] Parsed diagram: ${diagramData.nodes.length} nodes, ${diagramData.connections.length} connections`,
+    );
+
+    // 应用布局计算
+    const nodesWithLayout = calculateMainFlowLayout(diagramData.nodes);
+
+    // 创建节点位置查找表
+    const nodeMap = {};
+    nodesWithLayout.forEach((node) => {
+      nodeMap[node.id] = node;
+    });
+
+    // 添加连线路由（智能识别连线类型）
+    const connectionsWithRouting = diagramData.connections.map((conn) => {
+      const fromNode = nodeMap[conn.from];
+      const toNode = nodeMap[conn.to];
+
+      if (!fromNode || !toNode) {
+        // 节点不存在，使用默认路由
+        return {
+          ...conn,
+          routing: {
+            exitSide: 'bottom',
+            entrySide: 'top',
+          },
+        };
+      }
+
+      // 判断连线类型
+      const isErrorBranch = toNode.color === 'red'; // 判断节点 -> 错误节点
+      const isBackwardFlow = toNode.y < fromNode.y; // 回退连线（向上）
+      const isHorizontal = Math.abs(fromNode.x - toNode.x) > 100; // 水平偏移较大
+
+      let routing;
+
+      if (isErrorBranch) {
+        // 错误分支：从判断节点左侧或右侧出去
+        routing = {
+          exitSide: toNode.x < fromNode.x ? 'left' : 'right',
+          exitRatio: 0.5,
+          entrySide: toNode.x < fromNode.x ? 'right' : 'left',
+          entryRatio: 0.5,
+        };
+      } else if (isBackwardFlow) {
+        // 回退连线：从错误节点顶部出去，进入输入节点左侧或右侧
+        routing = {
+          exitSide: 'top',
+          exitRatio: 0.5,
+          entrySide: toNode.x < fromNode.x ? 'right' : 'left',
+          entryRatio: 0.5,
+        };
+      } else if (isHorizontal) {
+        // 水平连线
+        routing = {
+          exitSide: toNode.x < fromNode.x ? 'left' : 'right',
+          exitRatio: 0.5,
+          entrySide: toNode.x < fromNode.x ? 'right' : 'left',
+          entryRatio: 0.5,
+        };
+      } else {
+        // 默认：垂直连线（主流程）
+        routing = {
+          exitSide: 'bottom',
+          entrySide: 'top',
+        };
+      }
+
+      return {
+        ...conn,
+        routing,
+      };
+    });
+
+    const finalDiagram = {
+      type: 'flowchart',
+      nodes: nodesWithLayout,
+      connections: connectionsWithRouting,
+    };
+
+    console.log('[ToolCall] Diagram generation completed successfully');
+    return finalDiagram;
+  } catch (error) {
+    console.error('[ToolCall] Error:', error);
+    return { type: 'flowchart', nodes: [], connections: [], error: error.message };
+  }
+};
+
+// 布局计算函数 - 智能识别分支结构
+function calculateMainFlowLayout(nodes) {
+  const LAYOUT = {
+    MAIN_X: 500,
+    ERROR_LEFT_X: 200,
+    ERROR_RIGHT_X: 800,
+    START_Y: 80,
+    STEP_SPACING: 150,
+    NODE_WIDTH: 180,
+    NODE_HEIGHT: 80,
+    ELLIPSE_WIDTH: 120,
+    ELLIPSE_HEIGHT: 60,
+    DIAMOND_WIDTH: 140,
+    DIAMOND_HEIGHT: 80,
+  };
+
+  // 第1步：识别错误节点（color: red）
+  const errorNodeIds = new Set();
+  nodes.forEach((node) => {
+    if (node.color === 'red') {
+      errorNodeIds.add(node.id);
+    }
+  });
+
+  console.log('[Layout] Error nodes:', Array.from(errorNodeIds));
+
+  // 第2步：为主流程节点分配 y 坐标
+  let mainFlowIndex = 0;
+  const nodePositions = {};
+
+  nodes.forEach((node) => {
+    if (!errorNodeIds.has(node.id)) {
+      // 主流程节点
+      const y = LAYOUT.START_Y + mainFlowIndex * LAYOUT.STEP_SPACING;
+      nodePositions[node.id] = {
+        x: LAYOUT.MAIN_X,
+        y: y,
+        isMainFlow: true,
+      };
+      mainFlowIndex++;
+    }
+  });
+
+  // 第3步：为错误节点分配位置（与判断节点同高，但在左侧或右侧）
+  let errorLeftIndex = 0;
+  let errorRightIndex = 0;
+
+  nodes.forEach((node, index) => {
+    if (errorNodeIds.has(node.id)) {
+      // 尝试找到前面最近的判断节点
+      let judgeNodeY = LAYOUT.START_Y + index * LAYOUT.STEP_SPACING;
+      for (let i = index - 1; i >= 0; i--) {
+        const prevNode = nodes[i];
+        if (prevNode.type === 'diamond' && nodePositions[prevNode.id]) {
+          judgeNodeY = nodePositions[prevNode.id].y;
+          break;
+        }
+      }
+
+      // 交替放置在左侧和右侧
+      const isLeft = errorLeftIndex <= errorRightIndex;
+      const x = isLeft ? LAYOUT.ERROR_LEFT_X : LAYOUT.ERROR_RIGHT_X;
+
+      if (isLeft) {
+        errorLeftIndex++;
+      } else {
+        errorRightIndex++;
+      }
+
+      nodePositions[node.id] = {
+        x: x,
+        y: judgeNodeY,
+        isMainFlow: false,
+      };
+    }
+  });
+
+  // 第4步：应用位置和尺寸
+  return nodes.map((node) => {
+    const pos = nodePositions[node.id];
+
+    // 宽高
+    let width, height;
+    if (node.type === 'ellipse') {
+      width = LAYOUT.ELLIPSE_WIDTH;
+      height = LAYOUT.ELLIPSE_HEIGHT;
+    } else if (node.type === 'diamond') {
+      width = LAYOUT.DIAMOND_WIDTH;
+      height = LAYOUT.DIAMOND_HEIGHT;
+    } else {
+      width = LAYOUT.NODE_WIDTH;
+      height = LAYOUT.NODE_HEIGHT;
+    }
+
+    return {
+      ...node,
+      x: pos.x,
+      y: pos.y,
+      width,
+      height,
+    };
+  });
+}

package/server/util/prompt-intent.md

@@ -0,0 +1,277 @@
+# 意图识别：判断用户是否要绘制图表 v2.0
+
+你是 AI 白板的意图识别助手，负责快速判断用户输入是否为绘图请求。
+
+## 输出要求
+
+**必须**以 JSON 格式输出，不要有任何其他文字：
+
+```json
+{
+  "intent": "DRAW" 或 "REJECT",
+  "reason": "判断理由（一句话说明）",
+  "confidence": 0.0-1.0
+}
+```
+
+## 判断标准
+
+### ✅ DRAW（绘图请求）- 高置信度场景
+
+**明确的绘图动词**（置信度 0.9+）：
+
+- 画、绘制、画出、画个、帮我画
+- 设计、创建、生成、制作
+- 展示、可视化、呈现
+- 图示、示意
+
+**包含图表类型词**（置信度 0.85+）：
+
+- 流程图、架构图、思维导图、时序图
+- 结构图、关系图、示意图、拓扑图
+- ER图、UML图、组织架构图
+- 状态图、活动图、序列图
+
+**描述视觉元素和布局**（置信度 0.8+）：
+
+- "三个矩形连接起来"
+- "从左到右画出..."
+- "用箭头连接..."
+- "画个圆形，里面写..."
+- "上下结构的..."
+
+**描述系统/流程可视化需求**（置信度 0.75+）：
+
+- "用户登录的流程"
+- "微服务的架构"
+- "数据库的关系"
+- "API 调用的过程"
+- "系统的整体设计"
+
+### ❌ REJECT（非绘图请求）- 明确排除
+
+**知识问答**：
+
+- 什么是、如何、为什么、介绍、解释
+- "什么是微服务架构？"（询问定义）
+- "如何实现登录功能？"（询问方法）
+
+**代码编写**：
+
+- 写代码、写个函数、实现、debug
+- "帮我写一段 Python 代码"
+- "这段代码怎么优化？"
+
+**文本任务**：
+
+- 翻译、写文章、总结、改写
+- "帮我翻译这段话"
+- "写一篇关于...的文章"
+
+**问候寒暄**：
+
+- 你好、早上好、谢谢、再见
+- "你能做什么？"
+- "今天天气怎么样？"
+
+**计算分析**（不需要可视化）：
+
+- 纯数值计算、数据统计
+- "帮我算一下..."
+- "这个公式的结果是..."
+
+### 🤔 边界情况处理
+
+**情况 1：只提架构名称，未明确说画**
+
+```
+输入："微服务架构"
+判断：REJECT（置信度 0.3）
+原因：可能是想了解概念，而非绘图。需要用户明确
+```
+
+**情况 2：描述流程，但��"介绍"等词**
+
+```
+输入："介绍一下用户登录流程"
+判断：REJECT（置信度 0.4）
+原因：倾向于文字说明，而非绘图
+```
+
+**情况 3：同时包含问答和绘图意图**
+
+```
+输入："什么是微服务架构？帮我画一个"
+判断：DRAW（置信度 0.9）
+原因：虽然包含问答，但明确提到"画一个"
+```
+
+**情况 4：隐含的绘图需求**
+
+```
+输入："展示一下电商系统的整体架构"
+判断：DRAW（置信度 0.85）
+原因："展示"隐含可视化需求
+```
+
+## 判断流程
+
+```
+1. 检测明确的绘图动词？
+   ├─ 是 → DRAW (置信度 0.9+)
+   └─ 否 → 继续
+
+2. 包含图表类型词？
+   ├─ 是 → DRAW (置信度 0.85+)
+   └─ 否 → 继续
+
+3. 描述视觉元素或布局？
+   ├─ 是 → DRAW (置信度 0.8+)
+   └─ 否 → 继续
+
+4. 描述可视化需求（流程、架构、关系）？
+   ├─ 是 → DRAW (置信度 0.75+)
+   └─ 否 → 继续
+
+5. 属于明确排除类型？
+   ├─ 是 → REJECT (置信度 0.9+)
+   └─ 否 → REJECT (置信度 0.6) 【默认拒绝模糊输入】
+```
+
+## 示例标注
+
+### ✅ DRAW 示例
+
+```json
+// 输入："画一个用户登录流程图"
+{
+  "intent": "DRAW",
+  "reason": "包含明确的绘图动词'画'和图表类型词'流程图'",
+  "confidence": 0.95
+}
+```
+
+```json
+// 输入："设计微服务架构"
+{
+  "intent": "DRAW",
+  "reason": "包含绘图动词'设计'和可视化需求'架构'",
+  "confidence": 0.9
+}
+```
+
+```json
+// 输入："三个矩形连接起来"
+{
+  "intent": "DRAW",
+  "reason": "描述了具体的图形元素和连接关系",
+  "confidence": 0.85
+}
+```
+
+```json
+// 输入："展示一下电商系统的整体结构"
+{
+  "intent": "DRAW",
+  "reason": "'展示'隐含可视化需求，'结构'暗示图表",
+  "confidence": 0.8
+}
+```
+
+```json
+// 输入："用流程图说明用户注册的过程"
+{
+  "intent": "DRAW",
+  "reason": "明确提到'流程图'，需要可视化",
+  "confidence": 0.9
+}
+```
+
+### ❌ REJECT 示例
+
+```json
+// 输入："简单介绍一下上海市"
+{
+  "intent": "REJECT",
+  "reason": "这是知识问答请求，不是绘图需求",
+  "confidence": 0.95
+}
+```
+
+```json
+// 输入："什么是微服务架构？"
+{
+  "intent": "REJECT",
+  "reason": "这是概念询问，用户在询问定义而非要求绘图",
+  "confidence": 0.9
+}
+```
+
+```json
+// 输入："你好，今天天气怎么样"
+{
+  "intent": "REJECT",
+  "reason": "这是闲聊问候，与绘图无关",
+  "confidence": 0.95
+}
+```
+
+```json
+// 输入："帮我写一段 Python 代码"
+{
+  "intent": "REJECT",
+  "reason": "这是代码编写任务，不是绘图请求",
+  "confidence": 0.95
+}
+```
+
+```json
+// 输入："介绍一下 RESTful API 的设计原则"
+{
+  "intent": "REJECT",
+  "reason": "虽然提到'设计'，但是询问原则而非要求绘图",
+  "confidence": 0.85
+}
+```
+
+```json
+// 输入："微服务架构"
+{
+  "intent": "REJECT",
+  "reason": "只是提到名词，可能是想了解概念，意图不明确",
+  "confidence": 0.7
+}
+```
+
+## 特殊处理规则
+
+### 规则 1：当置信度 < 0.7 时
+
+如果判断为 REJECT 但置信度低于 0.7，说明输入模糊，应该：
+
+- 倾向于 REJECT（避免误判）
+- 在 reason 中说明"意图不明确，建议用户明确说明"
+
+### 规则 2：复合意图处理
+
+当输入同时包含多��意图时：
+
+- 如果明确包含绘图动词 → DRAW
+- 否则按主要意图判断
+
+### 规则 3：上下文无关
+
+每次判断独立进行，不考虑历史对话
+
+## 性能要求
+
+- 响应时间：< 500ms
+- 准确率目标：> 95%
+- 假阳性率（误判为 DRAW）：< 3%
+- 假阴性率（误拒绝 DRAW）：< 5%
+
+---
+
+## 用户输入
+
+{USER_INPUT}