@aexhq/sdk 0.35.0 → 0.37.0

package/README.md

@@ -8,15 +8,15 @@ aex is an agent execution platform for launching autonomous agents from a simple
 
 The package ships:
 
-- `Aex` / `AgentExecutor` for sessions, one-shot runs, inspect, download, cancel, and delete.
+- `Aex` for sessions, one-shot runs, inspect, download, cancel, and delete.
 - `sessions` / `openSession()` for durable, resumable agent sessions.
-- Typed run primitives: `Models`, `Providers`, `Sizes`, `Tool` / `Tools` (skill-tools), `AgentsMd`, `File`, `McpServer`, `ProxyEndpoint`, and `Secret`.
+- Typed run primitives: `Models`, `Providers`, `Sizes`, `Tool` / `Tools` (skill-tools), `AgentsMd`, `File`, `McpServer`, and `Secret`.
 - A bundled `aex` CLI with the same run, status, events, outputs, download, cancel, delete, and whoami operations.
 
 ## Install
 
 ```bash
-bun add @aexhq/sdk
+npm i @aexhq/sdk
 ```
 
 This installs the TypeScript SDK exports and the bundled `aex` CLI. Set both
@@ -119,33 +119,34 @@ you can `catch` by code; CLI failures print a JSON envelope carrying the HTTP
 `status`, a one-line `remedy`, and the `runId` where known, and a wrong `--model`,
 `--provider`, or `--runtime-size` gets a "did you mean?" suggestion.
 
-## Chat over a corpus of sessions
+## Continue with sessions
 
-Turn a selected set of sessions into a read-only chat.
-`createCorpusTools(client, { sessionIds })` returns vendor-neutral, corpus-scoped
-read tools (`list_sessions` / `get_session` / `list_outputs` / `read_output` /
-`search_outputs`) — every tool refuses a session outside the corpus. Drive them
-with any LLM; `examples/chat-corpus.ts` shows the direct-Claude loop
-(`@anthropic-ai/sdk`) on top of the LLM-vendor-free SDK.
+Use sessions for conversational flows. `run()` is the one-shot convenience; a
+`SessionHandle` is the lower-level surface when you want multiple turns,
+streaming, messages, events, outputs, or downloads.
 
-`aex.sessions.searchOutputs({ runIds, filename, extension, contentType, limit })`
-finds output files across sessions (scope with the `runIds` session-id allow-list)
-and returns references (no bytes) you then read with `aex.sessions.outputs(id).read(...)`.
+```ts
+const session = await aex.openSession(result.runId);
+const next = await session.send("Turn this into a checklist.").done();
+console.log(next.text);
+
+const messages = await session.messages().list();
+const outputs = await aex.sessions.outputs(session.id).list();
+```
 
 ## Feature Areas
 
 - **Agent runtime:** managed autonomous runs with filesystem read/edit, grep/glob/head/tail, open web fetch/search, background commands, code execution, git, and subagents.
 - **Durable infrastructure:** run records, status, wait/cancel/delete, idempotency, typed events, output capture, downloads, timeouts, and runtime sizes.
-- **Agent composition:** skills, files, AGENTS.md, remote MCP servers, proxy endpoints, environment variables, packages, and networking controls.
+- **Agent composition:** skills, files, AGENTS.md, remote MCP servers, environment variables, packages, and networking controls.
 - **Subagents:** typed parent/child lineage for async child runs, output handoff, and bounded agent delegation.
 - **Models and providers:** Anthropic, DeepSeek, OpenAI, Gemini, Mistral, OpenRouter, Doubao, and Doubao China behind one submission shape.
-- **Typed control surface:** strongly typed SDK inputs, CLI parity, BYOK secrets, scoped proxy auth, redaction, and output modes.
+- **Typed control surface:** strongly typed SDK inputs, CLI parity, BYOK provider keys, workspace secrets, redaction, and output modes.
 
 ## Docs
 
 - [Quickstart](docs/quickstart.md)
 - [Run configuration](docs/run-config.md)
