Remembering What the AI Decided: Four Marks in the Cache Key Paid Off on Model-Swap Day

// aiCache.ts — AI の分類結果を端末に覚えさせる小さなキャッシュ層
// 保存先は MMKV 互換の最小インターフェースに絞っています（テストでは Map で代用）。
export interface KV {
  getString(key: string): string | undefined;
  set(key: string, value: string): void;
  delete(key: string): void;
  getAllKeys(): string[];
}
 
export interface CacheConfig {
  task: string;          // 例: "wallpaper-category"
  model: string;         // 例: "claude-sonnet-5-5"（差し替えの日にここだけ変える）
  promptVersion: string; // 指示文を直したら上げる。例: "p3"
  ttlMs: number;         // 例: 30 日
  maxEntries: number;    // 端末に溜める上限
  minConfidence: number; // これ未満の答えは覚えない
}
 
export interface Answer { label: string; confidence: number }
interface Stored extends Answer { at: number; model: string; promptVersion: string }
 
const ROOT = "ai:v1:";
 
export function createAiCache(
  kv: KV,
  cfg: CacheConfig,
  ask: (contentId: string) => Promise<Answer>,
  now: () => number = Date.now,
) {
  const prefix = `${ROOT}${cfg.task}:${cfg.model}:${cfg.promptVersion}:`;
  const inflight = new Map<string, Promise<Answer>>();
  const stats = { hit: 0, miss: 0, joined: 0, skippedLowConfidence: 0, evicted: 0 };
 
  function read(key: string): Stored | undefined {
    const raw = kv.getString(key);
    if (!raw) return undefined;
    try {
      const v = JSON.parse(raw) as Stored;
      // キーに model / promptVersion が入っていても、値側でも照合します（手で書き換えた事故の保険）
      if (v.model !== cfg.model || v.promptVersion !== cfg.promptVersion) return undefined;
      if (now() - v.at > cfg.ttlMs) return undefined;
      if (typeof v.label !== "string" || typeof v.confidence !== "number") return undefined;
      return v;
    } catch {
      kv.delete(key); // 壊れた JSON は残さない
      return undefined;
    }
  }
 
  function trim() {
    const mine = kv.getAllKeys().filter((k) => k.startsWith(prefix));
    if (mine.length <= cfg.maxEntries) return;
    const aged = mine
      .map((k) => ({ k, at: (JSON.parse(kv.getString(k) ?? "{}") as Stored).at ?? 0 }))
      .sort((a, b) => a.at - b.at);
    for (const { k } of aged.slice(0, mine.length - cfg.maxEntries)) {
      kv.delete(k);
      stats.evicted++;
    }
  }
 
  async function classify(contentId: string): Promise<Answer> {
    const key = prefix + contentId;
    const hit = read(key);
    if (hit) { stats.hit++; return { label: hit.label, confidence: hit.confidence }; }
 
    const running = inflight.get(key);
    if (running) { stats.joined++; return running; }
 
    stats.miss++;
    const p = (async () => {
      try {
        const ans = await ask(contentId);
        if (ans.confidence >= cfg.minConfidence) {
          const rec: Stored = { ...ans, at: now(), model: cfg.model, promptVersion: cfg.promptVersion };
          kv.set(key, JSON.stringify(rec));
          trim();
        } else {
          stats.skippedLowConfidence++;
        }
        return ans;
      } finally {
        inflight.delete(key); // 失敗しても必ず外す。外さないと次の呼び出しが同じ失敗を受け取り続けます
      }
    })();
    inflight.set(key, p);
    return p;
  }
 
  // モデルや指示文を差し替えたあと、古い版の答えを端末から掃除します。
  function sweepOldVersions(): number {
    let n = 0;
    for (const k of kv.getAllKeys()) {
      if (k.startsWith(`${ROOT}${cfg.task}:`) && !k.startsWith(prefix)) { kv.delete(k); n++; }
    }
    return n;
  }
 
  return { classify, sweepOldVersions, stats };
}

// wallpaperCategory.ts — usage from the screen (the MMKV wrapper and hook are a type-checked sketch; I have not run them on a device)
import { MMKV } from "react-native-mmkv";
import { createAiCache, type KV } from "./aiCache";
 
const mmkv = new MMKV({ id: "ai-answers" });
const kv: KV = {
  getString: (k) => mmkv.getString(k),
  set: (k, v) => mmkv.set(k, v),
  delete: (k) => mmkv.delete(k), // `remove` in some versions
  getAllKeys: () => mmkv.getAllKeys(),
};
 
// On swap day, these two lines are the only thing you change
const MODEL = "claude-sonnet-5-5";
const PROMPT_VERSION = "p1";
 
export const categoryCache = createAiCache(
  kv,
  { task: "wallpaper-category", model: MODEL, promptVersion: PROMPT_VERSION,
    ttlMs: 30 * 24 * 3600 * 1000, maxEntries: 2000, minConfidence: 0.6 },
  async (id) => {
    // Point this at your own gateway, such as an Edge Function, so no key ships in the app.
    const res = await fetch(`https://YOUR_PROJECT.functions.supabase.co/classify?id=${id}`);
    if (!res.ok) throw new Error(`classify ${res.status}`);
    return (await res.json()) as { label: string; confidence: number };
  },
);
 
// Once at startup: sweep answers left over from older models or prompts.
categoryCache.sweepOldVersions();

// test_inflight.ts — node --experimental-strip-types test_inflight.ts
import { createAiCache } from "./aiCache.ts";
import { memKV } from "./mem.ts";
 
const cfg = { task: "t", model: "m1", promptVersion: "p1", ttlMs: 864e5, maxEntries: 100, minConfidence: 0.6 };
 
// Forgetful version (removes only inside then)
const inflight = new Map<string, Promise<number>>();
let calls = 0;
const flaky = async () => { calls++; if (calls === 1) throw new Error("timeout"); return 1; };
const buggy = (k: string) => {
  const r = inflight.get(k); if (r) return r;
  const p = flaky().then((v) => { inflight.delete(k); return v; }); // not removed on failure
  inflight.set(k, p); return p;
};
const a: string[] = [];
for (let i = 0; i < 3; i++) { try { await buggy("k"); a.push("ok"); } catch { a.push("fail"); } }
console.log("forgetful:", a.join(","), "calls", calls); // fail,fail,fail calls 1
 
// This implementation
let fail = true, n = 0;
const cache = createAiCache(memKV(), cfg, async () => { n++; if (fail) { fail = false; throw new Error("timeout"); } return { label: "x", confidence: 0.9 }; });
const b: string[] = [];
for (let i = 0; i < 3; i++) { try { await cache.classify("1"); b.push("ok"); } catch { b.push("fail"); } }
console.log("this one:", b.join(","), "calls", n); // fail,ok,ok calls 2