@beeuni/sdk 0.1.0 → 0.3.0

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

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

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

@@ -0,0 +1,215 @@
+import { SESSION_LOG_MINOR, SESSION_LOG_SCHEMA } from './types.js';
+import { BEEUNI_TRANSCRIPT_SCHEMA } from '../runtime/transcript-types.js';
+import { fromV1, toV1 } from './v1.js';
+const SHELL = {
+    schema: SESSION_LOG_SCHEMA,
+    v: SESSION_LOG_MINOR,
+    session_id: '',
+    title: null,
+    created_at: '',
+    restore_grade: 'native',
+    harness: { current: '', history: [] },
+    selection: { agent: null, model: null },
+    todos: [],
+    pending: { questions: [], permissions: [] },
+};
+const NO_MESSAGES = [];
+const v1Ext = (head) => Object.values(head.ext ?? {}).find((e) => e.version === BEEUNI_TRANSCRIPT_SCHEMA);
+export const isV1Thread = (head) => !!head && v1Ext(head) !== undefined;
+const nativeOf = (head) => {
+    const e = v1Ext(head);
+    return e ? (e.native_id ?? null) : head.thread_id;
+};
+const messageRows = new WeakMap();
+export function rowsOf(head, message) {
+    const native = nativeOf(head);
+    const cached = messageRows.get(message);
+    if (cached && cached.native === native)
+        return cached.rows;
+    const { rows } = toV1({ ...SHELL, threads: [{ ...head, messages: [message] }] });
+    const out = rows.map((r) => ({ info: r.info, parts: r.parts }));
+    messageRows.set(message, { native, rows: out });
+    return out;
+}
+const indexes = new WeakMap();
+function indexOf(state) {
+    let index = indexes.get(state);
+    if (!index) {
+        index = new Map();
+        for (const head of Object.values(state.threads)) {
+            const native = nativeOf(head);
+            if (native !== null && !index.has(native))
+                index.set(native, head.thread_id);
+        }
+        indexes.set(state, index);
+    }
+    return index;
+}
+function findThread(logs, runtimeSessionId) {
+    for (const state of Object.values(logs)) {
+        const threadId = indexOf(state).get(runtimeSessionId);
+        if (threadId !== undefined)
+            return { state, head: state.threads[threadId], list: state.messages[threadId] ?? NO_MESSAGES };
+    }
+    return null;
+}
+const createdOf = (row) => row.info.time?.created;
+function insertAt(rows, row) {
+    const created = createdOf(row);
+    if (created === undefined)
+        return rows.length;
+    const at = rows.findIndex((other) => {
+        const t = createdOf(other);
+        return t !== undefined && (t > created || (t === created && other.info.id > row.info.id));
+    });
+    return at < 0 ? rows.length : at;
+}
+function messageInsertAt(messages, message) {
+    const created = Date.parse(message.created_at);
+    if (!Number.isFinite(created))
+        return messages.length;
+    const at = messages.findIndex((other) => {
+        const t = Date.parse(other.created_at);
+        return Number.isFinite(t) && (t > created || (t === created && other.message_id > message.message_id));
+    });
+    return at < 0 ? messages.length : at;
+}
+const v1Order = (a, b) => (createdOf(a) ?? -Infinity) - (createdOf(b) ?? -Infinity) || (a.info.id < b.info.id ? -1 : a.info.id > b.info.id ? 1 : 0);
+const merged = new WeakMap();
+function heldByLog(row, held, revs, echoOf) {
+    const id = row.info.id;
+    if (held.has(id) || revs[id] !== undefined)
+        return true;
+    const echo = echoOf?.(id);
+    return echo !== undefined && (held.has(echo) || revs[echo] !== undefined);
+}
+export function sessionLogRowsFor(logs, runtimeSessionId, v1Rows, echoOf) {
+    const found = findThread(logs, runtimeSessionId);
+    if (!found)
+        return v1Rows;
+    const { state, head, list } = found;
+    const cached = merged.get(list);
+    const native = nativeOf(head);
+    const own = cached && cached.v1Rows === v1Rows && cached.native === native && cached.revs === state.revs ? cached.own : list.flatMap((m) => rowsOf(head, m)).sort(v1Order);
+    const shown = new Set(own.map((r) => r.info.id));
+    const extra = v1Rows.filter((row) => !heldByLog(row, shown, state.revs, echoOf));
+    if (cached && cached.own === own && cached.extra.length === extra.length && cached.extra.every((r, i) => r === extra[i]))
+        return cached.result;
+    const result = [...own];
+    for (const row of extra)
+        result.splice(insertAt(result, row), 0, row);
+    merged.set(list, { v1Rows, native, revs: state.revs, own, extra, result });
+    return result;
+}
+const extended = new WeakMap();
+export function sessionLogThreadWithV1Rows(state, thread, v1Rows, echoOf) {
+    const cached = extended.get(thread);
+    const held = cached?.held ?? new Set(thread.messages.flatMap((m) => rowsOf(thread, m).map((r) => r.info.id)));
+    const extra = v1Rows.filter((r) => !heldByLog(r, held, state.revs, echoOf));
+    if (cached && cached.extra.length === extra.length && cached.extra.every((r, i) => r === extra[i]))
+        return cached.result;
+    let result = thread;
+    if (extra.length) {
+        let seq = thread.messages[thread.messages.length - 1]?.seq ?? 0;
+        const { paired, used } = pairCompactions(extra);
+        const messages = [...thread.messages];
+        for (const r of extra) {
+            if (used.has(r))
+                continue;
+            const message = convert(state.session.session_id ?? '', thread.thread_id, r, paired.get(r), ++seq).message;
+            messages.splice(messageInsertAt(messages, message), 0, message);
+        }
+        result = { ...thread, messages };
+    }
+    extended.set(thread, { held, extra, result });
+    return result;
+}
+const converted = new WeakMap();
+const views = new WeakMap();
+const isObj = (v) => typeof v === 'object' && v !== null;
+const iso = (ms) => (ms !== undefined && Number.isFinite(ms) && Math.abs(ms) <= 8.64e15 ? new Date(ms).toISOString() : null);
+const isMarker = (row) => row.info.role === 'user' && row.parts.some((p) => isObj(p) && p.type === 'compaction');
+const summaryOf = (row, marker) => {
+    const info = row.info;
+    return info.role === 'assistant' && info.summary === true && info.parentID === marker.info.id;
+};
+const partBlocks = new WeakMap();
+function reuseBlocks(native, row, message) {
+    const info = row.info;
+    const at = `${native}|${String(info.id)}|${String(info.time?.created)}`;
+    let reused = false;
+    const blocks = message.blocks.map((block, i) => {
+        const part = row.parts[i];
+        if (!isObj(part) || block.type === 'compaction')
+            return block;
+        const key = `${at}|${i}|${block.id}`;
+        const prev = partBlocks.get(part);
+        if (prev && prev.key === key) {
+            reused = true;
+            return prev.block;
+        }
+        partBlocks.set(part, { key, block });
+        return block;
+    });
+    return reused ? { ...message, blocks } : message;
+}
+function pairCompactions(rows) {
+    const paired = new Map();
+    const used = new Set();
+    for (const row of rows) {
+        if (!isMarker(row))
+            continue;
+        const sum = rows.find((r) => !used.has(r) && summaryOf(r, row));
+        if (!sum)
+            continue;
+        paired.set(row, sum);
+        used.add(sum);
+    }
+    return { paired, used };
+}
+function convert(sessionId, native, row, sum, seq) {
+    const cached = converted.get(row);
+    if (cached && cached.sessionId === sessionId && cached.native === native && cached.sum === sum && cached.seq === seq)
+        return cached;
+    const unit = sum ? [row, sum] : [row];
+    const log = fromV1({ session_id: sessionId, root_id: native, rows: unit.map((r) => ({ runtime_session_id: native, info: r.info, parts: r.parts })) }, { live: true });
+    const message = reuseBlocks(native, row, log.threads[0].messages[0]);
+    const entry = { sessionId, native, sum, seq, message: { ...message, seq }, lost: log.grade_counts };
+    converted.set(row, entry);
+    return entry;
+}
+export function sessionLogOfV1Rows(sessionId, runtimeSessionId, rows) {
+    const cached = views.get(rows);
+    if (cached && cached.sessionId === sessionId && cached.native === runtimeSessionId)
+        return cached.log;
+    const sorted = [...rows].sort(v1Order);
+    const { paired, used } = pairCompactions(sorted);
+    const counts = { tool_input: 0, cut_point: 0, attachment: 0 };
+    const messages = [];
+    for (const row of sorted) {
+        if (used.has(row))
+            continue;
+        const entry = convert(sessionId, runtimeSessionId, row, paired.get(row), messages.length + 1);
+        for (const k of ['tool_input', 'cut_point', 'attachment'])
+            counts[k] += entry.lost[k];
+        messages.push(entry.message);
+    }
+    const created = iso(sorted.map(createdOf).find((t) => typeof t === 'number' && Number.isFinite(t))) ?? '';
+    const users = messages.filter((m) => m.role === 'user' && m.kind === 'turn');
+    const log = {
+        ...SHELL,
+        session_id: sessionId,
+        created_at: created,
+        restore_grade: counts.tool_input + counts.cut_point + counts.attachment > 0 ? 'partial' : 'converted',
+        grade_counts: counts,
+        harness: { current: 'opencode', history: [] },
+        selection: { agent: users.at(-1)?.agent ?? null, model: users.at(-1)?.model ?? null },
+        threads: [{
+                schema: SESSION_LOG_SCHEMA, v: SESSION_LOG_MINOR, thread_id: runtimeSessionId, parent_thread_id: null, spawned_by: null,
+                agent: users[0]?.agent ?? null, title: null, created_at: messages[0]?.created_at || created, messages,
+                ext: { opencode: { version: BEEUNI_TRANSCRIPT_SCHEMA, native_id: runtimeSessionId } },
+            }],
+    };
+    views.set(rows, { sessionId, native: runtimeSessionId, log });
+    return log;
+}

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

@@ -0,0 +1,31 @@
+import type { BeeuniFilePart, BeeuniMessageInfo, BeeuniPart } from '../runtime/transcript-types.js';
+import { type SessionLog } from './types.js';
+export type V1Row = {
+    runtime_session_id: string | null;
+    info: BeeuniMessageInfo;
+    parts: BeeuniPart[];
+};
+export type V1Transcript = {
+    session_id: string;
+    root_id: string | null;
+    rows: V1Row[];
+};
+export type V1Attachment = {
+    ref: string;
+    bytes: number;
+    sha256?: string;
+};
+export type FromV1Options = {
+    harness?: 'opencode' | 'pi';
+    resolveAttachment?: (part: BeeuniFilePart) => V1Attachment | null;
+    live?: boolean;
+};
+export type V1Change = {
+    set: unknown;
+} | {
+    del: true;
+} | {
+    sub: Record<string, V1Change>;
+};
+export declare function toV1(input: SessionLog): V1Transcript;
+export declare function fromV1(v1: V1Transcript, options?: FromV1Options): SessionLog;