Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import type { DeferredHistoryWork } from '@cindy/maker-shared/message-window';
import {
buildMessageRenderItems,
extractTodosFromSourceMessage,
formatDuration,
type MessageRenderAgentTaskItem,
type MessageRenderItem,
type MessageRenderOptions,
type MessageRenderMessageItem,
type MessageRenderThinkingItem,
type MessageRenderTodoCardItem,
type MessageRenderTodoItem,
type MessageRenderToolGroupItem,
type MessageRenderToolMediaItem,
type MessageRenderWorkChildItem,
type MessageRenderWorkGroupItem,
} from '@cindy/maker-shared/message-render';
import type { AgentTaskStatus, AgentTaskUpdate } from '@cindy/maker-shared/agent-task';
import type { MobilePendingSendItem } from '@/session/pendingSendItems';
import { normalizeRemoteMessages, type NormalizedRemoteMessage } from '@/session/messageNormalize';
import type { RemoteMessage } from '@/session/types';
import {
buildSubagentAwareRenderItems,
buildSubagentResultMeta,
hasSubagentMessages,
} from '@/session/subagentGrouping';
const MAX_VALID_DATE_MS = 8.64e15;
export type MobileTodoItem = MessageRenderTodoItem;
export type MobileMessageItem = MessageRenderMessageItem<NormalizedRemoteMessage>;
export type MobileThinkingItem = MessageRenderThinkingItem<NormalizedRemoteMessage>;
export type MobileToolGroupItem = MessageRenderToolGroupItem<NormalizedRemoteMessage>;
export type MobileToolMediaItem = MessageRenderToolMediaItem<NormalizedRemoteMessage>;
export type MobileTodoCardItem = MessageRenderTodoCardItem;
export type MobileAgentTaskItem = MessageRenderAgentTaskItem<NormalizedRemoteMessage>;
export type MobileWorkChildItem = MessageRenderWorkChildItem<NormalizedRemoteMessage>;
export type MobileWorkGroupItem = MessageRenderWorkGroupItem<NormalizedRemoteMessage>;
/**
* 真·子 agent 嵌套卡片(手机端净新能力)。由 parentUuid 分桶构建(见 subagentGrouping),
* 替换顶层那条 `Agent` tool_use、包住其内层 children(递归)、Agent 的 tool_result 作 summary。
* 这是 mobile-only render item,shared 的 MessageRenderItem 类型不动。
*/
export interface MobileSubagentGroupItem {
type: 'subagent_group';
sourceClientId?: string;
deferred?: DeferredHistoryWork;
key: string;
header: { description: string | null; subagentType: string | null };
/** 子 agent 内层 render items(递归,可含更深 subagent_group)。 */
childItems: MobileMessageRenderItem[];
/** 子 agent 终稿(Agent 的 tool_result,经 tool_use_id 配对);无则 null。 */
summary: string | null;
// 终态来自 host 持久化的结构化 Agent/Task 生命周期,绝不解析总结正文。
status: AgentTaskStatus;
durationMs?: number;
}
export interface MobileForkOriginItem {
type: 'fork_origin';
key: string;
parentSessionId: string;
forkedAtMessageId: string;
}
export interface MobileForkOrigin {
parentSessionId: string;
forkedAtMessageId: string;
forkedSessionCreatedAt: string;
}
export type MobileMessageRenderItem =
| MessageRenderItem<NormalizedRemoteMessage>
| MobileSubagentGroupItem
| MobileForkOriginItem
// 待发送气泡(排队 / 落定 / 本地 outbox)也是消息流的一等项:与正式消息同容器同 key,
// 回流时原地变实,不再跨 footer↔data 搬家(见 pendingSendItems.ts 的说明)。
| MobilePendingSendItem;
export function buildMobileMessageRenderItems(
messages: readonly RemoteMessage[],
options: MessageRenderOptions & {
autoResumePending?: Record<string, unknown> | null;
sessionId?: string;
preserveSourceOrder?: boolean;
sessionSource?: string | null;
} = {},
taskUpdates?: ReadonlyMap<string, AgentTaskUpdate>,
): MobileMessageRenderItem[] {
const normalized = normalizeRemoteMessages(messages, options);
scopeUnsettledToolsToActiveTail(normalized);
markTurnFinalAssistants(normalized, options.isSessionStreaming === true);
if (options.autoResumePending) {
const pendingCreatedAtMs = messageCreatedMs(normalized.at(-1));
normalized.push(...normalizeRemoteMessages([{
id: 'mobile:auto-resume-pending',
clientId: 'mobile:auto-resume-pending',
sessionId: options.sessionId ?? messages[0]?.sessionId ?? '',
role: 'user',
content: '',
toolUseId: null,
agentMeta: { autoResume: true, autoResumeInfo: { ...options.autoResumePending, live: true } },
createdAt: pendingCreatedAtMs === null || pendingCreatedAtMs >= MAX_VALID_DATE_MS ? '' : new Date(pendingCreatedAtMs + 1).toISOString(),
}]));
}
collapseConsecutiveAutoResumeCards(normalized);
// 无子 agent(Claude `Agent` 嵌套)→ 走原始线性路径,并接上 live agent_task 卡:
// Task / collab:* 工具调用按 toolUseId→clientId 链接;无对应工具调用的孤儿更新兜底
// 仅在会话运行中(isSessionStreaming)生效——空闲时孤儿是 stale 残留(工具调用已滑出
// 分页窗口),渲染会把旧子 agent 卡重放到消息流末尾(收口在 shared buildLinearItems)。
if (!hasSubagentMessages(normalized)) {
return dropSyntheticTriggerItems(buildMessageRenderItems(normalized, options, taskUpdates));
}
// 有 Claude `Agent` 嵌套 → 走 #311 的子 agent 分组路径:Agent 调用已被表达成更丰富的 subagent_group
// 卡(嵌套 children + 终稿 summary + 状态)。此路径内部按 run 多次调用 buildMessageRenderItems,若再
// 灌入 taskUpdates,孤儿兜底会在每个 run 重复追加同一张卡;且 agent_task_update 是 live-only、在该
// 路径触发的历史/持久化场景下通常为空。故此处不另渲染 agent_task,避免重复(Agent 状态由 subagent_group 表达)。
return dropSyntheticTriggerItems(
buildSubagentAwareRenderItems(normalized, buildSubagentResultMeta(messages), options),
);
}
/**
* 剔除合成 UI 指令行(桌面「失败后继续」等隐藏续跑 prompt,对齐桌面 MessageStream
* 渲染 null 的口径)。必须在 render items 构建**之后**过滤而不是在 normalize 时丢弃:
* turn 边界判定(markTurnFinalAssistants / scopeUnsettledToolsToActiveTail)需要这条
* user 行作为新一轮的边界,提前丢弃会让上一轮被中断的历史工具行在续跑时重新转圈。
* 消息搜索走过滤后的 render items,自然搜不到隐藏指令。
*/
function dropSyntheticTriggerItems(items: MobileMessageRenderItem[]): MobileMessageRenderItem[] {
return items.filter(
(item) => !(item.type === 'message' && item.message.isSyntheticTrigger === true && !item.message.systemCardType),
);
}
/** 同一次中断只展示最新状态;旧行仍作为 turn boundary 留在 normalized 流中。 */
function collapseConsecutiveAutoResumeCards(messages: NormalizedRemoteMessage[]): void {
let hasNewerCard = false;
for (let index = messages.length - 1; index >= 0; index--) {
const message = messages[index];
if (message.systemCardType === 'auto-resume') {
if (hasNewerCard) delete message.systemCardType;
hasNewerCard = true;
} else if (
message.systemCardType
|| (message.isSyntheticTrigger !== true && message.kind !== 'thinking'
&& (message.kind === 'tool' || !!message.attachments?.length || /[^\s\p{Cf}\p{Cc}]/u.test(message.body)))
) hasNewerCard = false;
}
}
export function extractTodosFromMessage(message: RemoteMessage): MobileTodoItem[] | null {
return extractTodosFromSourceMessage(message);
}
/**
* 标注每轮收尾正文(对齐桌面 #456:操作行只挂在每轮任务结束的最后一句正文上)。
* 口径:真实用户消息(kind='user' 且 label='user',排除 orca worker report)为 turn 边界;
* 每 turn 取最后一条 body 非空的 assistant 正文;子 agent 内层消息(agentMeta.parentUuid)
* 不参与——内层是过程内容,不挂操作行。尾部 turn 流式中恒不标,避免操作行随流式输出跳动。
*/
export function markTurnFinalAssistants(
normalized: readonly NormalizedRemoteMessage[],
isSessionStreaming: boolean,
): void {
const suppressTailFinalAssistant = isSessionStreaming && hasActiveLoadedTail(normalized);
let lastCandidate: NormalizedRemoteMessage | null = null;
let sealedAnswerFound = false;
for (const message of normalized) {
if (message.kind === 'user' && message.label === 'user' && !isSubagentChildMessage(message)) {
if (!sealedAnswerFound && lastCandidate) lastCandidate.isTurnFinalAssistant = true;
lastCandidate = null;
sealedAnswerFound = false;
continue;
}
if (
message.kind === 'assistant'
&& message.body.trim().length > 0
&& !isSubagentChildMessage(message)
) {
lastCandidate = message;
if (message.turnCompleted === true) {
message.isTurnFinalAssistant = true;
sealedAnswerFound = true;
}
}
}
if (!sealedAnswerFound && lastCandidate && !suppressTailFinalAssistant) {
lastCandidate.isTurnFinalAssistant = true;
}
}
function hasActiveLoadedTail(normalized: readonly NormalizedRemoteMessage[]): boolean {
let lastUserIndex = -1;
for (let index = normalized.length - 1; index >= 0; index--) {
const message = normalized[index];
if (message.kind === 'user' && message.label === 'user' && !isSubagentChildMessage(message)) {
lastUserIndex = index;
break;
}
}
const tail = lastUserIndex < 0 ? normalized : normalized.slice(lastUserIndex + 1);
if (tail.length === 0) return lastUserIndex >= 0;
if (tail.some((message) => message.isStreaming === true)) return true;
if (tail.some((message) => message.kind === 'tool' && message.toolSettled === false)) return true;
// 忽略尾部本地 system card(/pwd、/context、compact/status 等经 appendLocalSystemCard
// 追加的卡片):它们挂在已完成回答之后、不代表进行中的工作。用最后一条非 system
// 内容项判定——若它是已完成的 assistant 终稿则不算 active(否则 send 起流时上一条
// 回答的操作行会被误抑制,直到下一条 user 行到达才恢复)。
let lastContent: NormalizedRemoteMessage | undefined;
for (let index = tail.length - 1; index >= 0; index--) {
if (tail[index].kind !== 'system') {
lastContent = tail[index];
break;
}
}
if (!lastContent) return false;
return lastContent.kind !== 'assistant';
}
function isSubagentChildMessage(message: NormalizedRemoteMessage): boolean {
const parent = message.source.agentMeta?.parentUuid;
return typeof parent === 'string' && parent.length > 0;
}
/**
* 历史 turn 的未完成工具按已完成收敛(对齐桌面 #454「历史 turn 恒 done」口径):
* 被中断的旧 turn 会永久缺 tool_result,若不收敛,会话后续流式时这些历史行会
* 重新转圈。running 状态只允许出现在最后一条真实用户消息之后的 active tail。
*/
export function scopeUnsettledToolsToActiveTail(
normalized: readonly NormalizedRemoteMessage[],
): void {
let lastUserIndex = -1;
for (let index = normalized.length - 1; index >= 0; index--) {
const message = normalized[index];
if (message.kind === 'user' && message.label === 'user' && !isSubagentChildMessage(message)) {
lastUserIndex = index;
break;
}
}
if (lastUserIndex < 0) return;
let settleBeforeIndex = lastUserIndex;
for (let index = normalized.length - 1; index > lastUserIndex; index--) {
const message = normalized[index];
if (
message.kind === 'assistant'
&& message.body.trim().length > 0
&& message.isStreaming !== true
&& !isSubagentChildMessage(message)
) {
settleBeforeIndex = index;
break;
}
}
for (let index = 0; index < settleBeforeIndex; index++) {
const message = normalized[index];
if (message.kind === 'tool' && message.toolSettled === false) {
message.toolSettled = true;
}
}
}
export function insertMobileForkOriginItem(
items: MobileMessageRenderItem[],
forkOrigin: MobileForkOrigin | null | undefined,
): MobileMessageRenderItem[] {
if (!forkOrigin) return items;
const forkCreatedMs = Date.parse(forkOrigin.forkedSessionCreatedAt);
if (Number.isNaN(forkCreatedMs)) return items;
let hasLoadedItemBeforeFork = false;
const insertAt = items.findIndex((item) => {
const itemMs = mobileRenderItemStartMs(item);
if (itemMs !== null && itemMs < forkCreatedMs) {
hasLoadedItemBeforeFork = true;
return false;
}
return itemMs !== null && itemMs >= forkCreatedMs;
});
if (!hasLoadedItemBeforeFork || insertAt < 0) return items;
const marker: MobileForkOriginItem = {
type: 'fork_origin',
key: `fork-origin-${forkOrigin.parentSessionId}-${forkOrigin.forkedAtMessageId}`,
parentSessionId: forkOrigin.parentSessionId,
forkedAtMessageId: forkOrigin.forkedAtMessageId,
};
return [...items.slice(0, insertAt), marker, ...items.slice(insertAt)];
}
function mobileRenderItemStartMs(item: MobileMessageRenderItem | MobileWorkChildItem): number | null {
if (item.type === 'message' || item.type === 'thinking') return messageCreatedMs(item.message);
if (item.type === 'tool_group' || item.type === 'tool_media') return messageCreatedMs(item.tools[0]);
if (item.type === 'todo' || item.type === 'agent_task') return parseCreatedMs(item.createdAt);
if (item.type === 'work_group') {
for (const child of item.children) {
const childMs = mobileRenderItemStartMs(child);
if (childMs !== null) return childMs;
}
}
if (item.type === 'subagent_group') {
for (const child of item.childItems) {
const childMs = mobileRenderItemStartMs(child);
if (childMs !== null) return childMs;
}
}
return null;
}
function messageCreatedMs(message: NormalizedRemoteMessage | undefined): number | null {
return parseCreatedMs(message?.createdAt);
}
function parseCreatedMs(createdAt: string | undefined): number | null {
if (!createdAt) return null;
const ms = Date.parse(createdAt);
return Number.isFinite(ms) ? ms : null;
}
export { formatDuration };