第五章：ERP 报销与请假（Multi-Agent 审批流）

用户说："上周去上海出差，高铁来回980，住宿两晚共1100，餐饮三天共420"
AI 解析出：
  {
    type: 'travel',
    items: [
      { name: '高铁票', amount: 980, date: '2024-03-11' },
      { name: '住宿费', amount: 1100, date: '2024-03-11' },
      { name: '餐饮费', amount: 420, date: '2024-03-11' },
    ],
    totalAmount: 2500,
    reason: '上海出差'
  }

主管：这次出差的目的是什么？预期产出是？
申请人：参加产品发布会，预期建立合作意向，下周跟进
主管：好的，费用合理，通过
财务：注意住宿费偏高，每晚550元在公司标准范围内，通过

import { z } from 'zod'

// 定义我们期望得到的数据结构
const ExpenseSchema = z.object({
  type: z.enum(['travel', 'meal', 'office', 'training', 'other']),
  items: z.array(z.object({
    name:   z.string().describe('费用项目，如"高铁票""住宿费"'),
    amount: z.number().describe('金额，单位：元'),
    date:   z.string().optional().describe('日期，格式 YYYY-MM-DD'),
  })),
  totalAmount: z.number(),
  reason:      z.string().describe('报销事由，20字以内'),
  warnings:    z.array(z.string()).default([]),   // AI 自己发现的问题
})

// withStructuredOutput：保证模型的输出符合 Schema
const extractModel = model.withStructuredOutput(ExpenseSchema)

// 调用
const result = await extractModel.invoke([
  { role: 'system', content: '你是报销单填写助手，从用户描述中提取报销信息...' },
  { role: 'user',   content: '上周去上海出差，高铁来回980，住宿两晚共1100...' },
])

// result 就是符合 ExpenseSchema 的 JS 对象，不用手动解析 JSON
console.log(result.totalAmount)   // 2500
console.log(result.items.length)  // 3

// 好的 describe：给模型明确的指引
type: z.enum(['travel', 'meal', 'office']).describe('费用类型'),
name: z.string().describe('费用项目名称，如"高铁票""住宿费""餐费"'),
date: z.string().optional().describe('发生日期，格式 YYYY-MM-DD，如果用户说"上周"则推算具体日期'),

// 差的 describe（太模糊）
type: z.string(),  // 没有描述，模型不知道填什么

const systemPrompt = `你是报销单填写助手。
今天是 ${today}。
规则：
1. 如果用户说"上周"，根据今天日期推算具体日期
2. 金额务必精确，提到"约""大概"时保留原数字
3. 如果描述中有金额超过单笔3000元的项目，在 warnings 里提示
4. 如果报销事由不明确，在 warnings 里提示需要补充
5. totalAmount 等于所有 items 的 amount 之和`

const EXPENSE_RULES = {
  travel: {
    hotelPerNight:  800,    // 酒店每晚上限
    maxSingleItem: 5000,    // 单笔最大金额
  },
  meal: { maxSingleItem: 500 },
}

function checkCompliance(form) {
  const alerts = []
  const rules  = EXPENSE_RULES[form.type]

  form.items.forEach(item => {
    if (item.amount > rules.maxSingleItem) {
      alerts.push(`"${item.name}" ¥${item.amount} 超过单笔限额 ¥${rules.maxSingleItem}`)
    }
  })

  return alerts
}

// 合并 AI 发现的问题 + 规则引擎的问题
form.warnings = [...form.warnings, ...checkCompliance(form)]

单 Agent：一个 AI，一个人格，多个工具
Multi-Agent：多个 AI，多个人格，相互对话

function planApprovalFlow(formData, formType) {
  const flow = ['manager']  // 主管是必须的

  if (formType === 'expense') {
    flow.push('finance')              // 报销必须过财务
    if (formData.totalAmount > 5000) {
      flow.push('director')           // 大额需要总监审批
    }
  } else {
    // 请假
    flow.push('hr')                   // 请假必须过 HR
    if (formData.workdays > 5) {
      flow.push('director')           // 长假需要总监
    }
  }

  return flow
}

