Merge pull request #5379 from nodetool-ai/claude/cost-estimation-panel-review-xj5h9c

Author: georgi

packages/execution/src/service/workflow-run.ts

@@ -559,6 +559,8 @@ export async function runWorkflow(
         // This path builds its own runner instead of going through
         // `ExecutionSession`, so it has to attach the spend ledger itself.
         // No detach: the listener lives on this context and dies with it.
+        // No `projectId`/`documentId` either — a run request names a workflow
+        // and a user, and nothing on this path carries project attribution.
         attachRunCostLedger(executionContext, {
           userId,
           workflowId,

packages/execution/src/session.ts

@@ -80,6 +80,9 @@ export class ExecutionSession {
     // reads. Attached here, at the one seam all surfaces share, so image and
     // video spend is recorded whether the run came from the CLI, the debug
     // harness, an app, or the websocket server.
+    // No `projectId`/`documentId`: a session is constructed from a graph and a
+    // job id, and no host passes project attribution down to it. The rows carry
+    // a null rather than being attributed to the loose bucket.
     const detachLedger = init.recordCosts
       ? attachRunCostLedger(init.context, {
           userId: init.userId,

packages/fal-codegen/src/fal-pricing-fetch.ts

@@ -61,7 +61,10 @@ async function fetchBatchOnce(
       for (const row of json.prices ?? []) {
         out[row.endpoint_id] = {
           unit_price: row.unit_price,
-          billing_unit: row.unit,
+          // FAL's API pads some unit strings with trailing whitespace
+          // ("1000 characters ") and leaves others empty; trim rather than
+          // ship either verbatim.
+          billing_unit: row.unit.trim(),
           currency: row.currency
         };
       }

packages/fal-codegen/tests/fal-pricing-fetch.test.ts

@@ -57,6 +57,29 @@ describe("fetchFalPricing", () => {
     });
   });
 
+  it("trims whitespace FAL pads the billing unit with", async () => {
+    vi.stubGlobal(
+      "fetch",
+      makeFetchMock((ids) => ({
+        ok: true,
+        status: 200,
+        jsonBody: {
+          prices: ids.map((id) => ({
+            endpoint_id: id,
+            unit_price: 0.02,
+            unit: "1000 characters ",
+            currency: "USD"
+          }))
+        }
+      }))
+    );
+
+    const out = await fetchFalPricing(["fal-ai/minimax/speech-02-turbo"], "key");
+    expect(out["fal-ai/minimax/speech-02-turbo"].billing_unit).toBe(
+      "1000 characters"
+    );
+  });
+
   it("bisects on 404 so one unknown endpoint does not poison the batch", async () => {
     const unknown = new Set(["fal-ai/dead"]);
     vi.stubGlobal(

packages/model-pricing/README.md

@@ -16,16 +16,33 @@ getModelUnitPrice({ id: "fal-ai/flux/schnell", provider: "fal_ai" });
 
 Looked up in order, first hit wins:
 
-1. **FAL** — `@nodetool-ai/fal-nodes/unit-pricing-catalog`, keyed by `endpoint_id`.
-2. **kie** — `@nodetool-ai/kie-nodes/unit-pricing-catalog`, keyed by `model_id`,
+1. **GenSpend, when its entry is parameter-priceable** —
+   `src/generated/genspend-pricing.json`, keyed `<provider_id>:<model_id>`. An
+   entry qualifies when it publishes a grid (a resolution ladder, a duration
+   rung, an audio axis, an input surcharge) or bills per second. Those rows say
+   what a *rung* costs, so they price the run rather than one unit of it.
+2. **FAL** — `@nodetool-ai/fal-nodes/unit-pricing-catalog`, keyed by `endpoint_id`.
+3. **kie** — `@nodetool-ai/kie-nodes/unit-pricing-catalog`, keyed by `model_id`,
    using the USD conversion (a raw credit figure has no fixed USD value).
-3. **GenSpend** — `src/generated/genspend-pricing.json`, keyed
-   `<provider_id>:<model_id>`.
-
-FAL and kie come from the providers themselves, so they stay ahead of GenSpend.
-GenSpend covers every other provider NodeTool can run and GenSpend tracks —
-Replicate, AtlasCloud, Together, Gemini, OpenAI, MiniMax, ElevenLabs, xAI — plus
-any FAL or kie model their own catalogs predate.
+4. **GenSpend's flat scalar** — one number per generation, nothing to narrow.
+
+FAL and kie come from the providers themselves, but each carries a single scalar
+per endpoint, and for the 260 FAL rows billed per second that scalar is a rate:
+reported as the price of a run it understated a 4-second clip by 40×. So a
+published GenSpend grid wins, and a FAL/kie scalar is converted here — multiplied
+by the duration or output size the node states, and declined outright for a unit
+with no fixed value per run (credits) or a rate the node states nothing about
+(compute seconds, training steps).
+
+GenSpend covers every other provider it tracks and NodeTool can run — today
+that is Replicate, AtlasCloud, Together, Gemini, OpenAI, MiniMax, and
+ElevenLabs — plus any FAL or kie model their own catalogs predate. xAI is wired
+into `scripts/genspend/match.mjs`'s `PROVIDER_IDS_BY_GENSPEND_SLUG`, but the
+shipped catalog holds no `xai:` entries: GenSpend's own catalog has nothing to
+match against that slug. Topaz, Reve, Aki, Meshy, and Rodin are enumerated by
+the sync's model inventory (`scripts/genspend/inventory.mjs`) but are not yet
+in `PROVIDER_IDS_BY_GENSPEND_SLUG`, so none of the five has priced entries
+either.
 
 All three are imported as modules, not read off disk, so the estimate works
 identically in the browser bundle and inside the packaged Electron backend (no

packages/model-pricing/src/genspend-calc.ts

@@ -51,6 +51,10 @@ export interface ModelParamPrice extends ModelUnitPricingLike {
   warnings?: string[];
   /** Set instead of a price when we refuse to extrapolate. */
   declined?: string;
+  /** The duration the figure was billed for, when one applied. */
+  seconds?: number;
+  /** The rung the figure was billed at, in the catalog's own spelling. */
+  resolution?: string;
 }
 
 /**
@@ -104,10 +108,75 @@ export function normalizeResolution(value: string | undefined): string | null {
 
 const PER_SECOND_CLASSES = new Set(["per-video-second", "per-audio-second"]);
 
-const money = (usd: number): string =>
-  usd >= 0.01
-    ? `$${usd.toFixed(3).replace(/0+$/, "").replace(/\.$/, "")}`
-    : `$${usd}`;
+/**
+ * The megapixel rungs image grids are published at. `1K` is GenSpend's name for
+ * a one-megapixel deliverable, which `normalizeResolution` folds to `1MP`.
+ */
+const MEGAPIXEL_TIERS: Array<{ megapixels: number; tier: string }> = [
+  { megapixels: 0.25, tier: "512×512" },
+  { megapixels: 1, tier: "1MP" },
+  { megapixels: 4, tier: "2K" },
+  { megapixels: 16, tier: "4K" }
+];
+
+/** The rung a megapixel count sits closest to, inside a 1.5× band. */
+function tierForMegapixels(megapixels: number): string | null {
+  if (!Number.isFinite(megapixels) || megapixels <= 0) return null;
+  let best = MEGAPIXEL_TIERS[0];
+  let bestRatio = Infinity;
+  for (const candidate of MEGAPIXEL_TIERS) {
+    const ratio =
+      megapixels > candidate.megapixels
+        ? megapixels / candidate.megapixels
+        : candidate.megapixels / megapixels;
+    if (ratio < bestRatio) {
+      bestRatio = ratio;
+      best = candidate;
+    }
+  }
+  return bestRatio <= 1.5 ? best.tier : null;
+}
+
+const trimZeros = (text: string): string =>
+  text.includes(".") ? text.replace(/0+$/, "").replace(/\.$/, "") : text;
+
+/**
+ * A price as text. Sub-cent figures get as many decimal places as they need:
+ * `String(3e-7)` is `3e-7`, and a breakdown reading "$3e-7/s" is unreadable.
+ */
+export const formatUsd = (usd: number): string => {
+  if (!Number.isFinite(usd)) return "$0";
+  if (usd >= 0.01) return `$${trimZeros(usd.toFixed(3))}`;
+  if (usd <= 0) return "$0";
+  const places = Math.min(12, Math.ceil(-Math.log10(usd)) + 2);
+  return `$${trimZeros(usd.toFixed(places))}`;
+};
+
+const money = formatUsd;
+
+/**
+ * Whether the catalog can price this entry off stated parameters — a published
+ * grid, a per-second class the duration multiplies, or an input surcharge.
+ * A flat per-generation entry with none of those answers the same number the
+ * provider catalogs carry, so nothing is gained by routing it here.
+ */
+export function isParameterPriceable(entry: GenspendPrice): boolean {
+  const rows = entry.variants ?? [];
+  if (
+    rows.some(
+      (row) =>
+        row.resolution !== undefined ||
+        row.duration_seconds !== undefined ||
+        row.with_audio !== undefined ||
+        row.tier !== undefined ||
+        row.video_input !== undefined
+    )
+  ) {
+    return true;
+  }
+  if (PER_SECOND_CLASSES.has(entry.unit_class)) return true;
+  return (entry.surcharges ?? []).length > 0;
+}
 
 /** The shortest duration the model is receipted for, or 1 s when unbounded. */
 function shortestClipSecond(clip: GenspendPrice["clip_seconds"]): number {
@@ -232,7 +301,7 @@ export function priceGenspendEntry(
   const assumptions: string[] = [];
   const warnings: string[] = [];
 
-  const resolution =
+  let resolution =
     params.resolution === undefined || params.resolution === null
       ? null
       : normalizeResolution(params.resolution);
@@ -242,6 +311,20 @@ export function priceGenspendEntry(
     );
   }
 
+  // An image grid is laddered by megapixels, and a node that states a pixel
+  // size states that count without naming a rung. Only read it when the node
+  // named no resolution and the grid really is laddered.
+  if (resolution === null && params.megapixels !== undefined) {
+    const laddered = (entry.variants ?? []).some((row) => row.resolution);
+    const derived = laddered ? tierForMegapixels(params.megapixels) : null;
+    if (derived) {
+      resolution = derived;
+      assumptions.push(
+        `priced at the ${derived} rung, from the node's ${params.megapixels} MP output size`
+      );
+    }
+  }
+
   const askedSeconds = params.seconds ?? 0;
   const statedSeconds =
     Number.isFinite(askedSeconds) && askedSeconds > 0 ? askedSeconds : null;
@@ -368,6 +451,13 @@ export function priceGenspendEntry(
     source: "bundle",
     breakdown
   };
+  if (seconds !== null) {
+    price.seconds = seconds;
+  }
+  const rungResolution = row?.resolution ?? (resolution ?? undefined);
+  if (rungResolution !== undefined) {
+    price.resolution = rungResolution;
+  }
   if (assumptions.length > 0) {
     price.assumptions = assumptions;
   }