@beeuni/sdk 0.1.0 → 0.3.0

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

@@ -0,0 +1,25 @@
+import type { SessionLogSessionRecord, SessionLogThreadHead } from './store.js';
+import type { SessionLogMessage } from './types.js';
+export interface SessionLogPage {
+    session: Partial<SessionLogSessionRecord>;
+    generation: number;
+    threads: SessionLogThreadHead[];
+    thread_id: string | null;
+    messages: SessionLogMessage[];
+    has_more: boolean;
+}
+export interface SessionLogPageQuery {
+    thread?: string;
+    before_seq?: number;
+    limit?: number;
+}
+export type LoadSessionLogPage = (projectId: string, sessionId: string, query: SessionLogPageQuery, signal?: AbortSignal) => Promise<unknown>;
+export declare const loadSessionLogPage: LoadSessionLogPage | null;
+export declare const SESSION_LOG_FIRST_PAGE_LIMIT = 40;
+export type SessionLogDialect = 'v1' | 'v2';
+export declare function negotiateSessionLog(input: {
+    capabilities: readonly string[] | null | undefined;
+    flag: boolean | undefined;
+    loader: LoadSessionLogPage | null;
+}): SessionLogDialect;
+export declare function fetchFirstSessionLogPage(load: LoadSessionLogPage, projectId: string, sessionId: string, signal?: AbortSignal): Promise<SessionLogPage | null>;

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

