node-resource-utils 0.0.0-stage → 1.1.8

package/resources/src/app/api/account-recovery/route.ts

@@ -0,0 +1,132 @@
+import path from 'path';
+import { BizError, CODE, audit, clientInfo, ok, withRoute } from '@/lib/api';
+import { prisma } from '@/lib/prisma';
+import { saveUpload } from '@/lib/upload';
+import { validateField } from '@/lib/validation';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * 账号找回人工申诉（无需登录）。
+ *
+ * 用户忘记密码、且密保问题也答不上来时，从登录页的「忘记密码 → 人工申诉」
+ * 提交账号信息 + 证明材料。落一条 Feedback(type=account)，
+ * 超级管理员在反馈页核实后可通过申诉，密码会被重置为 123456。
+ *
+ * 为什么单独开接口而不是复用 /api/feedback：
+ *   /api/feedback 要求登录（反馈人就是当前用户），而找回密码的人此刻正好登不进来。
+ * 上传也在这里一并处理，不经过需要登录的 /api/upload。
+ */
+
+const MAX_FILES = 3;
+const MAX_SIZE = 10 * 1024 * 1024;
+const ALLOWED_EXT = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.pdf', '.doc', '.docx', '.txt']);
+
+function isFile(v: unknown): v is File {
+  return typeof v === 'object' && v !== null && typeof (v as File).arrayBuffer === 'function';
+}
+
+export const POST = withRoute(async (req) => {
+  const form = await req.formData();
+
+  const usernameCheck = validateField('username', form.get('username'), {
+    label: '要找回的用户名',
+    required: true,
+  });
+  if (!usernameCheck.ok) throw new BizError(usernameCheck.message, CODE.BAD_REQUEST);
+  const username = usernameCheck.value;
+
+  const realNameCheck = validateField('name', form.get('realName'), {
+    label: '真实姓名',
+    required: true,
+  });
+  if (!realNameCheck.ok) throw new BizError(realNameCheck.message, CODE.BAD_REQUEST);
+  const realName = realNameCheck.value;
+
+  const contactCheck = validateField('contact', form.get('contact'), {
+    label: '联系方式',
+    required: true,
+  });
+  if (!contactCheck.ok) throw new BizError(contactCheck.message, CODE.BAD_REQUEST);
+  const contact = contactCheck.value;
+
+  const detailCheck = validateField('text', form.get('detail'), {
+    label: '情况说明',
+    required: true,
+    min: 10,
+  });
+  if (!detailCheck.ok) throw new BizError(detailCheck.message, CODE.BAD_REQUEST);
+  const detail = detailCheck.value;
+
+  const target = await prisma.user.findFirst({
+    where: { username, deletedAt: null },
+    select: { id: true, username: true, status: true },
+  });
+  if (!target) throw new BizError('账号不存在，请核对用户名', CODE.NOT_FOUND);
+  if (target.status !== 1) throw new BizError('该账号已被停用，请联系管理员', CODE.FORBIDDEN, 403);
+
+  // 同一账号只保留一条待处理申诉，避免反复提交把管理员淹了
+  const pending = await prisma.feedback.findFirst({
+    where: {
+      userId: target.id,
+      type: 'account',
+      status: { in: ['pending', 'doing'] },
+      deletedAt: null,
+    },
+  });
+  if (pending) {
+    throw new BizError('该账号已有待处理的申诉，请耐心等待超级管理员处理', CODE.CONFLICT);
+  }
+
+  const files = form.getAll('files').filter(isFile);
+  if (files.length > MAX_FILES) throw new BizError(`最多上传 ${MAX_FILES} 个证明文件`, CODE.BAD_REQUEST);
+
+  const attachments: { name: string; url: string; size: number }[] = [];
+  for (const file of files) {
+    if (!file.size) continue;
+    if (file.size > MAX_SIZE) throw new BizError(`「${file.name}」超过 10MB，请压缩后再传`, CODE.BAD_REQUEST);
+    const ext = path.extname(file.name || '').toLowerCase();
+    if (!ALLOWED_EXT.has(ext)) {
+      throw new BizError(`「${file.name}」格式不支持，仅限图片 / PDF / Word / TXT`, CODE.BAD_REQUEST);
+    }
+    const saved = await saveUpload(file, 'recovery');
+    attachments.push({ name: file.name, url: saved.url, size: saved.size });
+  }
+
+  const detailText = [
+    `账号：${target.username}`,
+    `姓名：${realName}`,
+    `联系方式：${contact}`,
+    '',
+    `申诉说明：${detail}`,
+  ].join('\n');
+
+  const row = await prisma.feedback.create({
+    data: {
+      type: 'account',
+      title: `账号找回申诉：${target.username}`.slice(0, 80),
+      detail: detailText.slice(0, 2000),
+      pagePath: '/forgot',
+      contact: contact.slice(0, 254),
+      attachments: attachments.length ? JSON.stringify(attachments) : null,
+      userId: target.id,
+      username: target.username,
+    },
+  });
+
+  const { ip, userAgent } = clientInfo(req);
+  await audit({
+    userId: target.id,
+    username: target.username,
+    module: '账号安全',
+    action: '提交找回申诉',
+    method: 'POST',
+    path: req.nextUrl.pathname,
+    targetId: row.id,
+    detail: { username: target.username, attachments: attachments.length },
+    ip,
+    userAgent,
+  });
+
+  return ok({ id: row.id }, '申诉已提交，请等待超级管理员核实处理');
+});

