@aexhq/sdk 0.24.0 → 0.25.1

package/dist/_contracts/managed-key.js

@@ -1,181 +0,0 @@
-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",
-    builtins: "disabled",
-    mcpServers: "disabled",
-    proxyEndpoints: "disabled",
-    openNetworking: "disabled"
-});
-export const BLOCKED_MANAGED_KEY_POLICY_V1 = Object.freeze({
-    schemaVersion: MANAGED_KEY_POLICY_SCHEMA_VERSION,
-    credentialMode: "managed",
-    launchStage: "blocked",
-    privateImplementationAvailable: false,
-    billingRequired: true,
-    providers: Object.freeze([]),
-    runtimes: Object.freeze([]),
-    features: BLOCKED_MANAGED_KEY_FEATURE_POLICY_V1
-});
-export class ManagedKeyUnavailableError extends Error {
-    code = "managed_key_unavailable";
-    constructor(message = "credentialMode: \"managed\" is not available without a private managed-key implementation") {
-        super(message);
-        this.name = "ManagedKeyUnavailableError";
-    }
-}
-export function parseCredentialMode(input) {
-    if (input === undefined) {
-        return DEFAULT_CREDENTIAL_MODE;
-    }
-    if (!isCredentialMode(input)) {
-        throw new Error(`credentialMode must be one of: ${CREDENTIAL_MODES.join(", ")} (got ${JSON.stringify(input)})`);
-    }
-    return input;
-}
-export function credentialModeOrDefault(input) {
-    return input ?? DEFAULT_CREDENTIAL_MODE;
-}
-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.privateImplementationAvailable;
-}
-export function isManagedKeyAdmissionAllowed(policy) {
-    return policy.launchStage !== "blocked" && policy.privateImplementationAvailable;
-}
-export function assertManagedKeyModeAvailable(policy = BLOCKED_MANAGED_KEY_POLICY_V1) {
-    if (!isManagedKeyGenerallyAvailable(policy)) {
-        throw new ManagedKeyUnavailableError();
-    }
-}
-export function assertManagedKeyAdmissionAllowed(policy = BLOCKED_MANAGED_KEY_POLICY_V1) {
-    if (!isManagedKeyAdmissionAllowed(policy)) {
-        throw new ManagedKeyUnavailableError();
-    }
-}
-export class FakeManagedCredentialResolver {
-    async resolveManagedCredential(input) {
-        const denial = resolvePolicyDenial(input);
-        if (denial) {
-            return denial;
-        }
-        return {
-            ok: true,
-            lease: Object.freeze({
-                credentialMode: "managed",
-                provider: input.provider,
-                runtime: input.runtime,
-                custodyClass: "managed-provider-credential"
-            })
-        };
-    }
-}
-function resolvePolicyDenial(input) {
-    if (!isManagedKeyGenerallyAvailable(input.policy)) {
-        return {
-            ok: false,
-            code: "managed_key_unavailable",
-            message: "managed-key mode is not generally available for this public policy"
-        };
-    }
-    if (!input.policy.providers.includes(input.provider)) {
-        return {
-            ok: false,
-            code: "provider_not_allowed",
-            message: `provider ${input.provider} is not allowed by managed-key policy`
-        };
-    }
-    if (!input.policy.runtimes.includes(input.runtime)) {
-        return {
-            ok: false,
-            code: "runtime_not_allowed",
-            message: `runtime ${input.runtime} is not allowed by managed-key policy`
-        };
-    }
-    if (input.policy.models && !input.policy.models.includes(input.model)) {
-        return {
-            ok: false,
-            code: "model_not_allowed",
-            message: "model is not allowed by managed-key policy"
-        };
-    }
-    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/docs/product-boundaries.md

@@ -1,57 +0,0 @@
----
-title: Product capabilities and boundaries
----
-
-# Product capabilities and boundaries
-
-aex is the serverless control plane for autonomous agent sessions. It accepts a complete run request, dispatches it to the managed runtime, records typed events, captures outputs, and exposes auth-gated reads and downloads.
-
-aex is not a custom agent loop, a general-purpose sandbox, an interactive approval system, or a provider compliance layer. True self-host and customer-cloud deployment modes are not supported today.
-
-Start with the generated [provider/runtime capability matrix](provider-runtime-capabilities.md) for supported providers, runtime routing, and evidence pointers.
-
-## Owned by aex today
-
-- Run submission, idempotency, status, cancellation, reads, downloads, and workspace auth.
-- Runtime dispatch through the managed runtime, with unsupported runtime selectors rejected at submission.
-- Ordered event capture through the per-run coordinator and durable archive, with platform diagnostics kept on internal/admin surfaces.
-- Output capture into the run record, subject to runtime behavior and storage limits.
-- BYOK provider-key custody for a single run, using the top-level `secrets` carrier and terminal cleanup/revocation attempts for aex-controlled references.
-- Named proxy endpoint policy, auth injection, redaction, call budgets, and audit metadata on the aex-owned proxy path.
-- Default cleanup attempts for tracked aex runtime resources.
-
-## Boundary matrix
-
-| Area | aex-owned behavior | Inherited or customer-owned behavior |
-| --- | --- | --- |
-| Provider and model policy | aex validates the selected provider, injects the run-scoped BYOK credential, and records public-safe runtime events. | Provider retention, training exclusion, zero-retention, HIPAA/BAA, data residency, abuse policy, and pricing are properties of the selected provider account, endpoint, and contract. |
-| Runtime isolation | Managed runs execute in an isolated managed runtime. aex tracks resources and runs cleanup attempts. | Runtime isolation guarantees belong to the managed runtime provider. |
-| Secrets | Provider keys, MCP credentials, and proxy auth values are supplied inline per run, held in run-scoped custody, excluded from idempotency, and targeted for cleanup/revocation at terminal where aex controls the reference. | Customers choose and rotate their provider keys and MCP/proxy credentials. Provider-side credentials, sessions, and data may have their own retention rules. |
-| MCP servers | aex accepts remote HTTP/SSE MCP servers, validates their declaration, attaches run-scoped credentials, and records access metadata on the aex-controlled edge. | MCP servers are customer-trusted remote systems. aex does not sandbox their downstream behavior or make an untrusted MCP server safe. |
-| Proxy endpoints | The named endpoint proxy enforces declared host/path/method/auth policy and response caps for calls routed through it. | The upstream service's own auth, data handling, side effects, and compliance posture remain with the upstream service and customer. |
-| Outputs and run record | Captured outputs, events, and metadata are stored under the public run record and downloaded through auth-gated routes. Internal diagnostics are stored separately under internal/admin access. | Output content is customer content. Storage, deletion, and retention follow the run policy and infrastructure behavior; deletion-proof custody manifests are roadmap work until shipped. |
-| Human review | Runs execute full-auto after submission. Cancellation is available as an abort control. | Required input, approval, and planning happen before submission or after inspecting the completed run record. aex does not pause a run for platform-mediated human approval or interactive clarification. |
-| Agent identity and memory | The durable product primitive is the run record, addressed by run id. | Persistent agent identity, agent profiles, stateful memory, reusable provider sessions, and saved-definition products are out of scope. |
-| Deployment model | The supported product is the hosted aex control plane, plus the SDK and CLI used to submit and inspect runs. | True self-host and customer-cloud deployments are not supported product modes today. Alternate `baseUrl` values are for local, staging, or hosted aex API planes, not a self-host promise. |
-| Cost | BYOK provider-token charges accrue to the customer's provider account. aex can expose run/runtime/output metadata that helps operators reason about usage. | Paid managed-key mode, free trials, billing-grade cost telemetry, public rate cards, margins, and reconciliation are not shipped in the public product unless explicitly documented later. |
-
-## Provider and infrastructure policy links
-
-Use these links as starting points for the policy areas aex does not own:
-
-- Anthropic API data retention policy: <https://platform.claude.com/docs/en/manage-claude/api-and-data-retention>
-- OpenAI API data controls: <https://platform.openai.com/docs/guides/your-data>
-- Mistral privacy and API data handling: <https://docs.mistral.ai/admin/security-access/privacy>
-- Gemini API data handling: <https://ai.google.dev/gemini-api/docs/logs-policy>
-These links do not create aex guarantees. They identify the provider whose current terms and product behavior must be reviewed for a given workload.
-
-## Non-goals and unsupported claims
-
-Do not describe aex as providing:
-
-- true self-host or customer-cloud deployment support;
-- aex does not provide zero retention, HIPAA, BAA, or data-residency guarantees across providers;
-- aex does not provide a free trial or low-cost managed-key mode;
-- a general-purpose sandbox for every runtime and downstream MCP service;
-- human-in-the-loop approval checkpoints, ask-the-user loops, or interactive resume;
-- persistent agent identity, agent profiles, stateful memory, reusable sessions, or saved agent definitions.