hyperbrane 0.1.2 → 0.2.1

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 AgentSessionUpdate, type AgentSessionState, type AgentPermissionMode, type AgentStreamingMessage, type AgentTranscriptPage, type AgentTurnUsage, 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;
@@ -22,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;
@@ -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,15 @@ export type WorkerRequests = {
         before?: string;
         cursor?: string;
     }, AgentTranscriptPage];
+    "session/subagentTranscript": [{
+        session: string;
+        toolUseId: string;
+        limit?: number;
+        before?: string;
+    }, AgentTranscriptPage];
+    "session/usage": [{
+        session: string;
+    }, AgentTurnUsage[]];
     "permission/list": [{
         session: string;
     }, AgentPermissionRequest[]];
@@ -76,7 +71,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 +78,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 +92,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 +108,26 @@ export type WorkerNotifications = {
         message: AgentStreamingMessage;
     };
 };
+export declare const WORKER_PROTOCOL = 6;
 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 = 6;
+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": () => ({}),
@@ -11,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) }),
@@ -26,9 +21,15 @@ 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")),
+    }),
+    "session/usage": (params) => ({ session: name(params) }),
     "permission/list": (params) => ({ session: name(params) }),
     "permission/respond": (params) => ({
         session: name(params),
@@ -46,6 +47,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 +66,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 +86,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 +102,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 +115,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) {
@@ -124,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})");
@@ -136,7 +145,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 +166,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;

package/dist/agent/session/workerConnection.js

@@ -1,44 +1,39 @@
 import { createJsonRpcPeer } from "./worker/jsonRpc.js";
-import { WorkerMethodNotFoundError, decodeWorkerError, encodeWorkerError, } from "./worker/protocol.js";
-/** A connection speaking JSON-RPC over `transport` (`label` says where to, in errors). */
+import { WORKER_PROTOCOL, WorkerMethodNotFoundError, decodeWorkerError, encodeWorkerError, } from "./worker/protocol.js";
 export function workerConnectionOver(transport, label, onNotification) {
     let peer;
     transport.onText((text) => peer?.receive(text));
     const closed = transport.closed.then(() => peer?.close(new Error(`the worker at ${label} closed the connection`)));
     peer = createJsonRpcPeer((text) => transport.write(text), {
-        // The worker makes no requests of its clients.
         onRequest: async (method) => {
             throw new WorkerMethodNotFoundError(`no method ${method}`);
         },
-        // type-bypass: notifications arrive as JSON; the worker only sends those in WorkerNotifications.
         onNotification: (method, params) => onNotification?.(method, params),
+        protocol: WORKER_PROTOCOL,
         encodeError: encodeWorkerError,
         decodeError: decodeWorkerError,
     });
     const connected = peer;
     return {
-        // type-bypass: the result is the one WorkerRequests pairs with this method.
         request: (method, params) => connected.request(method, params),
         closed,
         close: () => transport.close(),
     };
 }
