@beeuni/sdk 0.2.0 → 0.3.0

package/dist/core/session-log/turns/turn.d.ts

@@ -0,0 +1,55 @@
+import type { SessionPrompt } from '../../rest/projects-client/sessions.js';
+import { type GatewayErrorDetails } from '../../turns/errors.js';
+import type { ModelPricingLookup, TurnCostInfo } from '../../turns/types.js';
+import { type AttachmentBlock, type CompactionBlock, type SessionLogBlock, type SessionLogMessage, type SessionLogThread, type TextBlock, type ToolCallBlock } from '../types.js';
+export type SessionLogTurnStatus = 'pending' | SessionLogMessage['status'];
+export type SessionLogCallStatus = ToolCallBlock['status'] | 'interrupted';
+export interface SessionLogTurnError {
+    code: string;
+    message: string;
+    details?: GatewayErrorDetails;
+    raw?: string;
+}
+export interface SessionLogCompaction {
+    block: CompactionBlock | null;
+    hasContent: boolean;
+    inFlight: boolean;
+}
+export interface SessionLogContinuation {
+    marker: string;
+    prompt: string | null;
+}
+export interface SessionLogTurn {
+    id: string;
+    user: SessionLogMessage;
+    assistant: SessionLogMessage[];
+    partial: boolean;
+    continues: SessionLogContinuation | null;
+    blocks: SessionLogBlock[];
+    status: SessionLogTurnStatus;
+    error: SessionLogTurnError | null;
+    cost: TurnCostInfo | null;
+    compaction: SessionLogCompaction | null;
+    threads: string[];
+    plan: boolean;
+    shell: ToolCallBlock | null;
+    response: TextBlock | null;
+    attachments: AttachmentBlock[];
+    live: boolean;
+    queued: boolean;
+    retrying: boolean;
+}
+export interface SessionLogTurnsOptions {
+    busy?: boolean;
+    liveMessageId?: string | null;
+    held?: readonly string[];
+    threads?: ReadonlyArray<Pick<SessionLogThread, 'thread_id' | 'spawned_by'>>;
+    pricing?: ModelPricingLookup;
+    hideOutOfContext?: boolean;
+}
+export declare const isClosedByRule: (b: ToolCallBlock) => boolean;
+export declare function sessionLogCallStatus(call: ToolCallBlock, live: boolean): SessionLogCallStatus;
+export declare function sessionLogPromptMessage(prompt: SessionPrompt, threadId: string): SessionLogMessage;
+export declare function usageCostOf(replies: SessionLogMessage[], lookup?: ModelPricingLookup): TurnCostInfo | null;
+export declare function sessionLogRetrying(thread: Pick<SessionLogThread, 'messages'>): boolean;
+export declare function sessionLogTurns(source: SessionLogThread, options?: SessionLogTurnsOptions): SessionLogTurn[];

package/dist/core/session-log/turns/turn.js

