@frockbot/plugin-billing 0.3.38 → 0.3.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-billing",
-  "version": "0.3.38",
+  "version": "0.3.40",
   "private": false,
   "type": "module",
   "exports": {
@@ -23,11 +23,11 @@
     "typecheck": "vue-tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/client-core": "0.3.38",
-    "@frockbot/client-ui": "0.3.38",
-    "@frockbot/kernel-contracts": "0.3.38",
-    "@frockbot/plugin-flock": "0.3.38",
-    "@frockbot/plugin-shell": "0.3.38",
+    "@frockbot/client-core": "0.3.40",
+    "@frockbot/client-ui": "0.3.40",
+    "@frockbot/kernel-contracts": "0.3.40",
+    "@frockbot/plugin-flock": "0.3.40",
+    "@frockbot/plugin-shell": "0.3.40",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },

package/src/bot.test.ts

@@ -52,6 +52,81 @@ describe("usage projection", () => {
     ]);
   });
 
+  test("prices two short platform-model turns in cents, not dollars", () => {
+    /*
+     * The defect this pins. A Bot on the platform default runs `@frock/auto`,
+     * which was absent from the price table, so every Turn a User has ever had
+     * was priced at the unknown-model fallback of $10 per million input
+     * tokens. The token counts here are the real shape of a two-sentence Turn:
+     * the transport reports nothing, so the loop estimates from the normalized
+     * request, and that request carries the system prompt and every tool
+     * schema whatever the person typed. Two of them read as "$0.50".
+     */
+    const turnEvents = (turn: number, requestId: string): SessionEvent[] =>
+      [
+        {
+          type: "model/usage",
+          seq: turn * 10,
+          timestamp: `2026-09-05T0${turn}:00:00.000Z`,
+          turn,
+          step: 1,
+          requestId,
+          provider: "flock-ai",
+          model: "@frock/auto",
+          modelBinding: { connectionId: "flock-ai-ambient" },
+          inputTokens: 24_000,
+          outputTokens: 40,
+          cachedInputTokens: 0,
+          reasoningTokens: 0,
+          latencyMs: 1_200,
+          estimated: true,
+        },
+        {
+          type: "turn/end",
+          seq: turn * 10 + 1,
+          timestamp: `2026-09-05T0${turn}:00:01.000Z`,
+          turn,
+          outcome: "completed",
+        },
+      ] as SessionEvent[];
+
+    const entries = [
+      ...usageEntriesFromTurnV1({
+        botId: "bot-a",
+        runId: "run-a",
+        turn: 1,
+        events: turnEvents(1, "request-1"),
+      }),
+      ...usageEntriesFromTurnV1({
+        botId: "bot-a",
+        runId: "run-a",
+        turn: 2,
+        events: turnEvents(2, "request-2"),
+      }),
+    ];
+
+    // 24,000 input at $0.44/M plus 40 output at $1.32/M, per Turn.
+    expect(entries.map((entry) => entry.costMicros)).toEqual([10_613, 10_613]);
+    // Priced, not guessed: the total is two cents rather than fifty.
+    expect(entries.every((entry) => entry.unknownPrice)).toBe(false);
+    expect(entries.reduce((total, entry) => total + entry.costMicros, 0)).toBe(
+      21_226,
+    );
+    // The legacy spelling of the same model is the same price, not a fallback.
+    expect(
+      usageEntriesFromTurnV1({
+        botId: "bot-a",
+        runId: "run-b",
+        turn: 1,
+        events: turnEvents(1, "request-3").map((event) =>
+          event.type === "model/usage"
+            ? { ...event, model: "@flock/auto" }
+            : event,
+        ) as SessionEvent[],
+      })[0],
+    ).toMatchObject({ costMicros: 10_613, unknownPrice: false });
+  });
+
   test("keeps entries until an idempotent sink accepts them", async () => {
     const values = new Map<string, unknown>();
     const outbox = new UsageOutboxV1({

package/src/client/format.ts

@@ -1,10 +1,28 @@
+/** One cent, in the micro-dollars the ledger records. */
+const CENT_IN_MICROS_V1 = 10_000;
+
+const USD_V1 = new Intl.NumberFormat("en", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+});
+
+/**
+ * Money, to the cent — except when rounding to the cent would say nothing
+ * happened.
+ *
+ * The ledger counts micro-dollars and a short Turn costs a few hundred of
+ * them, so two cents' worth of conversation used to render as "$0.00" beside
+ * a list of Bots that had plainly run. "<$0.01" is the honest reading of a
+ * real, sub-cent amount; exactly zero still reads as zero, because that is a
+ * different fact. Totals are never floored to build a bigger number: every
+ * figure here is the sum of what was recorded.
+ */
 export function formatCostV1(costMicros: number): string {
-  return new Intl.NumberFormat("en", {
-    style: "currency",
-    currency: "USD",
-    minimumFractionDigits: 2,
-    maximumFractionDigits: 2,
-  }).format(costMicros / 1_000_000);
+  if (costMicros > 0 && costMicros < CENT_IN_MICROS_V1) return "<$0.01";
+  if (costMicros < 0 && costMicros > -CENT_IN_MICROS_V1) return ">-$0.01";
+  return USD_V1.format(costMicros / 1_000_000);
 }
 
 export function shortModelNameV1(value: string): string {

package/src/client/index.test.ts

@@ -83,6 +83,17 @@ describe("billing client contribution", () => {
     expect(mounted.state.value.report?.bots[0]?.id).toBe("bot-a");
   });
 
+  test("says a real sub-cent amount rather than rounding it to nothing", () => {
+    // Two short platform-model Turns: real spend, well under a cent.
+    expect(formatCostV1(21_226)).toBe("$0.02");
+    expect(formatCostV1(10_613)).toBe("$0.01");
+    expect(formatCostV1(300)).toBe("<$0.01");
+    expect(formatCostV1(9_999)).toBe("<$0.01");
+    // Nothing spent is a different fact from a little spent.
+    expect(formatCostV1(0)).toBe("$0.00");
+    expect(formatCostV1(10_000)).toBe("$0.01");
+  });
+
   test("formats dollars and compact model names for the rendered view", () => {
     expect(formatCostV1(1_250_000)).toBe("$1.25");
     expect(shortModelNameV1("ollama-cloud/glm-5.3-flash:cloud")).toBe(

package/src/pricing.ts

@@ -50,6 +50,25 @@ export const MODEL_PRICE_TABLE_V1: readonly ModelPriceV1[] = [
     outputUsdPerMillion: 1.32,
     sourceUrl: CLOUDFLARE_SOURCE,
   },
+  /*
+   * Auto is what almost every Bot runs on, and it was absent from this table:
+   * every platform-model Turn was priced at the unknown-model fallback, which
+   * is $10/$50 per million — twenty-three times what the model it routes to
+   * actually costs. Two short Turns read as fifty cents.
+   *
+   * Auto is a Cloudflare AI Gateway dynamic route over Frock AI's text
+   * models, and Frock AI publishes exactly one, so the route's price is that
+   * model's price. A second text model would make this an approximation and
+   * the honest fix then is to record the model the route chose.
+   */
+  {
+    provider: "flock-ai",
+    model: "@frock/auto",
+    inputUsdPerMillion: 0.44,
+    cachedInputUsdPerMillion: 0.014,
+    outputUsdPerMillion: 1.32,
+    sourceUrl: CLOUDFLARE_SOURCE,
+  },
   ...[
     ["gpt-6-astra", 10, 1, 50],
     ["gpt-5.6", 4, 0.4, 20],