@aexhq/sdk 0.40.16 → 0.41.0

package/dist/_contracts/submission.d.ts

@@ -1,6 +1,6 @@
-import type { AgentsMdRef, FileRef, McpServerRef, ResolvedSkillRef, SkillRef, ToolRef } from "./run-config.js";
+import type { AgentsMdRef, FileRef, McpServerRef, ResolvedSkillRef, SkillRef, ToolRef } from "./session-config.js";
 import { type RuntimeSize } from "./runtime-sizes.js";
-import { type RunModel } from "./models.js";
+import { type ModelName } from "./models.js";
 import { type RuntimeSecurityProfileName } from "./runtime-security-profile.js";
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonValue[] | {
@@ -8,9 +8,9 @@ export type JsonValue = JsonPrimitive | JsonValue[] | {
 };
 /**
  * Networking + runtime-package snapshot carried inside a flat submission
- * so the hosted API can deep-clone and mutate it per run (e.g. injecting the
+ * so the hosted API can deep-clone and mutate it per session (e.g. injecting the
  * proxy hostname into `allowed_hosts`) without sharing state across
- * concurrent runs.
+ * concurrent sessions.
  *
  * `envVars` is the customer-controlled key/value bag delivered into the
  * managed container process and mirrored in the mounted `RUNTIME.env` /
@@ -96,14 +96,14 @@ export interface PlatformPackageInput {
  */
 export declare function packageInstallString(pkg: PlatformPackage): string;
 /**
- * Run-time provider selector. Aex exposes one customer interface
+ * SessionRecord-time provider selector. Aex exposes one customer interface
  * for every provider. All new submissions execute through the managed
  * runtime; provider selection only decides which upstream model route
  * the managed provider-proxy uses.
  */
-export declare const RUN_PROVIDERS: readonly ["anthropic", "deepseek", "openai", "gemini", "mistral", "openrouter", "doubao", "doubao-cn"];
-export type RunProvider = (typeof RUN_PROVIDERS)[number];
-export declare const DEFAULT_RUN_PROVIDER: RunProvider;
+export declare const PROVIDERS: readonly ["anthropic", "deepseek", "openai", "gemini", "mistral", "openrouter", "doubao", "doubao-cn"];
+export type ProviderName = (typeof PROVIDERS)[number];
+export declare const DEFAULT_PROVIDER: ProviderName;
 /**
  * Symbol-style accessors for the closed provider set. Prefer these over raw
  * strings so an invalid token is a compile error, not a runtime 400 — e.g.
@@ -112,8 +112,8 @@ export declare const DEFAULT_RUN_PROVIDER: RunProvider;
  * submission field; name it explicitly with one of these constants rather than
  * relying on the model alone to determine routing.
  *
- * Every value mirrors {@link RUN_PROVIDERS} exactly; a unit test asserts
- * `Object.values(Providers)` deep-equals `RUN_PROVIDERS` so the two can never
+ * Every value mirrors {@link PROVIDERS} exactly; a unit test asserts
+ * `Object.values(Providers)` deep-equals `PROVIDERS` so the two can never
  * drift.
  */
 export declare const Providers: {
@@ -140,8 +140,8 @@ export interface PlatformMcpServerSecret {
     readonly headers?: Record<string, string>;
 }
 /**
- * Per-run inline secrets bundle. `apiKeys` holds the BYOK provider keys, keyed
- * by {@link RunProvider}. A run REQUIRES a key for its own `provider`; it MAY
+ * Per-session inline secrets bundle. `apiKeys` holds the BYOK provider keys, keyed
+ * by {@link ProviderName}. A session REQUIRES a key for its own `provider`; it MAY
  * carry keys for additional providers so a subagent spawned with a
  * different-family model inherits them server-side from the vault (the keys
  * never transit the container). `mcpServers` credentials are cross-provider
@@ -149,14 +149,14 @@ export interface PlatformMcpServerSecret {
  * client).
  */
 export interface PlatformInlineSecrets {
-    readonly apiKeys?: Partial<Record<RunProvider, string>>;
+    readonly apiKeys?: Partial<Record<ProviderName, string>>;
     readonly mcpServers?: readonly PlatformMcpServerSecret[];
     /**
-     * Per-run env-var secret VALUES, keyed by env name. Each entry pairs with a
+     * Per-session env-var secret VALUES, keyed by env name. Each entry pairs with a
      * `submission.secretEnv[<envName>] = { ephemeral: true }` declaration. Lives
      * in the secrets channel so it is vaulted and excluded from the idempotency
      * hash; the runtime injects it as the named env var and it is deleted at the
-     * run's terminal. Workspace `{ ref }` bindings resolve server-side and never
+     * session's terminal. Workspace `{ ref }` bindings resolve server-side and never
      * appear here.
      */
     readonly envSecrets?: Readonly<Record<string, string>>;
@@ -170,7 +170,7 @@ export declare const SECRET_HANDLE_PATTERN: RegExp;
  * One `submission.secretEnv` entry — VALUE-FREE, so it rides the (hashed)
  * submission safely. `{ ref }` resolves a workspace secret server-side;
  * `{ ephemeral: true }` pairs with a `secrets.envSecrets[<envName>]` value
- * (per-run, vaulted, deleted at the run's terminal).
+ * (per-session, vaulted, deleted at the session's terminal).
  */
 export type PlatformSecretEnvEntry = {
     readonly ref: string;
@@ -201,7 +201,7 @@ export declare function optionalPositiveInt(input: unknown, field: string): numb
  */
 export declare function optionalPositiveNumber(input: unknown, field: string): number | undefined;
 /**
- * Wire-level submission posted to /api/runs in the flat surface. The
+ * Wire-level submission posted to /api/sessions in the flat surface. The
  * `prompt` is always an array internally so the hosted API, the audit log,
  * and the BFF idempotency hash all see one shape. `mcpServers` carries
  * only the non-secret half; bearer headers travel in
@@ -212,7 +212,7 @@ export declare function optionalPositiveNumber(input: unknown, field: string): n
  * first-class input on `skills` (by-name refs), NOT part of `tools`.
  */
 export interface PlatformSubmission {
-    readonly model: RunModel;
+    readonly model: ModelName;
     readonly system?: string;
     readonly prompt: readonly string[];
     readonly tools?: readonly ToolRef[];
@@ -221,7 +221,7 @@ export interface PlatformSubmission {
      * public ingress shape the SDK sends and the ONLY skill field the idempotency
      * hash covers. The platform resolves each name to the workspace skill's
      * current bytes at submit time; a re-upload under the same name changes what
-     * later runs see (the name-only ref, and therefore the hash, is unchanged).
+     * later sessions see (the name-only ref, and therefore the hash, is unchanged).
      */
     readonly skills?: readonly SkillRef[];
     /**
@@ -240,7 +240,7 @@ export interface PlatformSubmission {
      * value is `{ ref }` (resolve a workspace secret server-side) or
      * `{ ephemeral: true }` (value supplied in `secrets.envSecrets`, vaulted and
      * deleted at terminal). The runtime injects the resolved value as the named
-     * env var. Lifecycle parity with skills/files: per-run by default, persisted
+     * env var. Lifecycle parity with skills/files: per-session by default, persisted
      * only when promoted to the workspace store.
      */
     readonly secretEnv?: Readonly<Record<string, PlatformSecretEnvEntry>>;
@@ -248,16 +248,17 @@ export interface PlatformSubmission {
     readonly securityProfile?: RuntimeSecurityProfileName;
     readonly metadata?: Record<string, JsonValue>;
     /**
-     * Output capture policy. Omit `outputs.allowedDirs` to capture the whole
-     * filesystem delta; provide it to narrow capture to the listed roots.
-     * `outputs.deniedDirs` subtracts denied roots/patterns from the allowed set.
+     * File capture policy. Omit `fileCapture.allowedDirs` to expose regular
+     * workspace files from the latest complete checkpoint; provide it to narrow
+     * capture to the listed roots. `fileCapture.deniedDirs` subtracts denied
+     * roots/patterns from the allowed set.
      */
-    readonly outputs?: PlatformOutputCaptureConfig;
+    readonly fileCapture?: PlatformFileCaptureConfig;
     /**
      * Whether to inject the standard builtin tool set ({@link DEFAULT_BUILTIN_TOOLS}).
      *
      *   - omitted / `true` (default): inject the standard builtins.
-     *   - `false`: inject NO builtins — useful for a pure-MCP / pure-custom run.
+     *   - `false`: inject NO builtins — useful for a pure-MCP / pure-custom session.
      *
      * Pick a narrow subset alongside `includeBuiltinTools: false` by listing
      * builtin names in `tools` (a bare-string builtin reference; prefer
@@ -268,7 +269,7 @@ export interface PlatformSubmission {
      * Explicit builtin tool NAME references the caller listed in the wire `tools`
      * union (the bare-string members), extracted at parse time. Each is a member
      * of {@link BUILTIN_TOOL_NAMES}. Composed with {@link includeBuiltinTools} via
-     * {@link resolveBuiltinToolNames} to produce the run's final builtin tool set.
+     * {@link resolveBuiltinToolNames} to produce the session's final builtin tool set.
      * `tools` itself carries only the custom tool bundles ({@link ToolRef}).
      */
     readonly builtinTools?: readonly BuiltinToolName[];
@@ -284,7 +285,7 @@ export interface PlatformSubmission {
     /**
      * Structured-output policy. `{ kind: 'text' }` (default) is free-form; a
      * `{ kind: 'json_schema', … }` requests provider-native constrained decode.
-     * The run's typed outcome is then `decoded | refused` — no untyped path yields
+     * The session's typed outcome is then `decoded | refused` — no untyped path yields
      * a hallucinated object. Fail-closed for a provider lacking the capability.
      */
     readonly responseFormat?: ResponseFormat;
@@ -298,21 +299,22 @@ export interface PlatformSubmission {
     /**
      * Platform-injection controls. The platform prepends a small system
      * prompt (see `platformSystemPrompt`) ahead of `system` to explain
-     * managed-run expectations such as durable file capture. Set
+     * managed-session expectations such as durable file capture. Set
      * `systemPrompt: "off"` to suppress that injection and have the runtime
      * see only the customer's own `system`. Omitting the field (or
      * `systemPrompt: "default"`) keeps the injection on.
      *
-     * This does not change output capture scope. Omitted
-     * `outputs.allowedDirs` means capture all created/modified files; explicit
-     * `outputs.allowedDirs` narrows it.
+     * This does not change file capture scope. Omitted
+     * `fileCapture.allowedDirs` means expose regular workspace files from the
+     * latest complete checkpoint; explicit `fileCapture.allowedDirs` narrows it.
      */
     readonly platform?: PlatformInjectionConfig;
 }
-export interface PlatformOutputCaptureConfig {
+export interface PlatformFileCaptureConfig {
     /**
-     * Allowed capture roots. Omit or pass an empty list to use the default
-     * whole-filesystem delta capture. Entries are absolute UNIX paths.
+     * Allowed capture roots. Omit or pass an empty list to expose regular
+     * workspace files from the latest complete checkpoint. Entries are absolute
+     * UNIX paths.
      */
     readonly allowedDirs?: readonly string[];
     /**
@@ -321,29 +323,29 @@ export interface PlatformOutputCaptureConfig {
      */
     readonly deniedDirs?: readonly string[];
     /**
-     * Maximum time the platform may spend capturing outputs after the agent exits.
+     * Maximum time the platform may spend capturing files after the agent exits.
      * Positive integer milliseconds; values above the platform maximum are clamped.
      */
     readonly captureTimeoutMs?: number;
     /** Maximum size of a single captured file in bytes. Positive integer. */
     readonly maxFileBytes?: number;
-    /** Maximum total captured output bytes for the run. Positive integer. */
+    /** Maximum total captured file bytes for the session. Positive integer. */
     readonly maxTotalBytes?: number;
-    /** Maximum number of captured files for the run. Positive integer. */
+    /** Maximum number of captured files for the session. Positive integer. */
     readonly maxFiles?: number;
 }
 export interface PlatformInjectionConfig {
     readonly systemPrompt?: "default" | "off";
 }
-export interface PlatformRunSubmissionRequest {
+export interface PlatformSessionSubmissionRequest {
     readonly workspaceId: string;
     readonly idempotencyKey: string;
     /**
      * Provider selector. Always populated after parsing — absent on the
-     * wire means {@link DEFAULT_RUN_PROVIDER}. All providers are dispatched
+     * wire means {@link DEFAULT_PROVIDER}. All providers are dispatched
      * through the managed runtime.
      */
-    readonly provider: RunProvider;
+    readonly provider: ProviderName;
     readonly submission: PlatformSubmission;
     readonly secrets: PlatformInlineSecrets;
     /**
@@ -352,55 +354,55 @@ export interface PlatformRunSubmissionRequest {
      */
     readonly runtimeSize?: RuntimeSize;
     /**
-     * Run deadline in milliseconds, normalised by the parser from the wire
+     * SessionRecord deadline in milliseconds, normalised by the parser from the wire
      * `timeout` duration string (bounded to [1m, 8h]). Absent ⇒
-     * {@link DEFAULT_RUN_TIMEOUT_MS} (8h). Applies to the managed runner's
+     * {@link DEFAULT_SESSION_TIMEOUT_MS} (8h). Applies to the managed runner's
      * terminal wait window and self-kill deadline.
      */
     readonly timeoutMs?: number;
     /**
-     * Optional per-run callback URL. The platform delivers exactly the terminal
-     * `run.finished` event to this URL at the settle-consistent barrier, signed
+     * Optional per-session callback URL. The platform delivers exactly the terminal
+     * `session.finished` event to this URL at the settle-consistent barrier, signed
      * Standard-Webhooks style. It is a sibling of {@link idempotencyKey} — an
      * operational/delivery concern, NOT part of the hashed submission brief, so
      * the same idempotency key with a different callback URL never 409s and the
      * field never enters `request_hash`.
      */
-    readonly webhook?: RunWebhookSpec;
+    readonly webhook?: SessionWebhookSpec;
     /**
-     * Optional per-run override of the lineage limits (max concurrent child runs,
-     * max subagent depth, per-run spend cap). These are dials the client may
+     * Optional per-session override of the lineage limits (max concurrent child sessions,
+     * max subagent depth, per-session spend cap). These are dials the client may
      * *request*; the server resolves them against the per-workspace ceiling and
      * the hard platform ceiling (clamping happens in the resolver, NOT this
      * parser). Absent fields fall back to the platform defaults. Only shape +
      * positivity are validated here.
      */
-    readonly limits?: RunLimits;
+    readonly limits?: SessionLimits;
     /**
-     * Optional capacity intent for the run's managed machine. `spot: true` opts
-     * the run into interruptible capacity; absent / `spot: false` requests
+     * Optional capacity intent for the session's managed machine. `spot: true` opts
+     * the session into interruptible capacity; absent / `spot: false` requests
      * standard capacity (the default). Intent only — the managed runtime selects
      * capacity from it.
      */
-    readonly machine?: RunMachine;
+    readonly machine?: SessionMachine;
 }
-/** Per-run webhook callback. v1: terminal-only; the URL must be https. */
-export interface RunWebhookSpec {
+/** Per-session webhook callback. v1: terminal-only; the URL must be https. */
+export interface SessionWebhookSpec {
     readonly url: string;
 }
 /**
- * Per-run override of the lineage limits. Both fields are optional; an absent
- * field means "use the platform default". The parser ({@link parseRunLimits})
+ * Per-session override of the lineage limits. Both fields are optional; an absent
+ * field means "use the platform default". The parser ({@link parseSessionLimits})
  * only validates positivity/shape — clamping to the workspace + platform
- * ceilings is the resolver's job (see `resolveRunLimits` in `@aexhq/shared`).
+ * ceilings is the resolver's job (see `resolveSessionLimits` in `@aexhq/shared`).
  */
-export interface RunLimits {
-    readonly maxConcurrentChildRuns?: number;
+export interface SessionLimits {
+    readonly maxConcurrentChildSessions?: number;
     readonly maxSubagentDepth?: number;
     /**
-     * Per-run spend cap in USD (defense-in-depth). The platform 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).
+     * Per-session spend cap in USD (defense-in-depth). The platform kills the session once
+     * it would out-spend the cap. A positive number; omitted ⇒ unbounded per-session
+     * (only the session's wall-clock `timeout` + the per-workspace spend cap apply).
      * Only shape/positivity are validated here.
      *
      * The frozen boot session config the managed runtime folds the loop against
@@ -409,9 +411,9 @@ export interface RunLimits {
      */
     readonly maxSpendUsd?: number;
     /**
-     * Maximum number of agent ITERATIONS (turns) the run may take before the
+     * Maximum number of agent ITERATIONS (turns) the session may take before the
      * platform parks it terminal. A positive integer; omitted ⇒ the platform
-     * default (`RUN_DEFAULT_MAX_TURNS`). Previously a bare server literal absent
+     * default (`SESSION_DEFAULT_MAX_TURNS`). Previously a bare server literal absent
      * from both the public contract and the limits SSoT — now a settable dial.
      * Only shape/positivity are validated here; clamping to the ceiling is the
      * resolver's job.
@@ -419,12 +421,12 @@ export interface RunLimits {
     readonly maxTurns?: number;
 }
 /**
- * Per-run machine/capacity intent. v1 exposes only `spot`: opt the run into
+ * Per-session machine/capacity intent. v1 exposes only `spot`: opt the session into
  * interruptible capacity (`spot: true`) vs standard capacity (absent /
  * `spot: false`, the default). Only the boolean intent is public — capacity
  * selection is a runtime concern.
  */
-export interface RunMachine {
+export interface SessionMachine {
     readonly spot?: boolean;
 }
 /**
@@ -437,20 +439,20 @@ export interface RunMachine {
  * itself.
  *
  * `provider` is also optional on the wire — absent means
- * {@link DEFAULT_RUN_PROVIDER} (`anthropic`). The parser fills it in
- * before the value enters the run snapshot.
+ * {@link DEFAULT_PROVIDER} (`anthropic`). The parser fills it in
+ * before the value enters the session snapshot.
  */
-export type PlatformRunSubmissionInput = Omit<PlatformRunSubmissionRequest, "workspaceId" | "provider" | "timeoutMs"> & {
+export type PlatformSessionSubmissionInput = Omit<PlatformSessionSubmissionRequest, "workspaceId" | "provider" | "timeoutMs"> & {
     readonly workspaceId?: string;
-    readonly provider?: RunProvider;
+    readonly provider?: ProviderName;
     /**
-     * Run deadline as a human duration string (`"1h"`, `"90m"`, `"30s"`).
+     * SessionRecord deadline as a human duration string (`"1h"`, `"90m"`, `"30s"`).
      * Parsed + bounded to [1m, 8h] server-side into
-     * {@link PlatformRunSubmissionRequest.timeoutMs}. Absent ⇒ 8h default.
+     * {@link PlatformSessionSubmissionRequest.timeoutMs}. Absent ⇒ 8h default.
      */
     readonly timeout?: string;
 };
-export interface ParseRunSubmissionOptions {
+export interface ParseSessionSubmissionOptions {
     /**
      * Set by the in-container re-parse of the boot record (`aws-compose.ts`) to
      * accept trusted-only fields the BFF resolver wrote after ingress — currently
@@ -459,68 +461,68 @@ export interface ParseRunSubmissionOptions {
      */
     readonly trustedReparse?: boolean;
 }
-export declare function parseRunSubmissionRequest(input: unknown, options?: ParseRunSubmissionOptions): PlatformRunSubmissionRequest;
+export declare function parseSessionSubmissionRequest(input: unknown, options?: ParseSessionSubmissionOptions): PlatformSessionSubmissionRequest;
 /**
- * Parse + SSRF-shape-validate the optional per-run `webhook`. The URL must be
+ * Parse + SSRF-shape-validate the optional per-session `webhook`. The URL must be
  * https with no userinfo (a `user:pass@host` URL is rejected — credentials must
  * not ride in a callback URL). Unknown subfields are rejected so the strict
  * top-level allow-list extends to the nested object. Returns `undefined` when
  * absent. Delivery-time re-resolution + IP-deny checks live server-side; this
  * is the submit-time shape gate.
  */
-export declare function parseRunWebhook(input: unknown): RunWebhookSpec | undefined;
+export declare function parseSessionWebhook(input: unknown): SessionWebhookSpec | undefined;
 /**
- * Parse the optional per-run `limits` override. Mirrors {@link parseRunWebhook}:
+ * Parse the optional per-session `limits` override. Mirrors {@link parseSessionWebhook}:
  * absent ⇒ `undefined`; a non-object or any unknown subfield is rejected so the
  * strict top-level allow-list extends to the nested object. Each present field
  * is validated as a positive safe integer via {@link optionalPositiveInt}.
  *
  * This is a SHAPE/positivity gate only — it does NOT clamp to the workspace or
- * platform ceilings (that precedence lives in the resolver, `resolveRunLimits`).
+ * platform ceilings (that precedence lives in the resolver, `resolveSessionLimits`).
  * Only the present fields are returned; an all-absent override (e.g. `{}`)
  * collapses to `undefined` so it carries no signal onto the request.
  */
-export declare function parseRunLimits(input: unknown): RunLimits | undefined;
+export declare function parseSessionLimits(input: unknown): SessionLimits | undefined;
 /**
- * Boot-session budget fragment. The public submit surface names a run's spend
+ * Boot-session budget fragment. The public submit surface names a session's spend
  * cap `limits.maxSpendUsd`; the frozen boot session config the managed runtime
  * folds the loop against names the SAME USD value `budgetUsd` — the field the
- * session planner reads to enforce/terminate a run that would out-spend its cap.
+ * session planner reads to enforce/terminate a session that would out-spend its cap.
  * This is the single source of truth for that wire→boot name mapping so the two
  * layers can never drift.
  *
  * Returns a fragment safe to spread into `sessionConfig.limits`: `{ budgetUsd }`
- * when a cap is set, `{}` when none is (an absent cap stays absent — the run is
- * unbounded per-run, subject only to the run timeout + the per-workspace cap).
+ * when a cap is set, `{}` when none is (an absent cap stays absent — the session is
+ * unbounded per-session, subject only to the session timeout + the per-workspace cap).
  * Pure: same input ⇒ same output.
  */
-export declare function sessionBudgetLimits(limits: RunLimits | undefined): {
+export declare function sessionBudgetLimits(limits: SessionLimits | undefined): {
     budgetUsd?: number;
 };
 /**
- * Parse the optional per-run `machine` capacity intent. Mirrors
- * {@link parseRunWebhook}: absent ⇒ `undefined`; a non-object or any unknown
+ * Parse the optional per-session `machine` capacity intent. Mirrors
+ * {@link parseSessionWebhook}: absent ⇒ `undefined`; a non-object or any unknown
  * subfield is rejected so the strict top-level allow-list extends to the nested
  * object. `spot` must be a boolean when present. A no-signal object (e.g.
  * `machine: {}`) collapses to `undefined` so it never lands an empty object on
  * the request. An explicit `spot` (true or false) is preserved verbatim. Only
  * shape is validated here — capacity selection is a runtime concern.
  */
-export declare function parseRunMachine(input: unknown): RunMachine | undefined;
-export declare function parseRunProvider(input: unknown): RunProvider;
+export declare function parseSessionMachine(input: unknown): SessionMachine | undefined;
+export declare function parseProviderName(input: unknown): ProviderName;
 /**
  * Cross-check the supplied secrets bundle against the credential mode. BYOK
- * requires `secrets.apiKeys[provider]` (the key for the run's own `provider`).
- * Additional provider keys are optional (validated for shape only) so the run
+ * requires `secrets.apiKeys[provider]` (the key for the session's own `provider`).
+ * Additional provider keys are optional (validated for shape only) so the session
  * can supply keys for the other providers its subagents may use. MCP / proxy
  * endpoint auth carry across providers and are not checked here.
  *
- * A CHILD run (`inheritsFromParent`) is exempt from the own-key requirement: it
+ * A CHILD session (`inheritsFromParent`) is exempt from the own-key requirement: it
  * inherits its provider keys server-side from the parent's vaulted bundle, so
  * it need not carry any of its own. The server still verifies, at admission,
  * that the parent actually holds a key for the child's provider.
  */
-export declare function enforceCredentialSecretPolicy(secrets: PlatformInlineSecrets, provider: RunProvider, opts?: {
+export declare function enforceCredentialSecretPolicy(secrets: PlatformInlineSecrets, provider: ProviderName, opts?: {
     readonly inheritsFromParent?: boolean;
 }): void;
 export declare function parseSubmission(input: unknown, options?: {
@@ -539,13 +541,13 @@ export declare const DEFAULT_OUTPUT_MODE: OutputMode;
 export declare const STREAMABLE_SHAPES: readonly ["anthropic", "openai_chat"];
 export type StreamableShape = (typeof STREAMABLE_SHAPES)[number];
 /** True when a provider has a streaming producer wired (a {@link STREAMABLE_SHAPES} shape). */
-export declare function isStreamableProvider(provider: RunProvider): boolean;
+export declare function isStreamableProvider(provider: ProviderName): boolean;
 /**
  * Fail-closed streaming gate: `outputMode:'stream'` on a NON-streamable provider
  * throws (a HARD reject — no silent downgrade to buffered). Called by
- * {@link parseRunSubmissionRequest} once mode + provider are both known.
+ * {@link parseSessionSubmissionRequest} once mode + provider are both known.
  */
-export declare function assertStreamableOutputMode(outputMode: OutputMode | undefined, provider: RunProvider): void;
+export declare function assertStreamableOutputMode(outputMode: OutputMode | undefined, provider: ProviderName): void;
 /** Response-format kinds: free-form `text` (default) or provider-native `json_schema`. */
 export declare const RESPONSE_FORMAT_KINDS: readonly ["text", "json_schema"];
 export type ResponseFormatKind = (typeof RESPONSE_FORMAT_KINDS)[number];
@@ -632,14 +634,14 @@ export declare const DEFAULT_BUILTIN_TOOLS: readonly BuiltinToolName[];
  * Fixed name of the single skills meta-tool. Deliberately NOT a member of
  * {@link BUILTIN_TOOL_NAMES} (that closed set is the customer-cherry-pickable
  * toggle surface, pinned equal to `HANDS_TOOLS`) — the skills tool is IMPLIED by
- * a run having ≥1 skill, not chosen, and is injected platform-side. Kept in
+ * a session having ≥1 skill, not chosen, and is injected platform-side. Kept in
  * lockstep with {@link SKILL_RESERVED_NAMES} so it can never be shadowed by a
  * custom tool or skill of the same name.
  */
 export declare const SKILLS_TOOL_NAME = "skills";
 /**
  * The single default `skills` meta-tool (list/load) the platform injects when a
- * run references ≥1 workspace skill. Shared by the platform tool composer and
+ * session references ≥1 workspace skill. Shared by the platform tool composer and
  * kept adjacent to the reserved-name guard so the model-visible contract and the
  * name reservation stay in one place. It replaces the former N per-skill no-arg
  * load-tools with one arg-taking dispatcher.
@@ -678,9 +680,9 @@ export declare const SKILLS_TOOL_DEFINITION: {
  */
 export declare function resolveBuiltinToolNames(includeBuiltinTools: boolean | undefined, toolRefs?: readonly string[]): readonly BuiltinToolName[];
 /**
- * Upper bound on the number of workspace skills a single run may reference.
- * A run's skill list is a discovery surface, not a bulk-mount channel; 64 is
- * generous headroom over any realistic per-run set while capping the meta-tool
+ * Upper bound on the number of workspace skills a single session may reference.
+ * A session's skill list is a discovery surface, not a bulk-mount channel; 64 is
+ * generous headroom over any realistic per-session set while capping the meta-tool
  * `list` payload and the submit-time resolution fan-out.
  */
 export declare const SKILLS_MAX = 64;