@loomcycle/client 1.105.0 → 1.107.0

package/dist/errors.d.ts

@@ -20,9 +20,16 @@
 export declare class LoomcycleError extends Error {
     readonly status?: number;
     readonly bodyText?: string;
+    /** The machine-readable `code` of a JSON error body (`model_not_allowed`,
+     *  `token_limit_exceeded`, `per_user_quota_exhausted`, …), on whichever
+     *  class the status maps to. Undefined when the body is not JSON or carries
+     *  no string `code`. Read from the whole body, so it survives where
+     *  `bodyText` is cut at 1 KiB. Branch on this, not on the message. */
+    readonly code?: string;
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 /** Base class for every HTTP 404 the client surfaces. Lets callers
@@ -34,36 +41,91 @@ export declare class NotFoundError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class AgentNotFoundError extends NotFoundError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class SessionNotFoundError extends NotFoundError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class SessionBusyError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class AgentIDInUseError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
+/** Every HTTP 429 that is not a per-user quota. A plain BackpressureError is
+ *  the transient case (the server is busy; back off and retry). It has one
+ *  subclass that is NOT transient, TokenLimitExceededError — check for that
+ *  first when deciding whether to retry. */
 export declare class BackpressureError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
+    });
+}
+/**
+ * TokenLimitExceededError signals that the caller is at a hard token budget:
+ * HTTP 429 with body code `token_limit_exceeded`, from run creation and from
+ * `decide()`.
+ *
+ * Do not retry it the way you retry backpressure. The budget is a calendar
+ * month's tokens for an operator, tenant or user; the same call is refused
+ * until an operator raises the budget or the window rolls over.
+ *
+ * It extends BackpressureError only so that code written before this class
+ * existed, which caught this refusal with `instanceof BackpressureError`,
+ * keeps catching it. Test for this class BEFORE BackpressureError:
+ *
+ *   if (e instanceof TokenLimitExceededError) {
+ *     // not retryable now: report e.scope / e.used / e.limit
+ *   } else if (e instanceof BackpressureError) {
+ *     // transient: back off and retry
+ *   }
+ *
+ * The fields come from the response body and are null when the server did
+ * not send them.
+ */
+export declare class TokenLimitExceededError extends BackpressureError {
+    /** Whose budget was hit: "operator", "tenant" or "user". */
+    readonly scope: string | null;
+    /** The id of that scope: the tenant id or the user subject. Null for the
+     *  operator-wide budget, and where the server withholds it. */
+    readonly scopeId: string | null;
+    /** Tokens the scope has used in the current window. */
+    readonly used: number | null;
+    /** The hard ceiling that was reached, in tokens. */
+    readonly limit: number | null;
+    /** The budget window, e.g. "month" (a calendar month, UTC). */
+    readonly window: string | null;
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+        code?: string;
+        scope?: string;
+        scopeId?: string;
+        used?: number;
+        limit?: number;
+        window?: string;
     });
 }
 /**
@@ -111,6 +173,7 @@ export declare class PerUserQuotaExhaustedError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
         userId?: string;
         cap?: number;
         retryAfterMs?: number;
@@ -120,18 +183,21 @@ export declare class AuthError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class UnavailableError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class InvalidArgumentError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 /** Subclasses UnavailableError for back-compat: code that broadly
@@ -141,36 +207,76 @@ export declare class PauseNotConfiguredError extends UnavailableError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class AlreadyPausingError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class NotPausedError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 export declare class SnapshotNotFoundError extends NotFoundError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
+/** A snapshot envelope over the size cap (HTTP 413, body code
+ *  `snapshot_too_large`).
+ *
+ *  For compatibility it is ALSO the base class of every other 413: until
+ *  RequestTooLargeError and PromptTooLargeError existed, the client raised
+ *  this class for any 413, so `instanceof SnapshotTooLargeError` is true for
+ *  all of them and stays true. To single out a snapshot that is too large,
+ *  test `e.code === "snapshot_too_large"`. */
 export declare class SnapshotTooLargeError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
