@aexhq/sdk 0.34.0 → 0.36.0

package/dist/_contracts/submission.js

@@ -1,9 +1,3 @@
-import { authShapeHeaderName, PROXY_ALLOWED_METHODS, PROXY_ENDPOINT_DEFAULTS, PROXY_RETRY_JITTERS, PROXY_RETRY_POLICY_DEFAULTS, PROXY_RESPONSE_MODES } from "./proxy-protocol.js";
-// Re-exported from the protocol module (its canonical home, alongside the
-// index-file shape the builder fills). Kept on the submission surface so
-// existing `@aexhq/contracts` consumers of `PROXY_ENDPOINT_DEFAULTS` are
-// unaffected by the move.
-export { PROXY_ENDPOINT_DEFAULTS };
 import { TOOL_NAME_PATTERN, normaliseSkillBundlePath, parseAssetRefFields, parseMcpServerRef } from "./run-config.js";
 import { parseRunTimeout, parseRuntimeSize } from "./runtime-sizes.js";
 import { assertRunModelMatchesProvider, parseRunModel } from "./models.js";
@@ -118,29 +112,6 @@ export const SECRETS_KEY = "secrets";
 export const SECRET_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
 /** Workspace secret handle a `secretEnv` ref points at (and the name `secret.upload` persists to). */
 export const SECRET_HANDLE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-export const PROXY_ENDPOINT_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/;
-export const RESERVED_PROXY_ENDPOINT_NAMES = new Set(["proxy", "aex", "internal", "admin"]);
-/**
- * Headers the proxy never lets through, regardless of policy. Lowercase.
- * Anything that could re-introduce credentials, cookies, or routing
- * primitives. Kept in lockstep with the proxy route's reject list.
- */
-const PROXY_DENY_HEADER_LIST = new Set([
-    "authorization",
-    "cookie",
-    "set-cookie",
-    "proxy-authorization",
-    "host",
-    "content-length",
-    "transfer-encoding",
-    "connection",
-    "upgrade",
-    "expect",
-    "x-forwarded-for",
-    "x-forwarded-host",
-    "x-forwarded-proto",
-    "x-real-ip"
-]);
 export const deniedSecretFields = new Set([
     "providerApiKey",
     "anthropicApiKey",
@@ -313,322 +284,9 @@ function parsePackages(input) {
         return version ? { name, version, ecosystem } : { name, ecosystem };
     });
 }
