refactor: retire legacy stack; remove milvus/tts/ocr; slim deps (166→39 files)

P4 retirement + code slim-down (~18.5k lines deleted), on top of the intent-gate WIP (docs §17/§18 + agent/tool refinements): - Delete old 8-scene multi-agent stack: XlyErpService, SceneSelector/ Chati/ErpAi/DynamicTableNl2Sql agents, DynamicToolProvider (62 meta tools), Scene/ToolMeta/ParamRule entities+mappers+startup caches - Delete whole milvus/tts/ocr packages, /api/tts + /api/ocr endpoints, tts.html, python stream_server.py; strip dead TTS JS from chat.html (playByIndex/handleNormalResponse had no callers) - Three-pass orphan sweep: 17 dead utils, 16 dead entities, dead constants/exceptions, RedisService+RedisConfig, duplicate JacksonConfig, OperableChatMemoryProvider, old prompt generators; fold PageController into MvcConfig; trim OkHttpUtil 495→39 lines - pom: ~35→13 deps (drop mybatis/JPA/webflux/tika/pdfbox/poi/jieba/ jsoup/gson/fastjson2/springdoc/mapstruct/pagehelper/pinyin4j/ spring-retry/jnr-ffi/hutool/ocr/milvus/embeddings; add starter-jdbc); war 200M+→48M - application.yml: drop milvus/tts/ocr/tesseract/mybatis blocks; GlobalExceptionHandler returns plain {code,message} JSON - docs: mark P4 retirement done in agent-architecture §13/§18 Verified: mvn clean package OK; boot smoke on :8199 (Started 0.9s, /chat 200, health db UP). Old /api/tts & /api/ocr now 404 by design.

refactor: retire legacy stack; remove milvus/tts/ocr; slim deps (166→39 files)
P4 retirement + code slim-down (~18.5k lines deleted), on top of the intent-gate WIP (docs §17/§18 + agent/tool refinements): - Delete old 8-scene multi-agent stack: XlyErpService, SceneSelector/ Chati/ErpAi/DynamicTableNl2Sql agents, DynamicToolProvider (62 meta tools), Scene/ToolMeta/ParamRule entities+mappers+startup caches - Delete whole milvus/tts/ocr packages, /api/tts + /api/ocr endpoints, tts.html, python stream_server.py; strip dead TTS JS from chat.html (playByIndex/handleNormalResponse had no callers) - Three-pass orphan sweep: 17 dead utils, 16 dead entities, dead constants/exceptions, RedisService+RedisConfig, duplicate JacksonConfig, OperableChatMemoryProvider, old prompt generators; fold PageController into MvcConfig; trim OkHttpUtil 495→39 lines - pom: ~35→13 deps (drop mybatis/JPA/webflux/tika/pdfbox/poi/jieba/ jsoup/gson/fastjson2/springdoc/mapstruct/pagehelper/pinyin4j/ spring-retry/jnr-ffi/hutool/ocr/milvus/embeddings; add starter-jdbc); war 200M+→48M - application.yml: drop milvus/tts/ocr/tesseract/mybatis blocks; GlobalExceptionHandler returns plain {code,message} JSON - docs: mark P4 retirement done in agent-architecture §13/§18 Verified: mvn clean package OK; boot smoke on :8199 (Started 0.9s, /chat 200, health db UP). Old /api/tts & /api/ocr now 404 by design.
zichun
1 parent 8b927e3b
Showing 151 changed files with 252 additions and 18459 deletions
docs/agent-architecture.md
docs/legacy-tool-inventory.md
pom.xml
sql/README.md
src/main/java/com/xly/XlyAiApplication.java
src/main/java/com/xly/agent/AgentSystemPrompt.java
src/main/java/com/xly/agent/ChatiAgent.java
src/main/java/com/xly/agent/DynamicTableNl2SqlAiAgent.java
src/main/java/com/xly/agent/ErpAiAgent.java
src/main/java/com/xly/agent/Intent.java
src/main/java/com/xly/agent/ReActAgent.java
src/main/java/com/xly/agent/SceneSelectorAiAgent.java
src/main/java/com/xly/agent/SystemPromptGenerator.java
src/main/java/com/xly/agent/ToolScope.java
src/main/java/com/xly/config/BizExecuteUtil.java
src/main/java/com/xly/config/JacksonConfig.java
src/main/java/com/xly/config/ModelConfig.java
src/main/java/com/xly/config/MvcConfig.java
src/main/java/com/xly/config/OperableChatMemoryProvider.java
src/main/java/com/xly/config/RedisConfig.java
@@ -2,6 +2,9 @@
 > 状态：设计已收敛（2026-07-21）。全 Java / LangChain4j，单 ReAct agent + 通用工具 + 人在环写入。
 > 关联：知识图谱底座见 `sql/README.md`；现状代码接线见 memory `xlyai-rag-milvus-wiring`。
+>
+> **阅读指引**：§1–§14 是**设计**（决策与取舍，基本稳定）；§15/§16 是**历史实现快照**（按日期，不再更新）；
+> **当前实现状态看 §17，未完成清单看 §18**。分支 `kg-edge-flow`（尚未合并 master）。
 ## 1. 背景与目标
@@ -17,10 +20,11 @@
 ```
 浏览器前端                         xlyAi (Java/LangChain4j :8099)              saas ERP 后端 xlyEntry(:8697)
-├ 聊天 UI(流式/diff确认/QA选项)  ⇄ ┌ 单 ReAct Agent (AiServices 工具循环)   ⇄  ├ 表单读写 API (getBusinessData…)
-└ ERP 原生表单(预填/执行确认)      │ ChatMemory(Redis) · SystemPrompt(L1)      ├ 暂存执行器 (新建, 排空 sp_ai_addcommonwx)
-                                  │ 5 通用工具 + Skill 注册表                 └ MySQL (业务库)
-                                  └ 直连: Ollama(qwen2.5)/Milvus/MySQL(KG+NL2SQL)
+├ 聊天 UI(流式/diff确认/QA选项)  ⇄ ┌ 意图门(受约束JSON) → 按意图收窄工具集    ⇄  ├ 表单读写 API (getBusinessData…)
+└ ERP 原生表单(预填/执行确认)      ├ 单 ReAct Agent (AiServices 工具循环)      ├ 暂存执行器 (/ai/execStaging)
+                                  │ ChatMemory(Redis) · SystemPrompt(L1)      └ MySQL (业务库)
+                                  │ 9 个工具(6 类) + Skill 注册表
+                                  └ 直连: Ollama(qwen3:14b)/MySQL(KG+NL2SQL)（Milvus 已随 2026-07-27 精简移除，向量召回未建）
 ```
 **数据流要点（重要）**
@@ -29,8 +33,10 @@
 ## 3. Agent 核心
-- **单 agent** = LangChain4j `AiServices` 原生 **tool-calling 循环**当 ReAct（不用老式文本 Thought/Action；qwen2.5 支持 function calling）。
+- **单 agent** = LangChain4j `AiServices` 原生 **tool-calling 循环**当 ReAct（不用老式文本 Thought/Action；qwen3:14b 支持 function calling）。
 - **退役** 8 场景 `SceneSelector` 路由 —— agent 自路由。
+  > 实现修正（2026-07-23，见 §17）：纯自路由在 qwen3:14b 上不可靠 → 前置一道**确定性意图门 + 按意图收窄工具集**。
+  > 这不是回退到场景路由（不再有人设/每表单工具），而是把「判类」从模型的 ReAct 里拿出来单独做。
 - **System prompt** = 角色 + **L1 业务域图（`viw_kg_domain`, 11 行）** + Skill 摘要列表 + 工具用法 + 安全约束。
 - **记忆** = `ChatMemory`（窗口化 + 超长摘要），持久化到 **Redis**（键：`chat:{userId}:{conversationId}`，带 TTL）。**多条命名会话/用户**：每用户一个会话列表，存储按 `conversationId` 分；按稳定身份（userId+品牌+子公司）寻址，**重登录/换 token 后接回历史**（token 不是会话 key）。
 - **循环护栏**：最大工具迭代步数、单轮墙钟超时、单轮 LLM 调用上限。
@@ -42,17 +48,26 @@
 - **续跑**：本轮结束后，会话置 `pendingInteraction`（如 `awaiting_answer:{id}` / `awaiting_confirm:{stagingRef}`）。用户的下一条输入按此状态被路由回「上一步的答复」，而非当作新请求。**没有这个 pending 状态机，多轮 HITL 会错乱** —— 这是手搓 HITL 的关键点。
 - **确认动作走确定性端点，不过 LLM**：diff 的「确认」按钮 → 直接打 xlyAi 一个 endpoint 落暂存 + 返回 ERP 链接。
+> ⚠️ **本节仍是设计，未按此实现**（截至 2026-07-23）。实际做法：新 agent **没有**用
+> `immediateReturnToolNames`（只有休眠的旧 `XlyErpService` 用），工具结果仍回喂 LLM；也**没有**
+> `pendingInteraction` 状态机——多轮靠 `ChatMemory` 自然接续 + 表单提交时前端在消息里塞
+> `proposeWrite(action=create)` 标记让控制器识别。卡片/控件由控制器在 `onToolExecuted` 里推 SSE。
+> 已知代价见 §18（LLM 看得见提议 JSON，可能谎称"已完成"，目前只靠 prompt 规则压制）。
+
 **前端事件协议（SSE）**：`token`（流式文本）/ `tool_call`（可选可视化）/ `question{text,options[]}` / `write_proposal{diff,stagingRef}` / `link{url}` / `error` / `done`。
-## 5. 工具规格（5 通用工具 + KG 预留）
+## 5. 工具规格（6 类通用工具）
 > 通用原则：入参/出参 JSON-schema、无状态、**auth 走 per-call context**（MCP 形状，便于日后暴露成 MCP）。输出**必须分页/截断**，绝不吐爆上下文。
+>
+> 下表是**能力分类**（6 类）；实现上落成 9 个 `@Tool` 方法（Read 拆 `readFormData`/`lookupRecord`，
+> KgSearch 拆 `findForms`/`kgSearch`，其余各 1 个）。清单见 §17。
 | # | 工具 | 职责 | 关键入参 | 出参 | 安全 | HITL |
 |---|------|------|----------|------|------|------|
 | 1 | **Read** | 调**任意 ERP 表单/过程**（明细 **+ 预建聚合** AR/AP/库存/进度，即旧 type-5），包 `getBusinessDataByFormcustomId` | formId, moduleId, **白名单过滤**, page | 行(截断)+分页游标 | 租户+行级；**表单权限靠 xlyAi 授权层**(§7)；参数白名单 | 否 |
 | 2 | **Query** | 只读 SQL 沙箱，**仅 ad-hoc 兜底**（没有现成表单/过程能答时才用） | 自然语言 → SQL | 聚合结果(小) | ⚠ 见 §9 | 否 |
-| 3 | **KgSearch** | L2 邻居 / L3 字段→列→表 / 解析 formId（**暂缓，预留接口**） | 表单名/术语/域 | 子图/映射 | 只读 | 否 |
+| 3 | **KgSearch** | L2 邻居 / L3 字段→列→表 / 解析 formId | 表单名/术语/域 | 子图/映射 | 只读 | 否 |
 | 4 | **AskUser** | 小问题（选项 + 自由输入），消歧/澄清 | question, options[] | — (immediate-return) | — | ✅ |
 | 5 | **FormCollect(表单呈现)** | 渲染一张表单收集 N 个参数（字段/类型/下拉来自 ERP 元数据），用户填 | formId（+ 已知预填） | 收集到的参数 | — | ✅ |
 | 6 | **ProposeWrite** | 出 diff → 确认 → 暂存（单一写工具） | formId, op, payload | diff + stagingRef | 见 §12 | ✅ |
@@ -113,7 +128,7 @@
 - **确认端点（确定性 HTTP, 非工具/非 LLM）**：用户点【确认】→ `POST /op/{sId}/confirm` → status=confirmed → **同步调 ERP `/ai/execStaging/{sId}`** → 拿结果 → 回链接给用户 + **结果写入会话状态（供链式续跑）**。取消 → `POST /op/{sId}/cancel`。
   - **结果怎么进对话（不过 LLM）**：对话框是**事件流**，不只是 LLM 文本。确认端点的 HTTP 响应 `{status, link, msg}` **由前端直接渲染成一张 op_result 卡片**（`✅ 已生成 [查看]`），无需 LLM 生成；同时该事件写进会话历史。ProposeWrite 的 diff、AskUser 选项、FormCollect 表单同理——工具返回结构化 payload，前端渲染卡片/控件。只有要 NL 收尾或**链式下一步**时才把结果喂进新的 LLM 轮次。
 - **ProposeWrite 写完 draft 即结束本轮**（immediate-return），agent 暂停 `pendingInteraction=awaiting_confirm:{sId}`，此刻 `ai_op_queue` 只有一条 `draft`、未执行；执行在"用户确认"独立事件里，链式则 resume 新一轮；久不确认按 `tExpireAt` 过期。
-- **execStaging 不进任何工具、不新增工具** —— 它必须在"用户确认之后"这个独立事件里触发，塞进 immediate-return 的 ProposeWrite 会变成"确认前就执行"。工具仍是 6 个。
+- **execStaging 不进任何工具、不新增工具** —— 它必须在"用户确认之后"这个独立事件里触发，塞进 immediate-return 的 ProposeWrite 会变成"确认前就执行"。工具仍是那 6 类。
 - 报价即使已用 FormCollect 填完表单，**落暂存前仍要一份对话内最终确认**（确认 = 允许存起来的门）。
 - 落暂存后是 **ERP 的事、与 agent 无关**：ERP 对不同待办的策略（报价自动执行 `Sp_Ai_AddQuoQuoAfter` / copyto 让用户在 ERP 原生表单再确认→执行器执行）都在暂存之后。
 - **ProposeWrite 泛化为"提议任意变更动作"**：ERP 按钮动作（审核/过账/生成 等**写按钮**）也走这道确认门；只读按钮（查询/导出）归 Read。⚠️ 绝不给 agent 一条绕过确认门直接触发 ERP 写动作的路（后端权限只管"能不能做"，不等于"这次同意做"）。是否需要独立的"按钮调用"底层能力，待后台调查（过程是否写、读 API 会否触发写、后端是否对表单/过程/动作调用鉴权）后定。
