@lumavox/server 0.5.0 → 0.8.0

package/dist/index.d.ts

@@ -8,15 +8,16 @@ export { type Client, type ClientOptions, createClient, DEFAULT_BASE_URL, } from
 export { AuthenticationError, ConflictError, ConnectionError, InsufficientCreditsError, NotFoundError, PermissionError, PlatformError, type PlatformErrorCode, type PlatformErrorInit, RateLimitError, ServerError, TimeoutError, ValidationError, } from "./errors.js";
 export type * from "./gen/index.js";
 export type { Page } from "./paging.js";
-export type { AgentKnowledge, AgentSettings, Agents, } from "./resources/agents.js";
+export type { AgentKnowledge, AgentSettings, Agents, AgentTools, } from "./resources/agents.js";
 export type { AssetListParams, Assets, AssetUploadFields, FolderListParams, Folders, } from "./resources/assets.js";
 export type { EndUserCreated, EndUserExport, EndUserListParams, EndUsers, } from "./resources/end-users.js";
-export type { EphemeralKeyCreateOptions, EphemeralKeyListParams, EphemeralKeys, } from "./resources/ephemeral-keys.js";
+export type { EphemeralKeyCreateOptions, EphemeralKeyListParams, EphemeralKeyRevokeOptions, EphemeralKeys, } from "./resources/ephemeral-keys.js";
 export type { GenerationListParams, Generations, Jobs, Skybox, } from "./resources/generations.js";
 export type { Knowledge, KnowledgeInsightsParams, KnowledgeListParams, KnowledgeUploadFields, } from "./resources/knowledge.js";
-export type { Resource, Waitable } from "./resources/resource.js";
+export type { Library, Listing, Resource, Waitable, WaitableLibrary, } from "./resources/resource.js";
 export type { Speech, Stt, SttEvent, SttParams, Transcript, Tts, } from "./resources/speech.js";
 export type { TemplateFile, Templates } from "./resources/templates.js";
+export type { Tools } from "./resources/tools.js";
 export type { Usage, UsageParams } from "./resources/usage.js";
 export type { Voices, VoiceUploadFields } from "./resources/voices.js";
 export type { Fetch, RequestOptions } from "./transport.js";

package/dist/resources/agents.d.ts

@@ -6,15 +6,16 @@
  * - **A save reaches running sessions within a minute**, not at once: an
  *   agent's version travels through the platform's `STANDING` copy.
  * - **`settings`** are the organisation's, for every agent;
- *   **`knowledge.set`** replaces the entries one agent may look up.
+ *   **`knowledge.set`** replaces the entries one agent may look up, and
+ *   **`tools.set`** the tools it can call.
  * - **`create` is a 409 at the plan's maximum agents**; `delete` answers
  *   `true`, and `false` for one already gone.
  * - **`list()` reads one page**: an organisation's agents are few, and the
  *   route answers them all with `next_cursor` `null` (`paging.ts`).
  */
-import type { AgentCreateRequest, AgentInfo, AgentKnowledgeUpdate, AgentPage, AgentSettingsInfo, AgentSettingsUpdate, AgentSummary, AgentUpdate, KnowledgeAssigned, KnowledgeInfo } from "../gen/index.js";
+import type { AgentCreateRequest, AgentInfo, AgentKnowledgeUpdate, AgentPage, AgentSettingsInfo, AgentSettingsUpdate, AgentSummary, AgentToolsUpdate, AgentUpdate, KnowledgeAssigned, KnowledgeInfo, ToolInfo, ToolsAssigned } from "../gen/index.js";
 import type { RequestOptions, Transport } from "../transport.js";
