@beeuni/sdk 0.2.0 → 0.3.0

package/dist/core/session/turn-end-watch.d.ts

@@ -0,0 +1,47 @@
+import type { SessionTurnEndError, SessionTurnStatus } from '../rest/projects-client/sessions.js';
+export declare const TURN_END_WATCH_FIRST_READ_MS = 1000;
+export declare const TURN_END_WATCH_POLL_MS = 5000;
+export declare const TURN_END_WATCH_LONG_TURN_MS: number;
+export declare const TURN_END_WATCH_SLOW_POLL_MS = 15000;
+export declare const TURN_END_WATCH_START_MS = 60000;
+export declare const TURN_END_WATCH_MAX_MS: number;
+export interface TurnEndHandoff {
+    projectId: string;
+    sessionId: string;
+    openTurnToken: string | null;
+    lastEndedToken: string | null;
+    title?: () => string | undefined;
+}
+export type TurnEndOutcome = {
+    kind: 'completed';
+} | {
+    kind: 'failed';
+    error: SessionTurnEndError | null;
+} | {
+    kind: 'stopped';
+};
+export type TurnEndVerdict = {
+    state: 'running';
+} | {
+    state: 'waiting';
+} | {
+    state: 'ended';
+    outcome: TurnEndOutcome;
+};
+export declare function readTurnEnd(handoff: TurnEndHandoff, read: SessionTurnStatus, sawOpen: boolean): TurnEndVerdict;
+export interface TurnEndWatchDeps {
+    readTurn(projectId: string, sessionId: string): Promise<SessionTurnStatus>;
+    subscribe?(projectId: string, sessionId: string, onRead: (read: SessionTurnStatus) => void): () => void;
+    pushLive?(projectId: string, sessionId: string): boolean;
+    onEnded(handoff: TurnEndHandoff, outcome: TurnEndOutcome, watchedSinceMs: number): void;
+    now?: () => number;
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    clearTimer?: (handle: unknown) => void;
+}
+export interface TurnEndWatch {
+    watch(handoff: TurnEndHandoff): void;
+    release(projectId: string, sessionId: string): void;
+    releaseAll(): void;
+    watching(): string[];
+}
+export declare function createTurnEndWatch(deps: TurnEndWatchDeps): TurnEndWatch;

package/dist/core/session/turn-end-watch.js

