@beeuni/sdk 0.1.0 → 0.2.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,6 @@
+import type { ToolPart } from '../runtime/runtime-types.js';
+import { type ToolCallBlock } from './types.js';
+export declare function toolCallBlock(part: ToolPart): ToolCallBlock;
+export declare function toolPartOf(call: ToolCallBlock): ToolPart;
+export declare const isToolCallBlock: (value: unknown) => value is ToolCallBlock;
+export declare function toolCallMetadata(call: ToolCallBlock): Record<string, unknown>;

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

@@ -0,0 +1,46 @@
+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 toolPartOf(call) {
+    const cached = parts.get(call);
+    if (cached)
+        return cached;
+    const thread = {
+        ...V, thread_id: '', parent_thread_id: null, spawned_by: null, agent: null, title: null, created_at: '',
+        ext: { opencode: { version: BEEUNI_TRANSCRIPT_SCHEMA } },
+        messages: [{
+                ...V, message_id: '', thread_id: '', seq: 1, role: 'assistant', kind: 'turn', status: 'complete', in_context: true,
+                model: null, usage: null, finish: null, error: null, created_at: '', completed_at: null,
+                producer: { harness: '', harness_version: '', adapter_version: '' }, blocks: [call],
+            }],
+    };
+    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(call, part);
+    return part;
+}
+export const isToolCallBlock = (value) => typeof value === 'object' && value !== null && value.type === 'tool_call';
+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;
+}

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',
+];

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

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