@tangle-network/agent-provider-cli-bridge 2.0.5 → 2.0.7

package/README.md

@@ -200,6 +200,7 @@ The endpoint holds only a scheme, a host, and an explicit port; userinfo, path,
 
 `@tangle-network/agent-provider-cli-bridge/sandbox` turns a vendor sandbox that runs CLI Bridge into an `AgentEnvironmentProvider`.
 The vendor adapter implements `BridgeSandboxVendor`: `create`, `connect`, `list`, and per sandbox `exec`, `spawn`, `read`, `write`, `endpoint`, `status` and `destroy`.
+A vendor whose command call runs to completion, as Daytona's and computesdk's do, builds `exec` from `markedExec` and `spawn` from `envFileLaunch`.
 `createBridgeSandboxProvider({ vendor, router: { key } })` does the rest:
 
 - It refuses every create field the vendor cannot honor with an `EnvironmentProviderError` that names the field, before any vendor call, and validates the profile with the materializer the Bridge in the box uses.

package/dist/sandbox/checkpoint.d.ts

@@ -0,0 +1,26 @@
+import { type CheckpointRef, type CheckpointRequest, type CreateAgentEnvironmentInput, type ForkRequest } from "@tangle-network/agent-interface/environment-provider";
+import type { BridgeSandboxVendor, BridgeVendorSnapshots } from "./vendor.js";
+/**
+ * Vendor-snapshot checkpointing: the portable seam between the optional
+ * `AgentEnvironment.checkpoint`/`fork` surface and a vendor's snapshot
+ * lifecycle. A vendor without {@link BridgeVendorSnapshots} refuses both,
+ * exactly as it refuses every capability it cannot honor.
+ */
+/** The vendor snapshot lifecycle, or a refusal naming the vendor. */
+export declare function vendorSnapshots(vendor: BridgeSandboxVendor): BridgeVendorSnapshots;
+/** A checkpoint name that cannot collide with a caller-chosen vendor snapshot name. */
+export declare function checkpointSnapshotName(name: string | undefined): string;
+/** Snapshot one running sandbox and return the portable checkpoint reference. */
+export declare function createVendorSnapshot(vendor: BridgeSandboxVendor, sandboxId: string, options?: CheckpointRequest & {
+    signal?: AbortSignal;
+}): Promise<CheckpointRef>;
+/** A fork must restore this vendor's snapshot; a foreign checkpoint reference is refused. */
+export declare function assertForkableCheckpoint(ref: CheckpointRef, vendorName: string): void;
+/**
+ * The create input a fork runs with: the source environment's input, minus
+ * everything the snapshot already carries. A repository clone would overwrite
+ * the snapshot's workspace, and a caller-chosen environment would boot a
+ * different image than the checkpoint captured; both are dropped, while the
+ * requested working directory keeps its placement.
+ */
+export declare function forkCreateInput(source: CreateAgentEnvironmentInput, request?: ForkRequest): CreateAgentEnvironmentInput;

package/dist/sandbox/checkpoint.js

