hyperbrane 0.1.0 → 0.1.2

package/dist/agent/session/fileTranscript.js

@@ -0,0 +1,454 @@
+import { SandboxNotFoundError } from "../../sandbox/api.js";
+import { AgentInvalidError } from "../api.js";
+export function sandboxFiles(sandbox) {
+    return {
+        size: async (path) => (await sandbox.stat(path)).size,
+        readFileRange: (path, start, end) => sandbox.readFileRange(path, start, end),
+        listDirectory: (path) => sandbox.listDirectory(path),
+    };
+}
+/** The file of conversation `nativeId` laid out as `layout` under `home`; null when there's none yet. */
+export function locateTranscript(files, home, layout, nativeId) {
+    const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const [before = "", after = ""] = layout.name.split("{id}").map((part) => part.split("*").map(escape).join(".*"));
+    const name = new RegExp(`^${before}${escape(nativeId)}${after}$`);
+    return findFile(files, `${home}/${layout.dir}`, layout.depth, (entry) => name.test(entry));
+}
+/** How much of the file is read at a time. */
+export const CHUNK_BYTES = 64 * 1024;
+/**
+ * How far out of time order lines get, nearly always (parallel branches completing; in long claude
+ * sessions half are within 2s, 99% within a minute): searches allow for this much.
+ */
+export const TIME_SLACK_MS = 60_000;
+/** How many timed lines a probe of the bisection looks at: the earliest wins, so one odd line can't mislead it. */
+export const PROBE_LINES = 3;
+/** How much a probe reads, at most, before it gives up on finding a timed line (huge tool outputs). */
+export const PROBE_BYTES = 4 * CHUNK_BYTES;
+const NEWLINE = 0x0a;
+/** A line's time (epoch ms) from its `field`, null without a valid one. */
+function lineTime(entry, field) {
+    const value = entry?.[field];
+    const time = typeof value === "string" ? Date.parse(value) : NaN;
+    return Number.isNaN(time) ? null : time;
+}
+/** How much is read at a time when searching the whole file for where stretches were written again. */
+const SCAN_BYTES = 1024 * 1024;
+/**
+ * The stretches written again in the files searched last, by path and size: a search reads the whole
+ * file, and a file the backend only appends to that hasn't grown has the same ones.
+ */
+const searchedCopies = new Map();
+const SEARCHED_FILES = 16;
+/** `locate` finds the file; null when there's none yet (nothing stored). */
+export function createFileTranscript(files, locate, lineMessages, layout) {
+    function parse(bytes, start) {
+        try {
+            const entry = JSON.parse(new TextDecoder().decode(bytes));
+            return { start, time: lineTime(entry, layout.time), messages: lineMessages(entry) };
+        }
+        catch {
+            // A line still being written (the last one), or one this reader doesn't know: nothing in it.
+            return { start, time: null, messages: [] };
+        }
+    }
+    /** The stretches between `from` and `to` that aren't skipped, in order. */
+    function kept(from, to, skip) {
+        const parts = [];
+        let start = from;
+        for (const stretch of [...skip].sort((a, b) => a.start - b.start)) {
+            if (stretch.end <= start || stretch.start >= to)
+                continue;
+            if (stretch.start > start)
+                parts.push({ start, end: stretch.start });
+            start = Math.max(start, stretch.end);
+        }
+        if (start < to)
+            parts.push({ start, end: to });
+        return parts;
+    }
+    /** The file's lines before byte `end`, last first, read a chunk at a time, passing over `skip`. */
+    async function* backward(path, end, skip = []) {
+        for (const part of kept(0, end, skip).reverse())
+            yield* backwardIn(path, part.start, part.end);
+    }
+    async function* backwardIn(path, floor, end) {
+        let position = end;
+        // Bytes of a line that runs on into what was read before (later in the file).
+        let carry = new Uint8Array(0);
+        while (position > floor) {
+            const from = Math.max(floor, position - CHUNK_BYTES);
+            const chunk = await files.readFileRange(path, from, position);
+            const bytes = joined(chunk, carry);
+            let lineEnd = bytes.length;
+            for (let index = bytes.length - 1; index >= 0; index--) {
+                if (bytes[index] !== NEWLINE)
+                    continue;
+                if (lineEnd > index + 1)
+                    yield parse(bytes.subarray(index + 1, lineEnd), from + index + 1);
+                lineEnd = index;
+            }
+            carry = bytes.slice(0, lineEnd);
+            position = from;
+        }
+        if (carry.length > 0)
+            yield parse(carry, floor);
+    }
+    /** The file's lines from byte `start` to byte `end`, in order, read a chunk at a time, passing over `skip`. */
+    async function* forward(path, start, end, skip = []) {
+        for (const part of kept(start, end, skip))
+            yield* forwardIn(path, part.start, part.end);
+    }
+    async function* forwardIn(path, start, end) {
+        let position = start;
+        let carry = new Uint8Array(0);
+        let carryStart = start;
+        while (position < end) {
+            const to = Math.min(end, position + CHUNK_BYTES);
+            const bytes = joined(carry, await files.readFileRange(path, position, to));
+            let lineStart = 0;
+            for (let index = 0; index < bytes.length; index++) {
+                if (bytes[index] !== NEWLINE)
+                    continue;
+                if (index > lineStart)
+                    yield parse(bytes.subarray(lineStart, index), carryStart + lineStart);
+                lineStart = index + 1;
+            }
+            carry = bytes.slice(lineStart);
+            carryStart += lineStart;
+            position = to;
+        }
+        if (carry.length > 0)
+            yield parse(carry, carryStart);
+    }
+    /**
+     * Where the lines from time `target` on start, about, between `low` and `high`: the start of a line
+     * (or `high`) with only lines from before it, allowing for the slack, ahead of it. Bisects, each
+     * probe reading the times of the first few lines after its middle, passing over `skip`.
+     */
+    async function seek(path, low, high, target, skip) {
+        return (await narrow(path, low, high, target, skip)).high;
+    }
+    /** seek's bisection: where it got, from both sides. */
+    async function narrow(path, low, high, target, skip) {
+        while (high - low > CHUNK_BYTES) {
+            let middle = Math.floor((low + high) / 2);
+            const inside = skip.find((stretch) => stretch.start <= middle && middle < stretch.end);
+            if (inside) {
+                if (inside.end >= high) {
+                    high = Math.max(low, inside.start);
+                    continue;
+                }
+                middle = inside.end;
+            }
+            const probe = await probeTime(path, middle, high, skip);
+            if (!probe)
+                break; // one line spans it all: start from where the search got
+            if (probe.time >= target)
+                high = probe.start;
+            else
+                low = probe.start;
+        }
+        return { low, high };
+    }
+    /** The first line starting after `from` (before `limit`), with the earliest time of the next few timed lines. */
+    async function probeTime(path, from, limit, skip) {
+        let start = -1;
+        let time = Infinity;
+        let timed = 0;
+        for await (const line of forward(path, from, Math.min(limit, from + PROBE_BYTES), skip)) {
+            if (line.start === from && from > 0)
+                continue; // the middle of a line: only its end was read
+            if (line.start >= limit)
+                break;
+            if (start < 0)
+                start = line.start;
+            if (line.time === null)
+                continue;
+            time = Math.min(time, line.time);
+            if (++timed === PROBE_LINES)
+                break;
+        }
+        return start < 0 || timed === 0 ? null : { start, time };
+    }
+    /** The time of the first timed line from `from` on (a line start), if there's one in reach. */
+    async function timeAt(path, from, size, skip) {
+        for await (const line of forward(path, from, Math.min(size, from + PROBE_BYTES), skip))
+            if (line.time !== null)
+                return line.time;
+        return null;
+    }
+    /** Where the line holding byte `at` starts. */
+    async function lineStart(path, at) {
+        for await (const line of backward(path, at + 1))
+            return line.start;
+        return 0;
+    }
+    /**
+     * The stretches the backend wrote again (TranscriptLayout.copies): each starts at a line with the
+     * marker whose time goes back from the timed line before it, and runs until a line is newer than
+     * that one. Found by searching the whole file for the marker; the rest only
+     * reads around what's found.
+     */
+    function copiesOf(path, size) {
+        if (!layout.copies)
+            return Promise.resolve([]);
+        const key = `${path}\0${size}`;
+        let copies = searchedCopies.get(key);
+        if (!copies) {
+            copies = findCopies(path, size, layout.copies);
+            copies.catch(() => searchedCopies.delete(key));
+            searchedCopies.set(key, copies);
+            // A few files' worth: a worker serves an agent's sessions.
+            if (searchedCopies.size > SEARCHED_FILES)
+                searchedCopies.delete(searchedCopies.keys().next().value);
+        }
+        return copies;
+    }
+    async function findCopies(path, size, marker) {
+        const needle = Buffer.from(marker);
+        const found = [];
+        for (let position = 0; position < size; position += SCAN_BYTES) {
+            // Overlapping by the marker's length, so one across two reads is found.
+            const from = Math.max(0, position - needle.length + 1);
+            const bytes = Buffer.from(await files.readFileRange(path, from, Math.min(size, position + SCAN_BYTES)));
+            for (let index = bytes.indexOf(needle); index >= 0; index = bytes.indexOf(needle, index + 1)) {
+                if (from + index >= position || position === 0)
+                    found.push(from + index);
+            }
+        }
+        const copies = [];
+        for (const [index, at] of found.entries()) {
+            // The marker's line, and the timed line before it.
+            const start = await lineStart(path, at);
+            let earlier = null;
+            for await (const before of backward(path, start)) {
+                if (before.time === null)
+                    continue;
+                earlier = before.time;
+                break;
+            }
+            if (earlier === null || copies.some((copy) => copy.start <= start && start < copy.end))
+                continue;
+            let time = null;
+            for await (const line of forward(path, start, size)) {
+                time = line.time;
+                break;
+            }
+            // A compaction as it happened comes after what's before it (compacting takes a while: 25s and
+            // more); a copy starts back at its time.
+            if (time === null || time >= earlier)
+                continue;
+            // It runs up to what was written before it, and ends with the first line newer than that. It
+            // holds what was said since a compaction, so it ends by the next marker: the rest of the file
+            // (other copies) can't mislead the search.
+            const next = found[index + 1];
+            const near = await narrow(path, start + 1, next === undefined ? size : await lineStart(path, next), earlier + 1, []);
+            let end = near.high;
+            for await (const line of forward(path, near.low, near.high)) {
+                if (line.start <= start || line.time === null || line.time <= earlier)
+                    continue;
+                end = line.start;
+                break;
+            }
+            copies.push({ start, end });
+        }
+        return copies;
+    }
+    /**
+     * The file's lines before `end`, last first, each with the time it's paged by: its own, unless it's
+     * odd, more than the slack away from both the timed lines around it in the same direction (a
+     * background task's result written minutes after it began, a note dated ahead), when it's the one
+     * before it's; a line without a time goes with the timed line after it. These times follow the file
+     * order to within the slack, so the late result is paged where it is in the conversation.
+     * `after`: the time of the first timed line from `end` on.
+     */
+    async function* pagedBackward(path, end, after, skip) {
+        let next = after; // the time of the timed line after the one waiting
+        let waiting = []; // a timed line and the untimed ones before it, until the one before it is read
+        const settle = function* (before) {
+            const [timed, ...untimed] = waiting;
+            if (!timed)
+                return;
+            const own = timed.time;
+            const late = before !== null && own < before - TIME_SLACK_MS && (next === null || own < next - TIME_SLACK_MS);
+            const ahead = before !== null && own > before + TIME_SLACK_MS && (next === null || own > next + TIME_SLACK_MS);
+            const time = late || ahead ? before : own;
+            yield { ...timed, time };
+            for (const line of untimed)
+                yield { ...line, time };
+            next = own;
+            waiting = [];
+        };
+        for await (const line of backward(path, end, skip)) {
+            if (line.time === null) {
+                // Before any timed line: it goes with the line after the end, or is the newest.
+                if (waiting.length === 0)
+                    yield { ...line, time: next ?? Infinity };
+                else
+                    waiting.push(line);
+                continue;
+            }
+            yield* settle(line.time);
+            waiting = [line];
+        }
+        yield* settle(null);
+    }
+    async function page(before, limit, found) {
+        const path = await locate();
+        if (!path)
+            return { messages: [], nextBefore: null };
+        const size = await files.size(path);
+        const copies = found?.copies ?? (await copiesOf(path, size));
+        const from = Math.min(found?.end ?? (before === null ? size : await seek(path, 0, size, before + TIME_SLACK_MS, copies)), size);
+        const after = found ? found.after : from < size ? await timeAt(path, from, size, copies) : null;
+        // Read back until the page is full and a line is older than its oldest by more than the slack:
+        // nothing before it can belong on the page.
+        const taken = [];
+        let count = 0;
+        let oldest = Infinity; // the time of the page's limit-th newest message, once it's full
+        let older = false;
+        for await (const line of pagedBackward(path, from, after, copies)) {
+            if (count >= limit && line.time < oldest - TIME_SLACK_MS) {
+                older = true;
+                break;
+            }
+            if (line.messages.length === 0 || (before !== null && !(line.time < before)))
+                continue;
+            taken.push(line);
+            count += line.messages.length;
+            if (count >= limit)
+                oldest = oldestOnPage(taken, limit);
+        }
+        // The page: its newest messages by time, ties with the oldest of them included. A line's messages
+        // stay together, so a page can hold a message or so more than the limit.
+        const kept = count >= limit ? taken.filter((line) => line.time >= oldest) : taken;
+        if (kept.length < taken.length)
+            older = true;
+        return {
+            messages: kept.sort((a, b) => a.start - b.start).flatMap((line) => line.messages),
+            nextBefore: older && Number.isFinite(oldest) ? new Date(oldest).toISOString() : null,
+        };
+    }
+    // Passing over the copies too: a resumed session's stretch written again isn't replayed twice.
+    async function replay(afterId, emit) {
+        const path = await locate();
+        if (!path)
+            return afterId === undefined;
+        const end = await files.size(path);
+        const copies = await copiesOf(path, end);
+        let start = 0;
+        if (afterId !== undefined) {
+            let found = null;
+            for await (const line of backward(path, end, copies)) {
+                if (line.messages.some((message) => message.uuid === afterId)) {
+                    found = line;
+                    break;
+                }
+            }
+            if (!found)
+                return false;
+            start = found.start;
+        }
+        let passed = afterId === undefined;
+        for await (const line of forward(path, start, end, copies)) {
+            for (const message of line.messages) {
+                if (passed)
+                    emit(message);
+                else if (message.uuid === afterId)
+                    passed = true;
+            }
+        }
+        return true;
+    }
+    return { page, replay };
+}
+/** The time of the `limit`-th newest message of `lines`. */
+function oldestOnPage(lines, limit) {
+    const newestFirst = [...lines].sort((a, b) => b.time - a.time);
+    let count = 0;
+    for (const line of newestFirst) {
+        count += line.messages.length;
+        if (count >= limit)
+            return line.time;
+    }
+    return newestFirst[newestFirst.length - 1]?.time ?? Infinity;
+}
+function joined(first, second) {
+    if (first.length === 0)
+        return second;
+    if (second.length === 0)
+        return first;
+    const bytes = new Uint8Array(first.length + second.length);
+    bytes.set(first);
+    bytes.set(second, first.length);
+    return bytes;
+}
+const DEFAULT_PAGE_SIZE = 50;
+const MAX_PAGE_SIZE = 500;
+/** A page of the API's transcript (AgentTranscript.getTranscript); none stored for a session that never ran. */
+export async function transcriptPage(transcript, { limit, before, cursor } = {}, found) {
+    const time = transcriptTime(before ?? cursor);
+    if (!transcript)
+        return { messages: [], nextBefore: null, nextCursor: null };
+    const size = Math.min(Math.max(Math.floor(limit ?? DEFAULT_PAGE_SIZE), 1), MAX_PAGE_SIZE);
+    const page = await transcript.page(time, size, found);
+    return { ...page, nextCursor: page.nextBefore };
+}
+/** AgentTranscriptRequest.before as epoch ms; null for none. */
+export function transcriptTime(before) {
+    if (before === undefined)
+        return null;
+    const time = Date.parse(before);
+    if (Number.isNaN(time))
+        throw new AgentInvalidError(`invalid time ${before}: give an ISO 8601 time`);
+    return time;
+}
+/**
+ * The first file `depth` levels under `dir` whose name `matches` (the backends' own layouts, like
+ * projects/<project>/<id>.jsonl), each level listed at once; null when there's none, or no `dir`.
+ */
+async function findFile(files, dir, depth, matches) {
+    let names;
+    try {
+        names = await files.listDirectory(dir);
+    }
+    catch (error) {
+        if (error instanceof SandboxNotFoundError)
+            return null;
+        throw error;
+    }
+    if (depth <= 1) {
+        const name = names.find(matches);
+        return name === undefined ? null : `${dir}/${name}`;
+    }
+    // Newest first, where names sort by date (codex's YYYY/MM/DD): a recent conversation is the likely one.
+    const found = await Promise.all(names.sort().reverse().map((name) => 
+    // One that isn't a directory has nothing below it.
+    findFile(files, `${dir}/${name}`, depth - 1, matches).catch(() => null)));
+    return found.find((path) => path !== null) ?? null;
+}
+/**
+ * `files` with what was already fetched of the file at `path` in the same round trip: its size, and
+ * pieces of it (what a page reads, mostly). Reading back beyond them (a page across huge tool
+ * outputs) fetches twice as much as the time before, so it takes a few more reads, not one per chunk.
+ */
+export function prefetchedFiles(files, path, size, pieces) {
+    let more = Math.max(CHUNK_BYTES, ...pieces.map(({ bytes }) => bytes.length));
+    return {
+        size: async (at) => (at === path ? size : files.size(at)),
+        readFileRange: async (at, from, to) => {
+            if (at !== path)
+                return files.readFileRange(at, from, to);
+            let piece = pieces.find(({ start, bytes }) => from >= start && to <= start + bytes.length);
+            if (!piece) {
+                more *= 2;
+                const start = Math.max(0, Math.min(from, to - more));
+                piece = { start, bytes: await files.readFileRange(at, start, to) };
+                pieces.push(piece);
+            }
+            return piece.bytes.subarray(from - piece.start, to - piece.start);
+        },
+        listDirectory: (at) => files.listDirectory(at),
+    };
+}

