@lincoln504/pi-research 1.0.12 → 1.1.2

package/src/utils/llm-usage.ts

@@ -13,8 +13,44 @@
 
 import type { Model } from '@earendil-works/pi-ai';
 import { extractUsage } from '../types/llm.ts';
+import { logger } from '../logger.ts';
 import { metrics } from './metrics.ts';
 
+/** Models already warned about, so the notice fires at most once per model per process. */
+const unpricedModelsWarned = new Set<string>();
+
+/**
+ * Warn once when a model bills tokens but carries an all-zero price table.
+ *
+ * Cost is never read off the wire — pi computes it as tokens × the model's local
+ * price table — so an unpriced table yields $0.00 silently and indefinitely. That
+ * is legitimate for flat-rate plans and local servers, but it is also exactly what
+ * a misconfiguration looks like: a hand-written `models[]` entry in models.json
+ * REPLACES pi's catalog entry for the same id, discarding its pricing. This
+ * happened in practice and went unnoticed for weeks because every display site
+ * suppressed a zero cost. The message deliberately does not assert a fault — it
+ * states the condition and names the usual cause.
+ */
+function warnIfUnpriced(model: Model<any>, tokens: number, cost: number): void {
+  if (tokens <= 0 || cost > 0) return;
+  const m = model as unknown as { provider?: string; id?: string; cost?: Record<string, number> };
+  const key = `${m.provider ?? 'unknown'}/${m.id ?? 'unknown'}`;
+  if (unpricedModelsWarned.has(key)) return;
+
+  const table = m.cost;
+  const allZero =
+    !table || Object.values(table).every((v) => typeof v !== 'number' || v === 0);
+  if (!allZero) return;
+
+  unpricedModelsWarned.add(key);
+  logger.warn(
+    `[LlmUsage] Model "${key}" consumed ${tokens} tokens but reports $0.00 — its price table is all zeros. ` +
+      `Expected for flat-rate plans and local servers. Otherwise the price data is missing: a hand-written ` +
+      `"models" entry in ~/.pi/agent/models.json replaces pi's catalog entry (and its pricing) for the same ` +
+      `model id — remove it and let pi's catalog supply the model, or use "modelOverrides", which merges.`
+  );
+}
+
 /** Structural subset of the run observer — just the token sink. Kept structural (rather
  *  than importing ResearchObserver from core/) so this foundation-layer helper does not
  *  depend on an upper layer; the full ResearchObserver satisfies it. */