+    });
+}
+/** An HTTP 413 that is not about a snapshot: a request body over the server's
+ *  size limit (`request_too_large`, or a plain-text 413 with no code), a
+ *  memory value or quota (`memory_value_too_large`, `memory_quota_exceeded`),
+ *  a channel payload (`payload_too_large`). `e.code` says which.
+ *
+ *  It extends SnapshotTooLargeError only because that is the class these
+ *  responses were raised as before this one existed; the relation keeps an
+ *  existing `instanceof SnapshotTooLargeError` matching and says nothing about
+ *  snapshots. */
+export declare class RequestTooLargeError extends SnapshotTooLargeError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+        code?: string;
+    });
+}
+/** A `decide()` request that does not fit the decision model's context (HTTP
+ *  413, body code `prompt_too_large`). The server never shortens it for you:
+ *  shorten `state` or ask fewer questions, then send it again. */
+export declare class PromptTooLargeError extends RequestTooLargeError {
+    constructor(message: string, opts?: {
+        status?: number;
+        bodyText?: string;
+        code?: string;
     });
 }
 export declare class SnapshotVersionError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 /** ChannelCursorRegressionError — raised by `client.ackChannel()`
@@ -187,6 +293,7 @@ export declare class ChannelCursorRegressionError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
     });
 }
 /** SubstrateToolRefusedError — raised by `client.agentDef()` /
@@ -205,6 +312,7 @@ export declare class SubstrateToolRefusedError extends LoomcycleError {
     constructor(message: string, opts?: {
         status?: number;
         bodyText?: string;
+        code?: string;
         tool?: string;
     });
 }

package/dist/errors.js

@@ -20,11 +20,18 @@
 export class LoomcycleError extends Error {
     status;
     bodyText;
+    /** The machine-readable `code` of a JSON error body (`model_not_allowed`,
+     *  `token_limit_exceeded`, `per_user_quota_exhausted`, …), on whichever
+     *  class the status maps to. Undefined when the body is not JSON or carries
+     *  no string `code`. Read from the whole body, so it survives where
+     *  `bodyText` is cut at 1 KiB. Branch on this, not on the message. */
+    code;
     constructor(message, opts) {
         super(message);
         this.name = "LoomcycleError";
         this.status = opts?.status;
         this.bodyText = opts?.bodyText;
+        this.code = opts?.code;
     }
 }
 /** Base class for every HTTP 404 the client surfaces. Lets callers
@@ -62,12 +69,60 @@ export class AgentIDInUseError extends LoomcycleError {
         this.name = "AgentIDInUseError";
     }
 }
+/** Every HTTP 429 that is not a per-user quota. A plain BackpressureError is
+ *  the transient case (the server is busy; back off and retry). It has one
+ *  subclass that is NOT transient, TokenLimitExceededError — check for that
+ *  first when deciding whether to retry. */
 export class BackpressureError extends LoomcycleError {
     constructor(message, opts) {
         super(message, opts);
         this.name = "BackpressureError";
     }
 }