const systems = {
  manager: `你是直属主管，正在审核下属的报销申请。
申请内容：${JSON.stringify(formData)}
你的职责：
1. 判断这次报销是否有业务必要性
2. 金额和事由是否合理
3. 可以提问，然后给出批准/驳回/要求补充的意见
4. 语气严肃专业，像真实的主管。不超过80字。`,

  finance: `你是财务专员，负责审核报销合规性。
申请内容：${JSON.stringify(formData)}
公司规定：
- 差旅：酒店每晚不超过800元，机票必须经济舱
- 单笔超过3000元需附发票
你的职责：检查是否合规，发现问题要指出。不超过80字。`,

  hr: `你是 HR 专员，负责审核请假合规性。
假期规定：
- 年假：入职满1年后享有5天，每多1年增加1天，最多15天
- 事假：每年最多10天，超过3天影响年终绩效
你的职责：核实假期余额和规定。不超过80字。`,
}

第一步：审批人看申请，给初步意见（可能有问题）
→ [主管]：这次出差的目的是什么？

第二步：如果审批人有问题，申请人回答
→ [申请人]：参加产品发布会，预期建立合作意向

第三步：审批人看到回答后，给最终决定
→ [主管]：理解了，费用合理，批准

async function runApproverTurn(roleId, formData, formType, history, onEvent) {
  // 第一步：审批人初步审查
  const firstResponse = await model.invoke([
    new SystemMessage(getRoleSystem(roleId, formData)),
    new HumanMessage('请审核这份申请，如有疑问可以提问'),
    ...history,
  ])

  onEvent('message', { from: roleId, content: firstResponse.content, type: 'question' })
  history.push(new AIMessage(`[${roleName}]：${firstResponse.content}`))

  // 判断是否有追问
  const hasQuestion = firstResponse.content.includes('？') || firstResponse.content.includes('?')

  if (hasQuestion) {
    // 第二步：申请人回答
    const applicantResponse = await model.invoke([
      new SystemMessage(getApplicantSystem(formData)),
      ...history,
      new HumanMessage('审批人提了问题，请以申请人身份回答'),
    ])

    onEvent('message', { from: 'applicant', content: applicantResponse.content, type: 'answer' })
    history.push(new AIMessage(`[申请人]：${applicantResponse.content}`))

    // 第三步：审批人给最终决定
    const decisionResponse = await model.invoke([
      new SystemMessage(getRoleSystem(roleId, formData)),
      ...history,
      new HumanMessage('申请人已回答，请给出最终审批意见（批准/驳回）'),
    ])

    onEvent('message', { from: roleId, content: decisionResponse.content, type: 'decision' })
    history.push(new AIMessage(`[${roleName}]：${decisionResponse.content}`))

    return { approved: isApproved(decisionResponse.content) }
  }

  // 没有追问，第一个回复就是最终决定
  return { approved: isApproved(firstResponse.content) }
}

// 全局历史从一条初始消息开始
const conversationHistory = [
  new HumanMessage(`申请人提交了报销申请：\n${JSON.stringify(formData)}`),
]

// 每个审批人对话完，把对话加到历史里
// 这样财务看主管和申请人的对话，HR 看主管、财务和申请人的对话
for (const roleId of approverIds) {
  await runApproverTurn(roleId, formData, formType, conversationHistory, onEvent)
  // conversationHistory 在每轮里被修改，自动积累
}

for (const roleId of approverIds) {
  const { approved } = await runApproverTurn(...)

  if (!approved) {
    allApproved  = false
    finalComment = `被${role.name}驳回：...`
    break   // 跳出循环，不再继续后面的角色
  }
}

function isApproved(text) {
  const rejectKeywords = ['驳回', '不批', '拒绝', '不同意', '不予批准', '无法批准']
  return !rejectKeywords.some(kw => text.includes(kw))
}

