threadwire 0.1.28 → 0.1.30

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+- Fix `threadwire capacity --provider kimi` for the current Kimi usages API:
+  quota objects may provide either `used` or `remaining` alongside `limit` and
+  `resetTime`. Threadwire derives the omitted value while retaining strict
+  decimal, bounds, and consistency validation.
+
+- Upgrade `release-patch` from 1.0.3 to 1.0.5 so npm registry visibility is
+  checked for up to 10 attempts over 150 seconds without repeating the publish.
+
 - Add an optional loopback-only TensorBuzz-to-Telegram queue bridge. It verifies
   bounded raw-body HMAC-SHA-256 requests before JSON parsing, admits a closed
   `build_group.completed` schema, builds a bounded canonical `/queue` prompt,

package/docs/capacity-admission.md

@@ -80,11 +80,13 @@ pin before relying on it.
   to `short`; every returned window is validated (`window.duration` in
   `TIME_UNIT_MINUTE`s, `detail` quota) but intermediate windows are ignored,
   and normalization fails closed if the long duration would not exceed the
-  short. Quota fields are strict non-negative decimal strings validated with
-  `used + remaining === limit` and a positive limit, reset times must be
-  bounded ISO-8601, and remaining percent is floored so normalization never
-  overstates capacity. Unrelated top-level response fields are neither read
-  nor propagated into output or errors.
+  short. Quota fields are strict non-negative decimal strings with a positive
+  limit. Kimi may provide either `used` or `remaining` (or both); Threadwire
+  derives the omitted side from `limit` and, when both are present, requires
+  `used + remaining === limit`. Reset times must be bounded ISO-8601, and
+  remaining percent is floored so normalization never overstates capacity.
+  Unrelated top-level response fields are neither read nor propagated into
+  output or errors.
 
 Both probes are bounded (capped lines/bytes, single absolute timeout) and fail
 closed on any shape drift: exact keys within the parsed projection, forced

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadwire",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "Stream Codex, Claude, Kimi Code, and OpenCode worker progress to an explicit Telegram destination",
   "keywords": [
     "ai-agent",
@@ -68,7 +68,7 @@
     "eslint-plugin-jsdoc": "63.0.0",
     "fallow": "3.2.0",
     "globals": "17.0.0",
-    "release-patch": "1.0.3",
+    "release-patch": "1.0.5",
     "typescript": "6.0.2"
   },
   "license": "AGPL-3.0-only",

package/src/provider-capacity.js

@@ -199,21 +199,25 @@ function kimiLimitsWindow(value) {
 
 /**
  * Validate one quota object (`usage` or `detail`): exact keys, strict
- * non-negative decimal-string integers with `used + remaining === limit`, a
- * positive limit, and a bounded ISO-8601 reset time.
+ * non-negative decimal-string integers with either `used` or `remaining` (or
+ * both), a positive limit, and a bounded ISO-8601 reset time. Derive the
+ * omitted side from the limit and require equality when both are present.
  * @param {unknown} value
  * @param {number} windowDurationSeconds
  * @returns {CapacityWindow}
  */
 function kimiQuotaWindow(value, windowDurationSeconds) {
-  if (!isRecord(value) || !exactKeys(value, ["limit", "used", "remaining", "resetTime"])) {
+  if (!isRecord(value) || !kimiQuotaKeys(value)) {
     throw kimiProtocolError()
   }
   const limit = quotaValue(value.limit)
-  const used = quotaValue(value.used)
-  const remaining = quotaValue(value.remaining)
-  if (limit < 1 || used + remaining !== limit) throw kimiProtocolError()
-  const remainingPercent = Number((BigInt(remaining) * 100n) / BigInt(limit))
+  const used = value.used === undefined ? null : quotaValue(value.used)
+  const remaining = value.remaining === undefined ? null : quotaValue(value.remaining)
+  if (limit < 1 || (used !== null && used > limit) || (remaining !== null && remaining > limit)
+    || (used !== null && remaining !== null && used + remaining !== limit)) throw kimiProtocolError()
+  if (used === null && remaining === null) throw kimiProtocolError()
+  const normalizedRemaining = remaining === null ? limit - /** @type {number} */ (used) : remaining
+  const remainingPercent = Number((BigInt(normalizedRemaining) * 100n) / BigInt(limit))
   return {
     usedPercent: 100 - remainingPercent,
     remainingPercent,
@@ -222,6 +226,14 @@ function kimiQuotaWindow(value, windowDurationSeconds) {
   }
 }
 
+/** @param {Record<string, unknown>} value @returns {boolean} */
+function kimiQuotaKeys(value) {
+  const keys = Object.keys(value).sort()
+  return exactKeys(value, ["limit", "used", "remaining", "resetTime"])
+    || (keys.length === 3 && keys.includes("limit") && keys.includes("resetTime")
+      && (keys.includes("used") || keys.includes("remaining")))
+}
+
 /**
  * A strict non-negative decimal-string integer, digit-bounded so the sum of
  * two values always stays a safe integer.