302 lines
10 KiB
TypeScript
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 };
|
|
}
|