@aexhq/sdk 0.24.0 → 0.25.1

package/docs/quickstart.md

@@ -1,137 +1,60 @@
 ---
-title: aex quickstart
+title: Quickstart
 ---
 
 # Quickstart
 
-1. Get an aex SDK API token (`ant_…`).
-2. Create `AgentExecutor` — the workspace is derived server-side from the token.
-3. Submit the run with the agent's brief plus an inline `secrets` bundle. Wait for terminal status. Fetch outputs.
+## 1. Install
+
+```bash
+npm install @aexhq/sdk
+```
+
+## 2. Submit a run
 
 ```ts
-import { AgentExecutor, RunModels } from "@aexhq/sdk";
+import { AgentExecutor, Models, Providers } from "@aexhq/sdk";
 
 const aex = new AgentExecutor({
-  apiToken: process.env.AEX_API_TOKEN!,
-  // baseUrl defaults to https://api.aex.dev - set it for local or staging planes.
+  apiToken: process.env.AEX_API_TOKEN!
 });
 
 const runId = await aex.submit({
-  model: RunModels.CLAUDE_HAIKU_4_5,
-  prompt: "Write a short answer about agent-first SDK design.",
+  provider: Providers.ANTHROPIC,
+  model: Models.CLAUDE_HAIKU_4_5,
+  prompt: "Write a short report and save it as a file.",
   secrets: { apiKey: process.env.ANTHROPIC_API_KEY! }
 });
-
-const run = await aex.wait(runId);
-console.log(run.status);
-console.log(await aex.outputs(runId));
 ```
 
-For reusable, credential-free configs, use an ordinary function:
+## 3. Stream, wait, and download
 
 ```ts
-function summarise(topic: string) {
-  return {
-    model: RunModels.CLAUDE_HAIKU_4_5,
-    prompt: `Write a short answer about ${topic}.`
-  };
+for await (const event of aex.stream(runId)) {
+  console.log(event.type);
 }
 
-const runId = await aex.submit({
-  ...summarise("agent-first SDK design"),
-  secrets: { apiKey: process.env.ANTHROPIC_API_KEY! }
-});
+const run = await aex.wait(runId);
+console.log(run.status);
+
+await aex.download(runId, { to: "./run.zip" });
 ```
 
-Or from the shell:
+The same run from the CLI:
 
 ```bash
 aex run \
   --api-token "$AEX_API_TOKEN" \
   --anthropic-api-key "$ANTHROPIC_API_KEY" \
   --model claude-haiku-4-5 \
-  --prompt "Write a short answer about agent-first SDK design." \
+  --prompt "Write a short report and save it as a file." \
   --follow
 ```
 
