557 lines
22 KiB
TypeScript
557 lines
22 KiB
TypeScript
import fs from 'node:fs';
|
||
import fsp from 'node:fs/promises';
|
||
import path from 'node:path';
|
||
import { createHash, randomUUID } from 'node:crypto';
|
||
import { Transform } from 'node:stream';
|
||
import { pipeline } from 'node:stream/promises';
|
||
import type { Request } from 'express';
|
||
import type { AiAgentEvent, AiConversationResult, AiTaskDto } from '@classhelper/shared';
|
||
import { prisma } from '../../lib/db.js';
|
||
import { ApiError } from '../../lib/http.js';
|
||
import { logger } from '../../lib/logger.js';
|
||
import { assertPermission, loadAuthPrincipal } from '../../lib/authz/index.js';
|
||
import { loadSessionUser } from '../../lib/authz/session.js';
|
||
import { encryptSecret, decryptSecret } from '../../lib/secrets.js';
|
||
import { signToken, type TokenPayload } from '../../lib/jwt.js';
|
||
import { coursewareRoot } from '../courseware/courseware.service.js';
|
||
import { interpretConversation } from './conversation.js';
|
||
import { sanitizePrompt } from './model-planner.js';
|
||
import { runRead } from './actions.js';
|
||
import { confirmPlan, getPlan, preparePlan, discardPlan } from './plans.js';
|
||
import type { AiInterpretInput } from './ai.schemas.js';
|
||
|
||
const active = new Map<string, AbortController>();
|
||
const stagingRoot = path.resolve(coursewareRoot, '.ai-tasks');
|
||
const decode = <T>(value: string): T => JSON.parse(decryptSecret(value));
|
||
async function accessStamp(user: TokenPayload): Promise<string> {
|
||
const current = await loadSessionUser({ ...user });
|
||
const principal = await loadAuthPrincipal(current);
|
||
const relations =
|
||
current.role === 'ADMIN'
|
||
? []
|
||
: await Promise.all([
|
||
prisma.class.findMany({
|
||
select: { id: true, grade: true, teacherId: true },
|
||
orderBy: { id: 'asc' },
|
||
}),
|
||
prisma.course.findMany({
|
||
where: { teacherId: current.sub },
|
||
select: { id: true, classId: true, name: true },
|
||
orderBy: { id: 'asc' },
|
||
}),
|
||
]);
|
||
return createHash('sha256')
|
||
.update(
|
||
JSON.stringify({
|
||
role: current.role,
|
||
keys: [...principal.permissions].sort(),
|
||
grants: [...principal.grants].sort(),
|
||
relations,
|
||
}),
|
||
)
|
||
.digest('hex');
|
||
}
|
||
function attachmentPath(id: string, attachmentId: string): string {
|
||
return path.join(
|
||
stagingRoot,
|
||
createHash('sha256').update(id).digest('hex'),
|
||
createHash('sha256').update(attachmentId).digest('hex'),
|
||
);
|
||
}
|
||
async function owned(user: TokenPayload, id: string) {
|
||
await assertPermission(user, 'ai:use');
|
||
const row = await prisma.aiTask.findFirst({ where: { id, userId: user.sub } });
|
||
if (!row) throw ApiError.forbidden('无法访问此任务');
|
||
const saved = decode<AiInterpretInput & { accessStamp?: string }>(row.input).accessStamp;
|
||
if (saved && saved !== (await accessStamp(user)))
|
||
throw ApiError.forbidden('权限或任课关系已变化,请重新提交任务,原计划不会自动执行');
|
||
return row;
|
||
}
|
||
export async function createTask(user: TokenPayload, input: AiInterpretInput) {
|
||
await assertPermission(user, 'ai:use');
|
||
const expired = await prisma.aiTask.findMany({
|
||
where: {
|
||
userId: user.sub,
|
||
state: { in: ['preparing', 'ready', 'failed', 'stopped', 'succeeded', 'waiting_input'] },
|
||
updatedAt: { lt: new Date(Date.now() - 24 * 60 * 60 * 1000) },
|
||
},
|
||
take: 20,
|
||
});
|
||
for (const row of expired) await cleanup(row.id, decode<AiInterpretInput>(row.input));
|
||
if (
|
||
(await prisma.aiTask.count({ where: { userId: user.sub, state: { in: ['planning', 'executing'] } } })) >=
|
||
3
|
||
)
|
||
throw ApiError.conflict('请等待现有后台任务完成');
|
||
const conversation = input.conversationId
|
||
? await ownedConversation(user, input.conversationId)
|
||
: await createConversation(user);
|
||
if (input.supersedesTaskId) {
|
||
const old = await owned(user, input.supersedesTaskId);
|
||
if (old.conversationId !== conversation.id || old.state !== 'ready')
|
||
throw ApiError.conflict('只能替换本对话中明确选中的待确认计划');
|
||
}
|
||
const previous = await prisma.aiTask.findMany({
|
||
where: { userId: user.sub, conversationId: conversation.id },
|
||
orderBy: { turnNumber: 'asc' },
|
||
});
|
||
if (previous.some((t) => ['planning', 'executing'].includes(t.state)))
|
||
throw ApiError.conflict('当前对话仍在处理,请等待完成');
|
||
const history: { role: 'user' | 'assistant'; content: string }[] = [];
|
||
for (const old of previous) {
|
||
const checked = await task(user, old.id);
|
||
history.push({ role: 'user', content: checked.text });
|
||
if (checked.result)
|
||
history.push({
|
||
role: 'assistant',
|
||
content:
|
||
checked.result.message +
|
||
'\n' +
|
||
JSON.stringify(
|
||
checked.result.steps.map((s) => ({ action: s.action, status: s.status, summary: s.summary })),
|
||
),
|
||
});
|
||
}
|
||
const context =
|
||
history.length > 18
|
||
? [
|
||
{
|
||
role: 'user' as const,
|
||
content:
|
||
'此前用户需求摘要:' +
|
||
history
|
||
.slice(0, -18)
|
||
.filter((m) => m.role === 'user')
|
||
.map((m) => m.content.slice(0, 300))
|
||
.join(';')
|
||
.slice(-7000),
|
||
},
|
||
...history.slice(-18),
|
||
]
|
||
: history;
|
||
const last = previous.at(-1);
|
||
const inherited =
|
||
last?.state === 'waiting_input' && !input.attachments?.length
|
||
? decode<AiInterpretInput>(last.input).attachments
|
||
: undefined;
|
||
const safe = {
|
||
...input,
|
||
attachments: input.attachments?.length ? input.attachments : inherited,
|
||
text: sanitizePrompt(input.text),
|
||
conversationId: conversation.id,
|
||
messages: context.map((item) => ({ ...item, content: sanitizePrompt(item.content).slice(0, 8000) })),
|
||
};
|
||
Object.assign(safe, { accessStamp: await accessStamp(user) });
|
||
const row = await prisma.$transaction(async (tx) => {
|
||
// 与删除对话共用同一行锁,避免新轮次写入已删除的对话。
|
||
const locked = await tx.aiConversation.updateMany({
|
||
where: { id: conversation.id, userId: user.sub },
|
||
data: { updatedAt: new Date(), title: conversation.title || sanitizePrompt(input.text).slice(0, 80) },
|
||
});
|
||
if (!locked.count) throw ApiError.forbidden('此对话已删除或无法访问');
|
||
const latest = await tx.aiTask.findFirst({
|
||
where: { conversationId: conversation.id, userId: user.sub },
|
||
orderBy: { turnNumber: 'desc' },
|
||
});
|
||
if ((latest?.turnNumber ?? 0) !== (previous.at(-1)?.turnNumber ?? 0))
|
||
throw ApiError.conflict('对话已有新轮次,请重新发送');
|
||
return tx.aiTask.create({
|
||
data: {
|
||
userId: user.sub,
|
||
conversationId: conversation.id,
|
||
turnNumber: (latest?.turnNumber ?? 0) + 1,
|
||
input: encryptSecret(JSON.stringify(safe)),
|
||
},
|
||
});
|
||
});
|
||
if (last && inherited?.length) {
|
||
for (const attachment of inherited) {
|
||
const source = attachmentPath(last.id, attachment.id),
|
||
target = attachmentPath(row.id, attachment.id);
|
||
if (!fs.existsSync(source)) throw ApiError.badRequest('原附件暂存已过期,请重新上传后继续');
|
||
await fsp.mkdir(path.dirname(target), { recursive: true });
|
||
await fsp.copyFile(source, target);
|
||
}
|
||
}
|
||
return { id: row.id, conversationId: conversation.id };
|
||
}
|
||
export async function stageAttachment(
|
||
user: TokenPayload,
|
||
id: string,
|
||
attachmentId: string,
|
||
request: Request,
|
||
) {
|
||
const row = await owned(user, id);
|
||
if (row.state !== 'preparing' || active.has(id)) throw ApiError.conflict('任务已开始,不能更换附件');
|
||
const attachment = decode<AiInterpretInput>(row.input).attachments?.find(
|
||
(item) => item.id === attachmentId,
|
||
);
|
||
if (!attachment) throw ApiError.forbidden('附件不属于本次任务');
|
||
const file = attachmentPath(id, attachmentId),
|
||
partial = file + '.' + randomUUID() + '.partial';
|
||
await fsp.mkdir(path.dirname(file), { recursive: true });
|
||
let size = 0;
|
||
const digest = createHash('sha256');
|
||
try {
|
||
await pipeline(
|
||
request,
|
||
new Transform({
|
||
transform(chunk: Buffer, _encoding, callback) {
|
||
size += chunk.length;
|
||
if (size > attachment.size) {
|
||
callback(ApiError.badRequest('附件大小与预览不一致'));
|
||
return;
|
||
}
|
||
digest.update(chunk);
|
||
callback(null, chunk);
|
||
},
|
||
}),
|
||
fs.createWriteStream(partial, { flags: 'wx' }),
|
||
);
|
||
if (size !== attachment.size || digest.digest('hex') !== attachment.sha256)
|
||
throw ApiError.badRequest('附件校验失败,请重新上传');
|
||
await fsp.rename(partial, file);
|
||
} finally {
|
||
await fsp.rm(partial, { force: true });
|
||
}
|
||
}
|
||
async function cleanup(id: string, input: AiInterpretInput) {
|
||
for (const attachment of input.attachments ?? [])
|
||
await fsp.rm(attachmentPath(id, attachment.id), { force: true });
|
||
await fsp.rmdir(path.dirname(attachmentPath(id, ''))).catch(() => undefined);
|
||
}
|
||
|
||
export async function task(user: TokenPayload, id: string): Promise<AiTaskDto> {
|
||
const row = await owned(user, id);
|
||
if (
|
||
['planning', 'executing'].includes(row.state) &&
|
||
!active.has(id) &&
|
||
Date.now() - row.updatedAt.getTime() > 2000
|
||
) {
|
||
await prisma.aiTask.updateMany({
|
||
where: { id, state: row.state },
|
||
data: {
|
||
state: 'failed',
|
||
error:
|
||
row.state === 'executing'
|
||
? '服务已重启,请核对步骤状态后继续;成功步骤不会重复执行。'
|
||
: '服务已重启,任务已保留,可继续处理。',
|
||
},
|
||
});
|
||
return task(user, id);
|
||
}
|
||
let result = row.result ? decode<AiConversationResult>(row.result) : undefined;
|
||
if (result) {
|
||
if (result.planId) result.steps = await getPlan(user, result.planId);
|
||
// 重进页面时重新查询授权范围,不能用历史快照泄漏撤权后的记录。
|
||
const results: AiConversationResult['results'] = [];
|
||
for (const item of result.results)
|
||
if (item.operation) {
|
||
const data = await runRead(user, item.operation);
|
||
if (JSON.stringify(data) !== JSON.stringify(item.data))
|
||
throw ApiError.forbidden('记录或权限已变化,请重新查询当前结果');
|
||
results.push({ ...item, data });
|
||
}
|
||
result = { ...result, results };
|
||
}
|
||
return {
|
||
id,
|
||
classId: decode<AiInterpretInput>(row.input).classId,
|
||
conversationId: row.conversationId,
|
||
turnNumber: row.turnNumber,
|
||
state: row.state,
|
||
text: decode<AiInterpretInput>(row.input).text,
|
||
result,
|
||
events: row.events ? decode<AiAgentEvent[]>(row.events) : [],
|
||
...(row.error ? { error: row.error } : {}),
|
||
};
|
||
}
|
||
export async function listTasks(user: TokenPayload) {
|
||
await assertPermission(user, 'ai:use');
|
||
const rows = await prisma.aiTask.findMany({
|
||
where: { userId: user.sub },
|
||
orderBy: { createdAt: 'desc' },
|
||
take: 20,
|
||
});
|
||
return rows.map((row) => ({
|
||
id: row.id,
|
||
state: row.state,
|
||
text: decode<AiInterpretInput>(row.input).text,
|
||
events: [],
|
||
}));
|
||
}
|
||
|
||
function launch(
|
||
id: string,
|
||
user: TokenPayload,
|
||
work: (signal: AbortSignal, emit: (event: AiAgentEvent) => void) => Promise<void>,
|
||
) {
|
||
const controller = new AbortController();
|
||
active.set(id, controller);
|
||
let events: AiAgentEvent[] = [],
|
||
writes = Promise.resolve(),
|
||
lastMessage = '';
|
||
const emit = (event: AiAgentEvent) => {
|
||
if (event.type === 'status' && event.message.startsWith('模型正在推理'))
|
||
events = events.filter((item) => item.type !== 'status' || !item.message.startsWith('模型正在推理'));
|
||
if (event.type === 'message') {
|
||
if (lastMessage === event.text) return;
|
||
lastMessage = event.text;
|
||
events = events.filter((item) => item.type !== 'message');
|
||
}
|
||
events = [...events, event].slice(-80);
|
||
const snapshot = encryptSecret(JSON.stringify(events));
|
||
writes = writes
|
||
.then(async () => {
|
||
await prisma.aiTask.update({ where: { id }, data: { events: snapshot } });
|
||
})
|
||
.catch(() => undefined);
|
||
};
|
||
void work(controller.signal, emit)
|
||
.catch(async (error) => {
|
||
const message = controller.signal.aborted
|
||
? '任务已按你的要求停止。'
|
||
: error instanceof ApiError
|
||
? error.message
|
||
: '任务暂未完成,已保留当前进度。请重试继续。';
|
||
await prisma.aiTask.update({
|
||
where: { id },
|
||
data: { state: controller.signal.aborted ? 'stopped' : 'failed', error: message },
|
||
});
|
||
await prisma.aiAudit.create({
|
||
data: { userId: user.sub, prompt: '后台任务', intent: id, status: 'failed', message },
|
||
});
|
||
})
|
||
.finally(async () => {
|
||
await writes.catch(() => undefined);
|
||
active.delete(id);
|
||
})
|
||
.catch(() => {
|
||
active.delete(id);
|
||
});
|
||
}
|
||
|
||
export async function startTask(user: TokenPayload, id: string) {
|
||
const row = await owned(user, id);
|
||
if (active.has(id)) return;
|
||
if (!['preparing', 'failed', 'stopped'].includes(row.state) || row.result)
|
||
throw ApiError.conflict('任务已有结果,请核对现有计划');
|
||
const input = decode<AiInterpretInput>(row.input);
|
||
for (const attachment of input.attachments ?? [])
|
||
if (!fs.existsSync(attachmentPath(id, attachment.id)))
|
||
throw ApiError.badRequest('附件尚未上传完成,请重新选择原文件');
|
||
const claimed = await prisma.aiTask.updateMany({
|
||
where: { id, state: row.state },
|
||
data: { state: 'planning', error: '' },
|
||
});
|
||
if (!claimed.count) return;
|
||
launch(id, user, async (signal, emit) => {
|
||
const result = await interpretConversation(user, input, {
|
||
signal,
|
||
emit,
|
||
authorize: async () => {
|
||
await owned(user, id);
|
||
},
|
||
});
|
||
if (result.planId && result.steps.some((step) => step.status === 'draft')) {
|
||
for (const step of result.steps.filter((step) => step.status === 'draft')) {
|
||
signal.throwIfAborted();
|
||
const file = attachmentPath(id, step.attachmentId!);
|
||
if ((await fsp.stat(file)).size > 8 * 1024 * 1024)
|
||
throw ApiError.badRequest('结构化导入文件不可超过 8 MB');
|
||
result.steps = await preparePlan(user, result.planId, {
|
||
[step.attachmentId!]: { contentBase64: (await fsp.readFile(file)).toString('base64') },
|
||
});
|
||
}
|
||
}
|
||
signal.throwIfAborted();
|
||
await prisma.aiTask.update({
|
||
where: { id },
|
||
data: {
|
||
state: result.questions?.length ? 'waiting_input' : result.steps.length ? 'ready' : 'succeeded',
|
||
result: encryptSecret(JSON.stringify(result)),
|
||
},
|
||
});
|
||
if (input.supersedesTaskId && result.steps.length) {
|
||
const old = await owned(user, input.supersedesTaskId);
|
||
if (old.conversationId !== row.conversationId || old.state !== 'ready')
|
||
throw ApiError.conflict('原计划已变化,替换未完成,请分别核对计划');
|
||
if (active.has(old.id)) throw ApiError.conflict('原计划正在执行,不能替换');
|
||
const claimed = await prisma.aiTask.updateMany({
|
||
where: { id: old.id, state: 'ready' },
|
||
data: { state: 'superseded' },
|
||
});
|
||
if (!claimed.count) throw ApiError.conflict('原计划已变化,替换未完成');
|
||
const oldResult = decode<AiConversationResult>(old.result);
|
||
if (oldResult.planId) await discardPlan(user, oldResult.planId);
|
||
await prisma.aiTask.updateMany({
|
||
where: { id: old.id, state: 'ready' },
|
||
data: { state: 'superseded' },
|
||
});
|
||
}
|
||
emit({ type: 'status', message: result.steps.length ? '变更预览已准备,等待确认' : '处理完成' });
|
||
if (!result.steps.length && !result.questions?.length) await cleanup(id, input);
|
||
});
|
||
}
|
||
|
||
export async function executeTask(
|
||
user: TokenPayload,
|
||
id: string,
|
||
confirmation: Parameters<typeof confirmPlan>[2],
|
||
localPort: number,
|
||
) {
|
||
const row = await owned(user, id);
|
||
if (active.has(id)) return;
|
||
const result = row.result ? decode<AiConversationResult>(row.result) : undefined;
|
||
if (!result?.planId) throw ApiError.badRequest('请先生成操作预览');
|
||
const steps = await confirmPlan(user, result.planId, confirmation);
|
||
const input = decode<AiInterpretInput>(row.input);
|
||
for (const step of steps)
|
||
if (
|
||
step.status !== 'succeeded' &&
|
||
step.request?.attachmentId &&
|
||
!fs.existsSync(attachmentPath(id, step.request.attachmentId))
|
||
)
|
||
throw ApiError.badRequest('临时附件已过期,请重新上传原文件');
|
||
const claimed = await prisma.aiTask.updateMany({
|
||
where: { id, state: row.state },
|
||
data: { state: 'executing', error: '' },
|
||
});
|
||
if (!claimed.count) return;
|
||
launch(id, user, async (signal, emit) => {
|
||
for (const step of steps) {
|
||
signal.throwIfAborted();
|
||
if (step.status === 'succeeded') continue;
|
||
const request = step.request;
|
||
if (!request) throw ApiError.conflict('此步骤未确认,请重新核对');
|
||
emit({ type: 'status', message: `正在执行:${step.label}` });
|
||
// 地址只由本进程监听端口和确认后的动作目录生成,不接受模型 URL。
|
||
const url = new URL(`/api${request.path}`, `http://127.0.0.1:${localPort}`);
|
||
for (const [key, value] of Object.entries(request.query)) url.searchParams.set(key, String(value));
|
||
const file = request.attachmentId ? attachmentPath(id, request.attachmentId) : undefined;
|
||
const response = await fetch(url, {
|
||
method: request.method,
|
||
headers: {
|
||
authorization: `Bearer ${signToken(user)}`,
|
||
'x-classhelper-ai-step': step.id,
|
||
'content-type': file ? 'application/octet-stream' : 'application/json',
|
||
...(file ? { 'x-classhelper-ai-sha256': request.sha256! } : {}),
|
||
},
|
||
body: file
|
||
? (fs.createReadStream(file) as unknown as NonNullable<Parameters<typeof fetch>[1]>['body'])
|
||
: JSON.stringify(request.body),
|
||
...(file ? { duplex: 'half' } : {}),
|
||
signal: AbortSignal.timeout(600000),
|
||
});
|
||
const body = (await response.json()) as { message?: string };
|
||
if (!response.ok)
|
||
throw new ApiError(response.status, 'AI_READ_FAILED', body.message || '此步骤未完成,后续步骤已暂停');
|
||
emit({ type: 'status', message: `已完成:${step.label}` });
|
||
}
|
||
result.steps = await getPlan(user, result.planId!);
|
||
await prisma.aiTask.update({
|
||
where: { id },
|
||
data: { state: 'succeeded', result: encryptSecret(JSON.stringify(result)) },
|
||
});
|
||
await cleanup(id, input);
|
||
});
|
||
}
|
||
export async function stopTask(user: TokenPayload, id: string) {
|
||
await owned(user, id);
|
||
const controller = active.get(id);
|
||
if (controller) controller.abort();
|
||
else
|
||
await prisma.aiTask.update({
|
||
where: { id },
|
||
data: { state: 'stopped', error: '任务已按你的要求停止。' },
|
||
});
|
||
}
|
||
|
||
export async function createConversation(user: TokenPayload) {
|
||
await assertPermission(user, 'ai:use');
|
||
return prisma.aiConversation.create({ data: { userId: user.sub } });
|
||
}
|
||
async function ownedConversation(user: TokenPayload, id: string) {
|
||
await assertPermission(user, 'ai:use');
|
||
const row = await prisma.aiConversation.findFirst({ where: { id, userId: user.sub } });
|
||
if (!row) throw ApiError.forbidden('无法访问此对话');
|
||
return row;
|
||
}
|
||
export async function conversations(user: TokenPayload, before?: string) {
|
||
await assertPermission(user, 'ai:use');
|
||
const legacy = await prisma.aiTask.findMany({
|
||
where: { userId: user.sub, conversationId: null },
|
||
take: 100,
|
||
});
|
||
for (const old of legacy)
|
||
await prisma.$transaction(async (tx) => {
|
||
const c = await tx.aiConversation.upsert({
|
||
where: { id: old.id },
|
||
create: {
|
||
id: old.id,
|
||
userId: user.sub,
|
||
title: sanitizePrompt(decode<AiInterpretInput>(old.input).text).slice(0, 80),
|
||
createdAt: old.createdAt,
|
||
},
|
||
update: {},
|
||
});
|
||
await tx.aiTask.updateMany({
|
||
where: { id: old.id, conversationId: null },
|
||
data: { conversationId: c.id },
|
||
});
|
||
});
|
||
return prisma.aiConversation.findMany({
|
||
where: { userId: user.sub },
|
||
orderBy: [{ updatedAt: 'desc' }, { id: 'desc' }],
|
||
take: 30,
|
||
...(before ? { cursor: { id: before }, skip: 1 } : {}),
|
||
});
|
||
}
|
||
export async function conversationTurns(user: TokenPayload, id: string, before?: number) {
|
||
await ownedConversation(user, id);
|
||
const rows = await prisma.aiTask.findMany({
|
||
where: { conversationId: id, userId: user.sub, ...(before ? { turnNumber: { lt: before } } : {}) },
|
||
orderBy: { turnNumber: 'desc' },
|
||
take: 30,
|
||
});
|
||
return Promise.all(rows.reverse().map((row) => task(user, row.id)));
|
||
}
|
||
|
||
/** 删除自己的对话,不回滚已执行业务,也不删除业务审计。 */
|
||
export async function deleteConversation(user: TokenPayload, id: string) {
|
||
await ownedConversation(user, id);
|
||
const rows = await prisma.$transaction(async (tx) => {
|
||
const locked = await tx.aiConversation.updateMany({
|
||
where: { id, userId: user.sub },
|
||
data: { updatedAt: new Date() },
|
||
});
|
||
if (!locked.count) throw ApiError.forbidden('无法访问此对话');
|
||
const tasks = await tx.aiTask.findMany({ where: { conversationId: id, userId: user.sub } });
|
||
if (tasks.some((t) => active.has(t.id) || ['planning', 'executing'].includes(t.state)))
|
||
throw ApiError.conflict('对话仍有后台任务,请先停止或等待完成后再删除');
|
||
const planIds = tasks.flatMap((t) =>
|
||
t.result ? [decode<AiConversationResult>(t.result).planId].filter((p): p is string => Boolean(p)) : [],
|
||
);
|
||
if (
|
||
await tx.aiPlanStep.count({ where: { auditId: { in: planIds }, userId: user.sub, state: 'running' } })
|
||
)
|
||
throw ApiError.conflict('业务操作正在执行,请等待完成后再删除');
|
||
await tx.aiPlanStep.updateMany({
|
||
where: {
|
||
auditId: { in: planIds },
|
||
userId: user.sub,
|
||
state: { in: ['draft', 'prepared', 'confirmed', 'failed'] },
|
||
},
|
||
data: { state: 'blocked', result: JSON.stringify({ message: '对话已删除,未完成计划已取消' }) },
|
||
});
|
||
await tx.aiTask.deleteMany({ where: { conversationId: id, userId: user.sub } });
|
||
await tx.aiConversation.delete({ where: { id } });
|
||
return tasks;
|
||
});
|
||
for (const row of rows)
|
||
await cleanup(row.id, decode<AiInterpretInput>(row.input)).catch(() =>
|
||
logger.warn('AI 对话已删除,暂存附件清理未完成'),
|
||
);
|
||
return { id };
|
||
}
|