tines 0.0.179 → 0.0.182

package/dist/index.js

@@ -3529,10 +3529,21 @@ function runDurationLabel(run, now = Date.now()) {
 function runCostLabel(run) {
   const usage = run.usage;
   if (!usage) return null;
-  if (usage.cost_usd !== void 0) return `$${usage.cost_usd.toFixed(2)}`;
-  if (usage.cost_source === "none") return "unreported";
+  if (usage.cost_usd !== void 0) {
+    const dollars = usage.cost_usd === 0 ? "$0" : usage.cost_usd < 0.01 ? "<$0.01" : `$${usage.cost_usd.toFixed(2)}`;
+    const source = usage.cost_source === "provider" ? "Reported" : usage.cost_source === "priced" ? "Estimated" : "Recorded";
+    return `${dollars} ${source}`;
+  }
+  if (usage.pricing?.status === "unpriced") return "Unpriced";
+  if (usage.cost_source === "none") return "Unreported";
+  const measured = [
+    usage.input_tokens,
+    usage.output_tokens,
+    usage.cache_read_tokens,
+    usage.cache_write_tokens
+  ].some((value) => value !== void 0);
   const tokens = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0) + (usage.cache_read_tokens ?? 0) + (usage.cache_write_tokens ?? 0);
-  return tokens > 0 ? `${tokens.toLocaleString()} tok` : null;
+  return tokens > 0 ? `${tokens.toLocaleString()} tok` : measured ? "Unpriced" : null;
 }
 function utilizationLabel(quota, activeRuns, stateName = (id2) => id2) {
   if (quota.type === "global_cap") {
@@ -4177,6 +4188,14 @@ function createApiClient(options) {
       "/api/v1/library/prepare",
       body
     ),
+    installWorkflowPackage: (body) => request(
+      "POST",
+      "/api/v1/library/install",
+      body
+    ),
+    getWorkflowPackageReceipt: (planId) => get(
+      `/api/v1/library/installs/${encodeURIComponent(planId)}`
+    ),
     validateLibrary: (body) => request(
       "POST",
       "/api/v1/library/validate",
@@ -7591,7 +7610,16 @@ function validProviderSessionId(value) {
   return typeof value === "string" && value.length >= 1 && value.length <= 255 && Boolean(value.trim()) && !/[\x00-\x1f\x7f]/.test(value);
 }
 function copySummary(value) {
-  return { ...value, ...value.usage ? { usage: { ...value.usage } } : {} };
+  return {
+    ...value,
+    ...value.usage ? { usage: { ...value.usage } } : {},
+    ...value.pricingEvidence ? {
+      pricingEvidence: {
+        ...value.pricingEvidence,
+        ...value.pricingEvidence.raw_usage ? { raw_usage: { ...value.pricingEvidence.raw_usage } } : {}
+      }
+    } : {}
+  };
 }
 
 // src/daemon/claude-stream.ts
@@ -7792,8 +7820,24 @@ var CodexStreamRenderer = class {
   }
   emit;
   pending = "";
-  collected = {};
+  collected = {
+    pricingEvidence: {
+      version: 1,
+      harness: "codex",
+      model: null,
+      identity_source: "launch_argument",
+      usage_scope: "thread_total",
+      session_mode: "cold",
+      normalization: "codex-jsonl-v1",
+      model_rerouted: false,
+      measurement_status: "missing",
+      terminal_snapshots: 0
+    }
+  };
   finished = false;
+  threadId;
+  stickyStatus;
+  awaitingTerminal = false;
   write(chunk) {
     this.pending += chunk;
     let nl = this.pending.indexOf("\n");
@@ -7831,24 +7875,75 @@ var CodexStreamRenderer = class {
 `);
   }
   collect(event) {
-    if (event.type === "thread.started" && !this.collected.providerSessionId && validProviderSessionId(event.thread_id)) {
-      this.collected.providerSessionId = event.thread_id;
+    if (event.type === "thread.started" && validProviderSessionId(event.thread_id)) {
+      if (this.threadId && this.threadId !== event.thread_id)
+        this.stickyStatus = "multiple_threads";
+      this.threadId ??= event.thread_id;
+      this.collected.providerSessionId ??= event.thread_id;
+    }
+    if (event.type === "turn.started") {
+      this.awaitingTerminal = true;
+      this.updateEvidence("incomplete_attempt");
+      return;
+    }
+    if (event.type === "item.completed") {
+      const item = object2(event.item);
+      if (item?.type === "error" && /^model rerouted:/.test(text3(item.message) ?? "")) {
+        this.updateEvidence(void 0, true);
+      }
+      return;
     }
     if (event.type !== "turn.completed") return;
+    this.awaitingTerminal = false;
     const raw = object2(event.usage);
-    if (!raw) return;
-    const totalInput = validMetric(raw.input_tokens) ? raw.input_tokens : void 0;
-    const rawCached = validMetric(raw.cached_input_tokens) ? raw.cached_input_tokens : void 0;
-    const output = validMetric(raw.output_tokens) ? raw.output_tokens : void 0;
-    if (totalInput === void 0 && rawCached === void 0 && output === void 0) return;
+    const previous = this.collected.pricingEvidence?.raw_usage;
+    const metric = (value) => Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+    const totalInput = metric(raw?.input_tokens);
+    const rawCached = metric(raw?.cached_input_tokens);
+    const rawWrite = metric(raw?.cache_write_input_tokens);
+    const output = metric(raw?.output_tokens);
+    const rawUsage = {
+      ...totalInput !== void 0 ? { input_tokens: totalInput } : {},
+      ...rawCached !== void 0 ? { cached_input_tokens: rawCached } : {},
+      ...rawWrite !== void 0 ? { cache_write_input_tokens: rawWrite } : {},
+      ...output !== void 0 ? { output_tokens: output } : {}
+    };
+    const supplied = raw ? ["input_tokens", "cached_input_tokens", "cache_write_input_tokens", "output_tokens"].filter(
+      (key) => raw[key] !== void 0
+    ).length : 0;
+    const complete = supplied === 4 && Object.keys(rawUsage).length === 4 && rawCached + rawWrite <= totalInput;
+    const previousInput = previous ? metric(previous.input_tokens) !== void 0 && metric(previous.cached_input_tokens) !== void 0 && metric(previous.cache_write_input_tokens) !== void 0 ? previous.input_tokens - previous.cached_input_tokens - previous.cache_write_input_tokens : void 0 : void 0;
+    const input = complete ? totalInput - rawCached - rawWrite : void 0;
+    let status = complete ? "complete" : supplied < 4 ? "missing" : "invalid";
+    if (complete && previous && ["input_tokens", "cached_input_tokens", "cache_write_input_tokens", "output_tokens"].some(
+      (key) => rawUsage[key] < previous[key]
+    ) || input !== void 0 && previousInput !== void 0 && input < previousInput) {
+      this.stickyStatus = "nonmonotonic";
+    }
+    status = this.stickyStatus ?? status;
     const usage = {};
-    if (totalInput !== void 0) {
-      const cached = rawCached === void 0 ? void 0 : Math.min(rawCached, totalInput);
-      usage.input_tokens = totalInput - (cached ?? 0);
-      if (cached !== void 0) usage.cache_read_tokens = cached;
-    } else if (rawCached !== void 0) usage.cache_read_tokens = rawCached;
+    if (complete) usage.input_tokens = input;
+    if (rawCached !== void 0) usage.cache_read_tokens = rawCached;
+    if (rawWrite !== void 0) usage.cache_write_tokens = rawWrite;
     if (output !== void 0) usage.output_tokens = output;
     this.collected.usage = usage;
+    this.updateEvidence(status, void 0, rawUsage);
+  }
+  updateEvidence(status, rerouted, rawUsage) {
+    const old = this.collected.pricingEvidence;
+    this.collected.pricingEvidence = {
+      version: 1,
+      harness: "codex",
+      model: null,
+      identity_source: "launch_argument",
+      usage_scope: "thread_total",
+      session_mode: "cold",
+      normalization: "codex-jsonl-v1",
+      ...rawUsage ? { raw_usage: rawUsage } : old?.raw_usage ? { raw_usage: old.raw_usage } : {},
+      model_rerouted: rerouted || old?.model_rerouted || false,
+      measurement_status: this.stickyStatus ?? status ?? old?.measurement_status ?? (this.awaitingTerminal ? "incomplete_attempt" : "missing"),
+      terminal_snapshots: (old?.terminal_snapshots ?? 0) + (rawUsage ? 1 : 0)
+    };
   }
 };
 
@@ -8731,6 +8826,14 @@ async function runDaemon(opts) {
           ...error ? { error } : {},
           ...judgment,
           usage: summary?.usage ?? { cost_source: "none" },
+          ...summary?.pricingEvidence ? {
+            pricing_evidence: {
+              ...summary.pricingEvidence,
+              model: run.pricingModel ?? null,
+              session_mode: run.pricingSessionMode ?? "cold",
+              daemon_version: DAEMON_VERSION
+            }
+          } : {},
           ...summary?.providerSessionId ? { provider_session_id: summary.providerSessionId } : {},
           ...summary?.numTurns !== void 0 ? { turn_count: summary.numTurns } : {},
           // The whole conversation's turns, which for a resumed run is
@@ -8908,6 +9011,10 @@ async function runDaemon(opts) {
         { harness: opts.harness, command: opts.command },
         harnessInput
       );
+      if (opts.harness === "codex") {
+        run.pricingModel = harnessInput.model;
+        run.pricingSessionMode = resume ? "resumed" : "cold";
+      }
       run.batcher.append(
         formatLaunchBanner(invocation, harnessInput, {
           harness: opts.harness,
@@ -9576,16 +9683,37 @@ function register8(program3) {
       );
       if (run.usage) {
         const u = run.usage;
-        const parts = [];
-        if (u.input_tokens !== void 0 || u.output_tokens !== void 0) {
-          parts.push(
-            `${(u.input_tokens ?? 0).toLocaleString()} in / ${(u.output_tokens ?? 0).toLocaleString()} out tokens`
+        const costLabel = runCostLabel(run);
+        const metric = (value) => value === void 0 ? "unknown" : value.toLocaleString();
+        console.log(
+          `usage: input ${metric(u.input_tokens)}  cache-read ${metric(u.cache_read_tokens)}  cache-write ${metric(u.cache_write_tokens)}  output ${metric(u.output_tokens)}`
+        );
+        if (u.cost_usd !== void 0)
+          console.log(
+            `cost: ${runCostLabel(run)}${u.cost_source === void 0 ? " \xB7 source unavailable" : ""}`
+          );
+        const pricing = u.pricing;
+        if (pricing?.status === "provider_authoritative")
+          console.log("cost provenance: provider-reported amount is authoritative");
+        if (pricing?.status === "unpriced") console.log(`cost: Unpriced (${pricing.reason})`);
+        else if (u.cost_usd === void 0 && costLabel === "Unpriced")
+          console.log("cost: Unpriced");
+        if (pricing?.status === "calculated") {
+          const b = pricing.basis;
+          console.log(`cost provenance: Estimated standard API list-price equivalent`);
+          console.log(`  model: ${b.model} (${b.model_identity})`);
+          console.log(
+            `  rate: ${b.rate_id} v${b.rate_version}; adopted ${new Date(b.rate_adopted_at).toISOString()}`
+          );
+          console.log(
+            `  source: ${b.source_url} (checked ${b.source_checked_at}${b.source_effective_at ? `; effective ${b.source_effective_at}` : ""})`
+          );
+          console.log(
+            `  rates USD/1M: input ${b.rates.input_tokens}  cache-read ${b.rates.cache_read_tokens}  cache-write ${b.rates.cache_write_tokens ?? "unpublished"}  output ${b.rates.output_tokens}`
           );
+          console.log(`  exact estimated USD: ${b.cost_usd_exact}`);
+          console.log("  Standard API list-price estimate; not an invoice or subscription usage.");
         }
-        if (u.cost_usd !== void 0) parts.push(`$${u.cost_usd.toFixed(2)}`);
-        if (u.cost_source)
-          parts.push(`(${u.cost_source === "provider" ? "provider-reported" : u.cost_source})`);
-        if (parts.length > 0) console.log(`usage: ${parts.join("  ")}`);
       }
       if (run.provider_session_id) console.log(`provider session: ${run.provider_session_id}`);
       if (run.provider_url) console.log(`provider console: ${run.provider_url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.179",
+  "version": "0.0.182",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",