@arraystar/tokenscope 0.1.0

package/src/parser/claude.ts

@@ -0,0 +1,225 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { ParsedSession, PricingTriple } from "./types";
+
+const CLAUDE_DIR = path.join(
+  process.env.HOME || process.env.USERPROFILE || "~",
+  ".claude",
+  "projects"
+);
+
+const PRICING: Record<string, PricingTriple> = {
+  "glm-5.1": { input: 4.0, output: 18.0, cacheRead: 1.0 },
+  "glm-4.5-air": { input: 0.8, output: 3.0, cacheRead: 0.08 },
+  "claude-sonnet-4-20250514": { input: 3.0, output: 15.0, cacheRead: 0.3 },
+  "claude-opus-4-20250514": { input: 15.0, output: 75.0, cacheRead: 1.5 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4.0, cacheRead: 0.08 },
+};
+
+function getPrice(model: string): PricingTriple {
+  for (const [k, v] of Object.entries(PRICING)) {
+    if (model.includes(k)) return v;
+  }
+  return { input: 0, output: 0, cacheRead: 0 };
+}
+
+function extractUserText(msg: Record<string, unknown>): string {
+  const content = msg.content;
+  if (typeof content === "string") return content.slice(0, 100);
+  if (Array.isArray(content)) {
+    for (const c of content) {
+      if (
+        typeof c === "object" &&
+        c !== null &&
+        (c as Record<string, unknown>).type === "text"
+      ) {
+        return String((c as Record<string, unknown>).text ?? "").slice(0, 100);
+      }
+    }
+  }
+  return "";
+}
+
+interface RawLine {
+  type: string;
+  message?: Record<string, unknown>;
+  timestamp?: string;
+}
+
+export function parseClaudeSessions(
+  claudeDir?: string
+): ParsedSession[] {
+  const dir = claudeDir ?? CLAUDE_DIR;
+  if (!fs.existsSync(dir)) return [];
+
+  const sessions: ParsedSession[] = [];
+
+  for (const projDir of fs.readdirSync(dir).sort()) {
+    const projPath = path.join(dir, projDir);
+    if (!fs.statSync(projPath).isDirectory()) continue;
+
+    const parts = projDir.split("-");
+    const short =
+      parts.length > 2 ? parts.slice(2).join("/") : projDir;
+
+    for (const f of fs.readdirSync(projPath).sort()) {
+      if (!f.endsWith(".jsonl")) continue;
+
+      const sid = f.slice(0, 8);
+      const filePath = path.join(projPath, f);
+      const lines: RawLine[] = [];
+
+      for (const line of fs.readFileSync(filePath, "utf-8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          lines.push(JSON.parse(trimmed));
+        } catch {
+          // skip malformed
+        }
+      }
+
+      // Build turns: group user text + following assistant messages
+      let currentUserText = "";
+      let currentAssistantMsgs: {
+        model: string;
+        input: number;
+        output: number;
+        cache_read: number;
+        cache_write: number;
+        total: number;
+        cost: number;
+        timestamp: string;
+      }[] = [];
+
+      const flushTurn = (): void => {
+        if (currentAssistantMsgs.length === 0) return;
+        const tIn = currentAssistantMsgs.reduce((s, a) => s + a.input, 0);
+        const tOut = currentAssistantMsgs.reduce((s, a) => s + a.output, 0);
+        const tCR = currentAssistantMsgs.reduce(
+          (s, a) => s + a.cache_read,
+          0
+        );
+        const tCW = currentAssistantMsgs.reduce(
+          (s, a) => s + a.cache_write,
+          0
+        );
+        const tTot = currentAssistantMsgs.reduce((s, a) => s + a.total, 0);
+        const tCost = currentAssistantMsgs.reduce((s, a) => s + a.cost, 0);
+        const ts =
+          currentAssistantMsgs[0]?.timestamp ?? "";
+
+        // Group by model — pick the first model for the session
+        const model = currentAssistantMsgs[0]?.model ?? "unknown";
+
+        turns.push({
+          user: currentUserText.slice(0, 200),
+          time: ts,
+          input: tIn,
+          output: tOut,
+          cache_read: tCR,
+          cache_write: tCW,
+          total: tTot,
+          cost: Math.round(tCost * 10000) / 10000,
+        });
+
+        // Aggregate per-model stats
+        const key = model;
+        if (!modelStats[key]) {
+          modelStats[key] = {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+            total: 0,
+            cost: 0,
+            msgs: 0,
+          };
+        }
+        const ms = modelStats[key];
+        ms.input += tIn;
+        ms.output += tOut;
+        ms.cache_read += tCR;
+        ms.cache_write += tCW;
+        ms.total += tTot;
+        ms.cost += tCost;
+        ms.msgs += currentAssistantMsgs.length;
+      };
+
+      const turns: ParsedSession["turns"] = [];
+      const modelStats: Record<
+        string,
+        ParsedSession["stats"]
+      > = {};
+
+      for (const d of lines) {
+        if (d.type === "user") {
+          const msg = (d.message ?? {}) as Record<string, unknown>;
+          const text = extractUserText(msg);
+          if (
+            text &&
+            !text.startsWith("[{") &&
+            !text.startsWith("Continue from")
+          ) {
+            flushTurn();
+            currentUserText = text;
+            currentAssistantMsgs = [];
+          }
+        } else if (d.type === "assistant") {
+          const msg = (d.message ?? {}) as Record<string, unknown>;
+          const u = (msg.usage ?? {}) as Record<string, number>;
+          const inp = u.input_tokens ?? 0;
+          const out = u.output_tokens ?? 0;
+          const cr = u.cache_read_input_tokens ?? 0;
+          const cw = u.cache_creation_input_tokens ?? 0;
+          if (inp === 0 && out === 0 && cr === 0 && cw === 0) continue;
+
+          const model = String(msg.model ?? "unknown");
+          const ts = String(d.timestamp ?? "");
+          const price = getPrice(model);
+          const cost =
+            (inp * price.input +
+              out * price.output +
+              cr * price.cacheRead) /
+            1_000_000;
+
+          currentAssistantMsgs.push({
+            model,
+            input: inp,
+            output: out,
+            cache_read: cr,
+            cache_write: cw,
+            total: inp + out + cr + cw,
+            cost,
+            timestamp: ts,
+          });
+        }
+      }
+      flushTurn();
+
+      // For simplicity: each session file → one ParsedSession per dominant model
+      const dominantModel =
+        Object.entries(modelStats).sort(
+          (a, b) => b[1].cost - a[1].cost
+        )[0]?.[0] ?? "unknown";
+      const ms = modelStats[dominantModel];
+      if (!ms || ms.msgs === 0) continue;
+
+      sessions.push({
+        source: "claude",
+        project: short,
+        sid,
+        date: turns[0]?.time?.slice(0, 10) ?? "",
+        first_ts: turns[0]?.time ?? "",
+        model: dominantModel,
+        stats: {
+          ...ms,
+          cost: Math.round(ms.cost * 10000) / 10000,
+        },
+        turns,
+      });
+    }
+  }
+
+  return sessions;
+}

