@aexhq/sdk 0.35.0 → 0.37.0

package/dist/cli.mjs

@@ -10,34 +10,6 @@ import { readFile, writeFile, readdir, stat, mkdir, chmod, rm } from "node:fs/pr
 import { resolve as resolvePath4, join, dirname as dirname2 } from "node:path";
 import { homedir } from "node:os";
 
-// ../contracts/dist/proxy-protocol.js
-var PROXY_PROTOCOL_VERSION_V2 = "2";
-var PROXY_PROTOCOL_HEADER = "x-aex-proxy-protocol";
-var PROXY_RESP_STATUS_HEADER = "x-aex-proxy-status";
-var PROXY_RESP_MODE_HEADER = "x-aex-proxy-effective-mode";
-var PROXY_RESP_TRUNCATED_HEADER = "x-aex-proxy-truncated";
-var PROXY_RESP_UPSTREAM_HEADERS_HEADER = "x-aex-proxy-upstream-headers";
-var PROXY_METHOD_HEADER = "x-aex-method";
-var PROXY_PATH_HEADER = "x-aex-path";
-var PROXY_QUERY_HEADER = "x-aex-query";
-var PROXY_HEADERS_HEADER = "x-aex-headers";
-var PROXY_RESPONSE_MODE_HEADER = "x-aex-response-mode";
-var PROXY_RESPONSE_MODES = ["status_only", "headers_only", "full"];
-var PROXY_ENDPOINT_DEFAULTS = {
-  allowHeaders: [],
-  responseMode: "headers_only",
-  // 10 MiB. The body is buffered in the hosted API to enforce this cap, while the
-  // launch default fits practical multimodal/tool POSTs without every endpoint
-  // needing an override.
-  maxRequestBytes: 10 * 1024 * 1024,
-  // Unlimited (0). The request body is buffered to enforce its cap, so that
-  // stays finite; the response is streamed, so it does not need one.
-  maxResponseBytes: 0,
-  // 5 minutes. Long-running upstream tool/model calls should not fail under a
-  // development-oriented 10s ceiling; endpoints can still set a smaller value.
-  timeoutMs: 5 * 60 * 1e3
-};
-
 // ../contracts/dist/provider-support.js
 var COMMON_DOCS = [
   { label: "Secrets", href: "secrets.md" },
@@ -156,6 +128,46 @@ var MODEL_PROVIDER_IDS = {
   }
 };
 var RUN_MODELS = Object.keys(MODEL_PROVIDER_IDS);