@@ -164,15 +179,17 @@ ai_op_queue(
 |---|---|
 | **复用** | `AiServices` 循环、`ChatMemory`/`OperableChatMemoryProvider`、`VectorizationService`、表单 API 客户端、NL2SQL 护栏 + `ai_global_agent_question_sql` 缓存 + `ai_sql_error_history` 纠错、`jsqlparser`、Milvus/embedding |
 | **退役** | 8 场景 `SceneSelector`、`DynamicToolProvider` per-form `ToolMeta` 工具、手写 `explainMilvusResult` RAG（并入工具） |
-| **新建** | 5 通用工具、取表单 schema 能力、Skill 注册表 + `load_skill`、Redis 会话持久化 + `pendingInteraction` 状态机、L1 prompt 注入、diff 确认端点、**ERP 侧暂存执行器 + 预填 + 深链 + 待办入口**、审计日志、Langfuse 接入 |
+| **新建** | 6 类通用工具、取表单 schema 能力、Skill 注册表 + `loadSkill`、Redis 会话持久化、L1 prompt 注入、diff 确认端点、**ERP 侧暂存执行器 + 预填 + 深链 + 待办入口**、审计日志、Langfuse 接入；**（设计外补充）意图门 + 按意图收窄工具集 + 确定性槽位填充**（见 §17） |
 ## 13. 迁移路线（strangler，不大爆炸）
 - **P0 KG 底座** ✅（`sql/` 7 视图，分支 `kg-edge-flow`）。
-- **P1 单 agent 骨架 + Read + Query（只读优先、安全先行）** —— 灰度一个只读场景，用现有 62 工具当**回归基线**。
-- **P2 AskUser(QA) + KgSearch + Skill 注册表**。
-- **P3 ProposeWrite + ERP 暂存执行器 + 预填/深链**（最重、跨团队，先排脚手架）。
-- **P4 退役旧多智能体/元数据工具；接 Langfuse；报价统一走确认制**。
+- **P1 单 agent 骨架 + Read + Query（只读优先、安全先行）** ✅ 代码完成（含表白名单 + 租户注入）。
+  ❌ **灰度未做**：没有选定灰度场景，也**没有拿旧 64 工具跑过回归基线对比**。
+- **P2 AskUser(QA) + KgSearch + Skill 注册表** ✅ 代码完成（`askUser` / `kgSearch` / `ai_skill` 3 条种子技能）。
+- **P3 ProposeWrite + ERP 暂存执行器 + 预填/深链** —— xlyAi 侧 ✅；ERP 侧执行器/预填/待办端点 ✅ 已写并编译，
+  但**默认关闭**（`erp.exec-staging.enabled=false`，本地走直连），**生产路径未联调**。
+- **P4 退役旧多智能体/元数据工具；接 Langfuse；报价统一走确认制** —— 退役 ✅（2026-07-27 精简：旧栈/milvus/tts/ocr 全删，见 §18.2）；Langfuse ✅（配置开关，默认关）；报价确认制待业务。
 ## 14. 已定 / 开放问题（见对话讨论）
@@ -197,7 +214,10 @@ ai_op_queue(
 7. 现网安全发现（后端表单权限被关 / NL2SQL 越权 / 读 API 可写）是否作为独立整改上报业务。
 8. 首个灰度只读场景选哪个（建议高频只读轻后果，如库存 / 应收账龄）。
-## 15. 实现状态（2026-07-21，分支 `kg-edge-flow`）
+## 15. 实现状态（2026-07-21，分支 `kg-edge-flow`）—— 历史快照，勿当现状读
+
+> 下面记的是**当天**的状态。工具已在 §16/§17 变过（4 个 `propose*` 已合并成单个
+> `proposeWrite(action=…)`）。当前清单见 §17。
 **已建成、可运行、已验证**（xlyAi 全新单 agent 前后端，`/xlyAi/api/agent/*`）：
 - **单 ReAct agent**：`AiServices` 流式工具循环（qwen3:14b `think(false)`），L1 域图进 system prompt，退役 8 场景路由（旧代码休眠未删）。
@@ -207,10 +227,13 @@ ai_op_queue(
 - **审计**：`ai_audit_log` 记 propose/confirm/cancel/query。
 - **ERP 接入**：`ErpClient` dev-login(admin/666666)拿真实会话 token；读 `getBusinessDataByFormcustomId`，写 `addUpdateDelBusinessData`（`column` 列表 + `handleType`）。
-## 16. 缺口补齐（2026-07-22，分支 `kg-edge-flow`）
+## 16. 缺口补齐（2026-07-22 上午，分支 `kg-edge-flow`）—— 历史快照，勿当现状读
 上一轮 §15 里「尚未做 / 被外部条件阻塞」的缺口，本轮全部补齐（含跨团队 ERP 侧）。均已编译通过（xlyAi mvn + ERP gradle）。
+> 后续变更见 §17：`proposeCreate/Delete/Examine` 已合并进 `proposeWrite(action=…)`；
+> `collectForm` 的字段来源已从 `gdsconfigformslave` 改为字段字典/精选映射（后者只作兜底）。
+
 **xlyAi 侧**
 - **授权 + token 透传（§7）**：新增 `AgentIdentity` + `AgentFactory` —— **按每次请求的身份新建 agent**，把透传的用户 ERP token 与「表单权限集」（`sAuthsId` → `AuthzService.grantedIds`）放进每请求的工具实例（规避 LC4j 流式工具在回调线程执行、ThreadLocal 不可靠的问题，即架构说的 per-call context）。前端逐请求带 `authorization`+身份；`ErpClient` 所有读写 **转发用户 token**；**用户 token 过期绝不用 dev(admin) 重登**（防静默提权）。dev-login 仅作本地兜底。
 - **写：新增 / 删除 / 审核**：`proposeCreate`（自动补主键/必填）、`proposeDelete`、`proposeExamine` 三个 HITL 工具，均只暂存 `ai_op_queue` draft、确认端点才执行；确认转发用户 token。`ai_op_queue` 加 `sPayload/sSourceRef/bAutoExecute/sResultBillId/sErrorMsg/tExecutedDate/tExpireAt`。
@@ -220,6 +243,8 @@ ai_op_queue(
 - **KgSearch（§5/§11）**：`kgSearch` 暴露 L2 邻居/流转（`viw_kg_form_neighbors`）+ L3 字段→表列（`viw_kg_field_dict`），按词查、截断。
 - **稳健 NL2SQL（§9）**：`QueryTool` 加**表白名单**（`viw_*` + 表单数据源 + 字段字典表，用 jsqlparser `TablesNamesFinder` 校验 → 挡住 `gdslogininfo`/`sysjurisdiction`/`ai_op_queue` 等敏感表）+ **单表租户谓词注入**（`sBrandsId`）+ prompt 品牌提示 + 自修复重试。
 - **Langfuse（§1）**：`TracingChatModelListener` 增加**配置开关的 ingestion 导出**（generation span，走 JDK HttpClient，不引依赖）；`docker-compose.langfuse.yml` 自托管；默认关闭。
+  > ⚠️ `docker-compose.langfuse.yml` 在**本机工作区存在但未入库**——被全局 gitignore 的 `**/docker-compose.*.yml` 规则挡掉了，
+  > 换机器/换人 clone 拿不到（见 §18）。
 **ERP 侧（saas-8s+ `release/customer/2025/saas-8s+`，backup 分支未动）**
 - **暂存执行器 + 预填 + 待办（§10）**：`AiStagingController @/ai` —— `execStaging/{sId}`（POST，执行）、`staging/{sId}`（GET，预填加载供原生表单深链）、`myTodos`（GET，AI待办）；全部 `@Authorization`+`@CurrentUser`。`AiStagingService(Impl)` 读共享库 `ai_op_queue` → 以**用户身份**走 ERP 自己的写入/审核逻辑（`addUpdateDelBusinessData` / `doExamine`，复用租户隔离、单号、审核存储过程）→ 幂等 + 回写状态/结果。xlyAi 确认端点按 `erp.exec-staging.enabled` 委托它（生产路径）或直连（本地默认）。
@@ -227,3 +252,85 @@ ai_op_queue(
 **仍属业务/运维决策（非代码缺口）**
 - 现网安全发现（后端逐用户表单权限被注释关 / 读 API 可被 `bUpdate` 触发写 / 旧 NL2SQL 越权）——`docs/security-findings.md` 已成文，**是否整改由业务定**。授权层真正“收紧到非管理员”只有在**生产以真实用户 token 运行**时才能观测（本地 dev-login=admin 全通）。
 - 报价改双确认、首个灰度只读场景选型 —— 业务确认项。
+
+## 17. 当前实现状态（2026-07-23，分支 `kg-edge-flow`，HEAD `8b927e3`）
+
+> 这是**唯一的现状节**。改代码后请更新这一节，不要再往 §15/§16 里加。
+
+### 17.1 工具清单（9 个 `@Tool`，对应 §5 的 6 类）
+
+| 类（§5） | `@Tool` 方法 | 实现类 | 单例 / 按请求 |
+|---|---|---|---|
+| Read | `readFormData` · `lookupRecord` | `ErpReadTool` | 按请求（带身份） |
+| Query | `queryData` | `QueryTool` | 按请求 |
+| KgSearch | `findForms` · `kgSearch` | `KgQueryTool` | 单例（全局元数据） |
+| AskUser | `askUser` | `InteractionTool` | 单例 |
+| FormCollect | `collectForm` | `FormCollectTool` | 按请求 |
+| ProposeWrite | `proposeWrite(action=create\|update\|invalid\|cancelInvalid\|examine\|cancelExamine\|delete)` | `ProposeWriteTool` | 按请求 |
+| （非工具） | `loadSkill` | `SkillTool` | 单例 |
+
+**§16 之后的变化**：4 个 `propose*` 工具**合并成单个 `proposeWrite(action=…)`**（贴合 §10「单一写工具」），
+并补上 `invalid/cancelInvalid`（业务单据的"删除"= 作废，可复原）与 `cancelExamine`（销审）。
+
+### 17.2 编排：意图门 + 按意图收窄工具集（§3 的实现修正）
+
+`AgentChatController.route()` 每轮：
+1. **意图门** `IntentService.classify()` —— 受约束 JSON（`OllamaJsonClient`），产出 `{意图, 单据类型, 带角色实体, missing}`；
+2. **确定性路由**：
+   - **新增** → 完全**不走 ReAct**：`resolveMasterForm` → `SlotFillService` 按真实字段做正则/角色槽位填充 → 直接弹 `collectForm`；
+   - **修改/删除/审核** → `extractWrite` 抽 `{record, field, newValue}`；齐了就**确定性直调** `proposeWrite`，缺了就问一次即停；
+   - **查询** → WRITE 之外的 READ-scope agent（5 个读工具）；
+   - **不清楚/意图门失败** → FULL-scope 兜底（全部 9 个工具）。
+3. `AgentFactory.build(identity, scope)` 按 `ToolScope` 组装工具 + 对应版本 system prompt；
+   `maxSequentialToolsInvocations(8)` 作循环护栏。
+
+**动机（实测）**：qwen3:14b Q4 在一次 ReAct 里同时判意图/选工具/编参数，会把"查询"当"新增"、
+把产品名（纸盒）塞进客户字段、反复追问同一问题。窄任务（意图分类、尺寸拆分）改用受约束 JSON + Java 正则后稳定。
+
+### 17.3 写入闭环（真实落库，已端到端验证）
+
+- **报价 = 跨表主-从建单**：`proposeQuote` 把 17 个精选字段路由到
+  `quoquotationmaster` + `quoquotationslave`（印刷/部件，`sParentId` 级联）+ `quoquotationmanyqtys`（多数量，一档一行），
+  外键名→id、按列类型强转、自动补主键/租户/制单人/单号（`BJD`+`YYYYMM`+序号），
+  以 `__tables__` 结构化 payload 存 `ai_op_queue`，确认端点走 `ErpClient.createMulti` 一次提交。
+  **核价（控制/材料/工序行）刻意留给 ERP**——那是引擎生成的。
+- **表单渲染带类型**：`collectForm` 字段带 `fkselect|select|number|date|text`；外键下拉由
+  `GET /api/agent/form/options?table=&q=` 从来源表实时取（只允许在字段字典里作为外键目标出现过的表，租户过滤 + LIMIT）。
+- **验证记录**（真实写入本地 saas 库）：`BJD202607082`（主表）、`BJD202607084`（主+从+多数量）、`BJD202607086`（含多数量 2000/4000/6000）。
+
+### 17.4 与设计的已知偏离
+
+| 设计 | 实际 | 影响 |
+|---|---|---|
+| §4 immediate-return 工具 | **未用**（新 agent 没设 `immediateReturnToolNames`） | 提议 JSON 会回喂 LLM，可能谎称"已完成"，目前只靠 prompt 规则压制 |
+| §4 `pendingInteraction` 状态机 | **未建**，靠 `ChatMemory` + 表单提交时消息里的 `proposeWrite(action=create)` 标记 | 多轮 HITL 无显式状态，跨轮续跑脆弱 |
+| §10 卡片三态 + auto 异步 + SSE 终态推送 | **恒同步**：确认即执行并同步返回终态 | 长事务会 HTTP 死等；无重连对账 |
+| §10 manual 预填深链 `/form/{formId}?staging={sId}` | ERP 侧端点已写，xlyAi 侧**不产生这类链接** | manual 流程未打通 |
+| §3 agent 完全自路由 | 前置确定性意图门 | 见 §17.2（有意为之） |
+
+## 18. 未完成清单（2026-07-23）
+
+**阻塞上线**
+1. **`kg-edge-flow` 未合并 `master`** —— §14 已定"写入 master"，但全部 6200 行新代码只在该分支；`master` 仍是改造前状态。
+2. ~~旧栈未退役且仍在跑~~ ✅ **已退役（2026-07-27 精简）**：删除 `XlyErpService`/8 场景路由/`DynamicToolProvider`/Scene·ToolMeta 缓存、整个 milvus/tts/ocr 包、`/api/tts` 与 `/api/ocr` 端点、tts.html 及 chat.html 死 JS；pom 依赖同步裁剪（milvus/embeddings/mybatis/ocr/webflux 等）。代码只剩新栈 ~40 个类。
+3. **零自动化测试**：无 `src/test`，每次都是手工跑对话验证；重构无回归网。
+4. **生产路径未联调**：`erp.exec-staging.enabled=false`；ERP 侧 `AiStagingController` 只编译过、没被真实调用过。
+5. **授权层未在非管理员下验证**：本地 dev-login=admin 全通，`AuthzService.grantedIds` 的收紧效果无法观测。
+
+**功能缺口**
+6. `pendingInteraction` 状态机 + immediate-return（§17.4）。
+7. 异步执行 / 卡片三态 / SSE 终态推送 / `GET /op/{sId}/status` 重连对账（§10）。
+8. manual 预填深链与「我的 AI 待办」在 xlyAi 侧的入口。
+9. `ai_op_queue` 的 `tExpireAt` 过期清理无调度任务；`bAutoExecute` 建了但没有分流逻辑。
+10. **报价核价结果不回读**——建完单不知道算出多少钱，用户得自己去 ERP 看。
+11. Skill 只有 3 条种子且未在真实对话里验证过；`loadSkill` 无使用数据。
+12. KgSearch 的**向量召回未接**（只有 SQL 关键词匹配）。2026-07-27 精简已把 milvus/embedding 代码与依赖整体删除——若做 5b 需按新栈重新接（milvus-sdk + embedding 依赖重加，旧实现在 git 历史 `8b927e3` 前可查）。
+13. 报价之外的单据**没有精选字段映射**，`businessFields` 走字段字典启发式，复杂单据大概率不准。
+
+**安全 / 运维**
+14. Query 的租户 AST 注入**只覆盖单表**，多表 JOIN 仅靠 prompt 提示；**只读 MySQL 账号未启用**（与应用共用连接池）。
+15. `docker-compose.langfuse.yml` **未入库**（被全局 gitignore `**/docker-compose.*.yml` 挡掉）；Langfuse 默认关闭、从未真正导出过 trace。
+16. 现网安全发现待业务决策（见 `docs/security-findings.md`）。
+
+**业务决策项**
+17. 首个灰度只读场景选型；报价是否改双确认；多语言（当前仅中文）。
 # 旧 64 AI 工具能力盘点（迁移覆盖基线）
-> 目的：现有 64 个元数据工具（`ai_tool`/`ai_tool_detail_params`）→ 迁到 5 个通用工具（Read/Query/KgSearch/AskUser/ProposeWrite）时，**不能丢**的业务语义清单。
+> 目的：现有 64 个元数据工具（`ai_tool`/`ai_tool_detail_params`）→ 迁到 6 类通用工具（Read/Query/KgSearch/AskUser/FormCollect/ProposeWrite）时，**不能丢**的业务语义清单。
 > 关键发现：**这 64 个不是"薄读"——其中 25 个是写操作，内含大量业务逻辑**（BtnCopyTo 单据流转引擎 + 报价定价引擎）。
+>
+> **迁移进度（2026-07-23）**：新工具已建齐（9 个 `@Tool`，见 `agent-architecture.md` §17.1），
+> 但**旧 64 个工具一个都还没退役**——`AppStartupRunner` 仍在启动时加载它们，旧对话端点仍对外。
+> 本文的覆盖映射尚未做过逐条回归验证。
 ## 执行机制（证据）
 - `AppStartupRunner.initCache()` 载入 → `DynamicToolProvider.init()` 每行建一个 `ToolSpecification`+`ToolExecutor`（按 `sSceneId` 分桶）。
@@ -21,20 +21,9 @@
 	<properties>
 		<java.version>17</java.version>
-		<mybatis-spring.version>3.0.4</mybatis-spring.version>
-		<pagehelper.version>2.1.0</pagehelper.version>
-		<mapstruct.version>1.5.5.Final</mapstruct.version>
-		<fastjson.version>2.0.50</fastjson.version>
 		<langchain4j.version>1.14.0</langchain4j.version>
-		<langchain4j-emb.version>1.14.0-beta24</langchain4j-emb.version>
 		<lombok.version>1.18.34</lombok.version>
-		<hutool.version>5.8.28</hutool.version>
 		<okhttp.version>4.10.0</okhttp.version>
-		<springdoc.version>2.5.0</springdoc.version>
-		<jackson.version>2.17.2</jackson.version>
-		<milvus.version>2.6.15</milvus.version>
-		<tess4j.version>5.18.0</tess4j.version>
-		<jakarta-validation.version>3.1.0</jakarta-validation.version>
 	</properties>
 	<dependencies>
@@ -53,10 +42,6 @@
 		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-aop</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-thymeleaf</artifactId>
 		</dependency>
 		<dependency>
@@ -69,7 +54,7 @@
 		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-webflux</artifactId>
+			<artifactId>spring-boot-starter-jdbc</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
@@ -82,12 +67,7 @@
 			<optional>true</optional>
 		</dependency>
-		<!-- 数据库 & MyBatis -->
-		<dependency>
-			<groupId>org.mybatis.spring.boot</groupId>
-			<artifactId>mybatis-spring-boot-starter</artifactId>
-			<version>${mybatis-spring.version}</version>
-		</dependency>
+		<!-- 数据库 -->
 		<dependency>
 			<groupId>com.mysql</groupId>
 			<artifactId>mysql-connector-j</artifactId>
@@ -97,17 +77,6 @@
 			<groupId>com.zaxxer</groupId>
 			<artifactId>HikariCP</artifactId>
 		</dependency>
-		<dependency>
-			<groupId>com.github.pagehelper</groupId>
-			<artifactId>pagehelper-spring-boot-starter</artifactId>
-			<version>${pagehelper.version}</version>
-		</dependency>
-		<!-- 方案A：使用 pinyin4j（推荐） -->
-		<dependency>
-			<groupId>com.belerweb</groupId>
-			<artifactId>pinyin4j</artifactId>
-			<version>2.5.1</version>
-		</dependency>
 		<!-- 工具类 -->
 		<dependency>
@@ -116,93 +85,11 @@
 			<optional>true</optional>
 		</dependency>
 		<dependency>
-			<groupId>cn.hutool</groupId>
-			<artifactId>hutool-all</artifactId>
-			<version>${hutool.version}</version>
-		</dependency>
-		<dependency>
-			<groupId>com.google.code.gson</groupId>
-			<artifactId>gson</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>commons-io</groupId>
-			<artifactId>commons-io</artifactId>
-			<version>2.15.1</version>
-		</dependency>
-		<dependency>
 			<groupId>com.squareup.okhttp3</groupId>
 			<artifactId>okhttp</artifactId>
 			<version>${okhttp.version}</version>
 		</dependency>
-		<!-- JSON -->
-		<dependency>
-			<groupId>com.alibaba.fastjson2</groupId>
-			<artifactId>fastjson2</artifactId>
-			<version>${fastjson.version}</version>
-		</dependency>
-		<dependency>
-			<groupId>com.fasterxml.jackson.core</groupId>
-			<artifactId>jackson-databind</artifactId>
-			<version>${jackson.version}</version>
-		</dependency>
-		<dependency>
-			<groupId>com.fasterxml.jackson.core</groupId>
-			<artifactId>jackson-core</artifactId>
-			<version>${jackson.version}</version>
-		</dependency>
-		<dependency>
-			<groupId>com.fasterxml.jackson.core</groupId>
-			<artifactId>jackson-annotations</artifactId>
-			<version>${jackson.version}</version>
-		</dependency>
-		<dependency>
-			<groupId>com.fasterxml.jackson.datatype</groupId>
-			<artifactId>jackson-datatype-jsr310</artifactId>
-			<version>${jackson.version}</version>
-		</dependency>
-
-		<!-- 文档处理 -->
-		<dependency>
-			<groupId>org.apache.tika</groupId>
-			<artifactId>tika-core</artifactId>
-			<version>2.9.1</version>
-		</dependency>
-		<dependency>
-			<groupId>org.apache.pdfbox</groupId>
-			<artifactId>pdfbox</artifactId>
-			<version>3.0.2</version>
-		</dependency>
-		<dependency>
-			<groupId>org.apache.poi</groupId>
-			<artifactId>poi-ooxml</artifactId>
-			<version>5.2.5</version>
-		</dependency>
-
-		<!-- OCR -->
-		<dependency>
-			<groupId>net.sourceforge.tess4j</groupId>
-			<artifactId>tess4j</artifactId>
-			<version>${tess4j.version}</version>
-		</dependency>
-		<dependency>
-			<groupId>io.github.mymonstercat</groupId>
-			<artifactId>rapidocr</artifactId>
-			<version>0.0.7</version>
-		</dependency>
-		<dependency>
-			<groupId>io.github.mymonstercat</groupId>
-			<artifactId>rapidocr-onnx-platform</artifactId>
-			<version>0.0.7</version>
-		</dependency>
-
-		<!-- 向量数据库 -->
-		<dependency>
-			<groupId>io.milvus</groupId>
-			<artifactId>milvus-sdk-java</artifactId>
-			<version>${milvus.version}</version>
-		</dependency>
-
 		<!-- LangChain4j 核心 + Ollama -->
 		<dependency>
 			<groupId>dev.langchain4j</groupId>
@@ -214,98 +101,13 @@
 			<artifactId>langchain4j-ollama</artifactId>
 			<version>${langchain4j.version}</version>
 		</dependency>
-		<dependency>
-			<groupId>dev.langchain4j</groupId>
-			<artifactId>langchain4j-embeddings-all-minilm-l6-v2</artifactId>
-			<version>${langchain4j-emb.version}</version>
-		</dependency>
-
-		<!-- 分词 -->
-		<dependency>
-			<groupId>com.huaban</groupId>
-			<artifactId>jieba-analysis</artifactId>
-			<version>1.0.2</version>
-		</dependency>
-
-		<!-- 接口文档 -->
-		<dependency>
-			<groupId>org.springdoc</groupId>
-			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
-			<version>${springdoc.version}</version>
-		</dependency>
-
-		<!-- MapStruct -->
-		<dependency>
-			<groupId>org.mapstruct</groupId>
-			<artifactId>mapstruct</artifactId>
-			<version>${mapstruct.version}</version>
-		</dependency>
-		<!-- 其他工具 -->
+		<!-- SQL 解析（QueryTool 只读沙箱护栏） -->
 		<dependency>
 			<groupId>com.github.jsqlparser</groupId>
 			<artifactId>jsqlparser</artifactId>
 			<version>4.9</version>
 		</dependency>
-		<dependency>
-			<groupId>org.jsoup</groupId>
-			<artifactId>jsoup</artifactId>
-			<version>1.17.2</version>
-		</dependency>
-
-		<!-- 删掉这两个错误的 -->
-		<dependency>
-			<groupId>org.codehaus.groovy</groupId>
-			<artifactId>groovy</artifactId>
-			<version>3.0.20</version>
-		</dependency>
-		<dependency>
-			<groupId>org.codehaus.groovy</groupId>
-			<artifactId>groovy-all</artifactId>
-			<version>3.0.20</version>
-			<type>pom</type>
-		</dependency>
-
-		<!-- 正确的 Fastjson2 -->
-		<dependency>
-			<groupId>com.alibaba.fastjson2</groupId>
-			<artifactId>fastjson2</artifactId>
-			<version>2.0.50</version>
-		</dependency>
-
-		<!-- Spring Data JPA 核心依赖（自动包含 jakarta.persistence 包） -->
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-data-jpa</artifactId>
-		</dependency>
-
-		<!-- 数据库驱动（以 MySQL 为例，根据你的数据库替换） -->
-		<dependency>
-			<groupId>com.mysql</groupId>
-			<artifactId>mysql-connector-j</artifactId>
-			<scope>runtime</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>com.github.jnr</groupId>
-			<artifactId>jnr-ffi</artifactId>
-			<version>2.2.15</version> <!-- 稳定版 -->
-		</dependency>
-		<dependency>
-			<groupId>jakarta.annotation</groupId>
-			<artifactId>jakarta.annotation-api</artifactId>
-			<version>2.1.1</version>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.retry</groupId>
-			<artifactId>spring-retry</artifactId>
-		</dependency>
-
-		<!-- 必须加：Spring Retry 需要 AOP 依赖 -->
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-aop</artifactId>
-		</dependency>
 	</dependencies>
 	<build>
@@ -335,11 +137,6 @@
 							<artifactId>lombok</artifactId>
 							<version>${lombok.version}</version>
 						</path>
-						<path>
-							<groupId>org.mapstruct</groupId>
-							<artifactId>mapstruct-processor</artifactId>
-							<version>${mapstruct.version}</version>
-						</path>
 					</annotationProcessorPaths>
 				</configuration>
 			</plugin>
@@ -349,4 +146,4 @@
 			</plugin>
 		</plugins>
 	</build>
-</project>
 \ No newline at end of file
+</project>
@@ -64,6 +64,12 @@ done
 3. 术语接地：用 `viw_kg_field_dict` 把问题里的中文词映射到真实列 + join 目标，喂给 NL2SQL。
 4. 取数：命中表单后统一走 `POST /business/getBusinessDataByFormcustomId/{sFormId}?sModelsId={sModuleId}`。
+> **落地现状（2026-07-23）**：agent 侧只用到 L1（进 system prompt）与 L2/L3 的 **SQL 关键词查询**
+> （`KgQueryTool.findForms` / `kgSearch`、`FormResolverService`）。**第 1 步的向量召回尚未接入**
+> ——`export_form_cards.sh` 的产物没有灌进 Milvus，上面写的是目标用法而非现状。
+
 ## 校验基线
-以 `ai_tool`（62 张 form-backed 工具，`sSrcFormId`=菜单id）为 ground truth 校验召回。
+以 `ai_tool` 为 ground truth 校验召回：**共 64 个工具，63 个带 `sSrcFormId`（=菜单id）**
+（唯一没有的是「工单成本查询」，配置本身就是坏的）。按业务表单口径为 61 张——
+另 2 个挂在通用 KPI 模块上。逐条能力盘点见 `../docs/legacy-tool-inventory.md`。
 package com.xly;
-import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.core.util.StrUtil;
-import org.mybatis.spring.annotation.MapperScan;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.builder.SpringApplicationBuilder;
 import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
-import org.springframework.cache.annotation.EnableCaching;
-import org.springframework.scheduling.annotation.EnableAsync;
-import org.springframework.scheduling.annotation.EnableScheduling;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import java.util.HashMap;
-import java.util.Map;
-
-@EnableAsync
-@EnableScheduling
-@EnableCaching
 @SpringBootApplication
-@MapperScan("com.xly.mapper")
-public class XlyAiApplication extends SpringBootServletInitializer {  // 关键：继承 SpringBootServletInitializer
+public class XlyAiApplication extends SpringBootServletInitializer {
     private static final Logger logger = LoggerFactory.getLogger(XlyAiApplication.class);
-    @Override  // 关键：重写 configure 方法
+    // war 部署入口（外置 servlet 容器）
+    @Override
     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
         return application.sources(XlyAiApplication.class);
     }
-    /**
-     * 提取报修结构化信息
-     */
-    @PostMapping("/")
-    public String home(@RequestBody Map<String,Object> sendMap) {
-       return "欢迎来到小羚羊AI系统";
-    }
-
     public static void main(String[] args) {
         SpringApplication.run(XlyAiApplication.class, args);
-        logger.info("                                              \n" +
-                "                                   /$$          \n" +
-                "                                  | $$          \n" +
-                " /$$  /$$  /$$ /$$   /$$  /$$$$$$$| $$  /$$$$$$$\n" +
-                "| $$ | $$ | $$| $$  | $$ /$$_____/| $$ /$$_____/\n" +
-                "| $$ | $$ | $$| $$  | $$| $$      | $$|  $$$$$$ \n" +
-                "| $$ | $$ | $$| $$  | $$| $$      | $$ \\____  $$\n" +
-                "|  $$$$$/$$$$/|  $$$$$$$|  $$$$$$$| $$ /$$$$$$$/\n" +
-                " \\_____/\\___/  \\____  $$ \\_______/|__/|_______/ \n" +
-                "               /$$  | $$                        \n" +
-                "              |  $$$$$$/                        \n" +
-                "               \\______/   ");
-        logger.info("I wish you a pleasant use of the system and never have any bugs");
+        logger.info("xlyAi 启动完成");
     }
-}
 \ No newline at end of file
+}
-package com.xly.agent;
-
-public class AgentSystemPrompt {
-
-//        public static final String sSystemPrompt = "你是一个专业的智能助手，请根据以下规则精准匹配并调用工具：\n" +
-//                "【核心决策逻辑】\n" +
-//                "1. 单一工具绝对调用：当系统仅提供一个可用工具时，必须无条件调用该工具。即使参数不全，也必须发起调用，严禁返回向用户索要信息或者不调用工具；\n" +
-//                "2. 多工具意图匹配：当系统提供多个工具时，必须先精准识别用户的核心业务意图，然后匹配唯一对应的工具进行调用；\n" +
-//                "\n" +
-//                "【参数提取与调用规范】\n" +
-//                "3. 触发条件：匹配工具时，仅关注工具描述中“当用户”和“时，必须调用本工具”之间的语义关联；\n" +
-//                "4. 参数补全与缺省处理：\n" +
-//                "   - 如果当前是全新的独立请求，且必填参数缺失，请直接省略该字段发起调用（不要反问用户）。\n" +
-//                "5. 格式要求：提取参数时严格按标注类型赋值，数字不带引号，字符串需去除首尾空格；\n" +
-//                "6. 绝对禁止：在任何情况下，禁止向用户反问以确认参数或意图，你的输出只能是最终回复或合法的工具调用请求。";
-
-        public static final String sSystemPrompt = "你是一个无情的参数提取器，不是聊天助手。\n" +
-                "【绝对指令】\n" +
-                "1. 你的唯一任务是提取用户输入中的参数，并立即调用工具。\n" +
-                "2. 严禁与用户进行任何对话！严禁输出“您好”、“请提供”、“需要补充”等任何纯文本回复！\n" +
-                "3. 无论用户输入多么简短（例如只输入了公司名），或者参数缺失多么严重，你都必须直接调用工具，将缺失的字段留空或填0。\n" +
-                "4. 不要试图去引导用户，引导用户是你的后端程序要做的事，你只需要负责把提取到的参数传出去。";
-}
 \ No newline at end of file
-package com.xly.agent;
-
-import dev.langchain4j.service.MemoryId;
-import dev.langchain4j.service.SystemMessage;
-import dev.langchain4j.service.UserMessage;
-import dev.langchain4j.service.V;
-import reactor.core.publisher.Flux;
-
-public interface ChatiAgent {
-    @SystemMessage("""
-      你是一个轻松自然的聊天伙伴，语气亲切口语化，像朋友一样闲聊。
-      要求：1. 不生硬、不说教，避免书面化表达；
-           2. 主动接梗，适当延伸话题，不一问一答；
-           3. 偶尔带点小幽默，保持轻松无压力的氛围；
-           4. 回答简洁，符合日常聊天的语气，不啰嗦。
-           5. 首次沟通时发现称呼不是“小羚羊”时，请回复“我不是..,我是小羚羊”，语气俏皮。
-    """)
-    @UserMessage("用户说：{{userInput}}")
-    String chat(@MemoryId String userId, @V("userInput") String userInput);
-
-    @SystemMessage("""
-      你是一个轻松自然的聊天伙伴，语气亲切口语化，像朋友一样闲聊。
-      要求：1. 不生硬、不说教，避免书面化表达；
-           2. 主动接梗，适当延伸话题，不一问一答；
-           3. 偶尔带点小幽默，保持轻松无压力的氛围；
-           4. 回答简洁，符合日常聊天的语气，不啰嗦。
-           5. 首次沟通时发现称呼不是“小羚羊”时，请回复“我不是..,我是小羚羊”，语气俏皮。
-    """)
-    @UserMessage("用户说：{{userInput}}")
-    Flux<String> chatStream(@MemoryId String userId, @V("userInput") String userInput);
-}
-package com.xly.agent;
-
-import dev.langchain4j.service.MemoryId;
-import dev.langchain4j.service.SystemMessage;
-import dev.langchain4j.service.UserMessage;
-import dev.langchain4j.service.V;
-
-/**
- * 适配动态表结构的NL2SQL AI服务
- * 核心：表结构作为动态参数传入，@SystemMessage仅保留通用规则
- */
-
-
-public interface DynamicTableNl2SqlAiAgent {
-
-    /**
-     * 动态表结构：自然语言转MySQL SELECT语句
-     * 入参：数据库名、表名(多表用,分隔)、表结构、用户查询
-     */
-    @SystemMessage("""
-            你是资深MySQL数据分析师，严格遵循以下**通用规则**生成SQL，适用于所有业务场景：
-            1. 语法规范：仅生成符合MySQL8.0.36的标准SELECT语句，兼容低版本，多表关联用JOIN而非逗号；
-            2. 输出格式：仅返回SQL语句本身，无任何解释、换行、```sql/```包裹、备注、多余空格，直接输出可执行SQL；
-            3. 编写规范：
-                3.1 多表关联必须使用 表名+字段名（如表名.字段名），严格按下面[涉及表名]中的表次序关联，聚合函数(SUM/COUNT/AVG/MIN/MAX)必须加业务化别名，日期过滤使用标准DATE格式（yyyy-MM-dd）；
-                3.2 SQL所有字段均采用 表名.字段名 方式生成，务必确保 字段名 在相应的 表名 描述的字段中存在，如果不存在重试其它方式，直到满足条件；
-                3.3 SQL所有字段涉及的所有表名，都要**严格**按下面[涉及表名]中的表次序关联，没有关联不允许使用；
-                3.4 SQL所有的查询条件，如果是字符类型的字段,均需要加不为空判断，用示例格式判断，示例:ifnull(customername,'')<>''； 
-                3.5 SQL所有的查询条件，如果是布尔类型的字段 判断值只能是1或者0,1表示：true,0表示：false,例如:viw_ai_quotation.bCheck = 1； 
-                3.6 SQL所有的查询条件，如果是日期类型的字段,均需要加不为空判断，用示例格式判断，示例:tmakedate is not Null；
-                3.7 SQL所有的显示字段的别名中,不能出现空格，如: tCreateDate as earliest 订单日期,正确的应是 tCreateDate as earliest订单日期
-                3.8 在AVG聚合函数中不允许使用LAG、LEAD 等窗口函数 例如：AVG(LAG(...))这种嵌套是不允许的
-                3.9 GROUP BY 后面不允许使用窗口函数
-            4. 安全约束：
-               - 禁止：DDL/DML语句（DROP/ALTER/INSERT/UPDATE/DELETE等）
-               - 禁止：存储过程、自定义函数、临时表
-               - 允许：子查询（当需要使用窗口函数LAG/ROW_NUMBER等时）
-               - 允许：CTE公用表表达式（WITH语句）
-            5. 精准性：
-                5.1 严格按用户需求+传入的表结构生成，仅使用指定字段/表，无多余字段、无无效表关联、无冗余过滤条件；
-                5.2 用户需求中没有明确的日期条件,默认为全部数据,禁止增加任何日期过滤条件
-            6. 关联规则：多表关联时，必须使用外键/业务唯一键关联，禁止无意义关联。
-            7. 当前时间：{{sDataNow}}
-            8. 时间处理规则：
-               8.1 当前系统时间：{{sDataNow}}（格式：yyyy年MM月dd日HH时mm分ss秒）
-               8.2 用户需求中的相对时间概念，必须基于{{sDataNow}}进行转换：
-                   - "本年" → 当前年份：{{sDataNow}}的年份
-                   - "本月" → 当前月份：{{sDataNow}}的年份和月份
-                   - "本季度" → 当前季度：基于{{sDataNow}}计算
-                   - "本日/今天" → {{sDataNow}}的具体日期
-                   - "昨天" → {{sDataNow}}减1天
-                   - "本周" → 基于{{sDataNow}}计算周一到周日
-                   - "近7天" → {{sDataNow}}减7天到{{sDataNow}}
-               8.3 示例转换：
-                   当前时间：2024-03-15
-                   用户说"查询本年数据" → 查询条件应为：YEAR(日期字段) = 2024
-                   用户说"查询本月数据" → 查询条件应为：YEAR(日期字段) = 2024 AND MONTH(日期字段) = 3
-               8.4 如果用户需求中没有明确的时间条件，禁止增加任何时间过滤条件     
-            """)
-    @UserMessage("""
-            【业务场景表结构信息】
-            涉及表名：{{tableNames}}（多表用,分隔，需关联时请按规范使用JOIN）
-            表结构详情：{{tableStruct}}（多表请标注表名+字段，格式：表名(字段1:类型,字段2:类型,主键/外键)）
-            当前时间：{{sDataNow}}
-            【用户需求】
-            {{userInput}}
-            请根据上述表结构+通用规则，生成符合要求的MySQL SELECT语句;
-            【时间处理要求】
-                    1. 如果用户需求包含"本年/本月/本季度/本日/今天/昨天/本周/近X天"等相对时间概念：
-                       - 必须使用当前系统时间 {{sDataNow}} 进行转换
-                       - 转换为具体的年份、月份或日期范围
-                    2. 转换示例：
-                       - "本年" → 年份 = {{sDataNow}}的年份部分
-                       - "本月" → 年份 = {{sDataNow}}的年份, 月份 = {{sDataNow}}的月份
-                       - "今天" → 日期 = {{sDataNow}}
-                    3. 如果没有明确的时间需求，不要添加任何时间过滤条件
-            """)
-    String generateMysqlSql(@MemoryId String userId,
-                            @V("tableNames") String tableNames,
-                            @V("tableStruct") String tableStruct,
-                            @V("sDataNow") String sDataNow,
-                            @V("userInput") String userInput);
-
-
-    /**
-     * 动态表结构：自然语言转MySQL SELECT语句
-     * 入参：数据库名、表名(多表用,分隔)、表结构、用户查询
-     */
-    @SystemMessage("""
-        【系统角色】
-        你是资深MySQL 8.0.36数据分析师，严格杜绝以下错误，生成100%可执行的SELECT语句；
-        【严格禁止的错误类型（强制遵守）】
-        1. 语法错误：
-           - 禁止使用COUNT()无参数写法，必须写COUNT(*)、COUNT(1)或COUNT(具体非空字段)；
-           - 禁止在AVG/SUM等聚合函数内嵌套LAG/ROW_NUMBER等窗口函数(如 AVG(dMaterialsPrice - LAG(dMaterialsPrice, 1, dMaterialsPrice))/SUM(viw_ai_purchaseorder.dMaterialsPrice - LAG(viw_ai_purchaseorder.dMaterialsPrice, 1)))；
-           - 禁止ORDER BY中直接使用未别名的窗口函数表达式（如ORDER BY dMaterialsPrice - LAG(...)）；
-           - 禁止GROUP BY字段与SELECT非聚合字段不一致；
-        2. 规则违规：
-           - 禁止字段不写表名前缀（必须是「表名.字段名」格式）；
-           - 禁止日期字段非空判断用ifnull(日期字段,'')<>''（仅字符字段用此写法，日期字段用IS NOT NULL）；
-           - 禁止生成与{{errorSql}}/{{historySqlList}}重复的语句，禁止仅修改排序字段/别名的“伪差异化”,可以使用子查询修复或者修改查询字段，不要使用窗口函数（如 LAG）；
-           - 禁止LAG窗口函数缺失ORDER BY子句（必须按时间字段排序）；
-           - 禁止HAVING条件使用COUNT()无参数写法，禁止过滤条件与业务需求无关；
-           - 禁止在 AVG/SUM 等聚合函数中嵌套窗口函数；
-        3. 编写规范：
-            - 多表关联必须使用 表名+字段名（如表名.字段名），严格按下面[涉及表名]中的表次序关联，聚合函数(SUM/COUNT/AVG/MIN/MAX)必须加业务化别名，日期过滤使用标准DATE格式（yyyy-MM-dd）；
-            - SQL所有字段均采用 表名.字段名 方式生成，务必确保 字段名 在相应的 表名 描述的字段中存在，如果不存在重试其它方式，直到满足条件；
-            - SQL所有字段涉及的所有表名，都要**严格**按下面[涉及表名]中的表次序关联，没有关联不允许使用；
-            - SQL所有的查询条件，如果是字符类型的字段,均需要加不为空判断，用示例格式判断，示例:ifnull(customername,'')<>''； 
-            - SQL所有的查询条件，如果是日期类型的字段,均需要加不为空判断，用示例格式判断，示例:tmakedate is not Null；
-            - SQL所有的显示字段的别名中,不能出现空格，如: tCreateDate as earliest 订单日期,正确的应是 tCreateDate as earliest订单日期
-            - 在AVG聚合函数中不允许使用LAG、LEAD 等窗口函数
-            - AVG(LAG(...))这种嵌套是不允许的
-            - GROUP BY 后面不允许使用窗口函数
-        【生成前自检要求】
-        1. 先检查是否违反上述禁止规则，再生成SQL；
-        2. 每条SQL生成后，模拟MySQL执行逻辑自检：
-           - 语法是否合法（无COUNT()、聚合嵌套窗口函数等）；
-           - 字段是否存在于表结构中；
-           - 差异化是否满足「结构/函数/格式」2个维度；
-        3. 若自检发现错误，立即重新生成，直至所有SQL符合要求。      
-       """)
-    @UserMessage("""
-        【业务场景表结构信息】
-        涉及表名：{{tableNames}}
-        表结构详情：{{tableStruct}}
-        当前时间：{{sDataNow}}
-        【原始用户需求】
-        {{userInput}}
-        【错误信息】
-        之前生成的错误SQL：{{errorSql}}
-        执行错误信息：{{errorMessage}}
-        【生成要求】
-        1. 先修复错误SQL的所有问题，确保语法/逻辑合规；
-        2. 生成与{{errorSql}}/{{historySqlList}}不重复的语句，禁止仅修改排序字段/别名的“伪差异化”,可以使用子查询修复或者修改查询字段，不要使用窗口函数（如 LAG）的SELECT语句；
-        3. SQL所有字段均采用 表名.字段名 方式生成，务必确保 字段名 在相应的 表名 描述的字段中存在，如果不存在重试其它方式，直到满足条件； 
-        4. 自连接+子查询方式时，子查询跟自连接关联关系字段需要在子查询中查询列出现
-        5. 生成语法 / 逻辑合规且与历史语句无 “伪差异化” 的 SELECT 语句，且不使用窗口函数。
-        请根据上述表结构+通用规则，生成符合要求的MySQL SELECT语句;并且仅返回SQL语句
-        """)
-    String regenerateSqlWithError(@MemoryId String userId,
-            @V("tableNames") String tableNames,
-            @V("tableStruct") String tableStruct,
-            @V("sDataNow") String sDataNow,
-            @V("userInput") String userInput,
-            @V("errorSql") String errorSql,
-            @V("errorMessage") String errorMessage,
-            @V("n") String iErroCount,
-            @V("historySqlList") String historySqlList
-    );
-//    /**
-//     * 动态表结构：自然语言解释SQL执行结果
-//     * 入参：用户问题、执行的SQL、表结构、JSON格式结果
-//     */
-//    @SystemMessage("""
-//            你是专业的业务数据分析师，严格遵循以下**通用规则**解释查询结果，适用于所有业务场景：
-//            1. 解释风格：贴合业务场景，无任何SQL专业术语，用口语化、简洁的商业语言说明，避免技术词汇；
-//            2. 数据准确：严格按照JSON执行结果解释，不夸大、不遗漏、不编造数据，数值与结果完全一致；
-//            3. 输出格式：仅返回解释内容，不要列出ID,无多余标题、换行、符号，结果为空时直接返回“未查询到相关数据”；
-//            4. 长度控制：单条解释不超过150字，条理清晰，重点突出核心数据/趋势；
-//            5. 禁止重复：不重复用户问题、不重复执行的SQL语句，仅针对结果做业务解读。
-//            """)
-//    @UserMessage("""
-//            【业务场景表结构信息】
-//            表结构详情：{{tableStruct}}
-//            【查询相关信息】
-//            用户原始查询：{{userInput}}
-//            执行的MySQL SQL：{{sql}}
-//            SQL执行结果（JSON格式）：{{result}}
-//            请根据上述信息+通用规则，对查询结果做业务解释：
-//            """)
-//    String explainSqlResult(@MemoryId String userId,
-//                            @V("userInput") String userInput,
-//                            @V("sql") String sql,
-//                            @V("tableStruct") String tableStruct,
-//                            @V("result") String result);
-}
 \ No newline at end of file
-package com.xly.agent;
-
-
-import dev.langchain4j.service.*;
-
-/**
- * 优化后：新增场景专属交互规则，大模型仅处理当前场景业务指令
- */
-public interface ErpAiAgent {
-
-    @SystemMessage("{{sSystemPrompt}}")
-    @UserMessage("用户输入：{{userInput}}")
-    Result<String> chat(
-            @MemoryId String userId,
-            @V("userInput") String userInput,
-            @V("sSystemPrompt") String sSystemPrompt
-    );
-    /**
-     * 动态表结构：自然语言解释SQL执行结果
-     * 入参：用户问题、执行的SQL、表结构、JSON格式结果
-     */
-    @SystemMessage("""
-            你是专业的业务数据分析师，严格遵循以下**通用规则**解释查询结果，适用于所有业务场景：
-                1. 解释风格：贴合业务场景，无任何SQL专业术语，用口语化、简洁的商业语言说明，避免技术词汇；
-                2. 数据准确：严格按照JSON执行结果解释，不夸大、不遗漏、不编造数据，数值与结果完全一致；
-                3. 输出格式：仅返回解释内容，不要列出ID,无多余标题、换行、符号,结果为空时直接返回“未查询到相关数据”
-                    3.1. 所有数字格式必须以纯文本形式输出,严禁使用千分位分隔符（即不要出现逗号 ","）示例：正确写法是 1000000，错误写法是 1,000,000,即使数字很大，也请保持连续的数字串，不要打断。
-                    3.2  所有日期请转换为 YYYY-MM-DD 格式（例如：2026-03-15）,严禁包含时间部分（如小时、分钟、秒）（例如：2026-03-15 00:00:00），也不要包含时区信息。”
-                    3.3. 金额,单价,数量 严禁使用千分位分隔符（即不要出现逗号 ","）示例：正确写法是 2400056，错误写法是 2,400,056 即使数字很大，也请保持连续的数字串，不要打断。
-                4. 长度控制：单条解释不超过150字，条理清晰，重点突出核心数据/趋势；
-                5. 禁止重复：不重复用户问题、不重复执行的SQL语句，仅针对结果做业务解读。
-                """)
-    @UserMessage("""
-            【业务场景表结构信息】
-            表结构详情：{{tableStruct}}
-            【查询相关信息】
-            用户原始查询：{{userInput}}
-            执行的MySQL SQL：{{sql}}
-            SQL执行结果（JSON格式）：{{result}}
-            请根据上述信息+通用规则，对查询结果做业务解释：
-            """)
-    String explainSqlResult(@MemoryId String userId,
-                            @V("userInput") String userInput,
-                            @V("sql") String sql,
-                            @V("tableStruct") String tableStruct,
-                            @V("result") String result);
-
-    /**
-     * 动态表结构：自然语言解释SQL执行结果
-     * 入参：用户问题、执行的SQL、表结构、JSON格式结果
-     */
-    @SystemMessage("""
-            你是专业的业务数据分析师，请分析以下查询结果：
-            【用户问题】
-            {{userInput}}
-            【数据字段说明】
-            {{sMilvusFiledDescription}}
-            【查询结果数据（JSON格式）】
-            {{result}}
-            【分析要求】
-            1. 解释风格：贴合业务场景，无任何SQL专业术语，用口语化、简洁的商业语言说明，避免技术词汇；
-            2. 数据准确：严格按照JSON执行结果解释，不夸大、不遗漏、不编造数据，数值与结果完全一致；
-            3. 输出格式：
-               3.1. 如果用户要求"表格形式展示"，先输出简短文字说明，然后输出Markdown格式的表格
-               3.2. 如果用户未要求表格，仅返回解释内容，不要列出ID,无多余标题、换行、符号
-               3.3. 结果为空时直接返回"未查询到相关数据"
-               3.4. 所有数字格式必须以纯文本形式输出,严禁使用千分位分隔符（即不要出现逗号 ","）
-               3.5. 所有日期请转换为 YYYY-MM-DD 格式，严禁包含时间部分
-            4. 长度控制：单条解释不超过150字，条理清晰，重点突出核心数据/趋势；
-            5. 禁止重复：不重复用户问题、不重复执行的SQL语句，仅针对结果做业务解读。
-            """)
-    @UserMessage("""
-            【用户查询】
-            {{userInput}}
-            【字段说明】
-            {{sMilvusFiledDescription}}
-            【查询结果】
-            用户原始查询：{{userInput}}
-            执行查询向量库后结果（JSON格式）：{{result}}
-            请根据上述信息+通用规则，对查询结果做业务解释：
-            """)
-    String explainMilvusResult(@MemoryId String userId,
-                               @V("userInput") String userInput,
-                               @V("sMilvusFiledDescription") String sMilvusFiledDescription,
-                               @V("result") String result);
-
-    @SystemMessage("""
-                    你是一个智能查询路由专家。请根据【用户需求】，只返回 true 或 false。
-                    【最高优先级规则 - 必须首先判断】
-                    如果用户需求包含以下任一关键词，**直接返回 false**，不再进行其他判断：
-                    - 明细、列表、清单
-                    - ...明细、...列表、...清单
-                    重要：只要出现以上关键词，说明用户需要的是明细数据查询，而非统计分析。
-                    【统计类关键词 - 仅在满足最高优先级规则后才判断】
-                    只有当用户需求不包含上述明细类关键词时，才检查是否包含以下关键词：
-                    统计、求和、汇总、排名、TopN、平均、数量、总额、最高、最低、占比、分组
-                    - 如果包含，返回 true
-                    - 否则返回 false
-                    【判断示例】
-                    - \"查询中科精工集团的彩盒类产品的报价单明细\" → false（包含\"明细\"）
-                    - \"查询客户张三信息\" → false（无统计关键词，无明细关键词）
-                    - \"销售额排名前10的产品\" → true（包含\"排名\"，且无明细关键词）
-                    - \"查看销售订单明细\" → false（包含\"明细\"）
-            """)
-    @UserMessage("""
-            【用户需求】
-            {{userInput}}
-            """)
-//    @SystemMessage("""
-//                你是一个智能查询路由专家，请根据【用户需求】，基于**查询效率最优**原则，自动判断使用关系型数据库(MySQL)还是向量库(Milvus)，只返回 true 或 false。
-//                满足如下规则中任意一条则返回true 否则返回false:
-//                - 查询涉及**排名、TOP N、求和、计数、平均值、最大值、总额、最小值、最高、最低、占比**
-//                - 查询涉及**分组统计(GROUP BY)、排序(ORDER BY)、分页(LIMIT)**
-//                    """)
-//    @UserMessage("""
-//                【用户需求】
-//                {{userInput}}
-//                """)
-    Boolean routeQuery(@MemoryId String userId, @V("userInput") String userInput);
-
-    /**
-     * 生成 Milvus 过滤条件（适配 Milvus v2.3.9）
-     */
-    @SystemMessage("""
-        MILVUS 查询条件生成规则：
-        
-        【最高优先级 - 输出格式铁律】
-        ⚠️ 你的【全部输出】必须是且仅是一个合法的 JSON 对象
-        ⚠️ 禁止输出任何解释、说明、思考过程
-        ⚠️ 禁止输出任何中文文字
-        ⚠️ 只能输出以下 JSON 格式，不能有其他任何内容
-        
-        【输出 JSON 结构】
-        {
-            "sMethodName": true/false,     // 必选，判断用户意图是否匹配当前方法
-            "vectorField": "向量字段名",     // 可选，需要语义匹配时返回
-            "vectorValue": "向量化文本",      // 可选，用于向量检索的文本
-            "filterExpression": "标量过滤表达式"  // 可选，有标量条件时返回
-        }
-        
-        【方法匹配规则 - 重要】
-        sMethodName 的取值逻辑：
-        - 如果用户输入的意图与 {{sMethodName}} 相关，返回 true
-        - 否则返回 false
-        
-        判断标准：用户是否在询问或操作与 {{sMethodName}} 相关的业务数据
-        - 包括但不限于：查询、搜索、推荐、找、查看、明细、列表、详情等
-        - 只要用户想获取或操作这类数据，就应该返回 true
-        
-        示例：
-        - 方法名称：查询报价单
-        - "报价单明细" → true（想查看报价单数据）
-        - "报价单列表" → true（想查看报价单数据）
-        - "报价单" → true（想查看报价单数据）
-        - "查一下报价单" → true（想查询报价单）
-        - "推荐相似报价单" → true（想推荐报价单）
-        - "你好" → false（与报价单无关）
-        - "查询客户信息" → false（与报价单无关）
-        
-        【重要：理解你的数据结构】
-        
-        你有两种类型的字段：
-        
-        1. 标量字段（用于精确过滤）：
-           - {{sMilvusFiled}} 中的字段
-           - 根据提供的字段说明使用
-        
-        2. 向量字段（用于语义搜索）：
-           - 字段名：使用 {{sMilvusFiledXl}} 中提供的向量字段名
-           - 存储格式：管道符分隔的键值对 "字段名:值|字段名:值|..."
-           - 包含的业务数据：{{sMilvusFiledDescriptionXl}}
-           - 示例："sCustomerName:上海小羚羊|sProductName:2028宣传海报|dProductQty:1000|sType:报价丢单原因"
-        
-        【向量搜索规则】
-        
-        使用向量搜索的条件：用户明确表达语义匹配意图
-        - 关键词：找相似、推荐、匹配、类似、相关、类似的、相似的、推荐一下
-        - 使用向量搜索时：
-          1. 从用户问题中提取关键业务实体
-          2. 格式化为："字段名:值|字段名:值"（管道符分隔）
-          3. 示例：
-             - 用户："找丢单原因类似价格太高的记录" → "sReason:价格太高|sType:报价丢单原因"
-             - 用户："推荐和上海小羚羊类似的客户" → "sCustomerName:上海小羚羊"
-             - 用户："找类似2028宣传海报的产品" → "sProductName:2028宣传海报"
-        
-        【标量过滤规则 - 极其重要】
-        
-        可用标量字段（根据 {{sMilvusFiled}} 动态提供）：
-        - 使用提供的字段名
-        - 【字符串字段】：统一使用 like 操作符（前缀匹配）
-        - 【数字字段】：使用 >、<、>=、<=、== 操作符
-        - 【时间字段】：使用时间戳范围
-        
-        【操作符使用规则】
-        
-        1. 字符串字段（统一使用 like）：
-           - 语法：字段名 like '关键词%'
-           - 说明：只支持前缀匹配，不支持 '%keyword%' 或 '%keyword'
-           - 示例：
-             - 用户："上海小羚羊" → sCustomerName like '上海小羚羊%'
-             - 用户："客户名称包含上海" → sCustomerName like '上海%'
-             - 用户："姓张的销售人员" → sSalesManName like '张%'
-             - 用户："产品名称以2028开头" → sProductName like '2028%'
-             - 用户："张三" → sSalesManName like '张三%'
-        
-        2. 数字字段：
-           - 精确匹配：字段名 == 值
-           - 范围匹配：字段名 >= 值 && 字段名 <= 值
-           - 大于：字段名 > 值
-           - 小于：字段名 < 值
-           - 示例：
-             - 用户："数量1000" → dProductQty == 1000
-             - 用户："数量大于1000" → dProductQty > 1000
-             - 用户："数量在500到1000之间" → dProductQty >= 500 && dProductQty <= 1000
-        
-        3. 时间字段：
-           - 使用时间戳范围：tCreateDate >= 开始时间戳 && tCreateDate <= 结束时间戳
-           - 时间戳为 Unix 秒
-        
-        4. 组合条件：
-           - 使用 && (AND) 连接多个条件
-           - 使用 || (OR) 连接或条件
-           - 复杂条件用括号分组
-        
-        【核心约束 - 必须遵守】
-        1. 只有当用户【明确指定】具体条件时，才生成 filterExpression
-        2. 禁止为模糊查询添加默认过滤条件（如时间范围）
-        3. 禁止自动添加任何默认条件
-        4. 当前时间戳：{{sDataNow}}（Unix秒）
-        5. 字符串字段禁止使用 ==，必须使用 like
-        6. like 只支持前缀匹配，不支持 '%keyword%' 或 '%keyword' 格式
-        
-        【查询意图判断】
-        
-        类型A - 纯标量查询（只返回 filterExpression）：
-        - 用户明确指定了标量字段的具体条件
-        - 不包含语义匹配词
-        - 示例1："上海小羚羊" → {"sMethodName": true, "filterExpression": "sCustomerName like '上海小羚羊%'"}
-        - 示例2："客户名称包含上海" → {"sMethodName": true, "filterExpression": "sCustomerName like '上海%'"}
-        - 示例3："张三" → {"sMethodName": true, "filterExpression": "sSalesManName like '张三%'"}
-        - 示例4："数量大于1000" → {"sMethodName": true, "filterExpression": "dProductQty > 1000"}
-        - 示例5："今天创建的报价单" → {"sMethodName": true, "filterExpression": "tCreateDate >= 开始时间戳 && tCreateDate <= 结束时间戳"}
-        
-        类型B - 纯向量搜索（只返回 vectorField 和 vectorValue）：
-        - 用户只有语义意图，无具体标量条件
-        - 示例："找一些类似的报价单" → {"sMethodName": true, "vectorField": "向量字段名", "vectorValue": "sType:报价丢单原因"}
-        
-        类型C - 混合查询（同时返回 vectorField、vectorValue 和 filterExpression）：
-        - 用户既有具体条件，又需要语义匹配
-        - 示例："找丢单原因类似价格太高的上海小羚羊报价单" → 
-          {"sMethodName": true, "vectorField": "向量字段名", "vectorValue": "sReason:价格太高|sType:报价丢单原因", "filterExpression": "sCustomerName like '上海小羚羊%'"}
-        
-        类型D - 意图不匹配（只返回 sMethodName: false）：
-        - 用户输入与 {{sMethodName}} 完全无关
-        - 示例："你好" → {"sMethodName": false}
-        - 示例："查询客户信息"（如果方法名是"查询报价单"） → {"sMethodName": false}
-        
-        类型E - 意图匹配但无具体条件（只返回 sMethodName: true）：
-        - 用户想查询该类数据，但没有指定任何条件
-        - 示例："报价单明细" → {"sMethodName": true}
-        - 示例："报价单列表" → {"sMethodName": true}
-        - 示例："报价单" → {"sMethodName": true}
-        
-        【时间处理规则】
-        
-        当用户明确提到时间时，基于当前时间 {{sDataNow}} 计算：
-        - "今天"：当天 00:00:00 到 23:59:59
-        - "昨天"：前一天 00:00:00 到 23:59:59
-        - "本周"：本周一 00:00:00 到本周日 23:59:59
-        - "本月"：本月1日 00:00:00 到本月最后一天 23:59:59
-        - "上个月"：上个月1日 00:00:00 到上个月最后一天 23:59:59
-        - "近X天"：X天前 00:00:00 到今天 23:59:59
-        
-        时间范围表达式格式：tCreateDate >= 开始时间戳 && tCreateDate <= 结束时间戳
-        
-        【重要约束汇总】
-        1. 只输出 JSON，不要有任何其他内容
-        2. 只使用提供的标量字段
-        3. 【关键】字符串字段必须使用 like，禁止使用 ==
-        4. 时间范围必须使用 Unix 时间戳（秒）
-        5. 向量字段名使用 {{sMilvusFiledXl}} 中提供的字段名
-        6. vectorValue 必须保持管道符分隔格式："字段名:值|字段名:值"
-        7. 禁止为模糊查询添加默认条件
-        8. sMethodName 只要用户意图与当前方法相关就返回 true
-        9. like 只支持前缀匹配，格式：字段名 like '值%'
-        
-        【输出示例】
-        方法名称：查询报价单
-        
-        示例1：模糊查询 - "报价单明细"
-        输出：{"sMethodName": true}
-        
-        示例2：字符串模糊匹配 - "上海小羚羊"
-        输出：{"sMethodName": true, "filterExpression": "sCustomerName like '上海小羚羊%'"}
-        
-        示例3：字符串模糊匹配 - "客户名称包含上海"
-        输出：{"sMethodName": true, "filterExpression": "sCustomerName like '上海%'"}
-        
-        示例4：字符串模糊匹配 - "张三"
-        输出：{"sMethodName": true, "filterExpression": "sSalesManName like '张三%'"}
-        
-        示例5：数字范围 - "数量大于1000"
-        输出：{"sMethodName": true, "filterExpression": "dProductQty > 1000"}
-        
-        示例6：时间范围 - "今天创建的报价单"
-        输出：{"sMethodName": true, "filterExpression": "tCreateDate >= 1774754400 && tCreateDate <= 1774840799"}
-        
-        示例7：组合条件 - "上海小羚羊且数量大于1000"
-        输出：{"sMethodName": true, "filterExpression": "sCustomerName like '上海小羚羊%' && dProductQty > 1000"}
-        
-        示例8：纯向量 - "找一些类似的报价单"
-        输出：{"sMethodName": true, "vectorField": "content_embedding", "vectorValue": "sType:报价丢单原因"}
-        
-        示例9：混合查询 - "找丢单原因类似价格太高的上海小羚羊报价单"
-        输出：{"sMethodName": true, "vectorField": "content_embedding", "vectorValue": "sReason:价格太高|sType:报价丢单原因", "filterExpression": "sCustomerName like '上海小羚羊%'"}
-        
-        示例10：意图不匹配 - "你好"
-        输出：{"sMethodName": false}
-        
-        【标量字段列表】
-        {{sMilvusFiled}}
-        
-        【标量字段说明】
-        {{sMilvusFiledDescription}}
-        
-        【向量字段列表】
-        {{sMilvusFiledXl}}
-        
-        【向量字段说明】
-        {{sMilvusFiledDescriptionXl}}
-        
-        【方法名称】
-        {{sMethodName}}
-        
-        """)
-            @UserMessage("""
-        【用户输入】
-        {{userInput}}
-        
-        【当前时间】
-        {{sDataNow}}
-        
-        【标量字段】
-        {{sMilvusFiled}}
-        
-        【标量字段说明】
-        {{sMilvusFiledDescription}}
-        
-        【向量字段】
-        {{sMilvusFiledXl}}
-        
-        【向量字段说明】
-        {{sMilvusFiledDescriptionXl}}
-        
-        【方法名称】
-        {{sMethodName}}
-        
-        请根据以上规则，输出 JSON 格式结果。
-""")
-    String getMilvusFilter(@MemoryId String userId,
-                           @V("userInput") String userInput,
-                           @V("sMilvusFiled") String sMilvusFiled,
-                           @V("sMilvusFiledDescription") String sMilvusFiledDescription,
-                           @V("sMilvusFiledXl") String sMilvusFiledXl,
-                           @V("sMilvusFiledDescriptionXl") String sMilvusFiledDescriptionXl,
-                           @V("sDataNow") long sDataNow,
-                           @V("sMethodName") String sMethodName
-    );
-}
@@ -8,7 +8,7 @@ import java.util.List;
  *
  * <p>由 {@code IntentService} 用受约束 JSON 一次得出：把一句自然语言压成
  * {意图, 单据/实体类型, 带业务角色的实体清单, 还缺什么}。下游据此做**确定性路由**，
- * 而不是让弱模型在 12 个工具里盲选——这是治理「理解错/选错工具」的核心。
+ * 而不是让弱模型在全部 9 个工具里盲选——这是治理「理解错/选错工具」的核心。
  */
 public class Intent {
@@ -8,7 +8,11 @@ import dev.langchain4j.service.UserMessage;
  * 单一 ReAct 智能体。
  *
  * <p>LangChain4j 的 {@code AiServices} 原生工具调用循环即 ReAct：模型自行决定是否调用工具、
- * 调用哪个工具、以及何时给出最终答复。不再有旧的 8 场景 SceneSelector 路由——由 agent 自路由。
+ * 调用哪个工具、以及何时给出最终答复。不再有旧的 8 场景 {@code SceneSelector} 路由。
+ *
+ * <p>但 agent 也**不是完全自路由**：{@code AgentChatController} 先用意图门({@code IntentService})
+ * 判类，再由 {@link com.xly.config.AgentFactory} 按 {@link ToolScope} 只把该意图相关的工具装进本实例
+ * （新增意图更是完全绕过 ReAct，走确定性 collectForm 路径）。本接口只负责「给定这批工具，自己决定怎么用」。
  *
  * <p>返回 {@link TokenStream} 以支持流式输出；{@link MemoryId} 绑定每个会话独立的对话记忆。
  */
-package com.xly.agent;
-
-import com.xly.entity.SceneIntentParseResp;
-import dev.langchain4j.service.SystemMessage;
-import dev.langchain4j.service.UserMessage;
-import dev.langchain4j.service.V;
-import org.springframework.stereotype.Component;
-
-/**
- * 场景意图解析AI服务：专门让大模型解析用户输入的意图，匹配对应的业务场景
- * 基于LangChain4j AiServices构建，由大模型返回标准化的场景编码
- */
-public interface SceneSelectorAiAgent {
-
-    /**
-     * 核心方法：解析用户意图，匹配业务场景
-     * @param userInput 用户输入
-     * @param authScenesDesc 可访问场景描述
-     * @return 标准化的意图解析响应（仅返回sceneCode）
-     */
-    @SystemMessage("""
-            你是专业的ERP系统**意图解析助理**，你的唯一职责是根据用户输入，匹配其意图对应的业务场景，严格遵循以下规则：
-            1. 仅从用户提供的「可访问场景列表」中选择匹配的场景，绝对不允许虚构场景；
-            2. 匹配规则：用户输入的意图与场景的「支持功能」高度相关，即匹配该场景；
-            3. 输出格式：必须严格返回JSON格式，仅包含sceneCode字段,无任何多余文字、解释、换行；
-               - 匹配到一个场景：sceneCode为场景码（如salemange/purchasemange/ProductionR&Dmanagement）,scene为场景名称（如销售管理/采购管理/生产管理）；
-               - 匹配到多个场景,请列出并让客户选择场景;
-               - 无匹配场景/用户仅问候：sceneCode为NO_MATCH；
-            4. 不允许添加任何额外字段，不允许返回JSON以外的内容，确保后端能直接解析；
-            5. 忽略用户输入中的无关语气词（如“你好”“帮我”“麻烦”），提取核心业务意图。
-            """)
-    @UserMessage("""
-            用户输入：{{userInput}}
-            可访问场景列表：{{authScenesDesc}}
-            请严格按指定格式返回匹配的场景编码！
-            """)
-    SceneIntentParseResp parseSceneIntent(@V("userInput") String userInput,
-                                          @V("authScenesDesc") String authScenesDesc);
-}
 \ No newline at end of file
-package com.xly.agent;
-
-import cn.hutool.core.util.ObjectUtil;
-import com.alibaba.fastjson2.JSON;
-import com.alibaba.fastjson2.JSONObject;
-import com.alibaba.fastjson2.JSONWriter;
-import com.xly.entity.ParamRule;
-import com.xly.entity.UserSceneSession;
-
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class SystemPromptGenerator {
-
-    public static String generate(String toolName, UserSceneSession session) {
-        StringBuilder sb = new StringBuilder();
-
-        sb.append("你是一个无情的参数提取器，不是聊天助手。\n\n");
-        sb.append("【核心任务】\n");
-        sb.append("从用户输入中提取参数，并立即调用工具 ").append(toolName).append("。\n\n");
-        sb.append("【绝对指令】\n");
-        sb.append("1. 严禁与用户对话，严禁输出任何纯文本回复。\n");
-        sb.append("2. 无论参数缺失多么严重，都必须直接调用工具，缺失字段填空字符串或0。\n");
-        sb.append("3. 不要引导用户，后端程序会处理引导逻辑。\n\n");
-        sb.append("【参数提取规则】\n");
-        sb.append("用户输入格式为 \"参数名: 值\" 或 \"参数名 值\"，你必须识别参数名并提取对应的值。\n\n");
-        sb.append("【可提取的参数列表】\n");
-        List<ParamRule> dynamicParamRuleAll = session.getCurrentTool().getParamRuleListAll();
-        // 从参数定义中提取
-        for (ParamRule paramRule : dynamicParamRuleAll) {
-            sb.append("- ").append(paramRule.getSParam()).append("\n");
-        }
-        sb.append("\n【提取示例】\n");
-        // 动态生成示例（取前3个参数作为示例）
-        int count = 0;
-        for (ParamRule paramRule : dynamicParamRuleAll) {
-            if (count++ >= 3) break;
-            sb.append("- 用户输入 \"").append(paramRule.getSParam()).append(": {值}\" → 提取 ").append(paramRule.getSParam()).append("\n");
-        }
-
-        if(ObjectUtil.isNotEmpty(session.getArgs())){
-            sb.append("【已提取参数】\n");
-            sb.append(JSON.toJSONString(session.getArgs(), JSONWriter.Feature.PrettyFormat));
-        }
-        sb.append("\n【工具调用规则】\n");
-        sb.append("1. 每次只调用一次工具\n");
-        sb.append("2. 调用后立即停止，不要重复调用\n");
-        sb.append("3. 不要总结，不要回复用户，只调用工具");
-
-        return sb.toString();
-    }
-
-    /**
-     * 缺失参数统一提示模板：强制AI调用自定义方法，一次性回填所有参数
-     */
-    public static String buildMissParamPrompt(UserSceneSession session, List<ParamRule> paramRuleDataMiss) {
-        String methodNo = session.getCurrentTool().getSMethodNo();
-        // 1. 拼接缺失参数的描述（增加“参数名”和“英文名”的对应，方便模型映射）
-        String paramDesc = paramRuleDataMiss.stream()
-                .map(p -> String.format("- 参数名：%s (对应字段: %s)，示例值：%s",
-                        p.getSParam(), p.getSParamValue(), p.getSExampleValue()))
-                .collect(Collectors.joining("\n"));
-        // 但根据你的需求，其实 prompt 里并不需要强行插入一个空的 JSON 片段，
-        // 直接告诉模型去“合并”即可。
-        return String.format("""
-            请你根据用户最新的输入，补充缺失的参数，并带着【所有完整参数】立即发起工具调用。
-            
-            【核心执行规则】
-            1. **参数合并（至关重要）**：你必须保留上一轮对话中已经获取的参数（如 sSlaveId, operateType 等），并将用户本次提供的新参数与旧参数合并。
-            2. **必须调用工具**：必须调用工具 `%s`。绝对禁止直接输出 JSON 文本，也绝对禁止向用户反问或索要信息。
-            3. **完整调用**：请直接生成包含所有参数的 tool_calls 请求。
-            【已获取数据】
-            %s
-            【当前缺失的参数说明】
-            %s
-            """, methodNo,JSONObject.toJSONString(session.getArgs()), paramDesc);
-    }
-
-    public static String buildDynamicSystemPrompt(UserSceneSession session) {
-        // 获取当前工具编号（用于 JSON 的 name 字段）
-        String methodNo = session.getCurrentTool().getSMethodNo();
-        return """
-            【极强约束·必须执行】
-            1. 禁止说话！禁止解释！
-            2. 必须调用工具！
-            3. 只输出标准工具调用JSON！
-            
-            ### 任务背景 ###
-            用户会输入自然语言指令（如“第1行确认”、“全部合并”等）。
-            你的任务是：解析出【操作类型】和【目标行号】。
-            
-            ### 解析规则（必须严格遵守） ###
-            
-            1. **操作类型 (operateType)**：
-               - 如果用户说“全部确认”、“生成多个单据”，识别为："全部确认"
-               - 如果用户说“合并确认”、“生成一个单据”，识别为："合并确认"
-               - 其他情况，默认为："单行确认"
-            
-            2. **行号提取 (rowNumbers)**：
-               - 单选：如“第5行”，提取为 [5]
-               - 多选：如“第1、3、5行”，提取为 [1, 3, 5]
-               - 范围：如“第2到4行”，提取为 [2, 3, 4]
-               - 全选：如“全部”、“所有”，提取为 ["ALL"]
-            
-            ### 输出格式规范 ###
-            请直接输出以下 JSON（不要任何 Markdown 格式，不要 ```json）：
-            {"name": "%s", "parameters": {"operateType": "解析出的类型", "rowNumbers": [行号数组或"ALL"]}}
-            
-            """.formatted(methodNo);
-    }
-
-}
 \ No newline at end of file
@@ -4,14 +4,14 @@ package com.xly.agent;
  * 按意图收窄「本轮可见的工具集」（架构 §5 的 tool scoping）。
  *
  * <p>依据：单次 ReAct 的选工具准确率随工具数量上升而骤降（业界经验：50 个工具 ~94% → 200 个 ~64%）。
- * 弱模型(qwen3:14b Q4)一次性面对 12 个语义重叠的工具时，频繁选错族（把「查询」当「新增」）。
- * 于是先用意图门判类，再**只暴露该意图相关的 3-5 个工具**给 ReAct 执行——大幅降低选错概率。
+ * 弱模型(qwen3:14b Q4)一次性面对全部 9 个语义重叠的工具时，频繁选错族（把「查询」当「新增」）。
+ * 于是先用意图门判类，再**只暴露该意图相关的 5 个工具**给 ReAct 执行——大幅降低选错概率。
  */
 public enum ToolScope {
     /** 读：findForms/kgSearch/readFormData/lookupRecord/queryData（+askUser/loadSkill）。 */
     READ,
-    /** 写：collectForm/proposeCreate/Update/Delete/Examine（+lookupRecord 定位、askUser/loadSkill）。 */
+    /** 写：collectForm/proposeWrite(action=…)（+readFormData·lookupRecord 定位、askUser/loadSkill）。 */
     WRITE,
-    /** 兜底：全部工具（意图门失败时用）。 */
+    /** 兜底：全部 9 个工具（意图门失败时用）。 */
     FULL
 }
-package com.xly.config;
-
-import groovy.lang.GroovyClassLoader;
-import groovy.lang.GroovyObject;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.expression.Expression;
-import org.springframework.expression.ExpressionParser;
-import org.springframework.expression.spel.standard.SpelExpressionParser;
-import org.springframework.expression.spel.support.StandardEvaluationContext;
-import org.springframework.stereotype.Component;
-
-import java.util.Map;
-import java.util.Objects;
-
-/**
- * 业务逻辑执行工具：EL表达式 + Groovy脚本
- */
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class BizExecuteUtil {
-    /**
-     * EL表达式解析器
-     */
-    private final ExpressionParser elParser = new SpelExpressionParser();
-
-    /**
-     * Groovy类加载器
-     */
-    private final GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
-
-    /**
-     * 执行业务逻辑
-     * @param bizType 1=EL，2=Groovy
-     * @param bizContent 逻辑内容
-     * @param params JSON参数
-     * @return 执行结果
-     */
-    public String execute(Integer bizType, String bizContent, Map<String, Object> params) {
-        if (Objects.isNull(bizType) || Objects.isNull(bizContent) || bizContent.isBlank()) {
-            throw new IllegalArgumentException("业务逻辑配置异常");
-        }
-        // EL表达式执行
-        if (1 == bizType) {
-            return executeEL(bizContent, params);
-        }
-        // Groovy脚本执行
-        else if (2 == bizType) {
-            return executeGroovy(bizContent, params);
-        }
-        else {
-            throw new IllegalArgumentException("不支持的业务逻辑类型：" + bizType);
-        }
-    }
-
-    /**
-     * 执行EL表达式
-     */
-    private String executeEL(String elContent, Map<String, Object> params) {
-        try {
-            StandardEvaluationContext context = new StandardEvaluationContext();
-            context.setVariable("params", params);
-            Expression expression = elParser.parseExpression(elContent);
-            return expression.getValue(context, String.class);
-        } catch (Exception e) {
-            log.error("EL表达式执行失败：{}", elContent, e);
-            throw new IllegalArgumentException("EL表达式执行失败：" + e.getMessage());
-        }
-    }
-
-    /**
-     * 执行Groovy脚本
-     */
-    private String executeGroovy(String groovyContent, Map<String, Object> params) {
-        try {
-            // 构建Groovy脚本类
-            String scriptCode = "class DynamicScript { def execute(Map params) { " + groovyContent + " } }";
-            Class<?> groovyClass = groovyClassLoader.parseClass(scriptCode);
-            GroovyObject groovyObject = (GroovyObject) groovyClass.getDeclaredConstructor().newInstance();
-            // 执行脚本并返回结果
-            Object result = groovyObject.invokeMethod("execute", new Object[]{params});
-            return Objects.isNull(result) ? "执行成功" : result.toString();
-        } catch (Exception e) {
-            log.error("Groovy脚本执行失败：{}", groovyContent, e);
-            throw new IllegalArgumentException("Groovy脚本执行失败：" + e.getMessage());
-        }
-    }
-}
 \ No newline at end of file
-package com.xly.config;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
-
-/**
- * 全局 ObjectMapper 配置：支持 LocalDate 序列化/反序列化
- */
-@Configuration
-public class JacksonConfig {
-
-    /**
-     * 配置好的 ObjectMapper：注册 JavaTimeModule，支持 Java 8 时间类型
-     */
-    @Bean
-    @Primary // 标记为默认实例，避免多 ObjectMapper 冲突
-    public ObjectMapper objectMapper() {
-        ObjectMapper mapper = new ObjectMapper();
-        // 1. 核心：注册 JSR310 模块，处理 LocalDate/LocalDateTime
-        mapper.registerModule(new JavaTimeModule());
-        // 2. 关闭时间戳序列化，LocalDate 以 "yyyy-MM-dd" 字符串形式存储
-        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
-        // 3. 忽略未知字段（AI 返回多余字段时不报错）
-        mapper.configure(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-        return mapper;
-    }
-}
 \ No newline at end of file
@@ -3,13 +3,7 @@ package com.xly.config;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import com.xly.agent.DynamicTableNl2SqlAiAgent;
-import com.xly.agent.SceneSelectorAiAgent;
 import dev.langchain4j.model.ollama.OllamaChatModel;
-import dev.langchain4j.model.ollama.OllamaStreamingChatModel;
-import dev.langchain4j.service.AiServices;
-import dev.langchain4j.memory.chat.MessageWindowChatMemory;
-import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -23,42 +17,10 @@ public class ModelConfig {
     @Value("${langchain4j.ollama.base-url}")
     private String chatModelUrl;
-    @Value("${langchain4j.ollama.chat-model-name}")
-    private String chatModelName;
-
     @Value("${langchain4j.ollama.sql-model-name}")
     private String sqlModelName;
-    // ====================== 主对话模型 ======================
-    @Bean
-    @Primary
-    public OllamaChatModel chatLanguageModel() {
-        return OllamaChatModel.builder()
-                .baseUrl(chatModelUrl)
-                .modelName(chatModelName)
-                .temperature(0.1)
-                .topP(0.95)
-                .timeout(Duration.ofSeconds(120))
-                .maxRetries(2)
-                .logRequests(true)
-                .logResponses(true)
-                .build();
-    }
-
-    // ====================== 自由闲聊模型 ======================
-    @Bean("chatiModel")
-    public OllamaChatModel chatiModel() {
-        return OllamaChatModel.builder()
-                .baseUrl(chatModelUrl)
-                .modelName(chatModelName)
-                .temperature(0.7)
-                .topP(0.9)
-                .timeout(Duration.ofSeconds(60))
-                .maxRetries(2)
-                .build();
-    }
-
-    // ====================== SQL 专用模型 ======================
+    /** NL2SQL 专用模型（QueryTool 经 AgentFactory 注入）。 */
     @Bean("sqlChatModel")
     public OllamaChatModel sqlChatModel() {
         return OllamaChatModel.builder()
@@ -72,34 +34,6 @@ public class ModelConfig {
                 .build();
     }
-    // ====================== 流式对话模型 ======================
-    @Bean("streamingChatModel")
-    @Primary
-    public OllamaStreamingChatModel streamingChatModel() {
-        return OllamaStreamingChatModel.builder()
-                .baseUrl(chatModelUrl)
-                .modelName(chatModelName)
-                .temperature(0.3)
-                .topP(0.9)
-                .numPredict(1024)
-                .timeout(Duration.ofSeconds(60))
-                .build();
-    }
-
-    // ====================== 流式 SQL 模型 ======================
-    @Bean("streamingSqlModel")
-    public OllamaStreamingChatModel streamingSqlModel() {
-        return OllamaStreamingChatModel.builder()
-                .baseUrl(chatModelUrl)
-                .modelName(sqlModelName)
-                .temperature(0.2)
-                .topP(0.95)
-                .numPredict(2048)
-                .timeout(Duration.ofSeconds(120))
-                .build();
-    }
-
-    // ====================== JSON ======================
     @Bean
     @Primary
     public ObjectMapper objectMapper() {
@@ -109,24 +43,4 @@ public class ModelConfig {
         mapper.configure(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
         return mapper;
     }
-
-    // ====================== 动态 SQL Agent ======================
-    @Bean
-    public DynamicTableNl2SqlAiAgent dynamicTableNl2SqlAiAgent(
-            @Qualifier("sqlChatModel") OllamaChatModel sqlModel) {
-        return AiServices.builder(DynamicTableNl2SqlAiAgent.class)
-                .chatModel(sqlModel)
-                .chatMemoryProvider(memoryId -> MessageWindowChatMemory.withMaxMessages(10))
-                .build();
-    }
-
-    // ====================== 场景选择 Agent ======================
-    @Bean
-    public SceneSelectorAiAgent sceneSelectorAiAgent(
-            @Qualifier("chatLanguageModel") OllamaChatModel chatLanguageModel) {
-        return AiServices.builder(SceneSelectorAiAgent.class)
-                .chatModel(chatLanguageModel)
-                .chatMemoryProvider(memoryId -> MessageWindowChatMemory.withMaxMessages(10))
-                .build();
-    }
-}
 \ No newline at end of file
+}
@@ -9,8 +9,7 @@ public class MvcConfig implements WebMvcConfigurer {
     @Override
     public void addViewControllers(ViewControllerRegistry registry) {
-        // 直接映射URL到视图
         registry.addViewController("/chat").setViewName("chat");
-        registry.addViewController("/").setViewName("index");
+        registry.addRedirectViewController("/", "/chat");
     }
 }
 \ No newline at end of file
-package com.xly.config;
-
-import dev.langchain4j.memory.ChatMemory;
-import dev.langchain4j.memory.chat.ChatMemoryProvider;
-import dev.langchain4j.memory.chat.MessageWindowChatMemory;
-import dev.langchain4j.data.message.ChatMessage;
-import org.springframework.stereotype.Component;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.Collectors;
-
-/**
- * 可操作的ChatMemoryProvider：获取消息对象+清除记忆（指定/全量）+删除单条消息
- * 实现框架原生接口，无缝对接AiServices，线程安全适配生产环境
- */
-@Component
-public class OperableChatMemoryProvider implements ChatMemoryProvider {
-    // 核心缓存：memoryId -> ChatMemory，保证一个会话/用户对应唯一记忆实例
-    private final Map<Object, ChatMemory> memoryCache = new ConcurrentHashMap<>();
-    // 记忆最大消息数，根据业务需求调整
-    private static final int MAX_MESSAGE_SIZE = 100;
-
-    /**
-     * 框架原生方法：获取【当前memoryId对应的ChatMemory实例（含消息对象）】
-     * AiServices自动调用，也是手动操作记忆/消息的唯一入口
-     */
-    @Override
-    public ChatMemory get(Object memoryId) {
-        // 空memoryId兜底，避免空指针
-        Object finalMemId = Objects.isNull(memoryId) ? "default_erp_chat_memory" : memoryId;
-        // 不存在则创建MessageWindowChatMemory，存在则复用
-        return memoryCache.computeIfAbsent(finalMemId, k -> MessageWindowChatMemory.withMaxMessages(MAX_MESSAGE_SIZE));
-    }
-
-    // ===================== 1. 获取消息对象 =====================
-
-    /**
-     * 获取当前会话/用户的全部消息列表
-     */
-    public List<ChatMessage> getCurrentChatMessages(Object memoryId) {
-        if (Objects.isNull(memoryId)) {
-            return new ArrayList<>();
-        }
-        // 返回一个新的列表，避免直接操作内部列表
-        return new ArrayList<>(this.get(memoryId).messages());
-    }
-
-    // ===================== 2. 清除记忆 =====================
-
-    /**
-     * 清空【指定memoryId】的全部记忆
-     */
-    public void clearSpecifiedMemory(Object memoryId) {
-        if (Objects.nonNull(memoryId)) {
-            this.get(memoryId).clear();
-        }
-    }
-
-    /**
-     * 全量清除【所有memoryId】的记忆
-     */
-    public void clearAllMemory() {
-        memoryCache.values().forEach(ChatMemory::clear);
-    }
-
-    // ===================== 3. 删除单条消息（完全重新设置方案） =====================
-
-    /**
-     * 删除指定消息（通过完全重新设置消息列表的方式）
-     * @param memoryId 会话ID
-     * @param messageToDelete 要删除的消息对象
-     * @return 删除后的最新消息列表
-     */
-    public List<ChatMessage> deleteSingleMessage(Object memoryId, ChatMessage messageToDelete) {
-        if (Objects.isNull(memoryId) || Objects.isNull(messageToDelete)) {
-            return getCurrentChatMessages(memoryId);
-        }
-
-        // 步骤1: 获取当前所有消息
-        ChatMemory currentMemory = this.get(memoryId);
-        List<ChatMessage> currentMessages = new ArrayList<>(currentMemory.messages());
-
-        // 从后往前查找内容匹配的最后一条消息
-        int indexToDelete = -1;
-        for (int i = currentMessages.size() - 1; i >= 0; i--) {
-            ChatMessage msg = currentMessages.get(i);
-            if (isSameMessage(msg, messageToDelete)) {
-                indexToDelete = i;
-                break;
-            }
-        }
-        // 如果找到匹配的消息
-        if (indexToDelete >= 0) {
-            List<ChatMessage> filteredMessages = new ArrayList<>(currentMessages);
-            filteredMessages.remove(indexToDelete);
-            return rebuildMemoryWithMessages(memoryId, filteredMessages);
-        }
-        // 步骤4: 完全重新设置消息列表
-        return rebuildMemoryWithMessages(memoryId, currentMessages);
-    }
-    public List<ChatMessage> deleteUserLasterMessage(Object memoryId) {
-        if (Objects.isNull(memoryId)) {
-            return getCurrentChatMessages(memoryId);
-        }
-        // 步骤1: 获取当前所有消息
-        ChatMemory currentMemory = this.get(memoryId);
-        List<ChatMessage> currentMessages = new ArrayList<>(currentMemory.messages());
-
-        // 从后往前查找内容匹配的最后一条消息
-        int indexToDelete = currentMessages.size()-1;
-        // 如果找到匹配的消息
-        if (indexToDelete >= 0) {
-            List<ChatMessage> filteredMessages = new ArrayList<>(currentMessages);
-            filteredMessages.remove(indexToDelete);
-            return rebuildMemoryWithMessages(memoryId, filteredMessages);
-        }
-        // 步骤4: 完全重新设置消息列表
-        return rebuildMemoryWithMessages(memoryId, currentMessages);
-    }
-
-    public List<ChatMessage> deleteUserLasterMessageBySize(Object memoryId,Integer size) {
-        if (Objects.isNull(memoryId) || size==0) {
-            return getCurrentChatMessages(memoryId);
-        }
-        // 步骤1: 获取当前所有消息
-        ChatMemory currentMemory = this.get(memoryId);
-        List<ChatMessage> currentMessages = new ArrayList<>(currentMemory.messages());
-        // 从后往前查找内容匹配的最后一条消息
-        int indexToDelete = currentMessages.size();
-        // 如果找到匹配的消息
-        if (indexToDelete >= 0) {
-            List<ChatMessage> filteredMessages = new ArrayList<>(currentMessages);
-             for(int i=0;i<size;i++){
-                 indexToDelete = indexToDelete -1;
-                 if(indexToDelete>1){
-                     filteredMessages.remove(indexToDelete);
-                 }
-             }
-            return rebuildMemoryWithMessages(memoryId, filteredMessages);
-        }
-        // 步骤4: 完全重新设置消息列表
-        return rebuildMemoryWithMessages(memoryId, currentMessages);
-    }
-    /**
-     * 批量删除多条消息
-     * @param memoryId 会话ID
-     * @param messagesToDelete 要删除的消息列表
-     * @return 删除后的最新消息列表
-     */
-    public List<ChatMessage> deleteMessages(Object memoryId, List<ChatMessage> messagesToDelete) {
-        if (Objects.isNull(memoryId) || messagesToDelete == null || messagesToDelete.isEmpty()) {
-            return getCurrentChatMessages(memoryId);
-        }
-
-        // 获取当前所有消息
-        ChatMemory currentMemory = this.get(memoryId);
-        List<ChatMessage> currentMessages = new ArrayList<>(currentMemory.messages());
-
-        // 过滤掉所有要删除的消息
-        List<ChatMessage> filteredMessages = currentMessages.stream()
-                .filter(msg -> messagesToDelete.stream().noneMatch(delMsg -> isSameMessage(msg, delMsg)))
-                .collect(Collectors.toList());
-
-        // 如果消息数量没有变化，直接返回
-        if (filteredMessages.size() == currentMessages.size()) {
-            return currentMessages;
-        }
-
-        // 重新设置消息列表
-        return rebuildMemoryWithMessages(memoryId, filteredMessages);
-    }
-
-    /**
-     * 判断两条消息是否相同（支持根据内容、类型等多维度匹配）
-     */
-    private boolean isSameMessage(ChatMessage msg1, ChatMessage msg2) {
-//        if (msg1 == msg2) return true; // 同一对象引用
-//        if (msg1 == null || msg2 == null) return false;
-//
-//        // 根据消息类型和内容判断
-//        // 方式1: 根据对象相等性
-//        if (msg1.equals(msg2)) return true;
-        // 方式2: 根据消息类型和文本内容（适用于大多数场景）
-        if (msg1.type() == msg2.type()) {
-            // 如果有唯一ID或时间戳，也可以加入判断
-            // 这里简单使用文本内容判断
-            String text1 = extractText(msg1);
-            String text2 = extractText(msg2);
-            return Objects.equals(text1, text2);
-        }
-
-        return false;
-    }
-
-    /**
-     * 从消息中提取文本内容
-     */
-    private String extractText(ChatMessage message) {
-        // 根据ChatMessage的实际类型提取文本
-        // 这里需要根据您的具体消息实现来调整
-        try {
-            // 尝试通过toString获取内容
-            return message.toString();
-        } catch (Exception e) {
-            return "";
-        }
-    }
-
-    /**
-     * 核心方法：使用过滤后的消息列表重建记忆
-     */
-    private List<ChatMessage> rebuildMemoryWithMessages(Object memoryId, List<ChatMessage> messages) {
-        // 从缓存中移除原实例
-        ChatMemory oldMemory = memoryCache.remove(memoryId);
-
-        // 创建新的ChatMemory实例
-        MessageWindowChatMemory newMemory = MessageWindowChatMemory.withMaxMessages(MAX_MESSAGE_SIZE);
-
-        // 由于ChatMemory接口没有直接添加消息的方法，我们需要通过特定方式添加
-        // 方式1: 如果MessageWindowChatMemory有add方法（需要通过反射或强制类型转换）
-        try {
-            // 通过反射调用add方法（如果存在）
-            java.lang.reflect.Method addMethod = newMemory.getClass().getMethod("add", ChatMessage.class);
-            addMethod.setAccessible(true);
-            for (ChatMessage message : messages) {
-                addMethod.invoke(newMemory, message);
-            }
-        } catch (Exception e) {
-            // 方式2: 如果无法通过反射添加，我们需要使用替代方案
-            // 这里可以记录日志
-            System.err.println("无法通过反射添加消息: " + e.getMessage());
-
-            // 方式3: 使用clear后通过某种方式重新添加
-            // 注意：这取决于具体的ChatMemory实现
-        }
-
-        // 将新实例放入缓存
-        memoryCache.put(memoryId, newMemory);
-
-        // 返回重建后的消息列表
-        return new ArrayList<>(newMemory.messages());
-    }
-
-    /**
-     * 移除并清除指定记忆（清空消息+从缓存删除实例）
-     */
-    public void removeAndClearMemory(Object memoryId) {
-        if (Objects.nonNull(memoryId)) {
-            ChatMemory chatMemory = memoryCache.remove(memoryId);
-            if (Objects.nonNull(chatMemory)) {
-                chatMemory.clear();
-            }
-        }
-    }
-}
 \ No newline at end of file
-package com.xly.config;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
-import org.springframework.data.redis.serializer.StringRedisSerializer;
-
-@Configuration
-public class RedisConfig {
-
-    @Bean
-    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
-        RedisTemplate<String, Object> template = new RedisTemplate<>();
-        template.setConnectionFactory(factory);
-
-        // key 采用 String 序列化
-        template.setKeySerializer(new StringRedisSerializer());
-        // hash 的 key 也采用 String 序列化
-        template.setHashKeySerializer(new StringRedisSerializer());
-
-        // value 采用 Jackson 序列化
-        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();
-        template.setValueSerializer(jsonSerializer);
-        template.setHashValueSerializer(jsonSerializer);
-
-        template.afterPropertiesSet();
-        return template;
-    }
-}
 \ No newline at end of file
-package com.xly.config;
-
-import org.apache.commons.lang3.Validate;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.DisposableBean;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ApplicationContextAware;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Service;
-
-/**
- * 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候取出ApplicaitonContext.
- */
-@Service
-@Lazy(false)
-public class SpringContextHolder implements ApplicationContextAware, DisposableBean {
-
-    private static ApplicationContext applicationContext = null;
-
-    private static Logger logger = LoggerFactory.getLogger(SpringContextHolder.class);
-
-    /**
-     * 取得存储在静态变量中的ApplicationContext.
-     */
-    public static ApplicationContext getApplicationContext() {
-        assertContextInjected();
-        return applicationContext;
-    }
-
-    /**
-     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
-     */
-    @SuppressWarnings("unchecked")
-    public static <T> T getBean(String name) {
-        assertContextInjected();
-        return (T) applicationContext.getBean(name);
-    }
-
-    /**
-     * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
-     */
-    public static <T> T getBean(Class<T> requiredType) {
-        assertContextInjected();
-        return applicationContext.getBean(requiredType);
-    }
-
-    /**
-     * 清除SpringContextHolder中的ApplicationContext为Null.
-     */
-    public static void clearHolder() {
-        if (logger.isDebugEnabled()){
-            logger.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext);
-        }
-        applicationContext = null;
-    }
-
-    /**
-     * 实现ApplicationContextAware接口, 注入Context到静态变量中.
-     */
-    @Override
-    public void setApplicationContext(ApplicationContext applicationContext) {
-        SpringContextHolder.applicationContext = applicationContext;
-    }
-
-    /**
-     * 实现DisposableBean接口, 在Context关闭时清理静态变量.
-     */
-    @Override
-    public void destroy() throws Exception {
-        SpringContextHolder.clearHolder();
-    }
-
-    /**
-     * 检查ApplicationContext不为空.
-     */
-    private static void assertContextInjected() {
-        Validate.validState(applicationContext != null, "applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder.");
-    }
-}
 \ No newline at end of file
-package com.xly.constant;
-
-import lombok.Getter;
-
-/***
- * @Author 钱豹
- * @Date 9:53 2026/2/9
- * @Param 
- * @return 
- * @Description //TODO
- **/
-@Getter
-public enum BusinessCode {
-
-    //报价确认
-    QUOCONFIRM("quoconfirm", "报价确认"),
-    COMMONTS("commonTs", "如果切换场景，点［回首页］，如果在本场景下，转换意图，点［清除记忆］");
-
-    private final String code;
-    private final String message;
-
-    BusinessCode(String code, String message) {
-        this.code = code;
-        this.message = message;
-    }
-
-    /**
-     * 根据code获取ErrorCode
-     */
-    public static BusinessCode getByCode(Integer code) {
-        for (BusinessCode errorCode : values()) {
-            if (errorCode.getCode().equals(code)) {
-                return errorCode;
-            }
-        }
-        return QUOCONFIRM;
-    }
-}
 \ No newline at end of file
-package com.xly.constant;
-
-/**
- * 全局通用常量
- * 包含大模型解析提示语、请求头、资源前缀等
- */
-public class CommonConstant {
-    //重置方法
-    public static final String RESET = "<button \n" +
-            "    data-action=\"reset\" \n" +
-            "    style=\"\n" +
-            "        background: linear-gradient(135deg, #1677ff, #4096ff);\n" +
-            "        color: white;\n" +
-            "        border: none;\n" +
-            "        padding: 6px 14px;\n" +
-            "        border-radius: 6px;\n" +
-            "        cursor: pointer;\n" +
-            "        font-size: 12px;\n" +
-            "        font-weight: 500;\n" +
-            "        transition: all 0.3s ease;\n" +
-            "    \"\n" +
-            "    data-text=\"重置\"\n" +
-            "    onclick=\"reset('重置')\"\n" +
-            "    onmouseover=\"this.style.opacity='0.8'\"\n" +
-            "    onmouseout=\"this.style.opacity='1'\">\n" +
-            "    重置\n" +
-            "</button> 复位 \n\n";
-
-}
-package com.xly.constant;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/***
- * @Author 钱豹
- * @Date 22:41 2026/2/3
- * @Param
- * @return
- * @Description 调用过程的常量
- **/
-public class ProcedureConstant {
-
-    public	static final String PROTYPESTRING = "proc";
-    public	static final String CONFTYPESTRING = "sType";
-    public	static final String SSQLSTRSTRING = "sSqlStr";
-    public	static final String SRETURN = "sReturn";
-    public	static final String SCODE = "sCode";
-    public	static final String OUTSETSTRING = "outSet";
-    public	static final String SDEFAULT = "sDefault";
-    public	static final String IN = "IN";
-    public	static final String OUT = "OUT";
-    public	static final String HEADER = "HEADER";
-    public	static final String OUTLIST = "outList";
-    public	static final String OUTMAP = "outMap";
-
-    public static Map<String, Object> getRetMap(List<Map<String, Object>> proList, Map<String, Object> outMap) {
-        Map<String, Object> retMap = new HashMap<>(8);
-        Map<String, Object> proMap = new HashMap<>(4);
-        List<Map<String, Object>> outList = new ArrayList<>(1);
-        outList.add(outMap);
-        proMap.put("proData", proList);
-        proMap.put("outData", outList);
-        retMap.put("dataSet", proMap);
-        retMap.put(SCODE, outMap.get(SCODE));
-        retMap.put(SRETURN, outMap.get(SRETURN));
-        return  retMap;
-    }
-
-}
-package com.xly.constant;
-
-import lombok.Getter;
-
-/***
- * @Author 钱豹
- * @Date 23:04 2026/1/30
- * @Param
- * @return
- * @Description 异常码枚举
- **/
-@Getter
-public enum ReturnTypeCode {
-
-    // 成功
-    HTML("html", "html"),
-    JSON("JSON", "JSON"),
-    STREAM("stream", "stream"),
-    MAKEDOWN("makedown", "makedown");
-
-
-    private final String code;
-    private final String message;
-
-    ReturnTypeCode(String code, String message) {
-        this.code = code;
-        this.message = message;
-    }
-
-    /**
-     * 根据code获取ErrorCode
-     */
-    public static ReturnTypeCode getByCode(String code) {
-        for (ReturnTypeCode errorCode : values()) {
-            if (errorCode.getCode().equals(code)) {
-                return errorCode;
-            }
-        }
-        return MAKEDOWN;
-    }
-}
 \ No newline at end of file
-package com.xly.constant;
-
-import lombok.Getter;
-
-/***
- * @Author 钱豹
- * @Date 23:04 2026/1/30
- * @Param
- * @return
- * @Description 异常码枚举
- **/
-@Getter
-public enum RuleCode {
-//    {"sql":"SQL","pro":"过程","const":"常量"}
-    // 成功
-    SQL("sql", "SQL"),
-    // 客户端错误
-    PRO("pro", "过程"),
-    CONST("const", "常量");
-
-    private final String code;
-    private final String message;
-
-    RuleCode(String code, String message) {
-        this.code = code;
-        this.message = message;
-    }
-
-    /**
-     * 根据code获取ErrorCode
-     */
-    public static RuleCode getByCode(Integer code) {
-        for (RuleCode errorCode : values()) {
-            if (errorCode.getCode().equals(code)) {
-                return errorCode;
-            }
-        }
-        return CONST;
-    }
-}
 \ No newline at end of file
-package com.xly.constant;
-
-/***
- * @Author 钱豹
- * @Date 0:37 2026/2/6
- * @Param
- * @return
- * @Description ERP URL后缀
- **/
-public class UrlErpConstant {
-
-    public static final String getBusinessDataByFormcustomId = "/business/getBusinessDataByFormcustomId/{}?sModelsId={}&sName=";
-
-}
-package com.xly.entity;
-
-import com.xly.entity.AiResponseDTO;
-import cn.hutool.core.util.StrUtil;
-import lombok.extern.slf4j.Slf4j;
-
-/**
- * AI响应累积器
- */
-@Slf4j
-public class AiResponseAccumulator {
-
-    private final String requestId;
-    private final StringBuilder aiTextBuilder = new StringBuilder();
-    private final StringBuilder systemTextBuilder = new StringBuilder();
-    private String sSceneName;
-    private String sMethodName;
-    private String sReturnType;
-    private int totalChunks = 0;
-    private int processedChunks = 0;
-    private final long startTime;
-
-    public AiResponseAccumulator(String requestId) {
-        this.requestId = requestId;
-        this.startTime = System.currentTimeMillis();
-    }
-
-    /**
-     * 累积单个AI响应
-     */
-    public void accumulate(AiResponseDTO response) {
-        processedChunks++;
-
-        // 更新总块数
-        if (response.getTotalChunks() != null && response.getTotalChunks() > 0) {
-            this.totalChunks = response.getTotalChunks();
-        }
-
-        // 累积AI文本片段
-        if (StrUtil.isNotBlank(response.getTextFragment())) {
-            aiTextBuilder.append(response.getTextFragment());
-        }
-
-        // 累积系统文本片段
-        if (StrUtil.isNotBlank(response.getSystemTextFragment())) {
-            systemTextBuilder.append(response.getSystemTextFragment());
-        }
-
-        // 更新元数据（取最后一次非空值）
-        if (StrUtil.isNotBlank(response.getSSceneName())) {
-            this.sSceneName = response.getSSceneName();
-        }
-        if (StrUtil.isNotBlank(response.getSMethodName())) {
-            this.sMethodName = response.getSMethodName();
-        }
-        if (StrUtil.isNotBlank(response.getSReturnType())) {
-            this.sReturnType = response.getSReturnType();
-        }
-
-        log.debug("累积进度: requestId={}, 已处理={}/{}块, AI文本长度={}",
-                requestId, processedChunks, totalChunks, aiTextBuilder.length());
-    }
-
-    /**
-     * 获取完整的响应
-     */
-    public AiResponseDTO getCompleteResponse() {
-        AiResponseDTO response = new AiResponseDTO();
-        response.setRequestId(requestId);
-        response.setAiText(aiTextBuilder.toString());
-        response.setSystemText(systemTextBuilder.toString());
-        response.setFullAiText(aiTextBuilder.toString());
-        response.setFullSystemText(systemTextBuilder.toString());
-        response.setSSceneName(sSceneName);
-        response.setSMethodName(sMethodName);
-        response.setSReturnType(sReturnType != null ? sReturnType : "MARKDOWN");
-        response.setTotalChunks(totalChunks);
-        response.setChunkIndex(processedChunks - 1);
-        response.setIsLastChunk(true);
-        response.setElapsedTime(System.currentTimeMillis() - startTime);
-
-        log.info("ERP累积完成: requestId={}, 总块数={}, AI文本长度={}, 系统文本长度={}, 耗时={}ms",
-                requestId, totalChunks,
-                aiTextBuilder.length(), systemTextBuilder.length(),
-                response.getElapsedTime());
-
-        return response;
-    }
-}
 \ No newline at end of file
-package com.xly.entity;
-
-import cn.hutool.core.util.StrUtil;
-import com.xly.constant.ErrorCode;
-import com.xly.constant.ReturnTypeCode;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.io.Serializable;
-import java.util.List;
-import java.util.Map;
-
-/**
- * TTS响应数据传输对象
- * 增强版：支持流式处理
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class AiResponseDTO implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    // ============ 原有字段 ============
-
-    /**
-     * AI文字部分
-     */
-    private String aiText;
-
-    /**
-     * 系统拼接返回的文字部分
-     */
-    private String systemText;
-
-    /**
-     * 业务场景名称
-     */
-    private String sSceneName;
-
-    /**
-     * 业务方法名称
-     */
-    private String sMethodName;
-
-    /**
-     * 返回类型，默认MARKDOWN
-     */
-    private String sReturnType = ReturnTypeCode.MAKEDOWN.getCode();
-
-    // ============ 新增字段：流式处理支持 ============
-
-    /**
-     * 请求ID，用于追踪整个流式请求
-     */
-    private String requestId;
-
-    /**
-     * 响应码
-     */
-    private Integer code;
-
-    /**
-     * 响应消息
-     */
-    private String message;
-
-    /**
-     * 处理状态：PROCESSING, COMPLETED, FAILED
-     */
-    private String status;
-
-    /**
-     * 当前处理的块编号（从0开始）
-     */
-    private Integer chunkIndex;
-
-    /**
-     * 总块数
-     */
-    private Integer totalChunks;
-
-    /**
-     * 是否是最后一块
-     */
-    private Boolean isLastChunk;
-
-    /**
-     * 文本片段（用于流式传输）
-     * 当aiText过大时，可以分段传输
-     */
-    private String textFragment;
-
-    /**
-     * 系统文本片段（用于流式传输）
-     */
-    private String systemTextFragment;
-
-    /**
-     * 累积的完整AI文本（仅在最后一块时返回）
-     */
-    private String fullAiText;
-
-    /**
-     * 累积的完整系统文本（仅在最后一块时返回）
-     */
-    private String fullSystemText;
-
-    /**
-     * 处理进度（0-100）
-     */
-    private Integer progress;
-
-    /**
-     * 时间戳
-     */
-    private Long timestamp;
-
-    /**
-     * 处理耗时（毫秒）
-     */
-    private Long elapsedTime;
-
-    /**
-     * 扩展字段，用于存储额外的元数据
-     */
-    private Map<String, Object> metadata;
-
-    /**
-     * 错误信息（当status=FAILED时）
-     */
-    private String errorMessage;
-
-    /**
-     * 错误码（当status=FAILED时）
-     */
-    private String errorCode;
-
-    /**
-     * 数据库类型 X: 向量库  S:数据库
-     */
-    private String dbType;
-
-    /**
-     * 数据库类型 H: 缓存  D: 动态
-     */
-    private String dbCach;
-
-    /***
-     * @Author 钱豹
-     * @Date 15:15 2026/4/14
-     * @Param
-     * @return
-     * @Description 操作未清类型
-     **/
-    private String sCopyTo;
-    /***
-     * @Author 钱豹
-     * @Date 15:16 2026/4/14
-     * @Param
-     * @return
-     * @Description 未清记录ID
-     **/
-    private String sCopyToSrcId;
-
-    // ============ 便捷方法 ============
-
-    /**
-     * 判断是否处理成功
-     */
-    public boolean isSuccess() {
-        return code != null && code == 200;
-    }
-
-    /**
-     * 判断是否处理中
-     */
-    public boolean isProcessing() {
-        return "PROCESSING".equals(status);
-    }
-
-    /**
-     * 判断是否已完成
-     */
-    public boolean isCompleted() {
-        return "COMPLETED".equals(status);
-    }
-
-    /**
-     * 判断是否失败
-     */
-    public boolean isFailed() {
-        return "FAILED".equals(status);
-    }
-
-    /**
-     * 获取完整的文本（AI文本 + 系统文本）
-     */
-    public String getFullText() {
-        StringBuilder sb = new StringBuilder();
-        if (StrUtil.isNotBlank(aiText)) {
-            sb.append(aiText);
-        }
-        if (StrUtil.isNotBlank(systemText)) {
-            sb.append(systemText);
-        }
-        return sb.toString();
-    }
-
-    /**
-     * 创建处理中的响应
-     */
-    public static AiResponseDTO processing(String requestId, String textFragment,
-                                           Integer chunkIndex, Integer totalChunks) {
-        return AiResponseDTO.builder()
-                .requestId(requestId)
-                .code(200)
-                .message("Processing")
-                .status("PROCESSING")
-                .textFragment(textFragment)
-                .chunkIndex(chunkIndex)
-                .totalChunks(totalChunks)
-                .timestamp(System.currentTimeMillis())
-                .progress(calculateProgress(chunkIndex, totalChunks))
-                .build();
-    }
-
-    /**
-     * 创建完成响应
-     */
-    public static AiResponseDTO completed(String requestId, String fullAiText,
-                                          String fullSystemText, String sSceneName,
-                                          String sMethodName, String sReturnType) {
-        return AiResponseDTO.builder()
-                .requestId(requestId)
-                .code(200)
-                .message("Completed")
-                .status("COMPLETED")
-                .fullAiText(fullAiText)
-                .fullSystemText(fullSystemText)
-                .aiText(fullAiText)
-                .systemText(fullSystemText)
-                .sSceneName(sSceneName)
-                .sMethodName(sMethodName)
-                .sReturnType(sReturnType)
-                .progress(100)
-                .timestamp(System.currentTimeMillis())
-                .isLastChunk(true)
-                .build();
-    }
-
-    /**
-     * 创建失败响应
-     */
-    public static AiResponseDTO failed(String requestId, String errorMessage, String errorCode) {
-        return AiResponseDTO.builder()
-                .requestId(requestId)
-                .code(500)
-                .message("Failed")
-                .status("FAILED")
-                .errorMessage(errorMessage)
-                .errorCode(errorCode)
-                .timestamp(System.currentTimeMillis())
-                .build();
-    }
-
-    /**
-     * 计算进度
-     */
-    private static Integer calculateProgress(Integer chunkIndex, Integer totalChunks) {
-        if (chunkIndex == null || totalChunks == null || totalChunks == 0) {
-            return 0;
-        }
-        return (int) ((chunkIndex + 1) * 100.0 / totalChunks);
-    }
-}
 \ No newline at end of file
-package com.xly.entity;
-
-import cn.hutool.core.util.StrUtil;
-import lombok.Data;
-
-import java.util.Date;
-
-@Data
-public class AiSqlErrorHistory {
-
-    private Integer iIncrement;
-    private String sId;
-    private Integer iOrder;
-    private Date tCreateDate;
-    private String sBrandsId;
-    private String sSubsidiaryId;
-    private String sMakePerson;
-    private String sBillNo;
-    private String sFormId= StrUtil.EMPTY;
-    private Integer sStatus;
-    private String sSceneId;
-    private String sMethodId;
-    private String sQuestion;
-    private String sError_sql;
-    private String sError_mes;
-    private String sCorrect_sql;
-    private Boolean bCheck = false;
-    private Boolean bInvalid = false;
-    private String sLoginId;
-}
-package com.xly.entity;
-
-import cn.hutool.core.util.StrUtil;
-import lombok.Data;
-
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
-@Data
-public class AiUserAgentQuestion {
-
-    private Integer iIncrement;
-    private String sId;
-    private Integer iOrder;
-    private Date tCreateDate;
-    private String sBrandsId;
-    private String sSubsidiaryId;
-    private String sMakePerson;
-    private String sBillNo;
-    private String sFormId= StrUtil.EMPTY;
-    private Integer sStatus;
-    private String sSceneId;
-    private String sMethodId;
-    private String sQuestion;
-    private String sSqlContent;
-    private Boolean bCheck = false;
-    private Boolean bInvalid = false;
-    private String sLoginId;
-    private String sQuestionGroupNo;
-    private Boolean bRedis = false;
-    private Date tUpdateDate;
-    private Integer iUpdate;
-
-
-
-
-
-}
-package com.xly.entity;
-
-import lombok.Data;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Data
-public class ConfirmationData {
-    private final String requestId;
-    private final String toolName;
-    private final Map<String, Object> parameters;
-    private final String initialResult;
-    private final long expiryTimestamp; // 超时时间戳
-
-    public ConfirmationData(String requestId, String toolName,
-                            Map<String, Object> parameters,
-                            String initialResult,
-                            long timeoutMillis) {
-        this.requestId = requestId;
-        this.toolName = toolName;
-        this.parameters = parameters != null ? new HashMap<>(parameters) : new HashMap<>();
-        this.initialResult = initialResult;
-        this.expiryTimestamp = System.currentTimeMillis() + timeoutMillis;
-    }
-
-    // Getters 和 检查方法
-    public boolean isExpired() {
-        return System.currentTimeMillis() > expiryTimestamp;
-    }
-
-    public String getRequestId() { return requestId; }
-    public String getToolName() { return toolName; }
-    public Map<String, Object> getParameters() { return new HashMap<>(parameters); }
-    public String getInitialResult() { return initialResult; }
-    public long getExpiryTimestamp() { return expiryTimestamp; }
-}
-package com.xly.entity;
-
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 动态表结构的NL2SQL请求实体
- * 适配多场景、任意表结构的NL2SQL查询
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-public class DynamicNl2SqlRequest {
-    /** 涉及表名（多表用,分隔，如product,sales、order,user） */
-    private String tableNames;
-    /** 表结构详情（严格按格式：表名(字段1:类型,字段2:类型,主键/外键)，多表换行/逗号分隔） */
-    private String tableStruct;
-    /** 用户自然语言查询问题 */
-    private String question;
-}
 \ No newline at end of file
-package com.xly.entity;
-
-import lombok.Data;
-
-import java.util.List;
-import java.util.Map;
-
-/***
- * @Author 钱豹
- * @Date 1:22 2026/2/6
- * @Param
- * @return
- * @Description ERP 返回的结果集
- **/
-@Data
-public class ErpDataset {
-    private Integer start;
-    private Integer pageSize;
-    private Integer totalCount;
-    private Integer billNum;
-    private Integer end;
-    private Integer totalPageCount;
-    private Integer previousPageNo;
-    private Integer currentPageNo;
-    private Integer nextPageNo;
-    private List<ErpRow> rows;
-}
-package com.xly.entity;
-
-import lombok.Data;
-
-/***
- * @Author 钱豹
- * @Date 22:42 2026/1/30
- * @Param
- * @return
- * @Description 参数实体类
- **/
-@Data
-public class ErpResult {
-
-    private Integer code;
-    private String msg;
-    private ErpDataset dataset;
-
-}
-package com.xly.entity;
-
-import lombok.Data;
-
-import java.util.List;
-import java.util.Map;
-
-@Data
-public class ErpRow {
-    private List<Map<String,Object>> dataSet;
-    private List<Map<String,Object>> sumSet;
-}
-package com.xly.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-import java.util.Map;
-
-/**
- * NL2SQL统一请求参数
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-public class Nl2SqlRequest {
-    /** 用户自然语言查询语句 */
-    private String question;
-}
-
-
-
-package com.xly.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-import java.util.Map;
-
-
-
-/**
- * NL2SQL统一返回结果
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-public class Nl2SqlResult {
-    /** 生成并校验后的可执行MySQL SQL */
-    private String generateSql;
-    /** SQL执行结构化结果 */
-    private List<Map<String, Object>> sqlResult;
-    /** 结果自然语言解释 */
-    private String resultExplain;
-}
-
-package com.xly.entity;
-
-import lombok.Data;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Map;
-
-/***
- * @Author 钱豹
- * @Date 22:42 2026/1/30
- * @Param
- * @return
- * @Description 参数实体类
- **/
-@Data
-public class ParamRule {
-    private Integer iOrder;
-    private String sId;
-    private String sParamValue;
-    private String sParentId;
-    private String sParam;
-    private String sRule;
-    private String sType;
-    private String sExampleValue;
-    private String sDefaultValue;
-    private String sParamMissMemo;
-    private String sParamConfig;
-    private String sCopyTo;
-    private String sRuleTs;
-    private Boolean bTipModel;
-    private Boolean bEmpty;
-    private Boolean bConfirmAfter;
-    private String sDynamicParamRuleSql;
-    private String sDynamicParam;
-    private String sDynamicParamName;
-    private String sGroup;
-    private Object sParamConfigValue;
-    private Boolean bStandardParam;
-    private Boolean bDynamicParam = false;
-
-}
-package com.xly.entity;
-
-import jakarta.persistence.Column;
-import jakarta.persistence.Id;
-import lombok.Data;
-
-import java.time.LocalDateTime;
-
-/***
- * @Author 钱豹
- * @Date 22:41 2026/1/30
- * @Param
- * @return
- * @Description 模型实体
- **/
-@Data
-public class SceneDto {
-    @Id
-//    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private String sId;
-
-    @Column(name = "iOrder")
-    private Integer iOrder;
-
-    @Column(name = "tCreateDate")
-    private LocalDateTime tCreateDate;
-
-    @Column(name = "sMakePerson")
-    private String sMakePerson;
-
-    private String sBrandsId;
-
-    private String sSubsidiaryId;
-
-    private String sBillNo;
-
-    private String sSceneNo;
-
-    private String sSceneName;
-
-    private String sNickName;
-
-    private String sSceneContext;
-
-    private String sStatus;
-
-
-    private LocalDateTime tUpdateDate;
-
-}
-package com.xly.entity;
-import lombok.Data;
-
-/**
- * 意图解析请求参数：传给大模型的入参，包含用户输入+可访问场景列表
- */
-@Data
-public class SceneIntentParseReq{
-    /**
-     * 用户自然语言输入
-     */
-    private String userInput;
-    /**
-     * 该用户权限内的可访问场景（格式：场景编码-场景名称-支持功能，如ORDER_OPERATE-订单操作-下单、查订单、取消订单）
-     */
-    private String authScenesDesc;
-}
-package com.xly.entity;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.Map;
-
-/**
- * 大模型意图解析响应DTO：强制大模型按此格式返回，方便后端解析
- * 核心：仅返回场景编码（如ORDER_OPERATE），无需多余描述
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-public class SceneIntentParseResp {
-    /**
-     * 匹配的业务场景编码，必须是BusinessScene的枚举名称（如ORDER_OPERATE/CUSTOMER_MANAGE/STOCK_QUERY）
-     * 无匹配场景时，返回：NO_MATCH
-     */
-    private String sceneCode;
-
-
-    /**
-     * 业务场景名（如销量订单、送货单）
-     */
-    private String scene;
-
-    /**
-     * 操作方法名（如增加、修改、审核、物流跟踪）
-     */
-    private String method;
-
-    /**
-     * JSON结构化参数（键=参数名，值=参数值，类型与工具描述一致）
-     */
-    private Map<String, Object> params;
-
-
-}
-
-package com.xly.entity;
-
-import jakarta.persistence.*;
-import lombok.Data;
-
-/**
- * 数据库存储的动态模板
- */
-@Entity
-@Table(name = "ai_scene_template")
-@Data
-public class SceneTemplate {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @Column(name = "scene_code")
-    private String sceneCode;  // 场景编码
-
-    @Column(name = "scene_name")
-    private String sceneName;  // 场景名称
-
-    @Column(name = "template_content", columnDefinition = "TEXT")
-    private String templateContent;  // 模板内容
-
-    @Column(name = "variables_config", columnDefinition = "JSON")
-    private String variablesConfig;  // 变量配置
-
-    @Column(name = "rules_config", columnDefinition = "JSON")
-    private String rulesConfig;  // 规则配置
-
-    @Column(name = "is_active")
-    private Boolean active = true;
-
-    public void setId(Long id) {
-        this.id = id;
-    }
-
-    public Long getId() {
-        return id;
-    }
-}
 \ No newline at end of file
-package com.xly.entity;
-
-
-import lombok.Data;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Map;
-
-/***
- * @Author 钱豹
- * @Date 22:41 2026/1/30
- * @Param
- * @return
- * @Description 工具实体
- **/
-@Data
-public class ToolMeta {
-    private String sId;
-    private Integer iOrder;
-    private LocalDateTime tCreateDate;
-    private String sBrandsId;
-    private String sSubsidiaryId;
-    private String sMakePerson;
-    private String sBillNo;
-    private String sFormId;
-    private String sStatus;
-    private String sceneName;
-    private String sMethodName;
-    private String stoolDesc;
-    private String sParamRules;
-    private Integer iBizType;
-    private LocalDateTime tUpdateDate;
-    private String sMethodNo;
-    private String sControlName;
-    private String sApiUrl;
-    private String sSrcFormId;
-    private String sBizContent;
-    private String sSceneId;
-    private String sInputTabelName;
-    private String sStructureMemo;
-    private String sAIshowfield;
-    private List<Map<String,Object>> sAIshowfieldShow;
-    private Integer iActionType;
-    private String sendUrl;
-    private List<ParamRule> paramRuleList;//模型
-    private List<ParamRule> paramRuleListCheck;//需要校验
-    private List<ParamRule> paramRuleListAll;//所有的
-    private List<ParamRule> dynamicParamRule;//动态参数
-    private LocalDateTime tMakeDate;
-    private String sVectorfiled;
-    private String sVectorjson;
-    private String sVectorfiledAll;
-    private String sVectorfiledShow;
-    private String sTsMemo;
-    private Boolean sQue = false;
-    private Boolean bQuo = false;
-
-}
-package com.xly.entity;
-
-
-import cn.hutool.core.util.ObjectUtil;
-import lombok.Data;
-
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.stream.Collectors;
-
-/**
- * 用户会话状态：记录每个用户的场景选择状态，实现场景会话持久化
- * 存储：用户ID、权限内场景、是否已选场景、当前选定场景
- */
-@Data
-public class UserSceneSession {
-    /**
-     * 唯一标识：用户ID
-     */
-    private String userId;
-    private String userName;
-    private String authorization;
-
-    private String sUserName;
-    private String sBrandsId;
-    private String sSubsidiaryId;
-    /**
-     * 该用户权限内可访问的所有场景（从权限映射中获取）
-     */
-    private List<SceneDto> authScenes;
-    /***
-     * 用户问题集合
-     **/
-    private List<String> sUserQuestionList;
-
-    private List<ToolMeta> authTool;
-    /**
-     * 是否已选择场景（true=已选，进入专属场景交互；false=未选，先展示选择界面）
-     */
-    private boolean sceneSelected = false;
-    /**
-     * 当前选定的业务场景（sceneSelected=true时才有值）
-     */
-    private SceneDto currentScene;
-
-    private ToolMeta currentTool;
-
-    /***
-     * 当前未清返回的数据集
-     **/
-    private Map<Integer,Map<String,Object>> currentRowData;
-
-    /***
-     * @Author 钱豹
-     * @Date 10:07 2026/1/31
-     * @Param
-     * @return
-     * @Description  当前已有参数
-     **/
-    private Map<String,Object> currentArgs;
-
-    private String sFunPrompts; //方法返回的参数补全提示
-
-    private Boolean bCleanMemory = false;
-
-    private  Map<String, Object> args;
-    /***
-     * @Author 钱豹
-     * @Date 12:40 2026/7/7
-     * @Param
-     * @return
-     * @Description 报价data
-     **/
-    private  Map<String, Object> quoData;
-
-    /**
-     * 数据库类型 X: 向量库  S:数据库
-     */
-    private String dbType;
-
-    /**
-     * 数据库类型 H: 缓存  D: 动态
-     */
-    private String dbCach;
-    /**
-     * @Author 钱豹
-     * @Date 22:55 2026/4/13
-     * @Param
-     * @return
-     * @Description AI 模板
-     **/
-    private String sSystemPrompt;
-
-    /***
-     * @Author 钱豹
-     * @Date 15:15 2026/4/14
-     * @Param
-     * @return
-     * @Description 操作未清类型
-     **/
-    private String sCopyTo;
-    /***
-     * @Author 钱豹
-     * @Date 15:16 2026/4/14
-     * @Param
-     * @return
-     * @Description 未清记录ID
-     **/
-    private String sCopyToSrcId;
-
-    /***
-     * @Author 钱豹
-     * @Date 10:03 2026/4/24
-     * @Param
-     * @return
-     * @Description 工具是否已执行
-     **/
-    private Boolean toolExecuted=false;
-
-    /**
-     * 构建场景选择提示语：展示权限内场景，引导用户选择
-     * @return 自然语言提示语
-     */
-    public String buildSceneSelectHint() {
-        if (authScenes == null || authScenes.isEmpty()) {
-            return "<p style='color:red;'>抱歉，你暂无任何业务场景的访问权限，请联系管理员开通！</p>";
-        }
-        // 按名称分组
-        StringBuilder sb = new StringBuilder("<div style='line-height:1.8;'>");
-        sb.append("<span>请输入序号或点链接进入</span>");
-        sb.append("<ul style='padding-left:10px;margin:0;list-style: none;'>");
-        for(int i=0;i<authScenes.size();i++){
-            SceneDto sceneDto = authScenes.get(i);
-            sb.append("<li>").append(i+1).append("、").append("<span  style=\"text-decoration: underline;\"  data-action=\"reset\"  data-text=\"") .append(i+1).append("\" onclick=\"reset('").append(i+1).append("')\">") .append(sceneDto.getSNickName()).append("</span><font style='color:#666; font-size:14px;'>(").append(sceneDto.getSSceneContext()).append(")</font>").append("</li>");
-        }
-        sb.append("</ul>");
-        sb.append("<span style='color:red; font-size:14px;'>提示：可直接输入问题，系统会自动匹配智能体！ </span>");
-        sb.append("</div>");
-        return sb.toString();
-
-    }
-
-
-    // 新增：将权限内场景转换为「大模型可识别的描述字符串」
-    public String buildAuthScenesForLlm(List<ToolMeta> metasAll) {
-        if (authScenes == null || authScenes.isEmpty()) {
-            return "无可用场景";
-        }
-        // 格式：场景编码-场景名称-支持功能，如ORDER_OPERATE-订单操作-下单、查订单、取消订单
-        return authScenes.stream()
-                .map(scene -> "sceneCode:" + scene.getSSceneNo() + ",场景名称:" + scene.getSSceneName() + ",场景内容:\n" + getSceneContext(scene,metasAll))
-                .collect(Collectors.joining("\n"));
-    }
-    /***
-     * @Author 钱豹
-     * @Date 14:12 2026/2/6
-     * @Param [sceneDto, metasAll]
-     * @return java.lang.String
-     * @Description 方法名称拼接
-     **/
-    private String getSceneContext(SceneDto sceneDto,List<ToolMeta> metasAll){
-        List<ToolMeta> metas = metasAll.stream().filter(m->m.getSSceneId().equals(sceneDto.getSId())).collect(Collectors.toUnmodifiableList());
-        StringBuilder sb = new StringBuilder();
-        AtomicInteger index = new AtomicInteger(1);
-        metas.forEach(m -> {
-            sb.append(index.getAndIncrement())
-                    .append(". 【")
-//                    .append(m.getSMethodNo())
-//                    .append("-")
-                    .append(m.getSMethodName())
-                    .append("】")
-                    .append(m.getStoolDesc())
-                    .append("\n");
-        });
-        if(ObjectUtil.isEmpty(sb)){
-            sb.append(sceneDto.getSSceneContext());
-        }
-        return sb.toString();
-    }
-
-    /**
-     * 根据用户输入的序号，匹配选定场景
-     * @param input 用户输入的序号（如1/2/3）
-     * @return true=匹配成功，false=匹配失败
-     */
-    public boolean selectSceneByInput(String input) {
-        try {
-            int index = Integer.parseInt(input) - 1;
-            if (index >= 0 && index < authScenes.size()) {
-                this.currentScene = authScenes.get(index);
-                this.sceneSelected = true;
-                return true;
-            }
-        } catch (NumberFormatException e) {
-            // 非数字输入，直接返回false
-        }
-        return false;
-    }
-
-}
 \ No newline at end of file
@@ -2,12 +2,9 @@ package com.xly.exception;
 import com.xly.constant.ErrorCode;
 import com.xly.exception.dto.BusinessException;
-import com.xly.tts.bean.TTSResponseDTO;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.validation.ConstraintViolationException;
 import lombok.extern.slf4j.Slf4j;
-import org.junit.jupiter.api.Order;
-import org.springframework.core.Ordered;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.dao.DuplicateKeyException;
@@ -20,202 +17,91 @@ import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.servlet.NoHandlerFoundException;
-import java.util.Date;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 @Slf4j
 @RestControllerAdvice
-@Order(Ordered.HIGHEST_PRECEDENCE)
 public class GlobalExceptionHandler {
+    private Map<String, Object> error(Integer code, String message) {
+        Map<String, Object> body = new LinkedHashMap<>();
+        body.put("code", code);
+        body.put("message", message);
+        body.put("timestamp", System.currentTimeMillis());
+        return body;
+    }
-    /**
-     * 处理所有异常
-     */
     @ExceptionHandler(Exception.class)
-    public TTSResponseDTO handleException(HttpServletRequest request, Exception e) {
+    public Map<String, Object> handleException(HttpServletRequest request, Exception e) {
         log.error("请求地址: {}, 全局异常: ", request.getRequestURI(), e);
-
-        // 获取请求信息
-        String method = request.getMethod();
-        String uri = request.getRequestURI();
-        String queryString = request.getQueryString();
-
-        // 记录异常日志（可存入数据库）
-//        ErrorLog errorLog = ErrorLog.builder()
-//                .method(method)
-//                .uri(uri)
-//                .queryString(queryString)
-//                .exceptionName(e.getClass().getName())
-//                .exceptionMessage(e.getMessage())
-//                .stackTrace(ExceptionUtils.getStackTrace(e))
-//                .ip(IpUtil.getIpAddr(request))
-//                .userAgent(request.getHeader("User-Agent"))
-//                .timestamp(new Date())
-//                .build();
-//
-//        // 异步保存错误日志
-//        saveErrorLogAsync(errorLog);
-
-        // 生产环境隐藏详细错误信息
-        if (isProduction()) {
-            return TTSResponseDTO.error(ErrorCode.SYSTEM_ERROR);
-        } else {
-            // 开发环境返回详细错误信息
-            Map<String, Object> errorDetail = new HashMap<>();
-            errorDetail.put("exception", e.getClass().getName());
-            errorDetail.put("message", e.getMessage());
-            errorDetail.put("path", uri);
-            errorDetail.put("method", method);
-            errorDetail.put("timestamp", new Date());
-            return TTSResponseDTO.error(ErrorCode.SYSTEM_ERROR.getCode(), "系统异常: " + e.getMessage());
-        }
+        return error(ErrorCode.SYSTEM_ERROR.getCode(), "系统异常: " + e.getMessage());
     }
-    /**
-     * 处理业务异常
-     */
     @ExceptionHandler(BusinessException.class)
-    public TTSResponseDTO handleBusinessException(BusinessException e) {
+    public Map<String, Object> handleBusinessException(BusinessException e) {
         log.warn("业务异常: {}", e.getMessage());
-        return TTSResponseDTO.error(e.getCode(), e.getMessage());
+        return error(e.getCode(), e.getMessage());
     }
-    /**
-     * 处理数据校验异常
-     */
     @ExceptionHandler(MethodArgumentNotValidException.class)
-    public TTSResponseDTO handleMethodArgumentNotValidException(
-            MethodArgumentNotValidException e) {
+    public Map<String, Object> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
         List<String> errors = e.getBindingResult().getFieldErrors()
                 .stream()
-                .map(error -> error.getField() + ": " + error.getDefaultMessage())
+                .map(err -> err.getField() + ": " + err.getDefaultMessage())
                 .collect(Collectors.toList());
-
         String message = String.join("; ", errors);
         log.warn("参数校验失败: {}", message);
-        return TTSResponseDTO.error(ErrorCode.PARAM_ERROR.getCode(), message);
+        return error(ErrorCode.PARAM_ERROR.getCode(), message);
     }
-    /**
-     * 处理约束违反异常
-     */
     @ExceptionHandler(ConstraintViolationException.class)
-    public TTSResponseDTO handleConstraintViolationException(
-            ConstraintViolationException e) {
+    public Map<String, Object> handleConstraintViolationException(ConstraintViolationException e) {
         List<String> errors = e.getConstraintViolations()
                 .stream()
-                .map(violation ->
-                        violation.getPropertyPath() + ": " + violation.getMessage())
+                .map(violation -> violation.getPropertyPath() + ": " + violation.getMessage())
                 .collect(Collectors.toList());
-
         String message = String.join("; ", errors);
         log.warn("参数约束违反: {}", message);
-        return TTSResponseDTO.error(ErrorCode.PARAM_ERROR.getCode(), message);
+        return error(ErrorCode.PARAM_ERROR.getCode(), message);
     }
-    /**
-     * 处理Http请求方法不支持异常
-     */
     @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
-    public TTSResponseDTO handleHttpRequestMethodNotSupportedException(
-            HttpRequestMethodNotSupportedException e) {
+    public Map<String, Object> handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
         log.warn("HTTP方法不支持: {} {}", e.getMethod(), e.getSupportedHttpMethods());
-        return TTSResponseDTO.error(ErrorCode.BAD_REQUEST.getCode(),
-                "请求方法 '" + e.getMethod() + "' 不支持");
+        return error(ErrorCode.BAD_REQUEST.getCode(), "请求方法 '" + e.getMethod() + "' 不支持");
     }
-    /**
-     * 处理媒体类型不支持异常
-     */
     @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
-    public TTSResponseDTO handleHttpMediaTypeNotSupportedException(
-            HttpMediaTypeNotSupportedException e) {
+    public Map<String, Object> handleHttpMediaTypeNotSupportedException(HttpMediaTypeNotSupportedException e) {
         log.warn("媒体类型不支持: {}", e.getContentType());
-        return TTSResponseDTO.error(ErrorCode.BAD_REQUEST.getCode(),
-                "媒体类型不支持: " + e.getContentType());
+        return error(ErrorCode.BAD_REQUEST.getCode(), "媒体类型不支持: " + e.getContentType());
     }
-    /**
-     * 处理404异常
-     */
     @ExceptionHandler(NoHandlerFoundException.class)
-    public TTSResponseDTO handleNoHandlerFoundException(
-            NoHandlerFoundException e) {
+    public Map<String, Object> handleNoHandlerFoundException(NoHandlerFoundException e) {
         log.warn("接口不存在: {} {}", e.getHttpMethod(), e.getRequestURL());
-        return TTSResponseDTO.error(ErrorCode.NOT_FOUND.getCode(),
-                "接口不存在: " + e.getRequestURL());
+        return error(ErrorCode.NOT_FOUND.getCode(), "接口不存在: " + e.getRequestURL());
     }
-    /**
-     * 处理类型转换异常
-     */
     @ExceptionHandler(HttpMessageConversionException.class)
-    public TTSResponseDTO handleHttpMessageConversionException(
-            HttpMessageConversionException e) {
+    public Map<String, Object> handleHttpMessageConversionException(HttpMessageConversionException e) {
         log.warn("HTTP消息转换异常: {}", e.getMessage());
-        return TTSResponseDTO.error(ErrorCode.PARAM_ERROR.getCode(),
-                "参数格式错误");
+        return error(ErrorCode.PARAM_ERROR.getCode(), "参数格式错误");
     }
-    /**
-     * 处理数据库异常
-     */
     @ExceptionHandler(DataAccessException.class)
-    public TTSResponseDTO handleDataAccessException(DataAccessException e) {
+    public Map<String, Object> handleDataAccessException(DataAccessException e) {
         log.error("数据库异常: {}", e.getMessage(), e);
-
-        // 根据具体异常类型细化处理
         if (e instanceof DuplicateKeyException) {
-            return TTSResponseDTO.error(ErrorCode.DATA_EXISTS.getCode(),
-                    "数据已存在");
+            return error(ErrorCode.DATA_EXISTS.getCode(), "数据已存在");
         } else if (e instanceof DataIntegrityViolationException) {
-            return TTSResponseDTO.error(ErrorCode.DATA_ERROR.getCode(),
-                    "数据完整性违反");
+            return error(ErrorCode.DATA_ERROR.getCode(), "数据完整性违反");
         } else if (e instanceof BadSqlGrammarException) {
-            return TTSResponseDTO.error(ErrorCode.DB_ERROR.getCode(),
-                    "SQL语法错误");
+            return error(ErrorCode.DB_ERROR.getCode(), "SQL语法错误");
         }
-
-        return TTSResponseDTO.error(ErrorCode.DB_ERROR);
-    }
-
-    /**
-     * 处理JWT异常
-     */
-//    @ExceptionHandler(JwtException.class)
-//    public TTSResponseDTO handleJwtException(JwtException e) {
-//        log.warn("JWT异常: {}", e.getMessage());
-//        return ApiResult.error(ErrorCode.UNAUTHORIZED.getCode(),
-//                "Token无效或已过期");
-//    }
-
-//    /**
-//     * 异步保存错误日志
-//     */
-//    @Async
-//    public void saveErrorLogAsync(ErrorLog errorLog) {
-//        try {
-//            // 保存到数据库或日志文件
-//            errorLogService.save(errorLog);
-//        } catch (Exception ex) {
-//            log.error("保存错误日志失败", ex);
-//        }
-//    }
-
-    /***
-     * @Author 钱豹
-     * @Date 23:21 2026/1/30
-     * @Param []
-     * @return boolean
-     * @Description 判断是否生产环境还是开发环境 应该根据yml 配置来  后期拓展
-     **/
-    private boolean isProduction() {
-        //TODO
-        String profile = "dev";
-        return "prod".equals(profile);
+        return error(ErrorCode.DB_ERROR.getCode(), ErrorCode.DB_ERROR.getMessage());
     }
-}
 \ No newline at end of file
+}
-//package com.xly.exception;
-//
-//import com.fasterxml.jackson.databind.ObjectMapper;
-//import com.xly.tts.bean.TTSResponseDTO;
-//import jakarta.servlet.*;
-//import jakarta.servlet.http.HttpServletRequest;
-//import jakarta.servlet.http.HttpServletResponse;
-//import lombok.RequiredArgsConstructor;
-//import lombok.extern.slf4j.Slf4j;
-//import org.springframework.core.annotation.Order;
-//import org.springframework.http.HttpStatus;
-//import org.springframework.http.MediaType;
-//import org.springframework.stereotype.Component;
-//
-//import java.io.IOException;
-//
-//@Slf4j
-//@Component
-//@Order(1)
-//@RequiredArgsConstructor
-//public class TtsExceptionFilter implements Filter {
-//
-//    private final ObjectMapper objectMapper;
-//
-//    @Override
-//    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
-//            throws IOException, ServletException {
-//
-//        HttpServletRequest httpRequest = (HttpServletRequest) request;
-//        HttpServletResponse httpResponse = (HttpServletResponse) response;
-//
-//        // 只处理 TTS 相关接口
-//        if (!httpRequest.getRequestURI().contains("/api/tts/")) {
-//            chain.doFilter(request, response);
-//            return;
-//        }
-//
-//        try {
-//            chain.doFilter(request, response);
-//        } catch (Exception ex) {
-//            log.error("TTS接口异常: {}", httpRequest.getRequestURI(), ex);
-//
-//            // 清除之前的响应
-//            if (httpResponse.isCommitted()) {
-//                return;
-//            }
-//
-//            httpResponse.reset();
-//            httpResponse.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
-//            httpResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
-//            httpResponse.setCharacterEncoding("UTF-8");
-//
-//            TTSResponseDTO errorResult = TTSResponseDTO.error(
-//                    HttpStatus.INTERNAL_SERVER_ERROR.value(),
-//                    "语音合成服务异常: " + ex.getMessage()
-//            );
-//
-//            String jsonResponse = objectMapper.writeValueAsString(errorResult);
-//            httpResponse.getWriter().write(jsonResponse);
-//            httpResponse.getWriter().flush();
-//        }
-//    }
-//}
 \ No newline at end of file
-package com.xly.exception.dto;
-
-import com.xly.constant.ErrorCode;
-
-/***
- * @Author 钱豹
- * @Date 23:13 2026/1/30
- * @Param
- * @return
- * @Description 认证异常
- **/
-public class AuthenticationException extends BaseException {
-    public AuthenticationException(ErrorCode errorCode) {
-        super(errorCode);
-    }
-
-    public AuthenticationException(String message) {
-        super(ErrorCode.UNAUTHORIZED.getCode(), message);
-    }
-}
 \ No newline at end of file
-package com.xly.exception.dto;
-
-
-import com.xly.constant.ErrorCode;
-
-/***
- * @Author 钱豹
- * @Date 23:14 2026/1/30
- * @Param
- * @return
- * @Description 授权异常
- **/
-public class AuthorizationException extends BaseException {
-    public AuthorizationException(ErrorCode errorCode) {
-        super(errorCode);
-    }
-
-    public AuthorizationException(String message) {
-        super(ErrorCode.FORBIDDEN.getCode(), message);
-    }
-}
 \ No newline at end of file
-package com.xly.exception.dto;
-
-import com.xly.constant.ErrorCode;
-
-/***
- * @Author 钱豹
- * @Date 23:13 2026/1/30
- * @Param
- * @return
- * @Description 数据异常
- **/
-public class DataException extends BaseException {
-    public DataException(ErrorCode errorCode) {
-        super(errorCode);
-    }
-
-    public DataException(String message) {
-        super(ErrorCode.DATA_ERROR.getCode(), message);
-    }
-}
 \ No newline at end of file
-package com.xly.exception.sqlexception;
-
-/**
- * NL2SQL根异常
- */
-public class Nl2SqlBaseException extends RuntimeException {
-    public Nl2SqlBaseException(String message) {
-        super(message);
-    }
-
-    public Nl2SqlBaseException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
-package com.xly.exception.sqlexception;
-
-/**
- * SQL执行异常（数据库执行/结果解析失败）
- */
-public class SqlExecuteException extends Nl2SqlBaseException {
-    public SqlExecuteException(String message) {
-        super(message);
-    }
-
-    public SqlExecuteException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
 \ No newline at end of file
-package com.xly.exception.sqlexception;
-
-/**
- * SQL生成异常（@AiService调用失败/生成空SQL）
- */
-public class SqlGenerateException extends Nl2SqlBaseException {
-    public SqlGenerateException(String message) {
-        super(message);
-    }
-
-    public SqlGenerateException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
 \ No newline at end of file
-package com.xly.exception.sqlexception;
-
-/**
- * SQL强校验异常（语法错误/危险关键词/非SELECT语句）
- */
-public class SqlValidateException extends Nl2SqlBaseException {
-    public SqlValidateException(String message) {
-        super(message);
-    }
-
-    public SqlValidateException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
 \ No newline at end of file
-package com.xly.mapper;
-
-import com.xly.entity.ParamRule;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Select;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-@Mapper
-public interface AiToolDetailParamsMapper {
-
-    // XML配置方式
-    @Select("SELECT * FROM ai_tool_detail_params ORDER BY iOrder,iIncrement ")
-    List<ParamRule> findAll();
-}
 \ No newline at end of file
-package com.xly.mapper;
-
-
-import org.apache.ibatis.annotations.Mapper;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-import java.util.Map;
-
-
-@Repository
-@Mapper
-public interface DynamicExeDbMapper {
-
-    /***
-     * @Author 钱豹
-     * @Date 22:43 2026/1/30
-     * @Param []
-     * @return java.util.List<java.util.Map<java.lang.String,java.lang.Object>>
-     * @Description 查询SQL执行
-     **/
-    List<Map<String,Object>> findSql(Map<String,Object> searMap);
-
-    /***
-     * @Author 钱豹
-     * @Date 22:44 2026/1/30
-     * @Param [updMap]
-     * @return void
-     * @Description 更新SQL执行
-     **/
-    void updateSql(Map<String,Object> updMap);
-
-    /***
-     * @Author 钱豹
-     * @Date 22:45 2026/1/30
-     * @Param [updMap]
-     * @return void
-     * @Description 新增SQL执行
-     **/
-    void addSql(Map<String,Object> addMap);
-
-    /****
-     * @Author 钱豹
-     * @Date 22:56 2026/1/30
-     * @Param [delMap]
-     * @return void
-     * @Description 删除QL执行
-     **/
-    void delSql(Map<String,Object> delMap);
-
-
-    /***
-     * @Author 钱豹
-     * @Date 22:45 2026/1/30
-     * @Param
-     * @return
-     * @Description 动态执行过程 并且有返回 执行过程 返回多个数据集 ,默认10个
-     **/
-    List<List<Map<String,Object>>> getCallProMoreResult(Map<String,Object> map);
-
-    /***
-     * @Author 钱豹
-     * @Date 1:41 2026/2/4
-     * @Param [map]
-     * @return java.util.List<java.util.Map<java.lang.String,java.lang.Object>>
-     * @Description 调用过程
-     **/
-    List<Map<String,Object>> getCallPro(Map<String,Object> map);
-
-}
-package com.xly.mapper;
-
-import com.xly.entity.ParamRule;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Select;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-@Mapper
-public interface ParamRuleMapper {
-
-    // XML配置方式
-    @Select("SELECT * FROM ai_tool_detail_params")
-    List<ParamRule> findAll();
-}
 \ No newline at end of file
-package com.xly.mapper;
-
-import com.xly.entity.SceneDto;
-import org.apache.ibatis.annotations.*;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-@Mapper
-public interface SceneMapper {
-
-    // XML配置方式
-    @Select("SELECT * FROM ai_agent order by iOrder")
-    List<SceneDto> findAll();
-}
 \ No newline at end of file
-package com.xly.mapper;
-
-
-import com.xly.entity.ToolMeta;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Select;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-@Mapper
-public interface ToolMetaMapper {
-
-    // XML配置方式
-    @Select("SELECT A.* FROM ai_tool AS A order by iOrder")
-    List<ToolMeta> findAll();
-}
 \ No newline at end of file
-package com.xly.mapper;
-
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-import org.apache.ibatis.annotations.Select;
-import java.util.List;
-import java.util.Map;
-
-@Mapper
-public interface UserSceneSessionMapper {
-
-    /**
-     * 查询用户权限Key列表
-     * @param sUserId 用户ID
-     * @return 权限Key列表
-     */
-    @Select("SELECT J.sKey AS sKey FROM sysjurisdiction AS J JOIN sisjurisdictionclassify AS B ON J.sJurisdictionClassifyId = B.sId WHERE B.sId IN(SELECT U.sJurisdictionClassifyId  FROM sftlogininfojurisdictiongroup AS U WHERE U.sParentId = #{sUserId}) ")
-    List<Map<String, Object>> findUserPermissions(@Param("sUserId") String sUserId);
-
-}
 \ No newline at end of file
-package com.xly.milvus.bean;
-
-import io.milvus.grpc.SearchResultData;
-import io.milvus.response.SearchResultsWrapper;
-import java.util.List;
-
-/**
- * 自定义SearchResultsWrapper，用于访问protected方法
- */
-public class CustomSearchResultsWrapper extends SearchResultsWrapper {
-
-    public CustomSearchResultsWrapper(SearchResultData results) {
-        super(results);
-    }
-
-    /**
-     * 公开访问getOutputFields方法
-     */
-    public List<String> getOutputFieldsPublic() {
-        return super.getOutputFields();
-    }
-}
 \ No newline at end of file
-package com.xly.milvus.bean;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-import java.util.Map;
-
-/**
- * 相似度查询请求实体
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SimilaritySearchRequest {
-    private List<Float> queryVector;        // 查询向量
-    private String queryText;                // 查询文本（如果有文本转向量服务）
-    private Integer topK = 10;                // 返回数量
-    private Double minScore;                  // 最小相似度得分
-    private Double maxScore;                   // 最大相似度得分
-    private String metricType = "IP";          // 距离类型: IP(内积), L2(欧氏距离), COSINE(余弦)
-    private List<String> outputFields;         // 输出字段
-    private Map<String, Object> filter;        // 过滤条件
-    private String partitionName;               // 分区名称
-    private Boolean withScore = true;           // 是否返回得分
-    private Boolean withDistance = false;       // 是否返回距离
-}
 \ No newline at end of file
-package com.xly.milvus.bean;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.Map;
-
-/**
- * 相似度查询结果实体 - 增强版
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SimilaritySearchResult {
-    private Long id;                          // 整数ID
-    private String strId;                      // 字符串ID
-    private Float score;                       // 相似度得分
-    private Double normalizedScore;             // 归一化后的得分（0-1之间）
-    private Map<String, Object> fields;        // 字段数据
-    private String collectionName;              // 集合名称
-
-    /**
-     * 获取ID（优先返回字符串ID，如果没有则返回整数ID）
-     */
-    public String getId() {
-        if (strId != null && !strId.isEmpty()) {
-            return strId;
-        }
-        return id != null ? String.valueOf(id) : null;
-    }
-
-    /**
-     * 获取字段值
-     */
-    public Object getField(String fieldName) {
-        if (fields != null) {
-            return fields.get(fieldName);
-        }
-        return null;
-    }
-
-    /**
-     * 获取字符串字段值
-     */
-    public String getStringField(String fieldName) {
-        Object value = getField(fieldName);
-        return value != null ? value.toString() : null;
-    }
-
-    /**
-     * 获取整数字段值
-     */
-    public Integer getIntField(String fieldName) {
-        Object value = getField(fieldName);
-        if (value instanceof Number) {
-            return ((Number) value).intValue();
-        }
-        return null;
-    }
-}
 \ No newline at end of file
-package com.xly.milvus.config;
-
-import dev.langchain4j.model.embedding.EmbeddingModel;
-import dev.langchain4j.model.embedding.onnx.allminilml6v2.AllMiniLmL6V2EmbeddingModel;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * LangChain4j 嵌入模型配置类
- */
-@Configuration
-public class EmbeddingConfig {
-
-    @Bean
-    public EmbeddingModel embeddingModel() {
-        // 使用 All-MiniLM-L6-v2 嵌入模型
-        // 这是一个轻量级的模型，维度为384，适合在本地运行
-        return new AllMiniLmL6V2EmbeddingModel();
-    }
-}
 \ No newline at end of file
-package com.xly.milvus.config;
-
-import io.milvus.v2.client.ConnectConfig;
-import io.milvus.v2.client.MilvusClientV2;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.retry.annotation.EnableRetry;
-import org.springframework.retry.support.RetryTemplate;
-
-@Slf4j
-@Configuration
-@EnableRetry
-public class MilvusConfig {
-
-    @Value("${milvus.host:localhost}")
-    private String host;
-
-    @Value("${milvus.port:19530}")
-    private Integer port;
-
-    @Value("${milvus.database:default}")
-    private String database;
-
-    @Value("${milvus.username:}")
-    private String username;
-
-    @Value("${milvus.password:}")
-    private String password;
-
-    @Value("${milvus.connect-timeout:10000}")
-    private Long connectTimeout;
-
-    @Value("${milvus.rpc-deadline:10000}")
-    private Long rpcDeadline;
-
-    @Value("${milvus.keep-alive-time:300000}")
-    private Long keepAliveTime;
-
-    @Value("${milvus.keep-alive-timeout:5000}")
-    private Long keepAliveTimeout;
-
-    @Value("${milvus.secure:false}")
-    private Boolean secure;
-
-    @Value("${milvus.validate-on-startup:true}")
-    private boolean validateOnStartup;
-
-    @Value("${milvus.fail-on-connect-error:false}")
-    private boolean failOnConnectError;
-
-    @Value("${milvus.enable-precheck:true}")
-    private boolean enablePrecheck;
-
-    @Bean(destroyMethod = "close")
-    public MilvusClientV2 milvusClient() {
-        try {
-            String uri = String.format("http://%s:%d", host, port);
-            // 构建连接配置
-            ConnectConfig.ConnectConfigBuilder configBuilder = ConnectConfig.builder()
-                    .uri(uri)
-                    .dbName("default")
-                    .connectTimeoutMs(connectTimeout)
-                    .rpcDeadlineMs(rpcDeadline)
-                    .keepAliveTimeMs(keepAliveTime)
-                    .keepAliveTimeoutMs(keepAliveTimeout)
-                    .keepAliveWithoutCalls(true)
-                    .secure(secure)
-                    .enablePrecheck(enablePrecheck);
-
-            // 添加认证信息（如果有）
-            if (username != null && !username.isEmpty()) {
-                configBuilder.username(username);
-                if (password != null) {
-                    configBuilder.password(password);
-                }
-            }
-
-            ConnectConfig connectConfig = configBuilder.build();
-
-            // 创建客户端
-            MilvusClientV2 client = new MilvusClientV2(connectConfig);
-            // 检查xlyerp数据库是否存在，如果不存在则创建
-            var databases = client.listDatabases();
-            if (!databases.getDatabaseNames().contains(database)) {
-                log.info("数据库 xlyerp 不存在，正在创建...");
-                client.createDatabase(
-                        io.milvus.v2.service.database.request.CreateDatabaseReq.builder()
-                                .databaseName(database)
-                                .build()
-                );
-                log.info("数据库 xlyerp 创建成功");
-            }
-
-            // 切换到xlyerp数据库
-            client.useDatabase (database);
-            log.info("切换到数据库: {}",database);
-
-            // 启动验证
-            if (validateOnStartup) {
-                validateConnection(client);
-            }
-            return client;
-        } catch (Exception e) {
-            log.error("创建Milvus客户端时发生异常: {}", e.getMessage(), e);
-            throw new RuntimeException("无法创建Milvus客户端", e);
-        }
-
-    }
-
-    /**
-     * 验证Milvus连接 - 基于源码中可用的方法
-     */
-    private void validateConnection(MilvusClientV2 client) {
-        try {
-            // 方法1: 检查服务器版本（源码中存在getServerVersion()）
-            String serverVersion = client.getServerVersion();
-
-            // 方法2: 列出数据库（源码中存在listDatabases()）
-            var databases = client.listDatabases();
-
-            // 方法3: 检查健康状态（源码中存在checkHealth()）
-            var health = client.checkHealth();
-
-            System.out.println("✅ Milvus连接成功");
-            System.out.println("   - 服务器版本: " + serverVersion);
-            System.out.println("   - 数据库: " + databases);
-            System.out.println("   - 健康状态: " + health);
-
-            // 验证指定数据库是否存在
-            if (database != null && !database.isEmpty()) {
-                boolean dbExists = databases.getDatabaseNames().contains(database);
-                if (!dbExists && !"default".equals(database)) {
-                    System.err.println("⚠️ 警告: 指定数据库 '" + database + "' 不存在");
-                }
-            }
-
-        } catch (Exception e) {
-            String errorMsg = String.format("❌ Milvus连接失败: %s:%d - %s",host, port, e.getMessage());
-
-            if (failOnConnectError) {
-                throw new IllegalStateException(errorMsg, e);
-            } else {
-                System.err.println(errorMsg);
-                System.err.println("   ⚠️ 应用将继续启动，但Milvus功能可能不可用");
-            }
-        }
-    }
-
-    /**
-     * 配置重试模板（可选）
-     */
-    @Bean
-    public RetryTemplate milvusRetryTemplate() {
-        return RetryTemplate.builder()
-                .maxAttempts(3)
-                .exponentialBackoff(1000, 2, 10000)
-                .retryOn(Exception.class)
-                .build();
-    }
-}
 \ No newline at end of file
-package com.xly.milvus.config;
-
-import io.milvus.v2.client.MilvusClientV2;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.actuate.health.Health;
-import org.springframework.boot.actuate.health.HealthIndicator;
-import org.springframework.stereotype.Component;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Component
-public class MilvusHealthIndicator implements HealthIndicator {
-
-    @Autowired(required = false)
-    private MilvusClientV2 milvusClient;
-
-    @Override
-    public Health health() {
-        if (milvusClient == null) {
-            return Health.down()
-                    .withDetail("error", "Milvus客户端未初始化")
-                    .build();
-        }
-
-        try {
-            // 检查客户端是否就绪（源码中存在clientIsReady()）
-            boolean isReady = milvusClient.clientIsReady();
-
-            if (!isReady) {
-                return Health.down()
-                        .withDetail("error", "客户端未就绪")
-                        .build();
-            }
-
-            long startTime = System.currentTimeMillis();
-
-            // 执行健康检查 - 使用源码中存在的方法
-            String serverVersion = milvusClient.getServerVersion();
-            var databases = milvusClient.listDatabases();
-            var healthCheck = milvusClient.checkHealth();
-
-            long responseTime = System.currentTimeMillis() - startTime;
-
-            Map<String, Object> details = new HashMap<>();
-            details.put("serverVersion", serverVersion);
-            details.put("database", milvusClient.currentUsedDatabase());
-            details.put("databases", databases.getDatabaseNames());
-            details.put("healthStatus", healthCheck.getIsHealthy());
-            details.put("responseTime", responseTime + "ms");
-            details.put("clientReady", isReady);
-
-            if (healthCheck.getQuotaStates() != null) {
-                details.put("quotaStates", healthCheck.getQuotaStates());
-            }
-
-            return Health.up()
-                    .withDetails(details)
-                    .build();
-
-        } catch (Exception e) {
-            return Health.down()
-                    .withDetail("error", e.getMessage())
-                    .withDetail("clientReady", milvusClient.clientIsReady())
-                    .build();
-        }
-    }
-}
 \ No newline at end of file
-package com.xly.milvus.config;
-
-import io.milvus.v2.client.RetryConfig;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-public class MilvusRetryConfig {
-
-    @Value("${milvus.retry.max-retry-times:75}")
-    private int maxRetryTimes;
-
-    @Value("${milvus.retry.initial-backoff-ms:10}")
-    private long initialBackOffMs;
-
-    @Value("${milvus.retry.max-backoff-ms:3000}")
-    private long maxBackOffMs;
-
-    @Value("${milvus.retry.backoff-multiplier:3}")
-    private int backOffMultiplier;
-
-    @Value("${milvus.retry.retry-on-rate-limit:true}")
-    private boolean retryOnRateLimit;
-
-    @Value("${milvus.retry.max-retry-timeout-ms:0}")
-    private long maxRetryTimeoutMs;
-
-    @Value("${milvus.retry.enabled:true}")
-    private boolean retryEnabled;
-
-    /**
-     * 方法名改为 createRetryConfig，避免与类名冲突
-     */
-    @Bean
-    public RetryConfig createRetryConfig() {
-        if (!retryEnabled) {
-            return RetryConfig.builder()
-                    .maxRetryTimes(1)
-                    .initialBackOffMs(0)
-                    .maxBackOffMs(0)
-                    .backOffMultiplier(1)
-                    .retryOnRateLimit(false)
-                    .maxRetryTimeoutMs(0)
-                    .build();
-        }
-
-        return RetryConfig.builder()
-                .maxRetryTimes(maxRetryTimes)
-                .initialBackOffMs(initialBackOffMs)
-                .maxBackOffMs(maxBackOffMs)
-                .backOffMultiplier(backOffMultiplier)
-                .retryOnRateLimit(retryOnRateLimit)
-                .maxRetryTimeoutMs(maxRetryTimeoutMs)
-                .build();
-    }
-}
 \ No newline at end of file
-package com.xly.milvus.config;
-
-import io.milvus.v2.client.MilvusClientV2;
-import io.milvus.v2.service.collection.request.HasCollectionReq;
-import lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.boot.ApplicationArguments;
-import org.springframework.boot.ApplicationRunner;
-import org.springframework.core.annotation.Order;
-import org.springframework.stereotype.Component;
-
-import java.util.List;
-
-@Slf4j
-@Component
-@Order(1)
-public class MilvusStartupValidator implements ApplicationRunner {
-
-    @Autowired
-    private MilvusClientV2 milvusClient;
-
-    @Value("${milvus.validation.collections:}")
-    private List<String> validationCollections;
-
-    @Value("${milvus.validation.timeout:5000}")
-    private long validationTimeout;
-
-    @Override
-    public void run(ApplicationArguments args) throws Exception {
-        log.info("开始Milvus启动验证...");
-
-        try {
-            // 1. 验证客户端就绪状态
-            boolean isReady = milvusClient.clientIsReady();
-            log.info("客户端就绪状态: {}", isReady);
-
-            // 2. 获取服务器版本
-            String serverVersion = milvusClient.getServerVersion();
-            log.info("Milvus服务器版本: {}", serverVersion);
-
-            // 3. 列出所有数据库
-            var databases = milvusClient.listDatabases();
-            log.info("可用数据库: {}", databases.getDatabaseNames());
-
-            // 4. 检查当前使用的数据库
-            String currentDb = milvusClient.currentUsedDatabase();
-            log.info("当前数据库: {}", currentDb);
-
-            // 5. 健康检查
-            var healthCheck = milvusClient.checkHealth();
-            log.info("健康状态: {}", healthCheck.getIsHealthy());
-            if (healthCheck.getQuotaStates() != null && !healthCheck.getQuotaStates().isEmpty()) {
-                log.info("配额状态: {}", healthCheck.getQuotaStates());
-            }
-
-            // 6. 验证指定的集合（可选）
-            if (validationCollections != null && !validationCollections.isEmpty()) {
-                for (String collectionName : validationCollections) {
-                    boolean exists = milvusClient.hasCollection(
-                            HasCollectionReq.builder()
-                                    .collectionName(collectionName)
-                                    .build()
-                    );
-                    log.info("集合 '{}' 存在: {}", collectionName, exists);
-                }
-            }
-
-            log.info("Milvus启动验证完成");
-
-        } catch (Exception e) {
-            log.error("Milvus启动验证失败: {}", e.getMessage(), e);
-            // 可以根据配置决定是否抛出异常
-            // throw new RuntimeException("Milvus验证失败", e);
-        }
-    }
-}
 \ No newline at end of file
-package com.xly.milvus.config;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.Map;
-
-/**
- * 搜索结果实体
- */
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SearchResult {
-    private Long id;
-    private Float score;
-    private Map<String, Object> fields;
-    private String collectionName;
-}
 \ No newline at end of file
-package com.xly.milvus.service;
-
-
-import java.util.Map;
-
-public interface AiGlobalAgentQuestionSqlEmitterService {
-
-    /***
-     * @Author 钱豹
-     * @Date 15:27 2026/3/19
-     * @Param [data, sQuestion, sSqlContent, collectionName]
-     * @return void
-     * @Description 插入向量库
-     **/
-    void addAiGlobalAgentQuestionSqlEmitter(String sKey,Map<String,Object>  data,String sQuestion,String sSqlContent,String cachType,String collectionName,Boolean isInit);
-
-
-    Map<String, Object> queryAiGlobalAgentQuestionSqlEmitter(String searchText, String collectionName);
-
-    void removeAndCreateCollection(String collectionName);
-}
 \ No newline at end of file
-package com.xly.milvus.service;
-
-import java.util.List;
-
-public interface EmbeddingService {
-
-    /**
-     * 生成单个文本的向量
-     */
-    public List<Float> generateEmbedding(String text);
-
-    /**
-     * 批量生成向量（高效版）
-     * 利用 LangChain4j 内置的并行化能力，显著提升性能
-     */
-    public List<List<Float>> generateEmbeddings(List<String> texts);
-}
 \ No newline at end of file
-package com.xly.milvus.service;
-
-import com.xly.tts.bean.TTSResponseDTO;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 向量化服务接口
- */
-public interface MilvusService {
-
-    /***
-     * @Author 钱豹
-     * @Date 22:17 2026/3/24
-     * @Param
-     * @return
-     * @Description 初始化数据
-     **/
-
-    TTSResponseDTO initDataToMilvus(Map<String, Object> reqMap);
-
-    /***
-     * @Author 钱豹
-     * @Date 9:00 2026/4/1
-     * @Param [reqMap]
-     * @return com.xly.tts.bean.TTSResponseDTO
-     * @Description 客户问题库转入全局问题库
-     **/
-    TTSResponseDTO addGlobalAgentQuestion(Map<String, Object> reqMap);
-
-    /***
-     * @Author 钱豹
-     * @Date 9:28 2026/4/1
-     * @Param [reqMap]
-     * @return com.xly.tts.bean.TTSResponseDTO
-     * @Description 初始化全局SQL进入向量库
-     **/
-    TTSResponseDTO initGlobalAgentQuestion(Map<String, Object> reqMap);
-
-
-    /**
-     * 创建集合（如果不存在）
-     */
-    void createCollectionIfNotExists(String collectionName, String sVectorfiled, String sVectorjson, Boolean bRset);
-
-
-    /***
-     * @Author 钱豹
-     * @Date 21:39 2026/3/24
-     * @Param [collectionName, sVectorfiled, sVectorjson, data]
-     * @return long
-     * @Description 批量插入数据
-     **/
-    long addDataToCollection(String collectionName, String sVectorfiled, String sVectorjson, List<Map<String, Object>> data,String sceneName);
-
-    /***
-     * @Author 钱豹
-     * @Date 10:39 2026/3/25
-     * @Param
-     * @return
-     * @Description 向量库查询
-     **/
-    List<Map<String, Object>> getDataToCollection(String collectionName, String milvusFilter,String searchText,Integer size,List<String> fields,String vectorValue,String sceneName);
-
-    /***
-     * @Author 钱豹
-     * @Date 10:56 2026/3/25
-     * @Param [sVectorfiled]
-     * @return java.util.Map<java.lang.String,java.lang.Object>
-     * @Description 获取配置
-     **/
-    Map<String,Object> getMilvusFiled(String sVectorfiled,String sVectorfiledAll,String sVectorfiledShow,String sVectorjson);
-
-    boolean isStringFilterValid(String filter,String collectionName);
-}
 \ No newline at end of file
-package com.xly.milvus.service;
-
-import java.util.List;
-
-/**
- * 向量化服务接口
- */
-public interface VectorizationService {
-
-    /**
-     * 将文本向量化
-     * @param text 文本内容
-     * @return 向量数组
-     */
-    List<Float> textToVector(String text);
-
-    /**
-     * 批量向量化
-     * @param texts 文本列表
-     * @return 向量列表
-     */
-    List<List<Float>> batchTextToVector(List<String> texts);
-}
 \ No newline at end of file