@tangle-network/agent-app 0.46.53 → 0.46.55

package/README.md

@@ -16,7 +16,7 @@ The substrate packages — `@tangle-network/agent-runtime`, `agent-eval`, `agent
 - **Bounded tool loop** — `runAppToolLoop` / `streamAppToolLoop`: stream a turn → collect tool calls → dispatch → fold results back → re-run, capped. These are 1:1 aliases of `runToolLoop` / `streamToolLoop` from `@tangle-network/agent-runtime/tool-loop` (the engine owns the loop; this package adds no logic on that path). Substrate-free behind a `streamTurn` seam, so it drives a sandboxed agent, a Worker, or an in-browser copilot unchanged.
 - **Assembled chat vertical** — `createChatTurnRoutes` wires auth → thread/message store → streaming turn with buffered replay → uploads → sidecar question answering into one route factory, over `authorize` / `produce` / `store` / `interactions` seams. No hand-rolled orchestration. See [`examples/chat-app.md`](./examples/chat-app.md).
 - **Sandbox-optional** — the same tools, billing, eval, and loop work without a container. A `fetch`-only adapter maps any OpenAI-compatible stream (Tangle Router, tcloud) into the loop. See [`examples/browser-copilot.md`](./examples/browser-copilot.md).
-- **Resumable turns** — buffer a turn so a dropped tab loses nothing and a reconnecting client replays the tail. Two niches: a browser/edge copilot streaming the Router directly (no sandbox session to attach to), and any DETACHED sandbox run a browser must tail (`dispatchPrompt({ detach: true })` / `driveTurn` execute on a lane the session gateway never sees). **An INTERACTIVE sandbox turn doesn't need it** — drive it on the message lane (`box.session(id).sendMessage()`) and attach the tab with `box.mintScopedToken()` + `SessionGatewayClient`, or let the worker resume with `box.streamPrompt('', { executionId, lastEventId })`. See [`examples/resumable-turns.md`](./examples/resumable-turns.md).
+- **Resumable turns** — buffer a turn so a dropped tab loses nothing and a reconnecting client replays the tail. Two niches: a browser/edge copilot streaming the Router directly (no sandbox session to attach to), and any detached sandbox run driven through `dispatchPrompt({ detach: true })` / `streamPrompt` that a browser must tail. Sandbox 0.37 `driveTurn` uses the message lane and can be tailed through the session gateway. **An INTERACTIVE sandbox turn doesn't need it** — drive it on the message lane (`box.session(id).sendMessage()`) and attach the tab with `box.mintScopedToken()` + `SessionGatewayClient`, or let the worker resume with `box.streamPrompt('', { executionId, lastEventId })`. See [`examples/resumable-turns.md`](./examples/resumable-turns.md).
 - **Composes the engine, never forks it** — `/eval` re-exports `@tangle-network/agent-eval`'s verifier; `/integrations` wraps the hub; `/tangle` and `/billing` take the tcloud client as a structural contract. Engines are **peer dependencies** — you pin the version, nothing is bundled.
 - **ESM, typed, zero runtime deps** in the substrate-free modules (`/runtime`, `/web`, `/crypto`, `/redact`, `/stream`). Ships with `.d.ts` and npm [provenance](https://www.npmjs.com/package/@tangle-network/agent-app#provenance).
 
@@ -36,10 +36,10 @@ pnpm add @tangle-network/agent-eval @tangle-network/agent-integrations
 | Peer | Required by | Range |
 |---|---|---|
 | `@tangle-network/agent-eval` | `/eval`, `/eval-campaign`, `/profile`, `/knowledge` | `>=0.172.1 <0.174.0` |
-| `@tangle-network/agent-runtime` | `/runtime`, `/chat-routes` | `>=0.188.1 <0.192.0` |
+| `@tangle-network/agent-runtime` | `/runtime`, `/chat-routes` | `>=0.191.0 <0.193.0` |
 | `@tangle-network/agent-integrations` | `/integrations` | `>=0.53.55 <0.54.0` |
 | `@tangle-network/agent-interface` | `/interactions`, `/chat-store`, `/harness` | `^2.2.0` |
-| `@tangle-network/sandbox` | `/sandbox` | `>=0.36.3 <0.37.0` |
+| `@tangle-network/sandbox` | `/sandbox` | `>=0.36.4 <0.38.0` |
 | `@tangle-network/agent-knowledge` | `/knowledge-loop` | `^13.0.0` |
 | `@tangle-network/agent-profile-materialize` | `/skills-placement` | `>=0.18.1 <0.20.0` |
 | `@tangle-network/sandbox-ui` | `/brand`, `/work-product-react`, `/workspace-react` | `>=0.111.2 <0.114.0` |
@@ -130,7 +130,7 @@ Each primitive is written `package → symbol`; three packages ship similarly-na
 | Your turn | Use | Why |
 |---|---|---|
 | **Interactive** — a user is watching a chat or copilot | sandbox → `box.streamPrompt()` held open for the turn, wrapped here as `streamSandboxPrompt` (`/sandbox`); for the browser leg, sandbox → `box.mintScopedToken()` + `SessionGatewayClient` (`@tangle-network/sandbox/session-gateway`) attaches the tab directly | Worker lifetime ≈ turn length; a dropped tab replays the buffered tail on reconnect. |
-| **Autonomous** — a mission step, queue job, cron, or inbound email, with nobody watching | sandbox → `box.driveTurn()`, wrapped here as `driveSandboxTurn` (`/sandbox`), ticked from a durable driver; drop to raw `box.dispatchPrompt({ detach: true })` + `box.findCompletedTurn(turnId, { sessionId })` only when one pass is too coarse. `runDetachedTurn` (`/chat-routes`) bridges that detached run into the live buffer, so a browser opening the session mid-run still tails it token-by-token | No consumer exists and Workers die in minutes; the platform runs the turn server-side and a crash re-dispatch is a lookup, not a second run. |
+| **Autonomous** — a mission step, queue job, cron, or inbound email, with nobody watching | sandbox → `box.driveTurn()`, wrapped here as `driveSandboxTurn` (`/sandbox`), ticked from a durable driver; drop to raw `box.dispatchPrompt({ detach: true })` + `box.findCompletedTurn(turnId, { sessionId })` only when one pass is too coarse. Sandbox 0.37 `driveTurn` uses the message lane and a browser can attach through the session gateway; `runDetachedTurn` (`/chat-routes`) remains the buffer bridge for stream/dispatch detached runs | Workers die in minutes, so the platform runs the turn server-side and a crash re-dispatch is a lookup, not a second run. |
 | **Eval / CI** — a long-lived harness process | sandbox → `box.streamPrompt()` for a sandboxed harness; agent-runtime `/tool-loop` → `runToolLoop` / `streamToolLoop` for an in-process model turn — `runAppToolLoop` / `streamAppToolLoop` (`/runtime`) are 1:1 aliases of those, not a second implementation | The process outlives the run; durability adds nothing — a failed run is re-run, not resumed. |
 
 **2. Assembled or à la carte?** `createChatTurnRoutes` (`/chat-routes`) wires the whole server chat turn — auth, store, streaming, replay, uploads, interactions — over typed seams. Reach for the individual modules (`/stream`, `/chat-store`, `/interactions`) only to compose something the assembled route doesn't cover.

package/dist/billing/crypto-probe.d.ts

@@ -0,0 +1,3 @@
+import type { KeyCrypto } from './index';
+/** Prove the at-rest crypto seam before a remote key is minted. */
+export declare function assertWorkspaceKeyCryptoUsable(crypto: KeyCrypto): Promise<void>;

package/dist/billing/identity-bound.d.ts

@@ -0,0 +1,183 @@
+import type { KeyCrypto, KeyProvisioner } from './index';
+/** Lifecycle state for a durable delegated key row. */
+export type WorkspaceKeyStatus = 'legacy' | 'provisioning' | 'active' | 'revocation_pending' | 'revoked' | 'orphaned';
+/** Product partition used by the key store and remote provisioner. */
+export type WorkspaceKeyProduct = string;
+/** The identity fields that bind a child key to its paying owner and source. */
+export interface WorkspaceKeyIdentity {
+    workspaceId: string;
+    ownerUserId: string;
+    platformUserId: string;
+    sourceKeyId?: string | null;
+    /** A non-secret digest of the source credential. */
+    sourceKeyFingerprint: string;
+}
+/** A product/workspace/owner lookup scope. */
+export interface DurableWorkspaceKeyScope {
+    workspaceId: string;
+    ownerUserId: string;
+    product: WorkspaceKeyProduct;
+}
+/** A persisted child-key row owned by this manager. */
+export interface DurableWorkspaceKeyRecord {
+    id: string;
+    workspaceId: string;
+    ownerUserId: string;
+    product: WorkspaceKeyProduct;
+    platformUserId: string;
+    sourceKeyId: string | null;
+    sourceKeyFingerprint: string;
+    /** The persisted name used to recover a remote create after a crash. Null only for pre-name rows. */
+    name: string | null;
+    keyId: string;
+    keyEncrypted: string;
+    budgetUsd: number;
+    expiresAt: Date;
+    status: WorkspaceKeyStatus;
+    revocationAttempts: number;
+    nextRevocationAt: Date | null;
+    lastRevocationError: string | null;
+    createdAt: Date;
+}
+/** A row that has been written before its remote child key exists. */
+export interface DurableWorkspaceKeyProvisioningRecord extends DurableWorkspaceKeyRecord {
+    status: 'provisioning';
+}
+type DurableWorkspaceKeyCreateResult = Awaited<ReturnType<KeyProvisioner['createKey']>> & {
+    budgetUsd?: number | null;
+    budgetRemaining?: number;
+    expiresAt?: string | null;
+};
+/** The remote operations required by the durable manager. */
+export interface DurableWorkspaceKeyProvisioner {
+    createKey(input: Parameters<KeyProvisioner['createKey']>[0]): Promise<DurableWorkspaceKeyCreateResult>;
+    getKey(id: string): Promise<{
+        budgetUsd?: number | null;
+        budgetSpent?: number;
+        expiresAt?: string | null;
+    }>;
+    revokeKey: KeyProvisioner['revokeKey'];
+    /** Find remote keys for a specific persisted provisioning attempt. */
+    findCreatedKeys(input: {
+        name: string;
+        product: string;
+        sourceKeyId?: string | null;
+    }): Promise<Array<{
+        id: string;
+    }>>;
+}
+/** Persistence operations for identity-bound key lifecycle state. */
+export interface DurableWorkspaceKeyStore {
+    /** Return the active row for this exact product scope. */
+    getActive(scope: DurableWorkspaceKeyScope): Promise<DurableWorkspaceKeyRecord | null>;
+    /** Return every unfinished provisioning row for this exact product scope. */
+    listProvisioning(scope: DurableWorkspaceKeyScope): Promise<DurableWorkspaceKeyProvisioningRecord[]>;
+    /** Insert before the remote create so a crashed create can be recovered. */
+    insertProvisioning(record: DurableWorkspaceKeyProvisioningRecord): Promise<void>;
+    /** Save the remote id while the row remains in provisioning state. */
+    markProvisioningRemote(input: {
+        id: string;
+        keyId: string;
+    }): Promise<void>;
+    /** Promote a fully encrypted row to active state. */
+    markActive(input: {
+        id: string;
+        keyId: string;
+        keyEncrypted: string;
+        expiresAt: Date;
+        budgetUsd: number;
+    }): Promise<void>;
+    /** Keep a failed cleanup visible and schedule a later retry. */
+    markRevocationPending(input: {
+        id: string;
+        error?: string | null;
+        nextAttemptAt: Date;
+        incrementAttempts: boolean;
+    }): Promise<void>;
+    /** Mark a remote key as revoked. Missing remote keys count as revoked. */
+    markRevoked(id: string, now: Date): Promise<void>;
+    /** Mark a provisioning row terminal when no remote key remains to clean. */
+    markOrphaned(id: string, error: string): Promise<void>;
+    /** Query due cleanup rows. The implementation should filter by the supplied scope. */
+    listPendingRevocations(input: {
+        product: WorkspaceKeyProduct;
+        workspaceId?: string;
+        ownerUserId?: string;
+        now: Date;
+        limit: number;
+        /** Include rows scheduled for a later retry when checking before issuance. */
+        includeFuture?: boolean;
+    }): Promise<DurableWorkspaceKeyRecord[]>;
+    /** Acquire a cross-process lease for one product/workspace/owner scope. */
+    acquireLease(scope: string, operationId: string, now: Date, leaseMs: number): Promise<boolean>;
+    /** Renew an acquired lease before its expiry. */
+    renewLease(scope: string, operationId: string, now: Date, leaseMs: number): Promise<boolean>;
+    /** Release an acquired lease. */
+    releaseLease(scope: string, operationId: string): Promise<void>;
+}
+/** Live budget information for a child key. */
+export interface WorkspaceKeyUsage {
+    keyId: string;
+    budgetUsd: number;
+    budgetSpent: number;
+    budgetRemaining: number;
+    expiresAt: string;
+    exhausted: boolean;
+}
+/** The decrypted key plus the usage snapshot used to issue it. */
+export interface WorkspaceRuntimeKey {
+    key: string;
+    usage: WorkspaceKeyUsage;
+    /** True when this call minted a new remote key. */
+    refreshed: boolean;
+}
+/** Identity-bound durable key manager API. */
+export interface DurableWorkspaceKeyManager {
+    /** Reuse a matching active key or reconcile and mint one under a lease. */
+    ensureKey(identity: WorkspaceKeyIdentity, options?: {
+        budgetUsd?: number;
+    }): Promise<WorkspaceRuntimeKey>;
+    /** Read usage without returning the child secret. */
+    getUsage(identity: WorkspaceKeyIdentity): Promise<WorkspaceKeyUsage | null>;
+    /** Retry due cleanup rows. A supplied owner/workspace limits the retry to its scope. */
+    retryPendingRevocations(scope?: Pick<WorkspaceKeyIdentity, 'ownerUserId' | 'workspaceId'>): Promise<number>;
+}
+/** Configuration for {@link createIdentityBoundWorkspaceKeyManager}. */
+export interface DurableWorkspaceKeyManagerOptions {
+    store: DurableWorkspaceKeyStore;
+    provisioner: DurableWorkspaceKeyProvisioner;
+    crypto: KeyCrypto;
+    /** Product partition. Products must use separate values. */
+    product: WorkspaceKeyProduct;
+    defaultBudgetUsd: number;
+    now?: () => Date;
+    /** Local lifetime used when the remote response omits an expiry. */
+    keyLifetimeMs?: number;
+    /** Lease lifetime for remote operations. */
+    leaseMs?: number;
+    /** Maximum time to wait for another issuer to release the scope lease. */
+    leaseWaitMs?: number;
+    /** Poll delay while waiting for a scope lease. */
+    leasePollMs?: number;
+    /** Renewal interval. It must be shorter than `leaseMs`. */
+    leaseRenewIntervalMs?: number;
+    /** Initial delay for a failed remote revoke. */
+    revocationRetryBaseMs?: number;
+    /** Maximum delay for a failed remote revoke. */
+    revocationRetryMaxMs?: number;
+    /** Stable remote name. The operation id makes the default crash-safe. */
+    nameForIdentity?: (identity: WorkspaceKeyIdentity, operationId: string) => string;
+    /** Resolve names for rows written before `name` became durable. Null blocks issuance safely. */
+    legacyNameForRecord?: (record: DurableWorkspaceKeyRecord) => string | null | undefined;
+    /** Recognize a missing remote key without depending on a provider SDK. */
+    isRemoteMissing?: (error: unknown) => boolean;
+}
+/**
+ * Create a product-neutral manager for child-key issuance and cleanup.
+ *
+ * The provisioner must already be authenticated for the current source
+ * credential. The manager persists only the source id and its non-secret
+ * fingerprint, then refuses to reuse a row from another identity.
+ */
+export declare function createIdentityBoundWorkspaceKeyManager(options: DurableWorkspaceKeyManagerOptions): DurableWorkspaceKeyManager;
+export {};

package/dist/billing/index.d.ts

@@ -239,3 +239,4 @@ export interface PlatformBalanceManager<Plan extends string> {
 export declare function createPlatformBalanceManager<Plan extends string>(opts: PlatformBalanceManagerOptions<Plan>): PlatformBalanceManager<Plan>;
 /** Create a workspace key manager that handles key provisioning and budget tracking */
 export declare function createWorkspaceKeyManager(opts: WorkspaceKeyManagerOptions): WorkspaceKeyManager;
+export { createIdentityBoundWorkspaceKeyManager, type DurableWorkspaceKeyManager, type DurableWorkspaceKeyManagerOptions, type DurableWorkspaceKeyProvisioner, type DurableWorkspaceKeyProvisioningRecord, type DurableWorkspaceKeyRecord, type DurableWorkspaceKeyScope, type DurableWorkspaceKeyStore, type WorkspaceKeyIdentity, type WorkspaceKeyProduct, type WorkspaceKeyStatus, type WorkspaceKeyUsage, type WorkspaceRuntimeKey, } from './identity-bound';

package/dist/billing/index.js

@@ -1,9 +1,11 @@
 import {
+  createIdentityBoundWorkspaceKeyManager,
   createPlatformBalanceManager,
   createTcloudKeyProvisioner,
   createWorkspaceKeyManager
-} from "../chunk-GXE6KHTS.js";
+} from "../chunk-TS2ZIB53.js";
 export {
+  createIdentityBoundWorkspaceKeyManager,
   createPlatformBalanceManager,
   createTcloudKeyProvisioner,
   createWorkspaceKeyManager

package/dist/chat-routes/index.js

@@ -112,7 +112,7 @@ import {
   flattenHistory,
   readSandboxBinaryBytes,
   statSandboxFileSize
-} from "../chunk-T374KO42.js";
+} from "../chunk-LKZBMDYM.js";
 import "../chunk-MCYJON3F.js";
 import "../chunk-LWSJK546.js";
 import "../chunk-P5PIAQVS.js";

package/dist/{chunk-T374KO42.js → chunk-LKZBMDYM.js}

@@ -2674,8 +2674,9 @@ async function driveSandboxTurn(shell, box, message, options) {
       ...options.wallCapMs !== void 0 ? { wallCapMs: options.wallCapMs } : {},
       ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
       ...options.signal ? { signal: options.signal } : {},
-      // A durable caller with a session-gateway consumer can handle these events;
-      // callers without one should omit interactions so the run stays unattended.
+      // Sandbox 0.37 drives through the session message lane, so a gateway
+      // consumer can handle these events. Callers without one should omit
+      // interactions so the run stays unattended.
       backend: {
         type: harness,
         profile,
@@ -2833,4 +2834,4 @@ export {
   isTerminalPromptEvent,
   detectInteractiveQuestion
 };
-//# sourceMappingURL=chunk-T374KO42.js.map
+//# sourceMappingURL=chunk-LKZBMDYM.js.map