+/**
+ * TokenLimitExceededError signals that the caller is at a hard token budget:
+ * HTTP 429 with body code `token_limit_exceeded`, from run creation and from
+ * `decide()`.
+ *
+ * Do not retry it the way you retry backpressure. The budget is a calendar
+ * month's tokens for an operator, tenant or user; the same call is refused
+ * until an operator raises the budget or the window rolls over.
+ *
+ * It extends BackpressureError only so that code written before this class
+ * existed, which caught this refusal with `instanceof BackpressureError`,
+ * keeps catching it. Test for this class BEFORE BackpressureError:
+ *
+ *   if (e instanceof TokenLimitExceededError) {
+ *     // not retryable now: report e.scope / e.used / e.limit
+ *   } else if (e instanceof BackpressureError) {
+ *     // transient: back off and retry
+ *   }
+ *
+ * The fields come from the response body and are null when the server did
+ * not send them.
+ */
+export class TokenLimitExceededError extends BackpressureError {
+    /** Whose budget was hit: "operator", "tenant" or "user". */
+    scope;
+    /** The id of that scope: the tenant id or the user subject. Null for the
+     *  operator-wide budget, and where the server withholds it. */
+    scopeId;
+    /** Tokens the scope has used in the current window. */
+    used;
+    /** The hard ceiling that was reached, in tokens. */
+    limit;
+    /** The budget window, e.g. "month" (a calendar month, UTC). */
+    window;
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "TokenLimitExceededError";
+        this.scope = opts?.scope ?? null;
+        this.scopeId = opts?.scopeId ?? null;
+        this.used = opts?.used ?? null;
+        this.limit = opts?.limit ?? null;
+        this.window = opts?.window ?? null;
+    }
+}
 /**
  * PerUserQuotaExhaustedError signals that the caller has hit their
  * per-user cap on in-flight (active+queued) runs. Distinct from
@@ -164,12 +219,44 @@ export class SnapshotNotFoundError extends NotFoundError {
         this.name = "SnapshotNotFoundError";
     }
 }
+/** A snapshot envelope over the size cap (HTTP 413, body code
+ *  `snapshot_too_large`).
+ *
+ *  For compatibility it is ALSO the base class of every other 413: until
+ *  RequestTooLargeError and PromptTooLargeError existed, the client raised
+ *  this class for any 413, so `instanceof SnapshotTooLargeError` is true for
+ *  all of them and stays true. To single out a snapshot that is too large,
+ *  test `e.code === "snapshot_too_large"`. */
 export class SnapshotTooLargeError extends LoomcycleError {
     constructor(message, opts) {
         super(message, opts);
         this.name = "SnapshotTooLargeError";
     }
 }
