@aexhq/sdk 0.28.1 → 0.30.0

package/README.md

@@ -9,7 +9,7 @@ aex is an agent execution platform for launching autonomous agents from a simple
 The package ships:
 
 - `AgentExecutor` for submit, run, wait, stream, inspect, download, cancel, and delete.
-- Typed run primitives: `Models`, `Providers`, `RunRegions`, `RuntimeSizes`, `Skill`, `AgentsMd`, `File`, `McpServer`, `ProxyEndpoint`, and `Secret`.
+- Typed run primitives: `Models`, `Providers`, `Regions`, `RuntimeSizes`, `Skill`, `AgentsMd`, `File`, `McpServer`, `ProxyEndpoint`, and `Secret`.
 - A bundled `aex` CLI with the same run, status, events, outputs, download, cancel, delete, whoami, and skills operations.
 
 ## Install
@@ -21,17 +21,28 @@ bun add @aexhq/sdk
 ## First Run
 
 ```ts
-import { AgentExecutor, Models, Providers } from "@aexhq/sdk";
+import { AgentExecutor, Models } from "@aexhq/sdk";
 
-const aex = new AgentExecutor({
-  apiToken: process.env.AEX_API_TOKEN!
+const aex = new AgentExecutor({ apiToken: process.env.AEX_API_TOKEN! });
+
+// run() submits, waits for the run to settle, and returns the result —
+// no manual poll loop. `provider` is derived from the model.
+const { text, ok } = await aex.run({
+  model: Models.CLAUDE_HAIKU_4_5,
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+  prompt: "Summarize this repo."
 });
 
+console.log(ok, text);
+```
+
+Need the run id, live events, or downloads? Use `submit` + `stream` + `wait`:
+
+```ts
 const runId = await aex.submit({
-  provider: Providers.ANTHROPIC,
   model: Models.CLAUDE_HAIKU_4_5,
-  prompt: "Write the report and save outputs.",
-  secrets: { apiKey: process.env.ANTHROPIC_API_KEY! }
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+  prompt: "Write the report and save outputs."
 });
 
 for await (const event of aex.stream(runId)) {
@@ -44,6 +55,17 @@ console.log(run.status);
 await aex.download(runId, { to: "./run.zip" });
 ```
 
+For multiple providers (e.g. subagents on a different model family), pass a
+`credentials` map instead of `apiKey`:
+
+```ts
+await aex.run({
+  model: Models.CLAUDE_HAIKU_4_5,
+  credentials: { anthropic: process.env.ANTHROPIC_API_KEY!, openai: process.env.OPENAI_API_KEY! },
+  prompt: "Delegate research to a subagent."
+});
+```
+
 The same request can run from the CLI:
 
 ```bash
@@ -55,6 +77,57 @@ aex run \
   --follow
 ```
 