@@ -0,0 +1,141 @@
+import { isAbortError } from '../http/abort-error.js';
+export const TURN_END_WATCH_FIRST_READ_MS = 1_000;
+export const TURN_END_WATCH_POLL_MS = 5_000;
+export const TURN_END_WATCH_LONG_TURN_MS = 5 * 60_000;
+export const TURN_END_WATCH_SLOW_POLL_MS = 15_000;
+export const TURN_END_WATCH_START_MS = 60_000;
+export const TURN_END_WATCH_MAX_MS = 12 * 60 * 60_000;
+function outcomeOf(read) {
+    const ended = read.last_ended;
+    if (!ended)
+        return { kind: 'completed' };
+    const reason = ended.end_reason;
+    if (reason === 'completed' || reason === 'unknown' || reason === null)
+        return { kind: 'completed' };
+    const error = ended.error;
+    if (error) {
+        if (isAbortError({ name: error.name ?? undefined, message: error.message ?? undefined })) {
+            return { kind: 'stopped' };
+        }
+        return { kind: 'failed', error };
+    }
+    if (reason === 'failed') {
+        const listed = read.recent_failures?.some((failure) => !!ended.message_id && failure.message_id === ended.message_id);
+        if (!listed)
+            return { kind: 'stopped' };
+    }
+    return { kind: 'failed', error: null };
+}
+export function readTurnEnd(handoff, read, sawOpen) {
+    if (read.turns.length > 0)
+        return { state: 'running' };
+    const lastEndedToken = read.last_ended?.turn_token ?? null;
+    const endedSinceHandoff = handoff.openTurnToken !== null ||
+        sawOpen ||
+        (lastEndedToken !== null && lastEndedToken !== handoff.lastEndedToken);
+    if (!endedSinceHandoff)
+        return { state: 'waiting' };
+    return { state: 'ended', outcome: outcomeOf(read) };
+}
+function isFinalReadError(error) {
+    const status = error?.status;
+    return status === 401 || status === 403 || status === 404;
+}
+export function createTurnEndWatch(deps) {
+    const now = deps.now ?? Date.now;
+    const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    const clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
+    const entries = new Map();
+    const keyOf = (projectId, sessionId) => `${projectId}/${sessionId}`;
+    function drop(key, entry) {
+        if (entries.get(key) !== entry)
+            return;
+        entry.dropped = true;
+        clearTimer(entry.timer);
+        entry.unsubscribe?.();
+        entries.delete(key);
+    }
+    function schedule(key, entry, ms) {
+        entry.timer = setTimer(() => void tick(key, entry), ms);
+    }
+    function evaluate(key, entry, read) {
+        if (entries.get(key) !== entry)
+            return;
+        const verdict = readTurnEnd(entry.handoff, read, entry.sawOpen);
+        if (verdict.state === 'ended') {
+            drop(key, entry);
+            deps.onEnded(entry.handoff, verdict.outcome, entry.sinceMs);
+            return;
+        }
+        if (verdict.state === 'running')
+            entry.sawOpen = true;
+        entry.lastState = verdict.state;
+    }
+    async function tick(key, entry) {
+        if (entries.get(key) !== entry)
+            return;
+        const { projectId, sessionId } = entry.handoff;
+        if (!deps.pushLive?.(projectId, sessionId)) {
+            try {
+                const read = await deps.readTurn(projectId, sessionId);
+                evaluate(key, entry, read);
+            }
+            catch (error) {
+                if (entries.get(key) !== entry)
+                    return;
+                if (isFinalReadError(error)) {
+                    drop(key, entry);
+                    return;
+                }
+            }
+        }
+        if (entries.get(key) !== entry)
+            return;
+        const age = now() - entry.sinceMs;
+        const waitingTooLong = entry.lastState === 'waiting' && !entry.sawOpen && age >= TURN_END_WATCH_START_MS;
+        if (waitingTooLong || age >= TURN_END_WATCH_MAX_MS) {
+            drop(key, entry);
+            return;
+        }
+        schedule(key, entry, age >= TURN_END_WATCH_LONG_TURN_MS ? TURN_END_WATCH_SLOW_POLL_MS : TURN_END_WATCH_POLL_MS);
+    }
+    return {
+        watch(handoff) {
+            if (!handoff.projectId || !handoff.sessionId)
+                return;
+            const key = keyOf(handoff.projectId, handoff.sessionId);
+            const previous = entries.get(key);
+            if (previous)
+                drop(key, previous);
+            const entry = {
+                handoff,
+                sinceMs: now(),
+                sawOpen: false,
+                lastState: null,
+                timer: null,
+                unsubscribe: null,
+                dropped: false,
+            };
+            entries.set(key, entry);
+            schedule(key, entry, TURN_END_WATCH_FIRST_READ_MS);
+            const unsubscribe = deps.subscribe?.(handoff.projectId, handoff.sessionId, (read) => evaluate(key, entry, read));
+            if (entry.dropped)
+                unsubscribe?.();
+            else
+                entry.unsubscribe = unsubscribe ?? null;
+        },
+        release(projectId, sessionId) {
+            const key = keyOf(projectId, sessionId);
+            const entry = entries.get(key);
+            if (entry)
+                drop(key, entry);
+        },
+        releaseAll() {
+            for (const [key, entry] of [...entries])
+                drop(key, entry);
+        },
+        watching() {
+            return [...entries.keys()];
+        },
+    };
+}

package/dist/core/session-log/index.d.ts

@@ -1,3 +1,7 @@
 export { KNOWN_TOOL_KINDS, SESSION_LOG_MINOR, SESSION_LOG_SCHEMA, type AttachmentBlock, type CompactionBlock, type CompactionLayoutEntry, type GradeCounts, type HarnessBlock, type KnownToolKind, type ModelRef, type ReasoningBlock, type RestoreGrade, type SessionLog, type SessionLogBlock, type SessionLogMessage, type SessionLogThread, type StepBlock, type SubtaskBlock, type TextBlock, type ThreadInteraction, type ToolCallBlock, type ToolResultContent, } from './types.js';
 export type { Todo as SessionLogTodo, ToolKind as SessionLogToolKind } from './types.js';
