780 lines
26 KiB
Go
780 lines
26 KiB
Go
package service
|
||
|
||
// ========================================================================
|
||
// ReactLoop —— 完整 ReAct 循环（Planning + Reflection + JSON 自修复）
|
||
// ========================================================================
|
||
// 本模块是 EnhanceService 的"增强路径"，独立于 agent.Runner。
|
||
//
|
||
// 为什么不复用 agent.Runner.Run：
|
||
// 1. Runner.Run 是按 sessionID 操作的（带会话管理、并发清理协程），
|
||
// 而 EnhanceService 是"无状态一次性请求"，没有 session 概念；
|
||
// 2. Runner.Run 只返回最终文本，无法返回步骤明细（token/耗时/思考过程），
|
||
// 而我们需要把每一步落到 xk_ai_generation_step 子表；
|
||
// 3. Runner.Run 没有预算管理、没有 Reflection、没有 JSON 修复。
|
||
//
|
||
// 本循环的执行步骤（每一步都生成 EnhanceStep 落表）：
|
||
// [1] Planning（可选）：让模型先输出 plan JSON
|
||
// [2] 多轮 Think-Act-Observe：
|
||
// for i := 0; i < maxIter; i++ {
|
||
// budget 检查（超限中止）
|
||
// LLM 调用（带 tools，可触发 Function Calling）
|
||
// 累加 token，写 llm_call step
|
||
// 若触发工具 → 执行 → 工具结果入栈 → continue
|
||
// 否则进入 Reflection
|
||
// }
|
||
// [3] Reflection（可选）：让模型自检输出（温度更低）
|
||
// [4] JSON 修复（可选）：JSON 不合法时让模型修复
|
||
//
|
||
// 设计原则：
|
||
// - 任一步骤失败都不中断整体（除非超预算或 ctx 取消）
|
||
// - 所有 LLM 调用都通过 TokenBudget 控制
|
||
// - 步骤明细实时累加到 resp.Steps（即使中途失败也要返回已生成的部分）
|
||
// ========================================================================
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"strings"
|
||
"time"
|
||
|
||
"tcm-agent/internal/agent"
|
||
"tcm-agent/internal/agentcfg"
|
||
"tcm-agent/internal/llm"
|
||
"tcm-agent/internal/types"
|
||
)
|
||
|
||
// ------------------------------------------------------------------
|
||
// 入参与返回结构
|
||
// ------------------------------------------------------------------
|
||
|
||
// ReactLoopRequest ReactLoop 的一次调用入参
|
||
//
|
||
// 与 EnhanceRequest 区别：
|
||
// - Messages 已注入 KB 检索结果（KB 步骤已由 EnhancerService 完成）
|
||
// - Tools 是可选的（若客户端模型不支持 Function Calling，传 nil 走纯 chat）
|
||
// - Client 已通过 resolveClient 解析好（避免 ReactLoop 重复解析）
|
||
type ReactLoopRequest struct {
|
||
Scene string // 场景（仅用于日志/step 记录）
|
||
Messages []types.Message // 注入 KB 后的消息列表（会被本循环修改）
|
||
Tools []types.Tool // 可用工具集（可空）
|
||
Client llm.LLMClient // 已解析的 LLM 客户端
|
||
Provider string // 客户端对应的 provider 名
|
||
// Temperature 主生成温度覆盖（PHP 按场景显式传入时 >0）；
|
||
// 只影响主生成调用，Planning/Reflection/JSON 修复仍用各自的低温配置
|
||
Temperature float64
|
||
}
|
||
|
||
// ReactLoopResult ReactLoop 的执行结果
|
||
type ReactLoopResult struct {
|
||
Content string // 最终生成内容（最后一次 LLM 返回的文本）
|
||
Steps []EnhanceStep // 全部步骤明细（Planning + 多轮 Chat + Reflection + JSON 修复）
|
||
Aborted bool // 是否因预算超限而中止（true 时 Content 仍是已生成部分）
|
||
Budget agent.BudgetSnapshot // 预算使用快照
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// ReactLoop 主体
|
||
// ------------------------------------------------------------------
|
||
|
||
// runReactLoop 执行完整 ReAct 循环
|
||
//
|
||
// 调用方：EnhancerService.Enhance（仅在 agentcfg.ReAct.Enabled=true 时调用）
|
||
//
|
||
// 参数：
|
||
// - ctx - 请求上下文（支持超时取消）
|
||
// - req - 循环入参（messages/client/tools 已就绪）
|
||
// - reactCfg - ReAct 配置（maxIter/Planning/Reflection 等，来自 agentcfg）
|
||
// - budgetCfg - Token 预算配置（用于创建 budget 累加器）
|
||
//
|
||
// 返回：循环结果（含步骤明细 + 最终内容）
|
||
func (s *EnhancerService) runReactLoop(
|
||
ctx context.Context,
|
||
req *ReactLoopRequest,
|
||
reactCfg agentcfg.ReActConfig,
|
||
budgetCfg agentcfg.TokenBudgetConfig,
|
||
) *ReactLoopResult {
|
||
result := &ReactLoopResult{Steps: []EnhanceStep{}}
|
||
|
||
// 创建 Token 预算器（limit=0 表示不限制，按配置决定）
|
||
var limit int
|
||
if budgetCfg.Enabled {
|
||
limit = budgetCfg.PerRequest
|
||
}
|
||
budget := agent.NewTokenBudget(limit, budgetCfg.MaxTokensPerCall)
|
||
|
||
// 消息快照（循环内修改的是这份拷贝，不污染调用方原 messages）
|
||
messages := make([]types.Message, len(req.Messages))
|
||
copy(messages, req.Messages)
|
||
|
||
// ===== [1] Planning 阶段（可选） =====
|
||
if reactCfg.PlanningEnabled {
|
||
planStep := s.doPlanning(ctx, req, reactCfg, budget, &messages)
|
||
result.Steps = append(result.Steps, planStep)
|
||
if budget.IsExceeded() {
|
||
result.Aborted = true
|
||
result.Budget = budget.Snapshot()
|
||
return result
|
||
}
|
||
}
|
||
|
||
// ===== [2] Think-Act-Observe 多轮循环 =====
|
||
maxIter := reactCfg.MaxIterations
|
||
if maxIter < 1 {
|
||
maxIter = 3
|
||
}
|
||
|
||
var lastContent string
|
||
var lastProvider = req.Provider
|
||
var lastModel = req.Client.Name()
|
||
|
||
for i := 0; i < maxIter; i++ {
|
||
// 预算检查（超限立即中止，返回已生成的部分）
|
||
if budget.IsExceeded() {
|
||
result.Aborted = true
|
||
log.Printf("[ReactLoop] scene=%s 预算超限中止 at iter=%d used=%d limit=%d",
|
||
req.Scene, i, budget.Used(), limit)
|
||
break
|
||
}
|
||
|
||
// 计算本次调用 max_tokens（取 min(配置单次上限, 剩余预算)）
|
||
maxTokens := budget.CalcMaxTokensForCall(budgetCfg.MaxTokensPerCall)
|
||
// 主生成温度：PHP 按场景显式指定时优先（处方 0.3→可调低），否则用默认 0.3
|
||
mainTemp := 0.3
|
||
if req.Temperature > 0 {
|
||
mainTemp = req.Temperature
|
||
}
|
||
opts := llm.ChatOpts{
|
||
MaxTokens: maxTokens,
|
||
Temperature: mainTemp,
|
||
}
|
||
|
||
// 调用 LLM（带工具）
|
||
callStep := s.callLLMOnce(ctx, req, opts, messages, "llm_call")
|
||
result.Steps = append(result.Steps, callStep)
|
||
|
||
// 累加预算
|
||
budget.Consume(callStep.PromptTokens, callStep.CompletionTokens)
|
||
|
||
if callStep.Status != 1 {
|
||
// 调用失败：直接返回（上层决定要不要走降级）
|
||
break
|
||
}
|
||
|
||
// 取 LLM 实际返回的 Message（callLLMOnce 已通过 LastChatResult 拿到 token，
|
||
// 这里要拿 Message 内容 + ToolCall 信息）
|
||
llmMsg := callStep.lastMessage
|
||
if llmMsg == nil {
|
||
break
|
||
}
|
||
lastContent = llmMsg.Content
|
||
lastProvider = req.Provider
|
||
lastModel = req.Client.Name()
|
||
|
||
// 触发工具调用 → 执行工具 → 工具结果入栈 → 进入下一轮
|
||
if llmMsg.ToolCall != nil {
|
||
toolStep := s.executeToolCall(ctx, llmMsg.ToolCall)
|
||
result.Steps = append(result.Steps, toolStep)
|
||
|
||
// 【协议正确性】assistant 帧 + tool 帧都入栈（与 runner.go 修复一致）
|
||
// tool 帧必须带 ToolCallID 与 assistant 帧 tool_calls[].id 对应，
|
||
// 否则 OpenAI 协议厂商（讯飞/DeepSeek）会拒绝下一轮请求
|
||
messages = append(messages, *llmMsg)
|
||
messages = append(messages, types.Message{
|
||
Role: "tool",
|
||
Content: toolStep.Detail,
|
||
ToolCallID: llmMsg.ToolCall.ID,
|
||
Timestamp: time.Now().Unix(),
|
||
})
|
||
continue
|
||
}
|
||
|
||
// 未触发工具：本轮就是最终答案，跳出循环进入 Reflection
|
||
break
|
||
}
|
||
|
||
// ===== [3] Reflection 阶段（可选） =====
|
||
if reactCfg.ReflectionEnabled && lastContent != "" && !budget.IsExceeded() {
|
||
reflectStep, reflectOK := s.doReflection(ctx, req, reactCfg, budgetCfg, budget, lastContent)
|
||
result.Steps = append(result.Steps, reflectStep)
|
||
// 反思未通过：把反思详情放到 lastContent 末尾，让用户看到模型自检结果
|
||
if !reflectOK && reflectStep.Detail != "" {
|
||
lastContent += "\n\n[反思反馈] " + reflectStep.Detail
|
||
}
|
||
}
|
||
|
||
// ===== [4] JSON 修复（可选） =====
|
||
if reactCfg.JSONRepairEnabled && lastContent != "" {
|
||
repaired, repairStep := s.repairJSONIfNeeded(ctx, req, reactCfg, budget, lastContent)
|
||
if repairStep != nil {
|
||
result.Steps = append(result.Steps, *repairStep)
|
||
if repaired != "" {
|
||
lastContent = repaired
|
||
}
|
||
}
|
||
}
|
||
|
||
result.Content = lastContent
|
||
_ = lastProvider
|
||
_ = lastModel
|
||
result.Budget = budget.Snapshot()
|
||
return result
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// [1] Planning 阶段
|
||
// ------------------------------------------------------------------
|
||
|
||
// doPlanning 让模型先输出任务计划（先查什么 → 再查什么 → 最后生成）
|
||
//
|
||
// 设计目的：
|
||
// - 让模型在"消耗大量 token 之前"先规划清楚步骤
|
||
// - 复杂任务（如开中药处方）效果显著：模型可能意识到要"先查 18 反禁忌"
|
||
// - 计划本身也作为 step 落表，运维可以审计
|
||
//
|
||
// prompt 策略：
|
||
// - 单独一次 LLM 调用，只产出 plan，不让它真的执行
|
||
// - 用低温度（0.15）+ 强约束 prompt，避免计划发散
|
||
func (s *EnhancerService) doPlanning(
|
||
ctx context.Context,
|
||
req *ReactLoopRequest,
|
||
reactCfg agentcfg.ReActConfig,
|
||
budget *agent.TokenBudget,
|
||
messages *[]types.Message,
|
||
) EnhanceStep {
|
||
step := EnhanceStep{
|
||
StepType: "plan",
|
||
StartedAt: time.Now().Unix(),
|
||
}
|
||
start := time.Now()
|
||
|
||
// 构造规划 prompt：复用业务 system + 追加"请先输出计划"指令
|
||
//
|
||
// 【prompt 锚定】明确提示"这是医疗任务"，避免轻量模型（spark-lite 等）
|
||
// 把"执行计划"模式匹配成"软件项目管理计划"套话（已实际发生过的跑题案例）
|
||
planPrompt := "【Planning 阶段】你正在处理一个中医/医疗任务（见上面的 system 与用户消息）。" +
|
||
"请基于该医疗任务输出一个简短的执行计划（不超过 5 步，每步一句话，" +
|
||
"说明你打算查什么医学知识/做什么医疗判断，例如：先辨证、查配伍禁忌、再组方）。" +
|
||
"计划必须紧扣上面的医疗任务本身，不要输出通用的项目管理步骤。" +
|
||
"不要执行任务，只输出计划。"
|
||
|
||
tryMessages := append([]types.Message{}, *messages...)
|
||
tryMessages = append(tryMessages, types.Message{
|
||
Role: "user",
|
||
Content: planPrompt,
|
||
Timestamp: time.Now().Unix(),
|
||
})
|
||
|
||
opts := llm.ChatOpts{
|
||
MaxTokens: budget.CalcMaxTokensForCall(512), // 计划阶段最多 512 token
|
||
Temperature: 0.15, // 低温保证稳定
|
||
}
|
||
msg, chatResult := s.callLLMWithMeta(ctx, req.Client, tryMessages, nil, opts)
|
||
|
||
step.DurationMs = int(time.Since(start).Milliseconds())
|
||
step.FinishedAt = time.Now().Unix()
|
||
step.Provider = req.Provider
|
||
step.Model = req.Client.Name()
|
||
|
||
if msg == nil || msg.Content == "" {
|
||
step.Status = 2
|
||
step.Detail = "Planning 调用失败"
|
||
if chatResult != nil {
|
||
budget.Consume(chatResult.PromptTokens, chatResult.CompletionTokens)
|
||
step.PromptTokens = chatResult.PromptTokens
|
||
step.CompletionTokens = chatResult.CompletionTokens
|
||
step.TotalTokens = chatResult.TotalTokens
|
||
}
|
||
return step
|
||
}
|
||
|
||
// 累加预算
|
||
if chatResult != nil {
|
||
budget.Consume(chatResult.PromptTokens, chatResult.CompletionTokens)
|
||
step.PromptTokens = chatResult.PromptTokens
|
||
step.CompletionTokens = chatResult.CompletionTokens
|
||
step.TotalTokens = chatResult.TotalTokens
|
||
step.Usage = chatResult.Usage
|
||
}
|
||
|
||
// ===== 计划跑题检测：只有命中医疗白名单的计划才允许注入 =====
|
||
//
|
||
// 为什么用白名单制（而不是"没命中黑名单就放行"）：
|
||
// 轻量模型可能输出既无医疗词也无黑名单词的泛泛计划（如"1.收集信息 2.分析 3.输出"），
|
||
// 这种计划注入后同样会稀释医疗任务焦点、污染后续生成
|
||
// （实际案例：plan 跑题成项目管理 → 最终处方输出也变成了项目管理步骤）。
|
||
// 丢弃计划无副作用：step 记录保留（status=2 便于后台审计），主循环按无计划模式继续。
|
||
planGuard := validateMedicalRelevance([]types.Message{{Content: msg.Content}})
|
||
if len(planGuard.HitWhitelist) == 0 {
|
||
log.Printf("[ReactLoop] ⚠️ scene=%s Planning 输出未命中任何医疗关键词已丢弃（命中非医疗词=%v），主循环按无计划模式继续",
|
||
req.Scene, planGuard.HitBlacklist)
|
||
step.Status = 2
|
||
step.Detail = "计划跑题已丢弃: " + truncateForLog(msg.Content, 200)
|
||
return step
|
||
}
|
||
|
||
// ===== 把计划追加到对话历史，让后续主循环能参考 =====
|
||
//
|
||
// 【关键约定】messages 序列最后必须是 user 角色才能让下一次 LLM 调用生效。
|
||
// 之前直接把 plan 当 assistant 帧追加，导致序列以 assistant 结尾，
|
||
// 触发讯飞 Lite "10003 用户的消息格式有错误"（Pro/Max 宽松，Lite 严格）。
|
||
//
|
||
// 正确做法：
|
||
// 1) 先把 plan 当 user 帧（标明是"计划"内容）追加 → 让 LLM 知道计划是什么
|
||
// 2) 再追加一个 user 帧作为"执行指令" → 保证最后一条是 user
|
||
*messages = append(*messages, types.Message{
|
||
Role: "user",
|
||
Content: "[Planning 阶段输出的计划]\n" + msg.Content,
|
||
Timestamp: time.Now().Unix(),
|
||
})
|
||
*messages = append(*messages, types.Message{
|
||
Role: "user",
|
||
Content: "【执行阶段】请严格按照上述计划完成最初的医疗任务，并按 system 要求的格式输出最终结果。",
|
||
Timestamp: time.Now().Unix(),
|
||
})
|
||
|
||
step.Status = 1
|
||
step.Detail = "计划: " + truncateForLog(msg.Content, 200)
|
||
return step
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// [2] 单次 LLM 调用（带预算与 step 记录）
|
||
// ------------------------------------------------------------------
|
||
|
||
// callLLMOnce 调用一次 LLM，包装成 EnhanceStep（含 token 统计）
|
||
//
|
||
// 调用方：runReactLoop 主循环
|
||
func (s *EnhancerService) callLLMOnce(
|
||
ctx context.Context,
|
||
req *ReactLoopRequest,
|
||
opts llm.ChatOpts,
|
||
messages []types.Message,
|
||
stepType string,
|
||
) EnhanceStep {
|
||
step := EnhanceStep{
|
||
StepType: stepType,
|
||
StartedAt: time.Now().Unix(),
|
||
}
|
||
start := time.Now()
|
||
|
||
msg, chatResult := s.callLLMWithMeta(ctx, req.Client, messages, req.Tools, opts)
|
||
|
||
step.DurationMs = int(time.Since(start).Milliseconds())
|
||
step.FinishedAt = time.Now().Unix()
|
||
step.Provider = req.Provider
|
||
step.Model = req.Client.Name()
|
||
step.lastMessage = msg
|
||
|
||
if chatResult != nil {
|
||
step.PromptTokens = chatResult.PromptTokens
|
||
step.CompletionTokens = chatResult.CompletionTokens
|
||
step.TotalTokens = chatResult.TotalTokens
|
||
step.Usage = chatResult.Usage
|
||
step.APIKeyID = chatResult.APIKeyID
|
||
}
|
||
|
||
if msg == nil {
|
||
step.Status = 2
|
||
step.Detail = "LLM 返回空"
|
||
return step
|
||
}
|
||
|
||
step.Status = 1
|
||
if msg.ToolCall != nil {
|
||
step.Detail = fmt.Sprintf("触发工具调用: %s", msg.ToolCall.ToolName)
|
||
} else {
|
||
step.Detail = "成功 | finish_reason=" + chatResult.FinishReason
|
||
}
|
||
return step
|
||
}
|
||
|
||
// callLLMWithMeta 调用 LLM 并提取 token 元数据（统一入口）
|
||
//
|
||
// 策略：
|
||
// 1. 若客户端实现 OptAwareClient（DeepSeek/Spark/OpenAI）→ 用 ChatWithOpts 透传参数
|
||
// 2. 否则回落到 LLMClient.Chat
|
||
// 3. 若客户端实现 TokenAwareClient → 取 LastChatResult 拿 token/finish_reason
|
||
func (s *EnhancerService) callLLMWithMeta(
|
||
ctx context.Context,
|
||
client llm.LLMClient,
|
||
messages []types.Message,
|
||
tools []types.Tool,
|
||
opts llm.ChatOpts,
|
||
) (*types.Message, *types.ChatResult) {
|
||
var (
|
||
msg *types.Message
|
||
err error
|
||
)
|
||
|
||
// 单次调用的闭包（优先用 ChatWithOpts）
|
||
doCall := func() (*types.Message, error) {
|
||
if optClient, ok := client.(llm.OptAwareClient); ok {
|
||
return optClient.ChatWithOpts(ctx, messages, tools, opts)
|
||
}
|
||
return client.Chat(ctx, messages, tools)
|
||
}
|
||
|
||
msg, err = doCall()
|
||
|
||
// ---------- 稳定性加固：网络类错误自动重试 1 次 ----------
|
||
// 只重试瞬时网络抖动（连接失败/超时/reset），不重试业务错误（4xx/5xx API 返回）：
|
||
// - 业务错误重试大概率还是失败，白白双倍消耗 token 配额
|
||
// - 网络抖动重试一次通常就能恢复，显著提升单点抖动下的成功率
|
||
// 间隔 1s：给对端 LB/连接池一个恢复窗口，也避免瞬间重试风暴
|
||
if err != nil && isRetryableNetworkError(err) && ctx.Err() == nil {
|
||
log.Printf("[Enhancer] LLM 网络类错误，1s 后自动重试 1 次: %v", err)
|
||
select {
|
||
case <-time.After(1 * time.Second):
|
||
msg, err = doCall()
|
||
case <-ctx.Done():
|
||
// 上游已取消（如客户端断开），不再重试
|
||
}
|
||
}
|
||
|
||
if err != nil {
|
||
log.Printf("[Enhancer] LLM 调用失败: %v", err)
|
||
return nil, nil
|
||
}
|
||
|
||
// 尝试取 token 用量（DeepSeek/Spark 实现 TokenAwareClient）
|
||
var chatResult *types.ChatResult
|
||
if tac, ok := client.(llm.TokenAwareClient); ok {
|
||
chatResult = tac.LastChatResult()
|
||
}
|
||
if chatResult == nil {
|
||
chatResult = &types.ChatResult{}
|
||
}
|
||
return msg, chatResult
|
||
}
|
||
|
||
// isRetryableNetworkError 判断 LLM 调用错误是否属于「可重试的网络类错误」
|
||
//
|
||
// 判定思路：LLM 客户端返回的错误是 fmt.Errorf 包装的字符串，
|
||
// 无法用 errors.Is 精确匹配，只能按错误文案特征识别。
|
||
// 白名单只收纯网络故障（连接/超时/reset），凡是「API 返回 xxx」
|
||
// 这种服务端已给出响应的业务错误一律不重试，避免双倍烧 token。
|
||
func isRetryableNetworkError(err error) bool {
|
||
if err == nil {
|
||
return false
|
||
}
|
||
s := strings.ToLower(err.Error())
|
||
// 服务端已返回明确响应（业务错误），不属于网络抖动
|
||
if strings.Contains(s, "api 返回") {
|
||
return false
|
||
}
|
||
// 常见网络故障特征（Go net/http 错误文案）
|
||
networkHints := []string{
|
||
"timeout", "deadline exceeded", // 超时
|
||
"connection refused", "connection reset", // 连接被拒/被重置
|
||
"broken pipe", "unexpected eof", "eof", // 传输中断
|
||
"no such host", "dial tcp", // DNS/建连失败
|
||
"tls handshake", // TLS 握手失败
|
||
"请求失败", // 客户端封装的通用请求失败前缀
|
||
}
|
||
for _, hint := range networkHints {
|
||
if strings.Contains(s, hint) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// [3] Reflection 阶段
|
||
// ------------------------------------------------------------------
|
||
|
||
// doReflection 让模型自检生成结果是否合格
|
||
//
|
||
// prompt 策略：
|
||
// - 用更低温度（reactCfg.ReflectionTemperature，默认 0.2）
|
||
// - 强约束输出：要求模型回答"合格"或"不合格 + 原因"
|
||
// - 用预算的剩余部分作为 max_tokens，避免反思膨胀
|
||
//
|
||
// 返回：
|
||
// - EnhanceStep：反思过程记录
|
||
// - bool：是否合格（true=通过，false=不通过，调用方可决定是否重试）
|
||
func (s *EnhancerService) doReflection(
|
||
ctx context.Context,
|
||
req *ReactLoopRequest,
|
||
reactCfg agentcfg.ReActConfig,
|
||
budgetCfg agentcfg.TokenBudgetConfig,
|
||
budget *agent.TokenBudget,
|
||
generatedContent string,
|
||
) (EnhanceStep, bool) {
|
||
step := EnhanceStep{
|
||
StepType: "reflection",
|
||
StartedAt: time.Now().Unix(),
|
||
}
|
||
start := time.Now()
|
||
|
||
// 构造反思 prompt：让模型扮演"审核者"角色
|
||
reflectPrompt := fmt.Sprintf(
|
||
"【Reflection 反思阶段】请对以下 AI 生成内容进行严格审核：\n\n"+
|
||
"---\n%s\n---\n\n"+
|
||
"审核标准：\n"+
|
||
"1. 是否有医学常识性错误（剂量、配伍禁忌、诊断矛盾）\n"+
|
||
"2. 是否漏掉关键字段（处方缺剂量/用法；病历缺主诉对应诊断）\n"+
|
||
"3. 是否符合中文医疗文案规范（无歧义、无营销用语）\n\n"+
|
||
"输出格式：第一行必须是「合格」或「不合格」；如果不合格，第二行起说明原因。\n"+
|
||
"不要重新生成内容，只做审核。",
|
||
generatedContent,
|
||
)
|
||
|
||
// 反思用独立 messages，避免污染主对话
|
||
reflectMessages := []types.Message{
|
||
{
|
||
Role: "system",
|
||
Content: "你是一名严谨的中医临床审核专家。",
|
||
Timestamp: time.Now().Unix(),
|
||
},
|
||
{
|
||
Role: "user",
|
||
Content: reflectPrompt,
|
||
Timestamp: time.Now().Unix(),
|
||
},
|
||
}
|
||
|
||
temp := reactCfg.ReflectionTemperature
|
||
if temp <= 0 {
|
||
temp = 0.2
|
||
}
|
||
maxTokens := budget.CalcMaxTokensForCall(1024) // 反思最多 1024 token
|
||
opts := llm.ChatOpts{
|
||
MaxTokens: maxTokens,
|
||
Temperature: temp,
|
||
}
|
||
msg, chatResult := s.callLLMWithMeta(ctx, req.Client, reflectMessages, nil, opts)
|
||
|
||
step.DurationMs = int(time.Since(start).Milliseconds())
|
||
step.FinishedAt = time.Now().Unix()
|
||
step.Provider = req.Provider
|
||
step.Model = req.Client.Name()
|
||
|
||
if chatResult != nil {
|
||
budget.Consume(chatResult.PromptTokens, chatResult.CompletionTokens)
|
||
step.PromptTokens = chatResult.PromptTokens
|
||
step.CompletionTokens = chatResult.CompletionTokens
|
||
step.TotalTokens = chatResult.TotalTokens
|
||
step.Usage = chatResult.Usage
|
||
}
|
||
|
||
if msg == nil {
|
||
step.Status = 2
|
||
step.Detail = "反思调用失败（不阻断，按合格处理）"
|
||
return step, true
|
||
}
|
||
|
||
// 解析"合格/不合格"
|
||
content := strings.TrimSpace(msg.Content)
|
||
firstLine := strings.ToLower(strings.SplitN(content, "\n", 2)[0])
|
||
passed := true
|
||
if strings.Contains(firstLine, "不合格") {
|
||
passed = false
|
||
}
|
||
|
||
step.Status = 1
|
||
if passed {
|
||
step.Detail = "审核通过"
|
||
} else {
|
||
step.Detail = "审核不通过: " + truncateForLog(content, 300)
|
||
}
|
||
return step, passed
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// [4] JSON 修复阶段
|
||
// ------------------------------------------------------------------
|
||
|
||
// repairJSONIfNeeded 检查内容是否为合法 JSON，不合法时让模型修复
|
||
//
|
||
// 返回：
|
||
// - string：修复后的内容（无需修复或修复失败时返回空字符串）
|
||
// - *EnhanceStep：修复步骤（无需修复时返回 nil）
|
||
func (s *EnhancerService) repairJSONIfNeeded(
|
||
ctx context.Context,
|
||
req *ReactLoopRequest,
|
||
reactCfg agentcfg.ReActConfig,
|
||
budget *agent.TokenBudget,
|
||
content string,
|
||
) (string, *EnhanceStep) {
|
||
trimmed := strings.TrimSpace(content)
|
||
|
||
// 已经是合法 JSON：不修复
|
||
if json.Valid([]byte(trimmed)) {
|
||
return "", nil
|
||
}
|
||
|
||
// 不是 JSON 但不是预期的 JSON 场景（内容不以 { 或 [ 开头）：也不修复
|
||
// 避免对纯文本响应（如知识问答）误触发修复
|
||
if !strings.HasPrefix(trimmed, "{") && !strings.HasPrefix(trimmed, "[") {
|
||
return "", nil
|
||
}
|
||
|
||
maxRetries := reactCfg.JSONRepairMaxRetries
|
||
if maxRetries < 1 {
|
||
maxRetries = 2
|
||
}
|
||
|
||
var lastRepaired string
|
||
var lastStep *EnhanceStep
|
||
|
||
for retry := 0; retry < maxRetries; retry++ {
|
||
if budget.IsExceeded() {
|
||
break
|
||
}
|
||
|
||
repairStep, repaired := s.doJSONRepairOnce(ctx, req, budget, content, retry)
|
||
lastStep = repairStep
|
||
|
||
if repaired != "" && json.Valid([]byte(repaired)) {
|
||
lastRepaired = repaired
|
||
break // 修复成功
|
||
}
|
||
|
||
// 用修复后的内容（即使还不合法）作为下次输入
|
||
if repaired != "" {
|
||
content = repaired
|
||
}
|
||
}
|
||
|
||
return lastRepaired, lastStep
|
||
}
|
||
|
||
// doJSONRepairOnce 一次 JSON 修复尝试
|
||
func (s *EnhancerService) doJSONRepairOnce(
|
||
ctx context.Context,
|
||
req *ReactLoopRequest,
|
||
budget *agent.TokenBudget,
|
||
brokenContent string,
|
||
retry int,
|
||
) (*EnhanceStep, string) {
|
||
step := EnhanceStep{
|
||
StepType: "json_repair",
|
||
StartedAt: time.Now().Unix(),
|
||
}
|
||
start := time.Now()
|
||
|
||
repairPrompt := fmt.Sprintf(
|
||
"以下内容应当是合法 JSON 但解析失败，请修复并只输出修复后的 JSON（不要解释、不要 markdown）：\n\n---\n%s\n---",
|
||
brokenContent,
|
||
)
|
||
|
||
messages := []types.Message{
|
||
{
|
||
Role: "system",
|
||
Content: "你是一个 JSON 修复工具，只输出合法的 JSON 内容，不要任何其他文字。",
|
||
Timestamp: time.Now().Unix(),
|
||
},
|
||
{
|
||
Role: "user",
|
||
Content: repairPrompt,
|
||
Timestamp: time.Now().Unix(),
|
||
},
|
||
}
|
||
|
||
opts := llm.ChatOpts{
|
||
MaxTokens: budget.CalcMaxTokensForCall(2048),
|
||
Temperature: 0.1, // 极低温度保证修复稳定
|
||
}
|
||
msg, chatResult := s.callLLMWithMeta(ctx, req.Client, messages, nil, opts)
|
||
|
||
step.DurationMs = int(time.Since(start).Milliseconds())
|
||
step.FinishedAt = time.Now().Unix()
|
||
step.Provider = req.Provider
|
||
step.Model = req.Client.Name()
|
||
step.Detail = fmt.Sprintf("第 %d 次修复尝试", retry+1)
|
||
|
||
if chatResult != nil {
|
||
budget.Consume(chatResult.PromptTokens, chatResult.CompletionTokens)
|
||
step.PromptTokens = chatResult.PromptTokens
|
||
step.CompletionTokens = chatResult.CompletionTokens
|
||
step.TotalTokens = chatResult.TotalTokens
|
||
step.Usage = chatResult.Usage
|
||
}
|
||
|
||
if msg == nil {
|
||
step.Status = 2
|
||
step.Detail = "修复调用失败"
|
||
return &step, ""
|
||
}
|
||
|
||
repaired := strings.TrimSpace(msg.Content)
|
||
// 剥离可能的 markdown 代码块包裹
|
||
if strings.HasPrefix(repaired, "```json") {
|
||
repaired = strings.TrimPrefix(repaired, "```json")
|
||
repaired = strings.TrimSuffix(repaired, "```")
|
||
repaired = strings.TrimSpace(repaired)
|
||
} else if strings.HasPrefix(repaired, "```") {
|
||
repaired = strings.TrimPrefix(repaired, "```")
|
||
repaired = strings.TrimSuffix(repaired, "```")
|
||
repaired = strings.TrimSpace(repaired)
|
||
}
|
||
|
||
if json.Valid([]byte(repaired)) {
|
||
step.Status = 1
|
||
step.Detail = fmt.Sprintf("第 %d 次修复成功", retry+1)
|
||
} else {
|
||
step.Status = 2
|
||
step.Detail = fmt.Sprintf("第 %d 次修复仍不合法", retry+1)
|
||
}
|
||
|
||
return &step, repaired
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// [5] 工具调用执行
|
||
// ------------------------------------------------------------------
|
||
|
||
// executeToolCall 执行一次工具调用并记录 step
|
||
//
|
||
// 注意：本服务目前没有直接持有 tool 注册表（工具注册在 agent.Runner 里），
|
||
// 这里通过 s.toolRegistry 引用 runner 的工具集。如果 toolRegistry 为 nil，
|
||
// 本方法返回"工具未注册"的失败 step。
|
||
func (s *EnhancerService) executeToolCall(ctx context.Context, call *types.ToolCallInfo) EnhanceStep {
|
||
step := EnhanceStep{
|
||
StepType: "tool_call",
|
||
StartedAt: time.Now().Unix(),
|
||
}
|
||
start := time.Now()
|
||
step.Detail = fmt.Sprintf("调用工具: %s", call.ToolName)
|
||
|
||
var result string
|
||
var err error
|
||
if s.toolRegistry != nil {
|
||
if t, ok := s.toolRegistry[call.ToolName]; ok {
|
||
result, err = t.Execute(ctx, call.Params)
|
||
} else {
|
||
err = fmt.Errorf("工具 %s 未注册", call.ToolName)
|
||
}
|
||
} else {
|
||
err = fmt.Errorf("工具注册表为空")
|
||
}
|
||
|
||
step.DurationMs = int(time.Since(start).Milliseconds())
|
||
step.FinishedAt = time.Now().Unix()
|
||
|
||
if err != nil {
|
||
step.Status = 2
|
||
step.Detail = fmt.Sprintf("工具 %s 执行失败: %v", call.ToolName, err)
|
||
// 失败时仍返回错误内容作为 Detail，让 LLM 下一轮知道工具挂了
|
||
} else {
|
||
step.Status = 1
|
||
step.Detail = truncateForLog(result, 2000) // 工具结果可能很长，截断
|
||
}
|
||
return step
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// 工具方法
|
||
// ------------------------------------------------------------------
|
||
|
||
// truncateForLog 截断字符串用于日志（保留前 n 字符）
|
||
func truncateForLog(s string, n int) string {
|
||
if len(s) <= n {
|
||
return s
|
||
}
|
||
return s[:n] + "...(截断)"
|
||
}
|