@beeuni/sdk 0.1.0 → 0.3.0

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

@@ -0,0 +1,473 @@
+import { BEEUNI_TRANSCRIPT_SCHEMA, isTurnErrorCode } from '../runtime/transcript-types.js';
+import { SESSION_LOG_MINOR, SESSION_LOG_SCHEMA, } from './types.js';
+const IMPORT = 'beeuni-v1-import';
+const PRODUCER = { harness: IMPORT, harness_version: BEEUNI_TRANSCRIPT_SCHEMA, adapter_version: '1' };
+const V = { schema: SESSION_LOG_SCHEMA, v: SESSION_LOG_MINOR };
+const INTERRUPTED = { opencode: '[Tool execution was interrupted]', pi: 'No result provided' };
+const CLEARED = '[Old tool result content cleared]';
+const SUBTASK_TEXT = 'The following tool was executed by the user';
+const KIND = new Map(Object.entries({
+    bash: 'shell', powershell: 'shell', read: 'read', write: 'write', edit: 'edit', multiedit: 'edit', patch: 'patch', apply_patch: 'patch',
+    list: 'list', ls: 'list', glob: 'glob', find: 'glob', grep: 'grep', webfetch: 'web_fetch', websearch: 'web_search', codesearch: 'web_search',
+    todowrite: 'todo', todoread: 'todo', task: 'task', question: 'question', plan_enter: 'plan', plan_exit: 'plan',
+}));
+const kindOf = (name) => KIND.get(name) ?? (name.includes('_') ? 'mcp' : 'other');
+const FINISH_V2 = new Map([['stop', 'stop'], ['tool-calls', 'tool_calls'], ['length', 'length'], ['error', 'error']]);
+const FINISH_V1 = new Map([['stop', 'stop'], ['tool_calls', 'tool-calls'], ['length', 'length'], ['error', 'error']]);
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === 'string' ? v : undefined);
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const own = (o, k) => (Object.hasOwn(o, k) ? o[k] : undefined);
+const define = (o, k, v) => Object.defineProperty(o, k, { value: v, enumerable: true, writable: true, configurable: true });
+const iso = (ms) => (num(ms) !== undefined && Math.abs(ms) <= 8.64e15 ? new Date(ms).toISOString() : null);
+const msOf = (s) => {
+    const t = s ? Date.parse(s) : NaN;
+    return Number.isNaN(t) ? undefined : t;
+};
+function same(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b))
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((x, i) => same(x, b[i]));
+    if (!isObj(a) || !isObj(b))
+        return false;
+    const ka = Object.keys(a).filter((k) => a[k] !== undefined);
+    return ka.length === Object.keys(b).filter((k) => b[k] !== undefined).length && ka.every((k) => same(a[k], own(b, k)));
+}
+function diff(stored, built) {
+    if (same(stored, built))
+        return undefined;
+    if (stored === undefined)
+        return { del: true };
+    if (!isObj(stored) || !isObj(built))
+        return { set: stored };
+    const sub = {};
+    for (const k of new Set([...Object.keys(stored), ...Object.keys(built)])) {
+        const change = diff(own(stored, k), own(built, k));
+        if (change)
+            define(sub, k, change);
+    }
+    return { sub };
+}
+function apply(built, change) {
+    if (!change)
+        return built;
+    if ('set' in change)
+        return change.set;
+    if ('del' in change)
+        return undefined;
+    const out = isObj(built) ? { ...built } : {};
+    for (const [k, c] of Object.entries(change.sub)) {
+        const v = apply(own(out, k), c);
+        if (v === undefined)
+            delete out[k];
+        else
+            define(out, k, v);
+    }
+    return out;
+}
+const v1Ext = (ext) => Object.values(ext ?? {}).find((e) => e.version === BEEUNI_TRANSCRIPT_SCHEMA);
+const extOf = (h, entry) => ({ [h]: { version: BEEUNI_TRANSCRIPT_SCHEMA, ...entry } });
+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 };
+    const start = msOf(b.started_at) ?? c.created;
+    const end = msOf(b.ended_at) ?? start;
+    const meta = r?.exit_code !== undefined ? { exit: r.exit_code } : {};
+    if (b.status === 'pending')
+        return { status: 'pending', input: b.input ?? {}, raw: '' };
+    if (b.status === 'running')
+        return { status: 'running', input: b.input ?? {}, ...(b.title && { title: b.title }), time: { start } };
+    if (b.status === 'error')
+        return { status: 'error', ...input, error: textOf(r?.content), ...(r?.exit_code !== undefined && { metadata: meta }), time: { start, end } };
+    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: { ...detailsOf(b), ...meta },
+        time: { start, end, ...(compacted !== undefined && { compacted }) },
+        ...(atts.length && { attachments: atts }),
+    };
+}
+function partOf(b, c) {
+    const base = head(b, c);
+    switch (b.type) {
+        case 'text': return { ...base, type: 'text', text: b.text, ...(b.synthetic !== undefined && { synthetic: b.synthetic }) };
+        case 'reasoning': return { ...base, type: 'reasoning', text: b.text, time: { start: c.created } };
+        case 'attachment': return { ...base, type: 'file', mime: b.mime, ...(b.name !== undefined && { filename: b.name }), ...urlOf(b, c) };
+        case 'tool_call': return { ...base, type: 'tool', callID: b.call_id, tool: b.name, state: toolState(b, c, { ...(c.sessionID !== null && { sessionID: c.sessionID }), messageID: c.messageID }) };
+        case 'step': return b.phase === 'start'
+            ? { ...base, type: 'step-start' }
+            : { ...base, type: 'step-finish', reason: 'stop', cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } };
+        case 'compaction': return {
+            ...base, type: 'compaction', auto: b.trigger === 'auto' || b.trigger === 'overflow',
+            ...(b.trigger === 'overflow' && { overflow: true }), ...(b.first_kept_message_id !== null && { tail_start_id: b.first_kept_message_id }),
+        };
+        case 'harness':
+            if (c.fromV1 && (b.harness === 'opencode' || b.harness === 'pi'))
+                return b.data;
+            return b.model_visible && b.fallback_text !== undefined ? { ...base, type: 'text', text: b.fallback_text, synthetic: true } : undefined;
+        case 'subtask': return undefined;
+    }
+}
+function errorV1(e) {
+    if (!isTurnErrorCode(e.code))
+        return { name: e.code, data: { message: e.message } };
+    return { name: e.code === 'aborted' ? 'MessageAbortedError' : 'UnknownError', code: e.code, data: { message: e.message } };
+}
+function assistantInfo(m, c, over = {}) {
+    const u = m.usage;
+    const finish = m.finish === null ? undefined : FINISH_V1.get(m.finish);
+    return {
+        id: m.message_id, ...(c.sessionID !== null && { sessionID: c.sessionID }), role: 'assistant',
+        time: { created: c.created, ...(m.completed_at !== null && { completed: msOf(m.completed_at) }) },
+        ...(m.reply_to && { parentID: m.reply_to }),
+        modelID: m.model?.model ?? '', providerID: m.model?.provider ?? '', ...(m.model?.variant !== undefined && { variant: m.model.variant }),
+        mode: m.agent ?? '', agent: m.agent ?? '', path: { cwd: '', root: '' },
+        cost: u?.cost ?? 0, tokens: { input: u?.input ?? 0, output: u?.output ?? 0, reasoning: u?.reasoning ?? 0, cache: { read: u?.cache_read ?? 0, write: u?.cache_write ?? 0 } },
+        ...(finish && { finish }), ...(m.error && { error: errorV1(m.error) }),
+        ...over,
+    };
+}
+function infoOf(m, c) {
+    if (m.role === 'assistant')
+        return assistantInfo(m, c);
+    return {
+        id: m.message_id, ...(c.sessionID !== null && { sessionID: c.sessionID }), role: 'user', time: { created: c.created },
+        agent: m.agent ?? '', model: { providerID: m.model?.provider ?? '', modelID: m.model?.model ?? '', ...(m.model?.variant !== undefined && { variant: m.model.variant }) },
+    };
+}
+function summaryOf(m, cb, c) {
+    const id = `${m.message_id}-summary`;
+    const info = assistantInfo({ ...m, reply_to: m.message_id, agent: 'compaction', finish: m.status === 'complete' ? 'stop' : null }, c, { id, summary: true });
+    return { info, parts: [{ id: `${id}-p0`, ...(c.sessionID !== null && { sessionID: c.sessionID }), messageID: id, type: 'text', text: cb.summary }] };
+}
+function rowsOf(m, threadNative, v1Thread) {
+    const v1 = v1Thread || m.producer.harness === IMPORT;
+    if (!v1 && (m.role === 'system' || m.kind === 'context'))
+        return [];
+    const d = v1Ext(m.ext)?.data;
+    const sessionID = d && 'runtime_session_id' in d ? d.runtime_session_id ?? null : threadNative;
+    const c = { sessionID, messageID: m.message_id, created: msOf(m.created_at), fromV1: v1 };
+    const parts = d && 'parts' in d
+        ? d.parts
+        : m.blocks.flatMap((b) => {
+            const p = partOf(b, c);
+            return p === undefined ? [] : [apply(p, v1Ext(b.ext)?.data)];
+        });
+    const rows = [{ runtime_session_id: sessionID, info: apply(infoOf(m, c), d?.info), parts }];
+    const cb = m.blocks.find((b) => b.type === 'compaction');
+    if (m.kind === 'compaction' && cb && cb.summary !== null) {
+        const s = apply(summaryOf(m, cb, c), d?.summary);
+        rows.push({ runtime_session_id: sessionID, info: s.info, parts: s.parts });
+    }
+    return rows;
+}
+const created = (r) => num(isObj(r.info) && isObj(r.info.time) ? r.info.time.created : undefined) ?? -Infinity;
+const idOf = (r) => String(isObj(r.info) ? r.info.id : '');
+const rowOrder = (a, b) => created(a) - created(b) || (idOf(a) < idOf(b) ? -1 : idOf(a) > idOf(b) ? 1 : 0);
+const threadNativeOf = (t) => {
+    const e = v1Ext(t.ext);
+    return e ? e.native_id ?? null : t.thread_id;
+};
+export function toV1(input) {
+    const log = structuredClone(input);
+    const root = log.threads.find((t) => t.parent_thread_id === null) ?? log.threads[0];
+    const rows = log.threads.flatMap((t) => t.messages.flatMap((m) => rowsOf(m, threadNativeOf(t), v1Ext(t.ext) !== undefined)));
+    const stated = v1Ext(log.ext)?.data;
+    const rootId = stated && 'root_id' in stated ? stated.root_id ?? null : root ? threadNativeOf(root) : null;
+    return { session_id: log.session_id, root_id: rootId, rows: rows.sort(rowOrder) };
+}
+function modelOf(info) {
+    const src = info.role === 'assistant' ? { p: info.providerID, m: info.modelID, v: info.variant } : isObj(info.model) ? { p: info.model.providerID, m: info.model.modelID, v: info.model.variant } : {};
+    const provider = str(src.p);
+    const model = str(src.m);
+    return provider === undefined || model === undefined ? null : { provider, model, ...(str(src.v) !== undefined && { variant: src.v }) };
+}
+function usageOf(info) {
+    if (!isObj(info.tokens))
+        return null;
+    const t = info.tokens;
+    const cache = isObj(t.cache) ? t.cache : {};
+    return {
+        input: num(t.input) ?? 0, output: num(t.output) ?? 0, cache_read: num(cache.read) ?? 0, cache_write: num(cache.write) ?? 0,
+        ...(num(t.reasoning) !== undefined && { reasoning: t.reasoning }), ...(num(info.cost) !== undefined && { cost: info.cost }),
+    };
+}
+const errorOf = (e) => ({ code: str(e.code) || str(e.name) || 'UnknownError', message: str(isObj(e.data) ? e.data.message : undefined) ?? '' });
+function attachment(p, c, lost) {
+    const r = c.resolve(p);
+    if (!r)
+        lost.attachment++;
+    return {
+        mime: str(p.mime) ?? 'application/octet-stream',
+        ...(r && { ref: r.ref, bytes: r.bytes, ...(r.sha256 !== undefined && { sha256: r.sha256 }) }),
+        ...(str(p.url) !== undefined && { url: p.url }),
+    };
+}
+function toolBlock(p, id, c, lost) {
+    const st = p.state;
+    const time = isObj(st.time) ? st.time : {};
+    if (!isObj(st.input))
+        lost.tool_input++;
+    const exit = isObj(st.metadata) && num(st.metadata.exit) !== undefined ? { exit_code: st.metadata.exit } : {};
+    let status;
+    let result;
+    let input = st.input ?? null;
+    if (st.status === 'completed') {
+        const atts = (Array.isArray(st.attachments) ? st.attachments : []).filter(isObj).map((a) => {
+            const { bytes: _bytes, ...content } = attachment(a, c, lost);
+            return { type: 'attachment', ...content };
+        });
+        const cleared = iso(time.compacted);
+        status = 'complete';
+        result = {
+            content: [...(str(st.output) !== undefined ? [{ type: 'text', text: st.output }] : []), ...atts], is_error: false, ...exit,
+            ...(cleared && { model_content: [{ type: 'text', text: CLEARED }], cleared_at: cleared }),
+        };
+    }
+    else if (st.status === 'error') {
+        const error = str(st.error);
+        status = 'error';
+        result = { content: error !== undefined ? [{ type: 'text', text: error }] : [], is_error: true, ...(error !== undefined && { error: { message: error } }), ...exit };
+    }
+    else if (c.live) {
+        status = st.status === 'pending' ? 'pending' : 'running';
+        if (status === 'pending' && str(st.raw) && !(isObj(st.input) && Object.keys(st.input).length))
+            input = st.raw;
+    }
+    else {
+        const text = INTERRUPTED[c.h];
+        status = 'error';
+        result = { content: [{ type: 'text', text }], is_error: true, synthetic: true, error: { code: 'interrupted', message: text } };
+    }
+    const started = iso(time.start);
+    const ended = iso(time.end);
+    return {
+        type: 'tool_call', id, call_id: p.callID, name: p.tool, kind: kindOf(p.tool), input, status, ...(result && { result }),
+        ...(str(st.title) && { title: st.title }), ...(started && { started_at: started }), ...(ended && { ended_at: ended }),
+    };
+}
+function blockOf(p, id, marker, summary, c, lost) {
+    const harness = (kind, model_visible = false) => ({
+        type: 'harness', id, harness: c.h, kind, data: p, model_visible, ...(model_visible && { fallback_text: SUBTASK_TEXT }),
+    });
+    if (!isObj(p))
+        return harness('unknown');
+    switch (p.type) {
+        case 'text':
+            return typeof p.text !== 'string' || p.ignored === true ? harness('text') : { type: 'text', id, text: p.text, ...(typeof p.synthetic === 'boolean' && { synthetic: p.synthetic }) };
+        case 'reasoning':
+            return typeof p.text !== 'string' ? harness('reasoning') : { type: 'reasoning', id, text: p.text };
+        case 'file': {
+            if (p.mime === 'text/plain' || p.mime === 'application/x-directory')
+                return harness('file');
+            return { type: 'attachment', id, ...attachment(p, c, lost), ...(str(p.filename) !== undefined && { name: p.filename }) };
+        }
+        case 'tool':
+            return typeof p.callID === 'string' && typeof p.tool === 'string' && isObj(p.state) ? toolBlock(p, id, c, lost) : harness('tool');
+        case 'step-start':
+        case 'step-finish':
+            return { type: 'step', id, phase: p.type === 'step-start' ? 'start' : 'finish' };
+        case 'compaction': {
+            if (p !== marker)
+                return harness('compaction');
+            const trigger = p.overflow === true ? 'overflow' : p.auto === true ? 'auto' : 'manual';
+            return { type: 'compaction', id, summary, first_kept_message_id: str(p.tail_start_id) ?? null, trigger };
+        }
+        case 'subtask':
+            return harness('subtask', true);
+        default:
+            return harness(str(p.type) || 'unknown');
+    }
+}
+function blockIds(parts) {
+    const given = parts.map((p, i) => (isObj(p) && typeof p.id === 'string' && p.id ? p.id : `#${i}`));
+    const taken = new Set(given);
+    const seen = new Set();
+    return given.map((id) => {
+        if (!seen.has(id)) {
+            seen.add(id);
+            return id;
+        }
+        let n = 2;
+        while (taken.has(`${id}#${n}`))
+            n++;
+        taken.add(`${id}#${n}`);
+        return `${id}#${n}`;
+    });
+}
+function toMessage(row, sum, threadId, seq, superseded, c) {
+    const info = isObj(row.info) ? row.info : {};
+    const parts = Array.isArray(row.parts) ? row.parts : [];
+    const marker = info.role === 'user' ? parts.find((p) => isObj(p) && p.type === 'compaction') : undefined;
+    const sInfo = sum && isObj(sum.info) ? sum.info : undefined;
+    const role = info.role === 'assistant' || info.role === 'user' ? info.role : 'system';
+    const src = marker ? sInfo : role === 'assistant' ? info : undefined;
+    const err = src && isObj(src.error) ? src.error : undefined;
+    const aborted = err?.name === 'MessageAbortedError';
+    const completedAt = src && isObj(src.time) ? iso(src.time.completed) : null;
+    const open = c.live ? 'streaming' : 'interrupted';
+    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 ? 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++;
+    const m = {
+        ...V, message_id: str(info.id) ?? '', thread_id: threadId, seq, role, kind: marker ? 'compaction' : 'turn', status, in_context: inContext,
+        ...(hidden && { hidden_reason: hidden }),
+        agent: str(info.agent) ?? null,
+        ...(role === 'assistant' && { reply_to: str(info.parentID) ?? null }),
+        model: modelOf(info), usage: src ? usageOf(src) : null,
+        finish: !src || marker ? null : aborted ? 'aborted' : err ? 'error' : FINISH_V2.get(info.finish) ?? null,
+        error: err ? errorOf(err) : null,
+        created_at: createdAt, completed_at: src || marker ? completedAt : createdAt || null,
+        producer: PRODUCER, blocks,
+    };
+    return { m, lost };
+}
+function keepResidual(m, row, sum, threadNative, h) {
+    const data = {};
+    if (row.runtime_session_id !== threadNative)
+        data.runtime_session_id = row.runtime_session_id;
+    const c = { sessionID: row.runtime_session_id, messageID: m.message_id, created: msOf(m.created_at), fromV1: true };
+    if (Array.isArray(row.parts)) {
+        m.blocks.forEach((b, i) => {
+            if (b.type === 'harness' || b.type === 'subtask')
+                return;
+            const change = diff(row.parts[i], partOf(b, c));
+            if (change)
+                b.ext = extOf(h, { data: change });
+        });
+    }
+    else
+        data.parts = row.parts;
+    const info = diff(row.info, infoOf(m, c));
+    if (info)
+        data.info = info;
+    const cb = m.blocks.find((b) => b.type === 'compaction');
+    if (sum && cb) {
+        const change = diff({ info: sum.info, parts: sum.parts }, summaryOf(m, cb, c));
+        if (change)
+            data.summary = change;
+    }
+    if (Object.keys(data).length)
+        m.ext = extOf(h, { data });
+}
+function spawnerOf(rows, id, text) {
+    if (!id)
+        return undefined;
+    for (const exact of [true, false]) {
+        for (const row of rows) {
+            if (row.runtime_session_id === id || !Array.isArray(row.parts))
+                continue;
+            for (const p of row.parts) {
+                if (!isObj(p) || p.type !== 'tool' || !isObj(p.state))
+                    continue;
+                if (exact ? isObj(p.state.metadata) && p.state.metadata.sessionId === id : text(p.state).includes(id))
+                    return { row, part: p };
+            }
+        }
+    }
+    return undefined;
+}
+export function fromV1(v1, options = {}) {
+    const c = { h: options.harness ?? 'opencode', resolve: options.resolveAttachment ?? (() => null), counts: { tool_input: 0, cut_point: 0, attachment: 0 }, live: options.live === true };
+    const rows = structuredClone(v1.rows).sort(rowOrder);
+    const groups = new Map();
+    for (const r of rows) {
+        const list = groups.get(r.runtime_session_id);
+        if (list)
+            list.push(r);
+        else
+            groups.set(r.runtime_session_id, [r]);
+    }
+    const stated = v1.root_id;
+    const usable = groups.has(stated);
+    const texts = new Map();
+    const text = (state) => texts.get(state) ?? (texts.set(state, JSON.stringify(state)), texts.get(state));
+    const spawners = new Map();
+    for (const id of groups.keys()) {
+        const s = usable && id === stated ? undefined : spawnerOf(rows, id, text);
+        if (s)
+            spawners.set(id, s);
+    }
+    const latest = [...rows].reverse().find((r) => r.runtime_session_id === null || !spawners.has(r.runtime_session_id));
+    const root = usable || !latest ? stated : latest.runtime_session_id;
+    if (!groups.has(root))
+        groups.set(root, []);
+    const rootThread = root || v1.session_id;
+    const threadOf = (id) => (id !== null && spawners.has(id) ? id : rootThread);
+    const sessionCreated = iso(rows.map(created).find(Number.isFinite)) ?? '';
+    const threads = [];
+    for (const [id, own] of groups) {
+        if (id !== root && (id === null || !spawners.has(id)))
+            continue;
+        const isRoot = id === root;
+        const superseded = isRoot ? rows.filter((r) => r.runtime_session_id !== root && threadOf(r.runtime_session_id) === rootThread) : [];
+        const list = [...superseded, ...own];
+        const old = new Set(superseded);
+        const summaries = new Map();
+        const paired = new Set();
+        for (const row of list) {
+            const info = isObj(row.info) ? row.info : {};
+            if (info.role !== 'user' || !Array.isArray(row.parts) || !row.parts.some((p) => isObj(p) && p.type === 'compaction'))
+                continue;
+            const sum = list.find((r) => !paired.has(r) && r.runtime_session_id === row.runtime_session_id && isObj(r.info) && r.info.role === 'assistant' && r.info.summary === true && r.info.parentID === info.id);
+            if (!sum)
+                continue;
+            summaries.set(row, sum);
+            paired.add(sum);
+        }
+        const messages = [];
+        for (const row of list) {
+            if (paired.has(row))
+                continue;
+            const sum = summaries.get(row);
+            const { m, lost } = toMessage(row, sum, isRoot ? rootThread : id, messages.length + 1, old.has(row), c);
+            keepResidual(m, row, sum, id, c.h);
+            if (m.in_context)
+                for (const k of ['tool_input', 'cut_point', 'attachment'])
+                    c.counts[k] += lost[k];
+            messages.push(m);
+        }
+        const spawn = id === null ? undefined : spawners.get(id);
+        const firstUser = messages.find((m) => m.role === 'user' && m.kind === 'turn');
+        threads.push({
+            ...V, thread_id: isRoot ? rootThread : id,
+            parent_thread_id: spawn ? threadOf(spawn.row.runtime_session_id) : null,
+            spawned_by: spawn && typeof spawn.part.callID === 'string' ? { message_id: str(spawn.row.info?.id) ?? '', call_id: spawn.part.callID } : null,
+            agent: firstUser?.agent ?? null, title: null, created_at: messages[0]?.created_at || sessionCreated, messages,
+            ext: extOf(c.h, id === null ? {} : { native_id: id }),
+        });
+    }
+    threads.sort((a, b) => (a.parent_thread_id === null ? -1 : b.parent_thread_id === null ? 1 : rowsIndex(a) - rowsIndex(b)));
+    const lastUser = threads[0]?.messages.filter((m) => m.role === 'user' && m.kind === 'turn').at(-1);
+    const partial = c.counts.tool_input + c.counts.cut_point + c.counts.attachment > 0;
+    return {
+        ...V, session_id: v1.session_id, title: null, created_at: sessionCreated,
+        restore_grade: partial ? 'partial' : 'converted', grade_counts: c.counts,
+        harness: { current: c.h, history: [] },
+        selection: { agent: lastUser?.agent ?? null, model: lastUser?.model ?? null },
+        todos: [], pending: { questions: [], permissions: [] }, threads,
+        ...(root !== stated && { ext: extOf(c.h, { data: { root_id: stated } }) }),
+    };
+    function rowsIndex(t) {
+        return rows.findIndex((r) => r.runtime_session_id === t.thread_id);
+    }
+}