-- [Agent tools](docs/concepts/agent-tools.md)
 - [Composition](docs/concepts/composition.md)
 - [Secrets](docs/secrets.md)
 - [Limits](docs/limits.md)

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

@@ -195,6 +195,21 @@ export declare function isRunFinished(e: AexEvent): boolean;
 export declare function isRunError(e: AexEvent): boolean;
 /** A terminal event of either flavour (finished or error). */
 export declare function isRunTerminal(e: AexEvent): boolean;
+/**
+ * The CUSTOM `data.name`s the MANAGED runtime emits as a run/turn's terminal.
+ * A managed one-shot run PARKS (session_parked.v1 → `aex.session.idle` / `.error`
+ * / `.suspended`) rather than writing a `session_finished` → RUN_FINISHED, so
+ * these — not just the AG-UI RUN_FINISHED/RUN_ERROR — are what actually ends a
+ * managed run's event stream. Kept in sync with the platform journal projection
+ * (`journal-project.ts` session_parked.v1 mapping).
+ */
+export declare const AEX_SESSION_PARKED_NAMES: readonly ["aex.session.idle", "aex.session.error", "aex.session.suspended"];
+/**
+ * True for a managed-runtime session-park terminal (idle/error/suspended). The
+ * turn's work is done and the record has reached its terminal status; a stream
+ * consumer should stop here exactly as it would on RUN_FINISHED/RUN_ERROR.
+ */
+export declare function isSessionParked(e: AexEvent): boolean;
 export declare function isTextMessage(e: AexEvent): boolean;
 export declare function isToolCallStart(e: AexEvent): boolean;
 export declare function isToolCallResult(e: AexEvent): boolean;
@@ -213,7 +228,13 @@ export declare function customName(e: AexEvent): string | null;
  * platform mirrors this constant in `@aexhq/shared`.
  */
 export declare const AEX_RUN_SETTLED_NAME = "aex.run.settled";
-/** True for the settle-consistency barrier event (post-mirror, read-consistent). */
+/**
+ * True for the settle-consistency barrier event (post-mirror, read-consistent).
+ * Also true for a managed-runtime session-park terminal: the managed plane does
+ * NOT broadcast the `aex.run.settled` barrier, and by the time a run parks its
+ * record has reached a terminal status — so a `settleConsistent` stream ends at
+ * the park instead of hanging forever waiting for a barrier that never arrives.
+ */
 export declare function isRunSettled(e: AexEvent): boolean;
 export declare function isFromSource(e: AexEvent, source: AexEventSource): boolean;
 /** The channel a record rides, defaulting an absent value to `"event"`. */

package/dist/_contracts/event-envelope.js