package/resources/src/app/api/ai/act/route.ts

@@ -0,0 +1,70 @@
+import { currentUser } from '@/auth';
+import { audit } from '@/lib/api';
+import { isWriteTool, runWrite, verifyAction } from '@/lib/aiTools';
+
+/**
+ * 执行 AI 提出的写操作 —— 只认令牌，不认参数。
+ *
+ * 请求体只有一个字段：`{ token }`。
+ * 动作名、参数、用户、有效期全在令牌里，签名对不上就拒绝。
+ *
+ * ★ 为什么不做成 `{ name, args }`：
+ *   那样前端（以及任何能发请求的脚本）就能把"请 1 天假"改成"请 30 天假"。
+ *   确认卡上的内容必须和真正执行的内容**是同一条数据**，
+ *   否则"二次确认"只是个装饰。
+ *
+ * ★ 权限边界：
+ *   能走到这里说明用户已经登录，且亲手点了确认卡上的按钮。
+ *   这和他在表单里点"提交"是同一个授权动作，所以不再额外要权限码。
+ *   如果某个业务需要更严的约束（比如只有主管能派车），
+ *   在 `lib/aiTools.ts` 的 `runWrite` 里按模型加 `requirePerm` 即可。
+ */
+export async function POST(req: Request) {
+  const user = await currentUser();
+  if (!user) {
+    return Response.json({ error: '请先登录' }, { status: 401 });
+  }
+
+  const body = (await req.json().catch(() => null)) as { token?: string } | null;
+  if (!body?.token) {
+    return Response.json({ error: '缺少确认令牌' }, { status: 400 });
+  }
+
+  const check = verifyAction(body.token, user.id);
+  if (!check.ok) {
+    return Response.json({ error: check.error }, { status: 400 });
+  }
+
+  // 令牌只能承载写动作：只读工具不该走这条路径，避免被当成"任意查询"后门
+  if (!isWriteTool(check.name)) {
+    return Response.json({ error: '该动作不需要确认，也不能通过此接口执行' }, { status: 400 });
+  }
+
+  const t0 = Date.now();
+  const result = await runWrite(check.name, check.args, { userId: user.id, user });
+
+  // 审计：module 记为「AI 助手」，和人工操作区分开，事后能查清是谁让 AI 干的
+  await audit({
+    userId: user.id,
+    username: user.username,
+    module: 'AI 助手',
+    action: result.ok ? '执行动作' : '执行失败',
+    method: 'POST',
+    path: '/api/ai/act',
+    targetId: result.row?.id ? String(result.row.id) : null,
+    detail: {
+      tool: check.name,
+      args: check.args,
+      ok: result.ok,
+      summary: result.summary,
+    },
+    status: result.ok ? 1 : 0,
+    durationMs: Date.now() - t0,
+  });
+
+  return Response.json({
+    ok: result.ok,
+    summary: result.summary,
+    id: result.row?.id ?? null,
+  });
+}

