From bbbbd4e4ad2872ec1ecf242c6a48e446b38aab02 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:19:24 +0800 Subject: [PATCH] Import apps/android/src/state/message-helpers.ts --- apps/android/src/state/message-helpers.ts | 488 ++++++++++++++++++++++ 1 file changed, 488 insertions(+) create mode 100644 apps/android/src/state/message-helpers.ts diff --git a/apps/android/src/state/message-helpers.ts b/apps/android/src/state/message-helpers.ts new file mode 100644 index 0000000..cd126f3 --- /dev/null +++ b/apps/android/src/state/message-helpers.ts @@ -0,0 +1,488 @@ +import type { ChatItem, HistoryEntry } from '../types' + +export function findApproval(messages: Record, itemId: string) { + for (const items of Object.values(messages)) { + const found = items.find(item => item.kind === 'approval' && item.id === itemId) + if (found !== undefined && found.kind === 'approval') return found + } + return undefined +} + +export function findQuestion(messages: Record, itemId: string) { + for (const items of Object.values(messages)) { + const found = items.find(item => item.kind === 'question' && item.id === itemId) + if (found !== undefined && found.kind === 'question') return found + } + return undefined +} + +export function mapApprovalOutcome( + messages: Record, + itemId: string, + outcome: 'allowed-once' | 'rejected', +): Record { + return mapItems(messages, item => item.kind === 'approval' && item.id === itemId + ? { ...item, outcome } + : item) +} + +export function mapQuestionAnswered( + messages: Record, + itemId: string, +): Record { + return mapItems(messages, item => item.kind === 'question' && item.id === itemId + ? { ...item, outcome: 'answered' as const } + : item) +} + +function mapItems( + messages: Record, + map: (item: ChatItem) => ChatItem, +): Record { + return Object.fromEntries(Object.entries(messages).map(([sessionId, items]) => [sessionId, items.map(map)])) +} + +/** One queued prompt as rendered in the queue dock. */ +export interface InboxQueuedItem { + /** Host queue item id — the target of `session.updateQueue` actions. */ + id?: string + rpcId?: string + preview: string +} + +/** + * Queued prompts from the Host `inbox` projection. Only `next-turn` entries are + * user-visible queue items; `next-step` is the agent's internal continuation + * input (mirrors the official QueueDock, which renders `next-turn` only). + * In DS-Bot 0.3.0 (#663), only user-authored kinds (`user`, `schedule`, + * `user-question-reply`) belong in the QueueDock; team Bot-to-Bot relays + * (`source.kind === 'bot'`) are filtered out. + */ +const OWN_QUEUE_KINDS = new Set(['user', 'schedule', 'user-question-reply']) + +export function inboxQueuedItems(inbox: unknown): InboxQueuedItem[] { + const record = typeof inbox === 'object' && inbox !== null ? inbox as Record : {} + const rows = Array.isArray(record['next-turn']) ? record['next-turn'] : [] + const items: InboxQueuedItem[] = [] + for (const row of rows) { + if (typeof row !== 'object' || row === null) { items.push({ preview: '' }); continue } + const source = (row as Record).source + const sourceKind = typeof source === 'object' && source !== null ? (source as Record).kind : undefined + if (typeof sourceKind === 'string' && !OWN_QUEUE_KINDS.has(sourceKind)) continue + const rpcId = typeof source === 'object' && source !== null ? (source as Record).rpcId : undefined + const id = (row as Record).id + const content = (row as Record).content + const preview = Array.isArray(content) + ? content.flatMap(block => typeof block === 'object' && block !== null + && (block as Record).type === 'text' + && typeof (block as Record).text === 'string' + ? [(block as Record).text as string] : []).join(' ') + : '' + items.push({ + ...(typeof id === 'string' && id.length > 0 ? { id } : {}), + ...(typeof rpcId === 'string' && rpcId.length > 0 ? { rpcId } : {}), + preview, + }) + } + return items +} + +/** Extract queued-prompt rpcIds from the Host `inbox` projection (`next-turn`). */ +export function inboxRpcIds(inbox: unknown): Set { + const ids = new Set() + for (const item of inboxQueuedItems(inbox)) { + if (item.rpcId !== undefined) ids.add(item.rpcId) + } + return ids +} + +/** + * Delivery-state reconciliation against Host truth (no timers, no deletions): + * after a fresh history load plus an `inbox` snapshot, an optimistic row whose + * prompt is in neither source and that predates the current connection is + * judged — `queued` becomes `canceled` (removed remotely / claimed and later + * healed by its echo) and `unconfirmed` becomes `failed` (retryable). Rows are + * always kept: a late `user/message` echo still replaces them by requestRpcId. + */ +export function reconcileDeliveryStates( + items: ChatItem[], + queuedRpcIds: ReadonlySet, + historyRpcIds: ReadonlySet, + sentBefore: number, +): ChatItem[] { + return items.map(item => { + // `failed` keeps its retry material and `canceled` is terminal (user + // removal / authoritative drop) — re-judging either would resurrect a + // removed prompt as resendable. + if (item.kind !== 'message' || item.sendState === 'failed' || item.sendState === 'canceled') return item + if (item.requestRpcId === undefined || item.createdAt >= sentBefore) return item + if (historyRpcIds.has(item.requestRpcId) || queuedRpcIds.has(item.requestRpcId)) return item + // A row without a local verdict only needs settling when the inbox adopted + // it and its echo never landed (lost-echo hole: it would hide forever). + if (item.sendState === undefined && item.queuedAdopted !== true) return item + return { ...item, sendState: item.sendState === 'unconfirmed' ? 'failed' as const : 'canceled' as const } + }) +} + +export function mergeHistoryAndLive(history: ChatItem[], live: ChatItem[], throughSeq?: number): ChatItem[] { + const liveById = new Map(live.map(item => [item.id, item])) + const historyIds = new Set(history.map(item => item.id)) + const boundary = throughSeq ?? Math.max(-1, ...history.map(item => item.nativeSeq ?? item.nativeOrderSeq ?? -1)) + const requests = new Set(history.flatMap(item => item.kind === 'message' && item.requestRpcId !== undefined ? [item.requestRpcId] : [])) + const closedTurns = new Set(history.flatMap(item => { + if (item.turnEnd === undefined) return [] + const owner = item.turn ?? (item.kind === 'message' ? item.replyGroup : undefined) + return owner === undefined ? [] : [owner] + })) + const activeHistoryTurn = (() => { + for (let index = history.length - 1; index >= 0; index -= 1) { + const item = history[index]! + if (item.turnEnd !== undefined) return undefined + const owner = item.turn ?? (item.kind === 'message' ? item.replyGroup : undefined) + if (owner !== undefined) return owner + if (item.kind === 'message' && item.role === 'user' && !item.context) return undefined + } + return undefined + })() + const resolveInteractionTurn = (item: Extract): string | undefined => { + if (item.callId !== undefined) { + const matched = history.find(row => row.kind === 'tool' && row.id === item.callId) + if (matched?.turn !== undefined) return matched.turn + } + if (item.outcome === undefined) { + const runningTool = [...history].reverse().find(row => row.kind === 'tool' && row.state === 'running' + && (item.kind === 'approval' || (row.toolKey ?? row.toolName) === 'ask_user_question')) + if (runningTool?.turn !== undefined) return runningTool.turn + if (activeHistoryTurn !== undefined && (item.turn === undefined || closedTurns.has(item.turn))) { + return activeHistoryTurn + } + } + return item.turn + } + const result = [ + ...history.map(item => { + const cached = liveById.get(item.id) + if (cached === undefined) return item + const historySeq = item.nativeRevisionSeq ?? item.nativeSeq ?? item.nativeOrderSeq ?? -1 + const liveSeq = cached.nativeRevisionSeq ?? cached.nativeSeq ?? cached.nativeOrderSeq ?? -1 + const authoritative = liveSeq > historySeq ? cached : item + return authoritative.kind === 'message' && cached.kind === 'message' + ? { ...authoritative, ...(authoritative.feedback === undefined && cached.feedback !== undefined ? { feedback: cached.feedback } : {}), + ...(authoritative.role === 'user' && authoritative.images === undefined && cached.images !== undefined ? { images: cached.images } : {}) } + : authoritative + }), + ...live.filter(item => { + if (historyIds.has(item.id)) return false + if (item.kind === 'message' && item.requestRpcId !== undefined && requests.has(item.requestRpcId)) return false + // A follow snapshot replaces transient chunks already covered by its cursor. + if (item.kind === 'message' && item.streaming && (item.nativeRevisionSeq ?? item.nativeSeq ?? item.nativeOrderSeq ?? Infinity) <= boundary) return false + return true + }).map(item => { + if (item.kind !== 'approval' && item.kind !== 'question') return item + const turn = resolveInteractionTurn(item) + return turn === item.turn ? item : { ...item, ...(turn === undefined ? {} : { turn }) } + }), + ] + return result.sort((a, b) => { + const left = a.nativeOrderSeq ?? a.nativeSeq + const right = b.nativeOrderSeq ?? b.nativeSeq + if (left === undefined && right === undefined) return 0 + if (left === undefined) return 1 + if (right === undefined) return -1 + return left - right + }) +} + +/** Reconcile durable `userQuestions` projection rows into the session's chat items. */ +export function reconcileUserQuestionsProjection( + items: ChatItem[], + sessionId: string, + userQuestions: unknown, + inbox?: unknown, +): ChatItem[] { + if (typeof userQuestions !== 'object' || userQuestions === null || Array.isArray(userQuestions)) return items + const view = userQuestions as Record + if (!Array.isArray(view.active) || !Array.isArray(view.settled)) return items + const queuedReplyCallIds = new Set() + if (typeof inbox === 'object' && inbox !== null && !Array.isArray(inbox)) { + const inboxRecord = inbox as Record + for (const row of [ + ...(Array.isArray(inboxRecord['next-step']) ? inboxRecord['next-step'] : []), + ...(Array.isArray(inboxRecord['next-turn']) ? inboxRecord['next-turn'] : []), + ]) { + if (typeof row !== 'object' || row === null || Array.isArray(row)) continue + const source = (row as Record).source + if (typeof source !== 'object' || source === null || Array.isArray(source)) continue + const sourceRecord = source as Record + if (sourceRecord.kind === 'user-question-reply' && typeof sourceRecord.callId === 'string') { + queuedReplyCallIds.add(sourceRecord.callId) + } + } + } + const settledCallIds = new Set() + for (const row of view.settled) { + if (typeof row === 'object' && row !== null && typeof (row as Record).callId === 'string') { + settledCallIds.add((row as Record).callId as string) + } + } + const activeRows = view.active.flatMap(row => { + if (typeof row !== 'object' || row === null || Array.isArray(row)) return [] + const item = row as Record + if (typeof item.callId !== 'string' || !Array.isArray(item.questions) || item.questions.length === 0 + || (item.state !== 'open' && item.state !== 'continued')) return [] + return [{ + callId: item.callId, + questions: item.questions as import('../types').AskUserQuestionItem[], + state: item.state as 'open' | 'continued', + }] + }) + const activeByCallId = new Map(activeRows.map(row => [row.callId, row])) + const activeTurn = (() => { + for (let index = items.length - 1; index >= 0; index -= 1) { + const item = items[index]! + if (item.turnEnd !== undefined) return undefined + const owner = item.turn ?? (item.kind === 'message' ? item.replyGroup : undefined) + if (owner !== undefined) return owner + if (item.kind === 'message' && item.role === 'user' && !item.context) return undefined + } + return undefined + })() + const seenCallIds = new Set() + let changed = false + const updated = items.map((item): ChatItem => { + if (item.kind !== 'question' || item.callId === undefined) return item + seenCallIds.add(item.callId) + if (settledCallIds.has(item.callId)) { + if (item.outcome === 'answered') return item + changed = true + return { ...item, outcome: 'answered' as const } + } + const active = activeByCallId.get(item.callId) + if (active === undefined) { + if (item.outcome !== undefined) return item + changed = true + return { ...item, outcome: 'cancelled' as const } + } + const rpcId = `timed-question:${JSON.stringify([sessionId, active.callId])}` + const matchedTool = items.find(row => row.kind === 'tool' && row.id === active.callId) + const turn = matchedTool?.turn ?? item.turn ?? activeTurn + const nextOutcome = active.state === 'continued' && queuedReplyCallIds.has(active.callId) + ? 'queued' as const + : item.outcome === 'answered' || item.outcome === 'queued' + ? item.outcome + : undefined + if (item.frameRpcId === rpcId && item.questionState === active.state && item.outcome === nextOutcome && item.turn === turn && item.questions === active.questions) { + return item + } + changed = true + return { + ...item, + frameRpcId: item.frameRpcId ?? rpcId, + questions: active.questions, + questionState: active.state, + ...(turn === undefined ? {} : { turn }), + outcome: nextOutcome, + } + }) + const appended: ChatItem[] = [] + for (const active of activeRows) { + if (seenCallIds.has(active.callId)) continue + if (active.state === 'continued' && queuedReplyCallIds.has(active.callId)) continue + const rpcId = `timed-question:${JSON.stringify([sessionId, active.callId])}` + const matchedTool = items.find(row => row.kind === 'tool' && row.id === active.callId) + const turn = matchedTool?.turn ?? activeTurn + appended.push({ + kind: 'question', + id: `question:${rpcId}`, + sessionId, + callId: active.callId, + questionState: active.state, + frameRpcId: rpcId, + questions: active.questions, + ...(turn === undefined ? {} : { turn }), + createdAt: Date.now(), + }) + } + return !changed && appended.length === 0 ? items : [...updated, ...appended] +} + +export type ChatSection = + | { kind: 'item'; key: string; item: ChatItem } + | { kind: 'process'; key: string; turn: string; items: ChatItem[] } + +/** Group adjacent activity from one native turn, leaving user rows in place. */ +export function chatSections(items: ChatItem[], previous?: readonly ChatSection[]): ChatSection[] { + // Two phases on purpose: build fresh buffers first, then hand back the old + // object per key when nothing about it moved. Pushing into `sections.at(-1)` + // while reusing a previous section would mutate the array the previous + // render still holds, which is exactly the corruption this cache must avoid. + const drafts: ChatSection[] = [] + for (const item of items) { + const turn = item.kind === 'message' && item.role === 'user' + ? undefined + : item.turn ?? (item.kind === 'message' ? item.replyGroup : undefined) + const last = drafts.at(-1) + if (turn !== undefined && last?.kind === 'process' && last.turn === turn) { + last.items.push(item) + } else if (turn !== undefined) { + drafts.push({ kind: 'process', key: `process:${turn}:${item.id}`, turn, items: [item] }) + } else { + drafts.push({ kind: 'item', key: item.id, item }) + } + } + if (previous === undefined || previous.length === 0) return drafts + const reusable = new Map() + for (const section of previous) reusable.set(section.key, section) + const sections: ChatSection[] = [] + for (const draft of drafts) { + const old = reusable.get(draft.key) + if (old === undefined || old.kind !== draft.kind) { + sections.push(draft) + } else if (draft.kind === 'item') { + sections.push(old.kind === 'item' && old.item === draft.item ? old : draft) + } else { + sections.push(old.kind === 'process' && sameItems(old.items, draft.items) ? old : draft) + } + } + return sections +} + +/** True when both lists carry the same objects in the same order. */ +function sameItems(a: readonly ChatItem[], b: readonly ChatItem[]): boolean { + if (a.length !== b.length) return false + for (let index = 0; index < a.length; index += 1) { + if (a[index] !== b[index]) return false + } + return true +} + +/** + * Fold assistant reasoning fragments from one native turn into one disclosure. + * + * Native Harness and CodeX timelines can expose reasoning/plan items separately + * from the final assistant message. Keeping those rows separate makes one + * reply look like several unrelated answers. A reasoning-only row remains as + * the live placeholder until text arrives; once there is an answer, all of the + * turn's reasoning is attached to that answer and the placeholder is removed. + */ +export function mergeReplyReasoning(items: ChatItem[]): ChatItem[] { + const output: ChatItem[] = [] + const groups = new Map() + + for (const item of items) { + if (item.kind !== 'message' || item.role !== 'assistant' || item.replyGroup === undefined) { + output.push(item) + continue + } + + const group = groups.get(item.replyGroup) ?? { reasoning: [] } + groups.set(item.replyGroup, group) + const textVisible = hasVisibleText(item.text) || (item.images?.length ?? 0) > 0 + const reasoningVisible = hasVisibleText(item.reasoning ?? '') + + if (reasoningVisible) group.reasoning.push(item.reasoning!) + + if (textVisible) { + // Reasoning may have arrived as one or more rows before the answer. + // Remove those placeholders while leaving any intervening tool rows. + if (group.pendingIndex !== undefined) { + output.splice(group.pendingIndex, 1) + if (group.anchorIndex !== undefined && group.anchorIndex > group.pendingIndex) { + group.anchorIndex -= 1 + } + group.pendingIndex = undefined + } + const merged = group.reasoning.length === 0 + ? item + : { ...item, reasoning: joinReasoning(group.reasoning) } + output.push(merged) + group.anchorIndex = output.length - 1 + continue + } + + if (!reasoningVisible) { + output.push(item) + continue + } + + if (group.anchorIndex !== undefined) { + // A later reasoning/plan item in the same turn belongs to the already + // visible answer, even when a tool row occurred between the two. + const anchor = output[group.anchorIndex] + if (anchor?.kind === 'message') { + output[group.anchorIndex] = { + ...anchor, + reasoning: joinReasoning(group.reasoning), + ...(item.streaming === undefined ? {} : { streaming: item.streaming }), + ...(item.streamingPhase === undefined ? {} : { streamingPhase: item.streamingPhase }), + } + } + continue + } + + if (group.pendingIndex === undefined) { + output.push({ ...item, reasoning: joinReasoning(group.reasoning) }) + group.pendingIndex = output.length - 1 + } else { + const pending = output[group.pendingIndex] + if (pending?.kind === 'message') { + output[group.pendingIndex] = { + ...pending, + reasoning: joinReasoning(group.reasoning), + ...(item.streaming === undefined ? {} : { streaming: item.streaming }), + ...(item.streamingPhase === undefined ? {} : { streamingPhase: item.streamingPhase }), + } + } + } + } + + return output +} + +function hasVisibleText(value: string): boolean { + return value.replace(/[\s\u00AD\u034F\u061C\u180E\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/gu, '').length > 0 +} + +function joinReasoning(parts: string[]): string { + return parts.filter(hasVisibleText).join('\n\n') +} + +/** Prepend an older history page in front of the current chat items, deduplicated by id. */ +export function prependHistory(older: ChatItem[], current: ChatItem[]): ChatItem[] { + return mergeHistoryAndLive(older, current) +} + +/** Smallest event seq in a history page; drives the next `session.history` beforeSeq. */ +export function oldestSeq(events: HistoryEntry[]): number | undefined { + let oldest: number | undefined + for (const entry of events) { + const seq = entry.event.seq + if (Number.isSafeInteger(seq)) oldest = oldest === undefined ? seq : Math.min(oldest, seq) + } + return oldest +} + +/** + * Distance from the newest row that still counts as "at the latest message". + * Follow mode and the jump-to-latest button share this edge, so the button + * appears exactly when the viewport has left the turn streaming appends to. + */ +export const LATEST_EDGE_PX = 80 + +/** + * Cheap signature of the latest chat item so streaming token deltas trigger auto-scroll + * without deep item re-rendering. + */ +export function computeStreamingSignature(items: readonly ChatItem[]): string { + if (items.length === 0) return '' + const last = items[items.length - 1] + if (last === undefined) return '' + if (last.kind === 'message') { + return `${last.id}:${last.text.length}:${last.reasoning?.length ?? 0}:${last.turnEnd ? last.turnEnd.reason : ''}:${last.sendState ?? ''}` + } + return `${last.id}:${last.kind}` +}