package/dist/agent/session/sdkMessages.d.ts

@@ -0,0 +1,15 @@
+import type { SDKAssistantMessage, SDKResultMessage } from "../../vendor-types/claude/agent-sdk/sdk.js";
+import type { UserMessage } from "../api.ts";
+/** claude's tool for asking the user; other backends' questions appear in the stream under its name. */
+export declare const ASK_USER_QUESTION = "AskUserQuestion";
+export type AssistantContentBlock = SDKAssistantMessage["message"]["content"][number];
+export type AssistantUsage = SDKAssistantMessage["message"]["usage"];
+/** Token counts in the SDK's shape. */
+export declare function resultUsage({ input, output, cacheRead, cacheWrite }?: {
+    input?: number | undefined;
+    output?: number | undefined;
+    cacheRead?: number | undefined;
+    cacheWrite?: number | undefined;
+}): SDKResultMessage["usage"];
+/** The text of a user message, whichever shape its content has. */
+export declare function userMessageText(message: UserMessage): string;

package/dist/agent/session/sdkMessages.js

@@ -0,0 +1,28 @@
+// The stream speaks the Claude Agent SDK's messages (api.ts), so a backend that isn't claude makes
+// them up: these are the pieces it needs.
+/** claude's tool for asking the user; other backends' questions appear in the stream under its name. */
+export const ASK_USER_QUESTION = "AskUserQuestion";
+/** Token counts in the SDK's shape. */
+export function resultUsage({ input = 0, output = 0, cacheRead = 0, cacheWrite = 0 } = {}) {
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        cache_read_input_tokens: cacheRead,
+        cache_creation_input_tokens: cacheWrite,
+        cache_creation: { ephemeral_1h_input_tokens: 0, ephemeral_5m_input_tokens: 0 },
+        server_tool_use: { web_fetch_requests: 0, web_search_requests: 0 },
+        service_tier: "standard",
+    };
+}
+/** The text of a user message, whichever shape its content has. */
+export function userMessageText(message) {
+    const content = message.message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => (block.type === "text" && typeof block.text === "string" ? block.text : ""))
+        .filter(Boolean)
+        .join("\n");
+}