@@ -0,0 +1,82 @@
+import { randomUUID } from "node:crypto";
+import { EnvironmentProviderError, } from "@tangle-network/agent-interface/environment-provider";
+/**
+ * Vendor-snapshot checkpointing: the portable seam between the optional
+ * `AgentEnvironment.checkpoint`/`fork` surface and a vendor's snapshot
+ * lifecycle. A vendor without {@link BridgeVendorSnapshots} refuses both,
+ * exactly as it refuses every capability it cannot honor.
+ */
+/** The vendor snapshot lifecycle, or a refusal naming the vendor. */
+export function vendorSnapshots(vendor) {
+    if (vendor.snapshots === undefined) {
+        throw new EnvironmentProviderError("refused", `vendor ${vendor.name} exposes no snapshot lifecycle`, { provider: vendor.name });
+    }
+    return vendor.snapshots;
+}
+/** Snapshot metadata must be string-valued, exactly like vendor sandbox tags. */
+function snapshotMetadata(metadata, provider) {
+    if (metadata === undefined)
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (typeof value !== "string") {
+            throw new EnvironmentProviderError("refused", `snapshot metadata holds string values; ${key} is not a string`, { path: `metadata.${key}`, provider });
+        }
+        out[key] = value;
+    }
+    return out;
+}
+/** A checkpoint name that cannot collide with a caller-chosen vendor snapshot name. */
+export function checkpointSnapshotName(name) {
+    return name ?? `tangle-ckpt-${randomUUID()}`;
+}
+/** Snapshot one running sandbox and return the portable checkpoint reference. */
+export async function createVendorSnapshot(vendor, sandboxId, options) {
+    const snapshots = vendorSnapshots(vendor);
+    const request = options === undefined
+        ? {}
+        : {
+            ...(options.name === undefined ? {} : { name: options.name }),
+            ...(options.metadata === undefined ? {} : { metadata: snapshotMetadata(options.metadata, vendor.name) }),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        };
+    const record = await snapshots.create(sandboxId, Object.keys(request).length === 0 ? undefined : request);
+    if (typeof record.id !== "string" || record.id.length === 0) {
+        throw new EnvironmentProviderError("provision_failed", `vendor ${vendor.name} returned no snapshot id for ${sandboxId}`, { provider: vendor.name });
+    }
+    return {
+        id: record.id,
+        provider: vendor.name,
+        ...(record.createdAt === undefined ? {} : { metadata: { createdAt: record.createdAt } }),
+    };
+}
+/** A fork must restore this vendor's snapshot; a foreign checkpoint reference is refused. */
+export function assertForkableCheckpoint(ref, vendorName) {
+    if (typeof ref.id !== "string" || ref.id.length === 0) {
+        throw new EnvironmentProviderError("invalid_input", "a checkpoint reference carries a non-empty id", { path: "checkpoint.id", provider: vendorName });
+    }
+    if (ref.provider !== undefined && ref.provider !== vendorName) {
+        throw new EnvironmentProviderError("refused", `checkpoint from provider ${ref.provider} cannot restore on ${vendorName}`, { path: "checkpoint.provider", provider: vendorName });
+    }
+}
+/**
+ * The create input a fork runs with: the source environment's input, minus
+ * everything the snapshot already carries. A repository clone would overwrite
+ * the snapshot's workspace, and a caller-chosen environment would boot a
+ * different image than the checkpoint captured; both are dropped, while the
+ * requested working directory keeps its placement.
+ */
+export function forkCreateInput(source, request) {
+    const { workspace, name, metadata, signal, ...rest } = source;
+    const cwd = workspace?.cwd;
+    return {
+        ...rest,
+        ...(request?.name === undefined
+            ? (name === undefined ? {} : { name })
+            : { name: request.name }),
+        ...(metadata === undefined && request?.metadata === undefined
+            ? {}
+            : { metadata: { ...metadata, ...request?.metadata } }),
+        ...(cwd === undefined ? {} : { workspace: { cwd } }),
+    };
+}

package/dist/sandbox/image.d.ts

@@ -4,6 +4,8 @@ import type { HarnessType } from "@tangle-network/agent-interface";
  *
  * Every cloud builds from this text: E2B and Daytona build their template and
  * image from it, and a local Docker build of it is the same box. Harness
- * versions come from the registry that owns the pins.
+ * versions come from the registry that owns the pins. `baseImage` overrides
+ * the Node base for a box that carries more than the pins; the install layer
+ * is unchanged, so every box keeps the same Bridge and harness versions.
  */
-export declare function renderBoxDockerfile(harnesses?: readonly HarnessType[]): string;
+export declare function renderBoxDockerfile(harnesses?: readonly HarnessType[], baseImage?: string): string;

package/dist/sandbox/image.js

