613 lines
15 KiB
TypeScript
613 lines
15 KiB
TypeScript
import type {
|
|
ChatTimelineItem,
|
|
ChatTimelineKnowledgeHit,
|
|
ChatTimelineMessageItem,
|
|
ChatTimelineMessagePart,
|
|
ChatTimelineStatusItem,
|
|
ChatTimelineStatusStatus,
|
|
ChatTimelineStatusTone,
|
|
ChatTimelineThinkingStatus,
|
|
ChatTimelineToolApprovalPayload,
|
|
ChatTimelineToolItem,
|
|
ChatTimelineToolMode,
|
|
ChatTimelineToolStatus,
|
|
} from './types';
|
|
|
|
function createId(prefix: string) {
|
|
return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
|
|
}
|
|
|
|
function normalizeText(value: unknown) {
|
|
return value === null || value === undefined ? '' : String(value);
|
|
}
|
|
|
|
function normalizePayloadValue(value: unknown) {
|
|
if (value === null || value === undefined || value === '') {
|
|
return undefined;
|
|
}
|
|
if (typeof value === 'string') {
|
|
return value;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function normalizeToolName(value?: string) {
|
|
return normalizeText(value).trim().toLowerCase();
|
|
}
|
|
|
|
function isHiddenToolName(toolName?: string) {
|
|
const normalizedName = normalizeToolName(toolName);
|
|
return (
|
|
normalizedName === 'retrieve_knowledge' ||
|
|
normalizedName === 'context_reload' ||
|
|
normalizedName === '__fragment__'
|
|
);
|
|
}
|
|
|
|
function isKnowledgeRetrievalToolName(toolName?: string) {
|
|
return normalizeToolName(toolName) === 'retrieve_knowledge';
|
|
}
|
|
|
|
function isBlankToolName(toolName?: string) {
|
|
return !normalizeToolName(toolName);
|
|
}
|
|
|
|
function knowledgeRetrievalStatusKey(statusKey?: string) {
|
|
return normalizeText(statusKey).trim() || 'knowledge-retrieval';
|
|
}
|
|
|
|
function ensureMessageTail(
|
|
items: ChatTimelineItem[],
|
|
role: ChatTimelineMessageItem['role'],
|
|
status: ChatTimelineMessageItem['status'] = 'streaming',
|
|
metadata?: Partial<ChatTimelineMessageItem>,
|
|
) {
|
|
const last = items[items.length - 1];
|
|
if (
|
|
last?.type === 'message' &&
|
|
last.role === role &&
|
|
last.status !== 'done' &&
|
|
(!metadata?.roundId || last.roundId === metadata.roundId)
|
|
) {
|
|
last.status = status;
|
|
Object.assign(last, metadata);
|
|
return last;
|
|
}
|
|
const item: ChatTimelineMessageItem = {
|
|
id: createId(role),
|
|
role,
|
|
status,
|
|
createdAt: Date.now(),
|
|
parts: [],
|
|
type: 'message',
|
|
...metadata,
|
|
};
|
|
items.push(item);
|
|
return item;
|
|
}
|
|
|
|
function appendMessagePart(
|
|
message: ChatTimelineMessageItem,
|
|
part: ChatTimelineMessagePart,
|
|
) {
|
|
const tail = message.parts[message.parts.length - 1];
|
|
if (tail?.type === part.type) {
|
|
tail.content += part.content;
|
|
if (tail.type === 'thinking' && part.type === 'thinking') {
|
|
tail.status = part.status;
|
|
}
|
|
return;
|
|
}
|
|
message.parts.push(part);
|
|
}
|
|
|
|
function appendThinkingPart(
|
|
message: ChatTimelineMessageItem,
|
|
part: Extract<ChatTimelineMessagePart, { type: 'thinking' }>,
|
|
) {
|
|
appendMessagePart(message, part);
|
|
}
|
|
|
|
function appendTextPart(message: ChatTimelineMessageItem, content: string) {
|
|
appendMessagePart(message, {
|
|
id: createId('text'),
|
|
content,
|
|
type: 'text',
|
|
});
|
|
}
|
|
|
|
function replaceTextPart(message: ChatTimelineMessageItem, content: string) {
|
|
message.parts = [
|
|
...message.parts.filter((part) => part.type !== 'text'),
|
|
{
|
|
id: createId('text'),
|
|
content,
|
|
type: 'text' as const,
|
|
},
|
|
];
|
|
}
|
|
|
|
function updateThinkingStatus(
|
|
message: ChatTimelineMessageItem,
|
|
status: ChatTimelineThinkingStatus,
|
|
) {
|
|
message.parts = message.parts.map((part) =>
|
|
part.type === 'thinking' && part.status === 'thinking'
|
|
? { ...part, expanded: status === 'thinking', status }
|
|
: part,
|
|
);
|
|
}
|
|
|
|
function finishLastAssistantMessage(items: ChatTimelineItem[]) {
|
|
finishAssistantMessage(items, true);
|
|
}
|
|
|
|
function finishAssistantMessage(
|
|
items: ChatTimelineItem[],
|
|
roundCompleted: boolean,
|
|
) {
|
|
const lastMessage = [...items]
|
|
.reverse()
|
|
.find(
|
|
(item): item is ChatTimelineMessageItem =>
|
|
item.type === 'message' && item.role === 'assistant',
|
|
);
|
|
if (!lastMessage) {
|
|
return;
|
|
}
|
|
updateThinkingStatus(lastMessage, 'end');
|
|
lastMessage.status = lastMessage.status === 'error' ? 'error' : 'done';
|
|
if (lastMessage.status === 'done' && roundCompleted) {
|
|
lastMessage.roundCompleted = true;
|
|
}
|
|
}
|
|
|
|
function findToolItem(
|
|
items: ChatTimelineItem[],
|
|
toolCallId?: string,
|
|
taskId?: string,
|
|
sourceToolCallId?: string,
|
|
) {
|
|
const identities = new Set(
|
|
[toolCallId, sourceToolCallId]
|
|
.map((value) => normalizeText(value).trim())
|
|
.filter(Boolean),
|
|
);
|
|
const normalizedTaskId = normalizeText(taskId).trim();
|
|
if (identities.size === 0 && !normalizedTaskId) {
|
|
return undefined;
|
|
}
|
|
return items.find(
|
|
(item): item is ChatTimelineToolItem =>
|
|
item.type === 'tool' &&
|
|
((Boolean(normalizedTaskId) && item.taskId === normalizedTaskId) ||
|
|
(item.toolCallId ? identities.has(item.toolCallId) : false)),
|
|
);
|
|
}
|
|
|
|
function findStatusItem(items: ChatTimelineItem[], statusKey: string) {
|
|
return items.find(
|
|
(item): item is ChatTimelineStatusItem =>
|
|
item.type === 'status' && item.statusKey === statusKey,
|
|
);
|
|
}
|
|
|
|
function removeStatusItem(items: ChatTimelineItem[], statusKey: string) {
|
|
const index = items.findIndex(
|
|
(item) => item.type === 'status' && item.statusKey === statusKey,
|
|
);
|
|
if (index >= 0) {
|
|
items.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
function doneStatusLabel(item: ChatTimelineStatusItem) {
|
|
if (item.statusKey === 'knowledge-retrieval') {
|
|
return '已检索知识库';
|
|
}
|
|
if (item.statusKey === 'memory-compression') {
|
|
return '已整理上下文';
|
|
}
|
|
return item.label.replace(/^正在/, '已');
|
|
}
|
|
|
|
function finishRunningStatusItems(items: ChatTimelineItem[]) {
|
|
items.forEach((item) => {
|
|
if (item.type !== 'status' || item.status !== 'running') {
|
|
return;
|
|
}
|
|
item.status = 'done';
|
|
item.label = doneStatusLabel(item);
|
|
});
|
|
}
|
|
|
|
function upsertStatus(
|
|
items: ChatTimelineItem[],
|
|
payload: {
|
|
label: string;
|
|
presentation?: ChatTimelineStatusItem['presentation'];
|
|
status: ChatTimelineStatusStatus;
|
|
statusKey: string;
|
|
tone?: ChatTimelineStatusTone;
|
|
},
|
|
) {
|
|
const found = findStatusItem(items, payload.statusKey);
|
|
if (found) {
|
|
found.label = payload.label;
|
|
found.presentation = payload.presentation ?? found.presentation;
|
|
found.status = payload.status;
|
|
found.tone = payload.tone ?? found.tone;
|
|
return found;
|
|
}
|
|
const item: ChatTimelineStatusItem = {
|
|
id: payload.statusKey,
|
|
createdAt: Date.now(),
|
|
label: payload.label,
|
|
presentation: payload.presentation,
|
|
status: payload.status,
|
|
statusKey: payload.statusKey,
|
|
tone: payload.tone ?? 'muted',
|
|
type: 'status',
|
|
};
|
|
items.push(item);
|
|
return item;
|
|
}
|
|
|
|
function upsertTool(
|
|
items: ChatTimelineItem[],
|
|
payload: {
|
|
approval?: ChatTimelineToolApprovalPayload;
|
|
input?: unknown;
|
|
mode?: ChatTimelineToolMode;
|
|
output?: unknown;
|
|
rejectReason?: string;
|
|
requestId?: string;
|
|
resumeToken?: string;
|
|
sourceToolCallId?: string;
|
|
status?: ChatTimelineToolStatus;
|
|
taskId?: string;
|
|
toolCallId?: string;
|
|
toolName?: string;
|
|
},
|
|
) {
|
|
const toolCallId = normalizeText(
|
|
payload.toolCallId ?? payload.approval?.toolCallId,
|
|
).trim();
|
|
const taskId = normalizeText(payload.taskId).trim();
|
|
const found = findToolItem(
|
|
items,
|
|
toolCallId,
|
|
taskId,
|
|
payload.sourceToolCallId,
|
|
);
|
|
const approval = payload.approval ?? found?.approval;
|
|
const mode =
|
|
payload.mode === 'approval'
|
|
? 'approval'
|
|
: (found?.mode ?? payload.mode ?? (approval ? 'approval' : 'auto'));
|
|
const toolName =
|
|
payload.toolName ||
|
|
approval?.toolDisplayName ||
|
|
approval?.toolName ||
|
|
found?.toolName;
|
|
if (isHiddenToolName(toolName)) {
|
|
return found;
|
|
}
|
|
if (!found && isBlankToolName(toolName)) {
|
|
return undefined;
|
|
}
|
|
|
|
if (found) {
|
|
found.approval = approval;
|
|
found.input =
|
|
normalizePayloadValue(payload.input) ??
|
|
normalizePayloadValue(approval?.input) ??
|
|
found.input;
|
|
found.mode = mode;
|
|
found.output = normalizePayloadValue(payload.output) ?? found.output;
|
|
found.rejectReason = payload.rejectReason ?? found.rejectReason;
|
|
found.status = payload.status || found.status;
|
|
found.taskId = taskId || found.taskId;
|
|
found.toolCallId = toolCallId || found.toolCallId;
|
|
found.toolName = toolName || found.toolName;
|
|
return found;
|
|
}
|
|
|
|
const toolItem: ChatTimelineToolItem = {
|
|
id: toolCallId || createId('tool'),
|
|
approval,
|
|
createdAt: Date.now(),
|
|
input:
|
|
normalizePayloadValue(payload.input) ??
|
|
normalizePayloadValue(approval?.input),
|
|
mode,
|
|
output: normalizePayloadValue(payload.output),
|
|
rejectReason: payload.rejectReason,
|
|
status:
|
|
payload.status || (mode === 'approval' ? 'pending_approval' : 'running'),
|
|
taskId: taskId || undefined,
|
|
toolCallId,
|
|
toolName: toolName || '工具调用',
|
|
type: 'tool',
|
|
};
|
|
items.push(toolItem);
|
|
return toolItem;
|
|
}
|
|
|
|
export const ChatTimelineBuilder = {
|
|
appendUserMessage(
|
|
items: ChatTimelineItem[],
|
|
content?: unknown,
|
|
metadata?: Partial<ChatTimelineMessageItem>,
|
|
) {
|
|
const text = normalizeText(content);
|
|
if (!text && !metadata?.images?.length) {
|
|
return;
|
|
}
|
|
const item: ChatTimelineMessageItem = {
|
|
id: createId('user'),
|
|
role: 'user',
|
|
status: 'done',
|
|
createdAt: Date.now(),
|
|
parts: text
|
|
? [
|
|
{
|
|
id: createId('text'),
|
|
content: text,
|
|
type: 'text' as const,
|
|
},
|
|
]
|
|
: [],
|
|
type: 'message',
|
|
...metadata,
|
|
};
|
|
items.push(item);
|
|
},
|
|
|
|
appendThinkingDelta(
|
|
items: ChatTimelineItem[],
|
|
delta?: unknown,
|
|
metadata?: Partial<ChatTimelineMessageItem>,
|
|
) {
|
|
const text = normalizeText(delta);
|
|
if (!text) {
|
|
return;
|
|
}
|
|
const message = ensureMessageTail(
|
|
items,
|
|
'assistant',
|
|
'streaming',
|
|
metadata,
|
|
);
|
|
if (message.parts.some((part) => part.type === 'text')) {
|
|
return;
|
|
}
|
|
appendThinkingPart(message, {
|
|
id: createId('thinking'),
|
|
content: text,
|
|
expanded: true,
|
|
status: 'thinking',
|
|
type: 'thinking',
|
|
});
|
|
},
|
|
|
|
appendMessageDelta(
|
|
items: ChatTimelineItem[],
|
|
delta?: unknown,
|
|
metadata?: Partial<ChatTimelineMessageItem>,
|
|
) {
|
|
const text = normalizeText(delta);
|
|
if (!text) {
|
|
return;
|
|
}
|
|
const message = ensureMessageTail(
|
|
items,
|
|
'assistant',
|
|
'streaming',
|
|
metadata,
|
|
);
|
|
updateThinkingStatus(message, 'end');
|
|
appendTextPart(message, text);
|
|
},
|
|
|
|
replaceMessageContent(items: ChatTimelineItem[], content?: unknown) {
|
|
const text = normalizeText(content);
|
|
if (!text) {
|
|
return;
|
|
}
|
|
const message = ensureMessageTail(items, 'assistant', 'done');
|
|
updateThinkingStatus(message, 'end');
|
|
replaceTextPart(message, text);
|
|
},
|
|
|
|
appendToolApproval(
|
|
items: ChatTimelineItem[],
|
|
payload: ChatTimelineToolApprovalPayload,
|
|
) {
|
|
upsertTool(items, {
|
|
approval: payload,
|
|
input: payload.input,
|
|
mode: 'approval',
|
|
status: 'pending_approval',
|
|
toolCallId: payload.toolCallId,
|
|
toolName: payload.toolDisplayName || payload.toolName,
|
|
});
|
|
},
|
|
|
|
upsertToolCall(
|
|
items: ChatTimelineItem[],
|
|
payload: {
|
|
input?: unknown;
|
|
output?: unknown;
|
|
sourceToolCallId?: string;
|
|
status?: ChatTimelineToolStatus;
|
|
statusKey?: string;
|
|
taskId?: string;
|
|
toolCallId?: string;
|
|
toolName?: string;
|
|
},
|
|
) {
|
|
if (isKnowledgeRetrievalToolName(payload.toolName)) {
|
|
ChatTimelineBuilder.upsertKnowledgeRetrievalStatus(
|
|
items,
|
|
payload.status === 'success' ? 'done' : 'running',
|
|
payload.statusKey,
|
|
);
|
|
return;
|
|
}
|
|
upsertTool(items, {
|
|
...payload,
|
|
mode: 'auto',
|
|
status: payload.status || 'running',
|
|
});
|
|
},
|
|
|
|
upsertKnowledgeRetrievalStatus(
|
|
items: ChatTimelineItem[],
|
|
status: ChatTimelineStatusStatus,
|
|
statusKey?: string,
|
|
) {
|
|
finishAssistantMessage(items, false);
|
|
upsertStatus(items, {
|
|
label: status === 'running' ? '正在检索知识库' : '已检索知识库',
|
|
status,
|
|
statusKey: knowledgeRetrievalStatusKey(statusKey),
|
|
tone: 'muted',
|
|
});
|
|
},
|
|
|
|
upsertMemoryCompressionStatus(
|
|
items: ChatTimelineItem[],
|
|
payload?: {
|
|
compressed?: boolean;
|
|
label?: string;
|
|
phase?: string;
|
|
status?: string;
|
|
statusKey?: string;
|
|
},
|
|
) {
|
|
const status =
|
|
payload?.status === 'done' || payload?.phase === 'completed'
|
|
? 'done'
|
|
: 'running';
|
|
const statusKey = payload?.statusKey || 'memory-compression';
|
|
finishAssistantMessage(items, false);
|
|
if (status === 'done' && payload?.compressed === false) {
|
|
removeStatusItem(items, statusKey);
|
|
return;
|
|
}
|
|
const label =
|
|
status === 'running'
|
|
? payload?.label || '正在整理上下文'
|
|
: payload?.label || '已整理上下文';
|
|
upsertStatus(items, {
|
|
label,
|
|
status,
|
|
statusKey,
|
|
presentation: 'separator',
|
|
tone: 'muted',
|
|
});
|
|
},
|
|
|
|
markToolApproving(
|
|
items: ChatTimelineItem[],
|
|
payload: {
|
|
requestId?: string;
|
|
resumeToken?: string;
|
|
toolCallId?: string;
|
|
},
|
|
) {
|
|
upsertTool(items, {
|
|
...payload,
|
|
mode: 'approval',
|
|
status: 'approving',
|
|
});
|
|
},
|
|
|
|
markToolRejected(
|
|
items: ChatTimelineItem[],
|
|
payload: {
|
|
reason?: string;
|
|
requestId?: string;
|
|
resumeToken?: string;
|
|
toolCallId?: string;
|
|
},
|
|
) {
|
|
upsertTool(items, {
|
|
...payload,
|
|
mode: 'approval',
|
|
rejectReason: payload.reason,
|
|
status: 'rejected',
|
|
});
|
|
},
|
|
|
|
appendKnowledge(
|
|
items: ChatTimelineItem[],
|
|
knowledgeItems: ChatTimelineKnowledgeHit[],
|
|
) {
|
|
if (knowledgeItems.length === 0) {
|
|
return;
|
|
}
|
|
const lastAssistantMessage = [...items]
|
|
.reverse()
|
|
.find(
|
|
(item): item is ChatTimelineMessageItem =>
|
|
item.type === 'message' && item.role === 'assistant',
|
|
);
|
|
if (lastAssistantMessage) {
|
|
lastAssistantMessage.knowledgeItems = [
|
|
...(lastAssistantMessage.knowledgeItems || []),
|
|
...knowledgeItems,
|
|
];
|
|
return;
|
|
}
|
|
const last = items[items.length - 1];
|
|
if (last?.type === 'knowledge') {
|
|
last.items.push(...knowledgeItems);
|
|
return;
|
|
}
|
|
items.push({
|
|
id: createId('knowledge'),
|
|
createdAt: Date.now(),
|
|
items: knowledgeItems,
|
|
type: 'knowledge',
|
|
});
|
|
},
|
|
|
|
appendError(items: ChatTimelineItem[], message?: unknown) {
|
|
const text = normalizeText(message) || '请求失败';
|
|
const last = items[items.length - 1];
|
|
if (last?.type === 'message' && last.role === 'assistant') {
|
|
updateThinkingStatus(last, 'error');
|
|
last.status = 'error';
|
|
}
|
|
items.push({
|
|
id: createId('error'),
|
|
createdAt: Date.now(),
|
|
message: text,
|
|
type: 'error',
|
|
});
|
|
},
|
|
|
|
finalize(items: ChatTimelineItem[]) {
|
|
finishRunningStatusItems(items);
|
|
finishLastAssistantMessage(items);
|
|
},
|
|
|
|
replaceRoundAssistant(
|
|
items: ChatTimelineItem[],
|
|
roundId: string,
|
|
message: ChatTimelineMessageItem,
|
|
) {
|
|
const targetIndex = items.findIndex(
|
|
(item): item is ChatTimelineMessageItem =>
|
|
item.type === 'message' &&
|
|
item.role === 'assistant' &&
|
|
item.roundId === roundId,
|
|
);
|
|
if (targetIndex >= 0) {
|
|
items.splice(targetIndex, 1, message);
|
|
}
|
|
},
|
|
};
|