+export type { SessionLogPage, SessionLogPageQuery } from './source.js';
 export { toolCallBlock, toolCallMetadata } from './tool-call.js';
+export { toolCallError, toolCallRawOutput, toolCallStatus } from './tool-call.js';
+export { sessionLogOfV1Rows } from './v1-view.js';
+export * from './turns/index.js';

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

@@ -1,2 +1,5 @@
 export { KNOWN_TOOL_KINDS, SESSION_LOG_MINOR, SESSION_LOG_SCHEMA, } from './types.js';
 export { toolCallBlock, toolCallMetadata } from './tool-call.js';
+export { toolCallError, toolCallRawOutput, toolCallStatus } from './tool-call.js';
+export { sessionLogOfV1Rows } from './v1-view.js';
+export * from './turns/index.js';

package/dist/core/session-log/tool-call.d.ts

@@ -1,6 +1,11 @@
-import type { ToolPart } from '../runtime/runtime-types.js';
-import { type ToolCallBlock } from './types.js';
+import type { Part, ToolPart } from '../runtime/runtime-types.js';
+import { type SessionLogBlock, type ToolCallBlock } from './types.js';
 export declare function toolCallBlock(part: ToolPart): ToolCallBlock;
+export declare function blockPartOf(block: SessionLogBlock): Part | undefined;
 export declare function toolPartOf(call: ToolCallBlock): ToolPart;
 export declare const isToolCallBlock: (value: unknown) => value is ToolCallBlock;
+export declare const asToolPart: (value: ToolPart | ToolCallBlock) => ToolPart;
 export declare function toolCallMetadata(call: ToolCallBlock): Record<string, unknown>;
+export declare function toolCallStatus(call: ToolCallBlock): 'pending' | 'running' | 'completed' | 'error';
+export declare function toolCallRawOutput(call: ToolCallBlock): string;
+export declare function toolCallError(call: ToolCallBlock): string | undefined;

package/dist/core/session-log/tool-call.js

@@ -16,17 +16,16 @@ export function toolCallBlock(part) {
     return block;
 }
 const parts = new WeakMap();
