@robhowley/pi-openrouter 0.9.0 → 0.9.1

package/extensions/openrouter/overlay.ts

@@ -134,11 +134,13 @@ export class UsageOverlayComponent {
     const th = this.theme;
     const lines: string[] = [];
 
-    if (error) {
+    if (error && !summary) {
       lines.push(boxTop(this.width));
       lines.push(this.getUsageHeaderRow());
       lines.push(emptyRow(this.width));
-      lines.push(row(th.fg('error', error), this.width));
+      for (const errorLine of error.split('\n')) {
+        lines.push(row(th.fg('error', errorLine), this.width));
+      }
       if (cachedMinutesAgo !== null) {
         lines.push(
           row(th.fg('dim', `(last successful fetch: ${cachedMinutesAgo}m ago)`), this.width),
@@ -164,6 +166,19 @@ export class UsageOverlayComponent {
     lines.push(this.getUsageHeaderRow());
     lines.push(emptyRow(this.width));
 
+    if (error) {
+      lines.push(row(th.fg('warning', ' Stale usage data - refresh failed'), this.width));
+      for (const errorLine of error.split('\n')) {
+        lines.push(row(th.fg('dim', ` ${errorLine}`), this.width));
+      }
+      if (cachedMinutesAgo !== null) {
+        lines.push(
+          row(th.fg('dim', ` Last successful fetch: ${cachedMinutesAgo}m ago`), this.width),
+        );
+      }
+      lines.push(emptyRow(this.width));
+    }
+
     // Month row: amount stays with label, cap percentage right-aligned
     const monthLeftBase = ` Month $${fmt(summary.month)} / $${fmt(summary.cap)}`;
     const monthPercent = summary.cap > 0 ? Math.round((summary.month / summary.cap) * 100) : 0;
@@ -190,12 +205,8 @@ export class UsageOverlayComponent {
     }
     lines.push(rowRightAligned(weekLeftBase, weekRight + '  ', this.width));
 
-    // Today row on its own line - shows tilde since from local logs
-    const todayReqStr =
-      summary.local.requests > 0 ? ` · ${fmtCount(summary.local.requests)} reqs` : '';
-    lines.push(
-      rowRightAligned(` Today ~$${fmt(summary.local.cost)}${todayReqStr}`, '  ', this.width),
-    );
+    // Today row on its own line - shows tilde since it may include local tracked usage
+    lines.push(rowRightAligned(` Today ~$${fmt(summary.today)}`, '  ', this.width));
     lines.push(emptyRow(this.width));
 
     // Top models (7d table)

package/extensions/openrouter/session-state.ts

@@ -0,0 +1,110 @@
+import crypto from 'node:crypto';
+import { formatSessionId } from './session.js';
+
+/**
+ * Session state manager for OpenRouter session IDs.
+ * Ensures stable session IDs within a Pi session and proper reset across sessions.
+ */
+export interface SessionState {
+  /**
+   * Get the current session ID, creating one if needed.
+   * The ID is cached and stable for the lifetime of this SessionState instance.
+   */
+  getCurrentSessionId(ctx: { sessionManager: { getSessionId(): string } }): string;
+
+  /**
+   * Handle session_start lifecycle event.
+   * Checks if the raw session ID has changed and updates state accordingly.
+   * - If raw ID differs from cached: reset and format new ID
+   * - If raw ID is same: preserve cached formatted ID
+   * - If raw ID is empty/throws: clear state for fresh fallback
+   */
+  startSession(ctx: { sessionManager: { getSessionId(): string } }): void;
+
+  /**
+   * Reset the cached session ID. Call this on session_shutdown
+   * to ensure fresh IDs for new sessions.
+   */
+  reset(): void;
+
+  /**
+   * Peek at the current cached session ID without initializing one.
+   * Returns null if no session ID has been cached yet.
+   */
+  peek(): string | null;
+}
+
+class SessionStateImpl implements SessionState {
+  private cachedSessionId: string | null = null;
+  private cachedRawSessionId: string | null = null;
+
+  getCurrentSessionId(ctx: { sessionManager: { getSessionId(): string } }): string {
+    if (this.cachedSessionId) {
+      return this.cachedSessionId;
+    }
+
+    try {
+      const sessionId = ctx.sessionManager.getSessionId();
+      let formattedSessionId: string;
+
+      if (sessionId && sessionId !== '') {
+        formattedSessionId = formatSessionId(sessionId);
+        this.cachedRawSessionId = sessionId;
+      } else {
+        // Empty session ID: generate fallback UUID
+        formattedSessionId = formatSessionId(crypto.randomUUID());
+        this.cachedRawSessionId = null;
+      }
+
+      this.cachedSessionId = formattedSessionId;
+      return formattedSessionId;
+    } catch {
+      // Session manager threw error: generate fallback UUID
+      const fallbackId = formatSessionId(crypto.randomUUID());
+      this.cachedSessionId = fallbackId;
+      this.cachedRawSessionId = null;
+      return fallbackId;
+    }
+  }
+
+  startSession(ctx: { sessionManager: { getSessionId(): string } }): void {
+    try {
+      const rawSessionId = ctx.sessionManager.getSessionId();
+
+      if (rawSessionId && rawSessionId !== '') {
+        // Non-empty session ID from manager
+        if (this.cachedRawSessionId !== rawSessionId) {
+          // Raw session ID changed - reset and format new ID
+          this.cachedRawSessionId = rawSessionId;
+          this.cachedSessionId = formatSessionId(rawSessionId);
+        }
+        // else: same raw ID, preserve cached formatted ID
+      } else {
+        // Empty session ID - clear state for fresh fallback
+        this.cachedSessionId = null;
+        this.cachedRawSessionId = null;
+      }
+    } catch {
+      // Session manager threw - clear state for fresh fallback
+      this.cachedSessionId = null;
+      this.cachedRawSessionId = null;
+    }
+  }
+
+  reset(): void {
+    this.cachedSessionId = null;
+    this.cachedRawSessionId = null;
+  }
+
+  peek(): string | null {
+    return this.cachedSessionId;
+  }
+}
+
+/**
+ * Create a new SessionState instance.
+ * Each Pi session should get its own instance.
+ */
+export function createSessionState(): SessionState {
+  return new SessionStateImpl();
+}

package/extensions/openrouter/session.ts

@@ -23,6 +23,22 @@ export function formatSessionId(sessionId: string): string {
 // Detection Logic
 // =============================================================================
 
+/**
+ * Detect whether a provider request should be treated as an OpenRouter request.
+ *
+ * We intentionally use several overlapping signals because Pi events do not always
+ * expose provider metadata in the same place or at the same lifecycle stage.
+ * Different integrations can identify OpenRouter by:
+ * - provider name (`event.provider` or `event.payload.provider`) when Pi resolves it directly
+ * - model prefix (`openrouter/...`) when the request payload keeps the routed model id
+ * - `context.model.baseUrl` when the active model config points at OpenRouter
+ * - `provider.zdr === true` for Shopify's ZDR path that still routes through OpenRouter
+ * - request URL / endpoint as a last fallback for events that only expose transport details
+ *
+ * The checks stay intentionally redundant so session tagging and usage tracking keep
+ * working across request-time and `turn_end`-style event shapes without depending on
+ * a single field being present.
+ */
 export function isOpenRouterRequest(event: BeforeProviderRequestEvent, _ctx: unknown): boolean {
   const ev = event as unknown as Record<string, unknown>;
   const payload = ev['payload'] as Record<string, unknown> | undefined;

package/extensions/openrouter/types.ts

@@ -89,15 +89,34 @@ export interface UsageAggregate {
   cost: number;
 }
 
-export const ZERO_AGGREGATE: UsageAggregate = {
-  requests: 0,
-  promptTokens: 0,
-  completionTokens: 0,
-  reasoningTokens: 0,
-  cacheReadTokens: 0,
-  cacheWriteTokens: 0,
-  cost: 0,
-};
+export function createZeroAggregate(): UsageAggregate {
+  return {
+    requests: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    reasoningTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    cost: 0,
+  };
+}
+
+export function combineUsageAggregates(
+  official: UsageAggregate,
+  local: UsageAggregate,
+): UsageAggregate {
+  return {
+    requests: official.requests + local.requests,
+    promptTokens: official.promptTokens + local.promptTokens,
+    completionTokens: official.completionTokens + local.completionTokens,
+    reasoningTokens: official.reasoningTokens + local.reasoningTokens,
+    cacheReadTokens: official.cacheReadTokens + local.cacheReadTokens,
+    cacheWriteTokens: official.cacheWriteTokens + local.cacheWriteTokens,
+    cost: official.cost + local.cost,
+  };
+}
+
+export const ZERO_AGGREGATE: Readonly<UsageAggregate> = Object.freeze(createZeroAggregate());
 
 export interface CacheEntry<T> {
   data: T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robhowley/pi-openrouter",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "type": "module",
   "description": "Live OpenRouter spend/account TUI overlays, user-scoped model sync, and session tagging for Pi.",
   "license": "MIT",