@@ -0,0 +1,279 @@
+import { extractGatewayErrorDetails, rawErrorText, unwrapError } from '../../turns/errors.js';
+import { hasRetryingAssistantTurn } from '../../turns/open-turn.js';
+import { getChildSessionId, shouldShowToolPart } from '../../turns/parts.js';
+import { resolveWorkingTurn } from '../../turns/segments/working-turn.js';
+import { getTurnTokens } from '../../turns/state.js';
+import { toolKind } from '../../turns/tool-kind.js';
+import { SESSION_LOG_MINOR, SESSION_LOG_SCHEMA, } from '../types.js';
+import { isV1Thread } from '../v1-view.js';
+import { messageOfBlock, v1RowsOf } from './v1-parts.js';
+const V1_IMPORT = 'beeuni-v1-import';
+function getTurnCost(parts, _lookup) {
+    const tokens = getTurnTokens(parts);
+    return tokens ? { cost: null, tokens } : undefined;
+}
+const V = { schema: SESSION_LOG_SCHEMA, v: SESSION_LOG_MINOR };
+function last(list, test) {
+    for (let i = list.length - 1; i >= 0; i--)
+        if (test(list[i]))
+            return list[i];
+    return undefined;
+}
+const isCall = (b) => b.type === 'tool_call';
+const isOpen = (b) => b.status === 'pending' || b.status === 'running';
+export const isClosedByRule = (b) => b.status === 'error' && (b.result?.synthetic === true || b.result?.error?.code === 'interrupted');
+export function sessionLogCallStatus(call, live) {
+    const closed = isClosedByRule(call);
+    if (!isOpen(call) && !closed)
+        return call.status;
+    if (!live)
+        return 'interrupted';
+    return call.status === 'running' || (closed && call.started_at) ? 'running' : 'pending';
+}
+const prompts = new WeakMap();
+export function sessionLogPromptMessage(prompt, threadId) {
+    const cached = prompts.get(prompt);
+    if (cached)
+        return cached;
+    const ms = typeof prompt.client_sent_at_ms === 'number' ? prompt.client_sent_at_ms : Date.parse(prompt.created_at);
+    const message = {
+        ...V, message_id: prompt.message_id || `queued-${prompt.prompt_id}`, thread_id: threadId, seq: Number.MAX_SAFE_INTEGER, role: 'user', kind: 'turn',
+        status: 'complete', in_context: true, origin: 'prompt', model: null, usage: null, finish: null, error: null,
+        created_at: Number.isFinite(ms) ? new Date(ms).toISOString() : '', completed_at: null,
+        producer: { harness: 'beeuni-inbox', harness_version: '', adapter_version: '1' },
+        blocks: [{ type: 'text', id: `syn-${prompt.prompt_id}`, text: prompt.full_text ?? prompt.text }],
+    };
+    prompts.set(prompt, message);
+    return message;
+}
+const standIns = new WeakMap();
+function standInFor(reply) {
+    let m = standIns.get(reply);
+    if (!m) {
+        m = {
+            ...V, message_id: reply.reply_to, thread_id: reply.thread_id, seq: reply.seq, role: 'user', kind: 'turn', status: 'complete', in_context: true,
+            model: null, usage: null, finish: null, error: null, created_at: reply.created_at, completed_at: null, producer: reply.producer, blocks: [],
+        };
+        standIns.set(reply, m);
+    }
+    return m;
+}
+const continuations = new WeakMap();
+function continuationOf(marker) {
+    let m = continuations.get(marker);
+    if (!m) {
+        m = {
+            ...V, message_id: `${marker.message_id}:continued`, thread_id: marker.thread_id, seq: marker.seq, role: 'user', kind: 'turn', status: 'complete', in_context: true,
+            model: null, usage: null, finish: null, error: null, created_at: marker.created_at, completed_at: null, producer: marker.producer, blocks: [],
+        };
+        continuations.set(marker, m);
+    }
+    return m;
+}
+const isEmptyShell = (m) => !m.error && m.blocks.length === 0 && !(m.usage && (m.usage.input || m.usage.output || m.usage.reasoning));
+function drafts(messages, held) {
+    const turns = [];
+    const byId = new Map();
+    for (const m of messages) {
+        if (m.role !== 'user' || m.kind === 'context' || byId.has(m.message_id))
+            continue;
+        const d = { user: m, assistant: [], partial: false };
+        byId.set(m.message_id, d);
+        turns.push(d);
+    }
+    const partials = [];
+    const leading = [];
+    const order = new Map();
+    const continued = new Map();
+    let last = null;
+    let compaction = null;
+    for (const m of messages) {
+        if (m.role === 'user') {
+            const d = byId.get(m.message_id);
+            if (d && !held.has(m.message_id)) {
+                last = d;
+                if (!order.has(d))
+                    order.set(d, order.size);
+                if (d.user.kind === 'compaction')
+                    compaction = d;
+            }
+            continue;
+        }
+        if (m.role !== 'assistant' || isEmptyShell(m))
+            continue;
+        const named = m.reply_to ? byId.get(m.reply_to) : undefined;
+        let home = named ?? last;
+        if (compaction && home && (home === compaction || (order.get(home) ?? Infinity) < order.get(compaction))) {
+            let next = continued.get(compaction);
+            if (!next) {
+                next = { user: continuationOf(compaction.user), assistant: [], partial: true, continues: { marker: compaction.user.message_id, prompt: home === compaction ? null : home.user.message_id } };
+                continued.set(compaction, next);
+            }
+            home = next;
+        }
+        if (home) {
+            home.assistant.push(m);
+            continue;
+        }
+        if (!m.reply_to) {
+            leading.push(m);
+            continue;
+        }
+        const current = partials[partials.length - 1];
+        if (current && current.user.message_id === m.reply_to)
+            current.assistant.push(m);
+        else
+            partials.push({ user: standInFor(m), assistant: [m], partial: true });
+    }
+    if (leading.length) {
+        const first = turns[0] ?? partials[0];
+        if (first)
+            first.assistant.unshift(...leading);
+        else
+            turns.push({ user: leading[0], assistant: leading.slice(1), partial: false });
+    }
+    const shown = turns.filter((t) => !held.has(t.user.message_id)).flatMap((t) => {
+        const next = continued.get(t);
+        return next ? [t, next] : [t];
+    });
+    return [...partials, ...shown, ...[...held].flatMap((id) => byId.get(id) ?? [])];
+}
+function continuedHint(list, hint) {
+    if (!hint)
+        return hint;
+    let out = hint;
+    for (const d of list) {
+        const c = d.continues;
+        if (c && (out === c.marker || out === c.prompt || hint === c.prompt))
+            out = d.user.message_id;
+    }
+    return out;
+}
+function errorOf(d) {
+    const sources = d.user.kind === 'compaction' ? [d.user, ...d.assistant] : d.assistant;
+    const m = sources.find((x) => x.error);
+    if (!m?.error)
+        return null;
+    const error = v1RowsOf(m)[0]?.info?.error ?? m.error.message;
+    const details = extractGatewayErrorDetails(error);
+    const raw = rawErrorText(error);
+    return { code: m.error.code, message: details?.message || unwrapError(error), ...(details && { details }), ...(raw !== undefined && { raw }) };
+}
+function costOf(replies, exact, lookup) {
+    if (replies.length && replies.every(exact)) {
+        return getTurnCost(replies.flatMap((m) => v1RowsOf(m).flatMap((row) => row.parts.map((part) => ({ part, message: row })))), lookup) ?? null;
+    }
+    return usageCostOf(replies, lookup);
+}
+export function usageCostOf(replies, lookup) {
+    const parts = replies.flatMap((m) => {
+        const u = m.usage;
+        if (!u)
+            return [];
+        const part = { type: 'step-finish', cost: u.cost ?? 0, tokens: { input: u.input, output: u.output, reasoning: u.reasoning ?? 0, cache: { read: u.cache_read, write: u.cache_write } } };
+        return [{ part, message: { info: { id: m.message_id, role: 'assistant', providerID: m.model?.provider, modelID: m.model?.model }, parts: [part] } }];
+    });
+    return getTurnCost(parts, lookup) ?? null;
+}
+function compactionOf(user) {
+    if (user.kind !== 'compaction')
+        return null;
+    const block = user.blocks.find((b) => b.type === 'compaction') ?? null;
+    return { block, hasContent: !!block?.summary?.trim(), inFlight: user.status === 'streaming' };
+}
+function shellOf(d) {
+    const prompt = d.user.blocks;
+    if (!prompt.length || !prompt.every((b) => b.type === 'text' && b.synthetic))
+        return null;
+    const only = d.assistant.length === 1 && d.assistant[0].blocks.length === 1 ? d.assistant[0].blocks[0] : null;
+    return only && isCall(only) && only.name === 'bash' ? only : null;
+}
+function threadsOf(d, blocks, heads, known) {
+    if (!heads.length)
+        return [];
+    const replies = new Set(d.assistant.map((m) => m.message_id));
+    const out = new Set();
+    for (const h of heads)
+        if (h.spawned_by && replies.has(h.spawned_by.message_id))
+            out.add(h.thread_id);
+    for (const b of blocks) {
+        const id = b.type === 'subtask' ? b.thread_id : isCall(b) ? getChildSessionId(b) : undefined;
+        if (id && known.has(id))
+            out.add(id);
+    }
+    return [...out];
+}
+const writesPlan = (d) => d.assistant.some((m) => m.blocks.some((b) => isCall(b) && toolKind(b.name) === 'todowrite' && shouldShowToolPart(b)));
+const cache = new WeakMap();
+const NONE = [];
+export function sessionLogRetrying(thread) {
+    const reply = last(thread.messages, (m) => m.role === 'assistant');
+    return !!reply && hasRetryingAssistantTurn(v1RowsOf(reply));
+}
+const inContext = new WeakMap();
+function inContextOnly(thread) {
+    let out = inContext.get(thread);
+    if (!out) {
+        const messages = thread.messages.filter((m) => m.in_context || m.status === 'streaming');
+        out = messages.length === thread.messages.length ? thread : { ...thread, messages };
+        inContext.set(thread, out);
+    }
+    return out;
+}
+export function sessionLogTurns(source, options = {}) {
+    const thread = options.hideOutOfContext ? inContextOnly(source) : source;
+    const held = new Set(options.held ?? NONE);
+    const list = drafts(thread.messages, held);
+    const lastReply = last(thread.messages, (m) => m.role === 'assistant');
+    const retrying = sessionLogRetrying(thread);
+    const working = resolveWorkingTurn({
+        turns: list.map((d) => ({
+            userMessage: { info: { id: d.user.message_id } },
+            assistantMessages: d.assistant.map((m) => ({ info: { time: m.status === 'streaming' ? {} : { completed: 1 }, error: m.error ?? undefined } })),
+        })),
+        hintMessageId: continuedHint(list, options.liveMessageId),
+        unrunTurnIds: held,
+    });
+    const anchor = last(list, writesPlan) ?? list[list.length - 1];
+    const v1Thread = isV1Thread(thread);
+    const exact = (m) => v1Thread || m.producer.harness === V1_IMPORT;
+    const heads = options.threads ?? [];
+    const known = new Set(heads.map((h) => h.thread_id));
+    return list.map((d) => {
+        const live = options.busy === true && working.workingTurnId === d.user.message_id;
+        const queued = working.pendingTurnIds.includes(d.user.message_id);
+        const retries = retrying && d.assistant.includes(lastReply);
+        const key = `${d.partial}|${live}|${queued}|${d === anchor}|${retries}`;
+        const prev = cache.get(d.user);
+        if (prev && prev.key === key && prev.pricing === options.pricing && prev.heads === options.threads && prev.assistant.length === d.assistant.length && prev.assistant.every((m, i) => m === d.assistant[i]))
+            return prev.turn;
+        const blocks = d.assistant.flatMap((m) => m.blocks);
+        for (const m of d.assistant)
+            for (const b of m.blocks)
+                messageOfBlock.set(b, m);
+        const threads = threadsOf(d, blocks, heads, known);
+        const reply = d.assistant[d.assistant.length - 1];
+        const turn = {
+            id: d.user.message_id,
+            user: d.user,
+            assistant: d.assistant,
+            partial: d.partial,
+            continues: d.continues ?? null,
+            blocks,
+            status: retries ? 'streaming' : reply ? reply.status : d.user.kind === 'compaction' ? d.user.status : 'pending',
+            error: errorOf(d),
+            cost: costOf([d.user, ...d.assistant], exact, options.pricing),
+            compaction: compactionOf(d.user),
+            threads,
+            plan: d === anchor,
+            shell: shellOf(d),
+            response: last(blocks, (b) => b.type === 'text' && !!b.text.trim()) ?? null,
+            attachments: d.user.blocks.filter((b) => b.type === 'attachment' && (b.mime.startsWith('image/') || b.mime === 'application/pdf')),
+            live,
+            queued,
+            retrying: retries,
+        };
+        cache.set(d.user, { assistant: d.assistant, key, pricing: options.pricing, heads: options.threads, turn });
+        return turn;
+    });
+}