-export function toolPartOf(call) {
-    const cached = parts.get(call);
-    if (cached)
-        return cached;
+export function blockPartOf(block) {
+    if (parts.has(block))
+        return parts.get(block);
     const thread = {
         ...V, thread_id: '', parent_thread_id: null, spawned_by: null, agent: null, title: null, created_at: '',
         ext: { opencode: { version: BEEUNI_TRANSCRIPT_SCHEMA } },
         messages: [{
                 ...V, message_id: '', thread_id: '', seq: 1, role: 'assistant', kind: 'turn', status: 'complete', in_context: true,
                 model: null, usage: null, finish: null, error: null, created_at: '', completed_at: null,
-                producer: { harness: '', harness_version: '', adapter_version: '' }, blocks: [call],
+                producer: { harness: '', harness_version: '', adapter_version: '' }, blocks: [block],
             }],
     };
     const { rows } = toV1({
@@ -34,13 +33,33 @@ export function toolPartOf(call) {
         selection: { agent: null, model: null }, todos: [], pending: { questions: [], permissions: [] }, threads: [thread],
     });
     const part = rows[0].parts[0];
-    parts.set(call, part);
+    parts.set(block, part);
     return part;
 }
+export function toolPartOf(call) {
+    return blockPartOf(call);
+}
 export const isToolCallBlock = (value) => typeof value === 'object' && value !== null && value.type === 'tool_call';
+export const asToolPart = (value) => (isToolCallBlock(value) ? toolPartOf(value) : value);
 export function toolCallMetadata(call) {
     const metadata = toolPartOf(call).state.metadata;
     return typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata) && Object.keys(metadata).length
         ? metadata
         : EMPTY;
 }
+const textOf = (call) => (call.result?.content ?? []).flatMap((c) => (c.type === 'text' ? [c.text] : [])).join('');
+export function toolCallStatus(call) {
+    return call.status === 'complete' ? 'completed' : call.status;
+}
+const rawOutputs = new WeakMap();
+export function toolCallRawOutput(call) {
+    if (call.status !== 'complete')
+        return '';
+    let text = rawOutputs.get(call);
+    if (text === undefined)
+        rawOutputs.set(call, (text = textOf(call)));
+    return text;
+}
+export function toolCallError(call) {
+    return call.status === 'error' ? call.result?.error?.message || textOf(call) : undefined;
+}

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

@@ -0,0 +1,60 @@
+import { type ClassifiedTurn } from '../../turns/classify.js';
+import { type BurstSummary } from '../../turns/segments/burst-summary.js';
+import type { StepFamily } from '../../turns/segments/narration.js';
+import { type SegmentTurnOptions } from '../../turns/segments/segment-turn.js';
+import type { SessionLogBlock, SessionLogMessage, SessionLogThread, TextBlock, ToolCallBlock } from '../types.js';
+import { type SessionLogTurn } from './turn.js';
+export type SessionLogSegment = {
+    kind: 'burst';
+    blocks: SessionLogBlock[];
+} | {
+    kind: 'text';
+    block: TextBlock;
+} | {
+    kind: 'standalone';
+    block: ToolCallBlock;
+} | {
+    kind: 'show-group';
+    blocks: ToolCallBlock[];
+};
+export interface SessionLogTurnWorkSplit {
+    work: SessionLogSegment[];
+    hoisted: SessionLogSegment[];
+    final: SessionLogSegment[];
+}
+export type SessionLogBurstStep = {
+    kind: 'thought';
+    key: string;
+    texts: string[];
+    running: boolean;
+    durationMs?: number;
+} | {
+    kind: 'block';
+    key: string;
+    block: SessionLogBlock;
+} | {
+    kind: 'group';
+    key: string;
+    blocks: ToolCallBlock[];
+    family: StepFamily;
+    label: string;
+    status: 'running' | 'error' | 'done';
+    durationMs?: number;
+};
+export declare function sessionLogTurnSegments(blocks: ReadonlyArray<SessionLogBlock>, options?: SegmentTurnOptions): SessionLogSegment[];
+export declare function splitSessionLogTurnWork(segments: ReadonlyArray<SessionLogSegment>, options: {
+    working: boolean;
+}): SessionLogTurnWorkSplit | null;
+export declare function sessionLogBurstSteps(blocks: ReadonlyArray<SessionLogBlock>): SessionLogBurstStep[];
+export declare function sessionLogActivityText(turn: Pick<SessionLogTurn, 'blocks'>, childMessages?: readonly SessionLogMessage[]): string;
+export declare function sessionLogBurstSummary(blocks: ReadonlyArray<SessionLogBlock>): BurstSummary;
+export declare function sessionLogBurstWorkLabel(blocks: ReadonlyArray<SessionLogBlock>): string;
+export declare function sessionLogBurstRunning(blocks: ReadonlyArray<SessionLogBlock>, options: {
+    working: boolean;
+    trailing?: boolean;
+}): boolean;
+export declare function sessionLogOpenCall(call: ToolCallBlock): ToolCallBlock;
+export declare function sessionLogShowGroupCall(calls: ReadonlyArray<ToolCallBlock>): ToolCallBlock;
+export declare function sessionLogAnsweredQuestionCall(call: ToolCallBlock, answers: string[][], input?: Record<string, unknown>): ToolCallBlock;
+export declare function classifySessionLogMessage(message: SessionLogMessage): ClassifiedTurn;
+export declare function subAgentCalls(thread: Pick<SessionLogThread, 'messages'> | null | undefined): readonly ToolCallBlock[];

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

@@ -0,0 +1,124 @@
+import { classifyTurn, toToolView } from '../../turns/classify.js';
+import { isReasoningPart, isToolPart, shouldShowToolPart } from '../../turns/parts.js';
+import { burstSummary, burstWorkLabel } from '../../turns/segments/burst-summary.js';
+import { mergeBurstSteps, reasoningIsRunning } from '../../turns/segments/merge-steps.js';
+import { segmentTurn } from '../../turns/segments/segment-turn.js';
+import { isQuestionTool } from '../../turns/segments/session-activity-groups.js';
+import { groupShowSegments, showGroupItems } from '../../turns/segments/show-group.js';
+import { stepLabel } from '../../turns/segments/step-label.js';
+import { splitTurnWork } from '../../turns/segments/work-split.js';
+import { getTurnStatus } from '../../turns/state.js';
+import { parseQuestionAnswersFromOutput } from '../../turns/tools/question-helpers.js';
+import { toolCallBlock, toolPartOf } from '../tool-call.js';
+import { isClosedByRule } from './turn.js';
+import { blockOf, messageOfBlock, partOf, partsOf, v1RowsOf } from './v1-parts.js';
+const call = (p) => blockOf(p);
+export function sessionLogTurnSegments(blocks, options = {}) {
+    return groupShowSegments(segmentTurn(partsOf(blocks), options), options).map((s) => s.kind === 'burst' ? { kind: s.kind, blocks: s.parts.map(blockOf) }
+        : s.kind === 'show-group' ? { kind: s.kind, blocks: s.parts.map(call) }
+            : s.kind === 'text' ? { kind: s.kind, block: blockOf(s.part) }
+                : { kind: s.kind, block: call(s.part) });
+}
+const v1Segment = (s) => s.kind === 'burst' || s.kind === 'show-group' ? { kind: s.kind, parts: partsOf(s.blocks) } : { kind: s.kind, part: partOf(s.block) };
+export function splitSessionLogTurnWork(segments, options) {
+    const by = new Map(segments.map((s) => [v1Segment(s), s]));
+    const split = splitTurnWork([...by.keys()], options);
+    if (!split)
+        return null;
+    const back = (list) => list.map((s) => by.get(s));
+    return { work: back(split.work), hoisted: back(split.hoisted), final: back(split.final) };
+}
+function isAnswered(part) {
+    if (!isToolPart(part) || !isQuestionTool(part.tool))
+        return false;
+    const questions = part.state.input?.questions;
+    if (!Array.isArray(questions) || !questions.length)
+        return false;
+    const view = toToolView(part);
+    return (view.answers ?? parseQuestionAnswersFromOutput(view.outputText ?? '', questions.length) ?? []).length > 0;
+}
+export function sessionLogBurstSteps(blocks) {
+    const steps = mergeBurstSteps(partsOf(blocks), (p) => stepLabel(p).tier).flatMap((step) => step.kind === 'group' && step.step.parts.some(isAnswered) ? step.step.parts.map((part) => ({ kind: 'part', key: part.id, part })) : [step]);
+    return steps.map((s) => {
+        if (s.kind === 'part')
+            return { kind: 'block', key: s.key, block: blockOf(s.part) };
+        if (s.kind === 'group')
+            return { kind: 'group', key: s.key, blocks: s.step.parts.map(call), family: s.step.family, label: s.step.label, status: s.step.status, durationMs: s.step.durationMs };
+        const first = blocks.find((b) => b.id === s.key.slice('thought-'.length));
+        const message = first && messageOfBlock.get(first);
+        return { kind: 'thought', key: s.key, texts: s.texts, running: s.running && (!message || message.status === 'streaming'), durationMs: s.durationMs };
+    });
+}
+export function sessionLogActivityText(turn, childMessages) {
+    return getTurnStatus(partsOf(turn.blocks).map((part) => ({ part })), childMessages?.flatMap(v1RowsOf));
+}
+export function sessionLogBurstSummary(blocks) {
+    return burstSummary(partsOf(blocks));
+}
+export function sessionLogBurstWorkLabel(blocks) {
+    return burstWorkLabel(partsOf(blocks));
+}
+export function sessionLogBurstRunning(blocks, options) {
+    if (!options.working)
+        return false;
+    if (options.trailing)
+        return true;
+    return blocks.some((block) => {
+        if (block.type === 'tool_call')
+            return block.status === 'pending' || block.status === 'running';
+        if (block.type !== 'reasoning')
+            return false;
+        const part = partOf(block);
+        const message = messageOfBlock.get(block);
+        return !!part && isReasoningPart(part) && reasoningIsRunning(part) && (!message || message.status === 'streaming');
+    });
+}
+const reopened = new WeakMap();
+export function sessionLogOpenCall(call) {
+    if (!isClosedByRule(call))
+        return call;
+    let open = reopened.get(call);
+    if (!open) {
+        const { result: _result, ...rest } = call;
+        open = { ...rest, status: call.started_at ? 'running' : 'pending' };
+        reopened.set(call, open);
+    }
+    return open;
+}
+function carouselItem(item) {
+    const { callID: _callID, error, ...rest } = item;
+    return item.status === 'error' ? { ...rest, type: 'error', content: error || 'This output failed to load.' } : rest;
+}
+export function sessionLogShowGroupCall(calls) {
+    const parts = calls.map(toolPartOf);
+    const first = parts[0];
+    const running = parts.some((p) => p.state.status === 'running' || p.state.status === 'pending');
+    const items = showGroupItems(parts).map(carouselItem);
+    return toolCallBlock({ ...first, state: { ...first.state, status: running ? 'running' : 'completed', input: { items } } });
+}
+export function sessionLogAnsweredQuestionCall(call, answers, input) {
+    const part = toolPartOf(call);
+    const state = part.state;
+    return toolCallBlock({
+        ...part,
+        state: { ...state, status: 'completed', ...(input !== undefined && { input }), metadata: { ...(state.metadata ?? {}), answers } },
+    });
+}
+export function classifySessionLogMessage(message) {
+    const rows = v1RowsOf(message).map((row) => classifyTurn(row));
+    const error = rows.find((row) => row.error)?.error;
+    return { parts: rows.flatMap((row) => row.parts), error, isEmpty: rows.every((row) => row.isEmpty) && !error };
+}
+const NO_CALLS = Object.freeze([]);
+const threadCalls = new WeakMap();
+export function subAgentCalls(thread) {
+    if (!thread)
+        return NO_CALLS;
+    let calls = threadCalls.get(thread);
+    if (!calls) {
+        const found = thread.messages.flatMap((m) => m.role === 'assistant' ? m.blocks.filter((b) => b.type === 'tool_call' && shouldShowToolPart(b)) : []);
+        calls = found.length ? found : NO_CALLS;
+        threadCalls.set(thread, calls);
+    }
+    return calls;
+}

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

@@ -0,0 +1,32 @@
+import type { SessionLog, SessionLogMessage, SessionLogThread } from '../types.js';
+import type { SessionLogTurn } from './turn.js';
+export declare function isSessionLogRestoreNote(message: Pick<SessionLogMessage, 'role' | 'blocks'>): boolean;
+export interface SessionLogHarnessSwitch {
+    harness: string;
+    previous: string;
+    version: string;
+    at: string;
+}
+export declare function sessionLogHarnessSwitches(history: SessionLog['harness']['history'] | undefined, turns: ReadonlyArray<Pick<SessionLogTurn, 'id'> & {
+    user: Pick<SessionLogMessage, 'seq'>;
+}>): Map<string, SessionLogHarnessSwitch>;
+export interface SessionLogRestoreNotice {
+    generation: number;
+    missing: Array<{
+        kind: 'message' | 'attachment' | 'text' | 'tool_input' | 'tool_result' | 'cut_point' | 'other';
+        count: number;
+    }>;
+}
+export declare function sessionLogRestoreNotice(session: Partial<Pick<SessionLog, 'restore_grade' | 'grade_counts' | 'ext'>> | null | undefined): SessionLogRestoreNotice | null;
+export interface SessionLogReferencedText {
+    ref: string;
+    bytes: number;
+}
+export declare function sessionLogReferencedTexts(messages: readonly SessionLogMessage[]): SessionLogReferencedText[];
+export declare const SESSION_LOG_FULL_TEXT_INLINE_MAX_BYTES: number;
+export declare function sessionLogFullTextAction(refs: readonly SessionLogReferencedText[]): 'inline' | 'download';
+export declare function sessionLogFullTextPlan(refs: readonly SessionLogReferencedText[]): {
+    inline: SessionLogReferencedText[];
+    download: SessionLogReferencedText[];
+};
+export declare function sessionLogWithFullTexts(thread: SessionLogThread, texts: ReadonlyMap<string, string>): SessionLogThread;

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

@@ -0,0 +1,99 @@
+const RESTORE_NOTE = 'prt_beeuni_restore_g';
+export function isSessionLogRestoreNote(message) {
+    return message.role === 'user' && message.blocks.some((b) => b.type === 'text' && b.id.startsWith(RESTORE_NOTE));
+}
+export function sessionLogHarnessSwitches(history, turns) {
+    const out = new Map();
+    const entries = [...(history ?? [])].sort((a, b) => a.from_seq - b.from_seq);
+    for (let i = 1; i < entries.length; i++) {
+        const entry = entries[i];
+        const previous = entries[i - 1].harness;
+        if (entry.harness === previous)
+            continue;
+        const at = turns.findIndex((t) => t.user.seq >= entry.from_seq);
+        if (at < 0 || (at === 0 && turns[0].user.seq !== entry.from_seq))
+            continue;
+        out.set(turns[at].id, { harness: entry.harness, previous, version: entry.version, at: entry.at });
+    }
+    return out;
+}
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const count = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0);
+const COUNTED = new Set(['message', 'attachment', 'tool_input', 'cut_point', 'layout', 'text', 'tool_result']);
+export function sessionLogRestoreNotice(session) {
+    if (session?.restore_grade !== 'partial')
+        return null;
+    const data = session.ext?.beeuni?.data;
+    const restore = isObj(data) ? data.restore : undefined;
+    if (!isObj(restore))
+        return null;
+    const dropped = isObj(restore.dropped) ? restore.dropped : {};
+    const grade = session.grade_counts;
+    const missing = [
+        { kind: 'message', count: count(dropped.message) },
+        { kind: 'attachment', count: count(grade?.attachment) },
+        { kind: 'text', count: count(dropped.text) + count(restore.truncated) },
+        { kind: 'tool_input', count: count(grade?.tool_input) },
+        { kind: 'tool_result', count: count(dropped.tool_result) },
+        { kind: 'cut_point', count: count(grade?.cut_point) },
+        { kind: 'other', count: Object.entries(dropped).reduce((n, [k, v]) => (COUNTED.has(k) ? n : n + count(v)), 0) },
+    ];
+    return { generation: count(restore.generation), missing: missing.filter((m) => m.count > 0) };
+}
+const textsOf = (b) => b.type === 'text'
+    ? [b]
+    : b.type === 'tool_call'
+        ? (b.result?.content ?? []).filter((c) => c.type === 'text')
+        : [];
+export function sessionLogReferencedTexts(messages) {
+    const out = new Map();
+    for (const m of messages)
+        for (const b of m.blocks)
+            for (const t of textsOf(b))
+                if (t.ref && t.bytes !== undefined && !out.has(t.ref))
+                    out.set(t.ref, t.bytes);
+    return [...out].map(([ref, bytes]) => ({ ref, bytes }));
+}
+const swap = (item, texts) => {
+    const text = item.ref === undefined ? undefined : texts.get(item.ref);
+    if (text === undefined)
+        return item;
+    const { ref: _ref, bytes: _bytes, ...rest } = item;
+    return { ...rest, text };
+};
+const swapAll = (items, texts) => items.map((c) => (c.type === 'text' ? swap(c, texts) : c));
+const filled = new WeakMap();
+function withTexts(m, texts) {
+    const cached = filled.get(m);
+    if (cached?.texts === texts)
+        return cached.out;
+    const out = !m.blocks.some((b) => textsOf(b).some((t) => t.ref !== undefined && texts.has(t.ref)))
+        ? m
+        : {
+            ...m,
+            blocks: m.blocks.map((b) => b.type === 'text' ? swap(b, texts) : b.type === 'tool_call' && b.result ? { ...b, result: { ...b.result, content: swapAll(b.result.content, texts) } } : b),
+        };
+    filled.set(m, { texts, out });
+    return out;
+}
+export const SESSION_LOG_FULL_TEXT_INLINE_MAX_BYTES = 1024 * 1024;
+export function sessionLogFullTextAction(refs) {
+    return refs.reduce((n, r) => n + r.bytes, 0) > SESSION_LOG_FULL_TEXT_INLINE_MAX_BYTES ? 'download' : 'inline';
+}
+export function sessionLogFullTextPlan(refs) {
+    const fits = new Set();
+    let total = 0;
+    for (const r of [...refs].sort((a, b) => a.bytes - b.bytes)) {
+        if (total + r.bytes > SESSION_LOG_FULL_TEXT_INLINE_MAX_BYTES)
+            break;
+        total += r.bytes;
+        fits.add(r);
+    }
+    return { inline: refs.filter((r) => fits.has(r)), download: refs.filter((r) => !fits.has(r)) };
+}
+export function sessionLogWithFullTexts(thread, texts) {
+    if (texts.size === 0)
+        return thread;
+    const messages = thread.messages.map((m) => withTexts(m, texts));
+    return messages.every((m, i) => m === thread.messages[i]) ? thread : { ...thread, messages };
+}

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