+var Models = {
+  /** Claude Haiku 4.5 — Anthropic. */
+  CLAUDE_HAIKU_4_5: "claude-haiku-4-5",
+  /** Claude 3.5 Haiku (latest) — Anthropic. */
+  CLAUDE_3_5_HAIKU_LATEST: "claude-3-5-haiku-latest",
+  /** Claude 3.5 Sonnet (latest) — Anthropic. */
+  CLAUDE_3_5_SONNET_LATEST: "claude-3-5-sonnet-latest",
+  /** Claude Sonnet 4.6 — Anthropic (1M context, reasoning-capable). */
+  CLAUDE_SONNET_4_6: "claude-sonnet-4-6",
+  /** DeepSeek V4 Flash — DeepSeek (non-thinking, fast). */
+  DEEPSEEK_V4_FLASH: "deepseek-v4-flash",
+  /** DeepSeek V4 Pro — DeepSeek (reasoning-heavy). */
+  DEEPSEEK_V4_PRO: "deepseek-v4-pro",
+  /** GPT-4.1 — OpenAI. */
+  GPT_4_1: "gpt-4.1",
+  /** GPT-4o mini — OpenAI, or via OpenRouter (`provider: Providers.OPENROUTER`). */
+  GPT_4O_MINI: "gpt-4o-mini",
+  /** GPT-4o — via OpenRouter (`provider: Providers.OPENROUTER`). */
+  GPT_4O: "gpt-4o",
+  /** Gemini 2.0 Flash — Gemini, or via OpenRouter (`provider: Providers.OPENROUTER`). */
+  GEMINI_2_0_FLASH: "gemini-2.0-flash",
+  /** Gemini 2.5 Flash — Gemini. */
+  GEMINI_2_5_FLASH: "gemini-2.5-flash",
+  /** Mistral Large (latest) — Mistral. */
+  MISTRAL_LARGE_LATEST: "mistral-large-latest",
+  /** Mistral Small (latest) — Mistral. */
+  MISTRAL_SMALL_LATEST: "mistral-small-latest",
+  /**
+   * Doubao Seed 1.8 — ByteDance, via the official Ark API. Default routes
+   * through the international BytePlus gateway (`Providers.DOUBAO`); pair with
+   * `Providers.DOUBAO_CN` for the China Volcengine gateway.
+   */
+  DOUBAO_SEED_PRO: "doubao-seed-pro",
+  /**
+   * Doubao Seed 1.6 Flash — ByteDance, via the official Ark API (fast/cheap).
+   * Default `Providers.DOUBAO` (international); pair with `Providers.DOUBAO_CN`
+   * for China.
+   */
+  DOUBAO_SEED_FLASH: "doubao-seed-flash"
+};
 var PROVIDERS_BY_MODEL = (() => {
   const map = {};
   for (const [model, providers] of Object.entries(MODEL_PROVIDER_IDS)) {
@@ -199,6 +211,15 @@ var TERMINAL_RUN_STATUSES = [
   "cleanup_failed"
 ];
 var terminalRunStatuses = new Set(TERMINAL_RUN_STATUSES);
+var CLEANUP_STATUSES = [
+  "not_started",
+  "pending",
+  "running",
+  "succeeded",
+  "failed_retryable",
+  "failed_terminal",
+  "skipped"
+];
 
 // ../contracts/dist/run-config.js
 var SKILL_BUNDLE_LIMITS = {
@@ -392,7 +413,6 @@ function parseRunRequestConfig(input) {
     "environment",
     "runtimeSize",
     "timeout",
-    "proxyEndpoints",
     "metadata"
   ]);
   for (const key of Object.keys(record)) {
@@ -412,14 +432,13 @@ function parseRunRequestConfig(input) {
     ...system !== void 0 ? { system } : {},
     prompt,
     ...mcpServers !== void 0 ? { mcpServers } : {},
-    // environment / proxyEndpoints / metadata: passed through
-    // as-is — the BFF revalidates them via `parseRunSubmissionRequest`,
+    // environment / metadata: passed through as-is — the BFF revalidates
+    // them via `parseRunSubmissionRequest`,
     // so duplicating the heavyweight parsers here would mean two sources
     // of truth. The CLI surfaces structural errors at submission time.
     ...record.environment !== void 0 ? { environment: record.environment } : {},
     ...record.runtimeSize !== void 0 ? { runtimeSize: record.runtimeSize } : {},
     ...record.timeout !== void 0 ? { timeout: record.timeout } : {},
-    ...record.proxyEndpoints !== void 0 ? { proxyEndpoints: record.proxyEndpoints } : {},
     ...record.metadata !== void 0 ? { metadata: record.metadata } : {}
   };
 }
@@ -475,8 +494,8 @@ var RUNTIME_SIZE_PRESETS = {
 };
 var RUNTIME_SIZES = Object.keys(RUNTIME_SIZE_PRESETS);
 var DEFAULT_RUNTIME_SIZE = "shared-0.25x-1gb";
-var DEFAULT_RUN_TIMEOUT_MS = 60 * 60 * 1e3;
-var MAX_RUN_TIMEOUT_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_RUN_TIMEOUT_MS = 8 * 60 * 60 * 1e3;
+var MAX_RUN_TIMEOUT_MS = 8 * 60 * 60 * 1e3;
 var MIN_RUN_TIMEOUT_MS = 60 * 1e3;
 var RUN_PROCESS_KILL_GRACE_MS = 60 * 1e3;
 var RUN_TERMINAL_GRACE_MS = 90 * 1e3;
@@ -489,7 +508,6 @@ var RUNTIME_SECURITY_PROFILE_CONFIG = Object.freeze({
     allowOpenNetworking: false,
     allowRuntimePackages: false,
     allowCustomerEnvVars: true,
-    allowProxyEndpoints: true,
     allowMcpServers: true
   }),
   standard: Object.freeze({
@@ -498,7 +516,6 @@ var RUNTIME_SECURITY_PROFILE_CONFIG = Object.freeze({
     allowOpenNetworking: true,
     allowRuntimePackages: true,
     allowCustomerEnvVars: true,
-    allowProxyEndpoints: true,
     allowMcpServers: true
   }),
   developer: Object.freeze({
@@ -507,12 +524,12 @@ var RUNTIME_SECURITY_PROFILE_CONFIG = Object.freeze({
     allowOpenNetworking: true,
     allowRuntimePackages: true,
     allowCustomerEnvVars: true,
-    allowProxyEndpoints: true,
     allowMcpServers: true
   })
 });
 
 // ../contracts/dist/submission.js
+var PLATFORM_PACKAGE_ECOSYSTEMS = ["apt", "npm", "pip"];
 var RUN_PROVIDERS = [
   "anthropic",
   "deepseek",
@@ -524,9 +541,6 @@ var RUN_PROVIDERS = [
   "doubao-cn"
 ];
 var DEFAULT_RUN_PROVIDER = "anthropic";
-var MIN_REDACTION_TARGET_BYTES = 4;
-var MIN_PROXY_SECRET_BYTES = 8;
-var _MIN_PROXY_SECRET_BYTES_OK = MIN_PROXY_SECRET_BYTES >= MIN_REDACTION_TARGET_BYTES;
 var BUILTIN_TOOL_NAMES = [
   "bash",
   "read_file",
@@ -566,12 +580,17 @@ var AEX_EVENT_TYPES = [
   // off-the-shelf AG-UI client filters logs out by `channel`.
   "LOG"
 ];
+var AEX_SESSION_PARKED_NAMES = ["aex.session.idle", "aex.session.error", "aex.session.suspended"];
+function isSessionParked(e) {
+  const name = customName(e);
+  return name !== null && AEX_SESSION_PARKED_NAMES.includes(name);
+}
 function customName(e) {
   return e.type === "CUSTOM" ? str(e.data.name) || null : null;
 }
 var AEX_RUN_SETTLED_NAME = "aex.run.settled";
 function isRunSettled(e) {
-  return customName(e) === AEX_RUN_SETTLED_NAME;
+  return customName(e) === AEX_RUN_SETTLED_NAME || isSessionParked(e);
 }
 function channelOf(e) {
   return e.channel ?? "event";
@@ -629,7 +648,7 @@ function str(v) {
 var encoder = new TextEncoder();
 
 // ../contracts/dist/event-stream-client.js
-var isTerminalType = (e) => e.type === "RUN_FINISHED" || e.type === "RUN_ERROR";
+var isTerminalType = (e) => e.type === "RUN_FINISHED" || e.type === "RUN_ERROR" || isSessionParked(e);
 var COORDINATOR_PING = "aex:ping";
 var DEFAULT_IDLE_TIMEOUT_MS = 45e3;
 var DEFAULT_PING_INTERVAL_MS = 15e3;
@@ -787,6 +806,191 @@ function sleep(ms, signal) {
   });
 }
 
+// ../contracts/dist/run-unit.js
+function parseRunUnitSubmission(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return fallbackFlat();
+  }
+  const value = input;
+  if (value.kind === "submission") {
+    return parseFlatProjection(value);
+  }
+  return fallbackFlat();
+}
+function parseFlatProjection(value) {
+  const submissionRaw = isRecord(value.submission) ? value.submission : {};
+  const outputsRaw = isRecord(submissionRaw.outputs) ? submissionRaw.outputs : {};
+  const allowedDirs = toOptionalStringArray(outputsRaw.allowedDirs);
+  const deniedDirs = toOptionalStringArray(outputsRaw.deniedDirs);
+  const captureTimeoutMs = toOptionalPositiveInteger(outputsRaw.captureTimeoutMs);
+  const maxFileBytes = toOptionalPositiveInteger(outputsRaw.maxFileBytes);
+  const maxTotalBytes = toOptionalPositiveInteger(outputsRaw.maxTotalBytes);
+  const maxFiles = toOptionalPositiveInteger(outputsRaw.maxFiles);
+  const submission = {
+    model: coerceRunUnitModel(submissionRaw.model),
+    ...typeof submissionRaw.system === "string" ? { system: submissionRaw.system } : {},
+    prompt: toStringArray(submissionRaw.prompt),
+    agentsMd: [],
+    files: [],
+    mcpServers: toMcpServerRefArray(submissionRaw.mcpServers),
+    tools: [],
+    ...parseEnvironment(submissionRaw.environment) ? { environment: parseEnvironment(submissionRaw.environment) } : {},
+    ...parseSecurityProfile(submissionRaw.securityProfile) ? { securityProfile: parseSecurityProfile(submissionRaw.securityProfile) } : {},
+    ...isJsonRecord(submissionRaw.metadata) ? { metadata: submissionRaw.metadata } : {},
+    ...allowedDirs || deniedDirs || captureTimeoutMs !== void 0 || maxFileBytes !== void 0 || maxTotalBytes !== void 0 || maxFiles !== void 0 ? {
+      outputs: {
+        ...allowedDirs ? { allowedDirs } : {},
+        ...deniedDirs ? { deniedDirs } : {},
+        ...captureTimeoutMs !== void 0 ? { captureTimeoutMs } : {},
+        ...maxFileBytes !== void 0 ? { maxFileBytes } : {},
+        ...maxTotalBytes !== void 0 ? { maxTotalBytes } : {},
+        ...maxFiles !== void 0 ? { maxFiles } : {}
+      }
+    } : {}
+  };
+  return {
+    kind: "submission",
+    submission
+  };
+}
+function parseSecurityProfile(value) {
+  return value === "strict" || value === "standard" || value === "developer" ? value : void 0;
+}
+function toOptionalPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function fallbackFlat() {
+  return {
+    kind: "submission",
+    submission: {
+      model: Models.CLAUDE_HAIKU_4_5,
+      prompt: [],
+      agentsMd: [],
+      files: [],
+      mcpServers: [],
+      tools: []
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeRunUnit(raw) {
+  const r = isRecord(raw) ? raw : {};
+  const eventsRaw = isRecord(r.events) ? r.events : {};
+  const str3 = (v) => typeof v === "string" ? v : void 0;
+  const arr = (v) => Array.isArray(v) ? v : [];
+  return {
+    id: str3(r.id) ?? "",
+    workspaceId: str3(r.workspaceId) ?? "",
+    status: str3(r.status) ?? "unknown",
+    ...str3(r.lifecyclePhase) ? { lifecyclePhase: r.lifecyclePhase } : {},
+    cleanupStatus: CLEANUP_STATUSES.includes(r.cleanupStatus) ? r.cleanupStatus : "not_started",
+    createdAt: str3(r.createdAt) ?? "",
+    updatedAt: str3(r.updatedAt) ?? "",
+    ...str3(r.startedAt) ? { startedAt: r.startedAt } : {},
+    ...str3(r.terminalAt) ? { terminalAt: r.terminalAt } : {},
+    ...str3(r.deletedAt) ? { deletedAt: r.deletedAt } : {},
+    attemptCount: typeof r.attemptCount === "number" ? r.attemptCount : Array.isArray(r.attempts) ? r.attempts.length : 0,
+    submission: parseRunUnitSubmission(r.submission),
+    ...isRecord(r.capsSnapshot) ? { capsSnapshot: r.capsSnapshot } : {},
+    attempts: arr(r.attempts),
+    events: {
+      entries: arr(eventsRaw.entries),
+      totalCount: typeof eventsRaw.totalCount === "number" ? eventsRaw.totalCount : 0,
+      truncated: eventsRaw.truncated === true,
+      ...str3(eventsRaw.nextCursor) ? { nextCursor: eventsRaw.nextCursor } : {}
+    },
+    rawEventPages: arr(r.rawEventPages),
+    outputs: arr(r.outputs),
+    outputCaptureFailures: arr(r.outputCaptureFailures),
+    ...isRecord(r.costTelemetry) ? { costTelemetry: r.costTelemetry } : {},
+    ...isRecord(r.runtimeManifest) ? { runtimeManifest: r.runtimeManifest } : {}
+  };
+}
+function coerceRunUnitModel(value) {
+  if (typeof value !== "string")
+    return Models.CLAUDE_HAIKU_4_5;
+  try {
+    return parseRunModel(value, "run unit submission.model");
+  } catch {
+    return Models.CLAUDE_HAIKU_4_5;
+  }
+}
+function isJsonRecord(value) {
+  return isRecord(value);
+}
+function toStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string");
+}
+function toOptionalStringArray(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return void 0;
+  }
+  const filtered = value.filter((item) => typeof item === "string");
+  return filtered.length === 0 ? void 0 : filtered;
+}
+function toMcpServerRefArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const out = [];
+  for (let i2 = 0; i2 < value.length; i2++) {
+    try {
+      out.push(parseMcpServerRef(value[i2], `submission.mcpServers[${i2}]`));
+    } catch {
+    }
+  }
+  return out;
+}
+function parseEnvironment(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const env = {};
+  if (isRecord(value.networking)) {
+    const mode = value.networking.mode;
+    const allowedHosts = value.networking.allowedHosts;
+    if (mode === "limited" || mode === "open") {
+      env.networking = {
+        mode,
+        ...Array.isArray(allowedHosts) ? { allowedHosts: toStringArray(allowedHosts) } : {}
+      };
+    }
+  }
+  if (Array.isArray(value.packages)) {
+    const pkgs = value.packages.filter(isRecord).map((p) => {
+      const r = p;
+      if (typeof r.name !== "string")
+        return null;
+      const ecosystem = typeof r.ecosystem === "string" && PLATFORM_PACKAGE_ECOSYSTEMS.includes(r.ecosystem) ? r.ecosystem : "apt";
+      return {
+        name: r.name,
+        ...typeof r.version === "string" ? { version: r.version } : {},
+        ecosystem
+      };
+    }).filter((p) => p !== null);
+    if (pkgs.length > 0) {
+      env.packages = pkgs;
+    }
+  }
+  if (isRecord(value.envVars)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value.envVars)) {
+      if (typeof v === "string") {
+        out[k] = v;
+      }
+    }
+    if (Object.keys(out).length > 0) {
+      env.envVars = out;
+    }
+  }
+  return env.networking || env.packages || env.envVars ? env : void 0;
+}
+
 // ../contracts/dist/runtime-manifest.js
 var RUNTIME_PATHS = Object.freeze({
   skillsRoot: "/workspace/skills",
@@ -1365,6 +1569,8 @@ __export(operations_exports, {
   cancelRun: () => cancelRun,
   cancelSession: () => cancelSession,
   classifyOutput: () => classifyOutput,
+  createBillingCheckout: () => createBillingCheckout,
+  createBillingPortal: () => createBillingPortal,
   createOutputLink: () => createOutputLink,
   createSecret: () => createSecret,
   createSession: () => createSession,
@@ -1384,6 +1590,8 @@ __export(operations_exports, {
   findOutput: () => findOutput,
   findOutputs: () => findOutputs,
   getAgentsMd: () => getAgentsMd,
+  getBilling: () => getBilling,
+  getBillingLedger: () => getBillingLedger,
   getCoordinatorTicket: () => getCoordinatorTicket,
   getFile: () => getFile,
   getRun: () => getRun,
@@ -1393,6 +1601,7 @@ __export(operations_exports, {
   getSecretValue: () => getSecretValue,
   getSession: () => getSession,
   getSessionCoordinatorTicket: () => getSessionCoordinatorTicket,
+  getWebhookSigningSecret: () => getWebhookSigningSecret,
   listAgentsMd: () => listAgentsMd,
   listFiles: () => listFiles,
   listOutputs: () => listOutputs,
@@ -1400,6 +1609,7 @@ __export(operations_exports, {
   listRuns: () => listRuns,
   listSecrets: () => listSecrets,
   listSessionEvents: () => listSessionEvents,
+  listSessionMessages: () => listSessionMessages,
   listSessionOutputs: () => listSessionOutputs,
   listSessions: () => listSessions,
   normalizeOutputLinkExpiresIn: () => normalizeOutputLinkExpiresIn,
@@ -2138,7 +2348,7 @@ async function getRun(http, runId) {
   return hasRun(result) ? result.run : result;
 }
 async function getRunUnit(http, runId) {
-  return http.request(`/api/runs/${encodeURIComponent(runId)}`);
+  return normalizeRunUnit(await http.request(`/api/runs/${encodeURIComponent(runId)}`));
 }
 async function listRuns(http, query) {
   const params = {};
@@ -2188,6 +2398,16 @@ async function sendSessionMessage(http, sessionId, request, options) {
     body: JSON.stringify(request)
   });
 }
+async function listSessionMessages(http, sessionId, query) {
+  const params = {};
+  if (query?.limit !== void 0)
+    params.limit = String(query.limit);
+  if (query?.cursor !== void 0)
+    params.cursor = query.cursor;
+  if (query?.since !== void 0)
+    params.since = query.since;
+  return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/messages`, {}, params);
+}
 async function suspendSession(http, sessionId, options) {
   const headers = idempotencyHeaders(options);
   return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/suspend`, { method: "POST", ...headers ? { headers } : {} });
@@ -2411,6 +2631,30 @@ async function deleteWorkspaceAsset(http, hash) {
 async function whoami(http) {
   return http.request("/api/whoami");
 }
+async function getBilling(http) {
+  return http.request("/api/billing");
+}
+async function createBillingCheckout(http, request) {
+  return http.request("/api/billing/checkout", {
+    method: "POST",
+    body: JSON.stringify(request)
+  });
+}
+async function createBillingPortal(http, request = {}) {
+  return http.request("/api/billing/portal", {
+    method: "POST",
+    body: JSON.stringify(request)
+  });
+}
+async function getBillingLedger(http, query) {
+  const params = {};
+  if (query?.limit !== void 0)
+    params.limit = String(query.limit);
+  return http.request("/api/billing/ledger", {}, params);
+}
+async function getWebhookSigningSecret(http) {
+  return http.request("/api/webhook/signing-secret", { method: "POST" });
+}
 async function collectArtifactBytes(http, runId, items, zipPrefix, namespace2) {
   const entries = [];
   const captured = [];
@@ -2677,7 +2921,7 @@ function jsonlEntry(path, events) {
 }
 function extractSubmissionSnapshot(run) {
   const raw = run.submission;
-  if (!isRecord(raw) || raw.kind !== "submission" || !isRecord(raw.submission)) {
+  if (!isRecord2(raw) || raw.kind !== "submission" || !isRecord2(raw.submission)) {
     return void 0;
   }
   return {
@@ -2686,9 +2930,9 @@ function extractSubmissionSnapshot(run) {
 }
 function extractCostTelemetry(run) {
   const raw = run.costTelemetry;
-  return isRecord(raw) ? raw : void 0;
+  return isRecord2(raw) ? raw : void 0;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function submitRun(http, request) {
@@ -2800,34 +3044,8 @@ async function uploadWorkspaceAsset(http, input) {
   });
 }
 
-// ../contracts/dist/proxy-validation.js
-function validateProxyAuth(endpoints, auth) {
-  const authList = auth ?? [];
-  const endpointNames = new Set(endpoints.map((e) => e.name));
-  const authNames = /* @__PURE__ */ new Set();
-  for (const entry of authList) {
-    if (authNames.has(entry.name)) {
-      throw new Error(`secrets.proxyEndpointAuth contains duplicate name '${entry.name}'`);
-    }
-    authNames.add(entry.name);
-    if (!endpointNames.has(entry.name)) {
-      throw new Error(`secrets.proxyEndpointAuth[].name='${entry.name}' has no matching proxyEndpoints[].name`);
-    }
-  }
-  for (const endpoint of endpoints) {
-    const match = authList.find((a) => a.name === endpoint.name);
-    if (!match) {
-      throw new Error(`proxyEndpoints[].name='${endpoint.name}' is missing a matching secrets.proxyEndpointAuth entry`);
-    }
-    if (match.value.type !== endpoint.authShape.type) {
-      throw new Error(`secrets.proxyEndpointAuth[name='${endpoint.name}'].value.type='${match.value.type}' does not match proxyEndpoints[name='${endpoint.name}'].authShape.type='${endpoint.authShape.type}'`);
-    }
-  }
-}
-
 // dist/internal.js
 var AEX_INDEX_PATH = "/mnt/session/uploads/aex/index.json";
-var AEX_RUN_TOKEN_PATH = "/mnt/session/uploads/aex/run-token";
 
 // dist/host/common.js
 var SUCCESS = { code: 0 };
@@ -2835,7 +3053,7 @@ var USAGE_ERR = { code: 2 };
 var RUNTIME_ERR = { code: 1 };
 var TIMEOUT_ERR = { code: 3 };
 var TERMINAL_STATUSES = new Set(TERMINAL_RUN_STATUSES);
-function isSessionParked(status2) {
+function isSessionParked2(status2) {
   return status2 === "idle" || status2 === "suspended" || status2 === "error" || TERMINAL_STATUSES.has(status2);
 }
 function isSessionOk(status2) {
@@ -2922,6 +3140,8 @@ function describeApiError(err2) {
   return { code: "error", message: err2 instanceof Error ? err2.message : String(err2) };
 }
 function remedyForStatus(status2) {
+  if (status2 === 400)
+    return "malformed request \u2014 if this is an auth failure, check --api-token or run `aex login`";
   if (status2 === 401)
     return "check --api-token, or run `aex login`";
   if (status2 === 403)
@@ -2986,7 +3206,7 @@ async function refuseInsideManagedRun(io2, verb) {
   try {
     await io2.readFile(AEX_INDEX_PATH);
     io2.stderr(`\`aex ${verb}\` is a host command and cannot run inside a managed run container.
-Use \`aex proxy ...\` to call your declared upstream endpoints from inside the run.
+Make HTTP calls from your code and pass credentials through secrets.
 `);
     return true;
   } catch (err2) {
@@ -3171,285 +3391,6 @@ async function runOutputsSyncCmd(io2, dirs) {
   return SUCCESS;
 }
 
-// dist/proxy.js
-function parseProxyFlags(rest) {
-  let endpointName = null;
-  let method = "GET";
-  let path = "/";
-  let query = null;
-  const headers = /* @__PURE__ */ new Map();
-  let dataSpec = null;
-  let responseMode = null;
-  let showHelp = false;
-  for (let i2 = 0; i2 < rest.length; i2++) {
-    const arg = rest[i2];
-    if (arg === "--help" || arg === "-h") {
-      showHelp = true;
-      continue;
-    }
-    if (arg === "--method") {
-      method = expect(rest, ++i2, "--method");
-      continue;
-    }
-    if (arg === "--path") {
-      path = expect(rest, ++i2, "--path");
-      continue;
-    }
-    if (arg === "--query") {
-      query = expect(rest, ++i2, "--query");
-      continue;
-    }
-    if (arg === "--header") {
-      const kv = expect(rest, ++i2, "--header");
-      const eq = kv.indexOf("=");
-      if (eq <= 0)
-        return { ok: false, reason: "--header must be in the form KEY=VALUE" };
-      headers.set(kv.slice(0, eq).toLowerCase(), kv.slice(eq + 1));
-      continue;
-    }
-    if (arg === "--data") {
-      dataSpec = expect(rest, ++i2, "--data");
-      continue;
-    }
-    if (arg === "--response-mode") {
-      responseMode = expect(rest, ++i2, "--response-mode");
-      continue;
-    }
-    if (arg.startsWith("--")) {
-      return { ok: false, reason: `unknown flag: ${arg}` };
-    }
-    if (endpointName === null) {
-      endpointName = arg;
-      continue;
-    }
-    return { ok: false, reason: `unexpected positional argument: ${arg}` };
-  }
-  return { ok: true, flags: { endpointName, method, path, query, headers, dataSpec, responseMode, showHelp } };
-}
-function expect(arr, idx, flag) {
-  const v = arr[idx];
-  if (v === void 0) {
-    throw new CliUsageError(`${flag} requires a value`);
-  }
-  return v;
-}
-var CliUsageError = class extends Error {
-};
-async function printProxyHelp(io2) {
-  io2.stdout("aex proxy \u2014 call an upstream HTTP endpoint via the managed proxy.\n\n");
-  io2.stdout("Usage:\n");
-  io2.stdout("  aex proxy <endpoint-name> [flags]\n\n");
-  io2.stdout("Flags:\n");
-  io2.stdout("  --method <verb>          HTTP method (default: GET)\n");
-  io2.stdout("  --path <path>            Caller-supplied path; must match policy prefixes\n");
-  io2.stdout(`  --query <json>           JSON object of query parameters (e.g. '{"q":"x"}')
-`);
-  io2.stdout("  --header K=V             Add a caller header (repeatable)\n");
-  io2.stdout("  --data <value>           Request body. Use '-' for stdin, '@<file>' for file content\n");
-  io2.stdout("  --response-mode <mode>   status_only | headers_only | full (may only narrow policy)\n");
-  io2.stdout("  --help                   Show this message\n\n");
-  const manifest = await tryReadManifest(io2);
-  if (manifest && manifest.endpoints.length > 0) {
-    io2.stdout("Declared endpoints:\n");
-    for (const ep of manifest.endpoints) {
-      io2.stdout(`  \u2022 ${formatProxyEndpointSummary(ep)}
-`);
-    }
-  }
-  return SUCCESS;
-}
-function formatProxyEndpointSummary(ep) {
-  const retry = ep.retry ? `, retry=${ep.retry.maxAttempts}x ${ep.retry.retryOnMethods.join("/")} ${ep.retry.retryOnStatuses.join("/")} delay=${ep.retry.initialDelayMs}-${ep.retry.maxDelayMs}ms jitter=${ep.retry.jitter}${ep.retry.respectRetryAfter ? " retry-after" : ""}` : "";
-  return `${ep.name}: ${ep.allowMethods.join(",")} ${ep.allowPathPrefixes.join(",")} (mode=${ep.responseMode}${retry})`;
-}
-async function runProxy(io2, rest) {
-  let parsed;
-  try {
-    parsed = parseProxyFlags(rest);
-  } catch (err2) {
-    if (err2 instanceof CliUsageError) {
-      io2.stderr(`${err2.message}
-`);
-      return USAGE_ERR;
-    }
-    throw err2;
-  }
-  if (!parsed.ok) {
-    io2.stderr(`${parsed.reason}
-`);
-    return USAGE_ERR;
-  }
-  const f = parsed.flags;
-  if (f.showHelp) {
-    return await printProxyHelp(io2);
-  }
-  if (!f.endpointName) {
-    io2.stderr("missing endpoint-name\n");
-    io2.stderr("usage: aex proxy <endpoint-name> [flags]\n");
-    return USAGE_ERR;
-  }
-  if (f.responseMode && !PROXY_RESPONSE_MODES.includes(f.responseMode)) {
-    io2.stderr(`--response-mode must be one of: ${PROXY_RESPONSE_MODES.join(", ")}
-`);
-    return USAGE_ERR;
-  }
-  const manifest = await tryReadManifest(io2);
-  if (!manifest) {
-    emitError(io2, {
-      error: "internal_error",
-      message: "manifest not mounted; this CLI must run inside an aex-managed run"
-    });
-    return RUNTIME_ERR;
-  }
-  if (!manifest.proxyBaseUrl) {
-    emitError(io2, {
-      error: "endpoint_not_found",
-      message: "this run has no proxy endpoints declared",
-      endpointName: f.endpointName
-    });
-    return RUNTIME_ERR;
-  }
-  let token;
-  try {
-    token = (await io2.readFile(AEX_RUN_TOKEN_PATH)).trim();
-  } catch {
-    emitError(io2, {
-      error: "unauthorized",
-      message: "run token file missing; this run has no proxy bearer"
-    });
-    return RUNTIME_ERR;
-  }
-  if (!token) {
-    emitError(io2, { error: "unauthorized", message: "run token is empty" });
-    return RUNTIME_ERR;
-  }
-  let body;
-  if (f.dataSpec !== null) {
-    try {
-      body = await resolveBody(io2, f.dataSpec);
-    } catch (err2) {
-      io2.stderr(`failed to read request body: ${err2.message}
-`);
-      return RUNTIME_ERR;
-    }
-  }
-  const url = `${manifest.proxyBaseUrl.replace(/\/+$/, "")}/${encodeURIComponent(f.endpointName)}`;
-  const requestHeaders = new Headers();
-  requestHeaders.set("authorization", `Bearer ${token}`);
-  requestHeaders.set(PROXY_PROTOCOL_HEADER, PROXY_PROTOCOL_VERSION_V2);
-  requestHeaders.set(PROXY_METHOD_HEADER, f.method.toUpperCase());
-  requestHeaders.set(PROXY_PATH_HEADER, f.path);
-  if (f.query) {
-    requestHeaders.set(PROXY_QUERY_HEADER, f.query);
-  }
-  if (f.headers.size > 0) {
-    requestHeaders.set(PROXY_HEADERS_HEADER, JSON.stringify(Object.fromEntries(f.headers)));
-  }
-  if (f.responseMode) {
-    requestHeaders.set(PROXY_RESPONSE_MODE_HEADER, f.responseMode);
-  }
-  if (body !== void 0) {
-    requestHeaders.set("content-length", String(body.byteLength));
-  }
-  const init = {
-    method: "POST",
-    headers: requestHeaders,
-    redirect: "manual"
-  };
-  if (body !== void 0) {
-    init.body = body;
-  }
-  let response;
-  try {
-    response = await io2.fetchImpl(url, init);
-  } catch (err2) {
-    emitError(io2, {
-      error: "upstream_error",
-      message: `proxy request failed: ${err2.message}`,
-      endpointName: f.endpointName
-    });
-    return RUNTIME_ERR;
-  }
-  if (response.headers.get(PROXY_RESP_STATUS_HEADER) !== null) {
-    const envelope = await readStreamedEnvelope(response, f.endpointName);
-    io2.stdout(JSON.stringify(envelope) + "\n");
-    return SUCCESS;
-  }
-  const text = await response.text();
-  let parsedBody;
-  try {
-    parsedBody = text ? JSON.parse(text) : {};
-  } catch {
-    const snippet = text.slice(0, 200).replace(/\s+/g, " ").trim();
-    emitError(io2, {
-      error: "internal_error",
-      message: `proxy returned non-JSON response (HTTP ${response.status}, body=${JSON.stringify(snippet)})`,
-      endpointName: f.endpointName
-    });
-    return RUNTIME_ERR;
-  }
-  if (!response.ok) {
-    io2.stderr(JSON.stringify(parsedBody) + "\n");
-    return RUNTIME_ERR;
-  }
-  io2.stdout(JSON.stringify(parsedBody) + "\n");
-  return SUCCESS;
-}
-async function resolveBody(io2, spec) {
-  if (spec === "-") {
-    const data = await io2.readFile("/dev/stdin");
-    return new Uint8Array(Buffer.from(data, "utf8"));
-  }
-  if (spec.startsWith("@")) {
-    const path = spec.slice(1);
-    if (!path)
-      throw new Error("--data @<file> requires a path");
-    const data = await io2.readFile(path);
-    return new Uint8Array(Buffer.from(data, "utf8"));
-  }
-  return new Uint8Array(Buffer.from(spec, "utf8"));
-}
-function emitError(io2, body) {
-  io2.stderr(JSON.stringify(body) + "\n");
-}
-async function readStreamedEnvelope(response, endpointName) {
-  const effectiveResponseMode = response.headers.get(PROXY_RESP_MODE_HEADER) ?? "headers_only";
-  const upstreamStatus = Number.parseInt(response.headers.get(PROXY_RESP_STATUS_HEADER) ?? "0", 10);
-  let upstreamHeaders = {};
-  const rawHeaders = response.headers.get(PROXY_RESP_UPSTREAM_HEADERS_HEADER);
-  if (rawHeaders) {
-    try {
-      const parsed = JSON.parse(rawHeaders);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        upstreamHeaders = parsed;
-      }
-    } catch {
-    }
-  }
-  const truncatedRaw = response.headers.get(PROXY_RESP_TRUNCATED_HEADER);
-  const bytes = new Uint8Array(await response.arrayBuffer());
-  return {
-    endpointName,
-    upstreamStatus,
-    upstreamHeaders,
-    effectiveResponseMode,
-    // The streamed path can't echo the request-side clamp decision (it
-    // isn't carried back); the effective mode is authoritative for the
-    // agent and matches what v1 surfaced for an un-clamped call.
-    modeClamped: false,
-    ...effectiveResponseMode === "full" && bytes.byteLength > 0 ? { upstreamBodyBase64: Buffer.from(bytes).toString("base64") } : {},
-    ...truncatedRaw === "true" ? { truncated: true } : {}
-  };
-}
-async function tryReadManifest(io2) {
-  try {
-    const raw = await io2.readFile(AEX_INDEX_PATH);
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
 // dist/host/run-cmd.js
 import { resolve as resolvePath } from "node:path";
 var DEFAULT_SESSION_IDLE_TTL = "3m";
@@ -3616,6 +3557,10 @@ async function runRunCmd(io2, argv) {
     return USAGE_ERR;
   }
   rest = proxyAuthFlags.remaining;
+  if (proxyEndpointFlags.values.length > 0 || Object.keys(proxyAuthFlags.entries).length > 0) {
+    io2.stderr("--proxy-endpoint and --proxy-auth are no longer supported; make HTTP calls from your code and pass credentials via secrets.\n");
+    return USAGE_ERR;
+  }
   const positional = rest.filter((a) => !a.startsWith("--"));
   const unknownFlags = rest.filter((a) => a.startsWith("--"));
   if (unknownFlags.length > 0) {
@@ -3727,35 +3672,6 @@ async function runRunCmd(io2, argv) {
   for (const name of mcpHeaderBag.keys()) {
     if (!mcpServersForSubmission.some((m) => m.name === name)) {
       io2.stderr(`--mcp-auth ${name}: no matching --mcp / mcpServers entry declared
-`);
-      return USAGE_ERR;
-    }
-  }
-  let proxyEndpoints = runConfig.proxyEndpoints ?? [];
-  if (proxyEndpointFlags.values.length > 0) {
-    try {
-      proxyEndpoints = proxyEndpointFlags.values.map((raw, i2) => parseJsonOrThrow(raw, `--proxy-endpoint[${i2}]`));
-    } catch (err2) {
-      io2.stderr(`${err2.message}
-`);
-      return USAGE_ERR;
-    }
-  }
-  const proxyAuth = [];
-  for (const [name, spec] of Object.entries(proxyAuthFlags.entries)) {
-    const parsed = parseProxyAuth(spec);
-    if (!parsed.ok) {
-      io2.stderr(`--proxy-auth ${name}: ${parsed.reason}
-`);
-      return USAGE_ERR;
-    }
-    proxyAuth.push({ name, value: parsed.value });
-  }
-  if (proxyEndpoints.length > 0) {
-    try {
-      validateProxyAuth(proxyEndpoints, proxyAuth);
-    } catch (err2) {
-      io2.stderr(`proxy auth validation failed: ${err2.message}
 `);
       return USAGE_ERR;
     }
@@ -3774,8 +3690,7 @@ async function runRunCmd(io2, argv) {
   const hasAdditionalProviderKeys = Object.keys(providerKeyValues).some((p) => p !== provider);
   const secrets = {
     apiKeys: hasAdditionalProviderKeys ? providerKeyValues : { [provider]: providerKeyValues[provider] },
-    ...mcpServerSecrets.length > 0 ? { mcpServers: mcpServerSecrets } : {},
-    ...proxyAuth.length > 0 ? { proxyEndpointAuth: proxyAuth } : {}
+    ...mcpServerSecrets.length > 0 ? { mcpServers: mcpServerSecrets } : {}
   };
   const request = {
     provider,
@@ -3784,8 +3699,7 @@ async function runRunCmd(io2, argv) {
     retention: { idleTtl: DEFAULT_SESSION_IDLE_TTL },
     ...runtimeSizeFlag.value ? { runtimeSize: runtimeSizeFlag.value } : runConfig.runtimeSize ? { runtimeSize: runConfig.runtimeSize } : {},
     ...runTimeoutFlag.value ? { timeout: runTimeoutFlag.value } : runConfig.timeout ? { timeout: runConfig.timeout } : {},
-    ...webhookFlag.value ? { webhook: { url: webhookFlag.value } } : {},
-    ...proxyEndpoints.length > 0 ? { proxyEndpoints } : {}
+    ...webhookFlag.value ? { webhook: { url: webhookFlag.value } } : {}
   };
   const createKey = idempotency.value ?? generateIdempotencyKey();
   const messageKey = `${createKey}:message`;
@@ -3817,7 +3731,7 @@ async function runRunCmd(io2, argv) {
   const seen = /* @__PURE__ */ new Set();
   let currentStatus = accepted.session.status;
   const deadline = followTimeoutMs === null ? Number.POSITIVE_INFINITY : Date.now() + followTimeoutMs;
-  while (!isSessionParked(currentStatus)) {
+  while (!isSessionParked2(currentStatus)) {
     await sleep2(2e3);
     try {
       const events = await operations_exports.listSessionEvents(http, session.id);
@@ -3838,7 +3752,7 @@ async function runRunCmd(io2, argv) {
       io2.stderr(`(transient) status poll failed: ${err2.message}
 `);
     }
-    if (!isSessionParked(currentStatus) && Date.now() >= deadline) {
+    if (!isSessionParked2(currentStatus) && Date.now() >= deadline) {
       emitJsonError(io2, "run_follow_timeout", `timed out after ${followTimeoutMs}ms following session`, {
         sessionId: session.id,
         hint: `aex status ${session.id} | aex events ${session.id} | aex download ${session.id}`
@@ -3864,47 +3778,6 @@ async function runRunCmd(io2, argv) {
     return RUNTIME_ERR;
   }
 }
-function parseProxyAuth(spec) {
-  const idx = spec.indexOf(":");
-  if (idx <= 0) {
-    return { ok: false, reason: `expected '<type>:<value>' (got: ${spec})` };
-  }
-  const type = spec.slice(0, idx);
-  const restValue = spec.slice(idx + 1);
-  switch (type) {
-    case "bearer":
-      if (!restValue)
-        return { ok: false, reason: "bearer requires a token value" };
-      return { ok: true, value: { type: "bearer", token: restValue } };
-    case "header":
-      if (!restValue)
-        return { ok: false, reason: "header requires a value" };
-      return { ok: true, value: { type: "header", value: restValue } };
-    case "query":
-      if (!restValue)
-        return { ok: false, reason: "query requires a value" };
-      return { ok: true, value: { type: "query", value: restValue } };
-    case "basic": {
-      const sep = restValue.indexOf(":");
-      if (sep <= 0 || sep >= restValue.length - 1) {
-        return { ok: false, reason: "basic requires <username>:<password>" };
-      }
-      return {
-        ok: true,
-        value: { type: "basic", username: restValue.slice(0, sep), password: restValue.slice(sep + 1) }
-      };
-    }
-    default:
-      return { ok: false, reason: `unknown auth type '${type}' (expected bearer|basic|header|query)` };
-  }
-}
-function parseJsonOrThrow(raw, label) {
-  try {
-    return JSON.parse(raw);
-  } catch (err2) {
-    throw new Error(`${label} is not valid JSON: ${err2.message}`);
-  }
-}
 function stripMcpHeadersForParsing(input) {
   const mcpHeaders = /* @__PURE__ */ new Map();
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
@@ -4075,7 +3948,7 @@ async function runWaitCmd(io2, argv) {
       await sleep3(intervalMs);
       continue;
     }
-    if (isSessionParked(session.status)) {
+    if (isSessionParked2(session.status)) {
       io2.stdout(JSON.stringify(session) + "\n");
       return isSessionOk(session.status) ? SUCCESS : RUNTIME_ERR;
     }
@@ -4155,7 +4028,7 @@ async function runEventsCmd(io2, argv) {
     }
     try {
       const session = await operations_exports.getSession(http, sessionId);
-      if (isSessionParked(session.status)) {
+      if (isSessionParked2(session.status)) {
         return SUCCESS;
       }
     } catch (err2) {
@@ -4400,25 +4273,26 @@ async function runWhoamiCmd(io2, argv) {
   }
 }
 
-// dist/host/redeem.js
-function messageForStatus(status2, serverMessage) {
-  switch (status2) {
-    case 404:
-      return "coupon code not found";
-    case 403:
-      return "this coupon can't be redeemed by this workspace";
-    case 409:
-      return "coupon already redeemed";
-    case 400:
-      return serverMessage ? `invalid input: ${serverMessage}` : "invalid input";
-    case 401:
-      return "not authorized \u2014 check --api-token, or run `aex login`";
-    default:
-      return serverMessage ? `redeem failed: ${serverMessage}` : `redeem failed (HTTP ${status2})`;
+// dist/host/billing.js
+function usd(value) {
+  return typeof value === "number" && Number.isFinite(value) ? `$${value.toFixed(2)}` : "-";
+}
+function isPaidPlanKey(value) {
+  return value === "pro" || value === "team";
+}
+function parseLimit(io2, raw) {
+  if (raw === void 0)
+    return { ok: true, limit: void 0 };
+  const limit = Number(raw);
+  if (!Number.isInteger(limit) || limit < 1) {
+    io2.stderr(`--limit must be a positive integer (got: ${raw})
+`);
+    return { ok: false };
   }
+  return { ok: true, limit };
 }
-async function runRedeemCmd(io2, argv) {
-  if (await refuseInsideManagedRun(io2, "redeem"))
+async function runBillingCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "billing"))
     return USAGE_ERR;
   const common = await resolveCommonHostFlags(io2, argv);
   if (!common.ok) {
@@ -4426,54 +4300,255 @@ async function runRedeemCmd(io2, argv) {
 `);
     return USAGE_ERR;
   }
-  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
-  if (positional.length !== 1) {
-    io2.stderr("usage: aex redeem <code> [common flags]\n");
+  if (common.rest[0] === "ledger") {
+    return runBillingLedger(io2, common.rest.slice(1), common.flags);
+  }
+  if (common.rest[0] === "upgrade") {
+    return runBillingUpgrade(io2, common.rest.slice(1), common.flags);
+  }
+  if (common.rest[0] === "portal") {
+    return runBillingPortal(io2, common.rest.slice(1), common.flags);
+  }
+  const { present: json, remaining } = takeBooleanFlag(common.rest, "--json");
+  if (remaining.length > 0) {
+    io2.stderr(`unexpected arguments: ${remaining.join(" ")}
+`);
+    io2.stderr("usage: aex billing [--json] | aex billing ledger [--limit N] | aex billing upgrade pro|team | aex billing portal [common flags]\n");
     return USAGE_ERR;
   }
-  const code = positional[0];
-  const base = common.flags.aexUrl.replace(/\/+$/, "");
-  const url = `${base}/billing/redeem`;
-  let response;
+  const http = makeHttpClient(io2, common.flags);
   try {
-    response = await io2.fetchImpl(url, {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "content-type": "application/json",
-        authorization: `Bearer ${common.flags.apiToken}`
-      },
-      body: JSON.stringify({ code })
+    const billing = await operations_exports.getBilling(http);
+    if (json) {
+      io2.stdout(JSON.stringify(billing) + "\n");
+      return SUCCESS;
+    }
+    io2.stdout(`Balance:      ${usd(billing.balanceUsd)}
+`);
+    io2.stdout(`Month spend:  ${usd(billing.monthSpendUsd)}
+`);
+    io2.stdout(`Spend cap:    ${usd(billing.spendCapUsd)}
+`);
+    io2.stdout(`Plan:         ${billing.planKey} (subscription: ${billing.subscriptionStatus})
+`);
+    return SUCCESS;
+  } catch (err2) {
+    const d = describeApiError(err2);
+    return emitJsonError(io2, "billing_failed", d.message, {
+      ...d.status !== void 0 ? { status: d.status } : {},
+      ...d.remedy ? { remedy: d.remedy } : {}
     });
+  }
+}
+async function runBillingUpgrade(io2, argv, flags) {
+  const { present: json, remaining: rest1 } = takeBooleanFlag(argv, "--json");
+  const { value: successUrl, remaining: rest2 } = takeOptionFlag(rest1, "--success-url");
+  const { value: cancelUrl, remaining: rest3 } = takeOptionFlag(rest2, "--cancel-url");
+  const { value: idempotencyKey, remaining } = takeOptionFlag(rest3, "--idempotency-key");
+  const planKey = remaining[0];
+  if (!isPaidPlanKey(planKey) || remaining.length !== 1) {
+    io2.stderr("usage: aex billing upgrade pro|team [--success-url URL] [--cancel-url URL] [--idempotency-key KEY] [--json] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const http = makeHttpClient(io2, flags);
+  try {
+    const session = await operations_exports.createBillingCheckout(http, {
+      planKey,
+      ...successUrl !== void 0 ? { successUrl } : {},
+      ...cancelUrl !== void 0 ? { cancelUrl } : {},
+      ...idempotencyKey !== void 0 ? { idempotencyKey } : {}
+    });
+    io2.stdout(json ? `${JSON.stringify(session)}
+` : `${session.url}
+`);
+    return SUCCESS;
   } catch (err2) {
-    io2.stderr(`redeem failed: ${err2 instanceof Error ? err2.message : String(err2)}
+    const d = describeApiError(err2);
+    return emitJsonError(io2, "billing_checkout_failed", d.message, {
+      ...d.status !== void 0 ? { status: d.status } : {},
+      ...d.remedy ? { remedy: d.remedy } : {}
+    });
+  }
+}
+async function runBillingPortal(io2, argv, flags) {
+  const { present: json, remaining: rest1 } = takeBooleanFlag(argv, "--json");
+  const { value: returnUrl, remaining } = takeOptionFlag(rest1, "--return-url");
+  if (remaining.length > 0) {
+    io2.stderr(`unexpected arguments: ${remaining.join(" ")}
 `);
-    return RUNTIME_ERR;
+    io2.stderr("usage: aex billing portal [--return-url URL] [--json] [common flags]\n");
+    return USAGE_ERR;
   }
-  if (common.flags.debug) {
-    io2.stderr(`[aex] POST /billing/redeem -> ${response.status}
+  const http = makeHttpClient(io2, flags);
+  try {
+    const session = await operations_exports.createBillingPortal(http, returnUrl !== void 0 ? { returnUrl } : void 0);
+    io2.stdout(json ? `${JSON.stringify(session)}
+` : `${session.url}
 `);
+    return SUCCESS;
+  } catch (err2) {
+    const d = describeApiError(err2);
+    return emitJsonError(io2, "billing_portal_failed", d.message, {
+      ...d.status !== void 0 ? { status: d.status } : {},
+      ...d.remedy ? { remedy: d.remedy } : {}
+    });
   }
-  const text = await response.text();
-  let body = {};
+}
+async function runBillingLedger(io2, argv, flags) {
+  const { value: rawLimit, remaining } = takeOptionFlag(argv, "--limit");
+  if (remaining.length > 0) {
+    io2.stderr(`unexpected arguments: ${remaining.join(" ")}
+`);
+    io2.stderr("usage: aex billing ledger [--limit N] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const parsed = parseLimit(io2, rawLimit);
+  if (!parsed.ok)
+    return USAGE_ERR;
+  const http = makeHttpClient(io2, flags);
   try {
-    if (text.length > 0)
-      body = JSON.parse(text);
-  } catch {
-    body = {};
+    const page = await operations_exports.getBillingLedger(http, parsed.limit !== void 0 ? { limit: parsed.limit } : void 0);
+    io2.stdout(JSON.stringify(page.entries) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    const d = describeApiError(err2);
+    return emitJsonError(io2, "billing_ledger_failed", d.message, {
+      ...d.status !== void 0 ? { status: d.status } : {},
+      ...d.remedy ? { remedy: d.remedy } : {}
+    });
   }
-  if (!response.ok) {
-    const serverMessage = body && typeof body === "object" && typeof body.message === "string" ? body.message : void 0;
-    io2.stderr(`${messageForStatus(response.status, serverMessage)}
+}
+
+// dist/host/webhooks-cmd.js
+async function runWebhooksCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "webhooks"))
+    return USAGE_ERR;
+  const common = await resolveCommonHostFlags(io2, argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
 `);
-    return RUNTIME_ERR;
+    return USAGE_ERR;
+  }
+  const [sub, ...rest] = common.rest;
+  if (sub !== "secret") {
+    io2.stderr("usage: aex webhooks secret [common flags]\n");
+    return USAGE_ERR;
+  }
+  const { present: rotate, remaining } = takeBooleanFlag(rest, "--rotate");
+  if (rotate) {
+    io2.stderr("--rotate is not supported: the hosted API reveals (or creates on first use) the workspace webhook signing secret but does not rotate it. Run `aex webhooks secret` to reveal the current value.\n");
+    return USAGE_ERR;
   }
-  const ok = body;
-  const amountUsd = typeof ok.amountUsd === "number" ? ok.amountUsd : 0;
-  const newBalanceUsd = typeof ok.newBalanceUsd === "number" ? ok.newBalanceUsd : 0;
-  io2.stdout(`Redeemed $${amountUsd.toFixed(2)}. New balance: $${newBalanceUsd.toFixed(2)}.
+  if (remaining.length > 0) {
+    io2.stderr(`unexpected arguments: ${remaining.join(" ")}
 `);
-  return SUCCESS;
+    io2.stderr("usage: aex webhooks secret [common flags]\n");
+    return USAGE_ERR;
+  }
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const { whsec } = await operations_exports.getWebhookSigningSecret(http);
+    io2.stdout(`${whsec}
+`);
+    return SUCCESS;
+  } catch (err2) {
+    const d = describeApiError(err2);
+    return emitJsonError(io2, "webhooks_secret_failed", d.message, {
+      ...d.status !== void 0 ? { status: d.status } : {},
+      ...d.remedy ? { remedy: d.remedy } : {}
+    });
+  }
+}
+
+// dist/host/list-cmds.js
+function parseLimit2(io2, raw) {
+  if (raw === void 0)
+    return { ok: true, limit: void 0 };
+  const limit = Number(raw);
+  if (!Number.isInteger(limit) || limit < 1) {
+    io2.stderr(`--limit must be a positive integer (got: ${raw})
+`);
+    return { ok: false };
+  }
+  return { ok: true, limit };
+}
+async function runRunsCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "runs"))
+    return USAGE_ERR;
+  const common = await resolveCommonHostFlags(io2, argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const { value: rawLimit, remaining: afterLimit } = takeOptionFlag(common.rest, "--limit");
+  const { value: since, remaining } = takeOptionFlag(afterLimit, "--since");
+  if (remaining.length > 0) {
+    io2.stderr(`unexpected arguments: ${remaining.join(" ")}
+`);
+    io2.stderr("usage: aex runs [--limit N] [--since ISO-8601] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const parsed = parseLimit2(io2, rawLimit);
+  if (!parsed.ok)
+    return USAGE_ERR;
+  const sinceMs = since !== void 0 ? Date.parse(since) : void 0;
+  if (sinceMs !== void 0 && Number.isNaN(sinceMs)) {
+    io2.stderr(`--since must be an ISO-8601 timestamp (got: ${since})
+`);
+    return USAGE_ERR;
+  }
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const page = await operations_exports.listRuns(http, {
+      ...parsed.limit !== void 0 ? { limit: parsed.limit } : {},
+      ...since !== void 0 ? { since } : {}
+    });
+    const runs = sinceMs === void 0 ? page.runs : page.runs.filter((run) => {
+      const created = Date.parse(run.createdAt);
+      return !Number.isNaN(created) && created >= sinceMs;
+    });
+    io2.stdout(JSON.stringify({ ...page, runs }) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    const d = describeApiError(err2);
+    return emitJsonError(io2, "runs_failed", d.message, {
+      ...d.status !== void 0 ? { status: d.status } : {},
+      ...d.remedy ? { remedy: d.remedy } : {}
+    });
+  }
+}
+async function runSessionsCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "sessions"))
+    return USAGE_ERR;
+  const common = await resolveCommonHostFlags(io2, argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const { value: rawLimit, remaining } = takeOptionFlag(common.rest, "--limit");
+  if (remaining.length > 0) {
+    io2.stderr(`unexpected arguments: ${remaining.join(" ")}
+`);
+    io2.stderr("usage: aex sessions [--limit N] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const parsed = parseLimit2(io2, rawLimit);
+  if (!parsed.ok)
+    return USAGE_ERR;
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const page = await operations_exports.listSessions(http, parsed.limit !== void 0 ? { limit: parsed.limit } : void 0);
+    io2.stdout(JSON.stringify(page) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    const d = describeApiError(err2);
+    return emitJsonError(io2, "sessions_failed", d.message, {
+      ...d.status !== void 0 ? { status: d.status } : {},
+      ...d.remedy ? { remedy: d.remedy } : {}
+    });
+  }
 }
 
 // dist/host/debug.js
@@ -5543,7 +5618,7 @@ async function runTailCmd(io2, argv) {
   }
   if (isSessionOk(finalStatus))
     return SUCCESS;
-  if (isSessionParked(finalStatus))
+  if (isSessionParked2(finalStatus))
     return RUNTIME_ERR;
   io2.stderr(JSON.stringify({
     error: "tail_ended_before_terminal",
@@ -5725,8 +5800,6 @@ async function dispatch(io2, args) {
   const sub = args[0];
   const rest = args.slice(1);
   switch (sub) {
-    case "proxy":
-      return runProxy(io2, rest);
     case "run":
       return runRunCmd(io2, rest);
     case "status":
@@ -5754,10 +5827,16 @@ async function dispatch(io2, args) {
       return runDeleteCmd(io2, rest);
     case "delete-asset":
       return runDeleteAssetCmd(io2, rest);
+    case "runs":
+      return runRunsCmd(io2, rest);
+    case "sessions":
+      return runSessionsCmd(io2, rest);
     case "whoami":
       return runWhoamiCmd(io2, rest);
-    case "redeem":
-      return runRedeemCmd(io2, rest);
+    case "billing":
+      return runBillingCmd(io2, rest);
+    case "webhooks":
+      return runWebhooksCmd(io2, rest);
     case "login":
       return runLoginCmd(io2, rest);
     case "logout":
@@ -5782,26 +5861,6 @@ async function dispatch(io2, args) {
   }
 }
 async function printGlobalHelp(io2) {
-  const manifest = await tryReadManifest(io2);
-  if (manifest) {
-    io2.stdout("aex \u2014 in-container CLI for managed run sessions\n\n");
-    io2.stdout("Usage:\n");
-    io2.stdout("  aex proxy <endpoint-name> [flags]\n");
-    io2.stdout("  aex proxy --help\n\n");
-    if (manifest.endpoints.length === 0) {
-      io2.stdout("This run declared no proxy endpoints.\n");
-    } else {
-      io2.stdout("Declared proxy endpoints for this run:\n");
-      for (const ep of manifest.endpoints) {
-        io2.stdout(`  \u2022 ${formatProxyEndpointSummary(ep)}
-`);
-      }
-    }
-    io2.stdout(`
-Protocol version: ${manifest.protocolVersion}
-`);
-    return SUCCESS;
-  }
   io2.stdout("aex \u2014 unified CLI for the aex platform (mirrors the SDK 1:1)\n\n");
   io2.stdout("Usage:\n");
   io2.stdout("  aex run --config <run.json> --<provider>-api-key K --api-token T [flags]\n");
@@ -5817,8 +5876,14 @@ Protocol version: ${manifest.protocolVersion}
   io2.stdout("  aex cancel <session-id> --api-token T\n");
   io2.stdout("  aex delete <session-id> --api-token T\n");
   io2.stdout("  aex delete-asset <assetId|hash> --api-token T\n");
+  io2.stdout("  aex runs [--limit N] [--since ISO] --api-token T      List the workspace's runs (newest first, JSON)\n");
+  io2.stdout("  aex sessions [--limit N] --api-token T      List the workspace's sessions (newest first, JSON)\n");
   io2.stdout("  aex whoami --api-token T\n");
-  io2.stdout("  aex redeem <code> --api-token T             Redeem a coupon code into the workspace prepaid balance\n");
+  io2.stdout("  aex billing [--json] --api-token T          Show prepaid balance, month spend, and spend cap\n");
+  io2.stdout("  aex billing ledger [--limit N] --api-token T   Recent credit-ledger entries (newest first, JSON)\n");
+  io2.stdout("  aex billing upgrade pro|team --api-token T   Create a hosted checkout session and print its URL\n");
+  io2.stdout("  aex billing portal --api-token T             Create a hosted billing portal session and print its URL\n");
+  io2.stdout("  aex webhooks secret --api-token T           Reveal (create on first use) the webhook signing secret\n");
   io2.stdout("  aex login --api-token T [--aex-url U]      Persist token + url (then other verbs need no --api-token)\n");
   io2.stdout("  aex logout                                 Clear the stored token\n");
   io2.stdout("  aex auth status                            Show the resolved config (token never printed)\n");
@@ -5846,10 +5911,8 @@ Protocol version: ${manifest.protocolVersion}
   io2.stdout("  --mcp name=url              MCP server entry (repeatable)\n");
   io2.stdout("  --mcp-auth name=Hdr:Val     Auth header on the matching --mcp; routed into vaulted secrets (repeatable)\n");
   io2.stdout("  --metadata key=value        Submission metadata entry (repeatable)\n");
-  io2.stdout("  --proxy-endpoint '<json>'   PlatformProxyEndpoint JSON (repeatable)\n");
-  io2.stdout("  --proxy-auth name=<spec>    bearer:tok | basic:u:p | header:v | query:v (repeatable)\n");
   io2.stdout("  --runtime-size <size>       managed runtime preset\n");
-  io2.stdout("  --run-timeout <dur>         Server-side run deadline (e.g. 1h); distinct from --timeout\n");
+  io2.stdout("  --run-timeout <dur>         Server-side run deadline (e.g. 1h, max 8h); distinct from --timeout\n");
   io2.stdout("  --idempotency-key <key>     Optional; defaults to a fresh UUID\n");
   io2.stdout("  --webhook <url>             Optional per-run callback URL (https); receives the terminal run.finished event\n");
   io2.stdout("  --follow                    Poll events to stdout until the run terminates\n");