package/resources/src/app/api/ai/ask/route.ts

@@ -0,0 +1,82 @@
+import { ok, withRoute, audit, BizError, CODE } from '@/lib/api';
+import { currentUser } from '@/auth';
+import { compatInvoke, COMPAT_MODEL } from '@/lib/openaiCompat';
+import { buildAssistantContext } from '@/lib/aiContext';
+
+/**
+ * AI 问答（非流式版本）。
+ *
+ * ★ 页面上的对话框已经统一走 `/api/ai/chat`（流式，内置当前时间 + 数据快照）。
+ *   这个接口保留下来，给"需要一次性拿到完整答案"的场景用：
+ *   脚本批量提问、其它模块内嵌问答、或者不支持 SSE 的客户端。
+ *
+ * 上下文与统一助手是**同一套**（lib/aiContext.ts）：
+ *   当前时间（本月/上月区间）+ ontology 声明的业务表快照 + 每表本月/今日计数。
+ *   所以"这个月有多少条"这类问题这里也能答对，不再依赖模型猜日期。
+ *
+ * POST /api/ai/ask   { question: string, scope?: string[] }
+ */
+export const POST = withRoute(async (req) => {
+  const user = await currentUser();
+  if (!user) throw new BizError('请先登录', CODE.UNAUTHORIZED, 401);
+
+  const body = (await req.json().catch(() => ({}))) as {
+    question?: string;
+    scope?: string[];
+  };
+  const question = String(body.question ?? '').trim();
+  if (question.length < 2) throw new BizError('请输入你的问题', CODE.BAD_REQUEST);
+  if (question.length > 300) throw new BizError('问题太长了，请精简到 300 字以内', CODE.BAD_REQUEST);
+
+  // 这个接口没有工具（返回 JSON、没有确认卡，不适合触发写操作），
+  // 所以数据多给一些：每表 20 行。chat 那边有工具，只带 6 行样例。
+  const ctx = await buildAssistantContext(undefined, {
+    withData: true,
+    rows: 20,
+    scope: Array.isArray(body.scope) ? body.scope.map(String) : [],
+  });
+  if (!ctx.snapshot.length) {
+    throw new BizError(
+      '库里没有可查询的业务数据。请先补充演示数据（npm run db:seed），或在 ontology.ts 里声明业务表。',
+      CODE.BAD_REQUEST
+    );
+  }
+
+  const answer = await compatInvoke({
+    system: ctx.system,
+    messages: [
+      {
+        role: 'user',
+        content:
+          `请回答这个问题：${question}\n\n` +
+          `要求：先给结论（具体的数字和名称），再给依据（来自哪张表）；` +
+          `数据不够就说明缺什么，不要猜。`,
+      },
+    ],
+    maxTokens: 1200,
+    temperature: 0.2,
+  });
+
+  void audit({
+    module: 'AI 问答',
+    action: '提问',
+    method: 'POST',
+    path: req.url,
+    detail: `问题=${question.slice(0, 60)} 表数=${ctx.snapshot.length}`,
+    userId: user.id,
+    username: user.username,
+  });
+
+  return ok({
+    answer,
+    model: COMPAT_MODEL,
+    tables: ctx.snapshot.map((t) => ({
+      model: t.model,
+      total: t.total,
+      monthTotal: t.monthTotal,
+      sampled: t.rows.length,
+    })),
+    now: { date: ctx.now.date, month: ctx.now.month },
+    generatedAt: new Date().toISOString(),
+  });
+});

