@aexhq/sdk 0.40.15 → 0.41.0

package/dist/_contracts/models.js

@@ -4,10 +4,10 @@ import { suggest } from "./suggest.js";
  * 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.
@@ -45,7 +45,7 @@ export const MODEL_PROVIDER_IDS = {
         "doubao-cn": "doubao-seed-1-6-flash-250828"
     }
 };
-export const RUN_MODELS = Object.keys(MODEL_PROVIDER_IDS);
+export const SUPPORTED_MODELS = Object.keys(MODEL_PROVIDER_IDS);
 /**
  * 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.
@@ -109,9 +109,9 @@ const PROVIDERS_BY_MODEL = (() => {
 /**
  * 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 const RUN_MODELS_BY_PROVIDER = (() => {
+export const SUPPORTED_MODELS_BY_PROVIDER = (() => {
     const map = {};
     for (const [model, providers] of Object.entries(MODEL_PROVIDER_IDS)) {
         for (const provider of Object.keys(providers)) {
@@ -130,7 +130,7 @@ export function providersForModel(model) {
 /**
  * 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 function providerForModel(model) {
@@ -162,7 +162,7 @@ export function resolveProviderModelId(model, provider) {
  *     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 function resolveModelProvider(model, provider) {
     const providers = providersForModel(model);
@@ -175,23 +175,23 @@ export function resolveModelProvider(model, provider) {
     }
     const inferred = providers[0];
     if (inferred === undefined) {
-        const hint = suggest(model, RUN_MODELS);
+        const hint = suggest(model, SUPPORTED_MODELS);
         throw new Error(`${JSON.stringify(model)} is not a known model id` +
             (hint ? ` (did you mean ${JSON.stringify(hint)}?)` : "") +
             "; pass provider explicitly to run it");
     }
     return inferred;
 }
-export function isRunModel(input) {
-    return typeof input === "string" && RUN_MODELS.includes(input);
+export function isModelName(input) {
+    return typeof input === "string" && SUPPORTED_MODELS.includes(input);
 }
-export function parseRunModel(input, field = "submission.model") {
-    if (!isRunModel(input)) {
-        throw new Error(`${field} must be one of: ${RUN_MODELS.join(", ")}`);
+export function parseModelName(input, field = "submission.model") {
+    if (!isModelName(input)) {
+        throw new Error(`${field} must be one of: ${SUPPORTED_MODELS.join(", ")}`);
     }
     return input;
 }
-export function assertRunModelMatchesProvider(provider, model, field = "submission.model") {
+export function assertModelNameMatchesProvider(provider, model, field = "submission.model") {
     const providers = providersForModel(model);
     if (!providers.includes(provider)) {
         throw new Error(`${field} ${JSON.stringify(model)} is not supported for provider ${provider}; ` +

package/dist/_contracts/operations.d.ts

@@ -1,8 +1,8 @@
 import type { HttpClient } from "./http.js";
 import type { AexEvent } from "./event-envelope.js";
-import type { RunUnit } from "./run-unit.js";
-import type { AgentsMdRecord, BillingCheckoutRequest, BillingHostedSession, BillingLedgerPage, BillingLedgerQuery, BillingPortalRequest, BillingSummary, ChildRunRef, FileRecord, Output, OutputLink, OutputLinkOptions, OutputFileDownload, OutputFileSelector, OutputFileType, OutputQuery, OutputText, ReadOutputTextOptions, Run, RunListPage, RunListQuery, Session, SessionCreateRequest, SessionEvent, SessionListPage, SessionListQuery, SessionMessageAccepted, SessionMessageRequest, SessionMessagesPage, SessionMessagesQuery, SessionStateChangeAccepted, RunWebhookDelivery, SecretRecord, SecretReveal, SkillRecord, WebhookSigningSecret, WhoAmI } from "./runtime-types.js";
-import type { PlatformRunSubmissionInput } from "./submission.js";
+import type { SessionUnit } from "./session-unit.js";
+import type { AgentsMdRecord, BillingCheckoutRequest, BillingHostedSession, BillingLedgerPage, BillingLedgerQuery, BillingPortalRequest, BillingSummary, ChildSessionRef, FileRecord, SessionFile, SessionFileLink, SessionFileLinkOptions, SessionFileDownload, SessionFileSelector, SessionFileType, SessionFileQuery, SessionFileText, ReadSessionFileTextOptions, SessionRecord, SessionRecordListPage, SessionRecordListQuery, Session, SessionCreateRequest, SessionEvent, SessionListPage, SessionListQuery, SessionMessageAccepted, SessionMessageRequest, SessionMessagesPage, SessionMessagesQuery, SessionStateChangeAccepted, SessionWebhookDelivery, SecretRecord, SecretReveal, SkillRecord, WebhookSigningSecret, WhoAmI } from "./runtime-types.js";
+import type { PlatformSessionSubmissionInput } from "./submission.js";
 /**
  * The single source of truth for SDK<->BFF transport. The SDK class
  * AND the CLI subcommands both call these functions; neither
@@ -14,29 +14,29 @@ import type { PlatformRunSubmissionInput } from "./submission.js";
  * Workspace identity is derived server-side from the API key on
  * every request; callers do not pass `workspaceId`.
  */