package/dist/core/session-log/turns/v1-parts.d.ts

@@ -0,0 +1,8 @@
+import type { Part } from '../../runtime/runtime-types.js';
+import { type SessionLogBlock, type SessionLogMessage } from '../types.js';
+import { type V1MessageRow } from '../v1-view.js';
+export declare const messageOfBlock: WeakMap<SessionLogBlock, SessionLogMessage>;
+export declare function partOf(block: SessionLogBlock): Part | undefined;
+export declare const blockOf: (part: object) => SessionLogBlock;
+export declare const partsOf: (list: ReadonlyArray<SessionLogBlock>) => Part[];
+export declare function v1RowsOf(m: SessionLogMessage): V1MessageRow[];

package/dist/core/session-log/turns/v1-parts.js

@@ -0,0 +1,43 @@
+import { blockPartOf } from '../tool-call.js';
+import { SESSION_LOG_MINOR, SESSION_LOG_SCHEMA } from '../types.js';
+import { rowsOf } from '../v1-view.js';
+const blocks = new WeakMap();
+export const messageOfBlock = new WeakMap();
+const fallbacks = new WeakMap();
+export function partOf(block) {
+    let part;
+    const message = messageOfBlock.get(block);
+    if (message)
+        part = partsById(message).get(block.id);
+    if (part)
+        return blocks.set(part, block), part;
+    if (block.type !== 'harness')
+        part = blockPartOf(block);
+    else if (typeof block.data?.type === 'string')
+        part = block.data;
+    else if (block.model_visible && block.fallback_text !== undefined) {
+        part = fallbacks.get(block) ?? { id: block.id, type: 'text', text: block.fallback_text, synthetic: true };
+        fallbacks.set(block, part);
+    }
+    if (part)
+        blocks.set(part, block);
+    return part;
+}
+export const blockOf = (part) => blocks.get(part);
+export const partsOf = (list) => list.flatMap((b) => partOf(b) ?? []);
+const indexes = new WeakMap();
+function partsById(m) {
+    let index = indexes.get(m);
+    if (!index)
+        indexes.set(m, (index = new Map(v1RowsOf(m)[0]?.parts.map((p) => [p.id, p]))));
+    return index;
+}
+const heads = new Map();
+export function v1RowsOf(m) {
+    let head = heads.get(m.thread_id);
+    if (!head) {
+        head = { schema: SESSION_LOG_SCHEMA, v: SESSION_LOG_MINOR, thread_id: m.thread_id, parent_thread_id: null, spawned_by: null, agent: null, title: null, created_at: '' };
+        heads.set(m.thread_id, head);
+    }
+    return rowsOf(head, m);
+}