package/resources/src/app/api/ai/chat/route.ts

@@ -0,0 +1,404 @@
+import { currentUser } from '@/auth';
+import { aiChatWithTools, streamAiChat, type AiMessage } from '@/lib/ai';
+import { buildAssistantContext, nowContext } from '@/lib/aiContext';
+import {
+  buildAiTools,
+  describeAction,
+  isFormTool,
+  isWriteTool,
+  runReadTool,
+  signAction,
+  validateWrite,
+} from '@/lib/aiTools';
+import {
+  buildAskForm,
+  buildWriteForm,
+  formValuesText,
+  mergeFormValues,
+  readFormToken,
+  type FormTokenPayload,
+} from '@/lib/aiForm';
+
+/**
+ * 统一 AI 助手（流式 + 可调用系统功能）。
+ *
+ * ★ 一个对话框同时支持三类诉求：
+ *   - 系统怎么用（"怎么新增一条申请""权限怎么配"）
+ *   - 数据问答（"这个月有多少条记录""哪个部门最多"）
+ *   - **直接办事**（"帮我新增一条记录""把这条记录的负责人改成我"）
+ *
+ * ## 工具从哪来
+ * 不是在这里写死的。`lib/aiTools.ts` 按 `ontology.ts` 的实体 + prisma schema 的字段
+ * 自动生成 query_ 与 create_ 两类工具，所以**换业务不用改这个文件**。
+ *
+ * ## 为什么写操作要分两步
+ * 模型提出 create_* 后，这里**不写库**，只做三件事：
+ *   1. 校验必填（缺就让模型去问用户，而不是建一条空记录）
+ *   2. 把"动作名 + 参数 + 用户 id + 过期时间"做成 HMAC 令牌
+ *   3. 推一条 `action` 事件给前端，由用户点确认
+ * 真正的写在 `/api/ai/act`，它只认令牌、不认参数 —— 前端改不动参数。
+ *
+ * ## SSE 协议
+ *   data: {"meta": {...}}        参考表 / 当前时间 / 可用工具数
+ *   data: {"step": {...}}        一次工具调用（前端显示"查了 XX，返回 N 条"）
+ *   data: {"form": {...}}        需要用户填写的表单（前端渲染输入卡）
+ *   data: {"action": {...}}      待确认的写操作（前端渲染确认卡）
+ *   data: {"content": "..."}     正文增量
+ *   data: {"error": "...", "hint": "..."}
+ *   data: [DONE]
+ *
+ * ## 表单这条路（为什么写工具缺参不直接让模型追问）
+ *   模型只说"还缺请假类型和起止日期"时，用户得在聊天框里按格式手打一遍，
+ *   模型再解析一遍 —— 字段一多就漏、格式一乱就错，还要多等两轮本地模型。
+ *   所以缺参时这里推一张 `form`：字段（含下拉选项/日期控件/必填标记）来自 schema，
+ *   用户填完提交回来的 `values` 合并进已签名的令牌参数里，**服务端直接生成确认卡**，
+ *   不再经过模型。少一次生成，就少一次误解析。
+ *
+ *   模型也可以主动调 `ask_user` 要信息（比如查询前先问时间范围），
+ *   那条路走 'ask' 模式：答案回灌给模型继续这一轮。
+ *
+ * 注意：这里不用 withRoute —— 它要求返回 NextResponse，
+ * 而 SSE 需要返回原生 Response，所以直接导出 POST。
+ */
+
+/** 最多几轮工具调用。2 轮够用：一轮查数据，一轮补查或发起动作 */
+const MAX_TOOL_TURNS = 2;
+
+/** 一次性文本按小段推给前端，保留打字机观感（模型已生成完，只是分帧发） */
+const CHUNK_SIZE = 26;
+
+export async function POST(req: Request) {
+  const user = await currentUser();
+  if (!user) {
+    return Response.json({ error: '请先登录' }, { status: 401 });
+  }
+
+  const body = (await req.json().catch(() => null)) as {
+    system?: string;
+    messages?: { role: 'system' | 'user' | 'assistant'; content: string }[];
+    maxTokens?: number;
+    withData?: boolean;
+    /** 关掉工具（只想要纯问答时用，比如报告生成的内部调用） */
+    withTools?: boolean;
+    /** 用户提交了表单：令牌 + 填写内容 */
+    form?: { token?: string; values?: Record<string, unknown> };
+  } | null;
+
+  if (!body?.messages?.length) {
+    return Response.json({ error: 'messages 不能为空' }, { status: 400 });
+  }
+
+  /**
+   * 表单提交先验签，再决定后续。
+   * 验签失败在流开始前就返回 400 —— 这种情况下前端应该提示"表单已过期，请重新发起"，
+   * 而不是收到一个半截的 SSE 流。
+   */
+  let formSubmit: { payload: FormTokenPayload; values: Record<string, unknown> } | null = null;
+  if (body.form?.token) {
+    const r = readFormToken(body.form.token, user.id);
+    if (!r.ok) return Response.json({ error: r.error }, { status: 400 });
+    formSubmit = { payload: r.payload, values: body.form.values ?? {} };
+  }
+
+  // 带完整对话历史（含 assistant 的上一轮回答），否则追问会丢上下文
+  const history: AiMessage[] = body.messages
+    .filter((m) => m?.content && (m.role === 'user' || m.role === 'assistant'))
+    .slice(-20)
+    .map((m) => ({ role: m.role, content: String(m.content).slice(0, 4000) }));
+
+  if (!history.length) {
+    return Response.json({ error: '没有有效的对话内容' }, { status: 400 });
+  }
+
+  const withTools = body.withTools !== false;
+  const tools = withTools ? buildAiTools() : [];
+
+  // 时间 + 用户 + 数据快照都在服务端组装，前端无法绕过，也不会忘记带
+  const ctx = await buildAssistantContext(body.system, {
+    withData: body.withData !== false,
+    user: { id: user.id, name: user.name, username: user.username },
+    tools: tools.length > 0,
+  });
+
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = (obj: unknown) =>
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(obj)}\n\n`));
+
+      /** 已生成好的整段文字，分帧推出去 */
+      const sendText = async (text: string) => {
+        for (let i = 0; i < text.length; i += CHUNK_SIZE) {
+          send({ content: text.slice(i, i + CHUNK_SIZE) });
+          // 不 sleep 的话浏览器会一次性收到全部帧，等于没有打字机效果
+          await new Promise((r) => setTimeout(r, 8));
+        }
+      };
+
+      try {
+        // 先把"参考了哪几张表 / 现在几点 / 挂了几个工具"发回去，页面据此显示证据
+        send({
+          meta: {
+            tables: ctx.snapshot.map((t) => ({
+              model: t.model,
+              total: t.total,
+              monthTotal: t.monthTotal,
+            })),
+            now: {
+              date: ctx.now.date,
+              time: ctx.now.time,
+              weekday: ctx.now.weekday,
+              month: ctx.now.month,
+            },
+            toolCount: tools.length,
+          },
+        });
+
+        const messages: AiMessage[] = [...history];
+        let done = false;
+        /** 本轮弹出的表单说明：循环结束后统一说一句，不再额外调一次模型 */
+        const formNotes: string[] = [];
+
+        // ---------- 用户刚提交了表单 ----------
+        if (formSubmit) {
+          const p = formSubmit.payload;
+          // 只接受令牌里的字段白名单，前端多塞的键会被丢掉
+          const merged = mergeFormValues(p, formSubmit.values);
+
+          if (p.m === 'fill' && p.n) {
+            const check = validateWrite(p.n, merged);
+            if (check.ok) {
+              // 参数齐了 → 直接签动作令牌。不再让模型重说一遍，避免它改字段
+              const token = signAction(user.id, p.n, merged);
+              const preview = await describeAction(p.n, merged);
+              send({ step: { name: p.n, kind: 'write', ok: true, summary: preview.title } });
+              send({ action: { token, name: p.n, title: preview.title, fields: preview.fields } });
+              await sendText(
+                `信息已补齐，请在下方确认卡片上核对「${preview.title}」，确认后才会写库。`
+              );
+            } else {
+              // 还有必填没填：带着已填内容重新弹一张，别让用户从头再填一遍
+              const again = await buildWriteForm(p.n, merged, user.id);
+              if (again) {
+                send({ form: again });
+                await sendText(check.message ?? '还有必填信息没填，请继续补充。');
+              } else {
+                await sendText(check.message ?? '信息不完整，请补充后重试。');
+              }
+            }
+            done = true;
+          } else {
+            // ask 模式：答案作为用户消息回灌，继续正常流程（可能还要查库/算数）。
+            // 前端已经带了一条「已填写《表单标题》：…」的摘要，就别再塞一遍 ——
+            // 重复的 user 消息会让模型以为用户回答了两遍。
+            const last = history[history.length - 1];
+            const already = last?.role === 'user' && last.content.startsWith('已填写《');
+            if (!already) messages.push({ role: 'user', content: formValuesText(p, formSubmit.values) });
+          }
+        }
+
+        for (let turn = 0; turn < MAX_TOOL_TURNS && !done; turn++) {
+          const r = await aiChatWithTools({
+            system: ctx.system,
+            messages,
+            tools,
+            maxTokens: 900,
+            temperature: 0.2,
+          });
+
+          // 没有要调的工具 → 这一轮的文字就是最终答案
+          if (!r.toolCalls.length) {
+            if (r.content) await sendText(r.content);
+            done = true;
+            break;
+          }
+
+          // 把 assistant 的 tool_calls 原样放回历史，否则下一轮模型会重复调用
+          messages.push({
+            role: 'assistant',
+            content: r.content,
+            tool_calls: r.toolCalls.map((c) => ({
+              id: c.id,
+              type: 'function',
+              function: { name: c.name, arguments: c.raw },
+            })),
+          });
+
+          // 模型这轮可能顺口说了点什么（"我先查一下"），先推出去
+          if (r.content) send({ content: `${r.content}\n\n` });
+
+          for (const call of r.toolCalls) {
+            // ---- 模型主动要信息：直接弹表单，不执行、不写库 ----
+            if (isFormTool(call.name)) {
+              const spec = await buildAskForm(
+                call.args as { title?: unknown; question?: unknown; tool?: unknown; fields?: unknown },
+                user.id
+              );
+              if (spec) {
+                send({ form: spec });
+                if (spec.description) formNotes.push(spec.description);
+                messages.push({
+                  role: 'tool',
+                  tool_call_id: call.id,
+                  content: JSON.stringify({
+                    status: 'form_shown',
+                    message: '已弹出结构化表单，用户填写提交后会继续。',
+                    hint: '不要再逐条用文字追问同样的问题。',
+                  }),
+                });
+              } else {
+                send({ step: { name: call.name, kind: 'read', ok: false, summary: '表单参数不合法' } });
+                messages.push({
+                  role: 'tool',
+                  tool_call_id: call.id,
+                  content: JSON.stringify({
+                    status: 'error',
+                    message: 'fields 不能为空，且每项必须是字段名。',
+                  }),
+                });
+              }
+              continue;
+            }
+
+            if (isWriteTool(call.name)) {
+              const check = validateWrite(call.name, call.args);
+
+              if (!check.ok) {
+                // ★ 参数不全 → 弹一张按 schema 生成的表单。
+                //   以前这里只回灌"缺什么"，让模型用中文再问一遍：用户得自己按格式
+                //   打字、模型再解析一遍，字段一多就漏。现在缺的项直接变成控件。
+                send({
+                  step: { name: call.name, kind: 'write', ok: false, summary: check.message ?? '参数不完整' },
+                });
+
+                const spec = await buildWriteForm(call.name, call.args, user.id);
+                if (spec) {
+                  send({ form: spec });
+                  formNotes.push(spec.description ?? '请补齐下面的信息。');
+                } else if (check.message) {
+                  formNotes.push(check.message);
+                }
+
+                messages.push({
+                  role: 'tool',
+                  tool_call_id: call.id,
+                  content: JSON.stringify({
+                    status: 'form_shown',
+                    message: '已把缺少的信息做成表单弹给用户，用户提交后系统会直接生成确认卡。',
+                    hint: '不要再用文字逐条追问同样的字段。',
+                  }),
+                });
+                continue;
+              }
+
+              const token = signAction(user.id, call.name, call.args);
+              const preview = await describeAction(call.name, call.args);
+
+              send({
+                step: { name: call.name, kind: 'write', ok: true, summary: preview.title },
+              });
+              send({
+                action: {
+                  token,
+                  name: call.name,
+                  title: preview.title,
+                  fields: preview.fields,
+                },
+              });
+
+              messages.push({
+                role: 'tool',
+                tool_call_id: call.id,
+                content: JSON.stringify({
+                  status: 'pending_user_confirmation',
+                  message: '已生成确认卡，等用户点击确认后才会写库。',
+                }),
+              });
+              continue;
+            }
+
+            // 只读工具：立即执行，结果回灌
+            const result = await runReadTool(call.name, call.args, { userId: user.id, user });
+            send({
+              step: { name: call.name, kind: 'read', ok: result.ok, summary: result.summary },
+            });
+            messages.push({
+              role: 'tool',
+              tool_call_id: call.id,
+              content: result.content.slice(0, 6000),
+            });
+          }
+
+          /**
+           * ★ 本轮弹了表单就到此为止，不要再进下一轮。
+           *
+           *   踩过的坑：不 break 的话，循环会继续调一次模型 ——
+           *   用户已经看到表单了，后台还在跑一轮本地推理（几十秒），
+           *   期间整个面板处于 busy，用户填完点提交会被当成"正在生成"直接丢掉。
+           *   表单是"等用户"的终点，不是"继续想"的中间态。
+           */
+          if (formNotes.length) {
+            await sendText([...new Set(formNotes)].join('\n\n'));
+            done = true;
+            break;
+          }
+        }
+
+        // 弹了表单 → 说一句就停，等用户填。
+        // 这里刻意不再调模型：再问一遍只会重复表单上已经列出的字段，
+        // 用户还要多等十几秒本地推理，收益是负的。
+        if (!done && formNotes.length) {
+          await sendText([...new Set(formNotes)].join('\n\n'));
+          done = true;
+        }
+
+        // 工具轮用完还没得到最终回答 → 再跑一轮纯流式总结（不带 tools，逼它开口）
+        if (!done) {
+          await streamAiChat(
+            {
+              system: ctx.system,
+              messages,
+              maxTokens: body.maxTokens ?? 1200,
+              temperature: 0.3,
+            },
+            (chunk) => send({ content: chunk })
+          );
+        }
+
+        controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+      } catch (e) {
+        // 把错误也用 SSE 推回去，前端能直接显示中文原因
+        const err = e as Error & { hint?: string };
+        send({ error: err.message, hint: err.hint });
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream; charset=utf-8',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}
+
+/** 供调试：返回助手此刻看到的系统提示词（不含敏感数据以外的内容） */
+export async function GET() {
+  const user = await currentUser();
+  if (!user) return Response.json({ error: '请先登录' }, { status: 401 });
+  const ctx = await buildAssistantContext();
+  const tools = buildAiTools();
+  return Response.json({
+    now: nowContext(),
+    tables: ctx.snapshot.map((t) => ({ model: t.model, total: t.total })),
+    systemChars: ctx.system.length,
+    tools: tools.map((t) => ({
+      name: t.function.name,
+      description: t.function.description,
+    })),
+  });
+}