@aexhq/sdk 0.40.16 → 0.41.1

package/dist/_contracts/event-envelope.js

@@ -7,17 +7,17 @@
  * the shape the coordinator (Phase 2) appends, broadcasts, and archives.
  *
  *   - **CloudEvents-shaped** self-describing envelope: a stable `id`, the
- *     coarse `source`, the AG-UI-aligned `type`, the `subject` (run), a
+ *     coarse `source`, the AG-UI-aligned `type`, the `subject` (session), a
  *     `time`, the `sequence` cursor, and the typed `data`.
  *   - **AG-UI vocabulary** for `type` where it maps; aex-specific events
  *     ride AG-UI's reserved `CUSTOM` carrier under an `aex.*` name, so an
- *     off-the-shelf AG-UI client reads an aex run with no glue.
+ *     off-the-shelf AG-UI client reads an aex start with no glue.
  *   - Two aex extensions: a coarse `source` (filter first by origin) and
  *     an optional human `message` (log / CLI / dashboard rendering).
  *
  * Unified observability spine:
  * the envelope additionally carries four ordering attributes so BOTH the typed
- * event stream and the high-volume hosted-platform log stream ride one per-run
+ * event stream and the high-volume hosted-platform log stream ride one per-session
  * coordinator:
  *   - `channel`   — "event" (the typed AG-UI stream) or "log" (a verbose log
  *                   line). The single axis a consumer splits the unified stream
@@ -59,7 +59,7 @@ export const AEX_EVENT_MAP_VERSION = 1;
  */
 export const AEX_EVENT_SOURCES = ["agent", "api", "runtime", "mcp", "aex", "workflow", "host"];
 /**
- * The channel a record rides on the unified per-run stream:
+ * The channel a record rides on the unified per-session stream:
  *   - `event` — the typed, low-volume, fully-replayed AG-UI event stream.
  *   - `log`   — a high-volume verbose log line (level + message + fields). The
  *               coordinator prunes flushed log rows after evidence archival
@@ -80,16 +80,16 @@ export const AEX_LOG_LEVELS = ["info", "warn", "error"];
  * `CUSTOM`, AG-UI's reserved carrier for aex-native events.
  */
 export const AEX_EVENT_TYPES = [
-    "RUN_STARTED",
-    "RUN_FINISHED",
-    "RUN_ERROR",
+    "TURN_STARTED",
+    "TURN_FINISHED",
+    "TURN_ERROR",
     "TEXT_MESSAGE_CONTENT",
     "TOOL_CALL_START",
     "TOOL_CALL_RESULT",
     "CUSTOM",
     // The carrier type for a `channel: "log"` record. Kept out of the AG-UI
-    // typed-event vocabulary on purpose: a `LOG` is never a run-lifecycle signal,
-    // so terminal detection (RUN_FINISHED/RUN_ERROR) is unaffected and an
+    // typed-event vocabulary on purpose: a `LOG` is never a session-lifecycle signal,
+    // so terminal detection (TURN_FINISHED/TURN_ERROR) is unaffected and an
     // off-the-shelf AG-UI client filters logs out by `channel`.
     "LOG"
 ];
