pi-mega-compact 0.11.4 → 0.11.6

package/src/memoryGraph.ts

@@ -0,0 +1,438 @@
+/**
+ * memoryGraph.ts — S46 visual memory map: build a graph of graphs.
+ *
+ * Nodes = checkpoints (with optional RAPTOR level annotations).
+ * Edges = temporal adjacency, semantic similarity (cosine above threshold), and
+ *         RAPTOR parent–child links.
+ *
+ * pi-agnostic (no pi runtime types). Zero network calls (PREVENT-PI-004).
+ * Synchronous read-only interface — non-fatal on store errors.
+ *
+ * Re-exports the public types as both MemoryGraph* and shorter aliases
+ * (GraphNode, GraphEdge, GraphMetadata) so dashboard api-contracts can import
+ * from the canonical source.
+ */
+import { getStateDir, normalizeSessionId } from "./store.js";
+import { openStore, decodeEmbedding } from "./store/sqlite/utils.js";
+import { listRaptorNodes } from "./store/sqlite/raptor.js";
+import { Logger } from "./log.js";
+const log = new Logger();
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** A node in the memory graph represents one checkpoint (potentially with
+ *  RAPTOR level information if it participates in a RAPTOR tree). */
+export interface MemoryGraphNode {
+  id: string;
+  sessionId: string;
+  label: string;
+  summaryTruncated: string;
+  tokenEstimate: number;
+  /** Unix-epoch ms (from checkpoint timestamp or created_at). */
+  timestamp: number;
+  dedupStatus: string | undefined;
+  /** 0 = no RAPTOR parent; 1+ = RAPTOR cluster level. */
+  raptorLevel: number;
+  topicSummary: string | undefined;
+  decisionCount: number;
+  /** First ~200 chars of the checkpoint summary/text for inline preview. */
+  textSnippet: string;
+}
+
+/** Edge types indicate the *reason* two nodes are connected. */
+export type MemoryGraphEdgeType = "temporal" | "semantic" | "raptor_parent";
+
+export interface MemoryGraphEdge {
+  source: string;
+  target: string;
+  weight: number;
+  type: MemoryGraphEdgeType;
+}
+
+export interface MemoryGraphMetadata {
+  sessionCount: number;
+  totalCheckpoints: number;
+  totalEdges: number;
+  semanticEdgeCount: number;
+  temporalEdgeCount: number;
+  raptorEdgeCount: number;
+  similarityThresholdUsed: number;
+  builtAt: number;
+}
+
+/** The complete memory graph returned by buildMemoryGraph. */
+export interface MemoryGraph {
+  nodes: MemoryGraphNode[];
+  edges: MemoryGraphEdge[];
+  metadata: MemoryGraphMetadata;
+}
+
+// ---------------------------------------------------------------------------
+// Short aliases for dashboard api-contracts import convenience
+// ---------------------------------------------------------------------------
+
+export type GraphNode = MemoryGraphNode;
+export type GraphEdge = MemoryGraphEdge;
+export type GraphMetadata = MemoryGraphMetadata;
+
+/** Options to configure graph construction. */
+export interface MemoryGraphOptions {
+  /** Similarity threshold for semantic edges (cosine). Default 0.7. */
+  similarityThreshold?: number;
+  /** Maximum number of semantic edges per node (avoids dense clique). Default 4. */
+  maxEdgesPerNode?: number;
+  /** Optional session filter — undefined = all sessions. */
+  sessionId?: string;
+  /** State directory (defaults to getStateDir()). */
+  stateDir?: string;
+  /** Include RAPTOR parent–child edges when available. Default true. */
+  includeRaptorEdges?: boolean;
+  /** Include temporal adjacency edges (consecutive checkpoints in same session). Default true. */
+  includeTemporalEdges?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+const DEFAULT_SIMILARITY_THRESHOLD = 0.7;
+const DEFAULT_MAX_EDGES_PER_NODE = 4;
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a memory graph from the store.
+ *
+ * Opens the SQLite store, reads all (or session-filtered) checkpoints,
+ * computes cosine similarity edges, temporal edges, and RAPTOR parent edges.
+ * Returns a MemoryGraph or an empty graph on failure (non-fatal).
+ */
+export function buildMemoryGraph(opts: MemoryGraphOptions = {}): MemoryGraph {
+  const {
+    similarityThreshold = DEFAULT_SIMILARITY_THRESHOLD,
+    maxEdgesPerNode = DEFAULT_MAX_EDGES_PER_NODE,
+    sessionId,
+    stateDir = getStateDir(),
+    includeRaptorEdges = true,
+    includeTemporalEdges = true,
+  } = opts;
+
+  const builtAt = Date.now();
+
+  try {
+    const nodes = loadNodes(sessionId, stateDir);
+    const nodeIndex = buildNodeIndex(nodes);
+    const edges: MemoryGraphEdge[] = [];
+
+    // Temporal edges: consecutive checkpoints within the same session
+    if (includeTemporalEdges) {
+      edges.push(...buildTemporalEdges(nodes));
+    }
+
+    // Semantic edges: cosine similarity above threshold
+    edges.push(...buildSemanticEdges(nodes, nodeIndex, similarityThreshold, maxEdgesPerNode));
+
+    // RAPTOR parent–child edges
+    if (includeRaptorEdges) {
+      edges.push(...buildRaptorEdges(nodes, sessionId, stateDir, nodeIndex));
+    }
+
+    // Deduplicate edges (keep highest weight for each source-target pair)
+    const dedupedEdges = deduplicateEdges(edges);
+
+    // Count sessions
+    const sessionSet = new Set<string>();
+    for (const n of nodes) {
+      sessionSet.add(n.sessionId);
+    }
+
+    const meta: MemoryGraphMetadata = {
+      sessionCount: sessionSet.size,
+      totalCheckpoints: nodes.length,
+      totalEdges: dedupedEdges.length,
+      semanticEdgeCount: dedupedEdges.filter((e) => e.type === "semantic").length,
+      temporalEdgeCount: dedupedEdges.filter((e) => e.type === "temporal").length,
+      raptorEdgeCount: dedupedEdges.filter((e) => e.type === "raptor_parent").length,
+      similarityThresholdUsed: similarityThreshold,
+      builtAt,
+    };
+
+    return { nodes, edges: dedupedEdges, metadata: meta };
+  } catch (err) {
+    log.warn("buildMemoryGraph failed", { error: String(err) });
+    return {
+      nodes: [],
+      edges: [],
+      metadata: {
+        sessionCount: 0,
+        totalCheckpoints: 0,
+        totalEdges: 0,
+        semanticEdgeCount: 0,
+        temporalEdgeCount: 0,
+        raptorEdgeCount: 0,
+        similarityThresholdUsed: similarityThreshold,
+        builtAt,
+      },
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Node loading
+// ---------------------------------------------------------------------------
+
+function loadNodes(sessionId: string | undefined, stateDir: string): MemoryGraphNode[] {
+  const db = openStore(stateDir);
+
+  const sql = sessionId
+    ? "SELECT * FROM context_chunks WHERE session_id = ? ORDER BY id ASC"
+    : "SELECT * FROM context_chunks ORDER BY session_id, id ASC";
+
+  const rows = sessionId
+    ? (db.prepare(sql).all(normalizeSessionId(sessionId)) as any[])
+    : (db.prepare(sql).all() as any[]);
+
+  return rows.map(rowToGraphNode);
+}
+
+function rowToGraphNode(row: any): MemoryGraphNode {
+  const summary = row.summary ?? "";
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    label: row.id,
+    summaryTruncated: summary.length > 200 ? summary.slice(0, 197) + "..." : summary,
+    tokenEstimate: row.token_estimate ?? 0,
+    timestamp: row.created_at ?? Date.now(),
+    dedupStatus: row.dedup_status ?? undefined,
+    raptorLevel: 0, // enriched below if RAPTOR data exists
+    topicSummary: row.topic_summary ?? undefined,
+    decisionCount: row.key_decisions
+      ? safeJsonCount(row.key_decisions)
+      : 0,
+    textSnippet: summary.length > 200 ? summary.slice(0, 197) + "..." : summary,
+  };
+}
+
+/** Parse a JSON array stored in a text column and return its length. */
+function safeJsonCount(raw: string | null | undefined): number {
+  if (!raw) return 0;
+  try {
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Node index building
+// ---------------------------------------------------------------------------
+
+function buildNodeIndex(nodes: MemoryGraphNode[]): Map<string, number> {
+  const idx = new Map<string, number>();
+  nodes.forEach((n, i) => idx.set(n.id, i));
+  return idx;
+}
+
+// ---------------------------------------------------------------------------
+// Edges: temporal
+// ---------------------------------------------------------------------------
+
+function buildTemporalEdges(nodes: MemoryGraphNode[]): MemoryGraphEdge[] {
+  const edges: MemoryGraphEdge[] = [];
+  if (nodes.length < 2) return edges;
+
+  let prev = nodes[0];
+  for (let i = 1; i < nodes.length; i++) {
+    const cur = nodes[i];
+    if (cur.sessionId === prev.sessionId) {
+      edges.push({
+        source: prev.id,
+        target: cur.id,
+        weight: 1.0,
+        type: "temporal",
+      });
+    }
+    prev = cur;
+  }
+  return edges;
+}
+
+// ---------------------------------------------------------------------------
+// Edges: semantic (cosine similarity)
+// ---------------------------------------------------------------------------
+
+function buildSemanticEdges(
+  nodes: MemoryGraphNode[],
+  _nodeIndex: Map<string, number>,
+  threshold: number,
+  maxPerNode: number,
+): MemoryGraphEdge[] {
+  if (nodes.length < 2) return [];
+  const db = openStore();
+
+  // Retrieve embeddings from DB for each node
+  const embeddings = new Map<string, number[]>();
+  const placeholders = nodes.map(() => "?").join(",");
+  const ids = nodes.map((n) => n.id);
+  const rows = db
+    .prepare(`SELECT id, embedding_blob FROM context_chunks WHERE id IN (${placeholders})`)
+    .all(...ids) as unknown as Array<{ id: string; embedding_blob: Uint8Array | null }>;
+
+  for (const row of rows) {
+    const emb = decodeEmbedding(row.embedding_blob as Uint8Array | null | undefined);
+    if (emb.length > 0) {
+      embeddings.set(row.id, emb);
+    }
+  }
+
+  type EdgeCandidate = { target: string; weight: number };
+  const edges: MemoryGraphEdge[] = [];
+
+  for (const node of nodes) {
+    const aId = node.id;
+    const aEmb = embeddings.get(aId);
+    if (!aEmb) continue;
+
+    const candidates: EdgeCandidate[] = [];
+
+    for (const other of nodes) {
+      if (other.id === aId) continue;
+      // Skip if already connected via temporal or raptor edge
+      const bEmb = embeddings.get(other.id);
+      if (!bEmb) continue;
+
+      const sim = cosineSimilarity(aEmb, bEmb);
+      if (sim >= threshold) {
+        candidates.push({ target: other.id, weight: sim });
+      }
+    }
+
+    // Keep top-K highest-weight semantic neighbors
+    candidates.sort((a, b) => b.weight - a.weight);
+    const top = candidates.slice(0, maxPerNode);
+    for (const c of top) {
+      edges.push({
+        source: aId,
+        target: c.target,
+        weight: c.weight,
+        type: "semantic",
+      });
+    }
+  }
+
+  return edges;
+}
+
+// ---------------------------------------------------------------------------
+// Edges: RAPTOR parent–child
+// ---------------------------------------------------------------------------
+
+function buildRaptorEdges(
+  nodes: MemoryGraphNode[],
+  sessionId: string | undefined,
+  stateDir: string,
+  nodeIndex: Map<string, number>,
+): MemoryGraphEdge[] {
+  const edges: MemoryGraphEdge[] = [];
+
+  try {
+    if (sessionId) {
+      enrichRaptorForSession(sessionId, stateDir, nodeIndex, nodes, edges);
+    } else {
+      // Load all sessions from DB
+      const db = openStore(stateDir);
+      const sessionRows = db
+        .prepare("SELECT DISTINCT session_id FROM raptor_nodes ORDER BY session_id")
+        .all() as any[];
+      for (const row of sessionRows) {
+        enrichRaptorForSession(row.session_id as string, stateDir, nodeIndex, nodes, edges);
+      }
+    }
+  } catch (err) {
+    log.warn("RAPTOR edge build failed (non-fatal)", { error: String(err) });
+  }
+
+  return edges;
+}
+
+function enrichRaptorForSession(
+  sessId: string,
+  stateDir: string,
+  nodeIndex: Map<string, number>,
+  nodes: MemoryGraphNode[],
+  edges: MemoryGraphEdge[],
+): void {
+  const raptorNodes = listRaptorNodes(sessId, stateDir);
+
+  for (const rn of raptorNodes) {
+    const idx = nodeIndex.get(rn.id);
+    if (idx !== undefined) {
+      // Annotate the graph node with the RAPTOR level
+      nodes[idx].raptorLevel = rn.level;
+    }
+
+    if (!rn.parentId) continue;
+    // Only create edge if both nodes are in the graph
+    if (nodeIndex.has(rn.id) && nodeIndex.has(rn.parentId)) {
+      edges.push({
+        source: rn.id,
+        target: rn.parentId,
+        weight: Math.max(0.1, 1.0 - rn.level * 0.1), // higher levels = weaker link
+        type: "raptor_parent",
+      });
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Edge deduplication
+// ---------------------------------------------------------------------------
+
+function deduplicateEdges(edges: MemoryGraphEdge[]): MemoryGraphEdge[] {
+  const seen = new Map<string, MemoryGraphEdge>();
+
+  for (const e of edges) {
+    const keyA = `${e.source}|${e.target}`;
+    const keyB = `${e.target}|${e.source}`;
+    const existing = seen.get(keyA) ?? seen.get(keyB);
+
+    if (!existing) {
+      seen.set(keyA, e);
+    } else if (e.weight > existing.weight) {
+      // Replace with higher-weight edge
+      seen.delete(keyA);
+      seen.delete(keyB);
+      seen.set(keyA, e);
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+// ---------------------------------------------------------------------------
+// Cosine similarity
+// ---------------------------------------------------------------------------
+
+function cosineSimilarity(a: number[], b: number[]): number {
+  const len = Math.min(a.length, b.length);
+  if (len === 0) return 0;
+
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+
+  for (let i = 0; i < len; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}

package/src/memoryStats.ts

@@ -0,0 +1,107 @@
+/**
+ * memoryStats.ts — aggregate memory-store statistics (S53B).
+ *
+ * Reads from the durable SQLite memories table to produce:
+ *   - totalMemories: all memories in the store
+ *   - memoriesInLast30Days: memories created within the last 30 days
+ *   - topStableMemories: top-N memories by recall count (desc)
+ *   - avgRecallScore: mean recallCount across all memories
+ *
+ * recallCount = 1 if last_recalled_at IS NOT NULL, else 0.
+ * This is the durable signal from recallMemory() — a memory that was
+ * recalled at least once is "stable" (still relevant).  The exact recall
+ * frequency is tracked via turn_recall rows (source='memory') for
+ * cross-session analysis, but the memories table provides a reliable
+ * on-store signal that is always present without a schema migration.
+ *
+ * Real-store only (PREVENT-PI-004). No mocks. No network.
+ */
+import { openStore } from "./store/sqlite/utils.js";
+
+export interface MemoryStatsResult {
+  totalMemories: number;
+  memoriesInLast30Days: number;
+  topStableMemories: Array<{
+    id: number;
+    text: string;
+    recallCount: number;
+    lastRecalledAt: number | null;
+  }>;
+  avgRecallScore: number;
+}
+
+export interface MemoryStatsOptions {
+  /** Max memories in topStableMemories (default 5). */
+  topN?: number;
+}
+
+/**
+ * Aggregate memory statistics from the SQLite store.
+ * Always returns a valid MemoryStatsResult; never throws.
+ */
+export async function memoryStats(
+  stateDir: string,
+  opts: MemoryStatsOptions = {},
+): Promise<MemoryStatsResult> {
+  const topN = opts.topN ?? 5;
+  try {
+    const db = openStore(stateDir);
+    // ── totalMemories ──────────────────────────────────────────────────────
+    const totalRow = db
+      .prepare("SELECT COUNT(*) AS n FROM memories")
+      .get() as { n: number };
+    const totalMemories = totalRow.n;
+
+    // ── memoriesInLast30Days ───────────────────────────────────────────────
+    const thirtyDaysAgo = Math.floor(Date.now() / 1000) - 30 * 86_400;
+    const recentRow = db
+      .prepare(
+        "SELECT COUNT(*) AS n FROM memories WHERE created_at >= ?",
+      )
+      .get(thirtyDaysAgo) as { n: number };
+    const memoriesInLast30Days = recentRow.n;
+
+    // ── topStableMemories + avgRecallScore ─────────────────────────────────
+    // recallCount: 1 if last_recalled_at IS NOT NULL (recalled at least once),
+    //             0 otherwise.  Stable memories score high.
+    const topRows = db
+      .prepare(
+        `SELECT
+           m.id,
+           m.content         AS text,
+           m.last_recalled_at AS lastRecalledAt,
+           CASE WHEN m.last_recalled_at IS NOT NULL THEN 1 ELSE 0 END AS recallCount
+         FROM memories m
+         ORDER BY recallCount DESC, m.id ASC
+         LIMIT ?`,
+      )
+      .all(topN) as Array<Record<string, unknown>>;
+
+    // avgRecallScore = (count of recalled memories) / totalMemories.
+    // This represents the fraction of memories that are "stable" (recalled at least once).
+    const recalledRow = db
+      .prepare(
+        "SELECT COUNT(*) AS n FROM memories WHERE last_recalled_at IS NOT NULL",
+      )
+      .get() as { n: number };
+    const avgRecallScore =
+      totalMemories > 0 ? recalledRow.n / totalMemories : 0;
+
+    const topStableMemories = topRows.map((r) => ({
+      id: r.id as number,
+      text: (r.text as string) ?? "",
+      recallCount: (r.recallCount as number) ?? 0,
+      lastRecalledAt: (r.lastRecalledAt as number | null) ?? null,
+    }));
+
+    return { totalMemories, memoriesInLast30Days, topStableMemories, avgRecallScore };
+  } catch {
+    // Non-fatal: return zeros rather than propagating an error.
+    return {
+      totalMemories: 0,
+      memoriesInLast30Days: 0,
+      topStableMemories: [],
+      avgRecallScore: 0,
+    };
+  }
+}

package/src/monitoring.ts

@@ -24,6 +24,10 @@ export interface DedupDecisionEvent {
   latencyMs: number;
   /** True when this dedup was later found to be a false positive. */
   falsePositive?: boolean;
+  /** Cosine similarity score (L2 semantic tier) or 1 for exact match (L0/L1). */
+  similarityScore?: number;
+  /** Checkpoint ID of the matched entry. */
+  matchedId?: string;
 }
 
 export interface DedupMetrics {
@@ -169,3 +173,34 @@ export function defaultMetricsPath(stateDir: string = STATE_DIR_DEFAULT): string
 export function defaultEventsPath(stateDir: string = STATE_DIR_DEFAULT): string {
   return join(stateDir, "events.log");
 }
+
+// ---------------------------------------------------------------------------
+// S45 CRAG quality metrics event
+// ---------------------------------------------------------------------------
+
+export interface RecallQualityEvent {
+  ts: number;
+  sessionId: string;
+  tier: "CRAG";
+  score: number;
+  breakdown: { relevance: number; coverage: number; diversity: number; specificity: number };
+  expanded: boolean;
+  reRetrieved: boolean;
+  uncalibrated: boolean;
+  weights: { relevance: number; coverage: number; diversity: number; specificity: number };
+  note?: string;
+  error?: string;
+}
+
+/**
+ * Append a RecallQualityEvent to events.log (best-effort, non-fatal).
+ * Follows the same append-one-JSON-line pattern as logDecision.
+ */
+export function logRecallQuality(path: string, ev: RecallQualityEvent): void {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, JSON.stringify(ev) + "\n", "utf-8");
+  } catch {
+    /* best-effort — never break the extension */
+  }
+}

package/src/prefix-break.ts

@@ -0,0 +1,83 @@
+/**
+ * prefix-break.ts — S53A prefix-break classification.
+ *
+ * Classifies WHY the provider cache prefix broke on a given turn by comparing
+ * the break timestamp against the three candidate event timestamps with a
+ * configurable tolerance window.
+ *
+ * The classification is best-effort (non-fatal): null timestamps are absent,
+ * and a break outside all tolerance windows is classified as 'other'.
+ *
+ * Pi-agnostic: no pi runtime types, no network.
+ */
+
+export interface PrefixBreakMeta {
+	/** Which event caused the break. */
+	cause: "recall" | "compaction" | "inject" | "other";
+	/** Confidence score 0.0–1.0 based on proximity to the matched event. */
+	confidence: number;
+	/** Cache hit % immediately before the break. */
+	prevHitPct: number;
+	/** Cache hit % of the first degraded sample. */
+	currHitPct: number;
+	/** Wall-clock ms of the break sample. */
+	breakAt: number;
+}
+
+export interface PrefixBreak {
+	id: number;
+	ts: number;
+	kind: "prefix_break";
+	value: number;
+	meta: PrefixBreakMeta;
+}
+
+/**
+ * Timestamps of recent events that can cause a prefix break.
+ * All values are wall-clock ms (Date.now()) or null if no event has occurred.
+ */
+export interface EventTimestamps {
+	lastRecallAt: number | null;
+	lastCompactAt: number | null;
+	lastInjectAt: number | null;
+}
+
+/**
+ * Classify why the provider cache prefix broke at `breakTimestamp`.
+ *
+ * @param breakTimestamp  Wall-clock ms of the cache hit % drop sample.
+ * @param events          Recent event timestamps from the runtime.
+ * @param toleranceMs     Max ms gap to consider a match (default 2000).
+ * @returns Classification result with cause + confidence.
+ *
+ * Priority: recall > compaction > inject.  Confidence = 1 − (gap / (2·tolerance)),
+ * capped at [0.5, 1.0].  Returns 'other' when no event is within tolerance.
+ */
+export function classifyPrefixBreak(
+	breakTimestamp: number,
+	events: EventTimestamps,
+	toleranceMs = 2000,
+): { cause: "recall" | "compaction" | "inject" | "other"; confidence: number } {
+	// Ordered by priority (recall wins if multiple match).
+	const candidates: Array<{
+		cause: "recall" | "compaction" | "inject";
+		ts: number | null;
+	}> = [
+		{ cause: "recall", ts: events.lastRecallAt },
+		{ cause: "compaction", ts: events.lastCompactAt },
+		{ cause: "inject", ts: events.lastInjectAt },
+	];
+
+	for (const { cause, ts } of candidates) {
+		if (ts == null) continue;
+		const gap = Math.abs(breakTimestamp - ts);
+		if (gap <= toleranceMs) {
+			// confidence = 1 − (gap / (2·tolerance)) ∈ [0.5, 1.0]
+			// exact match (gap=0) → 1.0;  at boundary (gap=tolerance) → 0.5
+			const confidence = Math.max(0.5, 1 - gap / (2 * toleranceMs));
+			return { cause, confidence };
+		}
+	}
+
+	return { cause: "other", confidence: 0 };
+}

package/src/pricing.ts

@@ -39,7 +39,7 @@ export const MODEL_INPUT_RATES: Record<string, number> = {
 	"gemini-2.0-flash": 0.1e-6,
 	"deepseek-chat": 0.14e-6,
 	"deepseek-reasoner": 0.55e-6,
-	"codestral": 0.3e-6,
+	codestral: 0.3e-6,
 	"mistral-large": 2e-6,
 	"llama-3.1-405b": 1.33e-6,
 	"llama-3.1-70b": 0.8e-6,
@@ -92,4 +92,4 @@ export function computeCacheSavings(
 		cacheWriteCost,
 		netSaved: cacheReadSaved - cacheWriteCost,
 	};
-}
+}