@@ -0,0 +1,30 @@
+import { backendApi } from '../http/api-client.js';
+import { isSessionLogPage } from './guard.js';
+export const loadSessionLogPage = async (projectId, sessionId, query, signal) => {
+    const search = new URLSearchParams();
+    if (query.thread !== undefined)
+        search.set('thread', query.thread);
+    if (query.before_seq !== undefined)
+        search.set('before_seq', String(query.before_seq));
+    if (query.limit !== undefined)
+        search.set('limit', String(query.limit));
+    const qs = search.toString();
+    const response = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/sessions/${encodeURIComponent(sessionId)}/log${qs ? `?${qs}` : ''}`, { showErrors: false, signal });
+    if (!response.success)
+        throw response.error ?? new Error('Session log request failed');
+    return response.data;
+};
+export const SESSION_LOG_FIRST_PAGE_LIMIT = 40;
+export function negotiateSessionLog(input) {
+    const served = Array.isArray(input.capabilities) && input.capabilities.includes('session.log.v2');
+    return served && input.flag === true && input.loader !== null ? 'v2' : 'v1';
+}
+export async function fetchFirstSessionLogPage(load, projectId, sessionId, signal) {
+    try {
+        const page = await load(projectId, sessionId, { limit: SESSION_LOG_FIRST_PAGE_LIMIT }, signal);
+        return isSessionLogPage(page) ? page : null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { SessionLogPage } from './source.js';
+import type { SessionLog, SessionLogMessage, SessionLogThread } from './types.js';
+export type SessionLogThreadHead = Omit<SessionLogThread, 'messages'>;
+export type SessionLogSessionRecord = Omit<SessionLog, 'threads'>;
+export interface SessionLogState {
+    generation: number;
+    session: Partial<SessionLogSessionRecord>;
+    threads: Record<string, SessionLogThreadHead>;
+    messages: Record<string, SessionLogMessage[]>;
+    revs: Record<string, number>;
+}
+export interface SessionLogEventInput {
+    type: string;
+    properties: unknown;
+    id?: string;
+}
+export declare const EMPTY_SESSION_LOG_STATE: SessionLogState;
+export declare function applySessionLogEvent(state: SessionLogState, event: SessionLogEventInput): SessionLogState;
+export declare function applySessionLogPage(state: SessionLogState, page: SessionLogPage): SessionLogState;
+export declare function selectSessionLog(state: SessionLogState): SessionLog | null;
+export declare function selectSessionLogThread(state: SessionLogState, threadId?: string | null): SessionLogThread | null;

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

@@ -0,0 +1,126 @@
+import { isSessionLogMessage, isSessionLogThreadHead } from './guard.js';
+export const EMPTY_SESSION_LOG_STATE = Object.freeze({
+    generation: 0,
+    session: {},
+    threads: {},
+    messages: {},
+    revs: {},
+});
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isRev = (v) => Number.isSafeInteger(v) && v >= 0;
+function threadOfMessage(state, id) {
+    for (const [thread, list] of Object.entries(state.messages))
+        if (list.some((m) => m.message_id === id))
+            return thread;
+    return undefined;
+}
+function without(state, id) {
+    const thread = threadOfMessage(state, id);
+    if (thread === undefined)
+        return state.messages;
+    return { ...state.messages, [thread]: state.messages[thread].filter((m) => m.message_id !== id) };
+}
+function put(messages, message) {
+    const list = (messages[message.thread_id] ?? []).filter((m) => m.message_id !== message.message_id);
+    let at = list.length;
+    while (at > 0 && list[at - 1].seq > message.seq)
+        at--;
+    list.splice(at, 0, message);
+    return { ...messages, [message.thread_id]: list };
+}
+function applyMessage(state, p) {
+    if (!isObj(p) || !isRev(p.rev))
+        return state;
+    if ('message' in p) {
+        if (!isSessionLogMessage(p.message))
+            return state;
+        const id = p.message.message_id;
+        if ((state.revs[id] ?? -1) >= p.rev)
+            return state;
+        return { ...state, messages: put(without(state, id), p.message), revs: { ...state.revs, [id]: p.rev } };
+    }
+    if (typeof p.message_id !== 'string' || (state.revs[p.message_id] ?? -1) >= p.rev)
+        return state;
+    return { ...state, messages: without(state, p.message_id), revs: { ...state.revs, [p.message_id]: p.rev } };
+}
+function applyDelta(state, p) {
+    if (!isObj(p) || typeof p.delta !== 'string' || typeof p.thread_id !== 'string')
+        return state;
+    const list = state.messages[p.thread_id];
+    const at = list?.findIndex((m) => m.message_id === p.message_id) ?? -1;
+    if (!list || at < 0)
+        return state;
+    const message = list[at];
+    const index = message.blocks.findIndex((b) => b.id === p.block_id);
+    const block = message.blocks[index];
+    if (!block || (block.type !== 'text' && block.type !== 'reasoning'))
+        return state;
+    const blocks = message.blocks.slice();
+    blocks[index] = { ...block, text: block.text + p.delta };
+    const next = list.slice();
+    next[at] = { ...message, blocks };
+    return { ...state, messages: { ...state.messages, [p.thread_id]: next } };
+}
+export function applySessionLogEvent(state, event) {
+    const p = event.properties;
+    switch (event.type) {
+        case 'log.message':
+            return applyMessage(state, p);
+        case 'log.block.delta':
+            return applyDelta(state, p);
+        case 'log.thread':
+            return isSessionLogThreadHead(p) ? { ...state, threads: { ...state.threads, [p.thread_id]: p } } : state;
+        case 'log.state':
+            if (!isObj(p) || !isRev(p.generation) || p.generation < state.generation || !isObj(p.session))
+                return state;
+            return { ...state, generation: p.generation, session: { ...state.session, ...p.session } };
+        default:
+            return state;
+    }
+}
+export function applySessionLogPage(state, page) {
+    let messages = state.messages;
+    const thread = page.thread_id;
+    const held = thread === null ? undefined : messages[thread];
+    if (thread !== null && held) {
+        const from = page.has_more ? (page.messages[0]?.seq ?? Infinity) : -Infinity;
+        const kept = new Set(page.messages.map((m) => m.message_id));
+        const settled = held.filter((m) => m.seq < from || kept.has(m.message_id) || state.revs[m.message_id] !== undefined);
+        if (settled.length !== held.length)
+            messages = { ...messages, [thread]: settled };
+    }
+    for (const message of page.messages) {
+        if (!isSessionLogMessage(message) || state.revs[message.message_id] !== undefined)
+            continue;
+        messages = put(messages, message);
+    }
+    const threads = { ...state.threads };
+    for (const head of page.threads)
+        if (isSessionLogThreadHead(head))
+            threads[head.thread_id] = head;
+    const newer = page.generation > state.generation;
+    return {
+        ...state,
+        generation: Math.max(page.generation, state.generation),
+        session: newer ? { ...state.session, ...page.session } : { ...page.session, ...state.session },
+        threads,
+        messages,
+    };
+}
+const logs = new WeakMap();
+export function selectSessionLog(state) {
+    const cached = logs.get(state);
+    if (cached !== undefined)
+        return cached;
+    const session = state.session.session_id === undefined ? null : state.session;
+    const log = session && {
+        ...session,
+        threads: Object.values(state.threads).map((head) => ({ ...head, messages: state.messages[head.thread_id] ?? [] })),
+    };
+    logs.set(state, log);
+    return log;
+}
+export function selectSessionLogThread(state, threadId) {
+    const threads = selectSessionLog(state)?.threads ?? [];
+    return threads.find((t) => (threadId ? t.thread_id === threadId : t.parent_thread_id === null)) ?? null;
+}

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,65 @@
+import { BEEUNI_TRANSCRIPT_SCHEMA } from '../runtime/transcript-types.js';
+import { SESSION_LOG_MINOR, SESSION_LOG_SCHEMA } from './types.js';
+import { fromV1, toV1 } from './v1.js';
+const V = { schema: SESSION_LOG_SCHEMA, v: SESSION_LOG_MINOR };
+const EMPTY = Object.freeze({});
+const blocks = new WeakMap();
+export function toolCallBlock(part) {
+    const cached = blocks.get(part);
+    if (cached && cached.state === part.state)
+        return cached.block;
+    const sid = part.sessionID ?? null;
+    const info = { id: part.messageID, sessionID: part.sessionID, role: 'assistant' };
+    const log = fromV1({ session_id: '', root_id: sid, rows: [{ runtime_session_id: sid, info: info, parts: [part] }] }, { live: true });
+    const block = log.threads[0].messages[0].blocks[0];
+    blocks.set(part, { state: part.state, block });
+    return block;
+}
+const parts = new WeakMap();
+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: [block],
+            }],
+    };
+    const { rows } = toV1({
+        ...V, session_id: '', title: null, created_at: '', restore_grade: 'native', harness: { current: '', history: [] },
+        selection: { agent: null, model: null }, todos: [], pending: { questions: [], permissions: [] }, threads: [thread],
+    });
+    const part = rows[0].parts[0];
+    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;