-export declare function getRun(http: HttpClient, runId: string): Promise<Run>;
+export declare function getSessionRecord(http: HttpClient, sessionId: string): Promise<SessionRecord>;
 /**
- * Strongly-typed accessor for the full self-contained run unit:
+ * Strongly-typed accessor for the full self-contained session unit:
  * parsed submission inputs, attempts, indexed events (with
- * pagination cursor for large runs), raw-event Storage manifest,
- * outputs, capture failures, and the proxy-call audit.
+ * pagination cursor for large sessions), raw-event Storage manifest,
+ * files, capture failures, and the proxy-call audit.
  *
- * Backed by the same `GET /api/runs/:runId` endpoint that
- * `getRun` calls; this variant just narrows the return type to
- * the documented wire shape. Prefer this for new code; `getRun`
+ * Backed by the same `GET /api/sessions/:sessionId` endpoint that
+ * `getSessionRecord` calls; this variant just narrows the return type to
+ * the documented wire shape. Prefer this for new code; `getSessionRecord`
  * stays for callers that only need the loose record.
  */
-export declare function getRunUnit(http: HttpClient, runId: string): Promise<RunUnit>;
+export declare function getSessionUnit(http: HttpClient, sessionId: string): Promise<SessionUnit>;
 /**
- * List the runs in the token's workspace, most-recent first, one page at a time.
- * Backed by `GET /api/runs` (workspace-token gated; the bare collection path, NOT
- * the run-keyed `GET /api/runs/:runId`). The server clamps `limit` to [1, 100] and
+ * List the sessions in the token's workspace, most-recent first, one page at a time.
+ * Backed by `GET /api/sessions` (workspace-token gated; the bare collection path, NOT
+ * the session-keyed `GET /api/sessions/:sessionId`). The server clamps `limit` to [1, 100] and
  * returns an opaque `nextCursor` for the next page (absent on the last page).
  *
- * Returns public-safe {@link RunSummary} rows only — never the submission snapshot.
- * For a single page; callers wanting every run loop on `nextCursor` themselves.
+ * Returns public-safe {@link SessionRecordSummary} rows only — never the submission snapshot.
+ * For a single page; callers wanting every session loop on `nextCursor` themselves.
  */
-export declare function listRuns(http: HttpClient, query?: RunListQuery): Promise<RunListPage>;
+export declare function listSessionRecords(http: HttpClient, query?: SessionRecordListQuery): Promise<SessionRecordListPage>;
 export interface IdempotencyOptions {
     readonly idempotencyKey?: string;
 }
