hyperbrane 0.1.2 → 0.2.0

package/dist/agent/session/install.js

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+import manifest from "../vendor-types/manifest.json" with { type: "json" };
+export function pinnedVersion(vendor, pkg, sourcePackage = pkg) {
+    const prefix = `npm:${sourcePackage}@`;
+    const source = manifest[vendor].sources.find((entry) => entry.source.startsWith(prefix));
+    if (!source)
+        throw new Error(`agent/vendor-types/manifest.json has no ${sourcePackage} for ${vendor} (needed for ${pkg})`);
+    return source.source.slice(prefix.length);
+}
+export async function installedPackage(installDir, pkg, version, executable) {
+    const manifest = Bun.file(`${installDir}/node_modules/${pkg}/package.json`);
+    const found = (await manifest.exists()) ? ((await manifest.json()).version ?? null) : null;
+    return { version: found, ready: found !== null && existsSync(executable()), pinned: version };
+}
+export async function installPackage(installDir, pkg, version, executable) {
+    const installed = await installedPackage(installDir, pkg, version, executable);
+    if (installed.ready && installed.version === version)
+        return;
+    const force = installed.version === version ? ["--force"] : [];
+    const proc = Bun.spawn(["flock", `${installDir}/.install.lock`, process.execPath, "add", "--exact", ...force, `${pkg}@${version}`], {
+        cwd: installDir,
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+    ]);
+    if (exitCode !== 0)
+        throw new Error(`bun add ${pkg}@${version} failed (exit ${exitCode}): ${(stderr || stdout).trim()}`);
+    if (!existsSync(executable()))
+        throw new Error(`bun add ${pkg}@${version} left no ${executable()}: its platform package didn't install`);
+}

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

@@ -1,69 +1,38 @@
 import type { Sandbox } from "../../sandbox/api.ts";
-import type { AgentAuthStatus, AgentBackend, AgentPermissionRequest, AgentQuestionRequest, AgentSession } from "../api.ts";
-/** What the worker keeps of a session: never its messages, which are the backend's to store. */
+import type { AgentAuthStatus, AgentBackend, AgentPermissionMode, AgentPermissionRequest, AgentQuestionRequest, AgentSession, AgentSessionState } from "../api.ts";
 export type SessionRecord = {
     spec: AgentSession;
-    /** The backend's id for the conversation, once known: what a new worker resumes. */
     nativeId: string | null;
-    /** Chosen through AgentModels; null for the backend's default. */
     model: string | null;
+    permissionMode?: AgentPermissionMode;
 };
-/** Where a session's CLI stands with its sign-in, as far as it outlives a request. */
 export type SessionAuthRecord = {
-    /** Where the CLI's login in progress asked the user to sign in; null when none is. */
     login: Extract<AgentAuthStatus, {
         state: "pending";
     }> | null;
-    /** Why the last login failed, if it did. */
     error: string | null;
 };
-/** Every name must pass checkName; operations throw InvalidNameError otherwise. */
 export interface SessionStorage {
     getSessions(): Promise<SessionRecord[]>;
-    /** Stores the record unless one with that name exists; returns whichever record is stored afterwards. */
     insertSession(record: SessionRecord): Promise<SessionRecord>;
-    /** Replaces the record. */
     saveSession(record: SessionRecord): Promise<void>;
-    /** Removes the record and everything kept for the session. No-op if missing. */
     removeSession(sessionName: string): Promise<void>;
-    /** The permission requests the session's CLI is waiting on, oldest first. */
     getPermissionRequests(sessionName: string): Promise<AgentPermissionRequest[]>;
     savePermissionRequest(sessionName: string, request: AgentPermissionRequest): Promise<void>;
-    /** No-op if missing. */
     removePermissionRequest(sessionName: string, requestId: string): Promise<void>;
-    /** The questions the session's CLI is waiting on, oldest first. */
     getQuestionRequests(sessionName: string): Promise<AgentQuestionRequest[]>;
     saveQuestionRequest(sessionName: string, request: AgentQuestionRequest): Promise<void>;
-    /** No-op if missing. */
     removeQuestionRequest(sessionName: string, requestId: string): Promise<void>;
-    /** Null until the session's CLI has been asked to sign in. */
     readAuth(sessionName: string): Promise<SessionAuthRecord | null>;
     saveAuth(sessionName: string, record: SessionAuthRecord): Promise<void>;
-    /** Sandbox path of the unix socket the agent's worker listens on (see workerSocketPath). */
+    saveStatus(sessionName: string, status: AgentSessionState): Promise<void>;
     socketPath(): Promise<string>;
-    /**
-     * Sandbox path of the backend CLI's home (claude's config directory, codex's CODEX_HOME): its
-     * sign-in, config and conversations, kept with the rest of the dimension's state. Shared by the
-     * dimension's agents, like a home would be. Creates it.
-     */
     backendHome(backend: AgentBackend): Promise<string>;
 }