-import { Editable } from "./resource.js";
+import { Library } from "./resource.js";
 /** `agents.settings`: the organisation's, for every agent. */
 export interface AgentSettings {
     get(options?: RequestOptions): Promise<AgentSettingsInfo>;
@@ -27,13 +28,18 @@ export interface AgentKnowledge {
     /** Replaces them all with these. */
     set(agentId: string, body: AgentKnowledgeUpdate, options?: RequestOptions): Promise<KnowledgeAssigned>;
 }
-export declare class Agents extends Editable<AgentInfo, AgentUpdate> {
+/** `agents.tools`: the tools one agent can call. */
+export interface AgentTools {
+    /** Every tool it can call. */
+    list(agentId: string, options?: RequestOptions): AsyncGenerator<ToolInfo, void, undefined>;
+    /** Replaces them all with these, 20 at most. */
+    set(agentId: string, body: AgentToolsUpdate, options?: RequestOptions): Promise<ToolsAssigned>;
+}
+export declare class Agents extends Library<AgentInfo, AgentUpdate, AgentSummary, AgentPage, AgentCreateRequest> {
     readonly settings: AgentSettings;
     readonly knowledge: AgentKnowledge;
+    readonly tools: AgentTools;
     constructor(api: Transport, base: string);
-    /** The page of agents, as the route answers it. */
-    page(options?: RequestOptions): Promise<AgentPage>;
-    /** Every agent. */
-    list(options?: RequestOptions): AsyncGenerator<AgentSummary, void, undefined>;
-    create(body: AgentCreateRequest, options?: RequestOptions): Promise<AgentInfo>;
+    /** An agent's links to what the organisation has: its knowledge, its tools. */
+    protected links<T extends AgentKnowledge | AgentTools>(rest: string): T;
 }

package/dist/resources/agents.js

@@ -6,34 +6,29 @@
  * - **A save reaches running sessions within a minute**, not at once: an
  *   agent's version travels through the platform's `STANDING` copy.
  * - **`settings`** are the organisation's, for every agent;
- *   **`knowledge.set`** replaces the entries one agent may look up.
+ *   **`knowledge.set`** replaces the entries one agent may look up, and
+ *   **`tools.set`** the tools it can call.
  * - **`create` is a 409 at the plan's maximum agents**; `delete` answers
  *   `true`, and `false` for one already gone.
  * - **`list()` reads one page**: an organisation's agents are few, and the
  *   route answers them all with `next_cursor` `null` (`paging.ts`).
  */
-import { Editable } from "./resource.js";
-export class Agents extends Editable {
+import { Library } from "./resource.js";
+export class Agents extends Library {
     constructor(api, base) {
         super(api, base);
         this.settings = {
             get: (options) => this.send("GET", "/settings", options),
             update: (body, options) => this.send("PUT", "/settings", options, body),
         };
-        this.knowledge = {
-            list: (id, options) => this.each(this.at(id, "/knowledge"), {}, options),
-            set: (id, body, options) => this.send("PUT", this.at(id, "/knowledge"), options, body),
-        };
-    }
-    /** The page of agents, as the route answers it. */
-    page(options) {
-        return this.send("GET", "", options);
+        this.knowledge = this.links("/knowledge");
+        this.tools = this.links("/tools");
     }
-    /** Every agent. */
-    list(options) {
-        return this.each("", {}, options);
-    }
-    create(body, options) {
-        return this.send("POST", "", options, body);
+    /** An agent's links to what the organisation has: its knowledge, its tools. */
+    links(rest) {
+        return {
+            list: (id, options) => this.each(this.at(id, rest), {}, options),
+            set: (id, body, options) => this.send("PUT", this.at(id, rest), options, body),
+        };
     }
 }

package/dist/resources/end-users.d.ts

@@ -21,18 +21,15 @@
  * and an API key cannot read them (`/v1/agent/*` takes only an ephemeral
  * key): it mints a five-minute key for them, lists their sessions (200 a
  * page), reads each transcript back to its start by `messages.next_cursor`
- * (200 messages a page, four sessions at a time), reads their facts, and
- * revokes the key in `finally` — after an abort or a failure too. The
- * cost: one mint (and `limits()` when cold) + ⌈S/200⌉ lists + Σ⌈M/200⌉
- * transcript pages + one facts read + one revoke. **Its ceilings**: the
+ * (200 messages a page, four sessions at a time), reads their facts (200
+ * a page), and revokes the key in `finally` — after an abort or a failure
+ * too. The cost: one mint (and `limits()` when cold) + ⌈S/200⌉ lists +
+ * Σ⌈M/200⌉ transcript pages + ⌈F/200⌉ fact pages + one revoke. **Its ceilings**: the
  * key is ordinary, so at the person's live-key cap or the plan's mint rate
  * the export fails as the mint does (422, 429) and can be retried once a
  * key lapses; it lives five minutes, so a history that takes longer to
  * read fails with a 401; its one micro-credit is set aside like any key's,
- * so an organisation with no balance cannot export (402); and the facts
- * route answers the newest 100 in one page until it pages (left-overs
- * #109) — read here by its cursor, so the day it does, the export has
- * them all.
+ * so an organisation with no balance cannot export (402).
  */
 import type { EndUserCreateRequest, EndUserDeleted, EndUserInfo, EndUserPage, EndUserUpdateRequest, FactInfo, ListEndUsersData, SessionDetail } from "../gen/index.js";
 import { type RequestOptions, type Transport } from "../transport.js";

package/dist/resources/end-users.js

@@ -21,18 +21,15 @@
  * and an API key cannot read them (`/v1/agent/*` takes only an ephemeral
  * key): it mints a five-minute key for them, lists their sessions (200 a
  * page), reads each transcript back to its start by `messages.next_cursor`
- * (200 messages a page, four sessions at a time), reads their facts, and
- * revokes the key in `finally` — after an abort or a failure too. The
- * cost: one mint (and `limits()` when cold) + ⌈S/200⌉ lists + Σ⌈M/200⌉
- * transcript pages + one facts read + one revoke. **Its ceilings**: the
+ * (200 messages a page, four sessions at a time), reads their facts (200
+ * a page), and revokes the key in `finally` — after an abort or a failure
+ * too. The cost: one mint (and `limits()` when cold) + ⌈S/200⌉ lists +
+ * Σ⌈M/200⌉ transcript pages + ⌈F/200⌉ fact pages + one revoke. **Its ceilings**: the
  * key is ordinary, so at the person's live-key cap or the plan's mint rate
  * the export fails as the mint does (422, 429) and can be retried once a
  * key lapses; it lives five minutes, so a history that takes longer to
  * read fails with a 401; its one micro-credit is set aside like any key's,
- * so an organisation with no balance cannot export (402); and the facts
- * route answers the newest 100 in one page until it pages (left-overs
- * #109) — read here by its cursor, so the day it does, the export has
- * them all.
+ * so an organisation with no balance cannot export (402).
  */
 import { pages } from "../paging.js";
 import { segment, } from "../transport.js";
@@ -128,7 +125,7 @@ export class EndUsers extends Editable {
                     messages: { data: held.flat(), next_cursor: null },
                 };
             });
-            const facts = await all(pages((cursor) => read("/v1/agent/facts", { cursor })));
+            const facts = await all(pages((cursor) => read("/v1/agent/facts", { limit: PAGE, cursor })));
             return { end_user_id: key.end_user_id ?? id, sessions, facts };
         }
         finally {

package/dist/resources/ephemeral-keys.d.ts

@@ -5,24 +5,24 @@
  * - **A key is prepaid**: its `credit_limit_micros` is set aside from the
  *   balance when it is minted (402 when it cannot be), and what it does not spend
  *   comes back when it settles.
- * - **`create` clamps the lifetime by default** to the platform's maximum,
- *   read from `limits()` — which the API never does: past a cap is a 422
- *   (`apps/api/src/org/minting.ts`). The plan's own caps for one end
- *   user's key are not reported yet (left-overs #107), so a key within the
- *   platform's can still be refused.
+ * - **`create` clamps the lifetime by default** to the tighter of the
+ *   platform's maximum and the plan's for one end user's key, both read
+ *   from `limits()` — which the API never does: past a cap is a 422
+ *   (`apps/api/src/org/minting.ts`).
  * - **`limits()` is cached five minutes per client**, so a mint is two
  *   requests cold and one warm. Concurrent cold callers share one read.
  * - **`revoke` answers at once**, with the figures from before the key's
  *   end user DO settles: revocation leaves through the org DO's outbox
- *   (`apps/api/src/org/areas/keys.ts` `revokeEphemeral`). Waiting for the
- *   final figures needs the key's read route (left-overs #106).
- * - **`inspect` reads a key as itself** (`GET /v1/token` with that key).
- *   Its `credits_spent_micros` moves only when the key settles — at the end, or
- *   daily — so a live key reads as unspent (left-overs #105).
+ *   (`apps/api/src/org/areas/keys.ts` `revokeEphemeral`). With
+ *   `{ settled: true }` it reads the key (`get`) until `settled_at` is set
+ *   — seconds, longer while a memory job the key paid for runs — on the
+ *   polls of `../wait.ts`; a `signal` is its deadline.
+ * - **`inspect` reads a key as itself** (`GET /v1/token` with that key):
+ *   its spend as its end user DO counts it, turn by turn.
  */
 import type { EphemeralKeyCreateRequest, EphemeralKeyCreateResponse, EphemeralKeyInfo, EphemeralKeyLimits, EphemeralKeyPage, EphemeralTokenSelf, ListEphemeralKeysData } from "../gen/index.js";
 import { type RequestOptions } from "../transport.js";
-import { Resource } from "./resource.js";
+import { Readable } from "./resource.js";
 export type EphemeralKeyListParams = NonNullable<ListEphemeralKeysData["query"]>;
 export interface EphemeralKeyCreateOptions extends RequestOptions {
     /**
@@ -32,12 +32,17 @@ export interface EphemeralKeyCreateOptions extends RequestOptions {
      */
     clampTtl?: boolean;
 }
-export declare class EphemeralKeys extends Resource {
+export interface EphemeralKeyRevokeOptions extends RequestOptions {
+    /** Answer once the key's final figures are in (`settled_at` set), not at once. */
+    settled?: boolean;
+}
+export declare class EphemeralKeys extends Readable<EphemeralKeyInfo> {
     private cached;
     /**
-     * What a key may be minted with: the **platform's** longest lifetime and
-     * largest credit limit, and the scopes this API key may grant. Cached
-     * five minutes per client.
+     * What a key may be minted with: the platform's longest lifetime and
+     * largest credit limit, the plan's for one end user's key (`plan_*`,
+     * `null` where it sets none), and the scopes this API key may grant.
+     * Cached five minutes per client.
      */
     limits(options?: RequestOptions): Promise<EphemeralKeyLimits>;
     /**
@@ -49,10 +54,11 @@ export declare class EphemeralKeys extends Resource {
     create(body: EphemeralKeyCreateRequest, options?: EphemeralKeyCreateOptions): Promise<EphemeralKeyCreateResponse>;
     /**
      * Revokes a key: it is refused from now on, and what it did not spend
-     * comes back when it settles. `null` when there is no such key — a
-     * revoked, expired or unknown id answers as itself, a non-UUID as none.
+     * comes back when it settles — awaited with `{ settled: true }`. `null`
+     * when there is no such key — a revoked, expired or unknown id answers
+     * as itself, a non-UUID as none.
      */
-    revoke(id: string, options?: RequestOptions): Promise<EphemeralKeyInfo | null>;
+    revoke(id: string, options?: EphemeralKeyRevokeOptions): Promise<EphemeralKeyInfo | null>;
     /**
      * A key as it reads itself: its scopes, limit, spend and expiry. `null`
      * when the key is refused — expired, revoked, spent or not a key.

package/dist/resources/ephemeral-keys.js

@@ -5,24 +5,25 @@
  * - **A key is prepaid**: its `credit_limit_micros` is set aside from the
  *   balance when it is minted (402 when it cannot be), and what it does not spend
  *   comes back when it settles.
- * - **`create` clamps the lifetime by default** to the platform's maximum,
- *   read from `limits()` — which the API never does: past a cap is a 422
- *   (`apps/api/src/org/minting.ts`). The plan's own caps for one end
- *   user's key are not reported yet (left-overs #107), so a key within the
- *   platform's can still be refused.
+ * - **`create` clamps the lifetime by default** to the tighter of the
+ *   platform's maximum and the plan's for one end user's key, both read
+ *   from `limits()` — which the API never does: past a cap is a 422
+ *   (`apps/api/src/org/minting.ts`).
  * - **`limits()` is cached five minutes per client**, so a mint is two
  *   requests cold and one warm. Concurrent cold callers share one read.
  * - **`revoke` answers at once**, with the figures from before the key's
  *   end user DO settles: revocation leaves through the org DO's outbox
- *   (`apps/api/src/org/areas/keys.ts` `revokeEphemeral`). Waiting for the
- *   final figures needs the key's read route (left-overs #106).
- * - **`inspect` reads a key as itself** (`GET /v1/token` with that key).
- *   Its `credits_spent_micros` moves only when the key settles — at the end, or
- *   daily — so a live key reads as unspent (left-overs #105).
+ *   (`apps/api/src/org/areas/keys.ts` `revokeEphemeral`). With
+ *   `{ settled: true }` it reads the key (`get`) until `settled_at` is set
+ *   — seconds, longer while a memory job the key paid for runs — on the
+ *   polls of `../wait.ts`; a `signal` is its deadline.
+ * - **`inspect` reads a key as itself** (`GET /v1/token` with that key):
+ *   its spend as its end user DO counts it, turn by turn.
  */
 import { AuthenticationError } from "../errors.js";
 import { orNull } from "../transport.js";
-import { Resource } from "./resource.js";
+import { poll } from "../wait.js";
+import { Readable } from "./resource.js";
 const LIMITS_TTL_MS = 5 * 60_000;
 /** The route's largest page. */
 const PAGE = 200;
@@ -44,12 +45,13 @@ function until(promise, signal) {
         });
     });
 }
-export class EphemeralKeys extends Resource {
+export class EphemeralKeys extends Readable {
     cached = null;
     /**
-     * What a key may be minted with: the **platform's** longest lifetime and
-     * largest credit limit, and the scopes this API key may grant. Cached
-     * five minutes per client.
+     * What a key may be minted with: the platform's longest lifetime and
+     * largest credit limit, the plan's for one end user's key (`plan_*`,
+     * `null` where it sets none), and the scopes this API key may grant.
+     * Cached five minutes per client.
      */
     limits(options = {}) {
         const now = Date.now();
@@ -82,18 +84,23 @@ export class EphemeralKeys extends Resource {
             const wanted = body.expires_in_seconds ?? limits.default_ttl_seconds;
             sent = {
                 ...body,
-                expires_in_seconds: Math.min(wanted, limits.max_ttl_seconds),
+                expires_in_seconds: Math.min(wanted, limits.max_ttl_seconds, limits.plan_max_ttl_seconds ?? wanted),
             };
         }
         return this.send("POST", "", request, sent);
     }
     /**
      * Revokes a key: it is refused from now on, and what it did not spend
-     * comes back when it settles. `null` when there is no such key — a
-     * revoked, expired or unknown id answers as itself, a non-UUID as none.
+     * comes back when it settles — awaited with `{ settled: true }`. `null`
+     * when there is no such key — a revoked, expired or unknown id answers
+     * as itself, a non-UUID as none.
      */
-    revoke(id, options) {
-        return orNull(this.send("DELETE", this.at(id), options));
+    async revoke(id, options = {}) {
+        const { settled, ...request } = options;
+        const key = await orNull(this.send("DELETE", this.at(id), request));
+        return key && settled
+            ? poll(() => this.get(id, request), request, key, (k) => !k.settled_at)
+            : key;
     }
     /**
      * A key as it reads itself: its scopes, limit, spend and expiry. `null`

package/dist/resources/resource.d.ts

@@ -40,3 +40,17 @@ export declare class Waitable<Item extends Job & {
     /** `item` as made, or as it ended when `options.wait` says to wait. */
     protected settled(item: Item, options: UploadOptions): Promise<Item>;
 }
+/** What a `Library` adds to its base. */
+export interface Listing<Listed, ListPage, Create, Created> {
+    /** The page, as the route answers it: all of them, `next_cursor` `null`. */
+    page(options?: RequestOptions): Promise<ListPage>;
+    /** Every one of them. */
+    list(options?: RequestOptions): AsyncGenerator<Listed, void, undefined>;
+    create(body: Create, options?: RequestOptions): Promise<Created>;
+}
+/** An editable listed whole and made by a `POST`: the agents, the tools. */
+export declare const Library: new <Item, Update, Listed, ListPage, Create, Created = Item>(api: Transport, base: string) => Editable<Item, Update> & Listing<Listed, ListPage, Create, Created>;
+/** A waitable listed whole and made by a `POST`: the voices. */
+export declare const WaitableLibrary: new <Item extends Job & {
+    id: string;
+}, Update, Listed, ListPage, Create>(api: Transport, base: string) => Waitable<Item, Update> & Listing<Listed, ListPage, Create, Item>;

package/dist/resources/resource.js

@@ -13,6 +13,9 @@
  *   `false` when there is nothing by that id — already done. One that
  *   reports what went with it (an end user's, a folder's) answers those
  *   counts, and `null` for nothing by that id: the same rule, with a body.
+ * - **`Library`** and **`WaitableLibrary`**: one of the two, listed whole
+ *   in one page and made by a `POST` to the list — `page()`, `list()`,
+ *   `create(body)`, written once (`listed`).
  * - **`Waitable`**: an editable whose items are jobs — a voice, an asset,
  *   a knowledge entry — with `wait(id)` and `settled`, which an upload
  *   answers through.
@@ -83,3 +86,23 @@ export class Waitable extends Editable {
             : item;
     }
 }
+/**
+ * `Listing`'s three methods on `Base`, written once for every resource
+ * listed whole in one page and made by a `POST` to the list: a mixin, as
+ * the agents and the tools are editables and the voices waitables.
+ */
+const listed = (Base) => class extends Base {
+    page(options) {
+        return this.send("GET", "", options);
+    }
+    list(options) {
+        return this.each("", {}, options);
+    }
+    create(body, options) {
+        return this.send("POST", "", options, body);
+    }
+};
+/** An editable listed whole and made by a `POST`: the agents, the tools. */
+export const Library = listed(Editable);
+/** A waitable listed whole and made by a `POST`: the voices. */
+export const WaitableLibrary = listed(Waitable);

package/dist/resources/tools.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `client.tools`: what an organisation's agents can call while they reply
+ * — `/v1/tools*`. A tool is your server (`webhook`), sent a signed `POST`
+ * with the call, or the person's app (`app`), called over the agent's
+ * socket; each is turned on per agent (`agents.tools.set`), 20 at most.
+ *
+ * - **`create(body)`** answers a webhook's signing secret once, as does
+ *   `rotateSecret` (`secret`); every call carries `X-Tool-Signature`.
+ * - **`test(id, { arguments })`** sends your server one call, signed as a
+ *   real one, and answers what came back.
+ * - **`list()` reads one page**: a library holds 200 tools at most.
+ * - **`update` with `expected_version`** refuses an edit made over
+ *   somebody else's (409); `delete` answers `true`, and `false` for one
+ *   already gone.
+ */
+import type { ToolCreate, ToolInfo, ToolPage, ToolTestRequest, ToolTestResult, ToolUpdate, ToolWithSecret } from "../gen/index.js";
+import type { RequestOptions } from "../transport.js";
+import { Library } from "./resource.js";
+export declare class Tools extends Library<ToolInfo, ToolUpdate, ToolInfo, ToolPage, ToolCreate, ToolWithSecret> {
+    /** A new signing secret, shown this once. */
+    rotateSecret(id: string, options?: RequestOptions): Promise<ToolWithSecret>;
+    /** One call to your server, as a conversation would send it: `{ arguments }`. */
+    test(id: string, body?: ToolTestRequest, options?: RequestOptions): Promise<ToolTestResult>;
+}

package/dist/resources/tools.js

@@ -0,0 +1,26 @@
+/**
+ * `client.tools`: what an organisation's agents can call while they reply
+ * — `/v1/tools*`. A tool is your server (`webhook`), sent a signed `POST`
+ * with the call, or the person's app (`app`), called over the agent's
+ * socket; each is turned on per agent (`agents.tools.set`), 20 at most.
+ *
+ * - **`create(body)`** answers a webhook's signing secret once, as does
+ *   `rotateSecret` (`secret`); every call carries `X-Tool-Signature`.
+ * - **`test(id, { arguments })`** sends your server one call, signed as a
+ *   real one, and answers what came back.
+ * - **`list()` reads one page**: a library holds 200 tools at most.
+ * - **`update` with `expected_version`** refuses an edit made over
+ *   somebody else's (409); `delete` answers `true`, and `false` for one
+ *   already gone.
+ */
+import { Library } from "./resource.js";
+export class Tools extends Library {
+    /** A new signing secret, shown this once. */
+    rotateSecret(id, options) {
+        return this.send("POST", this.at(id, "/secret"), options);
+    }
+    /** One call to your server, as a conversation would send it: `{ arguments }`. */
+    test(id, body = {}, options) {
+        return this.send("POST", this.at(id, "/test"), options, body);
+    }
+}

package/dist/resources/voices.d.ts

@@ -16,20 +16,18 @@
 import type { VoiceDesignRequest, VoiceDesignResult, VoiceDesignSaveRequest, VoiceDetail, VoiceInfo, VoiceInfoPage, VoiceUpdate, VoiceUpload, VoiceUploadRequest, VoiceUploadTicket } from "../gen/index.js";
 import type { RequestOptions } from "../transport.js";
 import { type UploadData, type UploadOptions } from "../upload.js";
-import { Waitable } from "./resource.js";
+import { WaitableLibrary } from "./resource.js";
 /** A recording's voice: the create's fields, and the recording's type. */
 export type VoiceUploadFields = Omit<VoiceUpload, "upload_id"> & {
     /** A Blob's own type by default: `audio/wav`, `audio/mpeg`, … */
     content_type?: string;
 };
-/** `update` renames a voice, or changes its description or defaults. */
-export declare class Voices extends Waitable<VoiceDetail, VoiceUpdate> {
-    /** The page of voices, as the route answers it: all of them, `next_cursor` `null`. */
-    page(options?: RequestOptions): Promise<VoiceInfoPage>;
-    /** Every voice this organisation may speak with. */
-    list(options?: RequestOptions): AsyncGenerator<VoiceInfo, void, undefined>;
-    /** Clones a recording already `PUT` to its ticket: `pending` at once. */
-    create(body: VoiceUpload, options?: RequestOptions): Promise<VoiceDetail>;
+/**
+ * `update` renames a voice, or changes its description or defaults;
+ * `list()` is every voice this organisation may speak with; `create(body)`
+ * clones a recording already `PUT` to its ticket, `pending` at once.
+ */
+export declare class Voices extends WaitableLibrary<VoiceDetail, VoiceUpdate, VoiceInfo, VoiceInfoPage, VoiceUpload> {
     /** A signed URL to `PUT` a recording to, with exactly this type. */
     uploadUrl(body: VoiceUploadRequest, options?: RequestOptions): Promise<VoiceUploadTicket>;
     /** Uploads a recording and clones it: `uploadUrl`, the `PUT`, `create`. */

package/dist/resources/voices.js

@@ -14,21 +14,13 @@
  * - **`list()` reads one page**: the route answers every voice in it.
  */
 import { needType, put, } from "../upload.js";
-import { Waitable } from "./resource.js";
-/** `update` renames a voice, or changes its description or defaults. */
-export class Voices extends Waitable {
-    /** The page of voices, as the route answers it: all of them, `next_cursor` `null`. */
-    page(options) {
-        return this.send("GET", "", options);
-    }
-    /** Every voice this organisation may speak with. */
-    list(options) {
-        return this.each("", {}, options);
-    }
-    /** Clones a recording already `PUT` to its ticket: `pending` at once. */
-    create(body, options) {
-        return this.send("POST", "", options, body);
-    }
+import { WaitableLibrary } from "./resource.js";
+/**
+ * `update` renames a voice, or changes its description or defaults;
+ * `list()` is every voice this organisation may speak with; `create(body)`
+ * clones a recording already `PUT` to its ticket, `pending` at once.
+ */
+export class Voices extends WaitableLibrary {
     /** A signed URL to `PUT` a recording to, with exactly this type. */
     uploadUrl(body, options) {
         return this.send("POST", "/upload-url", options, body);

package/dist/wait.d.ts

@@ -32,7 +32,9 @@ export interface Job {
     status: string;
 }
 /**
- * Reads `read` until its status is final, starting from `first` (a job
- * just made, so the first read waits) or with a read now.
+ * Reads `read` until its status is final — or until `pending` says it no
+ * longer is, for what is not a job (a revoked key's settlement) —
+ * starting from `first` (a job just made, so the first read waits) or
+ * with a read now.
  */
-export declare function poll<T extends Job>(read: () => Promise<T>, options?: RequestOptions, first?: T): Promise<T>;
+export declare function poll<T>(read: () => Promise<T>, options?: RequestOptions, first?: T, pending?: (job: T) => boolean): Promise<T>;

package/dist/wait.js

@@ -37,12 +37,14 @@ const IN_PROGRESS = [
 const FIRST_MS = 1_000;
 const MAX_MS = 10_000;
 /**
- * Reads `read` until its status is final, starting from `first` (a job
- * just made, so the first read waits) or with a read now.
+ * Reads `read` until its status is final — or until `pending` says it no
+ * longer is, for what is not a job (a revoked key's settlement) —
+ * starting from `first` (a job just made, so the first read waits) or
+ * with a read now.
  */
-export async function poll(read, options = {}, first) {
+export async function poll(read, options = {}, first, pending = (job) => IN_PROGRESS.includes(job.status)) {
     let job = first ?? (await read());
-    for (let ms = FIRST_MS; IN_PROGRESS.includes(job.status);) {
+    for (let ms = FIRST_MS; pending(job);) {
         await sleep(ms, options.signal);
         job = await read();
         ms = Math.min(ms * 1.5, MAX_MS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumavox/server",
-  "version": "0.5.0",
+  "version": "0.8.0",
   "description": "The Lumavox API from your server: end users, ephemeral keys and the rest, typed from the published OpenAPI document. Zero dependencies.",
   "license": "MIT",
   "type": "module",