@@ -103,10 +103,10 @@ export function runnerEventToAexEvent(evt, ctx) {
     const projection = project(evt);
     return {
         specversion: AEX_EVENT_SPECVERSION,
-        id: `${ctx.runId}:${evt.seq}`,
+        id: `${ctx.sessionId}:${evt.seq}`,
         source: projection.source,
         type: projection.type,
-        subject: ctx.runId,
+        subject: ctx.sessionId,
         time: new Date(ctx.baseMs + evt.tMs).toISOString(),
         sequence: evt.seq,
         ...(projection.message !== undefined ? { message: projection.message } : {}),
@@ -117,7 +117,7 @@ function project(evt) {
     const data = evt.data;
     switch (evt.kind) {
         case "runtime_started":
-            return { type: "RUN_STARTED", source: "runtime", message: "run started", data: { ...data } };
+            return { type: "TURN_STARTED", source: "runtime", message: "turn started", data: { ...data } };
         case "assistant_text": {
             const text = str(data.text);
             return {
@@ -154,11 +154,11 @@ function project(evt) {
             const reason = str(data.reason);
             return {
                 // The event's own reason types it (error vs finished); the
-                // authoritative run *status* is still owned by the orchestrator and
+                // authoritative session *status* is still owned by the orchestrator and
                 // is never re-derived from this event.
-                type: reason === "error" ? "RUN_ERROR" : "RUN_FINISHED",
+                type: reason === "error" ? "TURN_ERROR" : "TURN_FINISHED",
                 source: "runtime",
-                message: reason ? `run ${reason}` : "run finished",
+                message: reason ? `turn ${reason}` : "session finished",
                 data: { ...data }
             };
         }
@@ -199,30 +199,30 @@ function custom(name, source, value, message) {
 }
 // --- Honest guards over the emitted vocabulary --------------------------------
 // These match the vocabulary a consumer of the unified stream actually receives.
-export function isRunStarted(e) {
-    return e.type === "RUN_STARTED";
+export function isTurnStarted(e) {
+    return e.type === "TURN_STARTED";
 }
-export function isRunFinished(e) {
-    return e.type === "RUN_FINISHED";
+export function isTurnFinished(e) {
+    return e.type === "TURN_FINISHED";
 }
-export function isRunError(e) {
-    return e.type === "RUN_ERROR";
+export function isTurnError(e) {
+    return e.type === "TURN_ERROR";
 }
 /** A terminal event of either flavour (finished or error). */
-export function isRunTerminal(e) {
-    return e.type === "RUN_FINISHED" || e.type === "RUN_ERROR";
+export function isTurnTerminal(e) {
+    return e.type === "TURN_FINISHED" || e.type === "TURN_ERROR";
 }
 /**
- * The CUSTOM `data.name`s the MANAGED runtime emits as a run/turn's SETTLED
- * terminal. A managed one-shot run PARKS (`session_parked.v1` → one of these)
- * rather than writing a `session_finished` → RUN_FINISHED, so these — not just
- * the AG-UI RUN_FINISHED/RUN_ERROR — are what actually end a managed run's event
+ * The CUSTOM `data.name`s the MANAGED runtime emits as a session/turn's SETTLED
+ * terminal. A managed one-shot session PARKS (`session_parked.v1` → one of these)
+ * rather than writing a `session_finished` → TURN_FINISHED, so these — not just
+ * the AG-UI TURN_FINISHED/TURN_ERROR — are what actually end a managed session's event
  * stream. Clean-cut (WS1): the bare `aex.session.error` park is retired in favour
  * of the terminal OUTCOME vocabulary — a failed turn is `failed`, a wall-clock
  * kill `timed_out`, a cancel `cancelled`, a clean finish `succeeded`; `idle`/
  * `suspended` remain the resumable parks. Held `awaiting_approval` is NOT here:
  * it ends the TURN stream (see `isSessionTurnTerminalEvent` in the SDK) but the
- * RUN is not settled. Kept byte-in-sync with `@aexhq/shared` `AEX_SESSION_PARKED_NAMES`
+ * session is not settled. Kept byte-in-sync with `@aexhq/shared` `AEX_SESSION_PARKED_NAMES`
  * and the platform journal projection (`journal-project.ts` session_parked.v1).
  */
 export const AEX_SESSION_PARKED_NAMES = [
@@ -237,8 +237,8 @@ export const AEX_SESSION_PARKED_NAMES = [
  * True for a managed-runtime session-park terminal (a resumable idle/suspended
  * park OR a terminal succeeded/failed/timed_out/cancelled outcome). 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. (Held
- * `awaiting_approval` is deliberately excluded — the run is paused, not settled.)
+ * should stop here exactly as it would on TURN_FINISHED/TURN_ERROR. (Held
+ * `awaiting_approval` is deliberately excluded — the session is paused, not settled.)
  */
 export function isSessionParked(e) {
     const name = customName(e);
@@ -262,27 +262,27 @@ export function customName(e) {
 }
 /**
  * The `data.name` of the settle-consistency barrier event. The coordinator
- * broadcasts ONE such CUSTOM event as a run's LAST stream event, after the
- * Postgres mirror lands — so observing it ⇒ a subsequent `getRun` is terminal
- * and `listOutputs` is complete. It is intentionally a CUSTOM event (not a
- * typed RUN_* event): off-the-shelf AG-UI clients ignore it, while
- * `streamEnvelopes(runId, { settleConsistent: true })` ends the iterator on it.
- * Unlike RUN_FINISHED (the AG-UI render-complete UX signal, emitted by the
+ * broadcasts ONE such CUSTOM event as a session's LAST stream event, after the
+ * Postgres mirror lands — so observing it ⇒ a subsequent `getSessionRecord` is terminal
+ * and `listSessionFiles` is complete. It is intentionally a CUSTOM event (not a
+ * typed SESSION_* event): off-the-shelf AG-UI clients ignore it, while
+ * `streamEnvelopes(sessionId, { settleConsistent: true })` ends the iterator on it.
+ * Unlike TURN_FINISHED (the AG-UI render-complete UX signal, emitted by the
  * runner BEFORE the platform learns the outcome), this is settle-gated. The
  * platform mirrors this constant in `@aexhq/shared`.
  */
-export const AEX_RUN_SETTLED_NAME = "aex.run.settled";
+export const AEX_SESSION_SETTLED_NAME = "aex.session.settled";
 /**
  * True for the settle-consistency barrier event (post-mirror, read-consistent).
  * Also true for a managed-runtime session-park terminal: the current plane emits
- * an `aex.run.settled` barrier after settle, but a stream may still observe the
+ * an `aex.session.settled` barrier after settle, but a stream may still observe the
  * park as the terminal event when no later barrier is delivered.
  */
-export function isRunSettled(e) {
-    return customName(e) === AEX_RUN_SETTLED_NAME || isSessionParked(e);
+export function isSessionSettled(e) {
+    return customName(e) === AEX_SESSION_SETTLED_NAME || isSessionParked(e);
 }
 /**
- * The CUSTOM `data.name` of the HITL write-gate park: the run has reached the
+ * The CUSTOM `data.name` of the HITL write-gate park: the session has reached the
  * `awaiting_approval` state before a gated action and is holding for an
  * `approve()`/`deny()`. Structural (independent of model prose).
  */
@@ -337,23 +337,23 @@ export function exceedsRowBudget(e, max = MAX_SQLITE_ROW_BYTES) {
 }
 /**
  * Project an aex envelope to a strict AG-UI event so an off-the-shelf
- * AG-UI client can consume an aex run with no glue. This is the
+ * AG-UI client can consume an aex start with no glue. This is the
  * client-side projection the SDK exposes.
  */
 export function toAGUI(e) {
     const timestamp = Date.parse(e.time);
     const d = e.data;
     switch (e.type) {
-        case "RUN_STARTED":
-            return { type: "RUN_STARTED", timestamp, threadId: e.subject, runId: e.subject };
-        case "RUN_FINISHED":
-            return { type: "RUN_FINISHED", timestamp, threadId: e.subject, runId: e.subject };
-        case "RUN_ERROR": {
+        case "TURN_STARTED":
+            return { type: "TURN_STARTED", timestamp, threadId: e.subject, sessionId: e.subject };
+        case "TURN_FINISHED":
+            return { type: "TURN_FINISHED", timestamp, threadId: e.subject, sessionId: e.subject };
+        case "TURN_ERROR": {
             const code = str(d.failureClass);
             return {
-                type: "RUN_ERROR",
+                type: "TURN_ERROR",
                 timestamp,
-                message: str(d.failureMessage) || e.message || "run error",
+                message: str(d.failureMessage) || e.message || "turn error",
                 ...(code ? { code } : {})
             };
         }

package/dist/_contracts/event-stream-client.d.ts

@@ -12,13 +12,13 @@
  * A silently half-open socket (no close/error, no frames) is the dangerous
  * case: the read loop would block forever and MISS a terminal that was already
  * persisted server-side. So the client sends a post-open replay trigger plus a
- * tiny keep-alive ping the coordinator answers with a matching pong, and runs an idle
+ * tiny keep-alive ping the coordinator answers with a matching pong, and uses an idle
  * watchdog: if no frame arrives within {@link CoordinatorStreamOptions.idleTimeoutMs},
  * the socket is treated as dead and reconnected — resume-from-cursor then
  * replays the terminal.
  *
  * Filtering and projection are the client's concern (the wire carries the
- * whole run): compose {@link filterStream} with the envelope guards, and
+ * whole session): compose {@link filterStream} with the envelope guards, and
  * {@link mapStream} with {@link toAGUI}, on top of this stream.
  *
  * The WebSocket is injectable so the SDK/CLI use the global `WebSocket`
@@ -36,7 +36,7 @@ export interface WebSocketLike {
 }
 export type WebSocketFactory = (url: string) => WebSocketLike;
 export interface CoordinatorStreamOptions {
-    /** Base subscribe URL, e.g. `wss://coordinator/runs/<id>/subscribe`. */
+    /** Base subscribe URL, e.g. `wss://coordinator/sessions/<id>/subscribe`. */
     readonly wsUrl: string;
     /** Starting cursor: events with `sequence >= from` are delivered. Default 0 (from start). */
     readonly from?: number;
@@ -51,10 +51,10 @@ export interface CoordinatorStreamOptions {
     readonly reconnectDelayMs?: number;
     /**
      * Predicate that decides which event ENDS the stream. Default: the AG-UI
-     * terminal events (RUN_FINISHED / RUN_ERROR) — the render-complete UX signal.
-     * Pass {@link isRunSettled} for a settle-consistent stream that keeps reading
-     * PAST RUN_FINISHED until the post-mirror barrier, so the iterator only ends
-     * once a subsequent `getRun` is guaranteed terminal.
+     * terminal events (TURN_FINISHED / TURN_ERROR) — the render-complete UX signal.
+     * Pass {@link isSessionSettled} for a settle-consistent stream that keeps reading
+     * PAST TURN_FINISHED until the post-mirror barrier, so the iterator only ends
+     * once a subsequent `getSessionRecord` is guaranteed terminal.
      */
     readonly isTerminal?: (event: AexEvent) => boolean;
     /**
@@ -66,9 +66,9 @@ export interface CoordinatorStreamOptions {
     /**
      * Client keep-alive ping cadence. The client sends {@link COORDINATOR_PING},
      * which the coordinator answers with a matching pong, so
-     * a legitimately quiet run keeps the socket measurably alive and does not trip
+     * a legitimately quiet session keeps the socket measurably alive and does not trip
      * the watchdog. Default 15s. Set 0 to disable (then only real events reset the
-     * watchdog → quiet runs may reconnect).
+     * watchdog → quiet sessions may reconnect).
      */
     readonly pingIntervalMs?: number;
     /**

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

@@ -12,13 +12,13 @@
  * A silently half-open socket (no close/error, no frames) is the dangerous
  * case: the read loop would block forever and MISS a terminal that was already
  * persisted server-side. So the client sends a post-open replay trigger plus a
- * tiny keep-alive ping the coordinator answers with a matching pong, and runs an idle
+ * tiny keep-alive ping the coordinator answers with a matching pong, and uses an idle
  * watchdog: if no frame arrives within {@link CoordinatorStreamOptions.idleTimeoutMs},
  * the socket is treated as dead and reconnected — resume-from-cursor then
  * replays the terminal.
  *
  * Filtering and projection are the client's concern (the wire carries the
- * whole run): compose {@link filterStream} with the envelope guards, and
+ * whole session): compose {@link filterStream} with the envelope guards, and
  * {@link mapStream} with {@link toAGUI}, on top of this stream.
  *
  * The WebSocket is injectable so the SDK/CLI use the global `WebSocket`
@@ -27,10 +27,10 @@
 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
+// .suspended). A managed one-shot session parks instead of emitting TURN_FINISHED, so
+// WITHOUT the session-park arm a `streamEnvelopes()` over a finished managed session
 // never sees a terminal and hangs on the idle watchdog forever.
-const isTerminalType = (e) => e.type === "RUN_FINISHED" || e.type === "RUN_ERROR" || isSessionParked(e);
+const isTerminalType = (e) => e.type === "TURN_FINISHED" || e.type === "TURN_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/event-view.d.ts

@@ -68,14 +68,14 @@ export interface ToolCallResultEventView extends AexEventView {
  * unchanged. Construct one with {@link asAexEventView}.
  */
 export declare class AexEventView {
-    /** True for the run-start lifecycle event. */
-    isRunStarted(): boolean;
+    /** True for the turn-start lifecycle event. */
+    isTurnStarted(): boolean;
     /** True for the terminal success event. */
-    isRunFinished(): boolean;
+    isTurnFinished(): boolean;
     /** True for the terminal error event. */
-    isRunError(): boolean;
+    isTurnError(): boolean;
     /** True for a terminal event of either flavour (finished or error). */
-    isRunTerminal(): boolean;
+    isTurnTerminal(): boolean;
     /** True for an assistant text event; narrows `data.text` to `string`. */
     isTextMessage(): this is TextMessageEventView;
     /** True for a tool-call start event; narrows `data` to `{ id, name }`. */
@@ -106,7 +106,7 @@ export declare class AexEventView {
      * session-park terminal (idle/error/suspended) — the one check that reliably
      * means "this stream is done and the record is authoritative".
      */
-    isRunSettled(): boolean;
+    isSessionSettled(): boolean;
     /** True when the record originates from the given coarse source. */
     isFromSource(source: AexEventSource): boolean;
 }

package/dist/_contracts/event-view.js

@@ -20,7 +20,7 @@
  * the prototype (they never serialize), and an `AexEventView` is still a
  * structural {@link AexEvent}.
  */
-import { channelOf, isRunSettled, isAwaitingApproval, isResultDecoded, isResultRefused } from "./event-envelope.js";
+import { channelOf, isSessionSettled, isAwaitingApproval, isResultDecoded, isResultRefused } from "./event-envelope.js";
 /**
  * A coordinator {@link AexEvent} with the standardized-event-type guards carried
  * as METHODS (`event.isTextMessage()`, `event.isToolCallStart()`, …). Extends
@@ -28,21 +28,21 @@ import { channelOf, isRunSettled, isAwaitingApproval, isResultDecoded, isResultR
  * unchanged. Construct one with {@link asAexEventView}.
  */
 export class AexEventView {
-    /** True for the run-start lifecycle event. */
-    isRunStarted() {
-        return this.type === "RUN_STARTED";
+    /** True for the turn-start lifecycle event. */
+    isTurnStarted() {
+        return this.type === "TURN_STARTED";
     }
     /** True for the terminal success event. */
-    isRunFinished() {
-        return this.type === "RUN_FINISHED";
+    isTurnFinished() {
+        return this.type === "TURN_FINISHED";
     }
     /** True for the terminal error event. */
-    isRunError() {
-        return this.type === "RUN_ERROR";
+    isTurnError() {
+        return this.type === "TURN_ERROR";
     }
     /** True for a terminal event of either flavour (finished or error). */
-    isRunTerminal() {
-        return this.type === "RUN_FINISHED" || this.type === "RUN_ERROR";
+    isTurnTerminal() {
+        return this.type === "TURN_FINISHED" || this.type === "TURN_ERROR";
     }
     /** True for an assistant text event; narrows `data.text` to `string`. */
     isTextMessage() {
@@ -95,8 +95,8 @@ export class AexEventView {
      * session-park terminal (idle/error/suspended) — the one check that reliably
      * means "this stream is done and the record is authoritative".
      */
-    isRunSettled() {
-        return isRunSettled(this);
+    isSessionSettled() {
+        return isSessionSettled(this);
     }
     /** True when the record originates from the given coarse source. */
     isFromSource(source) {

package/dist/_contracts/http.js

@@ -200,7 +200,7 @@ function transientReadErrorCode(err) {
 function toNetworkError(method, url, err, attempts, elapsedMs) {
     if (err instanceof AexError)
         return err;
-    // `DOMException` is not an `Error` subclass on every runtime, so match aborts by name.
+    // `DOMException` is not an `Error` subclass on every sessiontime, so match aborts by name.
     if (err?.name === "AbortError")
         return err;
     return new AexNetworkError({

package/dist/_contracts/index.d.ts

@@ -1,32 +1,32 @@
 export * from "./provider-support.js";
 export * from "./models.js";
 export * from "./status.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, RESPONSE_FORMAT_KINDS, RUN_PROVIDERS, SECRETS_KEY, SECRET_ENV_NAME_PATTERN, SECRET_HANDLE_PATTERN, SKILLS_MAX, SKILLS_TOOL_DEFINITION, SKILLS_TOOL_NAME, STREAMABLE_SHAPES, assertStreamableOutputMode, crossValidateSecretEnvAndValues, isStreamableProvider, packageInstallString, parseApprovalGate, parseInlineSecrets, parseResponseFormat, parseRunLimits, parseRunProvider, parseRunSubmissionRequest, parseRunWebhook, parseSkills, parseSubmission, resolveBuiltinToolNames } from "./submission.js";
-export type { ApprovalGate, BuiltinToolName, JsonPrimitive, JsonValue, OutputMode, ParseRunSubmissionOptions, PlatformEnvironment, PlatformEnvironmentInput, PlatformInlineSecrets, PlatformInjectionConfig, PlatformMcpServerSecret, PlatformNetworking, PlatformOutputCaptureConfig, PlatformPackage, PlatformPackageEcosystem, PlatformPackageInput, PlatformRunSubmissionInput, PlatformRunSubmissionRequest, PlatformSecretEnvEntry, PlatformSubmission, ResponseFormat, ResponseFormatKind, RunLimits, RunMachine, RunProvider, RunWebhookSpec, StreamableShape } from "./submission.js";
+export { AEX_RESERVED_ENV_PREFIX, BUILTIN_TOOL_NAMES, BuiltinTools, DEFAULT_BUILTIN_TOOLS, DEFAULT_OUTPUT_MODE, DEFAULT_PROVIDER, ENV_VARS_MAX_ENTRIES, ENV_VARS_MAX_TOTAL_BYTES, ENV_VARS_MAX_VALUE_BYTES, OUTPUT_MODES, PLATFORM_PACKAGE_ECOSYSTEMS, Providers, RESPONSE_FORMAT_KINDS, PROVIDERS, SECRETS_KEY, SECRET_ENV_NAME_PATTERN, SECRET_HANDLE_PATTERN, SKILLS_MAX, SKILLS_TOOL_DEFINITION, SKILLS_TOOL_NAME, STREAMABLE_SHAPES, assertStreamableOutputMode, crossValidateSecretEnvAndValues, isStreamableProvider, packageInstallString, parseApprovalGate, parseInlineSecrets, parseResponseFormat, parseSessionLimits, parseProviderName, parseSessionSubmissionRequest, parseSessionWebhook, parseSkills, parseSubmission, resolveBuiltinToolNames } from "./submission.js";
+export type { ApprovalGate, BuiltinToolName, JsonPrimitive, JsonValue, OutputMode, ParseSessionSubmissionOptions, PlatformEnvironment, PlatformEnvironmentInput, PlatformInlineSecrets, PlatformInjectionConfig, PlatformMcpServerSecret, PlatformNetworking, PlatformFileCaptureConfig, PlatformPackage, PlatformPackageEcosystem, PlatformPackageInput, PlatformSessionSubmissionInput, PlatformSessionSubmissionRequest, PlatformSecretEnvEntry, PlatformSubmission, ResponseFormat, ResponseFormatKind, SessionLimits, SessionMachine, ProviderName, SessionWebhookSpec, StreamableShape } from "./submission.js";
 export * from "./runtime-sizes.js";
 export * from "./runner-event.js";
 export * from "./event-envelope.js";
 export * from "./event-view.js";
 export * from "./connection-ticket.js";
 export * from "./event-stream-client.js";
-export * from "./run-unit.js";
-export type { AssistantTextEntry, RunTrace, ToolCallResult, ToolCallTrace } from "./run-trace.js";
+export * from "./session-unit.js";
+export type { AssistantTextEntry, TurnTrace, ToolCallResult, ToolCallTrace } from "./turn-trace.js";
 export * from "./runtime-manifest.js";
 export * from "./runtime-security-profile.js";
-export * from "./run-record.js";
-export * from "./run-cost.js";
-export * from "./run-custody.js";
-export * from "./run-retention.js";
+export * from "./session-record.js";
+export * from "./session-cost.js";
+export * from "./session-custody.js";
+export * from "./session-retention.js";
 export * from "./side-effect-audit.js";
 export * from "./stable.js";
 export * from "./sdk-secrets.js";
 export * from "./sdk-errors.js";
-export * from "./run-config.js";
+export * from "./session-config.js";
 export * from "./bundle-manifest.js";
 export * from "./runtime-types.js";
 export * from "./webhook-verify.js";
 export * from "./http.js";
-export * from "./run-artifacts.js";
+export * from "./session-artifacts.js";
 export * as operations from "./operations.js";
 export * from "./sse.js";
 export * from "./error-codes.js";

package/dist/_contracts/index.js

@@ -1,35 +1,35 @@
 export * from "./provider-support.js";
 export * from "./models.js";
 export * from "./status.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, RESPONSE_FORMAT_KINDS, RUN_PROVIDERS, SECRETS_KEY, SECRET_ENV_NAME_PATTERN, SECRET_HANDLE_PATTERN, SKILLS_MAX, SKILLS_TOOL_DEFINITION, SKILLS_TOOL_NAME, STREAMABLE_SHAPES, assertStreamableOutputMode, crossValidateSecretEnvAndValues, isStreamableProvider, packageInstallString, parseApprovalGate, parseInlineSecrets, parseResponseFormat, parseRunLimits, parseRunProvider, parseRunSubmissionRequest, parseRunWebhook, parseSkills, parseSubmission, resolveBuiltinToolNames } from "./submission.js";
+export { AEX_RESERVED_ENV_PREFIX, BUILTIN_TOOL_NAMES, BuiltinTools, DEFAULT_BUILTIN_TOOLS, DEFAULT_OUTPUT_MODE, DEFAULT_PROVIDER, ENV_VARS_MAX_ENTRIES, ENV_VARS_MAX_TOTAL_BYTES, ENV_VARS_MAX_VALUE_BYTES, OUTPUT_MODES, PLATFORM_PACKAGE_ECOSYSTEMS, Providers, RESPONSE_FORMAT_KINDS, PROVIDERS, SECRETS_KEY, SECRET_ENV_NAME_PATTERN, SECRET_HANDLE_PATTERN, SKILLS_MAX, SKILLS_TOOL_DEFINITION, SKILLS_TOOL_NAME, STREAMABLE_SHAPES, assertStreamableOutputMode, crossValidateSecretEnvAndValues, isStreamableProvider, packageInstallString, parseApprovalGate, parseInlineSecrets, parseResponseFormat, parseSessionLimits, parseProviderName, parseSessionSubmissionRequest, parseSessionWebhook, parseSkills, parseSubmission, resolveBuiltinToolNames } from "./submission.js";
 export * from "./runtime-sizes.js";
 export * from "./runner-event.js";
 export * from "./event-envelope.js";
 export * from "./event-view.js";
 export * from "./connection-ticket.js";
 export * from "./event-stream-client.js";
-export * from "./run-unit.js";
+export * from "./session-unit.js";
 export * from "./runtime-manifest.js";
 export * from "./runtime-security-profile.js";
-export * from "./run-record.js";
-export * from "./run-cost.js";
-export * from "./run-custody.js";
-export * from "./run-retention.js";
+export * from "./session-record.js";
+export * from "./session-cost.js";
+export * from "./session-custody.js";
+export * from "./session-retention.js";
 export * from "./side-effect-audit.js";
 export * from "./stable.js";
 export * from "./sdk-secrets.js";
 export * from "./sdk-errors.js";
-export * from "./run-config.js";
+export * from "./session-config.js";
 export * from "./bundle-manifest.js";
 export * from "./runtime-types.js";
 export * from "./webhook-verify.js";
 export * from "./http.js";
-export * from "./run-artifacts.js";
+export * from "./session-artifacts.js";
 export * as operations from "./operations.js";
 export * from "./sse.js";
 // The single canonical event surface: the `is*` guards live on `AexEvent`
 // (`event-envelope.js`) and as METHODS on `AexEventView` (`event-view.js`).
-// The loose `RunEvent` type and its free-function guard mirror (`event-guards.js`)
+// The loose `TurnEvent` type and its free-function guard mirror (`event-guards.js`)
 // are RETIRED — there is exactly one event shape.
 export * from "./error-codes.js";
 export * from "./error-factory.js";

package/dist/_contracts/models.d.ts

@@ -1,13 +1,13 @@
-import type { RunProvider } from "./submission.js";
+import type { ProviderName } from "./submission.js";
 /**
  * Source of truth for the closed model set: each canonical model id maps to the
  * upstream providers that can serve it and the **provider-native** model string
  * each one expects.
  *
- * `Models.*` / `RUN_MODELS` are aex's own **canonical, provider-neutral**
+ * `Models.*` / `SUPPORTED_MODELS` are aex's own **canonical, provider-neutral**
  * identifiers — they are NOT the strings sent to a provider. The platform
  * translates a `(canonical model, provider)` pair to the native id via
- * {@link resolveProviderModelId} when it builds the run's session manifest. The
+ * {@link resolveProviderModelId} when it builds the session's session manifest. The
  * same canonical model can therefore be served by more than one provider (e.g.
  * `gpt-4o-mini` via `openai` *or* `openrouter`), with a different native string
  * per provider.
@@ -69,11 +69,11 @@ export declare const MODEL_PROVIDER_IDS: {
     };
 };
 /**
- * Closed set of canonical model ids accepted by the public run-submission
+ * Closed set of canonical model ids accepted by the public session-submission
  * schema. Derived from {@link MODEL_PROVIDER_IDS} so the two never drift.
  */
-export type RunModel = keyof typeof MODEL_PROVIDER_IDS;
-export declare const RUN_MODELS: readonly RunModel[];
+export type ModelName = keyof typeof MODEL_PROVIDER_IDS;
+export declare const SUPPORTED_MODELS: readonly ModelName[];
 /**
  * Symbol-style accessors for the closed model set. Prefer these over raw
  * strings so an invalid token is a compile error, not a runtime 400 — e.g.
@@ -126,27 +126,27 @@ export declare const Models: {
 /**
  * Provider → canonical models that provider can serve. Derived from
  * {@link MODEL_PROVIDER_IDS}; every provider currently serves at least one
- * model, so all {@link RunProvider} keys are present.
+ * model, so all {@link ProviderName} keys are present.
  */
-export declare const RUN_MODELS_BY_PROVIDER: Readonly<Record<RunProvider, readonly RunModel[]>>;
+export declare const SUPPORTED_MODELS_BY_PROVIDER: Readonly<Record<ProviderName, readonly ModelName[]>>;
 /**
  * All upstream providers that can serve a model id, in declaration order.
  * Returns `[]` for an unknown model.
  */
-export declare function providersForModel(model: string): readonly RunProvider[];
+export declare function providersForModel(model: string): readonly ProviderName[];
 /**
  * The default upstream provider for a model id — the first provider declared
  * for it in {@link MODEL_PROVIDER_IDS}. Returns `undefined` when the input is
- * not a known {@link RunModel} (so the SDK can fall back to the default and let
+ * not a known {@link ModelName} (so the SDK can fall back to the default and let
  * the server reject the model).
  */
-export declare function providerForModel(model: string): RunProvider | undefined;
+export declare function providerForModel(model: string): ProviderName | undefined;
 /**
  * Translate a canonical model id + provider into the provider-native model
  * string the upstream API expects (e.g. `("gpt-4o-mini", "openrouter")` →
  * `"openai/gpt-4o-mini"`). Throws when the provider does not serve the model.
  */
-export declare function resolveProviderModelId(model: string, provider: RunProvider): string;
+export declare function resolveProviderModelId(model: string, provider: ProviderName): string;
 /**
  * The single model→provider resolver shared by the SDK and the CLI, wrapping
  * {@link providersForModel} with the forward-compat unknown-model allowance:
@@ -159,9 +159,9 @@ export declare function resolveProviderModelId(model: string, provider: RunProvi
  *     declared). An UNKNOWN model with no provider throws a `did you mean?`
  *     hint — you must name a provider to run a model this client doesn't know.
  *
- * Returns the resolved {@link RunProvider}.
+ * Returns the resolved {@link ProviderName}.
  */
-export declare function resolveModelProvider(model: string, provider?: RunProvider): RunProvider;
-export declare function isRunModel(input: unknown): input is RunModel;
-export declare function parseRunModel(input: unknown, field?: string): RunModel;
-export declare function assertRunModelMatchesProvider(provider: RunProvider, model: RunModel, field?: string): void;
+export declare function resolveModelProvider(model: string, provider?: ProviderName): ProviderName;
+export declare function isModelName(input: unknown): input is ModelName;
+export declare function parseModelName(input: unknown, field?: string): ModelName;
+export declare function assertModelNameMatchesProvider(provider: ProviderName, model: ModelName, field?: string): void;