@@ -46,22 +46,22 @@ export interface SubmitOptions extends IdempotencyOptions {
 /**
  * Resolve a caller-supplied idempotency key to the value that ships on the
  * request. FAIL-FAST: an empty or whitespace-only key THROWS
- * {@link RunConfigValidationError} — a footgun that silently disabled dedup
+ * {@link SessionConfigValidationError} — a footgun that silently disabled dedup
  * (`?? generate()` kept `''`, then a downstream truthy header-drop shipped no
  * `Idempotency-Key`). An absent key generates a fresh one; a real key is
  * returned verbatim. The single choke point every send/create/run entry uses.
  */
 export declare function resolveIdempotencyKey(key?: string): string;
 export declare function createSession(http: HttpClient, request: SessionCreateRequest, options?: IdempotencyOptions): Promise<Session>;
-/** The result of a non-blocking {@link submit}: the run id + the created session. */
+/** The result of a non-blocking {@link submit}: the session id + the created session. */
 export interface SubmitResult {
-    readonly runId: string;
+    readonly sessionId: string;
     readonly session: Session;
 }
 /**
  * Fire-and-forget submit — create the session and post its first turn WITHOUT
- * awaiting the turn to settle (the honest counterpart to await-settle `run()`).
- * Returns the `runId` immediately; observe the run via a `webhook`, the event
+ * awaiting the turn to settle (the honest counterpart to await-settle `start()`).
+ * Returns the `sessionId` immediately; observe the session via a `webhook`, the event
  * stream, or by re-opening the session. Mirrors {@link createSession}'s
  * idempotency handling.
  */
@@ -85,15 +85,15 @@ export declare function approveSession(http: HttpClient, sessionId: string, opti
 export declare function denySession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted>;
 export declare function deleteSession(http: HttpClient, sessionId: string, options?: IdempotencyOptions): Promise<SessionStateChangeAccepted | void>;
 export declare function listSessionEvents(http: HttpClient, sessionId: string): Promise<readonly SessionEvent[]>;
-export declare function listSessionOutputs(http: HttpClient, sessionId: string, query?: OutputQuery): Promise<readonly Output[]>;
+export declare function listSessionFiles(http: HttpClient, sessionId: string, query?: SessionFileQuery): Promise<readonly SessionFile[]>;
 export declare function getSessionCoordinatorTicket(http: HttpClient, sessionId: string): Promise<CoordinatorTicket>;
 /**
- * List a run's events. The read endpoint is PAGED (bounded per response so a
+ * List a session's events. The read endpoint is PAGED (bounded per response so a
  * long run can't return an unbounded body); this follows `nextCursor` across
  * pages and returns the FULL accumulated list, preserving the prior single-call
  * contract for callers (download/*, CLI, streamEvents polling).
  */
-export declare function listRunEvents(http: HttpClient, runId: string): Promise<readonly AexEvent[]>;
+export declare function listSessionRecordEvents(http: HttpClient, sessionId: string): Promise<readonly AexEvent[]>;
 /** A coordinator WS connection grant minted by the hosted API's ticket broker. */
 export interface CoordinatorTicket {
     readonly wsUrl: string;
@@ -102,67 +102,64 @@ export interface CoordinatorTicket {
 }
 /**
  * Mint a short-lived coordinator WS ticket via the workspace-token-gated
- * broker (`/api/runs/:id/events/ticket`). The returned `wsUrl` + `ticket`
+ * broker (`/api/sessions/:id/events/ticket`). The returned `wsUrl` + `ticket`
  * open the live event stream directly against the coordinator. Throws if no
  * coordinator is configured for the deployment (HTTP 503).
  */
-export declare function getCoordinatorTicket(http: HttpClient, runId: string): Promise<CoordinatorTicket>;
-export declare function listOutputs(http: HttpClient, runId: string, query?: OutputQuery): Promise<readonly Output[]>;
-export declare function findOutputs(http: HttpClient, runId: string, query: OutputQuery): Promise<readonly Output[]>;
-export declare function findOutput(http: HttpClient, runId: string, query: OutputQuery): Promise<Output | null>;
-export type OutputLinkSelector = string | OutputFileSelector | OutputQuery;
-export declare function outputLink(http: HttpClient, runId: string, selectorOrQuery: OutputLinkSelector, options?: OutputLinkOptions): Promise<OutputLink>;
-export declare function createOutputLink(http: HttpClient, runId: string, selectorOrQuery: OutputLinkSelector, options?: OutputLinkOptions): Promise<OutputLink>;
-export declare function eventArchiveLink(http: HttpClient, runId: string, options?: OutputLinkOptions): Promise<OutputLink>;
-export declare function resolveOutputFileSelector(outputs: readonly Output[], selector: OutputFileSelector, runId?: string): Output;
-export declare function downloadOutput(http: HttpClient, runId: string, selector: OutputFileSelector, options?: OutputTransferOptions): Promise<OutputFileDownload>;
-/** Byte ceiling for {@link readOutputText} — a hard cap even if a caller asks for more. */
-export declare const READ_OUTPUT_TEXT_MAX_BYTES = 10000000;
-/** Default `maxBytes` for {@link readOutputText} — a chat-sized preview. */
-export declare const READ_OUTPUT_TEXT_DEFAULT_BYTES = 50000;
-/** Default per-attempt timeout while fetching or reading one output body. */
-export declare const OUTPUT_FILE_TRANSFER_DEFAULT_TIMEOUT_MS = 30000;
-/** Idempotent output GETs retry once on a transfer timeout. */
-export declare const OUTPUT_FILE_TRANSFER_ATTEMPTS = 2;
-export interface OutputTransferOptions {
+export declare function getCoordinatorTicket(http: HttpClient, sessionId: string): Promise<CoordinatorTicket>;
+export declare function findSessionFiles(http: HttpClient, sessionId: string, query: SessionFileQuery): Promise<readonly SessionFile[]>;
+export declare function findSessionFile(http: HttpClient, sessionId: string, query: SessionFileQuery): Promise<SessionFile | null>;
+export type SessionFileLinkSelector = string | SessionFileSelector | SessionFileQuery;
+export declare function sessionFileLink(http: HttpClient, sessionId: string, selectorOrQuery: SessionFileLinkSelector, options?: SessionFileLinkOptions): Promise<SessionFileLink>;
+export declare function createSessionFileLink(http: HttpClient, sessionId: string, selectorOrQuery: SessionFileLinkSelector, options?: SessionFileLinkOptions): Promise<SessionFileLink>;
+export declare function eventArchiveLink(http: HttpClient, sessionId: string, options?: SessionFileLinkOptions): Promise<SessionFileLink>;
+export declare function resolveSessionFileSelector(files: readonly SessionFile[], selector: SessionFileSelector, sessionId?: string): SessionFile;
+export declare function downloadSessionFile(http: HttpClient, sessionId: string, selector: SessionFileSelector, options?: SessionFileTransferOptions): Promise<SessionFileDownload>;
+/** Byte ceiling for {@link readSessionFileText} — a hard cap even if a caller asks for more. */
+export declare const READ_SESSION_FILE_TEXT_MAX_BYTES = 10000000;
+/** Default `maxBytes` for {@link readSessionFileText} — a chat-sized preview. */
+export declare const READ_SESSION_FILE_TEXT_DEFAULT_BYTES = 50000;
+/** Default per-attempt timeout while fetching or reading one session file body. */
+export declare const SESSION_FILE_TRANSFER_DEFAULT_TIMEOUT_MS = 30000;
+/** Idempotent file GETs retry once on a transfer timeout. */
+export declare const SESSION_FILE_TRANSFER_ATTEMPTS = 2;
+export interface SessionFileTransferOptions {
     readonly timeoutMs?: number;
 }
 /**
- * Read ONE output file as byte-capped, decoded UTF-8 text. Built for handing a run
+ * Read ONE session file as byte-capped, decoded UTF-8 text. Built for handing a session
  * deliverable to an LLM tool: it streams the file body and STOPS at `maxBytes`, so
  * a 200 MB artifact never fully buffers in memory or context. `truncated` is true
  * when the file is larger than the cap. Optionally `grep` keeps only matching lines.
  *
- * Selector is the same `{ path }` / `{ id }` shape as `downloadOutput`. A path
- * selector lists the run's outputs to resolve the id; an id selector skips that.
+ * Selector is the same `{ path }` / `{ id }` shape as `downloadSessionFile`. A path
+ * selector lists the session's files to resolve the id; an id selector skips that.
  */
-export declare function readOutputText(http: HttpClient, runId: string, selector: OutputFileSelector, options?: ReadOutputTextOptions): Promise<OutputText>;
+export declare function readSessionFileText(http: HttpClient, sessionId: string, selector: SessionFileSelector, options?: ReadSessionFileTextOptions): Promise<SessionFileText>;
 /**
- * List a run's subagent CHILD runs (`GET /runs/:id/children`). Each row is a
- * {@link ChildRunRef} whose `id` resolves through the run facade (getRun /
- * events / outputs) — so every child the platform hands you is resolvable. An
- * empty array means the run spawned no children.
+ * List a session's subagent child sessions (`GET /sessions/:id/children`). Each row is a
+ * {@link ChildSessionRef} whose `id` resolves through the session record facade (getSessionRecord /
+ * events / files) — so every child the platform hands you is resolvable. An
+ * empty array means the session spawned no children.
  */
-export declare function listRunChildren(http: HttpClient, runId: string): Promise<readonly ChildRunRef[]>;
-export declare function cancelRun(http: HttpClient, runId: string): Promise<void>;
-export declare function deleteRun(http: HttpClient, runId: string): Promise<void>;
+export declare function listSessionChildren(http: HttpClient, sessionId: string): Promise<readonly ChildSessionRef[]>;
 /**
- * List a run's webhook delivery attempts (the per-run delivery ledger). Returns
- * the rows surfaced by `GET /api/runs/:id/webhook-deliveries`; an empty array
- * means the run carried no `webhook` or has not reached a terminal state yet.
+ * List a session's webhook delivery attempts (the per-session delivery ledger). Returns
+ * the rows surfaced by `GET /api/sessions/:id/webhook-deliveries`; an empty array
+ * means the session carried no `webhook` or has not reached a terminal state yet.
  */
-export declare function getRunWebhookDeliveries(http: HttpClient, runId: string): Promise<readonly RunWebhookDelivery[]>;
+export declare function getSessionWebhookDeliveries(http: HttpClient, sessionId: string): Promise<readonly SessionWebhookDelivery[]>;
 /**
- * Manually re-trigger a run's webhook delivery: resets the row to `pending` and
+ * Manually re-trigger a session's webhook delivery: resets the row to `pending` and
  * re-sends the frozen payload with the SAME `webhook-id` so the consumer
  * dedupes. Idempotent from the caller's view.
  */
-export declare function redeliverRunWebhook(http: HttpClient, runId: string, deliveryId: string): Promise<void>;
+export declare function redeliverSessionWebhook(http: HttpClient, sessionId: string, deliveryId: string): Promise<void>;
 /**
  * Delete a workspace asset cache entry. Accepts an `asset_<id>` value,
  * `sha256:<hex>`, or a bare 64-hex digest. Workspace is derived server-side
  * from the token; idempotent.
- * Does NOT affect runs that already snapshotted the asset.
+ * Does NOT affect sessions that already snapshotted the asset.
  */
 export declare function deleteWorkspaceAsset(http: HttpClient, hash: string): Promise<void>;
 export declare function whoami(http: HttpClient): Promise<WhoAmI>;
@@ -195,44 +192,44 @@ export declare function getBillingLedger(http: HttpClient, query?: BillingLedger
  * 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 filterSessionFiles(files: readonly SessionFile[], query: SessionFileQuery): readonly SessionFile[];
 /**
- * The single filename-matcher for cross-run / per-session output SEARCH. A
+ * The single filename-matcher for cross-session / per-session file SEARCH. A
  * string is a case-insensitive SUBSTRING match; a RegExp is tested as given (and
  * reset to `lastIndex = 0` so a reused `/g` regex is safe). Sharing this SSoT is
- * what closes the T16 crash class: `searchOutputs` no longer assumes `filename`
+ * what closes the T16 crash class: session-file search no longer assumes `filename`
  * is a string and passes a RegExp into `escapeRegExp(...).replace(...)`.
  */
 export declare function toFilenameMatcher(filename: string | RegExp): (name: string) => boolean;
-export declare function classifyOutput(output: Pick<Output, "filename" | "contentType">): OutputFileType;
-export declare function normalizeOutputLinkExpiresIn(input?: OutputLinkOptions["expiresIn"]): number;
+export declare function classifySessionFile(file: Pick<SessionFile, "filename" | "contentType">): SessionFileType;
+export declare function normalizeSessionFileLinkExpiresIn(input?: SessionFileLinkOptions["expiresIn"]): number;
 /**
- * Download EVERYTHING public about a run as one zip, organised into the three
+ * Download EVERYTHING public about a session as one zip, organised into the three
  * namespace folders:
  *
- *   metadata/run.json     — the run record.
+ *   metadata/session.json     — the session record.
  *   events/events.jsonl   — typed event-channel records.
- *   outputs/<rel>         — the run's deliverables.
- *   manifest.json         — `RunRecordManifestV1`.
+ *   files/<rel>       — the session's captured files.
+ *   manifest.json         — `SessionRecordManifestV1`.
  */
-export declare function download(http: HttpClient, runId: string): Promise<Uint8Array>;
+export declare function download(http: HttpClient, sessionId: string): Promise<Uint8Array>;
 /**
- * Download only the run's deliverables (the `outputs` namespace). Zip
+ * Download only the session's captured files (the `files` namespace). Zip
  * layout: `<rel>` per file plus a `manifest.json`
- * (`{ runId, namespace: "outputs", outputs[], errors[] }`).
+ * (`{ sessionId, namespace: "files", files[], errors[] }`).
  */
-export declare function downloadOutputs(http: HttpClient, runId: string, options?: OutputTransferOptions): Promise<Uint8Array>;
+export declare function downloadSessionFiles(http: HttpClient, sessionId: string, options?: SessionFileTransferOptions): Promise<Uint8Array>;
 /**
  * Download only the event archive (the `events` namespace). Always includes
  * typed `events.jsonl` plus `manifest.json`.
  */
-export declare function downloadEvents(http: HttpClient, runId: string): Promise<Uint8Array>;
+export declare function downloadEvents(http: HttpClient, sessionId: string): Promise<Uint8Array>;
 /**
- * Download only the run record (the `metadata` namespace) as a zip
- * containing `run.json` plus `manifest.json`.
+ * Download only the session record (the `metadata` namespace) as a zip
+ * containing `session.json` plus `manifest.json`.
  */
-export declare function downloadMetadata(http: HttpClient, runId: string): Promise<Uint8Array>;
-export declare function submitRun(http: HttpClient, request: PlatformRunSubmissionInput): Promise<Run>;
+export declare function downloadMetadata(http: HttpClient, sessionId: string): Promise<Uint8Array>;
+export declare function startSessionRecord(http: HttpClient, request: PlatformSessionSubmissionInput): Promise<SessionRecord>;
 export declare function listAgentsMd(http: HttpClient): Promise<readonly AgentsMdRecord[]>;
 export declare function getAgentsMd(http: HttpClient, agentsMdId: string): Promise<AgentsMdRecord>;
 export declare function deleteAgentsMd(http: HttpClient, agentsMdId: string): Promise<void>;
@@ -284,7 +281,7 @@ export interface AssetUploadResult {
 /**
  * Upload bytes to the hosted API's content-addressable asset endpoint.
  * Returns a storage-neutral asset id suitable for `kind:"asset"` refs in a
- * later run submission.
+ * later session submission.
  */
 export declare function uploadWorkspaceAsset(http: HttpClient, input: {
     readonly bytes: Uint8Array;