hyperbrane 0.2.0 → 0.2.1

package/README.md

@@ -22,7 +22,7 @@ hyperbrane dimension create --dir ~/work -m 4G --cpus 2 work
 ## Library
 
 ```ts
-import { createAgentClient, createDimensionClient, createGatewayClient, createPortalClient, createSandboxClient, MemoryLimit, CPULimit } from "hyperbrane";
+import { createAgentClient, createDimensionClient, createGatewayClient, createPortalClient, createSandboxClient, listSandboxes, MemoryLimit, CPULimit } from "hyperbrane";
 
 const host = createSandboxClient({ kind: "ssh", sshHost: "server.example.com", sshUser: "me", sshKey: privateKey });
 // A client per part, over the sandbox: making one does nothing.
@@ -37,11 +37,16 @@ await dimensions.createDimension({ name: "work", directory: "work", memoryLimit:
 await portals.createPortal({ name: "work-main", dimensionName: "work", gatewayName: "main" });
 await agents.createAgent({ name: "dev", dimensionName: "work" });
 await agents.install("dev", "claude");
+// A command in the dimension, as its user, in its workspace unless given a cwd.
+const { exitCode, stdout } = await dimensions.runCommand("work", ["git", "status"], { cwd: "repo" });
 ```
 
 Each call resolves once what it made is usable: a gateway once it intercepts, a portal once traffic
 flows through it, an install once the backend runs. Re-running any of them converges.
 