package/dist/core/session-log/v1-view.d.ts

@@ -1,10 +1,13 @@
 import type { Message, Part } from '../runtime/runtime-types.js';
 import type { SessionLogState, SessionLogThreadHead } from './store.js';
-import { type SessionLog } from './types.js';
+import { type SessionLog, type SessionLogMessage, type SessionLogThread } from './types.js';
 export interface V1MessageRow {
     info: Message;
     parts: Part[];
 }
 export declare const isV1Thread: (head: SessionLogThreadHead | undefined) => boolean;
-export declare function sessionLogRowsFor<R extends V1MessageRow>(logs: Record<string, SessionLogState>, runtimeSessionId: string, v1Rows: R[]): R[];
+export declare function rowsOf(head: SessionLogThreadHead, message: SessionLogMessage): V1MessageRow[];
+export type OptimisticEchoOf = (id: string) => string | undefined;
+export declare function sessionLogRowsFor<R extends V1MessageRow>(logs: Record<string, SessionLogState>, runtimeSessionId: string, v1Rows: R[], echoOf?: OptimisticEchoOf): R[];
+export declare function sessionLogThreadWithV1Rows(state: SessionLogState, thread: SessionLogThread, v1Rows: readonly V1MessageRow[], echoOf?: OptimisticEchoOf): SessionLogThread;
 export declare function sessionLogOfV1Rows(sessionId: string, runtimeSessionId: string, rows: readonly V1MessageRow[]): SessionLog;