@@ -43,6 +79,7 @@ export function recordLlmUsage(
 ): { tokens: number; cost: number } {
   if (!rawUsage) return { tokens: 0, cost: 0 };
   const { tokens, cost } = extractUsage(model, rawUsage);
+  warnIfUnpriced(model, tokens, cost);
   if (tokens > 0 || cost > 0) {
     const labels: Record<string, string> = { component: opts.component };
     if (opts.complexity !== undefined) labels['complexity'] = String(opts.complexity);

package/src/utils/metrics-summary.ts

@@ -283,8 +283,15 @@ export function buildResearchSummary(stats: ResearchStats): string {
   if (stats.tokens > 0) {
     resourceParts.push(`**${formatTokens(stats.tokens)}** tokens`);
   }
-  if (stats.cost > 0) {
-    const costStr = stats.cost < 0.01 ? '<$0.01' : `$${stats.cost.toFixed(2)}`;
+  // Render the cost whenever tokens were actually billed-through, INCLUDING when it
+  // is exactly zero. Gating on `cost > 0` hid a real defect for weeks: a model whose
+  // price table is all zeros (an unpriced or catalog-overwritten entry) produced no
+  // cost line at all, so a misconfiguration was indistinguishable from a run that
+  // simply had not reported yet. "$0.00" beside a large token count is conspicuous;
+  // silence is not. Zero is also the honest figure for flat-rate and local providers.
+  if (stats.tokens > 0 || stats.cost > 0) {
+    const costStr =
+      stats.cost === 0 ? '$0.00' : stats.cost < 0.01 ? '<$0.01' : `$${stats.cost.toFixed(2)}`;
     resourceParts.push(`**${costStr}**`);
   }
   if (stats.durationMs > 0) {
@@ -317,6 +324,9 @@ export interface SessionStats {
   totalUrlsDiscovered: number;
   totalSearchQueries: number;
   totalTokens: number;
+  /** Summed LLM cost across the session's runs. The Session Metrics UI advertises
+   *  "API cost estimates"; without this field it had no cost to show. */
+  totalCost: number;
   totalToolUsage: {
     searches: number;
     scrapes: number;
@@ -339,6 +349,7 @@ export function aggregateSessionStats(
   let totalUrlsDiscovered = 0;
   let totalSearchQueries = 0;
   let totalTokens = 0;
+  let totalCost = 0;
   const totalToolUsage = {
     searches: 0,
     scrapes: 0,
@@ -359,6 +370,7 @@ export function aggregateSessionStats(
       totalUrlsDiscovered += stats.urlsDiscovered;
       totalSearchQueries += stats.searchQueries;
       totalTokens += stats.tokens;
+      totalCost += stats.cost;
       totalToolUsage.searches += stats.toolUsage.searches;
       totalToolUsage.scrapes += stats.toolUsage.scrapes;
       totalToolUsage.securitySearches += stats.toolUsage.securitySearches;
@@ -377,6 +389,7 @@ export function aggregateSessionStats(
     totalUrlsDiscovered,
     totalSearchQueries,
     totalTokens,
+    totalCost,
     totalToolUsage,
   };
 }
@@ -403,6 +416,16 @@ export function buildSessionOverview(stats: SessionStats): string {
   }
   if (stats.totalTokens > 0) {
     overviewParts.push(`**${formatTokens(stats.totalTokens)}** tokens`);
+    // Shown alongside tokens even at exactly $0.00 — the Session Metrics view
+    // advertises cost estimates, and a silent omission is what let an unpriced
+    // model table go unnoticed. Zero is correct for flat-rate and local providers.
+    const costStr =
+      stats.totalCost === 0
+        ? '$0.00'
+        : stats.totalCost < 0.01
+          ? '<$0.01'
+          : `$${stats.totalCost.toFixed(2)}`;
+    overviewParts.push(`**${costStr}**`);
   }
   if (stats.totalDurationMs > 0) {
     overviewParts.push(`**${formatDuration(stats.totalDurationMs)}** total research time`);

package/src/utils/research-export.ts

@@ -207,8 +207,15 @@ export async function exportResearchReport(
  */
 export function appendExportMessage(result: string, filepath: string, totalCost?: number): string {
   let footer = `\n\n---\n\nResearch report saved to: ${filepath}`;
-  if (totalCost !== undefined && totalCost > 0) {
-    const costStr = totalCost < 0.01 ? '<$0.01' : `$${totalCost.toFixed(4)}`.replace(/0+$/, '').replace(/\.$/, '');
+  // Report a defined cost even when it is exactly zero — suppressing it made an
+  // unpriced/misconfigured model table look identical to "no cost reported yet".
+  if (totalCost !== undefined) {
+    const costStr =
+      totalCost === 0
+        ? '$0.00'
+        : totalCost < 0.01
+          ? '<$0.01'
+          : `$${totalCost.toFixed(4)}`.replace(/0+$/, '').replace(/\.$/, '');
     footer += `\nTotal cost: ${costStr}`;
   }
   return result + footer;

package/src/web-research/retry-utils.ts

@@ -141,6 +141,11 @@ export function withTimeout<T>(
     // aborted before we start means an external (user) cancellation, not a timeout —
     // a clean stop, so log at debug, not error.
     if (combinedSignal.aborted) {
+      // `promise` is a parameter, so the caller already started it. Returning here
+      // skips the promise.then(...) attachment below, leaving its eventual rejection
+      // with no handler — and Node 22 defaults to --unhandled-rejections=throw, so
+      // that kills the process. Adopt the rejection before bailing out.
+      void promise.catch(() => undefined);
       logger.debug(`[withTimeout] ${label} already aborted at start (external cancellation)`);
       return reject(new Error(`${label} cancelled or timed out`));
     }
@@ -319,7 +324,14 @@ export async function retryWithBackoff<T>(
       // the full backoff. If the wait is aborted, surface the original transient
       // error (not the synthetic AbortError) so callers see the real cause.
       try {
-        await abortableDelay(delay, opts.signal);
+        // keepAlive=true: this sleep IS the operation. The retry has already been
+        // decided and the next attempt must run, so the timer must hold the event
+        // loop open. Without it, a transient network failure — which by its nature
+        // leaves no referenced socket handle — can make the backoff the sole pending
+        // handle, and Node drains the loop and exits mid-retry. The attempt never
+        // runs, and no error surfaces: in the CLI neither branch of the top-level
+        // handler fires, so the user gets a bare exit with no report.
+        await abortableDelay(delay, opts.signal, true);
       } catch {
         metrics.increment('retry_aborted_total', 1, { label: opts.label });
         throw lastError;