package/src/parser/codex.ts

@@ -0,0 +1,181 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { ParsedSession, PricingTriple } from "./types";
+
+const CODEX_DIR = path.join(
+  process.env.HOME || process.env.USERPROFILE || "~",
+  ".codex"
+);
+
+const PRICING: Record<string, PricingTriple> = {
+  "gpt-5.4": { input: 2.5, output: 10.0, cacheRead: 1.25 },
+  "gpt-4o": { input: 2.5, output: 10.0, cacheRead: 1.25 },
+  "o3": { input: 2.0, output: 8.0, cacheRead: 0.2 },
+  "o4-mini": { input: 0.75, output: 4.5, cacheRead: 0.075 },
+  "o3-mini": { input: 1.1, output: 4.4, cacheRead: 0 },
+};
+
+function getPrice(model: string): PricingTriple {
+  for (const [k, v] of Object.entries(PRICING)) {
+    if (model.includes(k)) return v;
+  }
+  return { input: 0, output: 0, cacheRead: 0 };
+}
+
+interface TurnBuilder {
+  userText: string;
+  startTime: string;
+  model: string;
+  tokenCalls: { input: number; output: number; cached: number; reasoning: number }[];
+}
+
+function walkDir(dir: string): string[] {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) return results;
+  for (const entry of fs.readdirSync(dir).sort()) {
+    const full = path.join(dir, entry);
+    const stat = fs.statSync(full);
+    if (stat.isDirectory()) {
+      results.push(...walkDir(full));
+    } else if (full.endsWith(".jsonl")) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+function readJsonl(filePath: string): Record<string, unknown>[] {
+  const results: Record<string, unknown>[] = [];
+  for (const line of fs.readFileSync(filePath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try { results.push(JSON.parse(trimmed)); } catch { /* skip */ }
+  }
+  return results;
+}
+
+export function parseCodexSessions(codexDir?: string): ParsedSession[] {
+  const dir = codexDir ?? CODEX_DIR;
+  const sessionsDir = path.join(dir, "sessions");
+  if (!fs.existsSync(sessionsDir)) return [];
+
+  const sessions: ParsedSession[] = [];
+  const files = walkDir(sessionsDir);
+
+  for (const filePath of files) {
+    const lines = readJsonl(filePath);
+
+    // Extract session metadata
+    let cwd = "";
+    let sessionId = "";
+    let defaultModel = "unknown";
+
+    for (const d of lines) {
+      if (d.type === "session_meta" && d.payload) {
+        const p = d.payload as Record<string, unknown>;
+        cwd = String(p.cwd ?? "");
+        sessionId = String(p.id ?? "");
+      }
+      if (d.type === "turn_context" && d.payload) {
+        const p = d.payload as Record<string, unknown>;
+        if (p.model) defaultModel = String(p.model);
+      }
+    }
+
+    // Build turns: user_message starts a turn, collect token_counts until next user_message
+    const turnBuilders: TurnBuilder[] = [];
+    let current: TurnBuilder | null = null;
+
+    for (const d of lines) {
+      if (d.type !== "event_msg" || !d.payload) continue;
+      const payload = d.payload as Record<string, unknown>;
+      const pt = String(payload.type ?? "");
+
+      if (pt === "user_message") {
+        if (current) turnBuilders.push(current);
+        current = {
+          userText: String(payload.message ?? "").slice(0, 200),
+          startTime: String(d.timestamp ?? ""),
+          model: defaultModel,
+          tokenCalls: [],
+        };
+      } else if (pt === "turn_context" && current) {
+        const m = (d.payload as Record<string, unknown>).model;
+        if (m) current.model = String(m);
+      } else if (pt === "token_count" && payload.info && current) {
+        const info = payload.info as Record<string, unknown>;
+        const last = info.last_token_usage as Record<string, number> | undefined;
+        if (last) {
+          current.tokenCalls.push({
+            input: last.input_tokens ?? 0,
+            output: last.output_tokens ?? 0,
+            cached: last.cached_input_tokens ?? 0,
+            reasoning: last.reasoning_output_tokens ?? 0,
+          });
+        }
+      }
+    }
+    if (current) turnBuilders.push(current);
+
+    if (turnBuilders.length === 0) continue;
+
+    // Determine project from cwd
+    const project = cwd ? cwd.split("/").pop() || "unknown" : "unknown";
+    const sid = sessionId.slice(0, 8) || path.basename(filePath).slice(0, 8);
+    const date = turnBuilders[0].startTime.slice(0, 10);
+    const model = turnBuilders[0].model;
+    const price = getPrice(model);
+
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCR = 0;
+    let totalCost = 0;
+    let totalMsgs = 0;
+
+    const parsedTurns = turnBuilders.map((t) => {
+      const tIn = t.tokenCalls.reduce((s, c) => s + c.input, 0);
+      const tOut = t.tokenCalls.reduce((s, c) => s + c.output + c.reasoning, 0);
+      const tCR = t.tokenCalls.reduce((s, c) => s + c.cached, 0);
+      const tTot = tIn + tOut + tCR;
+      const tCost = (tIn * price.input + tOut * price.output + tCR * price.cacheRead) / 1_000_000;
+
+      totalInput += tIn;
+      totalOutput += tOut;
+      totalCR += tCR;
+      totalCost += tCost;
+      totalMsgs += t.tokenCalls.length;
+
+      return {
+        user: t.userText,
+        time: t.startTime,
+        input: tIn,
+        output: tOut,
+        cache_read: tCR,
+        cache_write: 0,
+        total: tTot,
+        cost: Math.round(tCost * 10000) / 10000,
+      };
+    });
+
+    sessions.push({
+      source: "codex",
+      project,
+      sid,
+      date,
+      first_ts: turnBuilders[0].startTime,
+      model,
+      stats: {
+        input: totalInput,
+        output: totalOutput,
+        cache_read: totalCR,
+        cache_write: 0,
+        total: totalInput + totalOutput + totalCR,
+        cost: Math.round(totalCost * 10000) / 10000,
+        msgs: totalMsgs,
+      },
+      turns: parsedTurns,
+    });
+  }
+
+  return sessions;
+}

package/src/parser/index.ts

@@ -0,0 +1,83 @@
+import type { ParsedSession } from "./types.ts";
+import { parseClaudeSessions } from "./claude.ts";
+import { parseCodexSessions } from "./codex.ts";
+import type { DashboardData, ModelData, SessionData } from "../types.ts";
+
+export { parseClaudeSessions, parseCodexSessions };
+
+export interface ParseOptions {
+  claude?: boolean;
+  codex?: boolean;
+  jsonOnly?: boolean;
+  claudeDir?: string;
+  codexDir?: string;
+}
+
+export function parseAllSessions(options: ParseOptions = {}): ParsedSession[] {
+  const sessions: ParsedSession[] = [];
+  const wantClaude = options.codex !== true;
+  const wantCodex = options.claude !== true;
+
+  if (wantClaude) {
+    try { sessions.push(...parseClaudeSessions(options.claudeDir)); } catch { /* skip */ }
+  }
+  if (wantCodex) {
+    try { sessions.push(...parseCodexSessions(options.codexDir)); } catch { /* skip */ }
+  }
+
+  return sessions;
+}
+
+export function buildDashboardData(sessions: ParsedSession[]): DashboardData {
+  const sources = new Set<"claude" | "codex">();
+  const modelsMap: Record<string, ModelData> = {};
+
+  for (const s of sessions) {
+    sources.add(s.source);
+    const modelKey = s.model;
+    if (!modelsMap[modelKey]) {
+      modelsMap[modelKey] = {
+        stats: { input: 0, output: 0, cache_read: 0, cache_write: 0, total: 0, cost: 0, msgs: 0 },
+        sessions: {},
+      };
+    }
+    const sessionKey = `${s.project}|${s.sid}`;
+    const sessionData: SessionData = {
+      source: s.source,
+      project: s.project,
+      sid: s.sid,
+      date: s.date,
+      first_ts: s.first_ts,
+      stats: s.stats,
+      turns: s.turns,
+    };
+    modelsMap[modelKey].sessions[sessionKey] = sessionData;
+    const ms = modelsMap[modelKey].stats;
+    ms.input += s.stats.input;
+    ms.output += s.stats.output;
+    ms.cache_read += s.stats.cache_read;
+    ms.cache_write += s.stats.cache_write;
+    ms.total += s.stats.total;
+    ms.cost += s.stats.cost;
+    ms.msgs += s.stats.msgs;
+  }
+
+  const grandTotal = { input: 0, output: 0, cache_read: 0, cache_write: 0, total: 0, cost: 0, msgs: 0 };
+  for (const md of Object.values(modelsMap)) {
+    grandTotal.input += md.stats.input;
+    grandTotal.output += md.stats.output;
+    grandTotal.cache_read += md.stats.cache_read;
+    grandTotal.cache_write += md.stats.cache_write;
+    grandTotal.total += md.stats.total;
+    grandTotal.cost += md.stats.cost;
+    grandTotal.msgs += md.stats.msgs;
+  }
+  grandTotal.cost = Math.round(grandTotal.cost * 10000) / 10000;
+
+  return {
+    generated: new Date().toISOString().slice(0, 16).replace("T", " "),
+    sources: Array.from(sources),
+    models: modelsMap,
+    grand_total: grandTotal,
+  };
+}

package/src/parser/types.ts

@@ -0,0 +1,35 @@
+export interface ParsedTurn {
+  user: string;
+  time: string;
+  input: number;
+  output: number;
+  cache_read: number;
+  cache_write: number;
+  total: number;
+  cost: number;
+}
+
+export interface ParsedSession {
+  source: "claude" | "codex";
+  project: string;
+  sid: string;
+  date: string;
+  first_ts: string;
+  model: string;
+  stats: {
+    input: number;
+    output: number;
+    cache_read: number;
+    cache_write: number;
+    total: number;
+    cost: number;
+    msgs: number;
+  };
+  turns: ParsedTurn[];
+}
+
+export interface PricingTriple {
+  input: number;
+  output: number;
+  cacheRead: number;
+}

package/src/pricing.ts

@@ -0,0 +1,139 @@
+import type { DashboardData } from "./types";
+
+export interface PricingEntry {
+  id: string;
+  provider: string;
+  model: string;
+  input: number;
+  output: number;
+  cacheRead: number;
+  currency: "usd" | "cny";
+}
+
+export interface CustomPrice {
+  input: number;
+  output: number;
+  cacheRead: number;
+  currency: "usd" | "cny";
+}
+
+export interface PricingConfig {
+  modelMappings: Record<string, string>;
+  customPricing: Record<string, CustomPrice>;
+}
+
+const LS_KEY = "token-dashboard-pricing-config";
+
+export const PRICING_DB: PricingEntry[] = [
+  // Anthropic (USD)
+  { id: "anthropic/claude-opus-4.6", provider: "Anthropic", model: "Claude Opus 4.6", input: 15.0, output: 75.0, cacheRead: 1.50, currency: "usd" },
+  { id: "anthropic/claude-sonnet-4.6", provider: "Anthropic", model: "Claude Sonnet 4.6", input: 3.0, output: 15.0, cacheRead: 0.30, currency: "usd" },
+  { id: "anthropic/claude-haiku-4.5", provider: "Anthropic", model: "Claude Haiku 4.5", input: 0.80, output: 4.0, cacheRead: 0.08, currency: "usd" },
+  // OpenAI (USD)
+  { id: "openai/gpt-4o", provider: "OpenAI", model: "GPT-4o", input: 2.50, output: 10.0, cacheRead: 1.25, currency: "usd" },
+  { id: "openai/gpt-4o-mini", provider: "OpenAI", model: "GPT-4o mini", input: 0.15, output: 0.60, cacheRead: 0, currency: "usd" },
+  { id: "openai/gpt-5.4", provider: "OpenAI", model: "GPT-5.4", input: 2.50, output: 10.0, cacheRead: 1.25, currency: "usd" },
+  { id: "openai/o1", provider: "OpenAI", model: "o1", input: 15.0, output: 60.0, cacheRead: 0, currency: "usd" },
+  { id: "openai/o3", provider: "OpenAI", model: "o3", input: 2.0, output: 8.0, cacheRead: 0.20, currency: "usd" },
+  { id: "openai/o3-mini", provider: "OpenAI", model: "o3-mini", input: 1.10, output: 4.40, cacheRead: 0, currency: "usd" },
+  { id: "openai/o4-mini", provider: "OpenAI", model: "o4-mini", input: 0.75, output: 4.50, cacheRead: 0.075, currency: "usd" },
+  // Google (USD)
+  { id: "google/gemini-2.5-pro", provider: "Google", model: "Gemini 2.5 Pro", input: 1.25, output: 10.0, cacheRead: 0.125, currency: "usd" },
+  { id: "google/gemini-2.5-flash", provider: "Google", model: "Gemini 2.5 Flash", input: 0.15, output: 1.25, cacheRead: 0.03, currency: "usd" },
+  { id: "google/gemini-2.0-flash", provider: "Google", model: "Gemini 2.0 Flash", input: 0.10, output: 0.40, cacheRead: 0.025, currency: "usd" },
+  // Zhipu (CNY)
+  { id: "zhipu/glm-5-turbo", provider: "Zhipu", model: "GLM-5-Turbo", input: 5.0, output: 22.0, cacheRead: 1.20, currency: "cny" },
+  { id: "zhipu/glm-5", provider: "Zhipu", model: "GLM-5", input: 4.0, output: 18.0, cacheRead: 1.0, currency: "cny" },
+  { id: "zhipu/glm-5.1", provider: "Zhipu", model: "GLM-5.1", input: 4.0, output: 18.0, cacheRead: 1.0, currency: "cny" },
+  { id: "zhipu/glm-4.7", provider: "Zhipu", model: "GLM-4.7", input: 2.0, output: 8.0, cacheRead: 0.40, currency: "cny" },
+  { id: "zhipu/glm-4.5-air", provider: "Zhipu", model: "GLM-4.5-Air", input: 0.80, output: 2.0, cacheRead: 0.16, currency: "cny" },
+  // DeepSeek (CNY)
+  { id: "deepseek/v3", provider: "DeepSeek", model: "DeepSeek-V3", input: 2.0, output: 3.0, cacheRead: 0.20, currency: "cny" },
+  { id: "deepseek/r1", provider: "DeepSeek", model: "DeepSeek-R1", input: 2.0, output: 3.0, cacheRead: 0.20, currency: "cny" },
+  // Mistral (USD)
+  { id: "mistral/large", provider: "Mistral", model: "Mistral Large", input: 2.0, output: 6.0, cacheRead: 0, currency: "usd" },
+  { id: "mistral/medium", provider: "Mistral", model: "Mistral Medium", input: 1.0, output: 3.0, cacheRead: 0, currency: "usd" },
+  { id: "mistral/codestral", provider: "Mistral", model: "Codestral", input: 0.20, output: 0.60, cacheRead: 0, currency: "usd" },
+];
+
+export function calculateCost(
+  input: number,
+  output: number,
+  cacheRead: number,
+  price: { input: number; output: number; cacheRead: number }
+): number {
+  return (input * price.input + output * price.output + cacheRead * price.cacheRead) / 1_000_000;
+}
+
+export function findPricingEntry(id: string): PricingEntry | undefined {
+  return PRICING_DB.find((e) => e.id === id);
+}
+
+export function detectModels(data: DashboardData): string[] {
+  return Object.keys(data.models);
+}
+
+export function fuzzyMatchModel(modelName: string): PricingEntry | undefined {
+  const lower = modelName.toLowerCase();
+  // Try exact id match first (e.g. "zhipu/glm-5.1")
+  const exact = PRICING_DB.find((e) => e.id === lower || e.model.toLowerCase() === lower);
+  if (exact) return exact;
+  // Substring matching: check if the model name contains or is contained in an entry's id/model
+  for (const entry of PRICING_DB) {
+    const idParts = entry.id.split("/")[1] || entry.id;
+    if (lower.includes(idParts) || idParts.includes(lower)) return entry;
+  }
+  // Broader matching by provider
+  for (const entry of PRICING_DB) {
+    if (lower.includes(entry.provider.toLowerCase())) return entry;
+  }
+  return undefined;
+}
+
+export function getEffectivePricing(
+  modelName: string,
+  config: PricingConfig
+): { input: number; output: number; cacheRead: number; currency: "usd" | "cny" } {
+  // 1. Custom pricing override
+  const custom = config.customPricing[modelName];
+  if (custom) return { input: custom.input, output: custom.output, cacheRead: custom.cacheRead, currency: custom.currency };
+  // 2. Mapped pricing entry
+  const mappedId = config.modelMappings[modelName];
+  if (mappedId) {
+    const entry = findPricingEntry(mappedId);
+    if (entry) return { input: entry.input, output: entry.output, cacheRead: entry.cacheRead, currency: entry.currency };
+  }
+  // 3. Fuzzy match
+  const fuzzy = fuzzyMatchModel(modelName);
+  if (fuzzy) return { input: fuzzy.input, output: fuzzy.output, cacheRead: fuzzy.cacheRead, currency: fuzzy.currency };
+  // 4. Fallback
+  return { input: 0, output: 0, cacheRead: 0, currency: "usd" };
+}
+
+export function getDefaultConfig(data: DashboardData): PricingConfig {
+  const config: PricingConfig = { modelMappings: {}, customPricing: {} };
+  for (const modelName of detectModels(data)) {
+    const match = fuzzyMatchModel(modelName);
+    if (match) {
+      config.modelMappings[modelName] = match.id;
+    }
+  }
+  return config;
+}
+
+export function loadConfig(data: DashboardData): PricingConfig {
+  try {
+    const raw = localStorage.getItem(LS_KEY);
+    if (raw) {
+      const parsed = JSON.parse(raw) as PricingConfig;
+      if (parsed.modelMappings && parsed.customPricing) return parsed;
+    }
+  } catch {
+    // ignore
+  }
+  return getDefaultConfig(data);
+}
+
+export function saveConfig(config: PricingConfig): void {
+  localStorage.setItem(LS_KEY, JSON.stringify(config));
+}