@@ -0,0 +1,4 @@
+export { classifySessionLogMessage, sessionLogActivityText, sessionLogAnsweredQuestionCall, sessionLogBurstRunning, sessionLogBurstSteps, sessionLogBurstSummary, sessionLogBurstWorkLabel, sessionLogOpenCall, sessionLogShowGroupCall, sessionLogTurnSegments, splitSessionLogTurnWork, subAgentCalls, type SessionLogBurstStep, type SessionLogSegment, type SessionLogTurnWorkSplit, } from './blocks.js';
+export { sessionLogTurns, sessionLogCallStatus, sessionLogPromptMessage, sessionLogRetrying, type SessionLogTurnsOptions, type SessionLogCallStatus, type SessionLogCompaction, type SessionLogContinuation, type SessionLogTurn, type SessionLogTurnError, type SessionLogTurnStatus, } from './turn.js';
+export { sessionLogThreadMetrics, type SessionLogThreadMetrics } from './metrics.js';
+export { SESSION_LOG_FULL_TEXT_INLINE_MAX_BYTES, isSessionLogRestoreNote, sessionLogFullTextAction, sessionLogFullTextPlan, sessionLogHarnessSwitches, sessionLogReferencedTexts, sessionLogRestoreNotice, sessionLogWithFullTexts, type SessionLogHarnessSwitch, type SessionLogReferencedText, type SessionLogRestoreNotice, } from './history.js';

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

