@beeuni/sdk 0.1.0 → 0.3.0

package/dist/core/rest/projects-client/sessions.js

@@ -2,6 +2,8 @@ import { ApiError, backendApi } from '../../http/api-client.js';
 import { markSessionFresh } from '../../http/fresh-sessions.js';
 import { currentSavedCopyStore } from '../../session-sync/saved-copy-store.js';
 import { noteSessionStopped } from '../../http/session-stopped.js';
+import { isSessionLogPage } from '../../session-log/guard.js';
+import { loadSessionLogPage } from '../../session-log/source.js';
 import { unwrap } from './shared.js';
 export function sessionParentId(session) {
     const parent = typeof session.parent_session_id === 'string'
@@ -34,6 +36,8 @@ function projectSessionListQuery(options) {
         params.set('q', q);
     for (const label of options?.labels ?? [])
         params.append('label', label);
+    if (options?.view)
+        params.set(options.view, 'only');
     return params.size > 0 ? `?${params}` : '';
 }
 export async function listProjectSessionsPage(projectId, options) {
@@ -63,6 +67,12 @@ export async function setSessionWatch(projectId, sessionId, watching) {
         watching,
     }));
 }
+export async function setSessionPinned(projectId, sessionId, pinned) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/sessions/${sessionId}/pin`, { pinned }));
+}
+export async function setSessionArchived(projectId, sessionId, archived) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/sessions/${sessionId}/archive`, { archived }));
+}
 export function resolvePublicShareUrl(share, origin) {
     const raw = share.public_url ?? share.public_path ?? share.proxy_path ?? share.public_token ?? '';
     if (!raw)
@@ -165,8 +175,22 @@ export async function getSessionTranscriptSync(projectId, sessionId, options) {
         search.set('child', options.child);
     return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/transcript?${search.toString()}`, { showErrors: false, signal: options?.signal }));
 }
-export async function getSessionTurn(projectId, sessionId) {
-    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/turn`));
+export async function getSessionLogPage(projectId, sessionId, query = {}, options) {
+    let page;
+    try {
+        page = await loadSessionLogPage(projectId, sessionId, query, options?.signal);
+    }
+    catch (error) {
+        if (error?.status === 404)
+            return null;
+        throw error;
+    }
+    if (!isSessionLogPage(page))
+        throw new Error('The response is not a session log page');
+    return page;
+}
+export async function getSessionTurn(projectId, sessionId, options) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/sessions/${sessionId}/turn`, options?.showErrors === false ? { showErrors: false } : undefined));
 }
 export async function getSessionOpenBundle(projectId, sessionId, options) {
     const search = new URLSearchParams();
@@ -222,8 +246,14 @@ export async function deleteProjectSession(projectId, sessionId) {
     void currentSavedCopyStore()?.remove(projectId, sessionId);
     return result;
 }
-export async function restartProjectSession(projectId, sessionId, opts = {}) {
-    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/restart`, opts.reset_machine ? { reset_machine: true, ...(opts.discard_state ? { discard_state: true } : {}) } : {}));
+export async function recoverProjectSession(projectId, sessionId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/recover`, {}, { showErrors: false }));
+}
+export async function restoreProjectSession(projectId, sessionId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/restore`, {}, { showErrors: false }));
+}
+export async function restartProjectSession(projectId, sessionId, _opts = {}) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/restart`, {}));
 }
 export async function stopProjectSession(projectId, sessionId) {
     const stopped = unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/stop`, {}));

package/dist/core/runtime/runtime-rest-client.js