+## CLI: login, discovery, typed errors
+
+Stop re-passing `--api-token` on every command — log in once and the token (plus
+your default `--aex-url`) is persisted to a `0600` config file
+(`$XDG_CONFIG_HOME/aex/config.json` or `~/.config/aex/config.json`; `%APPDATA%\aex\config.json`
+on Windows). An explicit `--api-token` flag always overrides the stored one.
+
+```bash
+aex login --api-token "$AEX_API_TOKEN" [--aex-url https://api.aex.dev]
+aex whoami            # no --api-token needed after login
+aex auth status       # show the resolved config (the token value is never printed)
+aex logout            # clear the stored token
+```
+
+Discover the closed sets the platform accepts — no token, no network (human table
+by default, machine JSON under `--json`):
+
+```bash
+aex models list           # canonical models + their default provider
+aex providers list        # providers + the models each serves
+aex tools list            # builtin tools (default vs opt-in, e.g. notebook_edit)
+aex runtime-sizes list    # managed runtime presets (cpus / memory / default)
+```
+
+Errors are typed and actionable. Every `submit()` config-validation failure throws
+a `RunConfigValidationError` (`err.code === "RUN_CONFIG_INVALID"`) 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`/
+`--runtime-size`/`--region` gets a "did you mean?" suggestion.
+
+## Chat over a corpus of runs
+
+Turn a selected set of runs into a read-only chat. `createCorpusTools(client, { runIds })`
+returns vendor-neutral, corpus-scoped read tools (`list_runs` / `get_run` /
+`list_outputs` / `read_output` / `search_outputs`) — every tool refuses a run
+outside the corpus. Drive them with any LLM; `examples/chat-corpus.ts` shows the
+direct-Claude loop (`@anthropic-ai/sdk`), and the CLI ships it as a one-shot
+command (BYOK; the importable SDK stays LLM-vendor-free):
+
+```bash
+aex chat --run run_<A> --run run_<B> \
+  --anthropic-api-key "$ANTHROPIC_API_KEY" \
+  --model claude-opus-4-8 \
+  --prompt "Across these runs, which produced a report.md and what's its headline finding?" \
+  --api-token "$AEX_API_TOKEN"
+```
+
+`AgentExecutor.searchOutputs({ runIds, filename, extension, contentType, limit })`
+finds output files across runs and returns references (no bytes) you then
+`readOutputText`.
+
 ## Feature Areas
 
 - **Agent runtime:** managed autonomous runs with filesystem read/edit, grep/glob/head/tail, open web fetch/search defaults, optional notebook tools, and post-hook repair.

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

@@ -0,0 +1,67 @@
+/**
+ * Type-narrowing guards over the loose {@link RunEvent} `listEvents` shape.
+ *
+ * The envelope guards in `event-envelope.ts` operate on the coordinator
+ * {@link import("./event-envelope.js").AexEvent} and return a plain `boolean`.
+ * These mirror the same AG-UI discriminants but operate on the {@link RunEvent}
+ * snapshot shape returned by `listEvents` / `RunResult.events` and NARROW
+ * `event.data` to the fields that event type carries, so a consumer reads
+ * `event.data.text` (etc.) without a manual cast.
+ *
+ * They are DISCRIMINANT-only at runtime (they test `event.type`), matching the
+ * envelope guards: the narrowed `data` shape is a typing convenience, not a deep
+ * runtime validation. Parse/verify the payload fields before trusting them when
+ * the producer is untrusted.
+ *
+ * The parameter is the minimal `{ type }` discriminant both the {@link RunEvent}
+ * snapshot and the coordinator `AexEvent` envelope satisfy, so the guards accept
+ * either shape while narrowing to the {@link RunEvent}-typed payloads.
+ */
+import type { RunEvent } from "./runtime-types.js";
+/** A `TEXT_MESSAGE_CONTENT` run event with its assistant-text payload narrowed. */
+export interface TextMessageRunEvent extends RunEvent {
+    readonly type: "TEXT_MESSAGE_CONTENT";
+    readonly data: {
+        readonly text: string;
+        readonly messageId?: string;
+    };
+}
+/** A `TOOL_CALL_START` run event with the tool-call id/name/args narrowed. */
+export interface ToolCallStartRunEvent extends RunEvent {
+    readonly type: "TOOL_CALL_START";
+    readonly data: {
+        readonly id: string;
+        readonly name: string;
+        readonly arguments?: Record<string, unknown>;
+    };
+}
+/** A `TOOL_CALL_RESULT` run event with the correlating id + result narrowed. */
+export interface ToolCallResultRunEvent extends RunEvent {
+    readonly type: "TOOL_CALL_RESULT";
+    readonly data: {
+        readonly id: string;
+        readonly content?: unknown;
+        readonly isError?: boolean;
+    };
+}
+/** A terminal `RUN_FINISHED` run event. */
+export interface RunFinishedRunEvent extends RunEvent {
+    readonly type: "RUN_FINISHED";
+    readonly data: Record<string, unknown>;
+}
+/** True for an assistant text event; narrows `event.data.text` to `string`. */
+export declare function isTextMessage(event: {
+    readonly type: string;
+}): event is TextMessageRunEvent;
+/** True for a tool-call start event; narrows `event.data` to `{ id, name }`. */
+export declare function isToolCallStart(event: {
+    readonly type: string;
+}): event is ToolCallStartRunEvent;
+/** True for a tool-call result event; narrows `event.data` to `{ id, content }`. */
+export declare function isToolCallResult(event: {
+    readonly type: string;
+}): event is ToolCallResultRunEvent;
+/** True for the terminal success event; narrows `event.data` to a record. */
+export declare function isRunFinished(event: {
+    readonly type: string;
+}): event is RunFinishedRunEvent;

package/dist/_contracts/event-guards.js

@@ -0,0 +1,36 @@
+/**
+ * Type-narrowing guards over the loose {@link RunEvent} `listEvents` shape.
+ *
+ * The envelope guards in `event-envelope.ts` operate on the coordinator
+ * {@link import("./event-envelope.js").AexEvent} and return a plain `boolean`.
+ * These mirror the same AG-UI discriminants but operate on the {@link RunEvent}
+ * snapshot shape returned by `listEvents` / `RunResult.events` and NARROW
+ * `event.data` to the fields that event type carries, so a consumer reads
+ * `event.data.text` (etc.) without a manual cast.
+ *
+ * They are DISCRIMINANT-only at runtime (they test `event.type`), matching the
+ * envelope guards: the narrowed `data` shape is a typing convenience, not a deep
+ * runtime validation. Parse/verify the payload fields before trusting them when
+ * the producer is untrusted.
+ *
+ * The parameter is the minimal `{ type }` discriminant both the {@link RunEvent}
+ * snapshot and the coordinator `AexEvent` envelope satisfy, so the guards accept
+ * either shape while narrowing to the {@link RunEvent}-typed payloads.
+ */
+/** True for an assistant text event; narrows `event.data.text` to `string`. */
+export function isTextMessage(event) {
+    return event.type === "TEXT_MESSAGE_CONTENT";
+}
+/** True for a tool-call start event; narrows `event.data` to `{ id, name }`. */
+export function isToolCallStart(event) {
+    return event.type === "TOOL_CALL_START";
+}
+/** True for a tool-call result event; narrows `event.data` to `{ id, content }`. */
+export function isToolCallResult(event) {
+    return event.type === "TOOL_CALL_RESULT";
+}
+/** True for the terminal success event; narrows `event.data` to a record. */
+export function isRunFinished(event) {
+    return event.type === "RUN_FINISHED";
+}
+//# sourceMappingURL=event-guards.js.map

package/dist/_contracts/index.d.ts

@@ -29,3 +29,5 @@ 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

@@ -29,4 +29,10 @@ 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`
+// snapshot shape `listEvents` returns. An `AexEvent` is assignable to `RunEvent`,
+// so envelope consumers keep working; the envelope-typed guards stay reachable
+// via the direct `event-envelope.js` module.
+export { isRunFinished, isTextMessage, isToolCallResult, isToolCallStart } from "./event-guards.js";
 //# sourceMappingURL=index.js.map

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, type RunRegion } from "./submission.js";
+import { type JsonValue, type PlatformProxyEndpoint, type PlatformEnvironment, type Region } from "./submission.js";
 import { type RunModel } from "./models.js";
 import type { RuntimeSize } from "./runtime-sizes.js";
 import { type PlatformPostHookInput } from "./post-hook.js";