const DecisionSchema = z.object({
  approved: z.boolean(),
  reason:   z.string(),
})
const decisionModel = model.withStructuredOutput(DecisionSchema)
const result = await decisionModel.invoke([...messages])
// result.approved 是精确的布尔值

event: start            → { appId }
event: plan             → { approvers: [{id, name, icon}...], totalSteps: 2 }
event: approver_start   → { roleId: 'manager', role: {...} }
event: message          → { from: 'manager', content: '...', type: 'question' }
event: message          → { from: 'applicant', content: '...', type: 'answer' }
event: message          → { from: 'manager', content: '...', type: 'decision' }
event: approver_done    → { roleId: 'manager', approved: true }
event: approver_start   → { roleId: 'finance', role: {...} }
event: message          → { from: 'finance', content: '...', type: 'decision' }
event: approver_done    → { roleId: 'finance', approved: true }
event: final            → { approved: true, status: 'approved', approvedBy: ['主管', '财务'] }
event: done             → {}

// 用 Map 存（生产用数据库）
const applications = new Map()

// 提交时创建记录
const application = {
  id:        `APP${Date.now()}`,
  formType,
  formData,
  status:    'pending',      // pending → approved | rejected
  messages:  [],             // 存所有对话消息
  createdAt: new Date().toISOString(),
}
applications.set(appId, application)

// 审批过程中同步更新
application.messages.push(messageData)
application.status    = result.status

<!-- 主逻辑：Composition API -->
<script setup>
const erpStore = useErpStore()
// ...
</script>

<!-- 子组件：Options API（也可以用 setup()） -->
<script>
const FormField = {
  props: ['label', 'value', 'highlight'],
  template: `<div class="form-field-item">...</div>`,
}
export default { components: { FormField } }
</script>

// 1. pending：等待（灰色）
// 2. running：审核中（蓝色 + 动画）
// 3. approved：通过（绿色 ✓）
// 4. rejected：驳回（红色 ✕）

const step = approvalSteps.value.find(s => s.roleId === data.roleId)
if (step) step.status = data.approved ? 'approved' : 'rejected'

<div
  class="msg-bubble-wrap"
  :class="{ 'is-applicant': msg.from === 'applicant' }"
>
  <!-- 靠左：avatar 在前，content 在后 -->
  <template v-if="msg.from !== 'applicant'">
    <div class="msg-avatar">{{ msg.role?.icon }}</div>
    <div class="msg-content">...</div>
  </template>

  <!-- 靠右：content 在前，avatar 在后（视觉上右对齐） -->
  <template v-else>
    <div class="msg-content right">...</div>
    <div class="msg-avatar applicant">👤</div>
  </template>
</div>

.msg-bubble-wrap { display: flex; gap: 10px; align-items: flex-start; }
/* 申请人消息：flex 方向反转 → 右对齐 */
.msg-bubble-wrap.is-applicant { flex-direction: row-reverse; }

.typing-dots span {
  width: 6px; height: 6px;
  border-radius: 50%;
  background: var(--color-text-muted);
  animation: typing .8s infinite;
}
.typing-dots span:nth-child(2) { animation-delay: .15s; }
.typing-dots span:nth-child(3) { animation-delay: .3s; }

@keyframes typing {
  0%,100% { opacity: .3; transform: scale(1); }
  50%     { opacity: 1;  transform: scale(1.2); }
}

result.totalAmount = result.items.reduce((sum, item) => sum + item.amount, 0)

finance: `...
驳回情形：
1. 酒店超过800元/晚且无特殊说明
2. 机票不是经济舱
3. 餐饮超过500元/次
满足以上任一条件时，必须驳回并说明原因。`

const result = await runApprovalFlow(...)

if (result.approved) {
  await sendFeishuMessage(applicant.openId, `你的报销申请已通过，金额 ¥${formData.totalAmount}`)
} else {
  await sendFeishuMessage(applicant.openId, `你的报销申请已驳回：${result.comment}`)
}