@johndimm/constellations 1.0.1 → 1.0.3

package/services/aiUtils.ts

@@ -1,3 +1,25 @@
+/** Read a Vite-style env var from process (e.g. Next.js) or import.meta (Vite). */
+export function readBundledEnv(key: string): string {
+  const fromProcess = getEnvVar(key);
+  if (fromProcess) return fromProcess;
+  // Dual-bundler: Vite uses `VITE_*`; Next exposes the same values as `NEXT_PUBLIC_VITE_*`
+  // (see apps/soundings/next.config `env`), not `NEXT_PUBLIC_*` with the `VITE_` infix stripped.
+  const nextKey = key.startsWith("VITE_") ? `NEXT_PUBLIC_${key}` : key;
+  const alt = getEnvVar(nextKey);
+  if (alt) return alt;
+  try {
+    // @ts-ignore
+    if (typeof import.meta !== "undefined" && import.meta.env) {
+      // @ts-ignore
+      const v = import.meta.env[key];
+      if (v != null && String(v) !== "") return String(v);
+    }
+  } catch {
+    /* ignore */
+  }
+  return "";
+}
+
 export const getEnvVar = (name: string): string => {
   // Try process.env first (Node.js / Server)
   try {
@@ -20,125 +42,72 @@ export const getEnvVar = (name: string): string => {
   return "";
 };
 
-export const getEnvCacheUrl = (): string => {
-  // Use literal access for Vite static replacement
-  let url = "";
-  try {
-    // @ts-ignore
-    if (typeof import.meta !== 'undefined' && import.meta.env) {
-      // @ts-ignore
-      url = import.meta.env.VITE_CACHE_URL || import.meta.env.VITE_CACHE_API_URL || "";
-    }
-  } catch (e) { }
-
-  if (url) return url;
-
-  return getEnvVar("VITE_CACHE_URL") || getEnvVar("VITE_CACHE_API_URL");
-};
-
-export const getEnvGeminiModel = (): string => {
-  // Literal access for Vite
-  let urlModel = "";
-  try {
-    // @ts-ignore
-    if (typeof import.meta !== 'undefined' && import.meta.env) {
-      // @ts-ignore
-      urlModel = import.meta.env.VITE_GEMINI_MODEL || "";
-    }
-  } catch (e) { }
-  if (urlModel) return urlModel;
-
-  return getEnvVar("VITE_GEMINI_MODEL") || "gemini-2.5-flash";
-};
-
-export const getEnvGeminiModelClassify = (): string => {
-  // Literal access for Vite
-  let urlModel = "";
-  try {
-    // @ts-ignore
-    if (typeof import.meta !== 'undefined' && import.meta.env) {
-      // @ts-ignore
-      urlModel = import.meta.env.VITE_GEMINI_MODEL_CLASSIFY || "";
-    }
-  } catch (e) { }
-  if (urlModel) return urlModel;
-
-  return getEnvVar("VITE_GEMINI_MODEL_CLASSIFY") || getEnvGeminiModel();
-};
-
-export type LlmProviderId = "gemini" | "openai" | "deepseek" | "anthropic";
-
-/** Node cache server only: per-request override from JSON body `llmProvider`. */
-let readServerRequestLlm: () => LlmProviderId | null = () => null;
-
-/** Register reader from server.ts (uses AsyncLocalStorage). No-op in the browser bundle. */
-export function registerServerRequestLlmReader(reader: () => LlmProviderId | null): void {
-  readServerRequestLlm = reader;
-}
-
-const BROWSER_LLM_KEY = "constellations_llm_provider";
+let __ccLoggedCacheUrlDiag = false;
 
-/** In-browser override (ControlPanel); ignored on the Node cache server. */
-export function getBrowserLlmOverride(): LlmProviderId | null {
-  if (typeof window === "undefined") return null;
+export const getEnvCacheUrl = (): string => {
+  // Next.js only inlines `process.env.FOO` when `FOO` is a static property access. Dynamic
+  // `process.env[name]` stays empty in the browser bundle, which disables the cache proxy and
+  // forces slow client-only paths (e.g. `extractMusicEntity`).
+  let source: "static-process" | "readBundled" | "none" = "none";
+  let out = "";
   try {
-    const v = window.localStorage.getItem(BROWSER_LLM_KEY)?.trim().toLowerCase();
-    if (v === "openai" || v === "deepseek" || v === "anthropic" || v === "gemini") {
-      return v;
+    if (typeof process !== "undefined" && process.env) {
+      const direct = (
+        process.env.VITE_CACHE_URL ||
+        process.env.VITE_CACHE_API_URL ||
+        process.env.NEXT_PUBLIC_VITE_CACHE_URL ||
+        process.env.NEXT_PUBLIC_VITE_CACHE_API_URL ||
+        ""
+      ).trim();
+      if (direct) {
+        out = direct;
+        source = "static-process";
+      }
     }
   } catch {
-    /* ignore */
+    /* empty */
   }
-  return null;
-}
-
-/** Persist or clear browser LLM choice. Pass null to follow .env / VITE_LLM_PROVIDER again. */
-export function setBrowserLlmOverride(provider: LlmProviderId | null): void {
-  if (typeof window === "undefined") return;
-  try {
-    if (provider === null) {
-      window.localStorage.removeItem(BROWSER_LLM_KEY);
-    } else {
-      window.localStorage.setItem(BROWSER_LLM_KEY, provider);
+  if (!out) {
+    const bundled = (
+      readBundledEnv("VITE_CACHE_URL") ||
+      readBundledEnv("VITE_CACHE_API_URL") ||
+      ""
+    ).trim();
+    if (bundled) {
+      out = bundled;
+      source = "readBundled";
     }
-  } catch {
-    /* ignore */
   }
-}
-
-/** Set LLM_PROVIDER (preferred on servers) or VITE_LLM_PROVIDER to openai | deepseek | anthropic | gemini (default). In the browser, a ControlPanel choice overrides via localStorage. On the cache server, an optional JSON field llmProvider overrides for that request only. */
-export function getLlmProvider(): LlmProviderId {
-  const req = readServerRequestLlm();
-  if (req) return req;
+  if (
+    typeof window !== "undefined" &&
+    typeof process !== "undefined" &&
+    process.env.NODE_ENV === "development" &&
+    !__ccLoggedCacheUrlDiag
+  ) {
+    __ccLoggedCacheUrlDiag = true;
+    let host = "";
+    try {
+      if (out) host = new URL(out).host;
+    } catch {
+      host = "(invalid URL)";
+    }
+    console.log("[Constellations]", "getEnvCacheUrl (first read)", { resolved: !!out, source, host });
+  }
+  return out;
+};
 
-  const browser = getBrowserLlmOverride();
-  if (browser) return browser;
+/** Default when unset; override with VITE_GEMINI_MODEL or NEXT_PUBLIC_GEMINI_MODEL (Next maps via next.config env). */
+const DEFAULT_GEMINI_MODEL = "gemini-2.5-flash";
 
-  // LLM_PROVIDER first: Render/Heroku/etc. set this; VITE_* must not override it if both exist.
-  const raw = (getEnvVar("LLM_PROVIDER") || getEnvVar("VITE_LLM_PROVIDER") || "gemini")
-    .trim()
-    .toLowerCase();
-  if (raw === "openai" || raw === "deepseek" || raw === "anthropic" || raw === "gemini") {
-    return raw;
-  }
-  return "gemini";
-}
+export const getEnvGeminiModel = (): string => {
+  const m = readBundledEnv("VITE_GEMINI_MODEL").trim();
+  return m || DEFAULT_GEMINI_MODEL;
+};
 
-/** API key for the active provider (Gemini uses existing getApiKey / AI Studio). */
-export async function getLlmApiKey(): Promise<string> {
-  const p = getLlmProvider();
-  if (p === "gemini") {
-    return getApiKey();
-  }
-  // Prefer plain env names on servers (OPENAI_API_KEY); VITE_* is for local Vite client.
-  const keys: Record<Exclude<LlmProviderId, "gemini">, [string, string]> = {
-    openai: ["OPENAI_API_KEY", "VITE_OPENAI_API_KEY"],
-    deepseek: ["DEEPSEEK_API_KEY", "VITE_DEEPSEEK_API_KEY"],
-    anthropic: ["ANTHROPIC_API_KEY", "VITE_ANTHROPIC_API_KEY"],
-  };
-  const [primary, secondary] = keys[p];
-  return getEnvVar(primary) || getEnvVar(secondary);
-}
+export const getEnvGeminiModelClassify = (): string => {
+  const m = readBundledEnv("VITE_GEMINI_MODEL_CLASSIFY").trim();
+  return m || getEnvGeminiModel();
+};
 
 // Robust text extraction from Gemini API response
 export function getResponseText(response: any): string {
@@ -178,6 +147,80 @@ export function cleanJson(text: unknown): string {
   return text.replace(/```(?:json)?\s*([\s\S]*?)\s*```/g, '$1').trim();
 }
 
+/** Extract first top-level `{...}` or `[...]` from a string (string-aware). */
+function extractFirstJsonSlice(s: string): string | null {
+  const trimmed = s.trim();
+  const startObj = trimmed.indexOf("{");
+  const startArr = trimmed.indexOf("[");
+  let start = -1;
+  if (startObj >= 0 && (startArr < 0 || startObj < startArr)) start = startObj;
+  else if (startArr >= 0) start = startArr;
+  else return null;
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start; i < trimmed.length; i++) {
+    const c = trimmed[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (c === "\\") {
+        escape = true;
+        continue;
+      }
+      if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      continue;
+    }
+    if (c === "{" || c === "[") depth++;
+    else if (c === "}" || c === "]") {
+      depth--;
+      if (depth === 0) return trimmed.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+
+/**
+ * Parse JSON from Gemini / proxy output: handles markdown fences, then plain text that may
+ * include a JSON object embedded in prose (or model noise like "You are a…" before the object).
+ */
+export function parseJsonFromModelText(text: unknown): unknown | null {
+  if (typeof text !== "string" || !text.trim()) return null;
+  const cleaned = cleanJson(text);
+  if (!cleaned) return null;
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    const slice = extractFirstJsonSlice(cleaned);
+    if (!slice) return null;
+    try {
+      return JSON.parse(slice);
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Read a fetch Response and parse JSON without throwing. Non-OK responses and HTML or plain
+ * error pages (e.g. Wikipedia rate limit text starting with "You are...") return null.
+ */
+export async function jsonFromResponse<T = unknown>(res: Response): Promise<T | null> {
+  const text = await res.text();
+  if (!res.ok) return null;
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return null;
+  }
+}
+
 // Safely retrieve API key
 export async function getApiKey() {
   let key = "";
@@ -229,28 +272,50 @@ export async function getApiKey() {
 }
 
 /**
- * `fetch` with a hard timeout so a hung cache/LLM endpoint cannot leave expansions spinning forever.
- * Do not pass `signal` in init unless you compose with this controller (not supported here).
+ * Strip YouTube channel names, bare years, and other web junk from a pasted search term.
+ * Handles multi-line pastes like:
+ *   "Alban Berg- Lyric Suite Part 3 Allegro misterioso\nplayingmusiconmars\n1926"
+ * Returns the first substantive line with trailing noise removed.
  */
-export async function fetchWithTimeout(
-  input: RequestInfo | URL,
-  init: RequestInit = {},
-  timeoutMs = 45000,
-): Promise<Response> {
-  const controller = new AbortController();
-  const id = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(input, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(id);
+export function sanitizeSearchTerm(raw: string): string {
+  if (!raw || typeof raw !== "string") return raw;
+
+  const RECORD_LABELS = /^(warner classics|deutsche grammophon|ecm records|decca|hyperion|harmonia mundi|naïve|sony classical|emi classics|philips classics|virgin classics|erato|chandos|bis records|naxos|ondine|telarc)$/i;
+
+  const isJunkLine = (line: string): boolean => {
+    const t = line.trim();
+    if (!t) return true;
+    // Pure year
+    if (/^\d{4}$/.test(t)) return true;
+    // YouTube channel pattern: no spaces, lowercase + digits, length > 4
+    if (!/\s/.test(t) && /[a-z]/.test(t) && /\d/.test(t) && t.length > 4) return true;
+    // Single word, all lowercase, no digits — likely a username without numbers
+    if (!/\s/.test(t) && t === t.toLowerCase() && t.length > 10) return true;
+    // Known record labels when appearing alone on a line
+    if (RECORD_LABELS.test(t)) return true;
+    return false;
+  };
+
+  // Split on newlines, filter junk lines
+  const lines = raw.split(/\n/).map(l => l.trim()).filter(l => !isJunkLine(l));
+  if (lines.length === 0) return raw.split(/\n/)[0]?.trim() || raw.trim();
+
+  // From the first good line, strip trailing tokens that look like channel names or years
+  let first = lines[0].replace(/\s+[a-z][a-z0-9]{4,}\d+\s*$/i, "").trim();  // e.g. "concerts1899"
+
+  // "Performer plays/performs Composer: Work" → "Composer: Work"
+  // e.g. "Gautier Capuçon plays Fauré: Sicilienne" → "Fauré: Sicilienne"
+  const playsMatch = first.match(/^.+?\s+(?:plays?|performs?|interprets?|conducted?\s+by)\s+(.+)$/i);
+  if (playsMatch) {
+    const extracted = playsMatch[1].trim();
+    if (extracted.length > 3) first = extracted;
   }
-}
 
-/** Truncate for console; LLM prompts/contexts can be huge. */
-export function clipForLlmLog(text: string, maxChars = 16000): string {
-  const s = String(text ?? "");
-  if (s.length <= maxChars) return s;
-  return `${s.slice(0, maxChars)}\n… [truncated ${s.length - maxChars} more chars]`;
+  // Strip trailing parenthetical performer info: "Work (Orchestra / Conductor)" → "Work"
+  // e.g. "Pavane pour une infante défunte (Orchestre national de France / Dalia Stasevska)"
+  first = first.replace(/\s*\([^)]*(?:\/|orchestra|ensemble|philharmonic|conducted)[^)]*\)\s*$/i, "").trim();
+
+  return first || lines[0];
 }
 
 // Wrap promise with timeout
@@ -272,92 +337,117 @@ export function withTimeout<T>(promise: Promise<T>, ms: number, errorMsg: string
   });
 }
 
-/** Collects message / nested API fields / JSON so 429s are not missed as "[object Object]". */
-function errorTextForMatch(e: any): string {
-  const parts: string[] = [];
-  if (e?.message) parts.push(String(e.message));
-  if (e?.error) {
-    parts.push(
-      typeof e.error === "string" ? e.error : JSON.stringify(e.error)
-    );
-  }
-  if (e?.status) parts.push(String(e.status));
-  if (e?.code !== undefined && e?.code !== null) parts.push(String(e.code));
-  if (typeof e === "string") parts.push(e);
-  if (typeof e === "object" && parts.length === 0) {
-    try {
-      parts.push(JSON.stringify(e));
-    } catch {
-      parts.push(String(e));
-    }
-  }
-  return parts.join(" ").toLowerCase();
+export function clipForLlmLog(text: string, maxChars = 16000): string {
+  const s = String(text ?? "");
+  if (s.length <= maxChars) return s;
+  return `${s.slice(0, maxChars)}\n… [truncated ${s.length - maxChars} more chars]`;
 }
 
-/** True for HTTP 429 / RESOURCE_EXHAUSTED (e.g. Vertex quota). */
 export function isRateLimitError(e: any): boolean {
-  if (e?.error?.code === 429) return true;
-  if (e?.code === 429) return true;
+  if (e?.error?.code === 429 || e?.code === 429) return true;
   const s = String(e?.error?.status || "").toLowerCase();
   if (s === "resource_exhausted") return true;
-  const t = errorTextForMatch(e);
+  const t = [e?.message, e?.error, e?.status, e?.code, typeof e === "string" ? e : ""]
+    .map(x => (typeof x === "object" ? JSON.stringify(x) : String(x ?? "")))
+    .join(" ")
+    .toLowerCase();
   return t.includes("429") || t.includes("resource_exhausted");
 }
 
-function isTransientError(errText: string): boolean {
-  return (
-    errText.includes("429") ||
-    errText.includes("resource_exhausted") ||
-    errText.includes("rate limit") ||
-    errText.includes("timeout") ||
-    errText.includes("fetch") ||
-    errText.includes("network") ||
-    errText.includes("econnreset") ||
-    errText.includes("etimedout") ||
-    errText.includes("503") ||
-    errText.includes("unavailable")
-  );
+export type LlmProviderId = "gemini" | "deepseek" | "openai" | "anthropic";
+
+const BROWSER_LLM_KEY = "constellations_llm_provider";
+
+function isValidProvider(v: string): v is LlmProviderId {
+  return v === "gemini" || v === "deepseek" || v === "openai" || v === "anthropic";
+}
+
+export function getBrowserLlmOverride(): LlmProviderId | null {
+  if (typeof window === "undefined") return null;
+  try {
+    const v = window.localStorage.getItem(BROWSER_LLM_KEY)?.trim().toLowerCase() ?? "";
+    if (isValidProvider(v)) return v;
+  } catch {}
+  return null;
+}
+
+export function setBrowserLlmOverride(provider: LlmProviderId | null): void {
+  if (typeof window === "undefined") return;
+  try {
+    if (provider === null) {
+      window.localStorage.removeItem(BROWSER_LLM_KEY);
+    } else {
+      window.localStorage.setItem(BROWSER_LLM_KEY, provider);
+    }
+  } catch {}
+}
+
+// Server-side per-request override (Node.js module memory, set before each proxy call).
+// This is intentionally simple — dev server is single-user so concurrent-request races are fine.
+let _serverLlmOverride: LlmProviderId | null = null;
+
+export function setServerLlmOverride(provider: LlmProviderId | null): void {
+  _serverLlmOverride = provider;
+}
+
+export function getLlmProvider(): LlmProviderId {
+  if (_serverLlmOverride) return _serverLlmOverride;
+  const browser = getBrowserLlmOverride();
+  if (browser) return browser;
+  const raw = (readBundledEnv("VITE_AI_PROVIDER") || "deepseek").trim().toLowerCase();
+  return isValidProvider(raw) ? raw : "deepseek";
 }
 
 /**
- * Retries on transient API failures. If a 429 (rate / quota) is seen, the run can extend
- * to `rateLimitAttempts` tries with longer waits (Vertex often needs many seconds between retries).
+ * Returns true if `term` is likely a person name (2–4 Title-Case words, no parens or digits,
+ * no leading article). Used as a sanity-check on LLM classification results and fallbacks.
+ * False-positives (e.g. "Star Wars") can happen, but this is only consulted when the model
+ * returns or falls back to isAtomic=false, so the worst case is a wrong default that the user
+ * can easily correct by re-searching with a disambiguated term.
  */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  attempts = 3,
-  backoffMs = 1000,
-  rateLimitAttempts = 8
-): Promise<T> {
+export function looksLikePersonName(term: string): boolean {
+  const t = term.trim();
+  if (/[()[\]{}]/.test(t)) return false;  // parenthetical tags → work title
+  if (/\d/.test(t)) return false;          // digits → year / track number
+  const words = t.split(/\s+/);
+  if (words.length < 2 || words.length > 4) return false;
+  // Leading stopwords rule out "The Godfather", "A Star Is Born", etc.
+  if (/^(the|a|an|of|in|on|at|to|for|with|by|la|le|les|el|los|das|der|die)$/i.test(words[0])) return false;
+  // Each word: Title-Case word (≥2 chars), single initial with period, or name suffix
+  const nameWordRe = /^[A-Z][a-z'-]{1,}\.?$|^[A-Z]\.$|^(Jr|Sr|II|III|IV|VI|VII|VIII|IX)\.?$/;
+  return words.every(w => nameWordRe.test(w));
+}
+
+// Improved retry logic with exponential backoff and jitter
+export async function withRetry<T>(fn: () => Promise<T>, attempts = 3, backoffMs = 1000): Promise<T> {
   let lastError: any;
-  let maxTries = Math.max(1, attempts);
-  for (let i = 0; i < maxTries; i++) {
+  for (let i = 0; i < attempts; i++) {
     try {
       return await fn();
     } catch (error: any) {
       lastError = error;
-      if (isRateLimitError(error)) {
-        maxTries = Math.max(maxTries, rateLimitAttempts);
-      }
-      const errText = errorTextForMatch(error);
-      const retryable = isTransientError(errText);
-      const isLast = i + 1 >= maxTries;
-      if (isLast || !retryable) {
+      const errorStr = String(error?.message || error || '').toLowerCase();
+      // Only retry if it looks like a transient error (rate limit, timeout, or network)
+      const isRetryable =
+        errorStr.includes('429') ||
+        errorStr.includes('resource_exhausted') ||
+        errorStr.includes('rate limit') ||
+        errorStr.includes('timeout') ||
+        errorStr.includes('fetch') ||
+        errorStr.includes('network');
+
+      if (i < attempts - 1 && isRetryable) {
+        // Exponential backoff: 1s, 2s, 4s...
+        const baseDelay = backoffMs * Math.pow(2, i);
+        // Add jitter: +/- 20% to avoid "thundering herd"
+        const jitter = baseDelay * 0.2 * (Math.random() * 2 - 1);
+        const delay = Math.max(0, baseDelay + jitter);
+
+        console.warn(`[Retry] Attempt ${i + 1} failed. Retrying in ${Math.round(delay)}ms...`, errorStr);
+        await new Promise(res => setTimeout(res, delay));
+      } else {
         throw error;
       }
-      const isRate = isRateLimitError(error);
-      // Longer waits for 429/RESOURCE_EXHAUSTED (capped) vs generic transient errors
-      const baseDelay = isRate
-        ? Math.min(90_000, 5_000 * Math.pow(1.45, i))
-        : backoffMs * Math.pow(2, i);
-      const jitter = baseDelay * 0.2 * (Math.random() * 2 - 1);
-      const delay = Math.max(0, baseDelay + jitter);
-
-      console.warn(
-        `[Retry] Attempt ${i + 1} failed. Retrying in ${Math.round(delay)}ms...`,
-        errText.slice(0, 500)
-      );
-      await new Promise((res) => setTimeout(res, delay));
     }
   }
   throw lastError;

package/services/cacheService.ts

@@ -1,3 +1,4 @@
+"use client";
 import { getEnvCacheUrl } from "./aiUtils";
 
 // Logic to determine effective cache base URL

package/services/crossrefService.ts

@@ -1,3 +1,4 @@
+"use client";
 type CrossrefWork = {
   DOI?: string;
   title?: string[];