@@ -4,9 +4,11 @@ import { BOX_HARNESSES, BOX_HOME, BOX_NODE_IMAGE, BOX_PINS, BOX_WORKSPACE_DIR, b
  *
  * Every cloud builds from this text: E2B and Daytona build their template and
  * image from it, and a local Docker build of it is the same box. Harness
- * versions come from the registry that owns the pins.
+ * versions come from the registry that owns the pins. `baseImage` overrides
+ * the Node base for a box that carries more than the pins; the install layer
+ * is unchanged, so every box keeps the same Bridge and harness versions.
  */
-export function renderBoxDockerfile(harnesses = Object.keys(BOX_HARNESSES)) {
+export function renderBoxDockerfile(harnesses = Object.keys(BOX_HARNESSES), baseImage = BOX_NODE_IMAGE) {
     const installs = harnesses.map((name) => {
         const entry = BOX_HARNESSES[name];
         if (entry === undefined)
@@ -17,7 +19,7 @@ export function renderBoxDockerfile(harnesses = Object.keys(BOX_HARNESSES)) {
     const packages = installs.map(({ entry, version }) => `${entry.npmPackage}@${version}`);
     const probes = installs.map(({ entry, version }) => `test "$(${entry.bin} --version | cut -d' ' -f1)" = "${version}"`);
     return [
-        `FROM ${BOX_NODE_IMAGE}`,
+        `FROM ${baseImage}`,
         "RUN apt-get update && apt-get install -y --no-install-recommends git curl ca-certificates python3 make g++ ripgrep procps \\",
         "    && rm -rf /var/lib/apt/lists/*",
         `RUN npm install -g ${[...packages, bridge].join(" ")} \\`,

package/dist/sandbox/index.d.ts

@@ -1,6 +1,8 @@
 export { createBridgeSandboxProvider, BRIDGE_RUN_TAG } from "./provider.js";
 export type { BridgeSandboxProviderOptions } from "./provider.js";
-export type { BridgeSandbox, BridgeSandboxCreateRequest, BridgeSandboxSummary, BridgeSandboxVendor, BridgeVendorSupport, } from "./vendor.js";
+export type { BridgeSandbox, BridgeSandboxCreateRequest, BridgeSandboxSummary, BridgeSandboxVendor, BridgeVendorSnapshot, BridgeVendorSnapshots, BridgeVendorSupport, } from "./vendor.js";
+export { checkpointSnapshotName } from "./checkpoint.js";
 export { validateBoxProfile } from "./refusal.js";
+export { envFileLaunch, markedExec, untilAborted } from "./shell.js";
 export { BOX_HARNESSES, BOX_HOME, BOX_PINS, BOX_TEMPLATE_NAME, BOX_WORKSPACE_DIR, BRIDGE_PORT, boxHarnessVersion, } from "./box.js";
 export { renderBoxDockerfile } from "./image.js";

package/dist/sandbox/index.js

@@ -1,4 +1,6 @@
 export { createBridgeSandboxProvider, BRIDGE_RUN_TAG } from "./provider.js";
+export { checkpointSnapshotName } from "./checkpoint.js";
 export { validateBoxProfile } from "./refusal.js";
+export { envFileLaunch, markedExec, untilAborted } from "./shell.js";
 export { BOX_HARNESSES, BOX_HOME, BOX_PINS, BOX_TEMPLATE_NAME, BOX_WORKSPACE_DIR, BRIDGE_PORT, boxHarnessVersion, } from "./box.js";
 export { renderBoxDockerfile } from "./image.js";

package/dist/sandbox/provider.js

@@ -3,10 +3,12 @@ import { posix } from "node:path";
 import { Agent, fetch as undiciFetch } from "undici";
 import { canonicalAgentProfileDigest, TANGLE_ROUTER_DEFAULT_ROOT_URL, } from "@tangle-network/agent-interface";
 import { AgentEnvironmentGetOptionsSchema, AgentTurnInputSchema, EnvironmentProviderError, } from "@tangle-network/agent-interface/environment-provider";
+import { shellQuote } from "@tangle-network/agent-core/node";
 import { harnessModelSupportFor } from "@tangle-network/cli-agent-registry";
 import { createCliBridgeProvider, defaultCliBridgeCapabilities } from "../index.js";
 import { BOX_WORKSPACE_DIR, BRIDGE_PORT, BRIDGE_START_COMMAND, bridgeProcessEnv, boxHarness, boxHarnessVersion, } from "./box.js";
 import { assertProfileValid, declarableHarnesses, plannerLowers, refuseUnsupportedCreateInput, resolveBoxHarness, validateBoxProfile } from "./refusal.js";
+import { assertForkableCheckpoint, createVendorSnapshot, forkCreateInput, } from "./checkpoint.js";
 export const BRIDGE_RUN_TAG = "tangle-bridge-run";
 const DEFAULT_LIFETIME_MS = 2 * 60 * 60 * 1000;
 const DEFAULT_READY_TIMEOUT_MS = 120_000;
@@ -35,9 +37,12 @@ export function createBridgeSandboxProvider(options) {
     const lifetimeMs = options.lifetimeMs ?? DEFAULT_LIFETIME_MS;
     const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
     const providerCapabilities = (harness) => environmentCapabilities(defaultCliBridgeCapabilities(harness), vendor, harness === undefined ? false : plannerLowers(harness, "hooks"));
-    async function create(input) {
+    async function create(input, restore) {
         input.signal?.throwIfAborted();
         refuseUnsupportedCreateInput(input, vendor.support);
+        if (restore !== undefined && input.workspace?.environment !== undefined) {
+            throw new EnvironmentProviderError("refused", "a fork restores its checkpoint; workspace.environment names a different one", { path: "workspace.environment" });
+        }
         const profile = input.profile;
         const validation = validateBoxProfile(profile, input.backend, declared);
         assertProfileValid(validation);
@@ -57,6 +62,7 @@ export function createBridgeSandboxProvider(options) {
                 env: input.env ?? {},
                 lifetimeMs,
                 ...(input.workspace?.environment === undefined ? {} : { environment: input.workspace.environment }),
+                ...(restore === undefined ? {} : { snapshot: restore.snapshot }),
                 ...(input.workspace?.image === undefined ? {} : { image: input.workspace.image }),
                 ...(input.resources === undefined ? {} : { resources: input.resources }),
                 ...(input.egress === undefined ? {} : { egress: egressFor(input, routerBaseUrl) }),
@@ -88,7 +94,8 @@ export function createBridgeSandboxProvider(options) {
                 workspace: { cwd: { base: "host", path: workspaceDir } },
             });
             input.signal?.throwIfAborted();
-            return wrapEnvironment({ inner, sandbox, vendor, harness, profile, workspaceDir, dispatcher, capabilities: environmentCapabilities(inner.capabilities ?? providerCapabilities(harness), vendor, plannerLowers(harness, "hooks")), input });
+            const forkFromCheckpoint = vendor.snapshots === undefined ? undefined : (checkpoint, request, signal) => create({ ...forkCreateInput(input, request), ...(signal === undefined ? {} : { signal }) }, { snapshot: checkpoint.id });
+            return wrapEnvironment({ inner, sandbox, vendor, harness, profile, workspaceDir, dispatcher, capabilities: environmentCapabilities(inner.capabilities ?? providerCapabilities(harness), vendor, plannerLowers(harness, "hooks")), input, ...(forkFromCheckpoint === undefined ? {} : { forkFromCheckpoint }) });
         }
         catch (error) {
             await dispatcher?.close().catch(() => undefined);
@@ -214,12 +221,11 @@ async function cloneRepository(sandbox, input, secrets) {
     if (repoUrl === undefined)
         return;
     const gitRef = input.workspace?.gitRef;
-    const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
     const command = [
-        `rm -rf ${quote(BOX_WORKSPACE_DIR)}/.git`,
-        `git clone ${quote(repoUrl)} ${quote(BOX_WORKSPACE_DIR)}.clone`,
-        ...(gitRef === undefined ? [] : [`git -C ${quote(BOX_WORKSPACE_DIR)}.clone checkout ${quote(gitRef)}`]),
-        `cp -a ${quote(BOX_WORKSPACE_DIR)}.clone/. ${quote(BOX_WORKSPACE_DIR)}/ && rm -rf ${quote(BOX_WORKSPACE_DIR)}.clone`,
+        `rm -rf ${shellQuote(BOX_WORKSPACE_DIR)}/.git`,
+        `git clone ${shellQuote(repoUrl)} ${shellQuote(BOX_WORKSPACE_DIR)}.clone`,
+        ...(gitRef === undefined ? [] : [`git -C ${shellQuote(BOX_WORKSPACE_DIR)}.clone checkout ${shellQuote(gitRef)}`]),
+        `cp -a ${shellQuote(BOX_WORKSPACE_DIR)}.clone/. ${shellQuote(BOX_WORKSPACE_DIR)}/ && rm -rf ${shellQuote(BOX_WORKSPACE_DIR)}.clone`,
     ].join(" && ");
     const result = await sandbox.exec(command, { timeoutMs: 600_000, ...signalOption(input.signal) });
     if (result.exitCode !== 0) {
@@ -227,7 +233,7 @@ async function cloneRepository(sandbox, input, secrets) {
     }
 }
 async function ensureDirectory(sandbox, directory) {
-    const result = await sandbox.exec(`mkdir -p '${directory.replace(/'/g, `'\\''`)}'`, { timeoutMs: 30_000 });
+    const result = await sandbox.exec(`mkdir -p ${shellQuote(directory)}`, { timeoutMs: 30_000 });
     if (result.exitCode !== 0) {
         throw new EnvironmentProviderError("provision_failed", `cannot create workspace directory ${directory}: ${result.stderr.trim().slice(0, 200)}`, { path: "workspace.cwd" });
     }
@@ -264,10 +270,12 @@ function environmentCapabilities(bridge, vendor, hooks) {
         ...base,
         profile: { ...base.profile, validation: true, hooks: hooks === true },
         workspace: { read: true, write: true, exec: true, git: false, upload: false, download: false, cwdBases: { repository: true, host: false } },
+        branching: { checkpoint: vendor.snapshots !== undefined, fork: vendor.snapshots !== undefined },
         placement: true,
         create: {
             durableIdempotency: false,
             ...(vendor.support.egress.length === 0 ? {} : { egress: [...vendor.support.egress] }),
+            ...(vendor.snapshots === undefined ? {} : { workspaceSnapshot: false }),
         },
     };
 }
@@ -348,6 +356,14 @@ function wrapEnvironment(args) {
         status: operations.status,
         stream: exclusive,
         ...(inner.session === undefined ? {} : { session: (id, options) => inner.session(id, options) }),
+        ...(vendor.snapshots === undefined ? {} : {
+            checkpoint: (options) => createVendorSnapshot(vendor, sandbox.id, options),
+            fork: async (checkpoint, options) => {
+                assertForkableCheckpoint(checkpoint, vendor.name);
+                const { signal, ...request } = options ?? {};
+                return args.forkFromCheckpoint(checkpoint, Object.keys(request).length === 0 ? undefined : request, signal);
+            },
+        }),
         ...(inner.dispatch === undefined
             ? {}
             : {

package/dist/sandbox/shell.d.ts

@@ -0,0 +1,16 @@
+import { type ExecRequest, type ExecResult } from "@tangle-network/agent-interface/environment-provider";
+/** Exec over a run-to-completion command call: a timeout or abort kills every process carrying the exec's marker, so the remote work stops too. */
+export declare function markedExec(command: string, options: ExecRequest | undefined, provider: string, run: (script: string, signal: AbortSignal) => Promise<ExecResult>): Promise<ExecResult>;
+/** The Bridge's credentials go to a file in a directory only the box user can open, sourced and deleted before exec, so no value enters an argv. */
+export declare function envFileLaunch(command: string, { cwd, env }: {
+    cwd?: string;
+    env: Record<string, string>;
+}): {
+    prepare: string;
+    file: string;
+    content: string;
+    launch: string;
+    cleanup: string;
+};
+/** For an SDK that takes no AbortSignal: an abort settles the call at once, and `late` receives a result that arrives afterwards. */
+export declare function untilAborted<T>(pending: Promise<T>, signal: AbortSignal | undefined, late?: (value: T) => Promise<unknown>): Promise<T>;

package/dist/sandbox/shell.js

@@ -0,0 +1,50 @@
+import { randomBytes } from "node:crypto";
+import { shellQuote } from "@tangle-network/agent-core/node";
+import { EnvironmentProviderError } from "@tangle-network/agent-interface/environment-provider";
+/** Exec over a run-to-completion command call: a timeout or abort kills every process carrying the exec's marker, so the remote work stops too. */
+export async function markedExec(command, options, provider, run) {
+    options?.signal?.throwIfAborted();
+    const marker = randomBytes(6).toString("hex");
+    const env = Object.entries(options?.env ?? {}).map(([key, value]) => `export ${key}=${shellQuote(value)}; `).join("");
+    const ended = new AbortController();
+    const timer = options?.timeoutMs === undefined ? undefined : setTimeout(() => ended.abort(new EnvironmentProviderError("timeout", `exec exceeded ${options.timeoutMs} ms`, { provider })), options.timeoutMs);
+    const signal = options?.signal === undefined ? ended.signal : AbortSignal.any([options.signal, ended.signal]);
+    try {
+        return await run(`export TBOX_EXEC=${marker}; ${env}${options?.cwd === undefined ? "" : `cd ${shellQuote(options.cwd)} && `}${command}`, signal);
+    }
+    catch (error) {
+        if (signal.aborted)
+            await run(`for p in /proc/[0-9]*; do grep -qz 'TBOX_EXEC=${marker}' "$p/environ" 2>/dev/null && kill -9 "\${p#/proc/}" 2>/dev/null; done; true`, AbortSignal.timeout(30_000)).catch(() => undefined);
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** The Bridge's credentials go to a file in a directory only the box user can open, sourced and deleted before exec, so no value enters an argv. */
+export function envFileLaunch(command, { cwd, env }) {
+    const dir = `/tmp/tbox-${randomBytes(8).toString("hex")}`;
+    return {
+        prepare: `umask 077 && mkdir ${dir}`,
+        file: `${dir}/env`,
+        content: Object.entries(env).map(([key, value]) => `export ${key}=${shellQuote(value)}\n`).join(""),
+        launch: `. ${dir}/env && rm -rf ${dir} && ${cwd === undefined ? "" : `cd ${shellQuote(cwd)} && `}exec ${command} >/tmp/bridge.log 2>&1`,
+        cleanup: `rm -rf ${dir}`,
+    };
+}
+/** For an SDK that takes no AbortSignal: an abort settles the call at once, and `late` receives a result that arrives afterwards. */
+export async function untilAborted(pending, signal, late) {
+    if (signal === undefined)
+        return pending;
+    signal.throwIfAborted();
+    let onAbort = () => undefined;
+    const aborted = new Promise((_, reject) => signal.addEventListener("abort", (onAbort = () => reject(signal.reason)), { once: true }));
+    try {
+        return await Promise.race([pending, aborted]);
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+        if (signal.aborted && late !== undefined)
+            void pending.then(late).catch(() => undefined);
+    }
+}

package/dist/sandbox/vendor.d.ts

@@ -61,6 +61,8 @@ export interface BridgeSandboxCreateRequest {
     lifetimeMs: number;
     /** Vendor template, snapshot or image the caller chose; absent selects the published box image. */
     environment?: string;
+    /** Snapshot id {@link BridgeVendorSnapshots.create} returned; restores that exact state. */
+    snapshot?: string;
     image?: string;
     resources?: ResourceRequest;
     egress?: {
@@ -86,10 +88,33 @@ export interface BridgeVendorSupport {
     /** Egress modes the vendor enforces; absent modes are refused. */
     egress: readonly AgentEnvironmentEgressMode[];
 }
+/** A vendor snapshot of one sandbox's state, restorable through `create`. */
+export interface BridgeVendorSnapshot {
+    /** Vendor snapshot identifier; restores via `BridgeSandboxCreateRequest.snapshot`. */
+    readonly id: string;
+    /** Vendor-reported creation time, when the vendor reports one. */
+    readonly createdAt?: string;
+}
+/** Snapshot lifecycle a vendor may expose beyond create, exec and destroy. */
+export interface BridgeVendorSnapshots {
+    /**
+     * Snapshot a running sandbox. The returned id restores via
+     * `create({ snapshot: id })`, producing a sandbox that starts from the
+     * source's captured state. What a snapshot carries (filesystem only, or
+     * memory too) is vendor truth, reported nowhere else.
+     */
+    create(sandboxId: string, options?: {
+        name?: string;
+        metadata?: Record<string, string>;
+        signal?: AbortSignal;
+    }): Promise<BridgeVendorSnapshot>;
+}
 export interface BridgeSandboxVendor {
     /** Provider name reported on every environment, for example `e2b`. */
     readonly name: string;
     readonly support: BridgeVendorSupport;
+    /** Present only when the vendor snapshots running sandboxes. */
+    readonly snapshots?: BridgeVendorSnapshots;
     create(request: BridgeSandboxCreateRequest): Promise<BridgeSandbox>;
     /** `null` only when the vendor definitively reports no such sandbox; transport failures throw. */
     connect(id: string, options?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-provider-cli-bridge",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "AgentEnvironmentProvider adapter for cli-bridge retained sessions and one-shot turns",
   "type": "module",
   "license": "MIT",
@@ -31,60 +31,16 @@
     "registry": "https://registry.npmjs.org"
   },
   "files": [
-    "dist/index.d.ts",
-    "dist/index.js",
-    "dist/environment-identity.d.ts",
-    "dist/environment-identity.js",
-    "dist/capability-discovery.d.ts",
-    "dist/capability-discovery.js",
-    "dist/context-transfer.d.ts",
-    "dist/context-transfer.js",
-    "dist/interaction-response.d.ts",
-    "dist/interaction-response.js",
-    "dist/observation.d.ts",
-    "dist/observation.js",
-    "dist/provider-options.d.ts",
-    "dist/provider-options.js",
-    "dist/retained-canonical-event.d.ts",
-    "dist/retained-canonical-event.js",
-    "dist/retained-control.d.ts",
-    "dist/retained-control.js",
-    "dist/retained-environment.d.ts",
-    "dist/retained-environment.js",
-    "dist/retained-event-cursor.d.ts",
-    "dist/retained-event-cursor.js",
-    "dist/retained-execution.d.ts",
-    "dist/retained-execution.js",
-    "dist/retained-native.d.ts",
-    "dist/retained-native.js",
-    "dist/retained-run-state.d.ts",
-    "dist/retained-run-state.js",
-    "dist/retained-stream.d.ts",
-    "dist/retained-stream.js",
-    "dist/transport.d.ts",
-    "dist/transport.js",
-    "dist/wire.d.ts",
-    "dist/wire.js",
-    "dist/sandbox/index.d.ts",
-    "dist/sandbox/index.js",
-    "dist/sandbox/box.d.ts",
-    "dist/sandbox/box.js",
-    "dist/sandbox/image.d.ts",
-    "dist/sandbox/image.js",
-    "dist/sandbox/provider.d.ts",
-    "dist/sandbox/provider.js",
-    "dist/sandbox/refusal.d.ts",
-    "dist/sandbox/refusal.js",
-    "dist/sandbox/vendor.d.ts",
-    "dist/sandbox/vendor.js",
+    "dist",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
+    "@tangle-network/agent-core": "^1.0.2",
     "@tangle-network/agent-interface": "^5.10.12",
-    "undici": "8.12.3",
     "@tangle-network/agent-profile-materialize": "1.1.4",
-    "@tangle-network/cli-agent-registry": "^0.14.0"
+    "@tangle-network/cli-agent-registry": "^0.14.0",
+    "undici": "8.12.3"
   },
   "devDependencies": {
     "@tangle-network/agent-provider-testkit": "0.12.4",