+/** An HTTP 413 that is not about a snapshot: a request body over the server's
+ *  size limit (`request_too_large`, or a plain-text 413 with no code), a
+ *  memory value or quota (`memory_value_too_large`, `memory_quota_exceeded`),
+ *  a channel payload (`payload_too_large`). `e.code` says which.
+ *
+ *  It extends SnapshotTooLargeError only because that is the class these
+ *  responses were raised as before this one existed; the relation keeps an
+ *  existing `instanceof SnapshotTooLargeError` matching and says nothing about
+ *  snapshots. */
+export class RequestTooLargeError extends SnapshotTooLargeError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "RequestTooLargeError";
+    }
+}
+/** A `decide()` request that does not fit the decision model's context (HTTP
+ *  413, body code `prompt_too_large`). The server never shortens it for you:
+ *  shorten `state` or ask fewer questions, then send it again. */
+export class PromptTooLargeError extends RequestTooLargeError {
+    constructor(message, opts) {
+        super(message, opts);
+        this.name = "PromptTooLargeError";
+    }
+}
 export class SnapshotVersionError extends LoomcycleError {
     constructor(message, opts) {
         super(message, opts);

package/dist/fetch-helpers.d.ts

@@ -88,15 +88,23 @@ export declare function deleteJSON<T>(ctx: _FetchContext, path: string, opts?: {
  *   409 + "session"                            → SessionBusyError
  *   409 + "agent_id"                           → AgentIDInUseError
  *   409 + (other)                              → LoomcycleError (base)
- *   413         → SnapshotTooLargeError
+ *   413 + code "snapshot_too_large" → SnapshotTooLargeError ──┐ all are
+ *   413 + code "prompt_too_large"   → PromptTooLargeError     │ instanceof
+ *   413 (other)                     → RequestTooLargeError ───┘ SnapshotTooLargeError
  *   422         → SnapshotVersionError (snapshot-version-too-new/unknown)
- *   429         → BackpressureError
+ *   429 + code "per_user_quota_exhausted" → PerUserQuotaExhaustedError
+ *   429 + code "token_limit_exceeded"     → TokenLimitExceededError
+ *                                           (subclass of BackpressureError)
+ *   429 (other)                           → BackpressureError
  *   503 + "pause manager not configured" → PauseNotConfiguredError
  *                                          (subclass of UnavailableError)
  *   503 + (other)                        → UnavailableError
  *   500-599 (other) → LoomcycleError (base)
  *   default     → LoomcycleError (base)
  *
+ * Whatever class the status maps to, a JSON body's string `code` is on the
+ * error as `code` (see bodyCode).
+ *
  * Priority within a status group is most-specific-first; an unknown
  * 409 falls through to base LoomcycleError so callers see a
  * meaningful message + status. For 404, the catch-all is NotFoundError

package/dist/fetch-helpers.js

@@ -9,7 +9,7 @@
  * Method-level code in client.ts stays focused on URL + body shape;
  * the boring fetch + error-translation machinery lives here.
  */
-import { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, ChannelCursorRegressionError, InvalidArgumentError, LoomcycleError, NotFoundError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, UnavailableError, } from "./errors.js";
+import { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, ChannelCursorRegressionError, InvalidArgumentError, LoomcycleError, NotFoundError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, PromptTooLargeError, RequestTooLargeError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, TokenLimitExceededError, UnavailableError, } from "./errors.js";
 /** authHeaders builds the standard request header set: JSON Accept
  *  + Bearer token when the client was constructed with one. The
  *  caller adds Content-Type when posting a body. */
@@ -168,15 +168,23 @@ export async function deleteJSON(ctx, path, opts) {
  *   409 + "session"                            → SessionBusyError
  *   409 + "agent_id"                           → AgentIDInUseError
  *   409 + (other)                              → LoomcycleError (base)
- *   413         → SnapshotTooLargeError
+ *   413 + code "snapshot_too_large" → SnapshotTooLargeError ──┐ all are
+ *   413 + code "prompt_too_large"   → PromptTooLargeError     │ instanceof
+ *   413 (other)                     → RequestTooLargeError ───┘ SnapshotTooLargeError
  *   422         → SnapshotVersionError (snapshot-version-too-new/unknown)
- *   429         → BackpressureError
+ *   429 + code "per_user_quota_exhausted" → PerUserQuotaExhaustedError
+ *   429 + code "token_limit_exceeded"     → TokenLimitExceededError
+ *                                           (subclass of BackpressureError)
+ *   429 (other)                           → BackpressureError
  *   503 + "pause manager not configured" → PauseNotConfiguredError
  *                                          (subclass of UnavailableError)
  *   503 + (other)                        → UnavailableError
  *   500-599 (other) → LoomcycleError (base)
  *   default     → LoomcycleError (base)
  *
+ * Whatever class the status maps to, a JSON body's string `code` is on the
+ * error as `code` (see bodyCode).
+ *
  * Priority within a status group is most-specific-first; an unknown
  * 409 falls through to base LoomcycleError so callers see a
  * meaningful message + status. For 404, the catch-all is NotFoundError
@@ -202,7 +210,7 @@ export async function raiseFromResponse(resp) {
     // ("401 Unauthorized" not "401 " with a trailing space).
     const statusPhrase = resp.statusText || stockStatusPhrase(status);
     const msg = bodyText.trim() ? bodyText.slice(0, 1024) : `${status} ${statusPhrase}`;
-    const opts = { status, bodyText: bodyText.slice(0, 1024) };
+    const opts = { status, bodyText: bodyText.slice(0, 1024), code: bodyCode(bodyText) };
     switch (status) {
         case 400:
             throw new InvalidArgumentError(msg, opts);
@@ -238,7 +246,14 @@ export async function raiseFromResponse(resp) {
                 throw new AgentIDInUseError(msg, opts);
             throw new LoomcycleError(msg, opts);
         case 413:
-            throw new SnapshotTooLargeError(msg, opts);
+            // Every 413 used to be a SnapshotTooLargeError, so the two classes
+            // below extend it: an existing `instanceof SnapshotTooLargeError`
+            // still matches all three.
+            if (opts.code === "snapshot_too_large")
+                throw new SnapshotTooLargeError(msg, opts);
+            if (opts.code === "prompt_too_large")
+                throw new PromptTooLargeError(msg, opts);
+            throw new RequestTooLargeError(msg, opts);
         case 422: {
             // 422 is shared between snapshot version errors (existing)
             // and v0.8.22 substrate tool refusals. Discriminate by body:
@@ -247,7 +262,7 @@ export async function raiseFromResponse(resp) {
             try {
                 const parsed = JSON.parse(bodyText);
                 if (parsed.code === "tool_refused") {
-                    throw new SubstrateToolRefusedError(parsed.error ?? msg, { status, bodyText, tool: parsed.tool });
+                    throw new SubstrateToolRefusedError(parsed.error ?? msg, { status, bodyText, code: parsed.code, tool: parsed.tool });
                 }
             }
             catch (e) {
@@ -259,6 +274,20 @@ export async function raiseFromResponse(resp) {
             throw new SnapshotVersionError(msg, opts);
         }
         case 429: {
+            // A hard token budget is not transient the way backpressure is, so
+            // it gets its own class (a BackpressureError subclass, for callers
+            // that already catch that).
+            if (opts.code === "token_limit_exceeded") {
+                const body = bodyObject(bodyText) ?? {};
+                throw new TokenLimitExceededError(msg, {
+                    ...opts,
+                    scope: stringField(body.scope),
+                    scopeId: stringField(body.scope_id),
+                    used: numberField(body.used),
+                    limit: numberField(body.limit),
+                    window: stringField(body.window),
+                });
+            }
             // v0.10.1: distinguish per-user quota exhaustion from
             // operator-wide backpressure. The shapes share the 429 status
             // but the JSON body's `code` field discriminates. Consumers
@@ -274,6 +303,7 @@ export async function raiseFromResponse(resp) {
                     throw new PerUserQuotaExhaustedError(parsed.error ?? msg, {
                         status,
                         bodyText,
+                        code: parsed.code,
                         userId: parsed.user_id,
                         cap: parsed.cap,
                         retryAfterMs: Number.isFinite(retryAfterMs) ? retryAfterMs : undefined,
@@ -295,6 +325,36 @@ export async function raiseFromResponse(resp) {
             throw new LoomcycleError(msg, opts);
     }
 }
+/** bodyCode returns the string `code` of a JSON error body, or undefined when
+ *  the body is not a JSON object or has none. Statuses are shared between
+ *  unrelated conditions (a 400 is any bad request; a 429 is backpressure, a
+ *  user quota or a token budget), and the code is what tells them apart. */
+function bodyCode(bodyText) {
+    return stringField(bodyObject(bodyText)?.code);
+}
+/** bodyObject returns a JSON error body as an object, or undefined when the
+ *  body is not JSON or is a JSON array or scalar. */
+function bodyObject(bodyText) {
+    try {
+        const parsed = JSON.parse(bodyText);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // not JSON: a plain-text error body has no fields
+    }
+    return undefined;
+}
+/** stringField / numberField read one body field, dropping a value of the
+ *  wrong type: an error's typed fields must not carry whatever a proxy or an
+ *  older server put under that name. An empty string counts as absent. */
+function stringField(v) {
+    return typeof v === "string" && v !== "" ? v : undefined;
+}
+function numberField(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
 /** stockStatusPhrase returns a stock reason phrase for the common
  *  HTTP statuses raiseFromResponse handles. Used as a fallback when
  *  Response.statusText is empty (HTTP/2 strips reason phrases). */

package/dist/index.d.ts

@@ -115,7 +115,9 @@
  *     AuthError, UnavailableError, InvalidArgumentError,
  *     PauseNotConfiguredError (subclass of UnavailableError),
  *     AlreadyPausingError, NotPausedError, SnapshotNotFoundError,
- *     SnapshotTooLargeError, SnapshotVersionError,
+ *     SnapshotTooLargeError, RequestTooLargeError + PromptTooLargeError
+ *     (both subclasses of SnapshotTooLargeError), TokenLimitExceededError
+ *     (subclass of BackpressureError), SnapshotVersionError,
  *     SubstrateToolRefusedError (v0.8.22)
  *
  * Transport: HTTP+SSE. Auth: Bearer token via the Authorization
@@ -130,5 +132,5 @@ export { InteractiveSession } from "./interactive.js";
 export type { InteractiveSessionOps } from "./interactive.js";
 export { ClientToolHost, clientToolsURL, CLIENT_TOOL_SUBPROTOCOL } from "./client-tools.js";
 export type { ClientToolSchema, ClientToolInvocation, ConnectClientToolsOptions, WebSocketLike, WebSocketCtor, } from "./client-tools.js";
-export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ImageMediaType, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, SamplingOptions, CompactionOptions, ContextOptions, ToolUse, Usage, CallTiming, Agent, AgentStatus, AwaitedState, AgentUsage, RunResult, RunSpec, RunSpecTeam, ConfiguredRun, ConfiguredRunPatch, ToolChoiceOptions, OutputFormatOptions, CancelAgentResult, ListAgentsResponse, WalkRunsPage, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, DirectoryBudget, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResidue, ErasureResult, ErasureTier, CancelTurnResult, ReviewRunResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, UserTokenMeta, ListUserTokensResponse, RunnableAgent, RunnableAgentsResponse, WhoamiResponse, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, MemorySearchInput, MemorySource, MemoryWhen, MemoryTimeFilter, MemorySearchEntry, MemorySearchResponse, MemoryEmbedModelStats, MemoryEmbedStatsResponse, MemoryReembedConfigured, MemoryReembedResponse, MemoryBackfillResponse, MemoryPurgeResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, ChannelHookCall, ChannelHookResult, HookFailMode, HookPhase, HookToolCall, HookToolResult, PostHookCall, PostHookResult, PreHookCall, PreHookResult, SubstrateToolInput, SubstrateToolResponse, TeamNameSummary, ListTeamsResponse, TeamDiagram, CreatedTeam, PromotedTeam, RetiredTeam, TeamDefDetail, TeamVerification, TeamDraft, TeamDraftVerification, TeamIssue, TeamIssueKind, TeamVersion, TeamVersionList, TeamBreakpoints, TeamRunDetached, TeamRunResult, TeamRunTarget, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelReleaseResult, ChannelScope, ChannelSubscribeResult, PeekChannelOptions, PublishChannelOptions, SubscribeChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAwaitEntry, ChannelAwaitMode, ChannelAwaitResult, ChannelBroadcastEntry, ChannelBroadcastResult, CreateChannelOptions, ReleaseChannelOptions, UpdateChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, AgentDefRowResponse, AgentDefVerifyResult, SkillDefVerifyResult, EnsureMcpServerOptions, EnsureMcpServerResult, MCPServerDefRowResponse, MCPServerDefVerifyResult, AgentDefOverlay, HookEvent, InlineWebhook, HookEntry, EventHooks, ToolEntry, ToolHooksByTool, EnsureCodeAgentOptions, EnsureCodeAgentResult, LibraryAgentDefinition, LibraryEntry, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, LLMChatContent, LLMChatMessage, LLMChatOptions, LLMChatResponse, LLMChatStreamDelta, LLMChatStreamItem, LLMChatToolCall, LLMChatUsage, LLMTool, LLMEmbeddingItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, LLMEmbeddingsUsage, UsageDimension, UsageAggregate, UsageReportResponse, CapabilityInertInfo, LimitInfo, ErrorInfo, CallFormat, CallRef, HookDecisionInfo, EffectiveConfigResponse, EffectiveConfigSource, EffectiveValue, RetuneRunResponse, RunConfigRecord, SubagentHoldInfo, RunConfigResponse, RunPromptResponse, RunPromptSnapshot, PromptBlock, TokenLimit, TokenLimitsResponse, ConfigResponse, ConfigProvider, ConfigModel, ConfigSearch, ConfigInstance, SetTokenLimitRequest, CredentialScope, CredentialMeta, CredentialListResponse, } from "./types.js";
-export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, NotFoundError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, UnavailableError, } from "./errors.js";
+export type { AgentEvent, ClientOptions, ContinueOptions, EventType, HostWidening, ImageMediaType, ParentContext, PromptContent, PromptSegment, RetryInfo, RunOptions, SamplingOptions, CompactionOptions, ContextOptions, ToolUse, Usage, CallTiming, Agent, AgentStatus, AwaitedState, AgentUsage, RunResult, RunSpec, RunSpecTeam, ConfiguredRun, ConfiguredRunPatch, ToolChoiceOptions, OutputFormatOptions, CancelAgentResult, ListAgentsResponse, WalkRunsPage, RunBatchOptions, RunBatchResult, SpawnRunResult, CompactRunResult, DirectoryBudget, DirectoryInspection, DirectoryTenant, DirectoryUser, ErasureReport, ErasureResidue, ErasureResult, ErasureTier, CancelTurnResult, ReviewRunResult, TranscriptEvent, TranscriptResponse, HealthResponse, ListUsersResponse, UserSummary, UserRecord, CreateUserBody, UpdateUserBody, MintedUserToken, UserTokenMeta, ListUserTokensResponse, RunnableAgent, RunnableAgentsResponse, WhoamiResponse, PauseResult, ResumeResult, RuntimeStateResponse, RuntimeStateStatus, ResolverMatrix, ResolverModelStatus, ResolverProviderAvailability, CreateSnapshotOptions, SnapshotCreateResponse, SnapshotDescriptor, SnapshotEnvelope, SnapshotListResponse, SnapshotRestoreResponse, MemoryEntriesResponse, MemoryEntry, MemoryEntryResponse, MemoryScopeIDsResponse, MemoryScopeIDSummary, MemoryScopeKind, MemoryScopesResponse, MemorySearchInput, MemorySource, MemoryWhen, MemoryTimeFilter, MemorySearchEntry, MemorySearchResponse, MemoryEmbedModelStats, MemoryEmbedStatsResponse, MemoryReembedConfigured, MemoryReembedResponse, MemoryBackfillResponse, MemoryPurgeResponse, InterruptListResponse, InterruptRow, InterruptStatus, ResolveInterruptOptions, ChannelHookCall, ChannelHookResult, HookFailMode, HookPhase, HookToolCall, HookToolResult, PostHookCall, PostHookResult, PreHookCall, PreHookResult, SubstrateToolInput, SubstrateToolResponse, TeamNameSummary, ListTeamsResponse, TeamDiagram, CreatedTeam, PromotedTeam, RetiredTeam, TeamDefDetail, TeamVerification, TeamDraft, TeamDraftVerification, TeamIssue, TeamIssueKind, TeamVersion, TeamVersionList, TeamBreakpoints, TeamRunDetached, TeamRunResult, TeamRunTarget, PathToolInput, PathToolResponse, DocumentToolInput, DocumentToolResponse, HistoryToolInput, HistoryToolResponse, VolumeMode, PersistentVolumeEntry, PersistentVolumesResponse, EphemeralVolumeEntry, EphemeralVolumesResponse, SystemPromptPayload, UserInputPayload, ChannelDescriptor, ListChannelsResponse, RunStateEvent, RunStateStreamClose, RunStateStreamItem, RunStateStreamOpen, StreamUserRunStatesOptions, AckChannelOptions, ChannelAckResult, ChannelMessageItem, ChannelPeekResult, ChannelPublishResult, ChannelPurgeResult, ChannelReleaseResult, ChannelScope, ChannelSubscribeResult, PeekChannelOptions, PublishChannelOptions, SubscribeChannelOptions, AwaitChannelsOptions, BroadcastChannelsOptions, ChannelAwaitEntry, ChannelAwaitMode, ChannelAwaitResult, ChannelBroadcastEntry, ChannelBroadcastResult, CreateChannelOptions, ReleaseChannelOptions, UpdateChannelOptions, SetMemoryEntryOptions, SetMemoryEntryResponse, AgentDefRowResponse, AgentDefVerifyResult, SkillDefVerifyResult, EnsureMcpServerOptions, EnsureMcpServerResult, MCPServerDefRowResponse, MCPServerDefVerifyResult, AgentDefOverlay, HookEvent, InlineWebhook, HookEntry, EventHooks, ToolEntry, ToolHooksByTool, EnsureCodeAgentOptions, EnsureCodeAgentResult, LibraryAgentDefinition, LibraryEntry, LibraryListResponse, LibraryMcpServerDefinition, LibrarySkillDefinition, LLMChatContent, LLMChatMessage, LLMChatOptions, LLMChatResponse, LLMChatStreamDelta, LLMChatStreamItem, LLMChatToolCall, LLMChatUsage, LLMTool, LLMEmbeddingItem, LLMEmbeddingsOptions, LLMEmbeddingsResponse, LLMEmbeddingsUsage, UsageDimension, UsageAggregate, UsageReportResponse, CapabilityInertInfo, LimitInfo, ErrorInfo, CallFormat, CallRef, HookDecisionInfo, EffectiveConfigResponse, EffectiveConfigSource, EffectiveValue, RetuneRunResponse, RunConfigRecord, SubagentHoldInfo, RunConfigResponse, RunPromptResponse, RunPromptSnapshot, PromptBlock, TokenLimit, TokenLimitsResponse, ConfigResponse, ConfigProvider, ConfigModel, ConfigSearch, ConfigInstance, SetTokenLimitRequest, CredentialScope, CredentialMeta, CredentialListResponse, DecideRequest, DecideResponse, DecisionQuestion, DecisionChoiceQuestion, DecisionNoulQuestion, DecisionScoreQuestion, DecisionAnswer, DecisionChoiceAnswer, DecisionNoulAnswer, DecisionScoreAnswer, DecisionModel, DecisionModelsResponse, } from "./types.js";
+export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, NotFoundError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, PromptTooLargeError, RequestTooLargeError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, TokenLimitExceededError, UnavailableError, } from "./errors.js";

package/dist/index.js

@@ -115,7 +115,9 @@
  *     AuthError, UnavailableError, InvalidArgumentError,
  *     PauseNotConfiguredError (subclass of UnavailableError),
  *     AlreadyPausingError, NotPausedError, SnapshotNotFoundError,
- *     SnapshotTooLargeError, SnapshotVersionError,
+ *     SnapshotTooLargeError, RequestTooLargeError + PromptTooLargeError
+ *     (both subclasses of SnapshotTooLargeError), TokenLimitExceededError
+ *     (subclass of BackpressureError), SnapshotVersionError,
  *     SubstrateToolRefusedError (v0.8.22)
  *
  * Transport: HTTP+SSE. Auth: Bearer token via the Authorization
@@ -128,4 +130,4 @@
 export { LoomcycleClient } from "./client.js";
 export { InteractiveSession } from "./interactive.js";
 export { ClientToolHost, clientToolsURL, CLIENT_TOOL_SUBPROTOCOL } from "./client-tools.js";
-export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, NotFoundError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, UnavailableError, } from "./errors.js";
+export { AgentIDInUseError, AgentNotFoundError, AlreadyPausingError, AuthError, BackpressureError, NotFoundError, InvalidArgumentError, ChannelCursorRegressionError, LoomcycleError, NotPausedError, PauseNotConfiguredError, PerUserQuotaExhaustedError, PromptTooLargeError, RequestTooLargeError, SessionBusyError, SessionNotFoundError, SnapshotNotFoundError, SnapshotTooLargeError, SnapshotVersionError, SubstrateToolRefusedError, TokenLimitExceededError, UnavailableError, } from "./errors.js";