+`sshKey` is an unencrypted private key, in OpenSSH format (as `ssh-keygen` writes it), PKCS#8 (as
+Node's `crypto` exports Ed25519, RSA and ECDSA keys), PKCS#1 (RSA) or SEC1 (ECDSA).
+
 hyperbrane runs where the application does and drives the machine from there, each call over a
 connection of its own (SSH, Boat's API): nothing is kept between calls, so it runs in serverless
 functions too. A browser reaches the machine through data endpoints instead: ports the sandbox makes
@@ -58,6 +63,8 @@ const boat = createSandboxClient({ kind: "boat", sshKey }); // BOAT_API_KEY; rea
 const [ctx] = await boat.create({ name: "box" }); // ctx, now with the sandbox's id, is what's kept
 // Elsewhere, with ctx alone: its operations read its state; open() resumes it first.
 const again = createSandboxClient(ctx);
+// Or found by its name, with the API key alone: every sandbox the key sees, and names can repeat.
+const [found] = (await listSandboxes({ kind: "boat" })).filter((sandbox) => sandbox.name === "box");
 ```
 
 Under a `url` with a root path, every endpoint is at `<url>/<name>` (with
@@ -79,19 +86,52 @@ can be told `EndpointUnreachableError` or `EndpointCredentialsError` (get new on
 agent can share one connection: `sharedConnector(workerGatewayConnector(...))` opens it on first use
 and keeps it until `close()`.
 
+Code running in a dimension (a script a session runs, a service in the workspace) drives the
+dimension's agents over their workers' sockets, under `/run/hyperbrane`:
+
+```ts
+import { createDimensionAgentClient, currentSession } from "hyperbrane";
+
+const agents = createDimensionAgentClient();
+const me = currentSession(); // the session this code runs under ({ agentName, sessionName }), or null
+await agents.createSession(me!.agentName, { name: "helper", backend: "claude", memoryLimit: MemoryLimit("2G"), cpuLimit: CPULimit("1") });
+```
+
+It does what the agents' workers do: sessions, their streams, transcripts, permissions and the
+rest, and installing backends. Making or stopping agents, and starting their workers, take the
+machine: `listAgents()` names the agents whose workers run, and a call to an agent whose worker
+doesn't gets `AgentConflictError` until a call through the machine's `agents` starts it. Its
+`login` doesn't know whether the gateway already holds a sign-in, so it signs in as the backend
+does. Anything in the dimension can drive its agents this way, a session itself included.
+
 What lasts:
 
 | | Container restart | Container recreated | Machine reboot, Boat resume |
 |---|---|---|---|
 | Workspace, sessions, sign-ins, installed backends | kept | kept | kept |
 | Agent workers | started again by the next call (or `agents.restoreAgents()`) | same | same |
-| A gateway's transport worker (on the machine) | kept | kept | started again by `restartGateway` |
-| A dimension's transport worker (in it) | started again by `restartDimension` | started by `createDimension` | started again by `restartDimension` |
+| A gateway's transport worker (on the machine) | kept | kept | started again by `restore` (or `gateways.restoreGateways()`) |
+| A dimension's transport worker (in it) | started again by `restartDimension` or `restore` | started by `createDimension` | started again by `restore` (or `dimensions.restoreDimensions()`) |
 | Portals | re-wired by `restartDimension` and `restartGateway`; otherwise as on the right | re-wired by the next agent call, or `portals.restorePortals()` | same |
 
+After a reboot or a Boat resume, one call starts again whatever didn't survive, in the order it
+needs: the gateways' transport workers and the dimensions' (without restarting their containers),
+then the portals, then the agents' workers. It's safe to call any time, and does nothing more where
+everything runs:
+
+```ts
+import { restore } from "hyperbrane";
+
+await sandbox.open(); // resumes a stopped Boat sandbox
+const { gateways, dimensions, agents } = await restore(sandbox); // what it started again
+```
+
 A Boat sandbox stops itself after a while; `sandbox.hasExpiration()` tells a sandbox that does, and
 `setExpiration` moves it.
 
+On Boat, `readFile`, `readFileRange`, `writeFile` and `writeFileExclusive` reach what Boat's file API
+does: files under `/home/user` and `/tmp`. Another path is a `SandboxPathError`, which says why.
+
 The root module exports the clients (`createDimensionClient`, `createGatewayClient`,
 `createPortalClient`, `createAgentClient`), the sandbox of any kind (`createSandboxClient`) and the
 agent's worker client. An upstream of your own is a `defineUpstream({ name, modes })`, given to a

package/dist/agent/agentService.js

@@ -94,7 +94,7 @@ export function createAgentService(host, { dataDirectory } = {}) {
         const agent = await requireAgent(agentName);
         const dimension = await runningDimension(agent.dimensionName);
         const health = await rawWorkerClient(dimension, agentName).call("worker/health", {}).catch(() => null);
-        if (health?.protocol !== WORKER_PROTOCOL)
+        if (!health || health.protocol < WORKER_PROTOCOL)
             await reviveWorker(agentName, dimension.name);
         return workerSocketPath(dimension.runDirectory, agentName);
     }
@@ -140,9 +140,10 @@ export function createAgentService(host, { dataDirectory } = {}) {
         install: (agentName, backend) => installScript(host, agentName, backend, controlOptions),
         listBackends: (agentName) => listBackendsScript(host, agentName, controlOptions),
         createSession: async (agentName, session) => (await clientFor(agentName)).call("session/create", { session }),
-        updateSession: async (ref, limits) => (await sessionClient(ref)).call("session/update", { session: ref.sessionName, limits }),
+        updateSession: async (ref, update) => (await sessionClient(ref)).call("session/update", { session: ref.sessionName, update }),
         stopSession: async (ref) => void (await (await sessionClient(ref)).call("session/stop", { session: ref.sessionName })),
         getTranscript,
+        getUsage: async (ref) => (await sessionClient(ref)).call("session/usage", { session: ref.sessionName }),
         cancel: async (ref) => void (await (await sessionClient(ref)).call("session/interrupt", { session: ref.sessionName })),
         sendMessage: async (ref, message) => void (await (await sessionClient(ref)).call("session/send", { session: ref.sessionName, message })),
         getSessionStatus: async (ref) => (await sessionClient(ref)).call("session/status", { session: ref.sessionName }),

package/dist/agent/api.d.ts

@@ -18,6 +18,7 @@ export type AgentSession = {
     env?: Record<string, string>;
 };
 export type AgentSessionLimits = Partial<Pick<AgentSession, "memoryLimit" | "cpuLimit">>;
+export type AgentSessionUpdate = Partial<Omit<AgentSession, "name">>;
 export type AgentSessionState = ({
     readonly state: "exited";
     readonly code: number | null;
@@ -97,7 +98,7 @@ export interface AgentClient {
     stopAgent(agentName: string): Promise<void>;
     listAgents(): Promise<Agent[]>;
     createSession(agentName: string, session: AgentSession): Promise<AgentSessionInfo>;
-    updateSession(ref: SessionRef, limits: AgentSessionLimits): Promise<AgentSessionInfo>;
+    updateSession(ref: SessionRef, update: AgentSessionUpdate): Promise<AgentSessionInfo>;
     listSessions(): Promise<AgentSessionInfo[]>;
     stopSession(ref: SessionRef): Promise<void>;
     restoreAgents(): Promise<string[]>;
@@ -224,7 +225,30 @@ export interface AgentModels {
 export interface AgentPermissionModes {
     setPermissionMode(ref: SessionRef, mode: AgentPermissionMode): Promise<void>;
 }
-export type AgentSessionCapabilities = AgentStream & AgentTranscript & AgentInterrupt & AgentInput & AgentSessionStatus & AgentMessageQueue & AgentPermissions & AgentQuestions & AgentBackgroundTasks & AgentAuth & AgentModels & AgentPermissionModes;
+export type AgentModelUsage = {
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly costUsd: number | null;
+};
+export type AgentTurnUsage = {
+    readonly id: string;
+    readonly startedAt: string;
+    readonly endedAt: string;
+    readonly models: AgentModelUsage[];
+    readonly costUsd: number | null;
+};
+/** @sealed */
+export interface AgentUsage {
+    getUsage(ref: SessionRef): Promise<AgentTurnUsage[]>;
+}
+export type AgentSessionCapabilities = AgentStream & AgentTranscript & AgentInterrupt & AgentInput & AgentSessionStatus & AgentMessageQueue & AgentPermissions & AgentQuestions & AgentBackgroundTasks & AgentAuth & AgentModels & AgentPermissionModes & AgentUsage;
+/** @sealed */
+export interface DimensionAgentClient extends Pick<AgentClient, "createSession" | "updateSession" | "listSessions" | "stopSession">, AgentProvision, AgentSessionCapabilities {
+    listAgents(): Promise<string[]>;
+}
 export type AgentLastUserMessage = {
     readonly message: UserMessage;
     readonly queued: boolean;

package/dist/agent/control.js

@@ -295,7 +295,7 @@ mkdir -p "$RUN"
 exec 8> "$RUN/$AGENT.start.lock"
 flock -w "$((START_TIMEOUT + STOP_TIMEOUT + 30))" 8
 
-if worker_running "$AGENT" && [ "$WORKER_PROTOCOL" = "$PROTOCOL" ] && { [ -z "\${REPLACE_BUILD:-}" ] || [ "$WORKER_BUILD" = "$BUILD" ]; }; then exit 0; fi
+if worker_running "$AGENT" && { [ "$WORKER_PROTOCOL" -gt "$PROTOCOL" ] 2> /dev/null || { [ "$WORKER_PROTOCOL" = "$PROTOCOL" ] && { [ -z "\${REPLACE_BUILD:-}" ] || [ "$WORKER_BUILD" = "$BUILD" ]; }; }; }; then exit 0; fi
 
 runs_as="\${DIMENSION_USER%%:*}"
 SOCKET_OWNER=""

package/dist/agent/dimensionAgentClient.d.ts

@@ -0,0 +1,8 @@
+import { type DimensionAgentClient, type SessionRef } from "./api.ts";
+export type DimensionDirectories = {
+    runDirectory: string;
+    stateDirectory: string;
+};
+export declare function createDimensionAgentClient(): DimensionAgentClient;
+export declare function currentSession(): SessionRef | null;
+export declare function dimensionAgentClient({ runDirectory, stateDirectory }: DimensionDirectories): DimensionAgentClient;

package/dist/agent/dimensionAgentClient.js

@@ -0,0 +1,99 @@
+import { readdir, stat } from "node:fs/promises";
+import { dimensionLayout } from "../dimension/api.js";
+import { InvalidNameError, checkName } from "../lib/jsonDirectory.js";
+import { SandboxConnectionRefusedError } from "../sandbox/api.js";
+import { connectUnixSocket } from "../lib/unixSocket.js";
+import { AgentConflictError, AgentInvalidError, AgentNotFoundError, } from "./api.js";
+import { createWorkerClient } from "./session/client.js";
+import { workerSocketPath } from "./session/sessionStorage.js";
+import { workerStreamConnector } from "./session/workerConnection.js";
+export function createDimensionAgentClient() {
+    return dimensionAgentClient({ runDirectory: dimensionLayout.runPath(), stateDirectory: dimensionLayout.statePath() });
+}
+export function currentSession() {
+    const { HYB_AGENT: agentName, HYB_SESSION: sessionName } = process.env;
+    return agentName && sessionName ? { agentName, sessionName } : null;
+}
+export function dimensionAgentClient({ runDirectory, stateDirectory }) {
+    function connector(agentName) {
+        const socket = workerSocketPath(runDirectory, agentName);
+        const connect = workerStreamConnector(() => connectUnixSocket(socket), socket);
+        return async (onNotification) => {
+            assertValidName("agent", agentName);
+            try {
+                return await connect(onNotification);
+            }
+            catch (error) {
+                if (!(error instanceof SandboxConnectionRefusedError))
+                    throw error;
+                const known = await stat(`${stateDirectory}/agents/${agentName}`).then(() => true, () => false);
+                if (!known)
+                    throw new AgentNotFoundError(`agent ${agentName} does not exist in this dimension`);
+                throw new AgentConflictError(`agent ${agentName}'s worker isn't running; a call through the machine's agents client starts it`);
+            }
+        };
+    }
+    function clientFor(agentName) {
+        return createWorkerClient(connector(agentName));
+    }
+    const sessionClient = ({ agentName }) => clientFor(agentName);
+    async function listAgents() {
+        const entries = await readdir(runDirectory).catch(() => []);
+        const names = entries.filter((entry) => entry.endsWith(".ready") && !entry.startsWith(".")).map((entry) => entry.slice(0, -".ready".length));
+        const running = await Promise.all(names.map((name) => stat(workerSocketPath(runDirectory, name)).then(() => name, () => null)));
+        return running.filter((name) => name !== null).sort();
+    }
+    async function* getStream(ref, request) {
+        yield* sessionClient(ref).stream(ref.sessionName, request.after_id);
+    }
+    async function listSessions() {
+        const listed = await Promise.all((await listAgents()).map((agentName) => clientFor(agentName)
+            .call("session/list", {})
+            .catch((error) => {
+            if (error instanceof AgentConflictError || error instanceof AgentNotFoundError)
+                return [];
+            throw error;
+        })));
+        return listed.flat();
+    }
+    return {
+        listAgents,
+        listSessions,
+        install: async (agentName, backend) => void (await clientFor(agentName).call("backend/install", { backend })),
+        listBackends: (agentName) => clientFor(agentName).call("backend/list", {}),
+        createSession: (agentName, session) => clientFor(agentName).call("session/create", { session }),
+        updateSession: (ref, update) => sessionClient(ref).call("session/update", { session: ref.sessionName, update }),
+        stopSession: async (ref) => void (await sessionClient(ref).call("session/stop", { session: ref.sessionName })),
+        getStream,
+        getTranscript: (ref, { toolUseId, limit, before } = {}) => toolUseId === undefined
+            ? sessionClient(ref).call("session/transcript", { session: ref.sessionName, limit, before })
+            : sessionClient(ref).call("session/subagentTranscript", { session: ref.sessionName, toolUseId, limit, before }),
+        getUsage: (ref) => sessionClient(ref).call("session/usage", { session: ref.sessionName }),
+        cancel: async (ref) => void (await sessionClient(ref).call("session/interrupt", { session: ref.sessionName })),
+        sendMessage: async (ref, message) => void (await sessionClient(ref).call("session/send", { session: ref.sessionName, message })),
+        getSessionStatus: (ref) => sessionClient(ref).call("session/status", { session: ref.sessionName }),
+        getLastUserMessages: (ref) => sessionClient(ref).call("session/lastUserMessages", { session: ref.sessionName }),
+        listPermissionRequests: (ref) => sessionClient(ref).call("permission/list", { session: ref.sessionName }),
+        respondPermissionRequest: async (ref, request, result) => void (await sessionClient(ref).call("permission/respond", { session: ref.sessionName, request, result })),
+        listQuestionRequests: (ref) => sessionClient(ref).call("question/list", { session: ref.sessionName }),
+        respondQuestionRequest: async (ref, request, response) => void (await sessionClient(ref).call("question/respond", { session: ref.sessionName, request, response })),
+        listModels: (ref) => sessionClient(ref).call("model/list", { session: ref.sessionName }),
+        setModel: async (ref, model) => void (await sessionClient(ref).call("model/set", { session: ref.sessionName, model })),
+        setPermissionMode: async (ref, mode) => void (await sessionClient(ref).call("permission/mode", { session: ref.sessionName, mode })),
+        listBackgroundTasks: (ref) => sessionClient(ref).call("task/list", { session: ref.sessionName }),
+        stopTask: async (ref, task) => void (await sessionClient(ref).call("task/stop", { session: ref.sessionName, task })),
+        getAuthStatus: (ref) => sessionClient(ref).call("auth/status", { session: ref.sessionName }),
+        login: (ref) => sessionClient(ref).call("auth/login", { session: ref.sessionName, gatewaySignedIn: false }),
+        submitAuthCode: (ref, code) => sessionClient(ref).call("auth/code", { session: ref.sessionName, code }),
+    };
+}
+function assertValidName(kind, name) {
+    try {
+        checkName(name);
+    }
+    catch (error) {
+        if (error instanceof InvalidNameError)
+            throw new AgentInvalidError(`invalid ${kind} name: ${error.message}`);
+        throw error;
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { AgentBackendInfo, AgentBackgroundTasks, AgentInput, AgentInterrupt, AgentMessageQueue, AgentModels, AgentPermissionMode, AgentPermissionModes, AgentPermissionRequest, AgentPermissionResult, AgentQuestionRequest, AgentQuestionResponse, AgentSession, AgentStreamingMessage, SessionRef } from "../api.ts";
+import type { AgentBackendInfo, AgentBackgroundTasks, AgentInput, AgentInterrupt, AgentMessageQueue, AgentModels, AgentPermissionMode, AgentPermissionModes, AgentPermissionRequest, AgentPermissionResult, AgentQuestionRequest, AgentQuestionResponse, AgentSession, AgentStreamingMessage, AgentTurnUsage, SessionRef } from "../api.ts";
 import type { Transcript, TranscriptFiles } from "./fileTranscript.ts";
 export type ForSession<Capability> = {
     [K in keyof Capability]: Capability[K] extends (ref: SessionRef, ...args: infer Args) => infer Result ? (...args: Args) => Result : never;
@@ -63,5 +63,6 @@ export type SessionBackend = {
     transcript(source: TranscriptSource): Transcript;
     findSubagent(source: TranscriptSource, toolUseId: string): Promise<string | null>;
     subagentTranscript(source: TranscriptSource, subagentId: string, toolUseId: string): Transcript;
+    usage(source: TranscriptSource): Promise<AgentTurnUsage[]>;
     homeEnvironment(home: string): Record<string, string>;
 };

package/dist/agent/session/claude/transcript.d.ts

@@ -4,5 +4,6 @@ import { type FileTranscript, type TranscriptLayout } from "../fileTranscript.ts
 export declare function claudeTranscript({ nativeId, env, files }: TranscriptSource): FileTranscript;
 export declare function claudeSubagentTranscript(source: TranscriptSource, agentId: string, toolUseId: string): FileTranscript;
 export declare function claudeFindSubagent(source: TranscriptSource, toolUseId: string): Promise<string | null>;
+export declare function claudeHome(env: Record<string, string>): string;
 export declare const CLAUDE_TRANSCRIPT_LAYOUT: TranscriptLayout;
 export declare function claudeLineMessages(line: unknown): AgentTranscriptMessage[];

package/dist/agent/session/claude/transcript.js

@@ -31,7 +31,7 @@ async function subagentsDirectory({ nativeId, env, files }) {
     const main = await locateTranscript(files, claudeHome(env), CLAUDE_TRANSCRIPT_LAYOUT, nativeId);
     return main ? `${main.slice(0, -".jsonl".length)}/subagents` : null;
 }
-function claudeHome(env) {
+export function claudeHome(env) {
     return env.CLAUDE_CONFIG_DIR ?? `${env.HOME}/.claude`;
 }
 const SUBAGENT_FILE = /^agent-.+\.jsonl$/;

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

@@ -1,4 +1,4 @@
-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 AgentAuthStatus, type AgentBackend, type AgentBackendInfo, type AgentBackgroundTask, type AgentLastUserMessage, type AgentModelInfo, type AgentPermissionRequest, type AgentPermissionResult, type AgentQuestionRequest, type AgentQuestionResponse, type AgentSession, type AgentSessionInfo, type AgentSessionUpdate, type AgentSessionState, type AgentPermissionMode, type AgentStreamingMessage, type AgentTranscriptPage, type AgentTurnUsage, type UserMessage } from "../../api.ts";
 import type { JsonRpcErrorObject } from "./jsonRpc.ts";
 /** @sealed */
 export type WorkerRequests = {
@@ -14,7 +14,7 @@ export type WorkerRequests = {
     "session/list": [Record<string, never>, AgentSessionInfo[]];
     "session/update": [{
         session: string;
-        limits: AgentSessionLimits;
+        update: AgentSessionUpdate;
     }, AgentSessionInfo];
     "session/stop": [{
         session: string;
@@ -52,6 +52,9 @@ export type WorkerRequests = {
         limit?: number;
         before?: string;
     }, AgentTranscriptPage];
+    "session/usage": [{
+        session: string;
+    }, AgentTurnUsage[]];
     "permission/list": [{
         session: string;
     }, AgentPermissionRequest[]];
@@ -105,7 +108,7 @@ export type WorkerNotifications = {
         message: AgentStreamingMessage;
     };
 };
-export declare const WORKER_PROTOCOL = 3;
+export declare const WORKER_PROTOCOL = 6;
 export type WorkerHealth = {
     agentName: string;
     build: string;

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

@@ -1,5 +1,5 @@
 import { AgentBackendNotInstalledError, AgentConflictError, AgentInvalidError, AgentNotFoundError, } from "../../api.js";
-export const WORKER_PROTOCOL = 3;
+export const WORKER_PROTOCOL = 6;
 export const WorkerErrorCode = {
     methodNotFound: -32601,
     invalidParams: -32602,

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

@@ -6,7 +6,7 @@ export const WORKER_PARAMS = {
     "backend/list": () => ({}),
     "session/create": (params) => ({ session: session(object(params.session, "session")) }),
     "session/list": () => ({}),
-    "session/update": (params) => ({ session: name(params), limits: limits(object(params.limits, "limits")) }),
+    "session/update": (params) => ({ session: name(params), update: sessionUpdate(object(params.update, "update")) }),
     "session/stop": (params) => ({ session: name(params) }),
     "session/send": (params) => ({ session: name(params), message: userMessage(params.message) }),
     "session/interrupt": (params) => ({ session: name(params) }),
@@ -29,6 +29,7 @@ export const WORKER_PARAMS = {
         limit: optional(params.limit, (value) => number(value, "limit")),
         before: optional(params.before, (value) => text(value, "before")),
     }),
+    "session/usage": (params) => ({ session: name(params) }),
     "permission/list": (params) => ({ session: name(params) }),
     "permission/respond": (params) => ({
         session: name(params),
@@ -126,8 +127,14 @@ function session(fields) {
         env: optional(fields.env, environment),
     };
 }
-function limits(fields) {
-    return { memoryLimit: optional(fields.memoryLimit, memoryLimit), cpuLimit: optional(fields.cpuLimit, cpuLimit) };
+function sessionUpdate(fields) {
+    return {
+        backend: optional(fields.backend, backend),
+        memoryLimit: optional(fields.memoryLimit, memoryLimit),
+        cpuLimit: optional(fields.cpuLimit, cpuLimit),
+        cwd: optional(fields.cwd, (value) => text(value, "cwd")),
+        env: optional(fields.env, environment),
+    };
 }
 function userMessage(value) {
     const fields = object(value, "a message (an SDK user message: {type: \"user\", message})");

package/dist/agent/vendor-types/manifest.json

@@ -3,7 +3,7 @@
         "docs": "https://code.claude.com/docs/en/agent-sdk/typescript",
         "sources": [
             {
-                "source": "npm:@anthropic-ai/claude-agent-sdk@0.3.283",
+                "source": "npm:@anthropic-ai/claude-agent-sdk@0.3.310",
                 "into": "agent-sdk",
                 "files": 7
             }
@@ -13,75 +13,20 @@
         "docs": "https://developers.openai.com/codex/app-server",
         "sources": [
             {
-                "source": "npm:@openai/codex-sdk@0.157.1",
+                "source": "npm:@openai/codex-sdk@0.164.0",
                 "into": "sdk",
                 "files": 1
             },
             {
-                "source": "github:openai/codex@rust-v0.157.1/codex-rs/app-server-protocol/schema/typescript",
+                "source": "github:openai/codex@rust-v0.164.0/codex-rs/app-server-protocol/schema/typescript",
                 "into": "app-server",
-                "files": 740
+                "files": 751
             },
             {
-                "source": "github:openai/codex@rust-v0.157.1/codex-rs/app-server-protocol/schema/json",
+                "source": "github:openai/codex@rust-v0.164.0/codex-rs/app-server-protocol/schema/json",
                 "into": "app-server-json",
                 "files": 2
             }
         ]
-    },
-    "pi": {
-        "docs": "https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/rpc.md",
-        "sources": [
-            {
-                "source": "npm:@mariozechner/pi-coding-agent@0.73.1",
-                "into": "coding-agent",
-                "files": 137
-            },
-            {
-                "source": "npm:@mariozechner/pi-agent-core@0.73.1",
-                "into": "agent-core",
-                "files": 5
-            },
-            {
-                "source": "npm:@mariozechner/pi-ai@0.73.1",
-                "into": "ai",
-                "files": 44
-            }
-        ]
-    },
-    "opencode": {
-        "docs": "https://opencode.ai/docs/server",
-        "sources": [
-            {
-                "source": "npm:@opencode-ai/sdk@1.18.32",
-                "into": "sdk",
-                "files": 39
-            },
-            {
-                "source": "github:anomalyco/opencode@v1.18.32/packages/sdk",
-                "into": "",
-                "files": 1
-            }
-        ]
-    },
-    "openclaw": {
-        "docs": "https://docs.openclaw.ai/gateway/protocol",
-        "sources": [
-            {
-                "source": "npm:@openclaw/gateway-protocol@2026.9.6",
-                "into": "gateway-protocol",
-                "files": 17
-            }
-        ]
-    },
-    "hermes": {
-        "docs": "https://hermes-agent.nousresearch.com/docs",
-        "sources": [
-            {
-                "source": "github:NousResearch/hermes-agent@v2026.9.24/apps/shared/src",
-                "into": "gateway",
-                "files": 3
-            }
-        ]
     }
 }