@aexhq/sdk 0.13.7 → 0.13.9

package/README.md

@@ -8,7 +8,7 @@ aex is a TypeScript-first SDK + CLI for running autonomous agent sessions across
 
 ```ts
 import {
-  AexClient,        // the only client class — submits durable runs to aex
+  AgentExecutor,        // the only client class — submits durable runs to aex
   Skill,                // workspace / provider / inline skill bundles
   McpServer,            // MCP server declarations (headers split into secrets server-side)
   ProxyEndpoint,        // per-run managed HTTP proxy endpoint
@@ -25,7 +25,7 @@ aex status  <run-id>             --api-token …
 aex wait    <run-id> [--timeout 8m] [--interval 2s] --api-token …
 aex events  <run-id> [--follow] [--timeout 8m]  --api-token …
 aex outputs <run-id>             --api-token …
-aex download <run-id> [--only outputs|logs|events|metadata] [--out path] --api-token …
+aex download <run-id> [--only outputs|events|metadata] [--out path] --api-token …
 aex cancel  <run-id>             --api-token …
 aex delete  <run-id>             --api-token …
 aex whoami                       --api-token …
@@ -34,11 +34,11 @@ aex skills  <upload|list|get|delete> [flags] --api-token …
 
 The SDK class and the CLI are backed by the same public `@aexhq/contracts` operations module — any read or write you can do through one, you can do through the other, against the same durable run records. The same npm package also ships the in-container `aex` CLI as its `bin` entry; managed runs mount that CLI inside the runner so skills can call `aex proxy …` against the per-run manifest. See [product capabilities and boundaries](docs/product-boundaries.md).
 
-The aex URL defaults to `https://api.aex.dev`. Set `--aex-url` on the CLI or `baseUrl` on `AexClient` for local, staging, or hosted aex API planes. This is not a supported self-host deployment claim. The workspace is derived server-side from your API token (1:1 binding), so there is no `--workspace` flag and no `workspaceId` option.
+The aex URL defaults to `https://api.aex.dev`. Set `--aex-url` on the CLI or `baseUrl` on `AgentExecutor` for local, staging, or hosted aex API planes. This is not a supported self-host deployment claim. The workspace is derived server-side from your API token (1:1 binding), so there is no `--workspace` flag and no `workspaceId` option.
 
 ## Product boundaries
 
-- Multi-provider via Goose Managed. The published surface is the same
+- Multi-provider via the managed runtime. The published surface is the same
   regardless of provider:
   - omit `runtime` or pass `runtime: "managed"`; every provider uses the
     managed runtime and BYOK provider-proxy.
@@ -54,31 +54,31 @@ The aex URL defaults to `https://api.aex.dev`. Set `--aex-url` on the CLI or `ba
 ## Quickstart (SDK)
 
 ```ts
-import { AexClient } from "@aexhq/sdk";
+import { AgentExecutor } from "@aexhq/sdk";
 
