@clocknext/sdk 0.15.0 → 0.16.0

package/dist/index.js

@@ -63,6 +63,7 @@ var FIELD_PATHS = [
   [/\busage\.inputTokens\b/g, "tokens.input"],
   [/\busage\.outputTokens\b/g, "tokens.output"],
   [/\busage\.cacheTokens\b/g, "tokens.cache"],
+  [/\busage\.cacheWriteTokens\b/g, "tokens.cacheWrite"],
   [/\busage\.model\b/g, "model"],
   // A missing/invalid `usage` block as a whole: the caller's equivalent is
   // `tokens` (plus `model`, which the SDK hoists to the top level).
@@ -330,7 +331,7 @@ function sleep(ms) {
 }
 
 // src/http.ts
-var SDK_VERSION = "0.15.0" ;
+var SDK_VERSION = "0.16.0" ;
 var Transport = class {
   constructor(cfg) {
     this.cfg = cfg;
@@ -434,6 +435,143 @@ var Transport = class {
   }
 };
 
+// src/filters.ts
+function activeQuery(active) {
+  return active === true ? "true" : void 0;
+}
+function filterByActive(rows, active) {
+  return active === false ? rows.filter((row) => !row.isActive) : rows;
+}
+
+// src/resources/composites.ts
+var Composites = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+   *  only archived ones; omit it for both. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/composites",
+      query: { active: activeQuery(params.active) }
+    });
+    return filterByActive(res.composites, params.active);
+  }
+  /** One composite's configuration. */
+  async get(id) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/composites/${encodeURIComponent(id)}`
+    });
+    return res.composite;
+  }
+  /** Create one. It starts active. Not retried on failure — a retry could
+   *  create a second row. */
+  async create(input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: "/api/v1/composites",
+      body: input
+    });
+    return res.composite;
+  }
+  /** PARTIAL update: only the fields you send change. `entitlements`, when
+   *  sent, is the complete new set. Renaming `refId` cuts live traffic over at
+   *  once — ship the new tag to your callers first. */
+  async update(id, input) {
+    const res = await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/composites/${encodeURIComponent(id)}`,
+      body: input
+    });
+    return res.composite;
+  }
+  /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+  async archive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/composites/${encodeURIComponent(id)}/archive`,
+      retry: true
+    });
+    return res.composite;
+  }
+  /** Bring an archived one back (`isActive` → true). Safe to retry. */
+  async unarchive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/composites/${encodeURIComponent(id)}/unarchive`,
+      retry: true
+    });
+    return res.composite;
+  }
+};
+
+// src/resources/credits.ts
+var Credits = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+   *  only archived ones; omit it for both. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/credits",
+      query: { active: activeQuery(params.active) }
+    });
+    return filterByActive(res.credits, params.active);
+  }
+  /** One credit's configuration. */
+  async get(id) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/credits/${encodeURIComponent(id)}`
+    });
+    return res.credit;
+  }
+  /** Create one. It starts active. Not retried on failure — a retry could
+   *  create a second row. */
+  async create(input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: "/api/v1/credits",
+      body: input
+    });
+    return res.credit;
+  }
+  /** PARTIAL update: only the fields you send change. Send `modelBundle` to
+   *  re-price; leave it out to keep the stored base price. */
+  async update(id, input) {
+    const res = await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/credits/${encodeURIComponent(id)}`,
+      body: input
+    });
+    return res.credit;
+  }
+  /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+  async archive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/credits/${encodeURIComponent(id)}/archive`,
+      retry: true
+    });
+    return res.credit;
+  }
+  /** Bring an archived one back (`isActive` → true). Safe to retry. */
+  async unarchive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/credits/${encodeURIComponent(id)}/unarchive`,
+      retry: true
+    });
+    return res.credit;
+  }
+};
+
 // src/idempotency.ts
 function newKey() {
   const c = globalThis.crypto;
@@ -662,7 +800,7 @@ var Customers = class {
    * Top up (positive `delta`) or draw down (negative `delta`) a customer's
    * wallet, in USD — allowed whatever the customer's plan. `remaining` is the
    * resulting USD balance. No `agentKey` — a customer has exactly one wallet.
-   * Pass `pool: "RESERVED"` to move the Reserved Wallet instead (then
+   * Pass `pool: "reserved"` to move the Reserved Wallet instead (then
    * `remaining` is its balance). `POST …/:id/wallet/adjust`.
    */
   adjustWallet(id, input) {
@@ -793,6 +931,71 @@ var Invoices = class {
   }
 };
 
+// src/resources/outcomes.ts
+var Outcomes = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+   *  only archived ones; omit it for both. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/outcomes",
+      query: { active: activeQuery(params.active) }
+    });
+    return filterByActive(res.outcomes, params.active);
+  }
+  /** One outcome's configuration, with every step in full. */
+  async get(id) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/outcomes/${encodeURIComponent(id)}`
+    });
+    return res.outcome;
+  }
+  /** Create one. It starts active. Not retried on failure — a retry could
+   *  create a second row. */
+  async create(input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: "/api/v1/outcomes",
+      body: input
+    });
+    return res.outcome;
+  }
+  /** PARTIAL update: only the fields you send change. Leave `steps` out to
+   *  leave the steps alone; send it and it is the complete list — pass each
+   *  existing step's `id` (or its same `agentKey`) to keep it. */
+  async update(id, input) {
+    const res = await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
+      body: input
+    });
+    return res.outcome;
+  }
+  /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+  async archive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/outcomes/${encodeURIComponent(id)}/archive`,
+      retry: true
+    });
+    return res.outcome;
+  }
+  /** Bring an archived one back (`isActive` → true). Safe to retry. */
+  async unarchive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/outcomes/${encodeURIComponent(id)}/unarchive`,
+      retry: true
+    });
+    return res.outcome;
+  }
+};
+
 // src/resources/payments.ts
 var Payments = class {
   constructor(transport) {
@@ -817,14 +1020,6 @@ var Payments = class {
   }
 };
 
-// src/filters.ts
-function activeQuery(active) {
-  return active === true ? "true" : void 0;
-}
-function filterByActive(rows, active) {
-  return active === false ? rows.filter((row) => !row.isActive) : rows;
-}
-
 // src/resources/plans.ts
 var Plans = class {
   constructor(transport) {
@@ -842,6 +1037,54 @@ var Plans = class {
     });
     return filterByActive(res.plans, params.active);
   }
+  /** One plan's configuration. */
+  async get(id) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/plans/${encodeURIComponent(id)}`
+    });
+    return res.plan;
+  }
+  /** Create a plan. It starts active. Not retried on failure — a retry could
+   *  create a second plan. */
+  async create(input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: "/api/v1/plans",
+      body: input
+    });
+    return res.plan;
+  }
+  /** PARTIAL update: only the fields you send change. `entitlements`, when
+   *  sent, is the complete new list — the list `get()` returned can be sent
+   *  back as it is. Changes apply to new purchases only. */
+  async update(id, input) {
+    const res = await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/plans/${encodeURIComponent(id)}`,
+      body: input
+    });
+    return res.plan;
+  }
+  /** Retire a plan (`isActive` → false): it can't be bought any more; customers
+   *  already on it are unaffected. Safe to retry. */
+  async archive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/plans/${encodeURIComponent(id)}/archive`,
+      retry: true
+    });
+    return res.plan;
+  }
+  /** Make an archived plan purchasable again (`isActive` → true). Safe to retry. */
+  async unarchive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/plans/${encodeURIComponent(id)}/unarchive`,
+      retry: true
+    });
+    return res.plan;
+  }
 };
 
 // src/resources/portal.ts
@@ -947,12 +1190,14 @@ function signalToWire(signal) {
   const body = {
     ...customerRefToWire(signal),
     // `usage` is required on all three model-priced kinds. input/output are
-    // always sent; `cacheTokens` only when provided (the server defaults 0).
+    // always sent; `cacheTokens` / `cacheWriteTokens` only when provided (the
+    // server defaults each to 0).
     usage: {
       model: signal.model,
       inputTokens: t.input,
       outputTokens: t.output,
-      ...t.cache != null ? { cacheTokens: t.cache } : {}
+      ...t.cache != null ? { cacheTokens: t.cache } : {},
+      ...t.cacheWrite != null ? { cacheWriteTokens: t.cacheWrite } : {}
     }
   };
   if (signal.member) body.member = signal.member;
@@ -1202,14 +1447,86 @@ var Signals = class {
   }
 };
 
+// src/resources/units.ts
+var Units = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List them. `{ active: true }` returns only active ones, `{ active: false }`
+   *  only archived ones; omit it for both. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/units",
+      query: { active: activeQuery(params.active) }
+    });
+    return filterByActive(res.units, params.active);
+  }
+  /** One unit's configuration. */
+  async get(id) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/units/${encodeURIComponent(id)}`
+    });
+    return res.unit;
+  }
+  /** Create one. It starts active. Not retried on failure — a retry could
+   *  create a second row. */
+  async create(input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: "/api/v1/units",
+      body: input
+    });
+    return res.unit;
+  }
+  /** PARTIAL update: only the fields you send change. `tiers`, when sent, is
+   *  the complete new tier list. */
+  async update(id, input) {
+    const res = await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/units/${encodeURIComponent(id)}`,
+      body: input
+    });
+    return res.unit;
+  }
+  /** Retire it (`isActive` → false). Nothing is deleted. Safe to retry. */
+  async archive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/units/${encodeURIComponent(id)}/archive`,
+      retry: true
+    });
+    return res.unit;
+  }
+  /** Bring an archived one back (`isActive` → true). Safe to retry. */
+  async unarchive(id) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/units/${encodeURIComponent(id)}/unarchive`,
+      retry: true
+    });
+    return res.unit;
+  }
+};
+
 // src/client.ts
 var ClockNext = class {
   /** Record usage signals (credit / wallet / outcome / unit) and read the usage log. */
   signals;
   /** Manage customers, their members, and balances. */
   customers;
-  /** List billing plans. */
+  /** Billing plans: list, get, create, update, archive, unarchive. */
   plans;
+  /** Credits: list, get, create, update, archive, unarchive (no delete). */
+  credits;
+  /** Outcomes: list, get, create, update, archive, unarchive (no delete). */
+  outcomes;
+  /** Units: list, get, create, update, archive, unarchive (no delete). */
+  units;
+  /** Composites: list, get, create, update, archive, unarchive (no delete). */
+  composites;
   /** Subscribe customers to plans (purchases). */
   purchases;
   /** Read invoices and mint hosted pay links. */
@@ -1232,6 +1549,10 @@ var ClockNext = class {
     this.signals = new Signals(transport, this.flusher, this.cfg);
     this.customers = new Customers(transport);
     this.plans = new Plans(transport);
+    this.credits = new Credits(transport);
+    this.outcomes = new Outcomes(transport);
+    this.units = new Units(transport);
+    this.composites = new Composites(transport);
     this.purchases = new Purchases(transport);
     this.invoices = new Invoices(transport);
     this.payments = new Payments(transport);