Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import type { ChatMessage } from '@/lib/makerChatStore';
import { groupWorkRuns, isCompletedAssistantMessage, type RenderItem } from './messageWorkGroups';
export interface MessageRenderProjection {
items: RenderItem[];
singleResultMap: Map<string, string>;
}
function sameFieldsExcept<T extends object>(previous: T, next: T, ignored: keyof T): boolean {
const keys = Object.keys(previous) as (keyof T)[];
return (
keys.length === Object.keys(next).length &&
keys.every(
(key) =>
Object.prototype.hasOwnProperty.call(next, key) &&
(key === ignored || Object.is(previous[key], next[key])),
)
);
}
/** Only a nonempty, plain streaming answer may bypass content-dependent history work. */
export function isStreamingTextOnlyUpdate(
previous: readonly ChatMessage[],
next: readonly ChatMessage[],
): boolean {
if (previous === next) return true;
if (previous.length === 0 || previous.length !== next.length) return false;
const last = next.length - 1;
const before = previous[last];
const after = next[last];
if (
before.role !== 'assistant' ||
before.systemCardType ||
before.isStreaming !== true ||
after.isStreaming !== true ||
!before.content.trim() ||
!after.content.trim() ||
!sameFieldsExcept(before, after, 'content')
)
return false;
// HistoryView normalizes live rows into fresh objects. Equal shallow fields
// still describe the same immutable row; any metadata/content change rebuilds.
for (let index = 0; index < last; index++) {
const beforeRow = previous[index];
const afterRow = next[index];
if (
beforeRow !== afterRow &&
(beforeRow.content !== afterRow.content || !sameFieldsExcept(beforeRow, afterRow, 'content'))
)
return false;
}
return true;
}
/** For metadata-only consumers. Never use this snapshot to display or copy answer text. */
export function createMessageMetadataProjection() {
let previous: ChatMessage[] | undefined;
return (messages: ChatMessage[]): ChatMessage[] => {
if (!previous || !isStreamingTextOnlyUpdate(previous, messages)) previous = messages;
return previous;
};
}
/** Metadata-only render-item consumers (gallery membership and user navigation).
* Never feed this snapshot to text rendering, copy, search or answer previews.
*/
export function createRenderItemMetadataProjection() {
let previous: RenderItem[] | undefined;
return (items: RenderItem[]): RenderItem[] => {
const unchanged =
previous &&
previous.length === items.length &&
items.every((item, index) => {
const before = previous![index];
return (
item === before ||
(index === items.length - 1 &&
item.type === 'message' &&
before.type === 'message' &&
item.key === before.key &&
isStreamingTextOnlyUpdate([before.message], [item.message]))
);
});
if (!unchanged) previous = items;
return previous!;
};
}
/** A view owns this projection; no session data survives its unmount. */
export function createStreamingMessageProjection() {
let previous:
| {
messages: readonly ChatMessage[];
dependencies: readonly unknown[];
result: MessageRenderProjection;
}
| undefined;
return (
messages: readonly ChatMessage[],
dependencies: readonly unknown[],
build: () => MessageRenderProjection,
allowTextReuse = true,
alreadyGrouped = false,
): MessageRenderProjection => {
let result: MessageRenderProjection | undefined;
if (
allowTextReuse &&
previous &&
previous.dependencies.length === dependencies.length &&
dependencies.every((value, index) => Object.is(value, previous!.dependencies[index]))
) {
if (previous.messages === messages) return previous.result;
if (isStreamingTextOnlyUpdate(previous.messages, messages)) {
const before = previous.messages[previous.messages.length - 1];
const after = messages[messages.length - 1];
const index = previous.result.items.findIndex(
(item) =>
item.type === 'message' &&
(item.message === before ||
(item.message.clientId === before.clientId &&
item.message.role === 'assistant' &&
item.message.content === before.content &&
item.message.isStreaming === true &&
!isCompletedAssistantMessage(item.message))),
);
// Hidden/subagent rows and special projections must still go through the full builder.
if (index >= 0 && (!alreadyGrouped || index === previous.result.items.length - 1)) {
const items = previous.result.items.slice();
const item = items[index] as Extract<RenderItem, { type: 'message' }>;
// A history row owns ordering metadata (notably createdAt). Live
// normalization may have a provisional timestamp: update only text.
items[index] = {
...item,
message: item.message === before ? after : { ...item.message, content: after.content },
};
result = { items, singleResultMap: previous.result.singleResultMap };
}
}
}
result ??= build();
previous = { messages, dependencies: [...dependencies], result };
return result;
};
}
/** Preserve unchanged work groups between successive projections of one view. */
export function createWorkGroupProjection() {
let previous = new Map<string, Extract<RenderItem, { type: 'work_group' }>>();
return (items: RenderItem[]): RenderItem[] => {
const next = new Map<string, Extract<RenderItem, { type: 'work_group' }>>();
const reuse = (item: RenderItem): RenderItem => {
if (item.type !== 'work_group') return item;
const children = item.children.map((child) => reuse(child) as typeof child);
const old = previous.get(item.key);
const unchanged =
old &&
sameFieldsExcept(old, item, 'children') &&
old.children.length === children.length &&
children.every((child, index) => child === old.children[index]);
const result = unchanged ? old : { ...item, children };
next.set(item.key, result);
return result;
};
const result = items.map(reuse);
previous = next; // Drop removed/prepended-away groups; this is not an unbounded key cache.
return result;
};
}
/**
* Plain active-tail text cannot change the activity runs before it. Reuse the
* already grouped history instead of rebuilding timestamps and nested wrappers.
* Only the last standalone, unsealed answer qualifies: earlier answers can cross
* delivery-prose thresholds and change which completed groups remain visible.
*/
export function createStreamingWorkGroupProjection(group = groupWorkRuns) {
const reuseGroups = createWorkGroupProjection();
let previous:
| { items: RenderItem[]; streaming: boolean; alreadyGrouped: boolean; result: RenderItem[] }
| undefined;
return (items: RenderItem[], streaming: boolean, alreadyGrouped = false): RenderItem[] => {
let result: RenderItem[] | undefined;
if (
previous &&
previous.streaming === streaming &&
previous.alreadyGrouped === alreadyGrouped
) {
if (previous.items === items) return previous.result;
const before = previous.items.at(-1);
const after = items.at(-1);
if (
streaming &&
!alreadyGrouped &&
before?.type === 'message' &&
after?.type === 'message' &&
before.key === after.key &&
!isCompletedAssistantMessage(before.message) &&
isStreamingTextOnlyUpdate([before.message], [after.message]) &&
previous.items.length === items.length &&
previous.result.at(-1) === before &&
items.every((item, index) => index === items.length - 1 || item === previous!.items[index])
) {
result = previous.result.slice();
result[result.length - 1] = after;
}
}
result ??= reuseGroups(alreadyGrouped ? items : group(items, streaming));
previous = { items, streaming, alreadyGrouped, result };
return result;
};
}