package/dist/core/session-log/v1-view.js

@@ -21,7 +21,7 @@ const nativeOf = (head) => {
     return e ? (e.native_id ?? null) : head.thread_id;
 };
 const messageRows = new WeakMap();
-function rowsOf(head, message) {
+export function rowsOf(head, message) {
     const native = nativeOf(head);
     const cached = messageRows.get(message);
     if (cached && cached.native === native)
@@ -37,7 +37,7 @@ function indexOf(state) {
     if (!index) {
         index = new Map();
         for (const head of Object.values(state.threads)) {
-            const native = v1Ext(head) ? nativeOf(head) : null;
+            const native = nativeOf(head);
             if (native !== null && !index.has(native))
                 index.set(native, head.thread_id);
         }
@@ -64,25 +64,64 @@ function insertAt(rows, row) {
     });
     return at < 0 ? rows.length : at;
 }
+function messageInsertAt(messages, message) {
+    const created = Date.parse(message.created_at);
+    if (!Number.isFinite(created))
+        return messages.length;
+    const at = messages.findIndex((other) => {
+        const t = Date.parse(other.created_at);
+        return Number.isFinite(t) && (t > created || (t === created && other.message_id > message.message_id));
+    });
+    return at < 0 ? messages.length : at;
+}
 const v1Order = (a, b) => (createdOf(a) ?? -Infinity) - (createdOf(b) ?? -Infinity) || (a.info.id < b.info.id ? -1 : a.info.id > b.info.id ? 1 : 0);
 const merged = new WeakMap();
-export function sessionLogRowsFor(logs, runtimeSessionId, v1Rows) {
+function heldByLog(row, held, revs, echoOf) {
+    const id = row.info.id;
+    if (held.has(id) || revs[id] !== undefined)
+        return true;
+    const echo = echoOf?.(id);
+    return echo !== undefined && (held.has(echo) || revs[echo] !== undefined);
+}
+export function sessionLogRowsFor(logs, runtimeSessionId, v1Rows, echoOf) {
     const found = findThread(logs, runtimeSessionId);
     if (!found)
         return v1Rows;
     const { state, head, list } = found;
     const cached = merged.get(list);
     const native = nativeOf(head);
-    if (cached && cached.v1Rows === v1Rows && cached.native === native && cached.revs === state.revs)
+    const own = cached && cached.v1Rows === v1Rows && cached.native === native && cached.revs === state.revs ? cached.own : list.flatMap((m) => rowsOf(head, m)).sort(v1Order);
+    const shown = new Set(own.map((r) => r.info.id));
+    const extra = v1Rows.filter((row) => !heldByLog(row, shown, state.revs, echoOf));
+    if (cached && cached.own === own && cached.extra.length === extra.length && cached.extra.every((r, i) => r === extra[i]))
         return cached.result;
-    const result = list.flatMap((m) => rowsOf(head, m)).sort(v1Order);
-    const shown = new Set(result.map((r) => r.info.id));
-    for (const row of v1Rows) {
-        if (shown.has(row.info.id) || state.revs[row.info.id] !== undefined)
-            continue;
+    const result = [...own];
+    for (const row of extra)
         result.splice(insertAt(result, row), 0, row);
+    merged.set(list, { v1Rows, native, revs: state.revs, own, extra, result });
+    return result;
+}
+const extended = new WeakMap();
+export function sessionLogThreadWithV1Rows(state, thread, v1Rows, echoOf) {
+    const cached = extended.get(thread);
+    const held = cached?.held ?? new Set(thread.messages.flatMap((m) => rowsOf(thread, m).map((r) => r.info.id)));
+    const extra = v1Rows.filter((r) => !heldByLog(r, held, state.revs, echoOf));
+    if (cached && cached.extra.length === extra.length && cached.extra.every((r, i) => r === extra[i]))
+        return cached.result;
+    let result = thread;
+    if (extra.length) {
+        let seq = thread.messages[thread.messages.length - 1]?.seq ?? 0;
+        const { paired, used } = pairCompactions(extra);
+        const messages = [...thread.messages];
+        for (const r of extra) {
+            if (used.has(r))
+                continue;
+            const message = convert(state.session.session_id ?? '', thread.thread_id, r, paired.get(r), ++seq).message;
+            messages.splice(messageInsertAt(messages, message), 0, message);
+        }
+        result = { ...thread, messages };
     }
-    merged.set(list, { v1Rows, native, revs: state.revs, result });
+    extended.set(thread, { held, extra, result });
     return result;
 }
 const converted = new WeakMap();
@@ -94,13 +133,48 @@ const summaryOf = (row, marker) => {
     const info = row.info;
     return info.role === 'assistant' && info.summary === true && info.parentID === marker.info.id;
 };
+const partBlocks = new WeakMap();
+function reuseBlocks(native, row, message) {
+    const info = row.info;
+    const at = `${native}|${String(info.id)}|${String(info.time?.created)}`;
+    let reused = false;
+    const blocks = message.blocks.map((block, i) => {
+        const part = row.parts[i];
+        if (!isObj(part) || block.type === 'compaction')
+            return block;
+        const key = `${at}|${i}|${block.id}`;
+        const prev = partBlocks.get(part);
+        if (prev && prev.key === key) {
+            reused = true;
+            return prev.block;
+        }
+        partBlocks.set(part, { key, block });
+        return block;
+    });
+    return reused ? { ...message, blocks } : message;
+}
+function pairCompactions(rows) {
+    const paired = new Map();
+    const used = new Set();
+    for (const row of rows) {
+        if (!isMarker(row))
+            continue;
+        const sum = rows.find((r) => !used.has(r) && summaryOf(r, row));
+        if (!sum)
+            continue;
+        paired.set(row, sum);
+        used.add(sum);
+    }
+    return { paired, used };
+}
 function convert(sessionId, native, row, sum, seq) {
     const cached = converted.get(row);
     if (cached && cached.sessionId === sessionId && cached.native === native && cached.sum === sum && cached.seq === seq)
         return cached;
     const unit = sum ? [row, sum] : [row];
     const log = fromV1({ session_id: sessionId, root_id: native, rows: unit.map((r) => ({ runtime_session_id: native, info: r.info, parts: r.parts })) }, { live: true });
-    const entry = { sessionId, native, sum, seq, message: { ...log.threads[0].messages[0], seq }, lost: log.grade_counts };
+    const message = reuseBlocks(native, row, log.threads[0].messages[0]);
+    const entry = { sessionId, native, sum, seq, message: { ...message, seq }, lost: log.grade_counts };
     converted.set(row, entry);
     return entry;
 }
@@ -109,17 +183,7 @@ export function sessionLogOfV1Rows(sessionId, runtimeSessionId, rows) {
     if (cached && cached.sessionId === sessionId && cached.native === runtimeSessionId)
         return cached.log;
     const sorted = [...rows].sort(v1Order);
-    const paired = new Map();
-    const used = new Set();
-    for (const row of sorted) {
-        if (!isMarker(row))
-            continue;
-        const sum = sorted.find((r) => !used.has(r) && summaryOf(r, row));
-        if (!sum)
-            continue;
-        paired.set(row, sum);
-        used.add(sum);
-    }
+    const { paired, used } = pairCompactions(sorted);
     const counts = { tool_input: 0, cut_point: 0, attachment: 0 };
     const messages = [];
     for (const row of sorted) {

package/dist/core/session-log/v1.js

@@ -71,6 +71,12 @@ const extOf = (h, entry) => ({ [h]: { version: BEEUNI_TRANSCRIPT_SCHEMA, ...entr
 const urlOf = (a, c) => a.url !== undefined ? { url: a.url } : a.ref !== undefined && !c.fromV1 ? { url: a.ref } : {};
 const textOf = (content) => (content ?? []).flatMap((c) => (c.type === 'text' ? [c.text] : [])).join('');
 const head = (b, c) => ({ id: b.id, ...(c.sessionID !== null && { sessionID: c.sessionID }), messageID: c.messageID });
+const detailsOf = (b) => {
+    if (isObj(b.result?.details))
+        return b.result.details;
+    const own = Object.values(b.ext ?? {}).find((e) => e.version !== BEEUNI_TRANSCRIPT_SCHEMA && isObj(e.data?.details));
+    return own ? own.data.details : {};
+};
 function toolState(b, c, base) {
     const r = b.result;
     const input = b.input === null || b.input === undefined ? {} : { input: b.input };
@@ -86,7 +92,7 @@ function toolState(b, c, base) {
     const atts = (r?.content ?? []).flatMap((x, i) => x.type === 'attachment' ? [{ ...base, id: `${b.id}-a${i}`, type: 'file', mime: x.mime, ...urlOf(x, c) }] : []);
     const compacted = msOf(r?.cleared_at);
     return {
-        status: 'completed', ...input, output: textOf(r?.content), title: b.title ?? '', metadata: meta,
+        status: 'completed', ...input, output: textOf(r?.content), title: b.title ?? '', metadata: { ...detailsOf(b), ...meta },
         time: { start, end, ...(compacted !== undefined && { compacted }) },
         ...(atts.length && { attachments: atts }),
     };
@@ -310,14 +316,15 @@ function toMessage(row, sum, threadId, seq, superseded, c) {
     const aborted = err?.name === 'MessageAbortedError';
     const completedAt = src && isObj(src.time) ? iso(src.time.completed) : null;
     const open = c.live ? 'streaming' : 'interrupted';
-    const status = !src ? (marker ? open : 'complete') : err ? (aborted ? 'aborted' : 'error') : completedAt ? 'complete' : open;
+    const settled = !src ? (marker ? open : 'complete') : err ? (aborted ? 'aborted' : 'error') : completedAt ? 'complete' : open;
     const createdAt = iso(isObj(info.time) ? info.time.created : undefined) ?? '';
     const summary = sum ? (Array.isArray(sum.parts) ? sum.parts : []).flatMap((p) => (isObj(p) && p.type === 'text' && typeof p.text === 'string' ? [p.text] : [])).join('') : null;
     const lost = { tool_input: 0, cut_point: 0, attachment: 0 };
     const ids = blockIds(parts);
     const blocks = parts.map((p, i) => blockOf(p, ids[i], marker, summary, c, lost));
     const visible = blocks.some((b) => b.type === 'text' || b.type === 'attachment' || b.type === 'tool_call' || (b.type === 'harness' && b.model_visible));
-    const inContext = !superseded && role !== 'system' && (marker ? status === 'complete' : !err || (aborted && visible));
+    const inContext = !superseded && role !== 'system' && (marker ? settled === 'complete' : !err || (aborted && visible));
+    const status = c.live && inContext && settled !== 'streaming' && blocks.some((b) => b.type === 'tool_call' && (b.status === 'pending' || b.status === 'running')) ? 'streaming' : settled;
     const hidden = superseded ? 'superseded' : inContext || !err ? undefined : aborted ? 'aborted' : 'failed_attempt';
     if (marker && isObj(marker) && str(marker.tail_start_id) === undefined)
         lost.cut_point++;

package/dist/core/session-sync/saved-transcript.d.ts

@@ -1,4 +1,18 @@
-import type { SessionTranscriptSyncEnvelope } from '../rest/projects-client/sessions.js';
+import { type SessionTranscriptSyncEnvelope } from '../rest/projects-client/sessions.js';
+export declare const SAVED_HISTORY_SNAPSHOT_WAIT_MS = 2000;
+export declare function loadSavedTranscript(projectId: string, sessionId: string, options?: {
+    signal?: AbortSignal;
+    snapshotWaitMs?: number;
+}): Promise<SessionTranscriptSyncEnvelope>;
+export interface SavedSessionCopy {
+    envelope: SessionTranscriptSyncEnvelope | null;
+    empty: boolean;
+}
+export declare function readSavedSessionCopy(input: {
+    projectId: string;
+    sessionId: string;
+    runtimeSessionId: string;
+}): Promise<SavedSessionCopy>;
 export type SavedTranscript = 'loading' | 'shown' | 'none';
 export interface SavedTranscriptInput {
     enabled: boolean;