@@ -212,6 +212,24 @@ export function isRunError(e) {
 export function isRunTerminal(e) {
     return e.type === "RUN_FINISHED" || e.type === "RUN_ERROR";
 }
+/**
+ * The CUSTOM `data.name`s the MANAGED runtime emits as a run/turn's terminal.
+ * A managed one-shot run PARKS (session_parked.v1 → `aex.session.idle` / `.error`
+ * / `.suspended`) rather than writing a `session_finished` → RUN_FINISHED, so
+ * these — not just the AG-UI RUN_FINISHED/RUN_ERROR — are what actually ends a
+ * managed run's event stream. Kept in sync with the platform journal projection
+ * (`journal-project.ts` session_parked.v1 mapping).
+ */
+export const AEX_SESSION_PARKED_NAMES = ["aex.session.idle", "aex.session.error", "aex.session.suspended"];
+/**
+ * True for a managed-runtime session-park terminal (idle/error/suspended). The
+ * turn's work is done and the record has reached its terminal status; a stream
+ * consumer should stop here exactly as it would on RUN_FINISHED/RUN_ERROR.
+ */
+export function isSessionParked(e) {
+    const name = customName(e);
+    return name !== null && AEX_SESSION_PARKED_NAMES.includes(name);
+}
 export function isTextMessage(e) {
     return e.type === "TEXT_MESSAGE_CONTENT";
 }
@@ -240,9 +258,15 @@ export function customName(e) {
  * platform mirrors this constant in `@aexhq/shared`.
  */
 export const AEX_RUN_SETTLED_NAME = "aex.run.settled";
-/** True for the settle-consistency barrier event (post-mirror, read-consistent). */
+/**
+ * True for the settle-consistency barrier event (post-mirror, read-consistent).
+ * Also true for a managed-runtime session-park terminal: the managed plane does
+ * NOT broadcast the `aex.run.settled` barrier, and by the time a run parks its
+ * record has reached a terminal status — so a `settleConsistent` stream ends at
+ * the park instead of hanging forever waiting for a barrier that never arrives.
+ */
 export function isRunSettled(e) {
-    return customName(e) === AEX_RUN_SETTLED_NAME;
+    return customName(e) === AEX_RUN_SETTLED_NAME || isSessionParked(e);
 }
 export function isFromSource(e, source) {
     return e.source === source;

package/dist/_contracts/event-stream-client.js

@@ -24,7 +24,13 @@
  * The WebSocket is injectable so the SDK/CLI use the global `WebSocket`
  * (Bun and Node 22+ ship it; no dependency) and tests drive a fake.
  */
-const isTerminalType = (e) => e.type === "RUN_FINISHED" || e.type === "RUN_ERROR";
+import { isSessionParked } from "./event-envelope.js";
+// The default terminal predicate ends the stream on the AG-UI terminals AND on
+// the managed runtime's CUSTOM session-park terminal (aex.session.idle/.error/
+// .suspended). A managed one-shot run parks instead of emitting RUN_FINISHED, so
+// WITHOUT the session-park arm a `streamEnvelopes()` over a finished managed run
+// never sees a terminal and hangs on the idle watchdog forever.
+const isTerminalType = (e) => e.type === "RUN_FINISHED" || e.type === "RUN_ERROR" || isSessionParked(e);
 /**
  * Keep-alive ping the client sends; the coordinator answers it with the matching
  * pong in its WebSocket message handler. Must stay byte-identical to

package/dist/_contracts/index.d.ts

@@ -1,15 +1,15 @@
-export * from "./proxy-protocol.js";
 export * from "./provider-support.js";
 export * from "./models.js";
 export * from "./status.js";
-export * from "./submission.js";
+export { AEX_RESERVED_ENV_PREFIX, BUILTIN_TOOL_NAMES, BuiltinTools, DEFAULT_BUILTIN_TOOLS, DEFAULT_OUTPUT_MODE, DEFAULT_RUN_PROVIDER, ENV_VARS_MAX_ENTRIES, ENV_VARS_MAX_TOTAL_BYTES, ENV_VARS_MAX_VALUE_BYTES, OUTPUT_MODES, PLATFORM_PACKAGE_ECOSYSTEMS, Providers, RUN_PROVIDERS, SECRETS_KEY, SECRET_ENV_NAME_PATTERN, SECRET_HANDLE_PATTERN, crossValidateSecretEnvAndValues, packageInstallString, parseInlineSecrets, parseRunLimits, parseRunProvider, parseRunSubmissionRequest, parseRunWebhook, parseSubmission, resolveBuiltinToolNames } from "./submission.js";
+export type { BuiltinToolName, JsonPrimitive, JsonValue, OutputMode, ParseRunSubmissionOptions, PlatformEnvironment, PlatformEnvironmentInput, PlatformInlineSecrets, PlatformInjectionConfig, PlatformMcpServerSecret, PlatformNetworking, PlatformOutputCaptureConfig, PlatformPackage, PlatformPackageEcosystem, PlatformPackageInput, PlatformRunSubmissionInput, PlatformRunSubmissionRequest, PlatformSecretEnvEntry, PlatformSubmission, RunLimits, RunMachine, RunProvider, RunWebhookSpec } from "./submission.js";
 export * from "./runtime-sizes.js";
 export * from "./runner-event.js";
 export * from "./event-envelope.js";
 export * from "./connection-ticket.js";
 export * from "./event-stream-client.js";
 export * from "./run-unit.js";
-export * from "./run-trace.js";
+export type { AssistantTextEntry, RunTrace, ToolCallResult, ToolCallTrace } from "./run-trace.js";
 export * from "./runtime-manifest.js";
 export * from "./runtime-security-profile.js";
 export * from "./run-record.js";
@@ -26,7 +26,6 @@ export * from "./webhook-verify.js";
 export * from "./http.js";
 export * from "./run-artifacts.js";
 export * as operations from "./operations.js";
-export * from "./proxy-validation.js";
 export * from "./sse.js";
 export { isRunFinished, isTextMessage, isToolCallResult, isToolCallStart } from "./event-guards.js";
 export type { RunFinishedRunEvent, TextMessageRunEvent, ToolCallResultRunEvent, ToolCallStartRunEvent } from "./event-guards.js";

package/dist/_contracts/index.js

@@ -1,15 +1,13 @@
-export * from "./proxy-protocol.js";
 export * from "./provider-support.js";
 export * from "./models.js";
 export * from "./status.js";
-export * from "./submission.js";
+export { AEX_RESERVED_ENV_PREFIX, BUILTIN_TOOL_NAMES, BuiltinTools, DEFAULT_BUILTIN_TOOLS, DEFAULT_OUTPUT_MODE, DEFAULT_RUN_PROVIDER, ENV_VARS_MAX_ENTRIES, ENV_VARS_MAX_TOTAL_BYTES, ENV_VARS_MAX_VALUE_BYTES, OUTPUT_MODES, PLATFORM_PACKAGE_ECOSYSTEMS, Providers, RUN_PROVIDERS, SECRETS_KEY, SECRET_ENV_NAME_PATTERN, SECRET_HANDLE_PATTERN, crossValidateSecretEnvAndValues, packageInstallString, parseInlineSecrets, parseRunLimits, parseRunProvider, parseRunSubmissionRequest, parseRunWebhook, parseSubmission, resolveBuiltinToolNames } from "./submission.js";
 export * from "./runtime-sizes.js";
 export * from "./runner-event.js";
 export * from "./event-envelope.js";
 export * from "./connection-ticket.js";
 export * from "./event-stream-client.js";
 export * from "./run-unit.js";
-export * from "./run-trace.js";
 export * from "./runtime-manifest.js";
 export * from "./runtime-security-profile.js";
 export * from "./run-record.js";
@@ -26,7 +24,6 @@ export * from "./webhook-verify.js";
 export * from "./http.js";
 export * from "./run-artifacts.js";
 export * as operations from "./operations.js";
-export * from "./proxy-validation.js";
 export * from "./sse.js";
 // Explicit re-export (shadows the same-named `AexEvent` guards from
 // `event-envelope.js`): the public `is*` guards narrow the loose `RunEvent`

package/dist/_contracts/operations.d.ts

@@ -1,6 +1,6 @@
 import type { HttpClient } from "./http.js";
 import type { RunUnit } from "./run-unit.js";
-import type { AgentsMdRecord, FileRecord, Output, OutputLink, OutputLinkOptions, OutputFileDownload, OutputFileSelector, OutputFileType, OutputQuery, OutputText, ReadOutputTextOptions, Run, RunEvent, RunListPage, RunListQuery, Session, SessionCreateRequest, SessionEvent, SessionListPage, SessionListQuery, SessionMessageAccepted, SessionMessageRequest, SessionStateChangeAccepted, RunWebhookDelivery, SecretRecord, SecretReveal, WhoAmI } from "./runtime-types.js";
+import type { AgentsMdRecord, BillingCheckoutRequest, BillingHostedSession, BillingLedgerPage, BillingLedgerQuery, BillingPortalRequest, BillingSummary, FileRecord, Output, OutputLink, OutputLinkOptions, OutputFileDownload, OutputFileSelector, OutputFileType, OutputQuery, OutputText, ReadOutputTextOptions, Run, RunEvent, RunListPage, RunListQuery, Session, SessionCreateRequest, SessionEvent, SessionListPage, SessionListQuery, SessionMessageAccepted, SessionMessageRequest, SessionMessagesPage, SessionMessagesQuery, SessionStateChangeAccepted, RunWebhookDelivery, SecretRecord, SecretReveal, WebhookSigningSecret, WhoAmI } from "./runtime-types.js";
 import type { PlatformRunSubmissionInput } from "./submission.js";
 /**
  * The single source of truth for SDK<->BFF transport. The SDK class
@@ -43,6 +43,7 @@ export declare function createSession(http: HttpClient, request: SessionCreateRe
 export declare function getSession(http: HttpClient, sessionId: string): Promise<Session>;
 export declare function listSessions(http: HttpClient, query?: SessionListQuery): Promise<SessionListPage>;
 export declare function sendSessionMessage(http: HttpClient, sessionId: string, request: SessionMessageRequest, options?: IdempotencyOptions): Promise<SessionMessageAccepted>;
+export declare function listSessionMessages(http: HttpClient, sessionId: string, query?: SessionMessagesQuery): Promise<SessionMessagesPage>;
 export declare function suspendSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted>;
 export declare function cancelSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted>;
 export declare function resumeSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted>;
@@ -115,6 +116,35 @@ export declare function redeliverRunWebhook(http: HttpClient, runId: string, del
  */
 export declare function deleteWorkspaceAsset(http: HttpClient, hash: string): Promise<void>;
 export declare function whoami(http: HttpClient): Promise<WhoAmI>;
+/**
+ * Read the workspace billing summary (`GET /api/billing`, scope `billing:read`):
+ * prepaid balance, current-month spend, spend cap, and plan fields. The result
+ * is additive-tolerant — server fields this SDK does not know yet pass through.
+ */
+export declare function getBilling(http: HttpClient): Promise<BillingSummary>;
+/**
+ * Create a hosted checkout session for a paid plan. Returns only the hosted
+ * URL; plan activation happens after checkout completes.
+ */
+export declare function createBillingCheckout(http: HttpClient, request: BillingCheckoutRequest): Promise<BillingHostedSession>;
+/**
+ * Create a hosted billing-portal session for the workspace customer.
+ * Returns only the hosted URL.
+ */
+export declare function createBillingPortal(http: HttpClient, request?: BillingPortalRequest): Promise<BillingHostedSession>;
+/**
+ * Read recent workspace credit-ledger rows (`GET /api/billing/ledger`, scope
+ * `billing:read`), newest first. `limit` is clamped server-side to [1, 100]
+ * (default 25); the read is not cursor-paged.
+ */
+export declare function getBillingLedger(http: HttpClient, query?: BillingLedgerQuery): Promise<BillingLedgerPage>;
+/**
+ * Reveal the workspace webhook signing secret (`POST /api/webhook/signing-secret`),
+ * CREATING one on first use. Repeat calls return the same `whsec_<base64>` value —
+ * the hosted API does not rotate it. POST (not GET) so a reveal is a logged action.
+ * Pass the returned `whsec` to `verifyAexWebhook` as `secret`.
+ */
+export declare function getWebhookSigningSecret(http: HttpClient): Promise<WebhookSigningSecret>;
 export declare function filterOutputs(outputs: readonly Output[], query: OutputQuery): readonly Output[];
 export declare function classifyOutput(output: Pick<Output, "filename" | "contentType">): OutputFileType;
 export declare function normalizeOutputLinkExpiresIn(input?: OutputLinkOptions["expiresIn"]): number;

package/dist/_contracts/operations.js

@@ -1,4 +1,5 @@
 import { strToU8, zipSync } from "fflate";
+import { normalizeRunUnit } from "./run-unit.js";
 import { RunStateError } from "./sdk-errors.js";
 import { assertRunRecordArchivePublicSafeV1, buildRunRecordDownloadManifestV1 } from "./run-record.js";
 /**
@@ -28,7 +29,11 @@ export async function getRun(http, runId) {
  * stays for callers that only need the loose record.
  */
 export async function getRunUnit(http, runId) {
-    return http.request(`/api/runs/${encodeURIComponent(runId)}`);
+    // Normalize so the RunUnit type contract holds at runtime: the managed plane
+    // returns a lean record and omits the aggregate collections (F25). The
+    // aggregates default to empty (safe array/page access) — read outputs()/events()
+    // for the authoritative per-run data on that plane.
+    return normalizeRunUnit(await http.request(`/api/runs/${encodeURIComponent(runId)}`));
 }
 /**
  * List the runs in the token's workspace, most-recent first, one page at a time.
@@ -87,6 +92,16 @@ export async function sendSessionMessage(http, sessionId, request, options) {
         body: JSON.stringify(request)
     });
 }
+export async function listSessionMessages(http, sessionId, query) {
+    const params = {};
+    if (query?.limit !== undefined)
+        params.limit = String(query.limit);
+    if (query?.cursor !== undefined)
+        params.cursor = query.cursor;
+    if (query?.since !== undefined)
+        params.since = query.since;
+    return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/messages`, {}, params);
+}
 export async function suspendSession(http, sessionId, options) {
     const headers = idempotencyHeaders(options);
     return http.request(`/api/sessions/${encodeURIComponent(sessionId)}/suspend`, { method: "POST", ...(headers ? { headers } : {}) });
@@ -373,6 +388,54 @@ export async function deleteWorkspaceAsset(http, hash) {
 export async function whoami(http) {
     return http.request("/api/whoami");
 }
+/**
+ * Read the workspace billing summary (`GET /api/billing`, scope `billing:read`):
+ * prepaid balance, current-month spend, spend cap, and plan fields. The result
+ * is additive-tolerant — server fields this SDK does not know yet pass through.
+ */
+export async function getBilling(http) {
+    return http.request("/api/billing");
+}
+/**
+ * Create a hosted checkout session for a paid plan. Returns only the hosted
+ * URL; plan activation happens after checkout completes.
+ */
+export async function createBillingCheckout(http, request) {
+    return http.request("/api/billing/checkout", {
+        method: "POST",
+        body: JSON.stringify(request)
+    });
+}
+/**
+ * Create a hosted billing-portal session for the workspace customer.
+ * Returns only the hosted URL.
+ */
+export async function createBillingPortal(http, request = {}) {
+    return http.request("/api/billing/portal", {
+        method: "POST",
+        body: JSON.stringify(request)
+    });
+}
+/**
+ * Read recent workspace credit-ledger rows (`GET /api/billing/ledger`, scope
+ * `billing:read`), newest first. `limit` is clamped server-side to [1, 100]
+ * (default 25); the read is not cursor-paged.
+ */
+export async function getBillingLedger(http, query) {
+    const params = {};
+    if (query?.limit !== undefined)
+        params.limit = String(query.limit);
+    return http.request("/api/billing/ledger", {}, params);
+}
+/**
+ * Reveal the workspace webhook signing secret (`POST /api/webhook/signing-secret`),
+ * CREATING one on first use. Repeat calls return the same `whsec_<base64>` value —
+ * the hosted API does not rotate it. POST (not GET) so a reveal is a logged action.
+ * Pass the returned `whsec` to `verifyAexWebhook` as `secret`.
+ */
+export async function getWebhookSigningSecret(http) {
+    return http.request("/api/webhook/signing-secret", { method: "POST" });
+}
 /**
  * Download each artifact's bytes into a zip-file map keyed by
  * `<zipPrefix><relative-path>`, fetched from the `outputs`

package/dist/_contracts/run-config.d.ts

@@ -30,7 +30,7 @@
  * Keep this as the public source of truth for the SDK/CLI composition
  * boundary.
  */
-import { type JsonValue, type PlatformProxyEndpoint, type PlatformEnvironment } from "./submission.js";
+import { type JsonValue, type PlatformEnvironment } from "./submission.js";
 import { type RunModel } from "./models.js";
 import type { RuntimeSize } from "./runtime-sizes.js";
 /**
@@ -303,9 +303,8 @@ export interface RunRequestConfig {
     readonly environment?: PlatformEnvironment;
     /** Managed runtime size preset (see {@link RuntimeSize}). */
     readonly runtimeSize?: RuntimeSize;
-    /** Run deadline as a duration string (`"1h"`, `"30m"`); bounded [1m, 6h] server-side. */
+    /** Run deadline as a duration string (`"1h"`, `"30m"`); bounded [1m, 8h] server-side. */
     readonly timeout?: string;
-    readonly proxyEndpoints?: readonly PlatformProxyEndpoint[];
     readonly metadata?: Readonly<Record<string, JsonValue>>;
 }
 /**
@@ -331,7 +330,6 @@ export interface NormalisedRunRequestConfig {
     readonly prompt: readonly string[];
     readonly mcpServers: readonly McpServerRef[];
     readonly environment?: PlatformEnvironment;
-    readonly proxyEndpoints?: readonly PlatformProxyEndpoint[];
     readonly metadata?: Readonly<Record<string, JsonValue>>;
     /**
      * MCP servers whose run-config entry carried `headers`. Keyed by the `name`

package/dist/_contracts/run-config.js

@@ -602,7 +602,6 @@ export function parseRunRequestConfig(input) {
         "environment",
         "runtimeSize",
         "timeout",
-        "proxyEndpoints",
         "metadata"
     ]);
     for (const key of Object.keys(record)) {
@@ -622,8 +621,8 @@ export function parseRunRequestConfig(input) {
         ...(system !== undefined ? { system } : {}),
         prompt,
         ...(mcpServers !== undefined ? { 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 !== undefined
@@ -635,9 +634,6 @@ export function parseRunRequestConfig(input) {
         ...(record.timeout !== undefined
             ? { timeout: record.timeout }
             : {}),
-        ...(record.proxyEndpoints !== undefined
-            ? { proxyEndpoints: record.proxyEndpoints }
-            : {}),
         ...(record.metadata !== undefined
             ? { metadata: record.metadata }
             : {})
@@ -699,7 +695,6 @@ export function normaliseRunRequestConfig(config) {
         prompt,
         mcpServers,
         ...(config.environment !== undefined ? { environment: config.environment } : {}),
-        ...(config.proxyEndpoints !== undefined ? { proxyEndpoints: config.proxyEndpoints } : {}),
         ...(config.metadata !== undefined ? { metadata: config.metadata } : {}),
         mcpServerSecrets
     };

package/dist/_contracts/run-trace.d.ts

@@ -1,114 +1,28 @@
-/**
- * Typed decoders for a `listEvents(runId)` stream.
- *
- * `listEvents` returns the loose {@link RunEvent} wire shape: `type` at the top
- * level, but the tool name at `data.name`, the call args at `data.arguments`,
- * assistant text at `data.text`, and — the awkward part — a `TOOL_CALL_RESULT`
- * carries no name, so a consumer must correlate each result back to its
- * `TOOL_CALL_START` by `data.id` (the tool-call id). Every consumer ended up
- * re-implementing that correlation; these helpers do it once, typed and pure.
- *
- * They are total and side-effect-free: pass the array `listEvents` returns and
- * get back structured traces. Unknown event types are ignored (forward-compat),
- * a result with no matching start surfaces as an orphan (never dropped silently),
- * and timing falls back gracefully when a `recordedAt` is absent.
- *
- * `summarizeRunUsage` remains tolerant of historical/internal `aex.usage`
- * CUSTOM records when a caller has them, but the normal public `listEvents`
- * stream is not the live usage-reporting surface. Settled provider/runtime
- * usage is exposed through the run's `costTelemetry`.
- */
 import type { UsageSummary } from "./runtime-types.js";
-/**
- * One decoded tool call: the `TOOL_CALL_START` and its correlated
- * `TOOL_CALL_RESULT` (when present), with timing. `result` is undefined while a
- * call is still in flight (the start has arrived but not the result), so a
- * mid-run decode shows in-progress calls honestly rather than dropping them.
- */
 export interface ToolCallTrace {
-    /** The tool-call id (`data.id`) that pairs the start with its result. */
     readonly id: string;
-    /** The tool name (from the `TOOL_CALL_START`). */
     readonly name: string;
-    /** The call arguments (`data.arguments`), or `{}` when absent. */
     readonly args: Readonly<Record<string, unknown>>;
-    /** The id of the assistant message that issued the call, when present. */
     readonly messageId?: string;
-    /** Event sequence of the `TOOL_CALL_START` (ordering within the run). */
     readonly startSeq?: number;
-    /** ISO-8601 time of the `TOOL_CALL_START`, when the event carried one. */
     readonly startedAt?: string;
-    /** The correlated result; undefined while the call is still in flight. */
     readonly result?: ToolCallResult;
-    /** Result wall-clock minus start wall-clock (ms); undefined if either time is missing. */
     readonly durationMs?: number;
 }
-/** The result half of a {@link ToolCallTrace}, decoded from `TOOL_CALL_RESULT`. */
 export interface ToolCallResult {
-    /** True when the tool reported an error (`data.isError`). */
     readonly isError: boolean;
-    /** The tool's result content, passed through verbatim (`data.content`). */
     readonly content: unknown;
-    /** Event sequence of the `TOOL_CALL_RESULT`. */
     readonly seq?: number;
-    /** ISO-8601 time of the `TOOL_CALL_RESULT`, when the event carried one. */
     readonly recordedAt?: string;
 }
-/** One assistant text block, decoded from a `TEXT_MESSAGE_CONTENT` event. */
 export interface AssistantTextEntry {
     readonly text: string;
     readonly messageId?: string;
     readonly seq?: number;
     readonly recordedAt?: string;
 }
-/**
- * A decoded view of a run's event stream: the correlated tool calls, the
- * aggregate token usage, and the assistant text — everything a consumer
- * previously hand-decoded from `listEvents`.
- */
 export interface RunTrace {
     readonly toolCalls: readonly ToolCallTrace[];
     readonly usage: UsageSummary;
     readonly text: readonly AssistantTextEntry[];
 }
-/** The loose event shape these decoders read — the {@link RunEvent} subset they touch. */
-interface TraceEvent {
-    readonly type: string;
-    readonly seq?: number;
-    readonly recordedAt?: string;
-    readonly data?: unknown;
-    readonly [key: string]: unknown;
-}
-/**
- * Decode a `listEvents` stream into correlated tool-call traces, in start order.
- *
- * Each `TOOL_CALL_START` opens a trace keyed by `data.id`; the matching
- * `TOOL_CALL_RESULT` (same `data.id`) fills in `result` + `durationMs`. A result
- * whose id never had a start is surfaced as an orphan trace (empty `name`, no
- * `args`) rather than dropped, so a partial/mis-ordered stream never hides a
- * result. Pure — no I/O, input is not mutated.
- */
-export declare function decodeToolCalls(events: readonly TraceEvent[]): readonly ToolCallTrace[];
-/**
- * Sum any `aex.usage` CUSTOM events present in the supplied stream into one
- * {@link UsageSummary}. This is mainly for historical/internal event arrays;
- * current public reads expose settled provider usage through cost telemetry.
- * `totalTokens` is the sum of input + output tokens. Pure.
- */
-export declare function summarizeRunUsage(events: readonly TraceEvent[]): UsageSummary;
-/**
- * The run's final assistant text: every `TEXT_MESSAGE_CONTENT` block in stream
- * order, concatenated. The one-line "what did the agent say" accessor over
- * {@link decodeAssistantText} (buffered mode yields whole messages, stream mode
- * yields token deltas — both concatenate correctly). Pure.
- */
-export declare function textOf(events: readonly TraceEvent[]): string;
-/** Decode the assistant text blocks (`TEXT_MESSAGE_CONTENT`) in stream order. Pure. */
-export declare function decodeAssistantText(events: readonly TraceEvent[]): readonly AssistantTextEntry[];
-/**
- * Decode a whole `listEvents` stream in one pass: correlated tool calls,
- * aggregate {@link UsageSummary}, and assistant text. Convenience over the three
- * focused decoders; pure.
- */
-export declare function summarizeRunTrace(events: readonly TraceEvent[]): RunTrace;
-export {};