-For a config-file flow, pass `--config <path>` with a run-config JSON file for a single run request (`{ model, system?, prompt, skills?, mcpServers?, environment?, runtimeSize?, timeout?, postHook?, proxyEndpoints?, metadata? }`). Both surfaces hit the same aex backend and operate on the same durable run records. The JSON `model` value is validated against `RUN_MODELS`.
-
-## Runtime controls
-
-`submit` also accepts per-run controls that are not secrets:
-
-- `runtimeSize` - a closed managed-runtime preset. Prefer `RuntimeSizes`, e.g. `RuntimeSizes.SHARED_2X_2GB`.
-- `timeout` - run deadline as a duration string such as `"30m"` or `"2h"`; bounded server-side.
-- `postHook` - optional post-agent verifier, e.g. `{ command: "pnpm test", timeout: "5m", maxTurns: 3, maxChars: 12000 }`. It runs after the agent process exits successfully; failures are sent back to the agent for repair until `maxTurns` is exhausted. Empty `command` is treated as omitted.
-- `builtins` - managed-runtime builtin extensions. Omit it to use the default `["developer"]` toolkit. Pass `[]` for a pure-MCP run with no builtins.
-- `outputMode` - `"buffered"` by default; pass `"stream"` for per-token assistant text deltas.
-
-## Where things go: customer → primitive mapping
-
-Every kind of thing you want to ship at run time has exactly one right primitive in the SDK. Reach for the right one rather than rolling your own wrapper.
-
-| What you have | Primitive | What it does |
-|---|---|---|
-| Non-secret paths or config (`BROLL_STORE`, mode flags) | `environment.envVars` | Mounted as `RUNTIME.env` / `RUNTIME.json`; `__KEY__` substitution in agent-facing markdown; echoed back as `run.runtimeManifest.envVars` |
-| Upstream HTTPS API keys (TMDB, Brave, Tavily, …) | `ProxyEndpoint` | Credentials live server-side; aex proxy injects them on outbound calls. The key never enters the container. |
-| MCP server credentials | `secrets.mcpServers` | Held in run-scoped custody, attached per run |
-| Provider API key | `secrets.apiKey` | Required on every `submit`; held in run-scoped custody. Carries the BYOK key for the selected `provider` |
-| Non-secret reference data files or folders (transcripts, persona docs, PDFs) | `File.fromPath('./subtitles.srt')` / `File.fromPath('./customer-folder/')` | Unzipped into the `mountPath` directory (default `/workspace`, the agent's cwd), preserving the real filename + extension — e.g. `/workspace/subtitles.srt`. See [Files: where they land](#files-where-they-land). |
-| Executable skill code (a `.pyz` wrapper, scripts, prompts) | `Skill.fromPath('./skills/my-skill/')` | Mounted under `skills/<name>/`; the bundle's `SKILL.md` is composed into the agent's instructions |
-| Agent instructions file | `AgentsMd.fromPath('./AGENTS.md')` | Prepended as the first user turn |
-
-`Skill`, `AgentsMd`, and `File` values are materialized for the run before the first agent turn. `environment.envVars` values surface in runtime metadata and can be referenced by `__KEY__` placeholders in agent-facing markdown.
-
-### Files: where they land
-
-A `File` is uploaded as a content-addressed archive and **unzipped on the runtime into a directory**, preserving the real filename + extension — the agent sees the actual file, never a `.zip` to unpack.
-
-- **`mountPath` is the directory the archive unzips into.** It must be an absolute container path (`/...`, no `..` traversal). It defaults to **`/workspace`**, which is also the agent's default working directory — so a file handed with no `mountPath` lands directly in the agent's cwd.
-- **A single file keeps its real basename.** `File.fromPath('./source-video-subtitles.srt')` lands at `/workspace/source-video-subtitles.srt` (not a slug, not a `.zip`). `File.fromBytes({ name: 'data.csv', bytes })` lands at `/workspace/data.csv` — `name` is the real filename here.
-- **A folder lands its entries under the mount directory.** `File.fromPath('./repo/', { mountPath: '/workspace/repo' })` puts each file at `/workspace/repo/<relative-path>`.
-- **The resolved mount directory is surfaced back on the run.** Read `run.runtimeManifest.mountedFiles` (an array of `{ name, mountPath }`) to learn where each handed file landed.
-
-```ts
-const subtitles = await File.fromPath('./source-video-subtitles.srt'); // → /workspace/source-video-subtitles.srt
-const dataset = await File.fromPath('./data/', { mountPath: '/workspace/input' }); // → /workspace/input/<files>
-const run = await client.submit({ model, prompt, files: [subtitles, dataset], secrets: { apiKey } });
-const resolved = (await client.getRun(run.id)).runtimeManifest?.mountedFiles;
-// [{ name: 'source-video-subtitles', mountPath: '/workspace' }, { name: 'data', mountPath: '/workspace/input' }]
-```
-
-## Safe retries with `idempotencyKey`
-
-Every `submit` call carries an `idempotencyKey`. When omitted the SDK auto-generates a UUID per call. Supplying your own key makes retries deterministic:
-
-| Submit shape | Server response |
-| --- | --- |
-| New `idempotencyKey` | HTTP 202 — returns the new run id. |
-| Same key + identical request body hash | HTTP 200 — returns the original run id. The SDK call resolves with that id. |
-| Same key + **different** request body hash | HTTP 409 — body `{ error: { message, code: "idempotency_conflict", details: { existingRunId } } }`. The SDK throws an `HttpError` carrying that body. Use `details.existingRunId` to adopt the pre-existing run, or pick a fresh key. |
-| Omitted `idempotencyKey` | A new UUID is generated on every call — repeat submissions create new runs. |
-
-The request hash is computed server-side over the canonical submission JSON (model, prompt, system, environment, skill refs, MCP server descriptors, proxy endpoints, `outputs`, etc.) so reordering JSON keys, adding whitespace, or rotating the inline secret bundle does **not** change the hash. Changing the prompt, model, system, or any other non-secret field does.
-
-Pattern for safe retries:
-
-```ts
-const idempotencyKey = crypto.randomUUID();
-async function submitWithRetry() {
-  for (let attempt = 0; attempt < 3; attempt++) {
-    try {
-      return await aex.submit({
-        model: RunModels.CLAUDE_HAIKU_4_5,
-        prompt: "...",
-        idempotencyKey,
-        secrets: { apiKey: process.env.ANTHROPIC_API_KEY! }
-      });
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("network")) continue;
-      throw err;
-    }
-  }
-  throw new Error("submit failed after retries");
-}
-```
+## Add capabilities
 
-The same `idempotencyKey` reused with the same body will deterministically resolve to the same run id regardless of how many times the network drops between attempts. Query, stream, wait, or download the run by that id.
+- Add files, skills, AGENTS.md, MCP servers, proxy endpoints, packages, and networking controls with [Composition](concepts/composition.md).
+- Inspect runtime tools with [Agent tools](concepts/agent-tools.md).
+- Use parent/child run delegation from the [Features](https://aex.dev/docs/features/#subagents) page.
+- Narrow output capture or download individual files with [Outputs](outputs.md).
+- Check supported providers and models in the [provider/runtime capability matrix](provider-runtime-capabilities.md).

package/docs/release.md

@@ -29,7 +29,7 @@ publish.
    publishes `@aexhq/sdk@<version>` under the `canary` tag — `latest` is
    untouched, so `npm install @aexhq/sdk` users are unaffected.
 5. Run the platform release against the canary: in **aex-platform**, dispatch
-   `deploy.yml` with `sdk_version=<version>` (threads `AEX_USER_TEST_SDK_VERSION`
+   `deploy.yml` with `sdk_version=<version>` (threads `AEX_USER_TEST_VERSION`
    into the suite). The local plane gates prod, and both planes' user-tests run
    against `@aexhq/sdk@<version>`.
 6. On a green platform release, run the **Promote** workflow

package/docs/run-config.md

@@ -13,7 +13,7 @@ Allowed fields:
 - `system` - optional system message.
 - `skills` - array of storage-neutral `kind:"asset"` refs. Config files cannot carry local draft bytes; use `Skill.fromPath(...)` / `Skill.fromFiles(...)` in SDK code first, or reference an existing asset/catalog skill.
 - `mcpServers` - array of `McpServerRef`; headers are split into `secrets.mcpServers` server-side.
-- `environment` - `{ networking?, packages?, envVars? }`. `envVars` are merged into the in-container `RUNTIME.env` / `RUNTIME.json` mounts.
+- `environment` - `{ networking?, packages?, envVars? }`. Networking is open by default; set `networking.mode` to `limited` only when you want an allowlist. `envVars` are merged into the in-container `RUNTIME.env` / `RUNTIME.json` mounts.
 - `runtimeSize` - optional managed-runtime preset. Prefer `RuntimeSizes` in TypeScript.
 - `timeout` - optional run deadline duration string such as `"30m"` or `"2h"`.
 - `postHook` - optional post-agent verifier `{ command, timeout?, maxTurns?, maxChars? }`. It runs after a successful agent process; a failing or timed-out command is sent back to the agent for repair until `maxTurns` is exhausted. Empty `command` is treated as omitted.
@@ -22,7 +22,7 @@ Allowed fields:
 
 `agentsMd`, `files`, `outputs`, `builtins`, and `outputMode` are top-level `submit` options, not run-config fields. They carry bytes, capture behavior, or agent tool/output controls that belong on a concrete run submission.
 
-Secrets never live in run config. Pass credentials through `submit({ ...config, secrets })` in the SDK or the equivalent host-mode flags (`--anthropic-api-key`, `--mcp-auth`, `--proxy-auth`) in the CLI. See [Credentials](credentials.md) for the proxy endpoint policy/auth split and retry fields.
+Secrets never live in run config. Pass credentials through `submit({ ...config, secrets })` in the SDK or the equivalent host-mode flags (`--anthropic-api-key`, `--mcp-auth`, `--proxy-auth`) in the CLI. See [Secrets](secrets.md) for secret lifecycles and [Credentials](credentials.md) for the proxy endpoint policy/auth split and retry fields.
 
 ## Reuse in code
 

package/docs/secrets.md

@@ -0,0 +1,123 @@
+---
+title: Secrets
+---
+
+# Secrets
+
+aex supports BYOK provider keys, per-run credentials, and reusable workspace
+secrets. Secret values are excluded from the idempotency fingerprint and do not
+belong in run config.
+
+## Use A Provider Key For One Run
+
+### TypeScript
+
+```ts
+import { AgentExecutor, Models, Providers } from "@aexhq/sdk";
+
+const aex = new AgentExecutor({ apiToken: process.env.AEX_API_TOKEN! });
+
+await aex.submit({
+  provider: Providers.ANTHROPIC,
+  model: Models.CLAUDE_HAIKU_4_5,
+  prompt: "Write the report and save outputs.",
+  secrets: { apiKey: process.env.ANTHROPIC_API_KEY! }
+});
+```
+
+### CLI
+
+```bash
+aex run \
+  --api-token "$AEX_API_TOKEN" \
+  --anthropic-api-key "$ANTHROPIC_API_KEY" \
+  --model claude-haiku-4-5 \
+  --prompt "Write the report and save outputs."
+```
+
+## Upload An Env Secret
+
+Use `Secret.value(...).upload(...)` when you start with an ephemeral value and
+want to persist it as a named workspace secret for later runs.
+
+```ts
+import { AgentExecutor, Models, Providers, Secret } from "@aexhq/sdk";
+
+const aex = new AgentExecutor({ apiToken: process.env.AEX_API_TOKEN! });
+
+const githubToken = await Secret.value(process.env.GITHUB_TOKEN!).upload(aex, {
+  name: "github-token"
+});
+
+await aex.submit({
+  provider: Providers.ANTHROPIC,
+  model: Models.CLAUDE_HAIKU_4_5,
+  prompt: "Inspect the repository issues.",
+  secretEnv: { GITHUB_TOKEN: githubToken },
+  secrets: { apiKey: process.env.ANTHROPIC_API_KEY! }
+});
+```
+
+## Set Or Rotate A Workspace Secret
+
+Use `client.secrets.set(...)` to create a named secret directly. Use
+`client.secrets.rotate(...)` to replace its value while keeping the same name.
+
+```ts
+await aex.secrets.set({
+  name: "serper-api-key",
+  value: process.env.SERPER_API_KEY!
+});
+
+await aex.secrets.rotate({
+  name: "serper-api-key",
+  value: process.env.SERPER_API_KEY_NEXT!
+});
+```
+
+## Retrieve Secret Metadata
+
+`list` and `get` return metadata only. They never return the secret value.
+
+```ts
+const secrets = await aex.secrets.list();
+const metadata = await aex.secrets.get("serper-api-key");
+```
+
+## Get A Secret Value
+
+Use `get_value` only when the value is intentionally needed outside a run. It is
+the explicit audited value-read path.
+
+```ts
+const secretValue = await aex.secrets.get_value("serper-api-key");
+console.log(secretValue.value);
+```
+
+## Inject A Workspace Secret Into A Run
+
+Reference workspace secrets with `Secret.ref(name)`. The value resolves
+server-side and is injected as the named environment variable.
+
+```ts
+import { Models, Providers, Secret } from "@aexhq/sdk";
+
+await aex.submit({
+  provider: Providers.ANTHROPIC,
+  model: Models.CLAUDE_HAIKU_4_5,
+  prompt: "Use SERPER_API_KEY for web search.",
+  secretEnv: {
+    SERPER_API_KEY: Secret.ref("serper-api-key")
+  },
+  secrets: { apiKey: process.env.ANTHROPIC_API_KEY! }
+});
+```
+
+## Delete A Workspace Secret
+
+```ts
+await aex.secrets.delete("serper-api-key");
+```
+
+The CLI supports per-run provider, MCP, and proxy credentials. Workspace secret
+administration is exposed through the SDK.

package/docs/skills.md

@@ -7,7 +7,7 @@ title: Skills
 A skill is executable or instructional content that is mounted into a run before
 the first agent turn. Every accepted skill ends up as a storage-neutral
 `kind:"asset"` reference in the run submission, and the hosted platform snapshots
-that asset into the run's object-storage prefix before dispatch.
+that asset into durable run asset storage before dispatch.
 
 There are three sources for skill bytes:
 
@@ -32,8 +32,8 @@ an aex asset instead.
 
 ## Materialization
 
-For each run, the platform copies referenced skill assets into that run's
-object-storage directory (`runs/<runId>/assets/<hash>`) and the runner downloads them into the
+For each run, the platform copies referenced skill assets into durable run asset
+storage (`runs/<runId>/assets/<hash>`) and the runner downloads them into the
 workspace under `skills/<name>/`.
 
 A bundle's `SKILL.md` is composed into the agent's instructions, so the agent is

package/docs/vision-skills.md

@@ -32,7 +32,7 @@ a raised `maxRequestBytes` (so the base64 image fits):
 ```ts
 import { AgentExecutor, RunModels, Skill, ProxyEndpoint, validateProxyAuth } from "@aexhq/sdk";
 
-const aex = new AgentExecutor({ apiToken: process.env.AEX_WORKSPACE_TOKEN! });
+const aex = new AgentExecutor({ apiToken: process.env.AEX_API_TOKEN! });
 
 const proxyEndpoints = [
   ProxyEndpoint.bearer({
@@ -124,33 +124,28 @@ upstream = json.loads(base64.b64decode(envelope["upstreamBodyBase64"]).decode())
 content = upstream["choices"][0]["message"]["content"]  # the model's JSON answer
 ```
 
-The key is injected by the BFF on the outbound call; it never appears on disk in
+The key is injected by the hosted proxy on the outbound call; it never appears on disk in
 the container or in the model's context.
 
-## `maxRequestBytes` is required for image POSTs
+## `maxRequestBytes` and timeout defaults
 
-The per-endpoint `maxRequestBytes` default is **1 MiB**. A base64 data-URL image
-is ~1.33x the raw bytes, so a ~480px JPEG (~40-150 KB raw) becomes ~55-200 KB in
-the request — within the default, but only just. **Set `maxRequestBytes`
-explicitly** (a couple of MB) whenever you POST images so a higher-res frame or a
-larger prompt does not trip the cap. If a body does exceed the cap, the proxy
-rejects it before any upstream call with an explicit error naming the observed
-size, the configured cap, and how to raise it:
+The per-endpoint `maxRequestBytes` default is **10 MiB** and the default timeout
+is **5 minutes**. That fits typical base64 image/model POSTs without extra
+configuration. If a body does exceed the cap, the proxy rejects it before any
+upstream call with an explicit error naming the observed size, the configured
+cap, and how to raise it:
 
 > request body is 2400000 bytes, which exceeds this endpoint's maxRequestBytes
-> (1048576). Raise the per-endpoint maxRequestBytes in the proxy endpoint policy …
+> (10485760). Raise the per-endpoint maxRequestBytes in the proxy endpoint policy …
 
-Two ways to stay under the cap: raise `maxRequestBytes`, and/or scale frames to
-~480px wide before captioning (`ffmpeg -i source.mp4 -vf fps=1,scale=480:-1
-frame_%03d.jpg`) — full-res adds payload and cost, not signal.
+Two ways to stay under the cap: raise `maxRequestBytes`, and/or scale frames
+before captioning (`ffmpeg -i source.mp4 -vf fps=1,scale=960:-1 frame_%03d.jpg`)
+so full-res frames do not add payload and model cost without useful signal.
 
 ## Notes
 
-- **Egress.** The named proxy reaches any HTTPS host you declare as `baseUrl`
-  (no upstream allow-list; only a literal-IP SSRF deny-list). The international
-  BytePlus host (`ark.ap-southeast.bytepluses.com`) is a normal public host. The
-  China host (`ark.cn-beijing.volces.com`) is reachable in principle but the
-  platform's egress to Beijing is currently unverified — prefer the BytePlus host.
+- **Host selection.** Use the provider endpoint that matches your account and
+  declare it as the proxy endpoint `baseUrl`.
 - **Keyless model hosts.** If the upstream takes no credential, declare the
   endpoint with `authShape: { type: "none" }` and omit the `proxyEndpointAuth`
   entry (see `credentials.md`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexhq/sdk",
-  "version": "0.24.0",
+  "version": "0.25.1",
   "description": "TypeScript SDK for running autonomous agent sessions across providers (Anthropic, OpenAI, DeepSeek, Gemini, Mistral) behind one interface.",
   "license": "Apache-2.0",
   "repository": {
@@ -26,7 +26,7 @@
     "examples"
   ],
   "devDependencies": {
-    "@aexhq/contracts": "0.24.0"
+    "@aexhq/contracts": "0.25.1"
   },
   "engines": {
     "node": ">=20"

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

@@ -1,101 +0,0 @@
-import type { RunProvider, RuntimeKind } from "./submission.js";
-import type { RunModel } from "./models.js";
-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;
-    readonly builtins: ManagedKeyFeatureDecision;
-    readonly mcpServers: ManagedKeyFeatureDecision;
-    readonly proxyEndpoints: ManagedKeyFeatureDecision;
-    readonly openNetworking: ManagedKeyFeatureDecision;
-}
-/**
- * Public managed-key policy contract. Concrete policy values, account
- * selection, financial calculation, and deployment wiring live outside this
- * public module.
- */
-export interface ManagedKeyPolicyV1 {
-    readonly schemaVersion: typeof MANAGED_KEY_POLICY_SCHEMA_VERSION;
-    readonly credentialMode: "managed";
-    readonly launchStage: ManagedKeyLaunchStage;
-    readonly privateImplementationAvailable: boolean;
-    readonly billingRequired: true;
-    readonly providers: readonly RunProvider[];
-    readonly runtimes: readonly RuntimeKind[];
-    readonly models?: readonly RunModel[];
-    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 {
-    readonly code = "managed_key_unavailable";
-    constructor(message?: string);
-}
-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;
-export declare function assertManagedKeyAdmissionAllowed(policy?: ManagedKeyPolicyV1): void;
-export interface ManagedCredentialResolutionInput {
-    readonly workspaceId: string;
-    readonly runId: string;
-    readonly provider: RunProvider;
-    readonly runtime: RuntimeKind;
-    readonly model: RunModel;
-    readonly policy: ManagedKeyPolicyV1;
-}
-export interface ManagedCredentialLease {
-    readonly credentialMode: "managed";
-    readonly provider: RunProvider;
-    readonly runtime: RuntimeKind;
-    readonly custodyClass: "managed-provider-credential";
-}
-export type ManagedCredentialResolution = {
-    readonly ok: true;
-    readonly lease: ManagedCredentialLease;
-} | {
-    readonly ok: false;
-    readonly code: "managed_key_unavailable" | "provider_not_allowed" | "runtime_not_allowed" | "model_not_allowed";
-    readonly message: string;
-};
-export interface ManagedCredentialResolver {
-    resolveManagedCredential(input: ManagedCredentialResolutionInput): Promise<ManagedCredentialResolution>;
-}
-export declare class FakeManagedCredentialResolver implements ManagedCredentialResolver {
-    resolveManagedCredential(input: ManagedCredentialResolutionInput): Promise<ManagedCredentialResolution>;
-}