@beeuni/sdk 0.1.0 → 0.3.0

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;
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,264 @@
+export declare const SESSION_LOG_SCHEMA: "beeuni.session/2";
+export declare const SESSION_LOG_MINOR = 1;
+export type SchemaRef = {
+    schema: typeof SESSION_LOG_SCHEMA;
+    v: number;
+};
+export type Ext = Record<string, {
+    version: string;
+    native_id?: string;
+    data?: unknown;
+}>;
+export type Producer = {
+    harness: string;
+    harness_version: string;
+    adapter_version: string;
+};
+export type ModelRef = {
+    provider: string;
+    model: string;
+    api?: 'anthropic-messages' | 'openai-chat' | 'openai-responses' | (string & {});
+    variant?: string;
+    reasoning_effort?: string;
+};
+export type Todo = {
+    id?: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+    priority?: 'high' | 'medium' | 'low';
+};
+export type Pending = {
+    id: string;
+    thread_id: string;
+    call_id?: string;
+    payload: unknown;
+    asked_at: string;
+};
+export type RestoreGrade = 'native' | 'converted' | 'partial';
+export type GradeCounts = {
+    tool_input: number;
+    cut_point: number;
+    attachment: number;
+};
+export type SessionLog = SchemaRef & {
+    session_id: string;
+    title: string | null;
+    created_at: string;
+    restore_grade: RestoreGrade;
+    grade_counts?: GradeCounts;
+    harness: {
+        current: string;
+        history: Array<{
+            harness: string;
+            version: string;
+            from_seq: number;
+            at: string;
+        }>;
+    };
+    selection: {
+        agent: string | null;
+        model: ModelRef | null;
+    };
+    todos: Todo[];
+    pending: {
+        questions: Pending[];
+        permissions: Pending[];
+    };
+    threads: SessionLogThread[];
+    ext?: Ext;
+};
+export type ThreadInteraction = {
+    message_id: string;
+    call_id: string;
+    op: 'spawn' | 'send' | 'wait' | 'close' | 'resume' | 'result';
+};
+export type SessionLogThread = SchemaRef & {
+    thread_id: string;
+    parent_thread_id: string | null;
+    spawned_by: {
+        message_id: string;
+        call_id: string;
+    } | null;
+    interactions?: ThreadInteraction[];
+    agent: string | null;
+    native_agent_id?: string;
+    nickname?: string | null;
+    title: string | null;
+    created_at: string;
+    messages: SessionLogMessage[];
+    ext?: Ext;
+};
+export type Role = 'user' | 'assistant' | 'system';
+export type SessionLogMessage = SchemaRef & {
+    message_id: string;
+    thread_id: string;
+    seq: number;
+    role: Role;
+    kind: 'turn' | 'compaction' | 'context';
+    status: 'streaming' | 'complete' | 'error' | 'aborted' | 'interrupted';
+    in_context: boolean;
+    hidden_reason?: 'failed_attempt' | 'aborted' | 'retracted' | 'reverted' | 'superseded';
+    origin?: 'prompt' | 'steer' | 'command' | 'automation' | 'subagent' | 'notification';
+    agent?: string | null;
+    native_agent_id?: string;
+    reply_to?: string | null;
+    parent_message_id?: string | null;
+    model: ModelRef | null;
+    usage: Usage | null;
+    finish: 'stop' | 'tool_calls' | 'length' | 'error' | 'aborted' | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+    created_at: string;
+    completed_at: string | null;
+    producer: Producer;
+    blocks: SessionLogBlock[];
+    context_ref?: string;
+    ext?: Ext;
+};
+export type Usage = {
+    input: number;
+    output: number;
+    cache_read: number;
+    cache_write: number;
+    reasoning?: number;
+    cost?: number;
+};
+export type BlockBase = {
+    id: string;
+};
+export type SessionLogBlock = TextBlock | ReasoningBlock | AttachmentBlock | ToolCallBlock | CompactionBlock | SubtaskBlock | StepBlock | HarnessBlock;
+export type TextBlock = BlockBase & {
+    type: 'text';
+    text: string;
+    model_text?: string;
+    synthetic?: boolean;
+    ref?: string;
+    bytes?: number;
+    ext?: Ext;
+};
+export type ReasoningBlock = BlockBase & {
+    type: 'reasoning';
+    text: string;
+    summary?: string[];
+    redacted?: boolean;
+    ext?: Ext;
+};
+export type AttachmentBlock = BlockBase & {
+    type: 'attachment';
+    ref?: string;
+    mime: string;
+    name?: string;
+    label?: string;
+    source_path?: string;
+    bytes?: number;
+    sha256?: string;
+    url?: string;
+    ext?: Ext;
+};
+export declare const KNOWN_TOOL_KINDS: readonly ["shell", "read", "write", "edit", "patch", "list", "glob", "grep", "web_fetch", "web_search", "todo", "task", "question", "plan", "mcp", "other"];
+export type KnownToolKind = (typeof KNOWN_TOOL_KINDS)[number];
+export type ToolKind = KnownToolKind | (string & {});
+export type ToolResultContent = {
+    type: 'text';
+    text: string;
+    ref?: string;
+    bytes?: number;
+} | {
+    type: 'attachment';
+    ref?: string;
+    mime: string;
+    sha256?: string;
+    url?: string;
+};
+export type ToolCallBlock = BlockBase & {
+    type: 'tool_call';
+    call_id: string;
+    name: string;
+    kind: ToolKind;
+    input: unknown;
+    input_format?: 'json' | 'text';
+    status: 'pending' | 'running' | 'complete' | 'error';
+    result?: {
+        content: ToolResultContent[];
+        model_content?: ToolResultContent[];
+        is_error: boolean;
+        error?: {
+            code?: string;
+            message: string;
+        };
+        exit_code?: number;
+        synthetic?: boolean;
+        cleared_at?: string;
+        details?: unknown;
+    };
+    title?: string;
+    started_at?: string;
+    ended_at?: string;
+    ext?: Ext;
+};
+export type CompactionLayoutEntry = {
+    summary: true;
+} | {
+    message_id: string;
+    text_only?: boolean;
+} | {
+    text: string;
+};
+export type CompactionBlock = BlockBase & {
+    type: 'compaction';
+    summary: string | null;
+    opaque?: boolean;
+    first_kept_message_id: string | null;
+    layout?: CompactionLayoutEntry[];
+    tokens_before?: number;
+    trigger?: 'auto' | 'manual' | 'overflow' | 'unknown';
+    ext?: Ext;
+};
+export type SubtaskBlock = BlockBase & {
+    type: 'subtask';
+    thread_id: string;
+    agent: string;
+    description: string;
+    call_id?: string;
+    call_ids?: string[];
+};
+export type StepBlock = BlockBase & {
+    type: 'step';
+    phase: 'start' | 'finish';
+    ext?: Ext;
+};
+export type HarnessBlock = BlockBase & {
+    type: 'harness';
+    harness: string;
+    kind: string;
+    data: unknown;
+    model_visible: boolean;
+    fallback_text?: string;
+};
+export type CapabilityFeatures = {
+    tool_error_channel: boolean;
+    attachments: {
+        user: string[];
+        tool_result: boolean;
+    };
+    compaction: Array<'summary_first_tail' | 'layout' | 'text_tail' | 'opaque'>;
+    subagents: 'none' | 'sync' | 'async';
+    todos: boolean;
+    reasoning_replay: 'none' | 'same_model' | 'lowers_to_text';
+    freeform_tool_input: boolean;
+};
+export type AdapterCapabilities = {
+    harness: string;
+    harness_versions: string;
+    schema_minors: number[];
+    dialects: Array<NonNullable<ModelRef['api']>>;
+    native: CapabilityFeatures;
+    rendered: CapabilityFeatures;
+};
+export type ExportCursor = {
+    thread_id: string;
+    last_seq: number;
+    native_hashes: Record<string, string>;
+};

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

@@ -0,0 +1,6 @@
+export const SESSION_LOG_SCHEMA = 'beeuni.session/2';
+export const SESSION_LOG_MINOR = 1;
+export const KNOWN_TOOL_KINDS = [
+    'shell', 'read', 'write', 'edit', 'patch', 'list', 'glob', 'grep',
+    'web_fetch', 'web_search', 'todo', 'task', 'question', 'plan', 'mcp', 'other',
+];