@@ -308,8 +308,8 @@ export interface RunRequestConfig {
     readonly environment?: PlatformEnvironment;
     /** Managed runtime size preset (see {@link RuntimeSize}). */
     readonly runtimeSize?: RuntimeSize;
-    /** Product placement token. Omitted lets the hosted platform infer/fallback. */
-    readonly region?: RunRegion;
+    /** Product placement region. Omitted lets the hosted platform infer/fallback. */
+    readonly region?: Region;
     /** Run deadline as a duration string (`"1h"`, `"30m"`); bounded [1m, 6h] server-side. */
     readonly timeout?: string;
     /** Post-agent-run verifier command. Empty command is treated as omitted. */

package/dist/_contracts/run-config.js

@@ -30,7 +30,7 @@
  * Keep this as the public source of truth for the SDK/CLI composition
  * boundary.
  */
-import { parseRunRegion, } from "./submission.js";
+import { parseRegion, } from "./submission.js";
 import { parseRunModel } from "./models.js";
 import { parsePostHook } from "./post-hook.js";
 // ---------------------------------------------------------------------------
@@ -670,7 +670,7 @@ export function parseRunRequestConfig(input) {
     const prompt = parseRunRequestConfigPrompt(record.prompt);
     const skills = parseRunRequestConfigSkills(record.skills);
     const mcpServers = parseRunRequestConfigMcpServers(record.mcpServers);
-    const region = parseRunRegion(record.region);
+    const region = parseRegion(record.region);
     const postHook = parsePostHook(record.postHook, "run request config postHook");
     return {
         model,

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

@@ -96,6 +96,13 @@ export declare function decodeToolCalls(events: readonly TraceEvent[]): readonly
  * `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[];
 /**

package/dist/_contracts/run-trace.js

@@ -123,6 +123,15 @@ export function summarizeRunUsage(events) {
         totalTokens: totals.inputTokens + totals.outputTokens
     };
 }
+/**
+ * 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 function textOf(events) {
+    return decodeAssistantText(events).map((entry) => entry.text).join("");
+}
 /** Decode the assistant text blocks (`TEXT_MESSAGE_CONTENT`) in stream order. Pure. */
 export function decodeAssistantText(events) {
     const out = [];

package/dist/_contracts/runtime-sizes.d.ts

@@ -11,106 +11,52 @@ export interface RuntimeResources {
 }
 /**
  * The single source of truth: every offered preset, keyed by its wire token.
- * Tokens intentionally remain stable product presets.
+ * Tokens intentionally remain stable product presets. The smallest
+ * (`shared-0.06x-256mb`) tier is for light / IO-bound runs only.
  */
 export declare const RUNTIME_SIZE_PRESETS: {
-    readonly "shared-1x-128mb": {
-        readonly cpus: 1;
-        readonly memoryMb: 128;
-    };
-    readonly "shared-1x-256mb": {
-        readonly cpus: 1;
+    readonly "shared-0.06x-256mb": {
+        readonly cpus: 0.0625;
         readonly memoryMb: 256;
     };
-    readonly "shared-1x-512mb": {
-        readonly cpus: 1;
-        readonly memoryMb: 512;
-    };
-    readonly "shared-1x-1gb": {
-        readonly cpus: 1;
-        readonly memoryMb: 1024;
-    };
-    readonly "shared-1x-2gb": {
-        readonly cpus: 1;
-        readonly memoryMb: 2048;
-    };
-    readonly "shared-2x-512mb": {
-        readonly cpus: 2;
-        readonly memoryMb: 512;
-    };
-    readonly "shared-2x-1gb": {
-        readonly cpus: 2;
-        readonly memoryMb: 1024;
-    };
-    readonly "shared-2x-2gb": {
-        readonly cpus: 2;
-        readonly memoryMb: 2048;
-    };
-    readonly "shared-2x-4gb": {
-        readonly cpus: 2;
-        readonly memoryMb: 4096;
-    };
-    readonly "shared-4x-1gb": {
-        readonly cpus: 4;
+    readonly "shared-0.25x-1gb": {
+        readonly cpus: 0.25;
         readonly memoryMb: 1024;
     };
-    readonly "shared-4x-2gb": {
-        readonly cpus: 4;
-        readonly memoryMb: 2048;
-    };
-    readonly "shared-4x-4gb": {
-        readonly cpus: 4;
+    readonly "shared-0.5x-4gb": {
+        readonly cpus: 0.5;
         readonly memoryMb: 4096;
     };
-    readonly "shared-4x-8gb": {
-        readonly cpus: 4;
-        readonly memoryMb: 8192;
-    };
-    readonly "shared-8x-2gb": {
-        readonly cpus: 8;
-        readonly memoryMb: 2048;
-    };
-    readonly "shared-8x-4gb": {
-        readonly cpus: 8;
-        readonly memoryMb: 4096;
+    readonly "shared-1x-6gb": {
+        readonly cpus: 1;
+        readonly memoryMb: 6144;
     };
-    readonly "shared-8x-8gb": {
-        readonly cpus: 8;
+    readonly "shared-2x-8gb": {
+        readonly cpus: 2;
         readonly memoryMb: 8192;
     };
-    readonly "shared-8x-16gb": {
-        readonly cpus: 8;
-        readonly memoryMb: 16384;
+    readonly "shared-4x-12gb": {
+        readonly cpus: 4;
+        readonly memoryMb: 12288;
     };
 };
 /** The accepted runtime-size values (the wire/CLI tokens). */
 export type RuntimeSize = keyof typeof RUNTIME_SIZE_PRESETS;
 /** All preset tokens, ordered as declared. Handy for CLI help + validation. */
 export declare const RUNTIME_SIZES: readonly RuntimeSize[];
-/** Default when `runtimeSize` is omitted. */
+/** Default when `runtimeSize` is omitted (the 1 GB tier). */
 export declare const DEFAULT_RUNTIME_SIZE: RuntimeSize;
 /**
- * Symbol-style accessors for TS callers. `RuntimeSizes.SHARED_2X_2GB`
- * resolves to the wire token `"shared-2x-2gb"`.
+ * Symbol-style accessors for TS callers. `RuntimeSizes.SHARED_2X_8GB`
+ * resolves to the wire token `"shared-2x-8gb"`.
  */
 export declare const RuntimeSizes: {
-    readonly SHARED_1X_128MB: "shared-1x-128mb";
-    readonly SHARED_1X_256MB: "shared-1x-256mb";
-    readonly SHARED_1X_512MB: "shared-1x-512mb";
-    readonly SHARED_1X_1GB: "shared-1x-1gb";
-    readonly SHARED_1X_2GB: "shared-1x-2gb";
-    readonly SHARED_2X_512MB: "shared-2x-512mb";
-    readonly SHARED_2X_1GB: "shared-2x-1gb";
-    readonly SHARED_2X_2GB: "shared-2x-2gb";
-    readonly SHARED_2X_4GB: "shared-2x-4gb";
-    readonly SHARED_4X_1GB: "shared-4x-1gb";
-    readonly SHARED_4X_2GB: "shared-4x-2gb";
-    readonly SHARED_4X_4GB: "shared-4x-4gb";
-    readonly SHARED_4X_8GB: "shared-4x-8gb";
-    readonly SHARED_8X_2GB: "shared-8x-2gb";
-    readonly SHARED_8X_4GB: "shared-8x-4gb";
-    readonly SHARED_8X_8GB: "shared-8x-8gb";
-    readonly SHARED_8X_16GB: "shared-8x-16gb";
+    readonly SHARED_0_06X_256MB: "shared-0.06x-256mb";
+    readonly SHARED_0_25X_1GB: "shared-0.25x-1gb";
+    readonly SHARED_0_5X_4GB: "shared-0.5x-4gb";
+    readonly SHARED_1X_6GB: "shared-1x-6gb";
+    readonly SHARED_2X_8GB: "shared-2x-8gb";
+    readonly SHARED_4X_12GB: "shared-4x-12gb";
 };
 /** Resolve a preset token to its product-level resource descriptor. */
 export declare function runtimeResources(size: RuntimeSize): RuntimeResources;

package/dist/_contracts/runtime-sizes.js

@@ -7,53 +7,32 @@
  */
 /**
  * The single source of truth: every offered preset, keyed by its wire token.
- * Tokens intentionally remain stable product presets.
+ * Tokens intentionally remain stable product presets. The smallest
+ * (`shared-0.06x-256mb`) tier is for light / IO-bound runs only.
  */
 export const RUNTIME_SIZE_PRESETS = {
-    "shared-1x-128mb": { cpus: 1, memoryMb: 128 },
-    "shared-1x-256mb": { cpus: 1, memoryMb: 256 },
-    "shared-1x-512mb": { cpus: 1, memoryMb: 512 },
-    "shared-1x-1gb": { cpus: 1, memoryMb: 1024 },
-    "shared-1x-2gb": { cpus: 1, memoryMb: 2048 },
-    "shared-2x-512mb": { cpus: 2, memoryMb: 512 },
-    "shared-2x-1gb": { cpus: 2, memoryMb: 1024 },
-    "shared-2x-2gb": { cpus: 2, memoryMb: 2048 },
-    "shared-2x-4gb": { cpus: 2, memoryMb: 4096 },
-    "shared-4x-1gb": { cpus: 4, memoryMb: 1024 },
-    "shared-4x-2gb": { cpus: 4, memoryMb: 2048 },
-    "shared-4x-4gb": { cpus: 4, memoryMb: 4096 },
-    "shared-4x-8gb": { cpus: 4, memoryMb: 8192 },
-    "shared-8x-2gb": { cpus: 8, memoryMb: 2048 },
-    "shared-8x-4gb": { cpus: 8, memoryMb: 4096 },
-    "shared-8x-8gb": { cpus: 8, memoryMb: 8192 },
-    "shared-8x-16gb": { cpus: 8, memoryMb: 16384 }
+    "shared-0.06x-256mb": { cpus: 0.0625, memoryMb: 256 },
+    "shared-0.25x-1gb": { cpus: 0.25, memoryMb: 1024 },
+    "shared-0.5x-4gb": { cpus: 0.5, memoryMb: 4096 },
+    "shared-1x-6gb": { cpus: 1, memoryMb: 6144 },
+    "shared-2x-8gb": { cpus: 2, memoryMb: 8192 },
+    "shared-4x-12gb": { cpus: 4, memoryMb: 12288 }
 };
 /** All preset tokens, ordered as declared. Handy for CLI help + validation. */
 export const RUNTIME_SIZES = Object.keys(RUNTIME_SIZE_PRESETS);
-/** Default when `runtimeSize` is omitted. */
-export const DEFAULT_RUNTIME_SIZE = "shared-1x-128mb";
+/** Default when `runtimeSize` is omitted (the 1 GB tier). */
+export const DEFAULT_RUNTIME_SIZE = "shared-0.25x-1gb";
 /**
- * Symbol-style accessors for TS callers. `RuntimeSizes.SHARED_2X_2GB`
- * resolves to the wire token `"shared-2x-2gb"`.
+ * Symbol-style accessors for TS callers. `RuntimeSizes.SHARED_2X_8GB`
+ * resolves to the wire token `"shared-2x-8gb"`.
  */
 export const RuntimeSizes = {
-    SHARED_1X_128MB: "shared-1x-128mb",
-    SHARED_1X_256MB: "shared-1x-256mb",
-    SHARED_1X_512MB: "shared-1x-512mb",
-    SHARED_1X_1GB: "shared-1x-1gb",
-    SHARED_1X_2GB: "shared-1x-2gb",
-    SHARED_2X_512MB: "shared-2x-512mb",
-    SHARED_2X_1GB: "shared-2x-1gb",
-    SHARED_2X_2GB: "shared-2x-2gb",
-    SHARED_2X_4GB: "shared-2x-4gb",
-    SHARED_4X_1GB: "shared-4x-1gb",
-    SHARED_4X_2GB: "shared-4x-2gb",
-    SHARED_4X_4GB: "shared-4x-4gb",
-    SHARED_4X_8GB: "shared-4x-8gb",
-    SHARED_8X_2GB: "shared-8x-2gb",
-    SHARED_8X_4GB: "shared-8x-4gb",
-    SHARED_8X_8GB: "shared-8x-8gb",
-    SHARED_8X_16GB: "shared-8x-16gb"
+    SHARED_0_06X_256MB: "shared-0.06x-256mb",
+    SHARED_0_25X_1GB: "shared-0.25x-1gb",
+    SHARED_0_5X_4GB: "shared-0.5x-4gb",
+    SHARED_1X_6GB: "shared-1x-6gb",
+    SHARED_2X_8GB: "shared-2x-8gb",
+    SHARED_4X_12GB: "shared-4x-12gb"
 };
 /** Resolve a preset token to its product-level resource descriptor. */
 export function runtimeResources(size) {

package/dist/_contracts/runtime-types.d.ts

@@ -79,6 +79,37 @@ export interface RunListPage {
     readonly runs: readonly RunSummary[];
     readonly nextCursor?: string;
 }
+/**
+ * Cross-run output search query (`AgentExecutor.searchOutputs`). Restrict to a
+ * corpus with `runIds`; filter by filename substring / extension / content type.
+ * The MVP composes this client-side (per-run `listOutputs` + filter) — a future
+ * server-side `GET /api/outputs/search` can back the same contract with a real
+ * cross-run index, body-only swap.
+ */
+export interface OutputSearchQuery {
+    /** Restrict the search to these runs (the chat corpus allow-list). */
+    readonly runIds?: readonly string[];
+    /** Case-insensitive substring match on the output filename. */
+    readonly filename?: string;
+    /** File extension, with or without a leading dot. Case-insensitive. */
+    readonly extension?: string;
+    /** Exact content type or a prefix wildcard such as `image/*`. */
+    readonly contentType?: string;
+    /** Cap the number of hits returned (default 100). */
+    readonly limit?: number;
+}
+/** One output-search hit — a reference only (no bytes); read with `readOutputText`. */
+export interface OutputSearchHit {
+    readonly runId: string;
+    readonly outputId: string;
+    readonly filename?: string;
+    readonly sizeBytes?: number;
+    readonly contentType?: string;
+}
+/** A page of output-search hits. */
+export interface OutputSearchPage {
+    readonly hits: readonly OutputSearchHit[];
+}
 /**
  * A run event as recorded by the dashboard. Includes the `type` field
  * that the `is*Event` type guards narrow on plus any provider payload.

package/dist/_contracts/submission.d.ts

@@ -138,19 +138,28 @@ export declare const Providers: {
     readonly DOUBAO_CN: "doubao-cn";
 };
 /**
- * Product placement tokens accepted on run submission. These are not exact
- * city guarantees: the hosted platform maps each token to the configured
- * database, object store, Durable Object, and sandbox backing available for
- * that product region.
- */
-export declare const RUN_REGIONS: readonly ["lhr", "iad", "sfo", "bom"];
-export type RunRegion = (typeof RUN_REGIONS)[number];
-/** Symbol-style accessors for the closed run-region set. */
-export declare const RunRegions: {
-    readonly LHR: "lhr";
-    readonly IAD: "iad";
-    readonly SFO: "sfo";
-    readonly BOM: "bom";
+ * Product placement regions accepted on run submission. These are
+ * product-level tokens, not exact city guarantees: the hosted platform maps
+ * each region to co-located managed Postgres, object storage, run-state
+ * placement, and sandbox backing.
+ *
+ *   eu-west       → London        (Western Europe)
+ *   us-west       → N. California (Western North America)
+ *   ap-northeast  → Seoul         (Northeast Asia)
+ *
+ * Prefer the {@link Regions} accessors over raw strings so a typo is a compile
+ * error, not a runtime 400.
+ */
+export declare const REGIONS: readonly ["eu-west", "us-west", "ap-northeast"];
+export type Region = (typeof REGIONS)[number];
+/** Symbol-style accessors for the closed region set — e.g. `Regions.EU_WEST`. */
+export declare const Regions: {
+    /** Western Europe — London. */
+    readonly EU_WEST: "eu-west";
+    /** Western North America — N. California. */
+    readonly US_WEST: "us-west";
+    /** Northeast Asia — Seoul. */
+    readonly AP_NORTHEAST: "ap-northeast";
 };
 /**
  * Customer-facing runtime selector. Optional on the wire; absent resolves
@@ -315,6 +324,11 @@ export declare function requireString(input: unknown, field: string): string;
 export declare function optionalString(input: unknown, field: string): string | undefined;
 export declare function optionalEnum<const T extends readonly string[]>(input: unknown, field: string, allowed: T): T[number] | undefined;
 export declare function optionalPositiveInt(input: unknown, field: string): number | undefined;
+/**
+ * A finite positive NUMBER (fractional allowed — e.g. a USD amount like `2.5`), or
+ * undefined when absent. Rejects non-numbers, NaN/Infinity, and `<= 0`.
+ */
+export declare function optionalPositiveNumber(input: unknown, field: string): number | undefined;
 /**
  * Wire-level submission posted to /api/runs in the flat surface. The
  * `prompt` is always an array internally so the worker, the audit log,
@@ -444,7 +458,7 @@ export interface PlatformRunSubmissionRequest {
      * falls back to its default region. Accepted tokens do not promise exact
      * city-level placement.
      */
-    readonly region?: RunRegion;
+    readonly region?: Region;
     readonly submission: PlatformSubmission;
     readonly secrets: PlatformInlineSecrets;
     readonly proxyEndpoints?: readonly PlatformProxyEndpoint[];
@@ -508,6 +522,15 @@ export interface RunWebhookSpec {
 export interface RunLimits {
     readonly maxConcurrentChildRuns?: number;
     readonly maxSubagentDepth?: number;
+    /**
+     * Per-run spend cap in USD (defense-in-depth). The platform converts it to a
+     * wall-clock budget (priced compute is wall-time; BYOK provider tokens cost the
+     * platform nothing) and kills the run once it would out-spend the cap. A
+     * positive number; omitted ⇒ unbounded per-run (only the run's wall-clock
+     * `timeout` + the per-workspace spend cap apply). Only shape/positivity are
+     * validated here.
+     */
+    readonly maxSpendUsd?: number;
 }
 /**
  * Wire shape posted by the SDK and CLI. `workspaceId` is **omitted by
@@ -533,10 +556,10 @@ export type PlatformRunSubmissionInput = Omit<PlatformRunSubmissionRequest, "wor
      */
     readonly runtime?: RuntimeKind;
     /**
-     * Optional product placement token. Invalid explicit values are rejected;
+     * Optional product placement region. Invalid explicit values are rejected;
      * omission lets the platform infer/fallback.
      */
-    readonly region?: RunRegion;
+    readonly region?: Region;
     /**
      * Run deadline as a human duration string (`"1h"`, `"90m"`, `"30s"`).
      * Parsed + bounded to [1m, 6h] server-side into
@@ -569,7 +592,7 @@ export declare function parseRunWebhook(input: unknown): RunWebhookSpec | undefi
  * collapses to `undefined` so it carries no signal onto the request.
  */
 export declare function parseRunLimits(input: unknown): RunLimits | undefined;
-export declare function parseRunRegion(input: unknown): RunRegion | undefined;
+export declare function parseRegion(input: unknown): Region | undefined;
 export declare function parseRuntimeKind(input: unknown): RuntimeKind | undefined;
 export declare function parseRunProvider(input: unknown): RunProvider;
 /**