@limitry/sdk 1.0.0-rc.6 → 1.0.0-rc.7

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 What changed in the Limitry TypeScript SDK (`@limitry/sdk`). Generated from the source on each release; newest first.
 
+## 1.0.0-rc.7 (2026-10-19)
+
+### Added
+
+- A refused check's `reason` has a `message`: the refusal in one sentence,
+  such as "Refused by AI budget: 3 cents left, resets
+  2026-11-01T00:00:00.000Z. Try again in 3600 s." `LimitExceeded` and
+  `limitry check` show it as the API writes it, so every client says the
+  same. Branch on `allowed` and `reason.code`, never on the message.
+
+### Fixed
+
+- - `held.cost()` refuses a cost the API can't commit (not a whole number
+    from 0 to 1,000,000,000): TypeScript throws `RangeError`, Python raises
+    `ValueError`, in your code. Before, the commit failed silently after
+    the work and its usage was never counted.
+  - TypeScript's `held.extend()` throws the API's error, such as for an
+    expired hold, as Python's already did. Both send the `ttlSeconds` you
+    give as it is, so `0` is refused rather than read as the default.
+  - Python checks, commits and releases now retry exactly as TypeScript's
+    do: a network error, `408`, `429` or `5xx`, at most twice, all within
+    the check's `timeout` (1.5 s) or 5 s for a settle. `standing()` retries
+    too, and reports an error answer that isn't JSON.
+  - `limitry check` and `limitry sync` refuse `--workspace` with an API key,
+    as every other command does, instead of ignoring it.
+
 ## 1.0.0-rc.6 (2026-10-19)
 
 ### Changed

package/dist/index.d.ts

@@ -79,6 +79,7 @@ declare function createBaseClient(options: ClientOptions): import("openapi-fetch
             reason: {
                 code: "limit_exceeded" | "too_many_reservations";
                 limit: string | null;
+                message: string;
             } | null;
             remaining: components["schemas"]["CheckRemaining"][];
             reservation?: {

package/dist/product/limits.d.ts

@@ -70,9 +70,18 @@ export type HoldRequest = {
     ttlSeconds?: number;
 };
 export type Held = {
-    /** The cost actually used — committed when the work returns. Default: the estimate. */
+    /**
+     * The cost actually used — committed when the work returns. Default: the
+     * estimate. A whole number from 0 to 1,000,000,000, as the API commits:
+     * anything else throws a RangeError here, in your code, rather than a
+     * commit the API refuses after the work (whose usage would go uncounted).
+     */
     cost(units: number): void;
-    /** Keep the hold for longer work: it expires `ttlSeconds` from now. */
+    /**
+     * Keep the hold for longer work: it expires `ttlSeconds` from now
+     * (default 300, 1 to 3600). Throws the API's error, such as for a hold
+     * that already expired.
+     */
     extend(ttlSeconds?: number): Promise<void>;
 };
 /** Not allowed: a limit is used up — or Limitry is unreachable and a limit fails closed. */

package/dist/product/limits.js

@@ -1,18 +1,11 @@
-/**
- * A refusal in the CLI's words, naming the limit rather than its id:
- * "Refused by AI replies per day: 0 replies left, resets …. Try again in
- * 42 s."
- */
-function refusal(decision) {
-    const id = decision?.reason?.limit ?? null;
-    const limit = decision?.remaining.find((r) => r.limit === id);
-    const retry = decision?.retryAfterSeconds != null
-        ? ` Try again in ${decision.retryAfterSeconds} s.`
-        : "";
-    if (!limit)
-        return `Refused: limit ${id ?? "(unknown)"} is used up.${retry}`;
-    const resets = limit.resetsAt ? `, resets ${limit.resetsAt}` : "";
-    return `Refused by ${limit.name}: ${limit.remaining} ${limit.unit} left${resets}.${retry}`;
+import { apiErrorFrom } from "../errors.js";
+/** The largest cost a commit takes. */
+const MAX_COST = 1_000_000_000;
+function checkedCost(units) {
+    if (!Number.isInteger(units) || units < 0 || units > MAX_COST) {
+        throw new RangeError(`held.cost(${units}): the cost must be a whole number from 0 to ${MAX_COST}`);
+    }
+    return units;
 }
 /** Not allowed: a limit is used up — or Limitry is unreachable and a limit fails closed. */
 export class LimitExceeded extends Error {
@@ -25,9 +18,8 @@ export class LimitExceeded extends Error {
         const reason = decision?.reason?.code ?? "unavailable";
         super(reason === "unavailable"
             ? "Limitry could not be reached and a limit denies when unreachable"
-            : reason === "too_many_reservations"
-                ? "Too many open reservations for this subject"
-                : refusal(decision));
+            : // The API's own sentence (reason.message), one wording everywhere.
+                (decision?.reason?.message ?? "Refused"));
         this.name = "LimitExceeded";
         this.reason = reason;
         this.limit = decision?.reason?.limit ?? null;
@@ -201,7 +193,12 @@ export function createLimits(client, options = {}) {
             };
             const idempotencyKey = crypto.randomUUID();
             const decision = await check(body, idempotencyKey);
-            const unmetered = { cost: () => { }, extend: async () => { } };
+            const unmetered = {
+                // Checked even unmetered: the mistake shows whether or not
+                // Limitry answered.
+                cost: (units) => void checkedCost(units),
+                extend: async () => { },
+            };
             if (decision === UNREACHABLE || decision === TIMED_OUT) {
                 const unheard = () => decision === TIMED_OUT
                     ? releaseUnheard(body, idempotencyKey)
@@ -225,14 +222,17 @@ export function createLimits(client, options = {}) {
             let used = estimate;
             const held = {
                 cost(units) {
-                    used = units;
+                    used = checkedCost(units);
                 },
                 async extend(ttlSeconds) {
-                    await client.POST("/reservations/{reservationId}/extend", {
+                    // Passed as given: the API refuses a bad one (0, past 3600).
+                    const { error, response } = await client.POST("/reservations/{reservationId}/extend", {
                         params: { path: { reservationId: id } },
-                        body: ttlSeconds ? { ttlSeconds } : {},
+                        body: ttlSeconds === undefined ? {} : { ttlSeconds },
                         signal: AbortSignal.timeout(timeoutMs),
                     });
+                    if (error !== undefined)
+                        throw apiErrorFrom(error, response);
                 },
             };
             let result;

package/dist/resources.gen.d.ts

@@ -8,6 +8,7 @@ export declare function resources(client: RawClient): {
             reason: {
                 code: "limit_exceeded" | "too_many_reservations";
                 limit: string | null;
+                message: string;
             } | null;
             remaining: import("./v1.gen.ts").components["schemas"]["CheckRemaining"][];
             reservation?: {

package/dist/v1.gen.d.ts

@@ -778,6 +778,11 @@ export interface components {
                 code: "limit_exceeded" | "too_many_reservations";
                 /** @example lim_3f0c… */
                 limit: string | null;
+                /**
+                 * @description The refusal in one sentence, for people and logs: show it, never parse it (its wording may change). Branch on `allowed` and `code`.
+                 * @example Refused by AI replies per day: 0 replies left, resets 2026-11-01T00:00:00.000Z. Try again in 3600 s.
+                 */
+                message: string;
             } | null;
             /** @description Every limit that applied, and what is left in its window. */
             remaining: components["schemas"]["CheckRemaining"][];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limitry/sdk",
-  "version": "1.0.0-rc.6",
+  "version": "1.0.0-rc.7",
   "description": "Limitry API client",
   "type": "module",
   "exports": {