@@ -158,7 +158,7 @@ export function fetchEventTransport(fetchFn = globalThis.fetch) {
         const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
         const cancel = () => {
             try {
-                void reader.cancel();
+                reader.cancel().catch(() => { });
             }
             catch {
             }

package/dist/core/runtime/runtime-types.d.ts

@@ -599,6 +599,7 @@ export type Command = {
     template: string;
     subtask?: boolean;
     hints: Array<string>;
+    agents?: Array<string>;
 };
 export type Agent = {
     name: string;

package/dist/core/session/control-stream.d.ts

@@ -25,6 +25,7 @@ export interface SessionControlStreamOptions {
     projectId: string;
     sessionId: string;
     runtime?: boolean;
+    schema?: 'v2';
     tabId?: string;
     onQueue?: (queue: SessionControlQueue) => void;
     onControl?: (frame: SessionControlFrame) => void;

package/dist/core/session/control-stream.js

@@ -16,6 +16,8 @@ export function openSessionStream(options) {
             lastHealth: null,
             runtimeRefs: 0,
             connectedWithRuntime: false,
+            logRefs: 0,
+            connectedWithLog: false,
             tabId: null,
             authoritative: false,
             reconnectNow: false,
@@ -33,6 +35,10 @@ export function openSessionStream(options) {
         if (!target.connectedWithRuntime)
             reconnect = true;
     }
+    if (options.schema === 'v2')
+        target.logRefs += 1;
+    if (target.runtimeRefs > 0 && target.logRefs > 0 && !target.connectedWithLog)
+        reconnect = true;
     if (options.tabId && target.tabId !== options.tabId) {
         target.tabId = options.tabId;
         reconnect = true;
@@ -66,8 +72,15 @@ export function openSessionStream(options) {
             target.subscribers.delete(options);
             if (options.runtime)
                 target.runtimeRefs -= 1;
-            if (target.subscribers.size > 0)
+            if (options.schema === 'v2')
+                target.logRefs -= 1;
+            if (target.subscribers.size > 0) {
+                if (target.connectedWithLog && (target.logRefs === 0 || target.runtimeRefs === 0) && target.attempt) {
+                    target.reconnectNow = true;
+                    target.attempt.abort();
+                }
                 return;
+            }
             target.abort.abort();
             if (streams.get(key) === target)
                 streams.delete(key);
@@ -132,10 +145,14 @@ async function run(options, shared) {
         arm();
         const withRuntime = shared.runtimeRefs > 0;
         shared.connectedWithRuntime = withRuntime;
+        const withLog = withRuntime && shared.logRefs > 0;
+        shared.connectedWithLog = withLog;
         try {
             const url = new URL(`${platformConfig().backendUrl.replace(/\/$/, '')}/projects/${encodeURIComponent(options.projectId)}/sessions/${encodeURIComponent(options.sessionId)}/events`);
             if (!withRuntime)
                 url.searchParams.set('channels', 'control');
+            if (withLog)
+                url.searchParams.set('schema', 'v2');
             if (shared.tabId)
                 url.searchParams.set('tab_id', shared.tabId);
             if (withRuntime && seq !== null && epoch) {

package/dist/core/session/open-bundle.d.ts

@@ -1,7 +1,9 @@
 import { type SessionAudit, type SessionOpenBundle, type SessionPrompt, type SessionTranscriptSyncEnvelope, type SessionTurn, type SessionTurnEnded, type SessionTurnFailure } from '../rest/projects-client/sessions.js';
 export declare const OPEN_BUNDLE_SHARE_MS = 5000;
-export declare const OPEN_BUNDLE_TRANSCRIPT_TTL_MS = 60000;
 export declare const OPEN_BUNDLE_TRANSCRIPT_LIMIT = 40;
+export declare const SAVED_WINDOW_HOLD_MS: number;
+export declare function holdSavedWindow(projectId: string, sessionId: string, envelope: SessionTranscriptSyncEnvelope, nowMs?: number): void;
+export declare function heldSavedWindow(projectId: string, sessionId: string, nowMs?: number): SessionTranscriptSyncEnvelope | null;
 export declare function resetSessionOpenBundles(): void;
 export interface OpenSessionBundleOptions {
     transcript?: number;
@@ -9,16 +11,14 @@ export interface OpenSessionBundleOptions {
 }
 export declare function openSessionBundle(projectId: string, sessionId: string, options?: OpenSessionBundleOptions): void;
 export declare function claimOpenBundle(projectId: string, sessionId: string, nowMs?: number): Promise<SessionOpenBundle | null> | null;
-export declare function settledOpenBundle(projectId: string, sessionId: string, nowMs?: number): SessionOpenBundle | null;
 export interface OpenBundleTurnObservation {
     turns: SessionTurn[];
     last_ended: SessionTurnEnded | undefined;
     recent_failures?: SessionTurnFailure[];
+    can_stop?: boolean;
     atMs: number;
 }
 export declare function openBundleTurn(bundle: SessionOpenBundle): OpenBundleTurnObservation | null;
 export declare function openBundleQueue(bundle: SessionOpenBundle): SessionPrompt[] | null;
 export declare function openBundleAudit(bundle: SessionOpenBundle): SessionAudit | null;
 export declare function openBundleHistory(bundle: SessionOpenBundle): SessionTranscriptSyncEnvelope | null;
-export declare function takeOpenBundleTranscriptAbsence(projectId: string, sessionId: string, nowMs?: number): boolean;
-export declare function takeOpenBundleTranscript(projectId: string, sessionId: string, nowMs?: number): SessionTranscriptSyncEnvelope | null;

package/dist/core/session/open-bundle.js

@@ -1,17 +1,37 @@
 import { getSessionOpenBundle, } from '../rest/projects-client/sessions.js';
 export const OPEN_BUNDLE_SHARE_MS = 5_000;
-export const OPEN_BUNDLE_TRANSCRIPT_TTL_MS = 60_000;
 export const OPEN_BUNDLE_TRANSCRIPT_LIMIT = 40;
+export const SAVED_WINDOW_HOLD_MS = 5 * 60_000;
+const HELD_WINDOW_CAP = 16;
+const heldWindows = new Map();
+export function holdSavedWindow(projectId, sessionId, envelope, nowMs = Date.now()) {
+    const key = scopeKey(projectId, sessionId);
+    heldWindows.delete(key);
+    heldWindows.set(key, { envelope, atMs: nowMs });
+    while (heldWindows.size > HELD_WINDOW_CAP) {
+        const oldest = heldWindows.keys().next().value;
+        if (oldest === undefined)
+            break;
+        heldWindows.delete(oldest);
+    }
+}
+export function heldSavedWindow(projectId, sessionId, nowMs = Date.now()) {
+    const held = heldWindows.get(scopeKey(projectId, sessionId));
+    if (!held)
+        return null;
+    if (nowMs - held.atMs > SAVED_WINDOW_HOLD_MS) {
+        heldWindows.delete(scopeKey(projectId, sessionId));
+        return null;
+    }
+    return held.envelope;
+}
 const entries = new Map();
-const transcripts = new Map();
-const absentTranscripts = new Map();
 function scopeKey(projectId, sessionId) {
     return `${projectId}/${sessionId}`;
 }
 export function resetSessionOpenBundles() {
     entries.clear();
-    transcripts.clear();
-    absentTranscripts.clear();
+    heldWindows.clear();
 }
 export function openSessionBundle(projectId, sessionId, options = {}) {
     if (!projectId || !sessionId)
@@ -26,17 +46,12 @@ export function openSessionBundle(projectId, sessionId, options = {}) {
         startedAtMs: nowMs,
         settledAtMs: null,
         promise: getSessionOpenBundle(projectId, sessionId, {
-            transcript: options.transcript ?? OPEN_BUNDLE_TRANSCRIPT_LIMIT,
-        })
-            .then((bundle) => {
-            stashTranscript(key, bundle, now());
-            return bundle;
-        })
-            .catch(() => null),
+            transcript: options.transcript ??
+                (heldSavedWindow(projectId, sessionId, nowMs) ? 0 : OPEN_BUNDLE_TRANSCRIPT_LIMIT),
+        }).catch(() => null),
     };
     entry.promise = entry.promise.then((bundle) => {
         entry.settledAtMs = now();
-        entry.bundle = bundle;
         return bundle;
     });
     entries.set(key, entry);
@@ -59,10 +74,6 @@ export function claimOpenBundle(projectId, sessionId, nowMs = Date.now()) {
     }
     return entry.promise;
 }
-export function settledOpenBundle(projectId, sessionId, nowMs = Date.now()) {
-    const entry = entries.get(scopeKey(projectId, sessionId));
-    return entry && entry.settledAtMs !== null && claimable(entry, nowMs) ? (entry.bundle ?? null) : null;
-}
 export function openBundleTurn(bundle) {
     const turn = bundle.turn;
     if (!turn || turn.known !== true)
@@ -72,6 +83,7 @@ export function openBundleTurn(bundle) {
         turns: turn.turns ?? [],
         last_ended: turn.last_ended,
         recent_failures: turn.recent_failures,
+        ...(typeof turn.can_stop === 'boolean' ? { can_stop: turn.can_stop } : {}),
         atMs: Number.isFinite(observedAtMs) ? observedAtMs : Date.now(),
     };
 }
@@ -104,32 +116,3 @@ export function openBundleHistory(bundle) {
     const savedRoot = envelope.runtime_session_id ?? envelope.opencode_session_id;
     return root && savedRoot === root ? envelope : null;
 }
-function stashTranscript(key, bundle, nowMs) {
-    const transcript = bundle.transcript;
-    if (!transcript || transcript.known !== true || transcript.requested !== true)
-        return;
-    if (!transcript.available || transcript.messages.length === 0) {
-        absentTranscripts.set(key, nowMs);
-        return;
-    }
-    const { known: _known, requested: _requested, ...envelope } = transcript;
-    transcripts.set(key, { envelope, stashedAtMs: nowMs });
-}
-export function takeOpenBundleTranscriptAbsence(projectId, sessionId, nowMs = Date.now()) {
-    const key = scopeKey(projectId, sessionId);
-    const answeredAtMs = absentTranscripts.get(key);
-    if (answeredAtMs === undefined)
-        return false;
-    absentTranscripts.delete(key);
-    return nowMs - answeredAtMs <= OPEN_BUNDLE_TRANSCRIPT_TTL_MS;
-}
-export function takeOpenBundleTranscript(projectId, sessionId, nowMs = Date.now()) {
-    const key = scopeKey(projectId, sessionId);
-    const stash = transcripts.get(key);
-    if (!stash)
-        return null;
-    transcripts.delete(key);
-    if (nowMs - stash.stashedAtMs > OPEN_BUNDLE_TRANSCRIPT_TTL_MS)
-        return null;
-    return stash.envelope;
-}

package/dist/core/session/turn-end-watch.d.ts

@@ -0,0 +1,47 @@
+import type { SessionTurnEndError, SessionTurnStatus } from '../rest/projects-client/sessions.js';
+export declare const TURN_END_WATCH_FIRST_READ_MS = 1000;
+export declare const TURN_END_WATCH_POLL_MS = 5000;
+export declare const TURN_END_WATCH_LONG_TURN_MS: number;
+export declare const TURN_END_WATCH_SLOW_POLL_MS = 15000;
+export declare const TURN_END_WATCH_START_MS = 60000;
+export declare const TURN_END_WATCH_MAX_MS: number;
+export interface TurnEndHandoff {
+    projectId: string;
+    sessionId: string;
+    openTurnToken: string | null;
+    lastEndedToken: string | null;
+    title?: () => string | undefined;
+}
+export type TurnEndOutcome = {
+    kind: 'completed';
+} | {
+    kind: 'failed';
+    error: SessionTurnEndError | null;
+} | {
+    kind: 'stopped';
+};
+export type TurnEndVerdict = {
+    state: 'running';
+} | {
+    state: 'waiting';
+} | {
+    state: 'ended';
+    outcome: TurnEndOutcome;
+};
+export declare function readTurnEnd(handoff: TurnEndHandoff, read: SessionTurnStatus, sawOpen: boolean): TurnEndVerdict;
+export interface TurnEndWatchDeps {
+    readTurn(projectId: string, sessionId: string): Promise<SessionTurnStatus>;
+    subscribe?(projectId: string, sessionId: string, onRead: (read: SessionTurnStatus) => void): () => void;
+    pushLive?(projectId: string, sessionId: string): boolean;
+    onEnded(handoff: TurnEndHandoff, outcome: TurnEndOutcome, watchedSinceMs: number): void;
+    now?: () => number;
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    clearTimer?: (handle: unknown) => void;
+}
+export interface TurnEndWatch {
+    watch(handoff: TurnEndHandoff): void;
+    release(projectId: string, sessionId: string): void;
+    releaseAll(): void;
+    watching(): string[];
+}
+export declare function createTurnEndWatch(deps: TurnEndWatchDeps): TurnEndWatch;

package/dist/core/session/turn-end-watch.js

@@ -0,0 +1,141 @@
+import { isAbortError } from '../http/abort-error.js';
+export const TURN_END_WATCH_FIRST_READ_MS = 1_000;
+export const TURN_END_WATCH_POLL_MS = 5_000;
+export const TURN_END_WATCH_LONG_TURN_MS = 5 * 60_000;
+export const TURN_END_WATCH_SLOW_POLL_MS = 15_000;
+export const TURN_END_WATCH_START_MS = 60_000;
+export const TURN_END_WATCH_MAX_MS = 12 * 60 * 60_000;
+function outcomeOf(read) {
+    const ended = read.last_ended;
+    if (!ended)
+        return { kind: 'completed' };
+    const reason = ended.end_reason;
+    if (reason === 'completed' || reason === 'unknown' || reason === null)
+        return { kind: 'completed' };
+    const error = ended.error;
+    if (error) {
+        if (isAbortError({ name: error.name ?? undefined, message: error.message ?? undefined })) {
+            return { kind: 'stopped' };
+        }
+        return { kind: 'failed', error };
+    }
+    if (reason === 'failed') {
+        const listed = read.recent_failures?.some((failure) => !!ended.message_id && failure.message_id === ended.message_id);
+        if (!listed)
+            return { kind: 'stopped' };
+    }
+    return { kind: 'failed', error: null };
+}
+export function readTurnEnd(handoff, read, sawOpen) {
+    if (read.turns.length > 0)
+        return { state: 'running' };
+    const lastEndedToken = read.last_ended?.turn_token ?? null;
+    const endedSinceHandoff = handoff.openTurnToken !== null ||
+        sawOpen ||
+        (lastEndedToken !== null && lastEndedToken !== handoff.lastEndedToken);
+    if (!endedSinceHandoff)
+        return { state: 'waiting' };
+    return { state: 'ended', outcome: outcomeOf(read) };
+}
+function isFinalReadError(error) {
+    const status = error?.status;
+    return status === 401 || status === 403 || status === 404;
+}
+export function createTurnEndWatch(deps) {
+    const now = deps.now ?? Date.now;
+    const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    const clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
+    const entries = new Map();
+    const keyOf = (projectId, sessionId) => `${projectId}/${sessionId}`;
+    function drop(key, entry) {
+        if (entries.get(key) !== entry)
+            return;
+        entry.dropped = true;
+        clearTimer(entry.timer);
+        entry.unsubscribe?.();
+        entries.delete(key);
+    }
+    function schedule(key, entry, ms) {
+        entry.timer = setTimer(() => void tick(key, entry), ms);
+    }
+    function evaluate(key, entry, read) {
+        if (entries.get(key) !== entry)
+            return;
+        const verdict = readTurnEnd(entry.handoff, read, entry.sawOpen);
+        if (verdict.state === 'ended') {
+            drop(key, entry);
+            deps.onEnded(entry.handoff, verdict.outcome, entry.sinceMs);
+            return;
+        }
+        if (verdict.state === 'running')
+            entry.sawOpen = true;
+        entry.lastState = verdict.state;
+    }
+    async function tick(key, entry) {
+        if (entries.get(key) !== entry)
+            return;
+        const { projectId, sessionId } = entry.handoff;
+        if (!deps.pushLive?.(projectId, sessionId)) {
+            try {
+                const read = await deps.readTurn(projectId, sessionId);
+                evaluate(key, entry, read);
+            }
+            catch (error) {
+                if (entries.get(key) !== entry)
+                    return;
+                if (isFinalReadError(error)) {
+                    drop(key, entry);
+                    return;
+                }
+            }
+        }
+        if (entries.get(key) !== entry)
+            return;
+        const age = now() - entry.sinceMs;
+        const waitingTooLong = entry.lastState === 'waiting' && !entry.sawOpen && age >= TURN_END_WATCH_START_MS;
+        if (waitingTooLong || age >= TURN_END_WATCH_MAX_MS) {
+            drop(key, entry);
+            return;
+        }
+        schedule(key, entry, age >= TURN_END_WATCH_LONG_TURN_MS ? TURN_END_WATCH_SLOW_POLL_MS : TURN_END_WATCH_POLL_MS);
+    }
+    return {
+        watch(handoff) {
+            if (!handoff.projectId || !handoff.sessionId)
+                return;
+            const key = keyOf(handoff.projectId, handoff.sessionId);
+            const previous = entries.get(key);
+            if (previous)
+                drop(key, previous);
+            const entry = {
+                handoff,
+                sinceMs: now(),
+                sawOpen: false,
+                lastState: null,
+                timer: null,
+                unsubscribe: null,
+                dropped: false,
+            };
+            entries.set(key, entry);
+            schedule(key, entry, TURN_END_WATCH_FIRST_READ_MS);
+            const unsubscribe = deps.subscribe?.(handoff.projectId, handoff.sessionId, (read) => evaluate(key, entry, read));
+            if (entry.dropped)
+                unsubscribe?.();
+            else
+                entry.unsubscribe = unsubscribe ?? null;
+        },
+        release(projectId, sessionId) {
+            const key = keyOf(projectId, sessionId);
+            const entry = entries.get(key);
+            if (entry)
+                drop(key, entry);
+        },
+        releaseAll() {
+            for (const [key, entry] of [...entries])
+                drop(key, entry);
+        },
+        watching() {
+            return [...entries.keys()];
+        },
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { SessionLogPage } from './source.js';
+import type { SessionLogThreadHead } from './store.js';
+import { type SessionLogMessage } from './types.js';
+export declare function isSessionLogMessage(v: unknown): v is SessionLogMessage;
+export declare function isSessionLogThreadHead(v: unknown): v is SessionLogThreadHead;
+export declare function isSessionLogPage(v: unknown): v is SessionLogPage;

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

@@ -0,0 +1,109 @@
+import { SESSION_LOG_SCHEMA } from './types.js';
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isStr = (v) => typeof v === 'string';
+const isId = (v) => isStr(v) && v.length > 0;
+const isStrOrNull = (v) => v === null || isStr(v);
+const isOptional = (v, check) => v === undefined || check(v);
+const oneOf = (...values) => (v) => values.includes(v);
+const isCount = (v) => Number.isInteger(v) && v >= 0;
+const isNum = (v) => typeof v === 'number';
+const isSchemaRef = (v) => v.schema === SESSION_LOG_SCHEMA && isCount(v.v);
+const isOptStr = (v) => isOptional(v, isStr);
+const isExt = (v) => v === undefined || (isObj(v) && Object.values(v).every((e) => isObj(e) && isStr(e.version)));
+const isModel = (v) => v === null || (isObj(v) && isStr(v.provider) && isStr(v.model) && isOptStr(v.variant));
+const isUsage = (v) => v === null ||
+    (isObj(v) && isNum(v.input) && isNum(v.output) && isNum(v.cache_read) && isNum(v.cache_write) && isOptional(v.reasoning, isNum) && isOptional(v.cost, isNum));
+const isResultContent = (c) => isObj(c) && ((c.type === 'text' && isStr(c.text)) || (c.type === 'attachment' && isStr(c.mime)));
+const isToolResult = (r) => isObj(r) && Array.isArray(r.content) && r.content.every(isResultContent) && isOptional(r.model_content, (m) => Array.isArray(m) && m.every(isResultContent)) && typeof r.is_error === 'boolean';
+const BLOCK = {
+    text: (b) => isStr(b.text) && isOptional(b.bytes, isCount) && isOptStr(b.ref) && (b.ref === undefined || b.bytes !== undefined),
+    reasoning: (b) => isStr(b.text),
+    attachment: (b) => isStr(b.mime) && isOptStr(b.ref) && isOptional(b.bytes, isCount) && (b.ref === undefined) === (b.bytes === undefined),
+    tool_call: (b) => isStr(b.call_id) &&
+        isStr(b.name) &&
+        isId(b.kind) &&
+        oneOf('pending', 'running', 'complete', 'error')(b.status) &&
+        isOptional(b.result, isToolResult),
+    compaction: (b) => isStrOrNull(b.summary) && isStrOrNull(b.first_kept_message_id),
+    subtask: (b) => isStr(b.thread_id) && isStr(b.agent) && isStr(b.description),
+    step: (b) => oneOf('start', 'finish')(b.phase),
+    harness: (b) => isId(b.harness) && isId(b.kind) && typeof b.model_visible === 'boolean',
+};
+function isBlocks(blocks, atRestInContext) {
+    if (!Array.isArray(blocks))
+        return false;
+    const seen = new Set();
+    for (const b of blocks) {
+        if (!isObj(b) || !isId(b.id) || seen.has(b.id) || !Object.hasOwn(BLOCK, b.type))
+            return false;
+        if (!BLOCK[b.type](b) || !isExt(b.ext))
+            return false;
+        if (atRestInContext && b.type === 'tool_call' && (b.status === 'pending' || b.status === 'running' || !b.result))
+            return false;
+        seen.add(b.id);
+    }
+    return true;
+}
+export function isSessionLogMessage(v) {
+    return (isObj(v) &&
+        isSchemaRef(v) &&
+        isId(v.message_id) &&
+        isId(v.thread_id) &&
+        Number.isInteger(v.seq) &&
+        oneOf('user', 'assistant', 'system')(v.role) &&
+        oneOf('turn', 'compaction', 'context')(v.kind) &&
+        oneOf('streaming', 'complete', 'error', 'aborted', 'interrupted')(v.status) &&
+        typeof v.in_context === 'boolean' &&
+        isOptional(v.hidden_reason, oneOf('failed_attempt', 'aborted', 'retracted', 'reverted', 'superseded')) &&
+        isOptional(v.origin, oneOf('prompt', 'steer', 'command', 'automation', 'subagent', 'notification')) &&
+        isOptional(v.agent, isStrOrNull) &&
+        isOptional(v.reply_to, isStrOrNull) &&
+        isOptional(v.parent_message_id, isStrOrNull) &&
+        isOptStr(v.native_agent_id) &&
+        isOptStr(v.context_ref) &&
+        isModel(v.model) &&
+        isUsage(v.usage) &&
+        oneOf('stop', 'tool_calls', 'length', 'error', 'aborted', null)(v.finish) &&
+        (v.error === null || (isObj(v.error) && isId(v.error.code) && isStr(v.error.message))) &&
+        isStr(v.created_at) &&
+        isStrOrNull(v.completed_at) &&
+        isObj(v.producer) &&
+        isId(v.producer.harness) &&
+        isStr(v.producer.harness_version) &&
+        isStr(v.producer.adapter_version) &&
+        isExt(v.ext) &&
+        isBlocks(v.blocks, v.status !== 'streaming' && v.in_context === true));
+}
+export function isSessionLogThreadHead(v) {
+    return (isObj(v) &&
+        isSchemaRef(v) &&
+        isId(v.thread_id) &&
+        isStrOrNull(v.parent_thread_id) &&
+        (v.spawned_by === null || isObj(v.spawned_by)) &&
+        isStr(v.created_at));
+}
+function isSessionPatch(v) {
+    return (isObj(v) &&
+        isOptional(v.schema, (x) => x === SESSION_LOG_SCHEMA) &&
+        isOptional(v.v, isCount) &&
+        isOptStr(v.session_id) &&
+        isOptional(v.title, isStrOrNull) &&
+        isOptStr(v.created_at) &&
+        isOptional(v.restore_grade, oneOf('native', 'converted', 'partial')) &&
+        isOptional(v.todos, Array.isArray) &&
+        isOptional(v.pending, (p) => isObj(p) && Array.isArray(p.questions) && Array.isArray(p.permissions)) &&
+        isOptional(v.selection, (x) => isObj(x) && isOptional(x.agent, isStrOrNull) && isModel(x.model ?? null)) &&
+        isOptional(v.harness, (x) => isObj(x) && isStr(x.current) && Array.isArray(x.history)) &&
+        isExt(v.ext));
+}
+export function isSessionLogPage(v) {
+    return (isObj(v) &&
+        isCount(v.generation) &&
+        typeof v.has_more === 'boolean' &&
+        isSessionPatch(v.session) &&
+        Array.isArray(v.threads) &&
+        v.threads.every(isSessionLogThreadHead) &&
+        (v.thread_id === null || isId(v.thread_id)) &&
+        Array.isArray(v.messages) &&
+        v.messages.every((m) => isSessionLogMessage(m) && m.thread_id === v.thread_id));
+}

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

@@ -0,0 +1,7 @@
+export { KNOWN_TOOL_KINDS, SESSION_LOG_MINOR, SESSION_LOG_SCHEMA, type AttachmentBlock, type CompactionBlock, type CompactionLayoutEntry, type GradeCounts, type HarnessBlock, type KnownToolKind, type ModelRef, type ReasoningBlock, type RestoreGrade, type SessionLog, type SessionLogBlock, type SessionLogMessage, type SessionLogThread, type StepBlock, type SubtaskBlock, type TextBlock, type ThreadInteraction, type ToolCallBlock, type ToolResultContent, } from './types.js';
+export type { Todo as SessionLogTodo, ToolKind as SessionLogToolKind } from './types.js';
+export type { SessionLogPage, SessionLogPageQuery } from './source.js';
+export { toolCallBlock, toolCallMetadata } from './tool-call.js';
+export { toolCallError, toolCallRawOutput, toolCallStatus } from './tool-call.js';
+export { sessionLogOfV1Rows } from './v1-view.js';
+export * from './turns/index.js';

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

@@ -0,0 +1,5 @@
+export { KNOWN_TOOL_KINDS, SESSION_LOG_MINOR, SESSION_LOG_SCHEMA, } from './types.js';
+export { toolCallBlock, toolCallMetadata } from './tool-call.js';
+export { toolCallError, toolCallRawOutput, toolCallStatus } from './tool-call.js';
+export { sessionLogOfV1Rows } from './v1-view.js';
+export * from './turns/index.js';

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

@@ -0,0 +1,10 @@
+import type { CopyCodec, CopyStore } from '../session-sync/copy-store-types.js';
+import type { SavedCopyStore } from '../session-sync/saved-copy-store.js';
+import type { SessionLogPage } from './source.js';
+export declare const SESSION_LOG_COPY: CopyCodec<SessionLogPage>;
+export interface SessionLogCopies {
+    read(projectId: string, sessionId: string): SessionLogPage | null | Promise<SessionLogPage | null>;
+    write(projectId: string, sessionId: string, page: SessionLogPage): Promise<void>;
+}
+export declare function registerSessionLogCopies(store: SavedCopyStore, v2: CopyStore<SessionLogPage>, removeV1: (projectId: string, sessionId: string) => Promise<void>): void;
+export declare function savedSessionLogCopies(store: SavedCopyStore | null | undefined): SessionLogCopies | null;

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

@@ -0,0 +1,25 @@
+import { isSessionLogPage } from './guard.js';
+const paintable = (page) => isSessionLogPage(page) && page.messages.length > 0;
+function fit(stored, maxChars) {
+    const { messages } = stored.e;
+    for (let from = 0; from < messages.length; from++) {
+        const text = JSON.stringify(from === 0 ? stored : { ...stored, e: { ...stored.e, messages: messages.slice(from), has_more: true } });
+        if (text.length <= maxChars)
+            return text;
+    }
+    return null;
+}
+export const SESSION_LOG_COPY = { paintable, fit, capturedAt: () => 0 };
+const copies = new WeakMap();
+export function registerSessionLogCopies(store, v2, removeV1) {
+    copies.set(store, {
+        read: (projectId, sessionId) => v2.read(projectId, sessionId),
+        write: async (projectId, sessionId, page) => {
+            await v2.write(projectId, sessionId, page);
+            await removeV1(projectId, sessionId);
+        },
+    });
+}
+export function savedSessionLogCopies(store) {
+    return (store && copies.get(store)) ?? null;
+}