package/dist/agent/session/sessionStorage.d.ts

@@ -53,6 +53,10 @@ export interface SessionStorage {
  * host side of that mount, so the host reaches the worker through it.
  */
 export declare function workerSocketPath(runDirectory: string, agentName: string): string;
+/** Where the session's record is in a dimension's state directory (see createSessionStorage). */
+export declare function sessionRecordPath(stateDirectory: string, agentName: string, sessionName: string): string;
+/** Where the backend CLI's home is (SessionStorage.backendHome) in a dimension's state directory. */
+export declare function backendHomePath(stateDirectory: string, backend: AgentBackend): string;
 /**
  * `stateDirectory` is a sandbox path: the dimension's state directory (STATE_PATH, mounted from the
  * host's hyperbrane storage, so everything here lives there with the rest). Layout:

package/dist/agent/session/sessionStorage.js

@@ -7,6 +7,17 @@ import { checkName, createJsonDirectory } from "../../lib/jsonDirectory.js";
 export function workerSocketPath(runDirectory, agentName) {
     return `${runDirectory}/${agentName}.sock`;
 }
+function sessionsDirectory(stateDirectory, agentName) {
+    return `${stateDirectory}/agents/${agentName}/sessions`;
+}
+/** Where the session's record is in a dimension's state directory (see createSessionStorage). */
+export function sessionRecordPath(stateDirectory, agentName, sessionName) {
+    return `${sessionsDirectory(stateDirectory, agentName)}/${checkName(sessionName)}.json`;
+}
+/** Where the backend CLI's home is (SessionStorage.backendHome) in a dimension's state directory. */
+export function backendHomePath(stateDirectory, backend) {
+    return `${stateDirectory}/backends/${backend}`;
+}
 /**
  * `stateDirectory` is a sandbox path: the dimension's state directory (STATE_PATH, mounted from the
  * host's hyperbrane storage, so everything here lives there with the rest). Layout:
@@ -15,7 +26,7 @@ export function workerSocketPath(runDirectory, agentName) {
  * (the CLIs' homes). The socket goes in `runDirectory`, the dimension's run directory.
  */
 export function createSessionStorage(sandbox, agentName, { stateDirectory = STATE_PATH, runDirectory = RUN_PATH } = {}) {
-    const sessionsDir = `${stateDirectory}/agents/${agentName}/sessions`;
+    const sessionsDir = sessionsDirectory(stateDirectory, agentName);
     const sessions = createJsonDirectory(sandbox, async () => sessionsDir);
     const sessionDir = (sessionName) => `${sessionsDir}/${checkName(sessionName)}`;
     const permissionRequests = (sessionName) => createJsonDirectory(sandbox, async () => `${sessionDir(sessionName)}/permission-requests`);
@@ -66,7 +77,7 @@ export function createSessionStorage(sandbox, agentName, { stateDirectory = STAT
         return workerSocketPath(runDirectory, agentName);
     }
     async function backendHome(backend) {
-        const path = `${stateDirectory}/backends/${backend}`;
+        const path = backendHomePath(stateDirectory, backend);
         await sandbox.createDirectory(path);
         return path;
     }

package/dist/agent/session/sharedConnection.d.ts

@@ -1,4 +1,5 @@
 import type { ConnectWorker } from "./workerConnection.ts";
+/** @sealed */
 export type SharedConnector = ConnectWorker & {
     /** Closes the connection they share (a later connect opens another). */
     close(): void;

package/dist/agent/session/storedTranscripts.d.ts

@@ -0,0 +1,13 @@
+import type { AgentBackend } from "../api.ts";
+import type { SessionBackend } from "./backend.ts";
+import type { LineMessages, TranscriptLayout } from "./fileTranscript.ts";
+/**
+ * Each backend's conversations as it stores them: where (under the home homeEnvironment points it
+ * at) and how a line reads, for reading a transcript with nothing running, from the host. None of
+ * the backends' other code, which runs only in the dimension.
+ */
+export type StoredTranscripts = Pick<SessionBackend, "homeEnvironment"> & {
+    layout: TranscriptLayout;
+    lineMessages(nativeId: string): LineMessages;
+};
+export declare const STORED_TRANSCRIPTS: Record<AgentBackend, StoredTranscripts>;

package/dist/agent/session/storedTranscripts.js

@@ -0,0 +1,8 @@
+import { claudeHomeEnvironment } from "./claude/home.js";
+import { CLAUDE_TRANSCRIPT_LAYOUT, claudeLineMessages } from "./claude/transcript.js";
+import { codexHomeEnvironment } from "./codex/home.js";
+import { CODEX_TRANSCRIPT_LAYOUT, codexLineMessages } from "./codex/transcript.js";
+export const STORED_TRANSCRIPTS = {
+    claude: { homeEnvironment: claudeHomeEnvironment, layout: CLAUDE_TRANSCRIPT_LAYOUT, lineMessages: () => claudeLineMessages },
+    codex: { homeEnvironment: codexHomeEnvironment, layout: CODEX_TRANSCRIPT_LAYOUT, lineMessages: codexLineMessages },
+};

package/dist/agent/session/worker/protocol.d.ts

@@ -1,10 +1,12 @@
-import { type AgentAuthStatus, type AgentBackend, type AgentBackgroundTask, type AgentLastUserMessage, type AgentModelInfo, type AgentPermissionRequest, type AgentPermissionResult, type AgentQuestionRequest, type AgentQuestionResponse, type AgentSession, type AgentSessionInfo, type AgentSessionLimits, type AgentSessionState, type AgentStreamingMessage, type AgentTranscriptPage, type UserMessage } from "../../api.ts";
+import { type AgentAuthStatus, type AgentBackend, type AgentBackendInfo, type AgentBackgroundTask, type AgentLastUserMessage, type AgentModelInfo, type AgentPermissionRequest, type AgentPermissionResult, type AgentQuestionRequest, type AgentQuestionResponse, type AgentSession, type AgentSessionInfo, type AgentSessionLimits, type AgentSessionState, type AgentStreamingMessage, type AgentTranscriptPage, type UserMessage } from "../../api.ts";
 import type { JsonRpcErrorObject } from "./jsonRpc.ts";
 /**
  * The worker's JSON-RPC protocol, spoken over its unix socket (see createWorkerServer): method ->
  * [params, result]. Sessions are named by `session`; everything answers `null` unless it says.
  * worker/health and worker/shutdown are how the host tells a worker's build and replaces it: they
  * never change.
+ *
+ * @sealed
  */
 export type WorkerRequests = {
     "worker/health": [Record<string, never>, WorkerHealth];
@@ -13,6 +15,7 @@ export type WorkerRequests = {
     "backend/install": [{
         backend: AgentBackend;
     }, null];
+    "backend/list": [Record<string, never>, AgentBackendInfo[]];
     "session/create": [{
         session: AgentSession;
     }, AgentSessionInfo];
@@ -54,6 +57,7 @@ export type WorkerRequests = {
     "session/transcript": [{
         session: string;
         limit?: number;
+        before?: string;
         cursor?: string;
     }, AgentTranscriptPage];
     "permission/list": [{

package/dist/agent/session/worker/protocol.js

@@ -1,10 +1,11 @@
-import { AgentConflictError, AgentInvalidError, AgentNotFoundError, } from "../../api.js";
+import { AgentBackendNotInstalledError, AgentConflictError, AgentInvalidError, AgentNotFoundError, } from "../../api.js";
 const METHOD_NOT_FOUND = -32601;
 const INVALID_PARAMS = -32602;
 const INTERNAL_ERROR = -32603;
 // Server-defined codes, for the Agent*Errors that aren't bad params.
 const NOT_FOUND = -32004;
 const CONFLICT = -32009;
+const BACKEND_NOT_INSTALLED = -32010;
 export class WorkerMethodNotFoundError extends Error {
     name = "WorkerMethodNotFoundError";
 }
@@ -15,6 +16,8 @@ export function encodeWorkerError(error) {
         return { code: INVALID_PARAMS, message };
     if (error instanceof AgentNotFoundError)
         return { code: NOT_FOUND, message };
+    if (error instanceof AgentBackendNotInstalledError)
+        return { code: BACKEND_NOT_INSTALLED, message };
     if (error instanceof AgentConflictError)
         return { code: CONFLICT, message };
     if (error instanceof WorkerMethodNotFoundError)
@@ -28,5 +31,7 @@ export function decodeWorkerError({ code, message }) {
         return new AgentNotFoundError(message);
     if (code === CONFLICT)
         return new AgentConflictError(message);
+    if (code === BACKEND_NOT_INSTALLED)
+        return new AgentBackendNotInstalledError(message);
     return new Error(`worker: ${message}`);
 }

package/dist/agent/session/worker/workerParams.d.ts

@@ -0,0 +1,11 @@
+import type { WorkerMethod, WorkerRequests } from "./protocol.ts";
+type Fields = Record<string, unknown>;
+/**
+ * Turns each method's params, as they arrived (JSON), into the protocol's types, or throws an
+ * AgentInvalidError saying what's wrong. Keeps only the fields the types have, so nothing unknown
+ * reaches the service (or its storage).
+ */
+export declare const WORKER_PARAMS: {
+    [M in WorkerMethod]: (params: Fields) => WorkerRequests[M][0];
+};
+export {};