-/**
- * 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 function workerSocketConnector(host, socketPath) {
+    return workerStreamConnector(() => host.connect(socketPath), socketPath);
+}
+export function workerStreamConnector(open, label) {
     return async (onNotification) => {
         const decoder = new TextDecoder();
         const encoder = new TextEncoder();
-        const socket = await host.connect(socketPath);
+        const socket = await open();
         const transport = {
             write: (text) => socket.write(encoder.encode(text)),
             onText: (listener) => socket.onData((data) => listener(decoder.decode(data, { stream: true }))),
             closed: socket.closed,
             close: () => socket.close(),
         };
-        return workerConnectionOver(transport, socketPath, onNotification);
+        return workerConnectionOver(transport, label, onNotification);
     };
 }

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

@@ -0,0 +1,18 @@
+import type { SandboxAccess } from "../../sandbox/api.ts";
+import { type ConnectWorker } from "./workerConnection.ts";
+export declare class EndpointUnreachableError extends Error {
+    readonly url: string;
+    name: string;
+    constructor(url: string, cause?: unknown);
+}
+export declare class EndpointCredentialsError extends Error {
+    readonly url: string;
+    name: string;
+    constructor(url: string);
+}
+export declare function workerGatewayConnector(endpoint: SandboxAccess, { dimensionName, agentName, }: {
+    dimensionName: string;
+    agentName: string;
+}, { signal, }?: {
+    signal?: AbortSignal;
+}): ConnectWorker;

package/dist/agent/session/workerGatewayConnection.js

@@ -0,0 +1,86 @@
+import { EventSourceParserStream } from "eventsource-parser/stream";
+import { AgentNotFoundError } from "../api.js";
+import { workerConnectionOver } from "./workerConnection.js";
+const TOKEN_PARAM = "hyb_token";
+export class EndpointUnreachableError extends Error {
+    url;
+    name = "EndpointUnreachableError";
+    constructor(url, cause) {
+        super(`the gateway ${url} didn't answer (a browser reports this as a CORS error): the machine is unreachable, or the gateway isn't running`, { cause });
+        this.url = url;
+    }
+}
+export class EndpointCredentialsError extends Error {
+    url;
+    name = "EndpointCredentialsError";
+    constructor(url) {
+        super(`the gateway ${url} refused the credentials: they expired, or aren't its own; get new ones`);
+        this.url = url;
+    }
+}
+export function workerGatewayConnector(endpoint, { dimensionName, agentName, }, { signal, } = {}) {
+    const { exeDev, token } = endpoint.credentials;
+    const headers = exeDev ? { "x-exedev-authorization": `Bearer ${exeDev.token}` } : {};
+    const url = (path, params = {}) => `${endpoint.url}${path}?${new URLSearchParams({ ...params, [TOKEN_PARAM]: token })}`;
+    const label = `agent ${agentName}'s worker through ${endpoint.url}`;
+    return async (onNotification) => {
+        signal?.throwIfAborted();
+        const aborting = new AbortController();
+        signal?.addEventListener("abort", () => aborting.abort(), { once: true });
+        let response;
+        try {
+            response = await fetch(url("/connect", { dimension: dimensionName, agent: agentName }), { headers, signal: aborting.signal });
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            throw new EndpointUnreachableError(endpoint.url, error);
+        }
+        if (response.status === 401)
+            throw new EndpointCredentialsError(endpoint.url);
+        if (response.status === 502)
+            throw new AgentNotFoundError(`${label} can't be reached: ${(await response.text()).trim()}`);
+        if (!response.ok || !response.body)
+            throw new Error(`${label}: the gateway answered ${response.status}: ${(await response.text()).trim()}`);
+        const events = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).getReader();
+        const opened = await events.read();
+        if (opened.done || opened.value.event !== "open")
+            throw new Error(`${label}: the gateway's stream didn't open`);
+        const { connection } = JSON.parse(opened.value.data);
+        const listeners = [];
+        let markClosed;
+        const closed = new Promise((done) => (markClosed = done));
+        void (async () => {
+            try {
+                for (;;) {
+                    const { value, done } = await events.read();
+                    if (done || value.event === "close")
+                        break;
+                    for (const listener of listeners)
+                        listener(`${value.data}\n`);
+                }
+            }
+            catch {
+                return;
+            }
+            finally {
+                markClosed();
+            }
+        })();
+        let writes = Promise.resolve();
+        const transport = {
+            write(text) {
+                if (aborting.signal.aborted)
+                    return;
+                writes = writes.then(() => fetch(url(`/connect/${connection}`), { method: "POST", headers, body: text, signal: aborting.signal }).then((response) => {
+                    if (!response.ok)
+                        aborting.abort();
+                }, () => aborting.abort()));
+            },
+            onText: (listener) => void listeners.push(listener),
+            closed,
+            close: () => aborting.abort(),
+        };
+        return workerConnectionOver(transport, label, onNotification);
+    };
+}

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

@@ -0,0 +1,32 @@
+{
+    "claude": {
+        "docs": "https://code.claude.com/docs/en/agent-sdk/typescript",
+        "sources": [
+            {
+                "source": "npm:@anthropic-ai/claude-agent-sdk@0.3.310",
+                "into": "agent-sdk",
+                "files": 7
+            }
+        ]
+    },
+    "codex": {
+        "docs": "https://developers.openai.com/codex/app-server",
+        "sources": [
+            {
+                "source": "npm:@openai/codex-sdk@0.164.0",
+                "into": "sdk",
+                "files": 1
+            },
+            {
+                "source": "github:openai/codex@rust-v0.164.0/codex-rs/app-server-protocol/schema/typescript",
+                "into": "app-server",
+                "files": 751
+            },
+            {
+                "source": "github:openai/codex@rust-v0.164.0/codex-rs/app-server-protocol/schema/json",
+                "into": "app-server-json",
+                "files": 2
+            }
+        ]
+    }
+}

package/dist/agent/workerBundle.d.ts

@@ -1,19 +1,4 @@
-/**
- * The session worker (agent/session/main.ts and all it imports) as the one script AgentService
- * uploads into a dimension and runs with bun. The backends' own packages aren't part of it: the
- * worker installs them into the dimension and loads them from there.
- */
-export type WorkerBundle = {
-    /** The worker as one script for bun. */
-    source: string;
-    /** Identifies the source: a running worker with another build is replaced. */
-    build: string;
-};
-/**
- * The worker, once per process. Under Bun with the sources at hand (a checkout) it is bundled from
- * them; otherwise (Node, or the built package, which ships no sources) it comes from
- * agent/workerBundle.generated.ts (scripts/bundle-worker.ts).
- */
-export declare function workerBundle(): Promise<WorkerBundle>;
-/** Bundles the worker with Bun.build. */
-export declare function buildWorkerSource(): Promise<string>;
+import { type ScriptBundle } from "../lib/scriptBundle.ts";
+export type WorkerBundle = ScriptBundle;
+export declare const workerEntry: () => string;
+export declare const workerBundle: () => Promise<ScriptBundle>;