package/dist/core/session-sync/copy-store-types.d.ts

@@ -0,0 +1,19 @@
+import type { SessionTranscriptSyncEnvelope } from '../rest/projects-client/sessions.js';
+export interface StoredCopy<T = SessionTranscriptSyncEnvelope> {
+    v: number;
+    user: string;
+    at: number;
+    e: T;
+}
+export interface CopyCodec<T> {
+    paintable(value: T | null | undefined): value is T;
+    fit(stored: StoredCopy<T>, maxChars: number): string | null;
+    capturedAt(value: T): number;
+}
+export interface CopyStore<T> {
+    keyFor(projectId: string, sessionId: string): string;
+    read(projectId: string, sessionId: string): T | null | Promise<T | null>;
+    write(projectId: string, sessionId: string, value: T): Promise<void>;
+    remove(projectId: string, sessionId: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/core/session-sync/copy-store-types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/session-sync/saved-copy-store.js

@@ -1,3 +1,4 @@
+import { registerSessionLogCopies, SESSION_LOG_COPY } from '../session-log/saved-log.js';
 export function isPaintableSavedCopy(envelope) {
     return (!!envelope &&
         envelope.available === true &&
@@ -58,7 +59,27 @@ function capturedAtMs(envelope) {
     const parsed = envelope.captured_at ? Date.parse(envelope.captured_at) : Number.NaN;
     return Number.isFinite(parsed) ? parsed : 0;
 }
+const ENVELOPE = {
+    paintable: isPaintableSavedCopy,
+    fit: fitSavedCopy,
+    capturedAt: capturedAtMs,
+};
 export function createSavedCopyStore(options) {
+    const v1 = createCopyStore(options, ENVELOPE);
+    const v2 = createCopyStore({ ...options, namespace: `${options.namespace ?? DEFAULT_NAMESPACE}.log` }, SESSION_LOG_COPY);
+    const store = {
+        ...v1,
+        remove: async (projectId, sessionId) => {
+            await Promise.all([v1.remove(projectId, sessionId), v2.remove(projectId, sessionId)]);
+        },
+        clear: async () => {
+            await Promise.all([v1.clear(), v2.clear()]);
+        },
+    };
+    registerSessionLogCopies(store, v2, v1.remove);
+    return store;
+}
+function createCopyStore(options, codec) {
     const { storage, userId, maxSessions = DEFAULT_MAX_SESSIONS, maxBytes = DEFAULT_MAX_BYTES, maxEnvelopeBytes = DEFAULT_MAX_ENVELOPE_BYTES, maxAgeMs = DEFAULT_MAX_AGE_MS, namespace = DEFAULT_NAMESPACE, now = () => Date.now(), } = options;
     const prefix = `${namespace}:${userId}:`;
     const indexKey = `${prefix}index`;
@@ -163,7 +184,7 @@ export function createSavedCopyStore(options) {
                     stored.v !== VERSION ||
                     stored.user !== userId ||
                     now() - stored.at > maxAgeMs ||
-                    !isPaintableSavedCopy(stored.e)) {
+                    !codec.paintable(stored.e)) {
                     removeNow(keyFor(projectId, sessionId));
                     void forgetScope(scope);
                     return null;
@@ -174,13 +195,13 @@ export function createSavedCopyStore(options) {
         },
         write(projectId, sessionId, envelope) {
             const scope = `${projectId}/${sessionId}`;
-            if (!isPaintableSavedCopy(envelope))
+            if (!codec.paintable(envelope))
                 return forgetScope(scope);
             const stored = { v: VERSION, user: userId, at: now(), e: envelope };
-            const text = fitSavedCopy(stored, maxEnvelopeBytes);
+            const text = codec.fit(stored, maxEnvelopeBytes);
             if (text === null)
                 return forgetScope(scope);
-            const captured = capturedAtMs(envelope);
+            const captured = codec.capturedAt(envelope);
             return enqueue(async () => {
                 const entries = await loadIndex();
                 const existing = entries.find((entry) => entry.s === scope);

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;

package/dist/core/session-sync/saved-transcript.js

@@ -1,3 +1,58 @@
+import { getSessionTranscriptSync, getSessionTurn, } from '../rest/projects-client/sessions.js';
+import { OPEN_BUNDLE_TRANSCRIPT_LIMIT, claimOpenBundle, heldSavedWindow, holdSavedWindow, openBundleHistory, } from '../session/open-bundle.js';
+export const SAVED_HISTORY_SNAPSHOT_WAIT_MS = 2_000;
+export async function loadSavedTranscript(projectId, sessionId, options = {}) {
+    return heldSavedWindow(projectId, sessionId) ?? readSavedWindow(projectId, sessionId, options);
+}
+async function readSavedWindow(projectId, sessionId, options) {
+    const claimed = claimOpenBundle(projectId, sessionId);
+    let timer;
+    const bundle = claimed
+        ? await Promise.race([
+            claimed,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, options.snapshotWaitMs ?? SAVED_HISTORY_SNAPSHOT_WAIT_MS, null);
+            }),
+        ]).finally(() => clearTimeout(timer))
+        : null;
+    return ((bundle && openBundleHistory(bundle)) ??
+        getSessionTranscriptSync(projectId, sessionId, {
+            limit: OPEN_BUNDLE_TRANSCRIPT_LIMIT,
+            history: true,
+            signal: options.signal,
+        }));
+}
+export async function readSavedSessionCopy(input) {
+    const { projectId, sessionId, runtimeSessionId } = input;
+    if (!projectId || !sessionId || !runtimeSessionId)
+        return { envelope: null, empty: false };
+    let envelope;
+    try {
+        envelope = await readSavedWindow(projectId, sessionId, {});
+    }
+    catch {
+        return { envelope: null, empty: false };
+    }
+    holdSavedWindow(projectId, sessionId, envelope);
+    if (savedCopyEmptyRoot(envelope) !== runtimeSessionId)
+        return { envelope, empty: false };
+    try {
+        const turn = await getSessionTurn(projectId, sessionId);
+        return {
+            envelope,
+            empty: isEmptyConversation({
+                savedEmptyRoot: runtimeSessionId,
+                rootSessionId: runtimeSessionId,
+                turnRead: true,
+                hasEndedTurn: turn.last_ended != null,
+                hasOpenOrQueuedTurn: turn.turns.length > 0,
+            }),
+        };
+    }
+    catch {
+        return { envelope, empty: false };
+    }
+}
 export function resolveSavedTranscript(input) {
     if (input.hasMessages)
         return 'shown';

package/dist/core/session-sync/session-sync-controller.js

@@ -132,6 +132,9 @@ export class SessionSyncController {
     reconcile(reason = 'manual') {
         if (this.destroyed)
             return Promise.resolve();
+        if (reason === 'visible' && this.streamReliable && this.snapshot.freshness === 'fresh') {
+            return Promise.resolve();
+        }
         if (this.tailRequest)
             return this.tailRequest;
         this.update({

package/dist/core/stream/event-stream.js

@@ -1,4 +1,4 @@
-import { getSupabaseAccessToken, invalidateTokenCache } from '../http/auth.js';
+import { getAuthToken as getSupabaseAccessToken, invalidateTokenCache } from '../http/auth.js';
 import { getClientForUrl } from '../runtime/client.js';
 import { isAuthFailure } from '../http/api/errors.js';
 import { logger } from '../http/logger.js';
@@ -222,8 +222,8 @@ function createLiveStream(client, opts, subscribers) {
                     schedule();
                     if (t.now() - yieldedAt < YIELD_INTERVAL_MS)
                         continue;
-                    yieldedAt = t.now();
                     await new Promise((resolve) => t.setTimeout(resolve, 0));
+                    yieldedAt = t.now();
                 }
                 stableConnection = streamHadWork;
             }