-/**
- * The agent's worker socket in a dimension's run directory: RUN_PATH inside the dimension, or the
- * 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 workerReadyPath(runDirectory: string, agentName: string): string;
 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:
- * agents/<agent>/sessions/<session>.json, and agents/<agent>/sessions/<session>/ holding
- * permission-requests/<id>.json, question-requests/<id>.json and auth.json; backends/<backend>/
- * (the CLIs' homes). The socket goes in `runDirectory`, the dimension's run directory.
- */
 export declare function createSessionStorage(sandbox: Sandbox, agentName: string, { stateDirectory, runDirectory }?: {
     stateDirectory?: string;
     runDirectory?: string;

package/dist/agent/session/sessionStorage.js

@@ -1,37 +1,28 @@
-import { RUN_PATH, STATE_PATH } from "../../dimension/paths.js";
+import { dimensionLayout } from "../../dimension/api.js";
 import { checkName, createJsonDirectory } from "../../lib/jsonDirectory.js";
-/**
- * The agent's worker socket in a dimension's run directory: RUN_PATH inside the dimension, or the
- * host side of that mount, so the host reaches the worker through it.
- */
 export function workerSocketPath(runDirectory, agentName) {
     return `${runDirectory}/${agentName}.sock`;
 }
+export function workerReadyPath(runDirectory, agentName) {
+    return `${runDirectory}/${agentName}.ready`;
+}
 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:
- * agents/<agent>/sessions/<session>.json, and agents/<agent>/sessions/<session>/ holding
- * permission-requests/<id>.json, question-requests/<id>.json and auth.json; backends/<backend>/
- * (the CLIs' homes). The socket goes in `runDirectory`, the dimension's run directory.
- */
-export function createSessionStorage(sandbox, agentName, { stateDirectory = STATE_PATH, runDirectory = RUN_PATH } = {}) {
+export function createSessionStorage(sandbox, agentName, { stateDirectory = dimensionLayout.statePath(), runDirectory = dimensionLayout.runPath() } = {}) {
     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`);
     const questionRequests = (sessionName) => createJsonDirectory(sandbox, async () => `${sessionDir(sessionName)}/question-requests`);
     const sessionFiles = (sessionName) => createJsonDirectory(sandbox, async () => sessionDir(sessionName));
+    const statusFiles = (sessionName) => createJsonDirectory(sandbox, async () => sessionDir(sessionName));
     async function oldestFirst(stored) {
         return (await stored).sort((a, b) => a.at - b.at).map((entry) => entry.request);
     }
@@ -44,7 +35,6 @@ export function createSessionStorage(sandbox, agentName, { stateDirectory = STAT
     async function saveSession(record) {
         await sessions.save(record.spec.name, record);
     }
-    // Everything kept for it first: while the record is there, the removal can be retried.
     async function removeSession(sessionName) {
         await sandbox.removeDirectory(sessionDir(sessionName));
         await sessions.remove(sessionName);
@@ -73,6 +63,9 @@ export function createSessionStorage(sandbox, agentName, { stateDirectory = STAT
     async function saveAuth(sessionName, record) {
         await sessionFiles(sessionName).save("auth", record);
     }
+    async function saveStatus(sessionName, status) {
+        await statusFiles(sessionName).save("status", { status });
+    }
     async function socketPath() {
         return workerSocketPath(runDirectory, agentName);
     }
@@ -94,6 +87,7 @@ export function createSessionStorage(sandbox, agentName, { stateDirectory = STAT
         removeQuestionRequest,
         readAuth,
         saveAuth,
+        saveStatus,
         socketPath,
         backendHome,
     };

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

@@ -1,14 +1,6 @@
 import type { ConnectWorker } from "./workerConnection.ts";
 /** @sealed */
 export type SharedConnector = ConnectWorker & {
-    /** Closes the connection they share (a later connect opens another). */
     close(): void;
 };
-/**
- * One connection to the worker, shared by everyone `connect`s through it: each gets a view of it
- * (its requests go over it, the worker's notifications reach every view, closing a view only
- * detaches it), so calls cost a round trip each rather than a connection each. Over an endpoint
- * that's what matters (workerSseConnector opens an event stream per connection). The connection is
- * opened on first use, and again after it closes.
- */
 export declare function sharedConnector(connect: ConnectWorker): SharedConnector;

package/dist/agent/session/sharedConnection.js

@@ -1,10 +1,3 @@
-/**
- * One connection to the worker, shared by everyone `connect`s through it: each gets a view of it
- * (its requests go over it, the worker's notifications reach every view, closing a view only
- * detaches it), so calls cost a round trip each rather than a connection each. Over an endpoint
- * that's what matters (workerSseConnector opens an event stream per connection). The connection is
- * opened on first use, and again after it closes.
- */
 export function sharedConnector(connect) {
     let current = null;
     function open() {

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

@@ -1,13 +1,8 @@
 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>;
+export declare const STORED_TRANSCRIPTS: Partial<Record<AgentBackend, StoredTranscripts>>;

package/dist/agent/session/storedTranscripts.js

@@ -1,8 +1,5 @@
 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/jsonRpc.d.ts

@@ -1,7 +1,3 @@
-/**
- * JSON-RPC 2.0 over a byte stream, one JSON object per line (the framing codex's app-server uses).
- * Either end can send requests and notifications; the worker protocol (protocol.ts) is built on it.
- */
 export type JsonRpcId = string | number;
 export type JsonRpcErrorObject = {
     code: number;
@@ -9,29 +5,22 @@ export type JsonRpcErrorObject = {
     data?: unknown;
 };
 export type JsonRpcPeerOptions = {
-    /** Answers a request; what it throws goes back as an error response, through `encodeError`. */
-    onRequest(method: string, params: unknown): Promise<unknown>;
+    onRequest(method: string, params: unknown, protocol: number | undefined): Promise<unknown>;
+    protocol?: number;
     onNotification?(method: string, params: unknown): void;
     encodeError(error: unknown): JsonRpcErrorObject;
     decodeError(error: JsonRpcErrorObject): Error;
 };
 export interface JsonRpcPeer {
-    /** Feeds text read from the connection; complete lines are handled as they arrive. */
     receive(text: string): void;
     request(method: string, params: unknown): Promise<unknown>;
     notify(method: string, params: unknown): void;
-    /** Fails every request still waiting for its response. */
     close(error: Error): void;
 }
 export declare function createJsonRpcPeer(write: (line: string) => void, options: JsonRpcPeerOptions): JsonRpcPeer;
-/** The part of a Bun socket a writer needs. */
 type WritableSocket = {
     write(data: Uint8Array): number;
 };
-/**
- * Writes to a Bun socket without losing what it can't take yet: the rest is kept and written on
- * `drain`, which the socket's drain handler must call.
- */
 export declare function createSocketWriter(socket: WritableSocket): {
     write(text: string): void;
     drain(): void;

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

@@ -1,8 +1,3 @@
-/**
- * JSON-RPC 2.0 over a byte stream, one JSON object per line (the framing codex's app-server uses).
- * Either end can send requests and notifications; the worker protocol (protocol.ts) is built on it.
- */
-/** Answer for a line that isn't JSON-RPC at all. */
 const PARSE_ERROR = -32700;
 export function createJsonRpcPeer(write, options) {
     const pending = new Map();
@@ -31,7 +26,7 @@ export function createJsonRpcPeer(write, options) {
             return;
         }
         const id = message.id;
-        options.onRequest(message.method, message.params).then((result) => send({ id, result: result ?? null }), (error) => send({ id, error: options.encodeError(error) }));
+        options.onRequest(message.method, message.params, message.protocol).then((result) => send({ id, result: result ?? null }), (error) => send({ id, error: options.encodeError(error) }));
     }
     function receive(text) {
         buffered += text;
@@ -58,7 +53,7 @@ export function createJsonRpcPeer(write, options) {
         const id = nextId++;
         return new Promise((resolve, reject) => {
             pending.set(id, { resolve, reject });
-            send({ id, method, params });
+            send({ id, method, params, ...(options.protocol === undefined ? {} : { protocol: options.protocol }) });
         });
     }
     function notify(method, params) {
@@ -72,10 +67,6 @@ export function createJsonRpcPeer(write, options) {
     }
     return { receive, request, notify, close };
 }
-/**
- * Writes to a Bun socket without losing what it can't take yet: the rest is kept and written on
- * `drain`, which the socket's drain handler must call.
- */
 export function createSocketWriter(socket) {
     const encoder = new TextEncoder();
     let backlog = null;

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

@@ -1,16 +1,8 @@
-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 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 AgentPermissionMode, 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
- */
+/** @sealed */
 export type WorkerRequests = {
     "worker/health": [Record<string, never>, WorkerHealth];
-    /** Answers, then stops the sessions' CLIs and exits. */
     "worker/shutdown": [Record<string, never>, null];
     "backend/install": [{
         backend: AgentBackend;
@@ -40,12 +32,6 @@ export type WorkerRequests = {
     "session/lastUserMessages": [{
         session: string;
     }, AgentLastUserMessage[]];
-    /**
-     * Streams the session's messages as `session/message` notifications carrying `subscription` (the
-     * client's own id for the stream): first the complete messages after `after_id` (all of them when
-     * omitted) from the backend's transcript, then each message as it comes, until session/unsubscribe
-     * or the connection closes.
-     */
     "session/subscribe": [{
         session: string;
         subscription: string;
@@ -60,6 +46,12 @@ export type WorkerRequests = {
         before?: string;
         cursor?: string;
     }, AgentTranscriptPage];
+    "session/subagentTranscript": [{
+        session: string;
+        toolUseId: string;
+        limit?: number;
+        before?: string;
+    }, AgentTranscriptPage];
     "permission/list": [{
         session: string;
     }, AgentPermissionRequest[]];
@@ -76,7 +68,6 @@ export type WorkerRequests = {
         request: string;
         response: AgentQuestionResponse;
     }, null];
-    /** Starts the session's CLI if it isn't running. */
     "model/list": [{
         session: string;
     }, AgentModelInfo[]];
@@ -84,7 +75,10 @@ export type WorkerRequests = {
         session: string;
         model: string | null;
     }, null];
-    /** Doesn't start the CLI: a session whose CLI isn't running has no tasks. */
+    "permission/mode": [{
+        session: string;
+        mode: AgentPermissionMode;
+    }, null];
     "task/list": [{
         session: string;
     }, AgentBackgroundTask[]];
@@ -95,7 +89,6 @@ export type WorkerRequests = {
     "auth/status": [{
         session: string;
     }, AgentAuthStatus];
-    /** `gatewaySignedIn`: the dimension's gateway holds the backend's upstream credential (the host knows; the worker can't). */
     "auth/login": [{
         session: string;
         gatewaySignedIn: boolean;
@@ -112,13 +105,26 @@ export type WorkerNotifications = {
         message: AgentStreamingMessage;
     };
 };
+export declare const WORKER_PROTOCOL = 3;
 export type WorkerHealth = {
     agentName: string;
     build: string;
+    protocol: number;
+};
+export declare const WorkerErrorCode: {
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internalError: -32603;
+    readonly notFound: -32004;
+    readonly conflict: -32009;
+    readonly backendNotInstalled: -32010;
+    readonly protocolMismatch: -32011;
 };
 export declare class WorkerMethodNotFoundError extends Error {
     name: string;
 }
-/** The Agent*Errors travel as their own codes, so the client can raise the same class again. */
+export declare class WorkerProtocolMismatchError extends Error {
+    name: string;
+}
 export declare function encodeWorkerError(error: unknown): JsonRpcErrorObject;
 export declare function decodeWorkerError({ code, message }: JsonRpcErrorObject): Error;

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

@@ -1,37 +1,48 @@
 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 const WORKER_PROTOCOL = 3;
+export const WorkerErrorCode = {
+    methodNotFound: -32601,
+    invalidParams: -32602,
+    internalError: -32603,
+    notFound: -32004,
+    conflict: -32009,
+    backendNotInstalled: -32010,
+    protocolMismatch: -32011,
+};
 export class WorkerMethodNotFoundError extends Error {
     name = "WorkerMethodNotFoundError";
 }
-/** The Agent*Errors travel as their own codes, so the client can raise the same class again. */
+export class WorkerProtocolMismatchError extends Error {
+    name = "WorkerProtocolMismatchError";
+}
 export function encodeWorkerError(error) {
     const message = error instanceof Error ? error.message : String(error);
     if (error instanceof AgentInvalidError)
-        return { code: INVALID_PARAMS, message };
+        return { code: WorkerErrorCode.invalidParams, message };
     if (error instanceof AgentNotFoundError)
-        return { code: NOT_FOUND, message };
+        return { code: WorkerErrorCode.notFound, message };
     if (error instanceof AgentBackendNotInstalledError)
-        return { code: BACKEND_NOT_INSTALLED, message };
+        return { code: WorkerErrorCode.backendNotInstalled, message };
     if (error instanceof AgentConflictError)
-        return { code: CONFLICT, message };
+        return { code: WorkerErrorCode.conflict, message };
     if (error instanceof WorkerMethodNotFoundError)
-        return { code: METHOD_NOT_FOUND, message };
-    return { code: INTERNAL_ERROR, message };
+        return { code: WorkerErrorCode.methodNotFound, message };
+    if (error instanceof WorkerProtocolMismatchError)
+        return { code: WorkerErrorCode.protocolMismatch, message };
+    return { code: WorkerErrorCode.internalError, message };
 }
 export function decodeWorkerError({ code, message }) {
-    if (code === INVALID_PARAMS)
+    if (code === WorkerErrorCode.invalidParams)
         return new AgentInvalidError(message);
-    if (code === NOT_FOUND)
+    if (code === WorkerErrorCode.notFound)
         return new AgentNotFoundError(message);
-    if (code === CONFLICT)
+    if (code === WorkerErrorCode.conflict)
         return new AgentConflictError(message);
-    if (code === BACKEND_NOT_INSTALLED)
+    if (code === WorkerErrorCode.backendNotInstalled)
         return new AgentBackendNotInstalledError(message);
+    if (code === WorkerErrorCode.methodNotFound)
+        return new WorkerMethodNotFoundError(`worker: ${message}`);
+    if (code === WorkerErrorCode.protocolMismatch)
+        return new WorkerProtocolMismatchError(`worker: ${message}`);
     return new Error(`worker: ${message}`);
 }

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

@@ -1,10 +1,5 @@
 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];
 };

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

@@ -1,9 +1,4 @@
-import { AGENT_BACKENDS, AgentInvalidError, } from "../../api.js";
-/**
- * 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).
- */
+import { AGENT_BACKENDS, AGENT_PERMISSION_MODES, AgentInvalidError, } from "../../api.js";
 export const WORKER_PARAMS = {
     "worker/health": () => ({}),
     "worker/shutdown": () => ({}),
@@ -26,9 +21,14 @@ export const WORKER_PARAMS = {
     "session/transcript": (params) => ({
         session: name(params),
         limit: optional(params.limit, (value) => number(value, "limit")),
-        // `cursor`: `before`'s old name.
         before: params.before === undefined ? optional(params.cursor, (value) => text(value, "cursor")) : text(params.before, "before"),
     }),
+    "session/subagentTranscript": (params) => ({
+        session: name(params),
+        toolUseId: text(params.toolUseId, "toolUseId"),
+        limit: optional(params.limit, (value) => number(value, "limit")),
+        before: optional(params.before, (value) => text(value, "before")),
+    }),
     "permission/list": (params) => ({ session: name(params) }),
     "permission/respond": (params) => ({
         session: name(params),
@@ -46,6 +46,7 @@ export const WORKER_PARAMS = {
         session: name(params),
         model: params.model === null ? null : text(params.model, "the model (a model name, or null for the backend's default)"),
     }),
+    "permission/mode": (params) => ({ session: name(params), mode: permissionMode(params.mode) }),
     "task/list": (params) => ({ session: name(params) }),
     "task/stop": (params) => ({ session: name(params), task: text(params.task, "task") }),
     "auth/status": (params) => ({ session: name(params) }),
@@ -64,10 +65,8 @@ function name(params) {
 function object(value, what) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         invalid(`${what} must be an object`);
-    // type-bypass: a non-null, non-array object is a record of its fields.
     return value;
 }
-/** A non-empty string. */
 function text(value, what) {
     if (typeof value !== "string" || value.trim() === "")
         invalid(`${what} must be a non-empty string`);
@@ -86,6 +85,12 @@ function boolean(value, what) {
 function optional(value, parse) {
     return value === undefined ? undefined : parse(value);
 }
+function permissionMode(value) {
+    const known = AGENT_PERMISSION_MODES.find((mode) => mode === value);
+    if (!known)
+        invalid(`unknown permission mode "${String(value)}"; known: ${AGENT_PERMISSION_MODES.join(", ")}`);
+    return known;
+}
 function backend(value) {
     const known = AGENT_BACKENDS.find((name) => name === value);
     if (!known)
@@ -96,14 +101,12 @@ function memoryLimit(value) {
     const bytes = number(value, "memoryLimit");
     if (!(bytes > 0))
         invalid("memoryLimit must be positive");
-    // type-bypass: a positive byte count is what a MemoryLimit is (MemoryLimit() parses the CLI's strings).
     return bytes;
 }
 function cpuLimit(value) {
     const cores = number(value, "cpuLimit");
     if (!(cores > 0))
         invalid("cpuLimit must be positive");
-    // type-bypass: a positive core count is what a CPULimit is (CPULimit() parses the CLI's strings).
     return cores;
 }
 function environment(value) {
@@ -111,7 +114,6 @@ function environment(value) {
     for (const [key, entry] of Object.entries(fields))
         if (typeof entry !== "string")
             invalid(`env.${key} must be a string`);
-    // type-bypass: every value was just checked to be a string.
     return fields;
 }
 function session(fields) {
@@ -136,7 +138,6 @@ function userMessage(value) {
         invalid('message.message.role must be "user"');
     if (typeof message.content !== "string" && !Array.isArray(message.content))
         invalid("message.message.content must be a string or an array of content blocks");
-    // type-bypass: the envelope is checked; the content blocks are the CLI's to judge.
     return value;
 }
 function permissionResult(value) {
@@ -158,6 +159,5 @@ function questionResponse(value) {
     for (const [question, answer] of Object.entries(answers))
         if (typeof answer !== "string")
             invalid(`the answer to "${question}" must be a string`);
-    // type-bypass: every answer was just checked to be a string.
     return { answers: answers };
 }

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

@@ -1,29 +1,18 @@
-import type { Sandbox } from "../../sandbox/api.ts";
+import type { Sandbox, SandboxConnection } from "../../sandbox/api.ts";
 import { type WorkerMethod, type WorkerNotifications, type WorkerRequests } from "./worker/protocol.ts";
-/** One connection to a worker: typed requests, and the notifications it pushes. */
 export type WorkerConnection = {
     request<M extends WorkerMethod>(method: M, params: WorkerRequests[M][0]): Promise<WorkerRequests[M][1]>;
-    /** Resolves when the worker closes the connection (or it fails). */
     closed: Promise<void>;
     close(): void;
 };
 export type WorkerNotificationHandler = <N extends keyof WorkerNotifications>(method: N, params: WorkerNotifications[N]) => void;
-/** Opens a connection; notifications go to `onNotification`. */
 export type ConnectWorker = (onNotification?: WorkerNotificationHandler) => Promise<WorkerConnection>;
-/** A text stream to a worker that its JSON-RPC lines go out and come in on. */
 export type WorkerTransport = {
     write(text: string): void;
-    /** Receives the text read from the worker, in order. Registered before anything arrives. */
     onText(listener: (text: string) => void): void;
-    /** Resolves once the transport is closed, by either side or by an error. */
     closed: Promise<void>;
     close(): void;
 };
-/** A connection speaking JSON-RPC over `transport` (`label` says where to, in errors). */
 export declare function workerConnectionOver(transport: WorkerTransport, label: string, onNotification?: WorkerNotificationHandler): WorkerConnection;
-/**
- * Connects over the worker's unix socket at `socketPath` in `host` (the dimension's run directory is
- * mounted on the host, wherever that is: this machine, or a server reached over SSH), speaking
- * JSON-RPC.
- */
 export declare function workerSocketConnector(host: Sandbox, socketPath: string): ConnectWorker;
+export declare function workerStreamConnector(open: () => Promise<SandboxConnection>, label: string): ConnectWorker;