ai-chatbot/lib/canvas/feedback-context.ts

302 lines
10 KiB
TypeScript

import "server-only";
import { and, asc, desc, eq, gte, inArray, sql } from "drizzle-orm";
import { db } from "@/lib/db";
import {
canvasProject,
canvasAgentRun,
canvasCapabilityTask,
canvasImageTask,
chat,
message,
user,
} from "@/lib/db/schema";
import { feedbackMessages } from "./feedback-client";
import type {
FeedbackClient,
FeedbackContext,
FeedbackMessage,
FeedbackRequest,
} from "./feedback-contract";
export class CanvasFeedbackError extends Error {
status: number;
constructor(message: string, status = 400) {
super(message);
this.status = status;
}
}
const text = (value: unknown) => (typeof value === "string" ? value : "");
const duration = (started: Date | null, completed: Date | null) =>
started && completed ? Math.max(0, completed.getTime() - started.getTime()) : null;
function requestSummary(
column: typeof canvasImageTask.request | typeof canvasCapabilityTask.request,
) {
return sql<Record<string, unknown>>`jsonb_build_object(
'prompt', coalesce(${column}->'params'->>'prompt', ${column}->'input'->>'prompt', ${column}->>'displayPrompt', ${column}->>'prompt'),
'model', coalesce(${column}->'params'->>'model', ${column}->>'model'))`;
}
function requestParameters(request: Record<string, any>) {
const values = request.params || request.input || request;
const keys = [
"aspectRatio",
"imageSize",
"imageCount",
"sourceNodeIds",
"targetNodeIds",
"imageUrl",
"sourceImageUrl",
"referenceImage",
"referenceImages",
"region",
"selectionRect",
"width",
"height",
"operation",
"capabilityId",
];
const compact = (value: unknown): unknown => {
if (typeof value === "string")
return value.startsWith("data:") ? "内嵌图片,已省略二进制内容" : value.slice(0, 4000);
if (Array.isArray(value)) return value.slice(0, 20).map(compact);
return value;
};
return Object.fromEntries(
keys.filter((key) => values[key] !== undefined).map((key) => [key, compact(values[key])]),
);
}
export function feedbackConversationRequests(
messages: FeedbackMessage[],
verifiedIds: Set<string>,
) {
const requests: FeedbackRequest[] = [];
for (const item of messages) {
if (item.role === "user") {
requests.push({
key: `message:${item.id}`,
kind: "message",
id: item.id,
requestId: null,
createdAt: item.createdAt || "",
prompt: item.text,
status: "未获取任务状态",
model: null,
error: null,
evidence: verifiedIds.has(item.id) ? "server" : "browser",
});
} else {
const latest = item.userMessageId
? requests.find((request) => request.id === item.userMessageId)
: requests.at(-1);
if (!latest) continue;
if (item.requestId) latest.requestId = item.requestId;
if (item.status) latest.status = item.status;
if (item.error) latest.error = item.error;
}
}
return requests.filter((item) => item.prompt).reverse();
}
export async function collectCanvasFeedbackContext(
userId: string,
projectId: string,
client: FeedbackClient,
selection?: string | null,
): Promise<FeedbackContext> {
const [project] = await db
.select({ id: canvasProject.id, title: canvasProject.title })
.from(canvasProject)
.where(and(eq(canvasProject.id, projectId), eq(canvasProject.userId, userId)))
.limit(1);
if (!project) throw new CanvasFeedbackError("画布不存在或无权反馈该画布", 404);
const [reporter] = await db
.select({ id: user.id, name: user.name, email: user.email, department: user.department })
.from(user)
.where(eq(user.id, userId))
.limit(1);
if (!reporter) throw new CanvasFeedbackError("登录状态已失效,请重新登录", 401);
const [kind, selectedId] = (selection || "").split(":", 2);
const validId = /^[0-9a-f-]{36}$/i.test(selectedId || "");
const selectedMessage =
kind === "message" && validId && client.chatId
? (
await db
.select({ createdAt: message.createdAt })
.from(message)
.innerJoin(chat, and(eq(chat.id, message.chatId), eq(chat.userId, userId)))
.where(and(eq(message.chatId, client.chatId), eq(message.id, selectedId)))
.limit(1)
)[0]
: null;
const [runs, capabilities, storedMessages] = await Promise.all([
db
.select({
id: canvasAgentRun.id,
createdAt: canvasAgentRun.createdAt,
status: canvasAgentRun.status,
objective: sql<string>`${canvasAgentRun.snapshot}->>'objective'`,
errors: sql<
string[]
>`jsonb_path_query_array(${canvasAgentRun.snapshot}, '$.calls[*].error')`,
})
.from(canvasAgentRun)
.where(
and(
eq(canvasAgentRun.userId, userId),
eq(canvasAgentRun.projectId, projectId),
...(client.chatId ? [eq(canvasAgentRun.chatId, client.chatId)] : []),
...(kind === "agent" && validId ? [eq(canvasAgentRun.id, selectedId)] : []),
),
)
.orderBy(desc(canvasAgentRun.createdAt))
.limit(10),
db
.select({
id: canvasCapabilityTask.id,
requestId: canvasCapabilityTask.requestId,
capabilityId: canvasCapabilityTask.capabilityId,
createdAt: canvasCapabilityTask.createdAt,
startedAt: canvasCapabilityTask.startedAt,
completedAt: canvasCapabilityTask.completedAt,
status: canvasCapabilityTask.status,
error: canvasCapabilityTask.error,
request:
kind === "capability" && validId
? canvasCapabilityTask.request
: requestSummary(canvasCapabilityTask.request),
})
.from(canvasCapabilityTask)
.where(
and(
eq(canvasCapabilityTask.userId, userId),
eq(canvasCapabilityTask.projectId, projectId),
...(kind === "capability" && validId ? [eq(canvasCapabilityTask.id, selectedId)] : []),
),
)
.orderBy(desc(canvasCapabilityTask.createdAt))
.limit(10),
client.chatId
? db
.select({
id: message.id,
role: message.role,
parts: message.parts,
createdAt: message.createdAt,
})
.from(message)
.innerJoin(chat, and(eq(chat.id, message.chatId), eq(chat.userId, userId)))
.where(
and(
eq(message.chatId, client.chatId),
...(selectedMessage ? [gte(message.createdAt, selectedMessage.createdAt)] : []),
),
)
.orderBy(selectedMessage ? asc(message.createdAt) : desc(message.createdAt))
.limit(12)
: Promise.resolve([]),
]);
const verifiedIds = new Set(storedMessages.map((item) => item.id));
const serverById = new Map(
feedbackMessages(selectedMessage ? storedMessages : [...storedMessages].reverse()).map(
(item) => [item.id, item],
),
);
const browserIds = new Set(client.messages.map((item) => item.id));
const combined = [...serverById.values()].filter((item) => !browserIds.has(item.id));
combined.push(...client.messages.map((item) => ({ ...item, ...serverById.get(item.id) })));
// Browser stream metadata can arrive before the final assistant row is persisted.
const conversation = feedbackConversationRequests(combined, verifiedIds);
const imageIds = Array.from(
new Set(
[
...conversation.map((item) => item.requestId),
...client.nodes.map((node) => node.taskId),
].filter((id): id is string => Boolean(id && /^[0-9a-f-]{36}$/i.test(id))),
),
);
if (kind === "image" && validId) imageIds.push(selectedId);
const images = imageIds.length
? await db
.select({
id: canvasImageTask.id,
createdAt: canvasImageTask.createdAt,
startedAt: canvasImageTask.startedAt,
completedAt: canvasImageTask.completedAt,
status: canvasImageTask.status,
error: canvasImageTask.error,
request:
kind === "image" && validId
? canvasImageTask.request
: requestSummary(canvasImageTask.request),
})
.from(canvasImageTask)
.where(
and(
eq(canvasImageTask.userId, userId),
inArray(canvasImageTask.id, imageIds),
...(kind === "image" && validId ? [eq(canvasImageTask.id, selectedId)] : []),
),
)
.limit(12)
: [];
const requests: FeedbackRequest[] = [
...conversation,
...runs.map(
(run): FeedbackRequest => ({
key: `agent:${run.id}`,
kind: "agent",
id: run.id,
requestId: run.id,
createdAt: run.createdAt.toISOString(),
prompt: run.objective || "Agent 任务",
status: run.status,
model: null,
error: (run.errors || []).join("\n") || null,
evidence: "server",
}),
),
...capabilities.map((task): FeedbackRequest => {
const request = task.request as Record<string, any>;
return {
key: `capability:${task.id}`,
kind: "capability",
id: task.id,
requestId: task.requestId,
createdAt: task.createdAt.toISOString(),
prompt:
text(request.params?.prompt) ||
text(request.input?.prompt) ||
text(request.prompt) ||
task.capabilityId,
status: task.status,
model: text(request.params?.model) || text(request.model) || null,
error: task.error,
durationMs: duration(task.startedAt, task.completedAt),
parameters: requestParameters(request),
evidence: "server",
};
}),
...images.map((task): FeedbackRequest => {
const request = task.request as Record<string, any>;
return {
key: `image:${task.id}`,
kind: "image",
id: task.id,
requestId: task.id,
createdAt: task.createdAt.toISOString(),
prompt: text(request.displayPrompt) || text(request.prompt),
status: task.status,
model: text(request.model) || null,
error: task.error,
durationMs: duration(task.startedAt, task.completedAt),
parameters: requestParameters(request),
evidence: "server",
};
}),
];
requests.sort((a, b) => (Date.parse(b.createdAt) || 0) - (Date.parse(a.createdAt) || 0));
if (selection && !requests.some((item) => item.key === selection))
throw new CanvasFeedbackError("关联请求已变化,请重新选择要反馈的请求", 409);
return { project, reporter: { ...reporter, name: reporter.name || reporter.email }, requests };
}