-function parseProxyEndpoints(input) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(input)) {
-        throw new Error("proxyEndpoints must be an array");
-    }
-    if (input.length === 0) {
-        return undefined;
-    }
-    const seen = new Set();
-    return input.map((entry, index) => {
-        const endpoint = parseProxyEndpoint(entry, `proxyEndpoints[${index}]`);
-        if (seen.has(endpoint.name)) {
-            throw new Error(`proxyEndpoints duplicate name: ${endpoint.name}`);
-        }
-        seen.add(endpoint.name);
-        return endpoint;
-    });
-}
-function parseProxyEndpoint(input, path) {
-    const value = requireRecord(input, path);
-    const allowed = new Set([
-        "name",
-        "baseUrl",
-        "authShape",
-        "allowMethods",
-        "allowPathPrefixes",
-        "allowHeaders",
-        "responseMode",
-        "maxRequestBytes",
-        "maxResponseBytes",
-        "timeoutMs",
-        "retry"
-    ]);
-    for (const key of Object.keys(value)) {
-        if (!allowed.has(key)) {
-            throw new Error(`${path}.${key} is not an allowed field`);
-        }
-    }
-    const name = requireString(value.name, `${path}.name`);
-    if (!PROXY_ENDPOINT_NAME_PATTERN.test(name)) {
-        throw new Error(`${path}.name must match ${PROXY_ENDPOINT_NAME_PATTERN} (lowercase letters, digits, '_' and '-'; <=63 chars)`);
-    }
-    if (RESERVED_PROXY_ENDPOINT_NAMES.has(name)) {
-        throw new Error(`${path}.name is reserved: ${name}`);
-    }
-    const baseUrl = parseProxyBaseUrl(value.baseUrl, `${path}.baseUrl`);
-    const authShape = parseProxyAuthShape(value.authShape, `${path}.authShape`);
-    const allowMethods = parseProxyMethods(value.allowMethods, `${path}.allowMethods`);
-    const allowPathPrefixes = parseProxyPathPrefixes(value.allowPathPrefixes, `${path}.allowPathPrefixes`);
-    const allowHeaders = parseProxyAllowedHeaders(value.allowHeaders, `${path}.allowHeaders`, authShape);
-    const responseMode = optionalEnum(value.responseMode, `${path}.responseMode`, PROXY_RESPONSE_MODES);
-    const maxRequestBytes = optionalPositiveInt(value.maxRequestBytes, `${path}.maxRequestBytes`);
-    const maxResponseBytes = optionalPositiveInt(value.maxResponseBytes, `${path}.maxResponseBytes`);
-    const timeoutMs = optionalPositiveInt(value.timeoutMs, `${path}.timeoutMs`);
-    const retry = parseProxyRetryPolicy(value.retry, `${path}.retry`);
-    return {
-        name,
-        baseUrl,
-        authShape,
-        allowMethods,
-        allowPathPrefixes,
-        ...(allowHeaders ? { allowHeaders } : {}),
-        ...(responseMode ? { responseMode } : {}),
-        ...(maxRequestBytes !== undefined ? { maxRequestBytes } : {}),
-        ...(maxResponseBytes !== undefined ? { maxResponseBytes } : {}),
-        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(retry !== undefined ? { retry } : {})
-    };
-}
-export function parseProxyRetryPolicy(input, field) {
-    if (input === undefined) {
-        return undefined;
-    }
-    const value = requireRecord(input, field);
-    const allowed = new Set([
-        "maxAttempts",
-        "initialDelayMs",
-        "maxDelayMs",
-        "jitter",
-        "retryOnStatuses",
-        "retryOnMethods",
-        "respectRetryAfter"
-    ]);
-    for (const key of Object.keys(value)) {
-        if (!allowed.has(key)) {
-            throw new Error(`${field}.${key} is not an allowed field`);
-        }
-    }
-    const maxAttempts = parseOptionalBoundedInt(value.maxAttempts, `${field}.maxAttempts`, 1, 5);
-    const initialDelayMs = optionalPositiveInt(value.initialDelayMs, `${field}.initialDelayMs`);
-    const maxDelayMs = optionalPositiveInt(value.maxDelayMs, `${field}.maxDelayMs`);
-    const effectiveInitialDelayMs = initialDelayMs ?? PROXY_RETRY_POLICY_DEFAULTS.initialDelayMs;
-    const effectiveMaxDelayMs = maxDelayMs ?? PROXY_RETRY_POLICY_DEFAULTS.maxDelayMs;
-    if (effectiveMaxDelayMs < effectiveInitialDelayMs) {
-        throw new Error(`${field}.maxDelayMs must be greater than or equal to ${field}.initialDelayMs`);
-    }
-    const jitter = optionalEnum(value.jitter, `${field}.jitter`, PROXY_RETRY_JITTERS);
-    const retryOnStatuses = parseProxyRetryStatuses(value.retryOnStatuses, `${field}.retryOnStatuses`);
-    const retryOnMethods = parseProxyRetryMethods(value.retryOnMethods, `${field}.retryOnMethods`);
-    const respectRetryAfter = parseOptionalBoolean(value.respectRetryAfter, `${field}.respectRetryAfter`);
-    return {
-        ...(maxAttempts !== undefined ? { maxAttempts } : {}),
-        ...(initialDelayMs !== undefined ? { initialDelayMs } : {}),
-        ...(maxDelayMs !== undefined ? { maxDelayMs } : {}),
-        ...(jitter !== undefined ? { jitter } : {}),
-        ...(retryOnStatuses !== undefined ? { retryOnStatuses } : {}),
-        ...(retryOnMethods !== undefined ? { retryOnMethods } : {}),
-        ...(respectRetryAfter !== undefined ? { respectRetryAfter } : {})
-    };
-}
-function parseProxyRetryStatuses(input, field) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(input)) {
-        throw new Error(`${field} must be an array of HTTP status codes`);
-    }
-    const seen = new Set();
-    for (const entry of input) {
-        if (typeof entry !== "number" ||
-            !Number.isSafeInteger(entry) ||
-            entry < 100 ||
-            entry > 599) {
-            throw new Error(`${field} entries must be HTTP status codes between 100 and 599`);
-        }
-        seen.add(entry);
-    }
-    return Array.from(seen);
-}
-function parseProxyRetryMethods(input, field) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(input)) {
-        throw new Error(`${field} must be an array of HTTP methods`);
-    }
-    const seen = new Set();
-    for (const entry of input) {
-        if (typeof entry !== "string") {
-            throw new Error(`${field} entries must be strings`);
-        }
-        const upper = entry.toUpperCase();
-        if (!PROXY_ALLOWED_METHODS.includes(upper)) {
-            throw new Error(`${field} contains unsupported method: ${entry}`);
-        }
-        seen.add(upper);
-    }
-    return Array.from(seen);
-}
-function parseProxyBaseUrl(input, field) {
-    const raw = requireString(input, field);
-    let parsed;
-    try {
-        parsed = new URL(raw);
-    }
-    catch {
-        throw new Error(`${field} must be a valid absolute URL`);
-    }
-    if (parsed.protocol !== "https:") {
-        throw new Error(`${field} must use https://`);
-    }
-    if (parsed.username || parsed.password) {
-        throw new Error(`${field} must not embed credentials`);
-    }
-    if (parsed.search || parsed.hash) {
-        throw new Error(`${field} must not include a query string or fragment`);
-    }
-    // Normalize: strip trailing slash so prefix matching is predictable.
-    const normalized = `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
-    return normalized;
-}
-export function parseProxyAuthShape(input, field) {
-    const value = requireRecord(input, field);
-    const type = requireString(value.type, `${field}.type`);
-    switch (type) {
-        case "none":
-            assertOnlyKeys(value, field, ["type"]);
-            return { type: "none" };
-        case "bearer":
-            assertOnlyKeys(value, field, ["type"]);
-            return { type: "bearer" };
-        case "basic":
-            assertOnlyKeys(value, field, ["type"]);
-            return { type: "basic" };
-        case "header": {
-            assertOnlyKeys(value, field, ["type", "name"]);
-            const name = requireString(value.name, `${field}.name`);
-            assertHeaderName(name, `${field}.name`);
-            return { type: "header", name };
-        }
-        case "query": {
-            assertOnlyKeys(value, field, ["type", "name"]);
-            const name = requireString(value.name, `${field}.name`);
-            if (!/^[a-zA-Z0-9_\-.]{1,64}$/.test(name)) {
-                throw new Error(`${field}.name must be a URL-safe identifier (<=64 chars)`);
-            }
-            return { type: "query", name };
-        }
-        default:
-            throw new Error(`${field}.type must be one of: none, bearer, basic, header, query`);
-    }
-}
-export function parseProxyMethods(input, field) {
-    if (!Array.isArray(input) || input.length === 0) {
-        throw new Error(`${field} must be a non-empty array of HTTP methods`);
-    }
-    const seen = new Set();
-    for (const entry of input) {
-        if (typeof entry !== "string") {
-            throw new Error(`${field} entries must be strings`);
-        }
-        const upper = entry.toUpperCase();
-        if (!PROXY_ALLOWED_METHODS.includes(upper)) {
-            throw new Error(`${field} contains unsupported method: ${entry}`);
-        }
-        seen.add(upper);
-    }
-    return Array.from(seen);
-}
-export function parseProxyPathPrefixes(input, field) {
-    if (!Array.isArray(input) || input.length === 0) {
-        throw new Error(`${field} must be a non-empty array of path prefixes`);
-    }
-    const seen = new Set();
-    for (const entry of input) {
-        if (typeof entry !== "string" || !entry.startsWith("/")) {
-            throw new Error(`${field} entries must be non-empty strings starting with '/'`);
-        }
-        // Reject traversal / encoded traversal at config time so we never
-        // need to second-guess at request time.
-        if (entry.includes("..") || entry.toLowerCase().includes("%2e%2e")) {
-            throw new Error(`${field} entry must not contain path traversal: ${entry}`);
-        }
-        seen.add(entry);
-    }
-    return Array.from(seen);
-}
-export function parseProxyAllowedHeaders(input, field, authShape) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(input)) {
-        throw new Error(`${field} must be an array of header names`);
-    }
-    const seen = new Set();
-    const result = [];
-    for (const entry of input) {
-        if (typeof entry !== "string" || entry.length === 0) {
-            throw new Error(`${field} entries must be non-empty strings`);
-        }
-        const lower = entry.toLowerCase();
-        assertHeaderName(entry, field);
-        if (PROXY_DENY_HEADER_LIST.has(lower)) {
-            throw new Error(`${field} contains a forbidden header: ${entry}`);
-        }
-        const authHeader = authShapeHeaderName(authShape);
-        if (authHeader && lower === authHeader) {
-            throw new Error(`${field} must not contain the auth header for this endpoint (${authHeader}); the proxy injects it from secrets.proxyEndpointAuth`);
-        }
-        if (seen.has(lower)) {
-            continue;
-        }
-        seen.add(lower);
-        result.push(lower);
-    }
-    return result;
-}
-function assertHeaderName(value, field) {
-    // RFC 7230 token chars, conservative.
-    if (!/^[A-Za-z0-9!#$%&'*+\-.^_`|~]{1,64}$/.test(value)) {
-        throw new Error(`${field} must be a valid header token (<=64 chars): ${value}`);
-    }
-}
-function assertOnlyKeys(value, field, allowed) {
-    const permitted = new Set(allowed);
-    for (const key of Object.keys(value)) {
-        if (!permitted.has(key)) {
-            throw new Error(`${field}.${key} is not an allowed field; permitted: ${allowed.join(", ")}`);
-        }
-    }
-}
-export function crossValidateProxyEndpointsAndAuth(endpoints, auth) {
-    const endpointsList = endpoints ?? [];
-    const authList = auth ?? [];
-    const endpointsByName = new Map(endpointsList.map((e) => [e.name, e]));
-    const authByName = new Map(authList.map((a) => [a.name, a]));
-    for (const endpoint of endpointsList) {
-        const authEntry = authByName.get(endpoint.name);
-        if (endpoint.authShape.type === "none") {
-            // Keyless endpoints carry no auth value. Reject any matching
-            // auth entry so callers don't accidentally ship a secret bound
-            // to a "none" endpoint (which would be silently ignored at
-            // request time — confusing and a leak risk).
-            if (authEntry) {
-                throw new Error(`proxyEndpoints[${endpoint.name}] has authShape "none" but a matching secrets.proxyEndpointAuth entry was supplied; remove the auth entry`);
-            }
-            continue;
-        }
-        if (!authEntry) {
-            throw new Error(`proxyEndpoints[${endpoint.name}] has no matching secrets.proxyEndpointAuth entry`);
-        }
-        if (authEntry.value.type !== endpoint.authShape.type) {
-            throw new Error(`secrets.proxyEndpointAuth[${endpoint.name}].value.type must equal proxyEndpoints[${endpoint.name}].authShape.type (expected ${endpoint.authShape.type}, got ${authEntry.value.type})`);
-        }
-    }
-    for (const authEntry of authList) {
-        if (!endpointsByName.has(authEntry.name)) {
-            throw new Error(`secrets.proxyEndpointAuth[${authEntry.name}] has no matching proxyEndpoints entry`);
-        }
-    }
-}
 /**
  * Cross-check `submission.secretEnv` declarations against `secrets.envSecrets`
- * values. Mirrors {@link crossValidateProxyEndpointsAndAuth}:
+ * values:
  *
  *  - `{ ephemeral: true }` MUST have a matching `secrets.envSecrets` value.
  *  - `{ ref }` MUST NOT supply a value (the value lives in the workspace store).
@@ -658,18 +316,18 @@ export function crossValidateSecretEnvAndValues(secretEnv, envSecrets) {
     }
 }
 export function parseInlineSecrets(input) {
-    // A child run (parentRunId set) inherits its provider keys server-side from
-    // the parent's vault, so it may omit `secrets` entirely.
+    // Absent/null secrets collapse to an empty bundle; the credential-policy gate
+    // (enforceCredentialSecretPolicy) decides whether that is admissible for the
+    // run's mode (a run inheriting keys server-side may legitimately omit them).
     if (input === undefined || input === null)
         return {};
     const value = requireRecord(input, "secrets");
-    const allowedTopLevel = new Set(["apiKeys", "mcpServers", "proxyEndpointAuth", "envSecrets"]);
+    const allowedTopLevel = new Set(["apiKeys", "mcpServers", "envSecrets"]);
     for (const key of Object.keys(value)) {
         if (key.startsWith("__aex_")) {
-            // Platform-internal namespace (e.g. __aex_proxy_token). The BFF
-            // mutates the vaulted bundle to inject these; inbound submissions
-            // are never allowed to set them, to prevent a malicious caller
-            // from forging the bearer.
+            // Platform-internal namespace. The BFF may mutate the vaulted bundle
+            // to inject reserved values; inbound submissions are never allowed to
+            // set them.
             throw new Error(`secrets.${key} uses the platform-internal __aex_ namespace and may not be set by callers`);
         }
         if (!allowedTopLevel.has(key)) {
@@ -678,12 +336,10 @@ export function parseInlineSecrets(input) {
     }
     const apiKeys = parseApiKeys(value.apiKeys);
     const mcpServers = parseMcpServerSecrets(value.mcpServers);
-    const proxyEndpointAuth = parseProxyEndpointAuth(value.proxyEndpointAuth);
     const envSecrets = parseEnvSecrets(value.envSecrets);
     return {
         ...(apiKeys ? { apiKeys } : {}),
         ...(mcpServers ? { mcpServers } : {}),
-        ...(proxyEndpointAuth ? { proxyEndpointAuth } : {}),
         ...(envSecrets ? { envSecrets } : {})
     };
 }
@@ -754,103 +410,6 @@ function parseMcpServerSecret(input, path) {
     const headers = optionalStringRecord(value.headers, `${path}.headers`);
     return headers ? { name, url, headers } : { name, url };
 }
-function parseProxyEndpointAuth(input) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(input)) {
-        throw new Error("secrets.proxyEndpointAuth must be an array");
-    }
-    if (input.length === 0) {
-        return undefined;
-    }
-    const seen = new Set();
-    return input.map((entry, index) => {
-        const auth = parseProxyEndpointAuthEntry(entry, `secrets.proxyEndpointAuth[${index}]`);
-        if (seen.has(auth.name)) {
-            throw new Error(`secrets.proxyEndpointAuth duplicate name: ${auth.name}`);
-        }
-        seen.add(auth.name);
-        return auth;
-    });
-}
-function parseProxyEndpointAuthEntry(input, path) {
-    const value = requireRecord(input, path);
-    const allowed = new Set(["name", "value"]);
-    for (const key of Object.keys(value)) {
-        if (!allowed.has(key)) {
-            throw new Error(`${path}.${key} is not an allowed field; permitted: name, value`);
-        }
-    }
-    const name = requireString(value.name, `${path}.name`);
-    if (!PROXY_ENDPOINT_NAME_PATTERN.test(name)) {
-        throw new Error(`${path}.name must match the same pattern as proxyEndpoints[].name (lowercase letters, digits, '_' and '-'; <=63 chars)`);
-    }
-    const valueField = parseProxyAuthValue(value.value, `${path}.value`);
-    return { name, value: valueField };
-}
-function parseProxyAuthValue(input, path) {
-    const value = requireRecord(input, path);
-    const type = requireString(value.type, `${path}.type`);
-    switch (type) {
-        case "bearer": {
-            assertOnlyKeys(value, path, ["type", "token"]);
-            const token = requireSecretValue(value.token, `${path}.token`);
-            return { type: "bearer", token };
-        }
-        case "basic": {
-            assertOnlyKeys(value, path, ["type", "username", "password"]);
-            // Usernames are not redactable in the strict sense (often public
-            // identifiers like an email), so we only enforce non-emptiness.
-            // The password is the secret-bearing half.
-            const username = requireString(value.username, `${path}.username`);
-            const password = requireSecretValue(value.password, `${path}.password`);
-            return { type: "basic", username, password };
-        }
-        case "header": {
-            assertOnlyKeys(value, path, ["type", "value"]);
-            const headerValue = requireSecretValue(value.value, `${path}.value`);
-            return { type: "header", value: headerValue };
-        }
-        case "query": {
-            assertOnlyKeys(value, path, ["type", "value"]);
-            const queryValue = requireSecretValue(value.value, `${path}.value`);
-            return { type: "query", value: queryValue };
-        }
-        default:
-            throw new Error(`${path}.type must be one of: bearer, basic, header, query`);
-    }
-}
-/**
- * The proxy body-redactor refuses to mask any derived target string shorter
- * than this many bytes — masking a 1-byte literal would corrupt the response
- * body. This is the floor for the *derived* redaction targets (e.g.
- * `Bearer <token>`, base64 fragments), used by
- * the hosted proxy redactor, which imports this constant so the two sides can
- * never silently diverge.
- */
-export const MIN_REDACTION_TARGET_BYTES = 4;
-/**
- * Minimum byte length for an accepted proxy secret *value*. Strictly greater
- * than {@link MIN_REDACTION_TARGET_BYTES}: a secret short enough to fall under
- * the redactor's floor could slip through unmasked, so the submission parser
- * rejects it up front. The `satisfies` check below pins that invariant at
- * compile time.
- */
-const MIN_PROXY_SECRET_BYTES = 8;
-// Invariant: an accepted secret must always be long enough for the redactor to
-// mask it. If someone lowers MIN_PROXY_SECRET_BYTES below the redaction floor,
-// this errors at compile time.
-const _MIN_PROXY_SECRET_BYTES_OK = (MIN_PROXY_SECRET_BYTES >= MIN_REDACTION_TARGET_BYTES);
-void _MIN_PROXY_SECRET_BYTES_OK;
-function requireSecretValue(input, field) {
-    const value = requireString(input, field);
-    const byteLen = Buffer.byteLength(value, "utf8");
-    if (byteLen < MIN_PROXY_SECRET_BYTES) {
-        throw new Error(`${field} must be at least ${MIN_PROXY_SECRET_BYTES} bytes; shorter values cannot be reliably redacted from upstream responses`);
-    }
-    return value;
-}
 export function assertNoSecretBearingFields(input, path) {
     if (Array.isArray(input)) {
         input.forEach((item, index) => assertNoSecretBearingFields(item, [...path, String(index)]));
@@ -948,27 +507,6 @@ export function optionalPositiveNumber(input, field) {
     }
     return input;
 }
-function parseOptionalBoundedInt(input, field, min, max) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (typeof input !== "number" ||
-        !Number.isSafeInteger(input) ||
-        input < min ||
-        input > max) {
-        throw new Error(`${field} must be a safe integer between ${min} and ${max}`);
-    }
-    return input;
-}
-function parseOptionalBoolean(input, field) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (typeof input !== "boolean") {
-        throw new Error(`${field} must be a boolean`);
-    }
-    return input;
-}
 function isJsonValue(input) {
     if (typeof input === "number") {
         return Number.isFinite(input);
@@ -993,10 +531,9 @@ export function parseRunSubmissionRequest(input, options = {}) {
         "submission",
         "runtimeSize",
         "timeout",
-        "proxyEndpoints",
-        "parentRunId",
         "webhook",
         "limits",
+        "machine",
         SECRETS_KEY
     ]);
     for (const key of Object.keys(value)) {
@@ -1020,17 +557,11 @@ export function parseRunSubmissionRequest(input, options = {}) {
     void options;
     const runtimeSize = parseRuntimeSize(value.runtimeSize);
     const timeoutMs = parseRunTimeout(value.timeout);
-    // Lineage parent only. `depth` is NEVER accepted from the wire — the server
-    // derives it from the parent row (a forged depth must not bypass the cap).
-    const parentRunId = optionalString(value.parentRunId, "submission.parentRunId");
     const webhook = parseRunWebhook(value.webhook);
     const limits = parseRunLimits(value.limits);
-    const proxyEndpoints = parseProxyEndpoints(value.proxyEndpoints);
+    const machine = parseRunMachine(value.machine);
     const secrets = parseInlineSecrets(value.secrets);
-    enforceCredentialSecretPolicy(secrets, provider, {
-        inheritsFromParent: parentRunId !== undefined
-    });
-    crossValidateProxyEndpointsAndAuth(proxyEndpoints, secrets.proxyEndpointAuth);
+    enforceCredentialSecretPolicy(secrets, provider);
     const submission = parseSubmission(value.submission);
     assertRunModelMatchesProvider(provider, submission.model);
     crossValidateSecretEnvAndValues(submission.secretEnv, secrets.envSecrets);
@@ -1059,10 +590,9 @@ export function parseRunSubmissionRequest(input, options = {}) {
         submission,
         ...(runtimeSize ? { runtimeSize } : {}),
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(proxyEndpoints ? { proxyEndpoints } : {}),
-        ...(parentRunId !== undefined ? { parentRunId } : {}),
         ...(webhook !== undefined ? { webhook } : {}),
         ...(limits !== undefined ? { limits } : {}),
+        ...(machine !== undefined ? { machine } : {}),
         secrets
     };
 }
@@ -1141,6 +671,53 @@ export function parseRunLimits(input) {
         ...(maxSpendUsd !== undefined ? { maxSpendUsd } : {})
     };
 }
+/**
+ * Boot-session budget fragment. The public submit surface names a run's spend
+ * cap `limits.maxSpendUsd`; the frozen boot session config the managed runtime
+ * folds the loop against names the SAME USD value `budgetUsd` — the field the
+ * session planner reads to enforce/terminate a run that would out-spend its cap.
+ * This is the single source of truth for that wire→boot name mapping so the two
+ * layers can never drift.
+ *
+ * Returns a fragment safe to spread into `sessionConfig.limits`: `{ budgetUsd }`
+ * when a cap is set, `{}` when none is (an absent cap stays absent — the run is
+ * unbounded per-run, subject only to the run timeout + the per-workspace cap).
+ * Pure: same input ⇒ same output.
+ */
+export function sessionBudgetLimits(limits) {
+    if (limits?.maxSpendUsd === undefined) {
+        return {};
+    }
+    return { budgetUsd: limits.maxSpendUsd };
+}
+/**
+ * Parse the optional per-run `machine` capacity intent. Mirrors
+ * {@link parseRunWebhook}: absent ⇒ `undefined`; a non-object or any unknown
+ * subfield is rejected so the strict top-level allow-list extends to the nested
+ * object. `spot` must be a boolean when present. A no-signal object (e.g.
+ * `machine: {}`) collapses to `undefined` so it never lands an empty object on
+ * the request. An explicit `spot` (true or false) is preserved verbatim. Only
+ * shape is validated here — capacity selection is a runtime concern.
+ */
+export function parseRunMachine(input) {
+    if (input === undefined) {
+        return undefined;
+    }
+    const value = requireRecord(input, "machine");
+    const allowed = new Set(["spot"]);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throw new Error(`machine.${key} is not an allowed field; permitted: ${[...allowed].join(", ")}`);
+        }
+    }
+    if (value.spot !== undefined && typeof value.spot !== "boolean") {
+        throw new Error("machine.spot must be a boolean");
+    }
+    if (value.spot === undefined) {
+        return undefined;
+    }
+    return { spot: value.spot };
+}
 export function parseRunProvider(input) {
     if (input === undefined) {
         return DEFAULT_RUN_PROVIDER;