@@ -0,0 +1,4 @@
+export { classifySessionLogMessage, sessionLogActivityText, sessionLogAnsweredQuestionCall, sessionLogBurstRunning, sessionLogBurstSteps, sessionLogBurstSummary, sessionLogBurstWorkLabel, sessionLogOpenCall, sessionLogShowGroupCall, sessionLogTurnSegments, splitSessionLogTurnWork, subAgentCalls, } from './blocks.js';
+export { sessionLogTurns, sessionLogCallStatus, sessionLogPromptMessage, sessionLogRetrying, } from './turn.js';
+export { sessionLogThreadMetrics } from './metrics.js';
+export { SESSION_LOG_FULL_TEXT_INLINE_MAX_BYTES, isSessionLogRestoreNote, sessionLogFullTextAction, sessionLogFullTextPlan, sessionLogHarnessSwitches, sessionLogReferencedTexts, sessionLogRestoreNotice, sessionLogWithFullTexts, } from './history.js';

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

@@ -0,0 +1,21 @@
+import type { ModelPricingLookup } from '../../turns/types.js';
+import type { SessionLogMessage, SessionLogThread } from '../types.js';
+export interface SessionLogThreadMetrics {
+    cost: null;
+    messages: {
+        all: number;
+        user: number;
+        assistant: number;
+    };
+    tokens: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    context: SessionLogMessage | null;
+}
+export declare function sessionLogThreadMetrics(thread: SessionLogThread, options?: {
+    pricing?: ModelPricingLookup;
+}): SessionLogThreadMetrics;

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

@@ -0,0 +1,29 @@
+import { sessionLogTurns, usageCostOf } from './turn.js';
+export function sessionLogThreadMetrics(thread, options = {}) {
+    const m = {
+        cost: null,
+        messages: { all: 0, user: 0, assistant: 0 },
+        tokens: { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 },
+        context: null,
+    };
+    for (const turn of sessionLogTurns(thread)) {
+        const cost = usageCostOf([turn.user, ...turn.assistant], options.pricing);
+        if (!cost)
+            continue;
+        for (const k of Object.keys(m.tokens))
+            m.tokens[k] += cost.tokens[k];
+    }
+    for (const msg of thread.messages) {
+        if (msg.role === 'user')
+            m.messages.user++;
+        else if (msg.role === 'assistant')
+            m.messages.assistant++;
+        if (msg.kind === 'compaction' && msg.status !== 'streaming')
+            m.messages.assistant++;
+        const u = msg.usage;
+        if ((msg.role === 'assistant' || msg.kind === 'compaction') && u && u.input + u.output + (u.reasoning ?? 0) + u.cache_read + u.cache_write > 0)
+            m.context = msg;
+    }
+    m.messages.all = m.messages.user + m.messages.assistant;
+    return m;
+}