-const client = new AexClient({
+const aex = new AgentExecutor({
   apiToken: process.env.AEX_API_TOKEN!
   // baseUrl defaults to https://api.aex.dev - set it for local or staging planes.
 });
 
-const runId = await client.submitRun({
+const runId = await aex.submitRun({
   model: "claude-haiku-4-5",
   system: "You are a concise automation agent.",
   prompt: "Write a short answer about agent-first SDK design.",
   secrets: { anthropic: { apiKey: process.env.ANTHROPIC_API_KEY! } }
 });
 
-const run = await client.wait(runId);
+const run = await aex.wait(runId);
 console.log(run.status);
 
-for (const output of await client.outputs(runId)) {
+for (const output of await aex.outputs(runId)) {
   console.log(output.id, output.filename);
 }
 
-const report = await client.downloadOutput(runId, { path: "report.txt", match: "suffix" });
+const report = await aex.downloadOutput(runId, { path: "report.txt", match: "suffix" });
 console.log(new TextDecoder().decode(report));
 
-await client.downloadOutputs(runId, { to: "./outputs.zip" });
+await aex.downloadOutputs(runId, { to: "./outputs.zip" });
 ```
 
 Reusable, credential-free configs can be ordinary functions:
@@ -92,16 +92,16 @@ function summarise(topic: string) {
   };
 }
 
-const runId = await client.submitRun({
+const runId = await aex.submitRun({
   ...summarise("agent-first SDK design"),
   secrets: { anthropic: { apiKey: process.env.ANTHROPIC_API_KEY! } }
 });
 ```
 
-Stream events live with `client.stream(runId)`:
+Stream events live with `aex.stream(runId)`:
 
 ```ts
-for await (const event of client.stream(runId)) {
+for await (const event of aex.stream(runId)) {
   if (event.type === "agent.message") {
     // typed event helpers live under `aex`'s event guard exports.
   }

package/dist/_contracts/connection-ticket.d.ts

@@ -4,18 +4,19 @@
  * A browser/Node WebSocket handshake cannot carry an Authorization header,
  * so a subscriber first obtains a short-lived ticket from an authenticated
  * HTTP endpoint, then presents it as a `?ticket=` query parameter on the WS
- * upgrade. The ticket is an HMAC over `${runId}.${exp}` keyed by the
- * coordinator secret — it binds the grant to one run and one expiry and is
- * verified without any per-ticket storage.
+ * upgrade. The ticket is an HMAC over `${runId}.${channel}.${exp}` keyed by
+ * the coordinator secret — it binds the grant to one run, one stream channel,
+ * and one expiry and is verified without any per-ticket storage.
  *
  * This lives in shared so the coordinator (which verifies) and the API
  * hosted API's ticket broker (which mints, on behalf of a workspace token) use
  * ONE implementation. Pure Web Crypto — identical under Node and workerd.
  */
-/** Mint a `${exp}.${mac}` ticket valid for `ttlMs` from `nowMs`. */
-export declare function mintConnectionTicket(runId: string, secret: string, nowMs: number, ttlMs?: number): Promise<{
+export type ConnectionTicketChannel = "event" | "log" | "all";
+/** Mint a `${channel}.${exp}.${mac}` ticket valid for `ttlMs` from `nowMs`. */
+export declare function mintConnectionTicket(runId: string, secret: string, nowMs: number, ttlMs?: number, channel?: ConnectionTicketChannel): Promise<{
     ticket: string;
     expiresAtMs: number;
 }>;
-/** Verify a ticket against `runId` + the current time. Constant-time MAC compare. */
-export declare function verifyConnectionTicket(ticket: string, runId: string, secret: string, nowMs: number): Promise<boolean>;
+/** Verify a ticket against `runId`, channel, and current time. Constant-time MAC compare. */
+export declare function verifyConnectionTicket(ticket: string, runId: string, secret: string, nowMs: number, channel?: ConnectionTicketChannel): Promise<boolean>;

package/dist/_contracts/connection-ticket.js

@@ -4,9 +4,9 @@
  * A browser/Node WebSocket handshake cannot carry an Authorization header,
  * so a subscriber first obtains a short-lived ticket from an authenticated
  * HTTP endpoint, then presents it as a `?ticket=` query parameter on the WS
- * upgrade. The ticket is an HMAC over `${runId}.${exp}` keyed by the
- * coordinator secret — it binds the grant to one run and one expiry and is
- * verified without any per-ticket storage.
+ * upgrade. The ticket is an HMAC over `${runId}.${channel}.${exp}` keyed by
+ * the coordinator secret — it binds the grant to one run, one stream channel,
+ * and one expiry and is verified without any per-ticket storage.
  *
  * This lives in shared so the coordinator (which verifies) and the API
  * hosted API's ticket broker (which mints, on behalf of a workspace token) use
@@ -14,27 +14,33 @@
  */
 const DEFAULT_TICKET_TTL_MS = 60_000;
 const encoder = new TextEncoder();
+function normalizeTicketChannel(channel) {
+    return channel === "log" || channel === "all" ? channel : "event";
+}
 async function hmacHex(secret, message) {
     const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
     const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
     return [...new Uint8Array(sig)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-/** Mint a `${exp}.${mac}` ticket valid for `ttlMs` from `nowMs`. */
-export async function mintConnectionTicket(runId, secret, nowMs, ttlMs = DEFAULT_TICKET_TTL_MS) {
+/** Mint a `${channel}.${exp}.${mac}` ticket valid for `ttlMs` from `nowMs`. */
+export async function mintConnectionTicket(runId, secret, nowMs, ttlMs = DEFAULT_TICKET_TTL_MS, channel = "event") {
+    const boundChannel = normalizeTicketChannel(channel);
     const exp = nowMs + ttlMs;
-    const mac = await hmacHex(secret, `${runId}.${exp}`);
-    return { ticket: `${exp}.${mac}`, expiresAtMs: exp };
+    const mac = await hmacHex(secret, `${runId}.${boundChannel}.${exp}`);
+    return { ticket: `${boundChannel}.${exp}.${mac}`, expiresAtMs: exp };
 }
-/** Verify a ticket against `runId` + the current time. Constant-time MAC compare. */
-export async function verifyConnectionTicket(ticket, runId, secret, nowMs) {
-    const dot = ticket.indexOf(".");
-    if (dot < 0)
+/** Verify a ticket against `runId`, channel, and current time. Constant-time MAC compare. */
+export async function verifyConnectionTicket(ticket, runId, secret, nowMs, channel = "event") {
+    const [ticketChannel, expRaw, mac, ...rest] = ticket.split(".");
+    if (rest.length > 0 || !ticketChannel || !expRaw || !mac)
+        return false;
+    const boundChannel = normalizeTicketChannel(channel);
+    if (ticketChannel !== boundChannel)
         return false;
-    const exp = Number(ticket.slice(0, dot));
-    const mac = ticket.slice(dot + 1);
+    const exp = Number(expRaw);
     if (!Number.isFinite(exp) || exp < nowMs)
         return false;
-    const expected = await hmacHex(secret, `${runId}.${exp}`);
+    const expected = await hmacHex(secret, `${runId}.${boundChannel}.${exp}`);
     return timingSafeEqual(mac, expected);
 }
 /** Length-then-constant-time comparison of two hex strings. */

package/dist/_contracts/event-envelope.d.ts

@@ -17,7 +17,7 @@
  *
  * Unified observability spine:
  * the envelope additionally carries four ordering attributes so BOTH the typed
- * event stream and the high-volume hosted runtime log stream ride one per-run
+ * event stream and the high-volume hosted-platform log stream ride one per-run
  * coordinator:
  *   - `channel`   — "event" (the typed AG-UI stream) or "log" (a verbose log
  *                   line). The single axis a consumer splits the unified stream
@@ -52,24 +52,23 @@ export declare const AEX_EVENT_MAP_VERSION: 1;
  * Coarse origin classifier — the first axis a consumer filters on.
  *   - `agent`   — the model: text, reasoning, builtin tool calls/results.
  *   - `worker`  — the hosted aex edge itself.
- *   - `runtime` — the execution runtime (Goose container / Anthropic session):
- *                 lifecycle, diagnostics, non-fatal stream errors.
+ *   - `runtime` — the execution runtime: lifecycle, diagnostics, non-fatal
+ *                 stream errors.
  *   - `mcp`     — an MCP server (a tool call/result routed through MCP).
  *   - `aex` — the platform: skills, files, and other aex-native events.
- *   - `workflow`— the orchestration layer (Cloudflare Workflows trace).
- *   - `machine` — the managed host the runtime executes on (machine-level host
- *                 logs). A forthcoming source; `runtime` stays the
- *                 Goose-container / Anthropic-session source, distinct from the
- *                 host machine that carries it.
+ *   - `workflow`— the orchestration layer.
+ *   - `host`    — the managed host the runtime executes on; distinct from the
+ *                 runtime process itself.
  */
-export declare const AEX_EVENT_SOURCES: readonly ["agent", "worker", "runtime", "mcp", "aex", "workflow", "machine"];
+export declare const AEX_EVENT_SOURCES: readonly ["agent", "worker", "runtime", "mcp", "aex", "workflow", "host"];
 export type AexEventSource = (typeof AEX_EVENT_SOURCES)[number];
 /**
  * The channel a record rides on the unified per-run stream:
  *   - `event` — the typed, low-volume, fully-replayed AG-UI event stream.
  *   - `log`   — a high-volume verbose log line (level + message + fields). The
- *               coordinator prunes flushed log rows after R2 archival (logs are
- *               append-only, events are kept). Absent on the wire ⇒ `event`.
+ *               coordinator prunes flushed log rows after evidence archival
+ *               (logs are append-only, events are kept). Absent on the wire ⇒
+ *               `event`.
  */
 export declare const AEX_EVENT_CHANNELS: readonly ["event", "log"];
 export type AexEventChannel = (typeof AEX_EVENT_CHANNELS)[number];
@@ -130,13 +129,13 @@ export interface AexEvent {
      * companion to `sequence` — distinct from `emittedAt` (the SOURCE's clock) and
      * `time` (the LOGICAL time = run base + relative tMs).
      *
-     * NOTE: a Workers clock is coarsened/frozen-at-I/O (a side-channel
-     * mitigation), so `receivedAt` is precisely "the DO's last-I/O wall-clock at
-     * ingest" — that is fine as the authoritative receive marker. It does NOT need
-     * to exceed `emittedAt`: the source runs on a different machine with an
-     * independent clock, so cross-machine drift can leave `receivedAt < emittedAt`
-     * and that is expected, not an error. Absent on records produced before this
-     * field existed (back-compat with archived records).
+     * NOTE: some edge clocks are coarsened/frozen-at-I/O, so `receivedAt` is
+     * precisely "the coordinator's last-I/O wall-clock at ingest" — that is fine
+     * as the authoritative receive marker. It does NOT need to exceed `emittedAt`:
+     * the source runs on a different host with an independent clock, so cross-host
+     * drift can leave `receivedAt < emittedAt` and that is expected, not an error.
+     * Absent on records produced before this field existed (back-compat with
+     * archived records).
      */
     readonly receivedAt?: number;
     /**

package/dist/_contracts/event-envelope.js

@@ -17,7 +17,7 @@
  *
  * Unified observability spine:
  * the envelope additionally carries four ordering attributes so BOTH the typed
- * event stream and the high-volume hosted runtime log stream ride one per-run
+ * event stream and the high-volume hosted-platform log stream ride one per-run
  * coordinator:
  *   - `channel`   — "event" (the typed AG-UI stream) or "log" (a verbose log
  *                   line). The single axis a consumer splits the unified stream
@@ -50,23 +50,22 @@ export const AEX_EVENT_MAP_VERSION = 1;
  * Coarse origin classifier — the first axis a consumer filters on.
  *   - `agent`   — the model: text, reasoning, builtin tool calls/results.
  *   - `worker`  — the hosted aex edge itself.
- *   - `runtime` — the execution runtime (Goose container / Anthropic session):
- *                 lifecycle, diagnostics, non-fatal stream errors.
+ *   - `runtime` — the execution runtime: lifecycle, diagnostics, non-fatal
+ *                 stream errors.
  *   - `mcp`     — an MCP server (a tool call/result routed through MCP).
  *   - `aex` — the platform: skills, files, and other aex-native events.
- *   - `workflow`— the orchestration layer (Cloudflare Workflows trace).
- *   - `machine` — the managed host the runtime executes on (machine-level host
- *                 logs). A forthcoming source; `runtime` stays the
- *                 Goose-container / Anthropic-session source, distinct from the
- *                 host machine that carries it.
+ *   - `workflow`— the orchestration layer.
+ *   - `host`    — the managed host the runtime executes on; distinct from the
+ *                 runtime process itself.
  */
-export const AEX_EVENT_SOURCES = ["agent", "worker", "runtime", "mcp", "aex", "workflow", "machine"];
+export const AEX_EVENT_SOURCES = ["agent", "worker", "runtime", "mcp", "aex", "workflow", "host"];
 /**
  * The channel a record rides on the unified per-run stream:
  *   - `event` — the typed, low-volume, fully-replayed AG-UI event stream.
  *   - `log`   — a high-volume verbose log line (level + message + fields). The
- *               coordinator prunes flushed log rows after R2 archival (logs are
- *               append-only, events are kept). Absent on the wire ⇒ `event`.
+ *               coordinator prunes flushed log rows after evidence archival
+ *               (logs are append-only, events are kept). Absent on the wire ⇒
+ *               `event`.
  */
 export const AEX_EVENT_CHANNELS = ["event", "log"];
 /**

package/dist/_contracts/managed-key.d.ts

@@ -3,10 +3,13 @@ export declare const CREDENTIAL_MODES: readonly ["byok", "managed"];
 export type CredentialMode = (typeof CREDENTIAL_MODES)[number];
 export declare const DEFAULT_CREDENTIAL_MODE: CredentialMode;
 export declare const MANAGED_KEY_POLICY_SCHEMA_VERSION = 1;
+export declare const MANAGED_KEY_RESERVATION_SCHEMA_VERSION = 1;
 export declare const MANAGED_KEY_LAUNCH_STAGES: readonly ["blocked", "pilot", "ga"];
 export type ManagedKeyLaunchStage = (typeof MANAGED_KEY_LAUNCH_STAGES)[number];
 export declare const MANAGED_KEY_FEATURE_DECISIONS: readonly ["disabled", "allowed"];
 export type ManagedKeyFeatureDecision = (typeof MANAGED_KEY_FEATURE_DECISIONS)[number];
+export declare const MANAGED_KEY_RESERVATION_STATUSES: readonly ["open", "settled", "released"];
+export type ManagedKeyReservationStatus = (typeof MANAGED_KEY_RESERVATION_STATUSES)[number];
 export interface ManagedKeyFeaturePolicyV1 {
     readonly files: ManagedKeyFeatureDecision;
     readonly packages: ManagedKeyFeatureDecision;
@@ -24,13 +27,35 @@ export interface ManagedKeyPolicyV1 {
     readonly schemaVersion: typeof MANAGED_KEY_POLICY_SCHEMA_VERSION;
     readonly credentialMode: "managed";
     readonly launchStage: ManagedKeyLaunchStage;
-    readonly serviceAvailable: boolean;
+    readonly privateImplementationAvailable: boolean;
     readonly billingRequired: true;
     readonly providers: readonly RunProvider[];
     readonly runtimes: readonly RuntimeKind[];
     readonly models?: readonly string[];
     readonly features: ManagedKeyFeaturePolicyV1;
 }
+/**
+ * Public-safe reservation lifecycle summary. It intentionally carries only
+ * credit-unit invariants and public row identifiers; private key handles,
+ * account selection, rate cards, margins, and payment-provider references
+ * remain outside this contract.
+ */
+export interface ManagedKeyReservationLifecycleV1 {
+    readonly schemaVersion: typeof MANAGED_KEY_RESERVATION_SCHEMA_VERSION;
+    readonly reservationId: string;
+    readonly workspaceId: string;
+    readonly runId: string;
+    readonly credentialMode: "managed";
+    readonly status: ManagedKeyReservationStatus;
+    readonly reservedCreditUnits: number;
+    readonly chargedCreditUnits: number;
+    readonly releasedCreditUnits: number;
+    readonly createdAt?: string;
+    readonly closedAt?: string;
+}
+export type ManagedKeyReservationLifecycleInput = Omit<ManagedKeyReservationLifecycleV1, "schemaVersion" | "credentialMode"> & {
+    readonly credentialMode?: "managed";
+};
 export declare const BLOCKED_MANAGED_KEY_FEATURE_POLICY_V1: ManagedKeyFeaturePolicyV1;
 export declare const BLOCKED_MANAGED_KEY_POLICY_V1: ManagedKeyPolicyV1;
 export declare class ManagedKeyUnavailableError extends Error {
@@ -40,6 +65,7 @@ export declare class ManagedKeyUnavailableError extends Error {
 export declare function parseCredentialMode(input: unknown): CredentialMode;
 export declare function credentialModeOrDefault(input: CredentialMode | undefined): CredentialMode;
 export declare function isCredentialMode(input: unknown): input is CredentialMode;
+export declare function buildManagedKeyReservationLifecycle(input: ManagedKeyReservationLifecycleInput): ManagedKeyReservationLifecycleV1;
 export declare function isManagedKeyGenerallyAvailable(policy: ManagedKeyPolicyV1): boolean;
 export declare function isManagedKeyAdmissionAllowed(policy: ManagedKeyPolicyV1): boolean;
 export declare function assertManagedKeyModeAvailable(policy?: ManagedKeyPolicyV1): void;

package/dist/_contracts/managed-key.js

@@ -1,8 +1,10 @@
 export const CREDENTIAL_MODES = ["byok", "managed"];
 export const DEFAULT_CREDENTIAL_MODE = "byok";
 export const MANAGED_KEY_POLICY_SCHEMA_VERSION = 1;
+export const MANAGED_KEY_RESERVATION_SCHEMA_VERSION = 1;
 export const MANAGED_KEY_LAUNCH_STAGES = ["blocked", "pilot", "ga"];
 export const MANAGED_KEY_FEATURE_DECISIONS = ["disabled", "allowed"];
+export const MANAGED_KEY_RESERVATION_STATUSES = ["open", "settled", "released"];
 export const BLOCKED_MANAGED_KEY_FEATURE_POLICY_V1 = Object.freeze({
     files: "disabled",
     packages: "disabled",
@@ -15,7 +17,7 @@ export const BLOCKED_MANAGED_KEY_POLICY_V1 = Object.freeze({
     schemaVersion: MANAGED_KEY_POLICY_SCHEMA_VERSION,
     credentialMode: "managed",
     launchStage: "blocked",
-    serviceAvailable: false,
+    privateImplementationAvailable: false,
     billingRequired: true,
     providers: Object.freeze([]),
     runtimes: Object.freeze([]),
@@ -23,7 +25,7 @@ export const BLOCKED_MANAGED_KEY_POLICY_V1 = Object.freeze({
 });
 export class ManagedKeyUnavailableError extends Error {
     code = "managed_key_unavailable";
-    constructor(message = "credentialMode: \"managed\" is not available") {
+    constructor(message = "credentialMode: \"managed\" is not available without a private managed-key implementation") {
         super(message);
         this.name = "ManagedKeyUnavailableError";
     }
@@ -43,11 +45,58 @@ export function credentialModeOrDefault(input) {
 export function isCredentialMode(input) {
     return typeof input === "string" && CREDENTIAL_MODES.includes(input);
 }
+export function buildManagedKeyReservationLifecycle(input) {
+    const status = normalizeManagedKeyReservationStatus(input.status);
+    const reservedCreditUnits = nonNegativeFinite(input.reservedCreditUnits, "reservedCreditUnits");
+    const chargedCreditUnits = nonNegativeFinite(input.chargedCreditUnits, "chargedCreditUnits");
+    const releasedCreditUnits = nonNegativeFinite(input.releasedCreditUnits, "releasedCreditUnits");
+    if (input.credentialMode !== undefined && input.credentialMode !== "managed") {
+        throw new Error("managed-key reservation credentialMode must be managed");
+    }
+    if (status === "open") {
+        if (input.closedAt !== undefined) {
+            throw new Error("managed-key open reservation must not have closedAt");
+        }
+        if (chargedCreditUnits !== 0 || releasedCreditUnits !== 0) {
+            throw new Error("managed-key open reservation cannot have charged or released credit units");
+        }
+    }
+    if (status === "settled") {
+        if (!input.closedAt) {
+            throw new Error("managed-key settled reservation requires closedAt");
+        }
+        const expectedReleased = Math.max(0, reservedCreditUnits - chargedCreditUnits);
+        if (!nearlyEqual(releasedCreditUnits, expectedReleased)) {
+            throw new Error("managed-key settlement releasedCreditUnits must equal max(reserved - charged, 0)");
+        }
+    }
+    if (status === "released") {
+        if (!input.closedAt) {
+            throw new Error("managed-key released reservation requires closedAt");
+        }
+        if (chargedCreditUnits !== 0 || !nearlyEqual(releasedCreditUnits, reservedCreditUnits)) {
+            throw new Error("managed-key released reservation must release all reserved credit units without charge");
+        }
+    }
+    return Object.freeze({
+        schemaVersion: MANAGED_KEY_RESERVATION_SCHEMA_VERSION,
+        reservationId: nonEmptyString(input.reservationId, "reservationId"),
+        workspaceId: nonEmptyString(input.workspaceId, "workspaceId"),
+        runId: nonEmptyString(input.runId, "runId"),
+        credentialMode: "managed",
+        status,
+        reservedCreditUnits,
+        chargedCreditUnits,
+        releasedCreditUnits,
+        ...(input.createdAt ? { createdAt: input.createdAt } : {}),
+        ...(input.closedAt ? { closedAt: input.closedAt } : {})
+    });
+}
 export function isManagedKeyGenerallyAvailable(policy) {
-    return policy.launchStage === "ga" && policy.serviceAvailable;
+    return policy.launchStage === "ga" && policy.privateImplementationAvailable;
 }
 export function isManagedKeyAdmissionAllowed(policy) {
-    return policy.launchStage !== "blocked" && policy.serviceAvailable;
+    return policy.launchStage !== "blocked" && policy.privateImplementationAvailable;
 }
 export function assertManagedKeyModeAvailable(policy = BLOCKED_MANAGED_KEY_POLICY_V1) {
     if (!isManagedKeyGenerallyAvailable(policy)) {
@@ -107,4 +156,26 @@ function resolvePolicyDenial(input) {
     }
     return null;
 }
+function normalizeManagedKeyReservationStatus(input) {
+    if (typeof input !== "string" ||
+        !MANAGED_KEY_RESERVATION_STATUSES.includes(input)) {
+        throw new Error(`managed-key reservation status ${String(input)} is not supported`);
+    }
+    return input;
+}
+function nonEmptyString(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`managed-key reservation ${field} must be a non-empty string`);
+    }
+    return value;
+}
+function nonNegativeFinite(value, field) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`managed-key reservation ${field} must be a non-negative finite number`);
+    }
+    return value;
+}
+function nearlyEqual(left, right) {
+    return Math.abs(left - right) <= 1e-9;
+}
 //# sourceMappingURL=managed-key.js.map

package/dist/_contracts/operations.d.ts

@@ -27,9 +27,13 @@ export declare function getRun(http: HttpClient, runId: string): Promise<Run>;
  * stays for callers that only need the loose record.
  */
 export declare function getRunUnit(http: HttpClient, runId: string): Promise<RunUnit>;
-export declare function listRunEvents(http: HttpClient, runId: string, options?: {
-    readonly channel?: "event" | "log" | "all";
-}): Promise<readonly RunEvent[]>;
+/**
+ * List a run's events. The read endpoint is PAGED (bounded per response so a
+ * long run can't return an unbounded body); this follows `nextCursor` across
+ * pages and returns the FULL accumulated list, preserving the prior single-call
+ * contract for callers (download/*, CLI, streamEvents polling).
+ */
+export declare function listRunEvents(http: HttpClient, runId: string): Promise<readonly RunEvent[]>;
 /** A coordinator WS connection grant minted by the hosted API's ticket broker. */
 export interface CoordinatorTicket {
     readonly wsUrl: string;
@@ -44,11 +48,6 @@ export interface CoordinatorTicket {
  */
 export declare function getCoordinatorTicket(http: HttpClient, runId: string): Promise<CoordinatorTicket>;
 export declare function listOutputs(http: HttpClient, runId: string): Promise<readonly Output[]>;
-/**
- * List the run's platform diagnostics (the `logs` namespace). Legacy stored
- * filenames are normalized to canonical public namespaces.
- */
-export declare function listLogs(http: HttpClient, runId: string): Promise<readonly Output[]>;
 export declare function createOutputLink(http: HttpClient, runId: string, outputId: string): Promise<SignedOutputLink>;
 export declare function resolveOutputFileSelector(outputs: readonly Output[], selector: OutputFileSelector, runId?: string): Output;
 export declare function downloadOutput(http: HttpClient, runId: string, selector: OutputFileSelector): Promise<OutputFileDownload>;
@@ -63,15 +62,12 @@ export declare function deleteRun(http: HttpClient, runId: string): Promise<void
 export declare function deleteWorkspaceAsset(http: HttpClient, hash: string): Promise<void>;
 export declare function whoami(http: HttpClient): Promise<WhoAmI>;
 /**
- * Download EVERYTHING about a run as one zip, organised into the four
+ * Download EVERYTHING public about a run as one zip, organised into the three
  * namespace folders:
  *
  *   metadata/run.json     — the run record.
  *   events/events.jsonl   — typed event-channel records.
- *   events/logs.jsonl     — log-channel records, when the API serves them.
- *   events/all.jsonl      — full unified stream, when the API serves it.
  *   outputs/<rel>         — the run's deliverables.
- *   logs/<rel>            — platform diagnostics.
  *   manifest.json         — `RunRecordManifestV1`.
  */
 export declare function download(http: HttpClient, runId: string): Promise<Uint8Array>;
@@ -81,16 +77,9 @@ export declare function download(http: HttpClient, runId: string): Promise<Uint8
  * (`{ runId, namespace: "outputs", outputs[], errors[] }`).
  */
 export declare function downloadOutputs(http: HttpClient, runId: string): Promise<Uint8Array>;
-/**
- * Download only the platform diagnostics (the `logs` namespace). Zip
- * layout: `<rel>` per file plus a `manifest.json`
- * (`{ runId, namespace: "logs", logs[], errors[] }`).
- */
-export declare function downloadLogs(http: HttpClient, runId: string): Promise<Uint8Array>;
 /**
  * Download only the event archive (the `events` namespace). Always includes
- * typed `events.jsonl`; includes `logs.jsonl` / `all.jsonl` when the deployed
- * event API proves those channel exports are available.
+ * typed `events.jsonl`.
  */
 export declare function downloadEvents(http: HttpClient, runId: string): Promise<Uint8Array>;
 /**