@ifc-lite/viewer 1.14.1 → 1.14.3

package/src/lib/llm/ClerkChatSync.tsx

@@ -0,0 +1,74 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { useEffect } from 'react';
+import { useAuth } from '@clerk/clerk-react';
+import { useViewerStore } from '@/store';
+
+/**
+ * Sync Clerk session state into chat store for authenticated LLM requests.
+ * Keeps chat UX decoupled from auth/billing details.
+ */
+export function ClerkChatSync() {
+  const { isLoaded, isSignedIn, userId, getToken, has } = useAuth();
+  const setChatAuthToken = useViewerStore((s) => s.setChatAuthToken);
+  const switchChatUserContext = useViewerStore((s) => s.switchChatUserContext);
+  const currentChatUserId = useViewerStore((s) => s.chatStorageUserId);
+  const currentChatHasPro = useViewerStore((s) => s.chatHasPro);
+
+  useEffect(() => {
+    if (!isLoaded) return;
+
+    if (!isSignedIn) {
+      switchChatUserContext(null, false, {
+        clearPersistedCurrent: currentChatUserId !== null,
+        restoreMessages: false,
+      });
+      setChatAuthToken(null);
+      return;
+    }
+
+    let cancelled = false;
+
+    const syncAuth = async () => {
+      try {
+        const token = await getToken({ skipCache: true });
+        const proPlan = has?.({ plan: 'pro' }) ?? false;
+        const proFeature = has?.({ feature: 'pro_models' }) ?? false;
+        const nextHasPro = proPlan || proFeature;
+        if (!cancelled) {
+          // Avoid resetting chat usage/messages on routine token refreshes for
+          // the same signed-in user. Only switch context when identity or
+          // entitlement actually changes.
+          if (currentChatUserId !== (userId ?? null) || currentChatHasPro !== nextHasPro) {
+            switchChatUserContext(userId ?? null, nextHasPro, {
+              clearPersistedCurrent: currentChatUserId !== null && currentChatUserId !== userId,
+              restoreMessages: true,
+            });
+          }
+          if (token) {
+            setChatAuthToken(token);
+          }
+        }
+      } catch {
+        if (!cancelled) {
+          // Preserve the current signed-in chat context on transient token
+          // refresh failures. Explicit sign-out is handled above.
+        }
+      }
+    };
+
+    void syncAuth();
+    // Keep short-lived JWTs fresh so chat/usage polling doesn't reuse expired tokens.
+    const timer = window.setInterval(() => {
+      void syncAuth();
+    }, 15_000);
+    return () => {
+      cancelled = true;
+      window.clearInterval(timer);
+    };
+  }, [currentChatHasPro, currentChatUserId, getToken, has, isLoaded, isSignedIn, setChatAuthToken, switchChatUserContext, userId]);
+
+  return null;
+}

package/src/lib/llm/clerk-auth.ts

@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Auth helpers for the LLM chat integration.
+ *
+ * Setup:
+ * 1. Install: pnpm add @clerk/clerk-react
+ * 2. Set VITE_CLERK_PUBLISHABLE_KEY in .env
+ * 3. Create plans in dashboard:
+ *    - Free plan (slug: 'free', features: ['llm_chat', 'free_models'])
+ *    - Pro plan (slug: 'pro', $8/month, features: ['llm_chat', 'free_models', 'pro_models'])
+ * 4. Wrap app with <ClerkProvider>
+ *
+ * Usage in components:
+ *
+ * ```tsx
+ * import { useAuth, useUser, Protect } from '@clerk/clerk-react';
+ *
+ * const { has } = useAuth();
+ * const hasPro = has?.({ feature: 'pro_models' }) ?? false;
+ *
+ * const { getToken } = useAuth();
+ * const token = await getToken();
+ * ```
+ */
+
+/**
+ * Subscription tiers and their features.
+ */
+export const SUBSCRIPTION_PLANS = {
+  free: {
+    slug: 'free',
+    name: 'Free',
+    features: ['llm_chat', 'free_models'],
+    description: 'AI chat with free models',
+  },
+  pro: {
+    slug: 'pro',
+    name: 'Pro',
+    features: ['llm_chat', 'free_models', 'pro_models'],
+    description: 'All models with monthly credits ($8/month)',
+  },
+} as const;
+
+/**
+ * Feature flags that map to plan features.
+ */
+export const FEATURES = {
+  LLM_CHAT: 'llm_chat',
+  FREE_MODELS: 'free_models',
+  PRO_MODELS: 'pro_models',
+} as const;
+
+/**
+ * Check if auth is configured (publishable key present).
+ * When not configured, the chat works in anonymous free-tier mode.
+ */
+export function isClerkConfigured(): boolean {
+  return Boolean(import.meta.env.VITE_CLERK_PUBLISHABLE_KEY);
+}

package/src/lib/llm/code-extractor.ts

@@ -0,0 +1,50 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Extract executable code blocks from LLM markdown responses.
+ */
+
+import type { CodeBlock } from './types.js';
+
+/**
+ * Parse fenced code blocks from a markdown string.
+ * Supports ```js, ```javascript, ```typescript, ```ts, and bare ``` blocks.
+ */
+export function extractCodeBlocks(markdown: string): CodeBlock[] {
+  const blocks: CodeBlock[] = [];
+  // Match ```lang\n...code...\n```
+  const regex = /```(\w*)\n([\s\S]*?)```/g;
+  let match: RegExpExecArray | null;
+  let index = 0;
+
+  while ((match = regex.exec(markdown)) !== null) {
+    const language = match[1] || 'js';
+    const code = match[2].trim();
+
+    // Only extract JS/TS code blocks (skip html, css, json, etc. unless they look like scripts)
+    const isExecutable = ['js', 'javascript', 'ts', 'typescript', ''].includes(language.toLowerCase());
+    // Also include unlabeled blocks that reference `bim.`
+    const referencesBim = code.includes('bim.');
+
+    if (isExecutable || referencesBim) {
+      blocks.push({ index, language, code });
+      index++;
+    }
+  }
+
+  return blocks;
+}
+
+/**
+ * Inject CSV data into a script as a `const DATA = [...]` declaration.
+ * Prepends the data array before the LLM-generated script body.
+ */
+export function injectCsvData(
+  script: string,
+  data: Record<string, string>[],
+): string {
+  const dataDeclaration = `const DATA = ${JSON.stringify(data)};\n\n`;
+  return dataDeclaration + script;
+}

package/src/lib/llm/context-builder.test.ts

@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseCSV } from './context-builder.js';
+
+test('parseCSV preserves embedded newlines inside quoted fields', () => {
+  const csv = 'Name,Notes\n"Lobby","Line 1\nLine 2"\n"Office","Single line"';
+
+  const parsed = parseCSV(csv);
+
+  assert.deepEqual(parsed.columns, ['Name', 'Notes']);
+  assert.equal(parsed.rows.length, 2);
+  assert.equal(parsed.rows[0]?.Notes, 'Line 1\nLine 2');
+  assert.equal(parsed.rows[1]?.Notes, 'Single line');
+});

package/src/lib/llm/context-builder.ts

@@ -0,0 +1,305 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Build model context from the current viewer state.
+ * This context is injected into the system prompt so the LLM
+ * knows what's currently loaded in the 3D viewer.
+ */
+
+import { useViewerStore } from '@/store';
+import type { ModelContext } from './system-prompt.js';
+import { IfcTypeEnum, type SpatialNode, type SpatialHierarchy } from '@ifc-lite/data';
+import {
+  extractClassificationsOnDemand,
+  extractMaterialsOnDemand,
+  extractPropertiesOnDemand,
+  extractQuantitiesOnDemand,
+  extractTypeEntityOwnProperties,
+  extractTypePropertiesOnDemand,
+} from '@ifc-lite/parser';
+import { resolveEntityRef } from '@/store/resolveEntityRef';
+
+let cachedTypeCountsFingerprint = '';
+let cachedTypeCounts: Record<string, number> = {};
+
+function buildFingerprint(state: ReturnType<typeof useViewerStore.getState>): string {
+  if (state.models.size > 0) {
+    const items: string[] = [];
+    for (const [id, model] of state.models) {
+      const count = model.ifcDataStore?.entities.count ?? 0;
+      items.push(`${id}:${count}`);
+    }
+    items.sort();
+    return `federated|${items.join('|')}`;
+  }
+
+  const legacyCount = state.ifcDataStore?.entities.count ?? 0;
+  return `legacy|${legacyCount}`;
+}
+
+function computeTypeCounts(state: ReturnType<typeof useViewerStore.getState>): Record<string, number> {
+  const typeCounts: Record<string, number> = {};
+
+  if (state.models.size > 0) {
+    for (const [, model] of state.models) {
+      const store = model.ifcDataStore;
+      if (!store) continue;
+      for (let i = 0; i < store.entities.count; i++) {
+        const id = store.entities.expressId[i];
+        const type = store.entities.getTypeName(id);
+        if (type) typeCounts[type] = (typeCounts[type] ?? 0) + 1;
+      }
+    }
+    return typeCounts;
+  }
+
+  if (state.ifcDataStore) {
+    const store = state.ifcDataStore;
+    for (let i = 0; i < store.entities.count; i++) {
+      const id = store.entities.expressId[i];
+      const type = store.entities.getTypeName(id);
+      if (type) typeCounts[type] = (typeCounts[type] ?? 0) + 1;
+    }
+  }
+
+  return typeCounts;
+}
+
+function collectStoreys(
+  hierarchy: SpatialHierarchy | undefined,
+  modelName?: string,
+): NonNullable<ModelContext['storeys']> {
+  if (!hierarchy?.project) return [];
+
+  const result: NonNullable<ModelContext['storeys']> = [];
+  const visit = (node: SpatialNode) => {
+    if (node.type === IfcTypeEnum.IfcBuildingStorey) {
+      result.push({
+        modelName,
+        name: node.name || 'Storey',
+        elevation: node.elevation ?? hierarchy.storeyElevations.get(node.expressId) ?? 0,
+        height: hierarchy.storeyHeights.get(node.expressId),
+        elementCount: hierarchy.byStorey.get(node.expressId)?.length ?? node.elements.length,
+      });
+    }
+    for (const child of node.children) visit(child);
+  };
+
+  visit(hierarchy.project);
+  result.sort((a, b) => a.elevation - b.elevation);
+  return result;
+}
+
+function getStoreForModel(
+  state: ReturnType<typeof useViewerStore.getState>,
+  modelId: string,
+): { store: NonNullable<typeof state.ifcDataStore> | null; modelName?: string } {
+  if (modelId === 'legacy') {
+    return { store: state.ifcDataStore, modelName: 'Model' };
+  }
+  const model = state.models.get(modelId);
+  return { store: model?.ifcDataStore ?? null, modelName: model?.name ?? modelId };
+}
+
+function uniqueStrings(values: Array<string | undefined>): string[] {
+  return Array.from(new Set(values.filter((value): value is string => Boolean(value))));
+}
+
+function collectSelectedEntities(state: ReturnType<typeof useViewerStore.getState>): NonNullable<ModelContext['selectedEntities']> {
+  const refs = state.selectedEntities.length > 0
+    ? state.selectedEntities
+    : state.selectedEntity
+      ? [state.selectedEntity]
+      : state.selectedEntityIds.size > 0
+        ? Array.from(state.selectedEntityIds).slice(0, 5).map((id) => resolveEntityRef(id))
+        : [];
+
+  return refs.slice(0, 5).flatMap((ref) => {
+    const { store, modelName } = getStoreForModel(state, ref.modelId);
+    if (!store) return [];
+
+    const type = store.entities.getTypeName(ref.expressId) || 'Unknown';
+    const name = store.entities.getName(ref.expressId) || `${type} #${ref.expressId}`;
+    const storeyId = store.spatialHierarchy?.elementToStorey.get(ref.expressId);
+    const storeyName = storeyId !== undefined ? (store.entities.getName(storeyId) || `Storey #${storeyId}`) : undefined;
+    const storeyElevation = storeyId !== undefined ? store.spatialHierarchy?.storeyElevations.get(storeyId) : undefined;
+
+    const rawPsets = extractPropertiesOnDemand(store, ref.expressId) as Array<{ name?: string; Name?: string }> | undefined;
+    const rawQsets = extractQuantitiesOnDemand(store, ref.expressId) as Array<{ name?: string; Name?: string }> | undefined;
+    const typeOwnPsets = extractTypeEntityOwnProperties(store, ref.expressId);
+    const inheritedTypeProps = extractTypePropertiesOnDemand(store, ref.expressId);
+    const rawMaterial = extractMaterialsOnDemand(store, ref.expressId);
+    const rawClassifications = extractClassificationsOnDemand(store, ref.expressId);
+    const instancePropertySets = uniqueStrings((rawPsets ?? []).map((pset) => pset.name ?? pset.Name));
+    const ownTypePropertySets = uniqueStrings(typeOwnPsets.map((pset) => pset.name));
+    const inheritedTypePropertySets = uniqueStrings((inheritedTypeProps?.properties ?? []).map((pset) => pset.name));
+    const selectionKind = ownTypePropertySets.length > 0 ? 'type' : 'occurrence';
+    const propertySets = (selectionKind === 'type' ? ownTypePropertySets : instancePropertySets).slice(0, 6);
+    const typePropertySets = (selectionKind === 'type' ? [] : inheritedTypePropertySets).slice(0, 6);
+    const quantitySets = (rawQsets ?? []).map((qset) => qset.name ?? qset.Name).filter((value): value is string => Boolean(value)).slice(0, 6);
+    const materialName = rawMaterial?.name ?? rawMaterial?.materials?.[0];
+    const classifications = rawClassifications
+      .map((classification) => classification.identification ?? classification.name ?? classification.system)
+      .filter((value): value is string => Boolean(value))
+      .slice(0, 4);
+
+    return [{
+      modelName,
+      name,
+      type,
+      selectionKind,
+      globalId: store.entities.getGlobalId?.(ref.expressId),
+      storeyName,
+      storeyElevation,
+      propertySets,
+      typePropertySets,
+      quantitySets,
+      materialName,
+      classifications,
+    }];
+  });
+}
+
+/**
+ * Snapshot the current model context from the Zustand store.
+ * Called before each LLM request to provide up-to-date context.
+ */
+export function getModelContext(): ModelContext {
+  const state = useViewerStore.getState();
+
+  const models: ModelContext['models'] = [];
+  const storeys: NonNullable<ModelContext['storeys']> = [];
+  const fingerprint = buildFingerprint(state);
+
+  // Federated models
+  if (state.models.size > 0) {
+    for (const [, model] of state.models) {
+      const entityCount = model.ifcDataStore?.entities.count ?? 0;
+      models.push({
+        name: model.name ?? 'Unknown',
+        entityCount,
+      });
+      storeys.push(...collectStoreys(model.ifcDataStore?.spatialHierarchy, model.name ?? 'Unknown'));
+    }
+  }
+
+  // Legacy single-model path
+  if (models.length === 0 && state.ifcDataStore) {
+    const store = state.ifcDataStore;
+    models.push({
+      name: 'Model',
+      entityCount: store.entities.count,
+    });
+    storeys.push(...collectStoreys(store.spatialHierarchy, 'Model'));
+  }
+
+  if (fingerprint !== cachedTypeCountsFingerprint) {
+    cachedTypeCounts = computeTypeCounts(state);
+    cachedTypeCountsFingerprint = fingerprint;
+  }
+
+  // Selection count
+  const selectedCount = state.selectedEntities.length > 0
+    ? state.selectedEntities.length
+    : state.selectedEntitiesSet.size > 0
+      ? state.selectedEntitiesSet.size
+      : state.selectedEntity
+        ? 1
+        : state.selectedEntityIds.size > 0
+          ? state.selectedEntityIds.size
+          : state.selectedEntityId !== null ? 1 : 0;
+  const selectedEntities = collectSelectedEntities(state);
+
+  return { models, typeCounts: cachedTypeCounts, selectedCount, storeys, selectedEntities };
+}
+
+/**
+ * Parse a CSV string into an array of row objects.
+ * Simple parser that handles quoted fields with commas.
+ */
+export function parseCSV(text: string): { columns: string[]; rows: Record<string, string>[] } {
+  const records = splitCSVRecords(text).filter((record) => record.trim().length > 0);
+  if (records.length === 0) return { columns: [], rows: [] };
+
+  // Parse header
+  const columns = parseCSVLine(records[0]);
+
+  // Parse rows
+  const rows: Record<string, string>[] = [];
+  for (let i = 1; i < records.length; i++) {
+    const values = parseCSVLine(records[i]);
+    const row: Record<string, string> = {};
+    for (let j = 0; j < columns.length; j++) {
+      row[columns[j]] = values[j] ?? '';
+    }
+    rows.push(row);
+  }
+
+  return { columns, rows };
+}
+
+function splitCSVRecords(text: string): string[] {
+  const normalized = text.replace(/\r\n?/g, '\n');
+  const records: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < normalized.length; i++) {
+    const char = normalized[i];
+    if (char === '"') {
+      if (inQuotes && normalized[i + 1] === '"') {
+        current += '""';
+        i++;
+        continue;
+      }
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+    if (char === '\n' && !inQuotes) {
+      records.push(current);
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+
+  if (current.length > 0) {
+    records.push(current);
+  }
+  return records;
+}
+
+/** Parse a single CSV line, handling quoted fields */
+function parseCSVLine(line: string): string[] {
+  const fields: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else {
+      if (char === '"') {
+        inQuotes = true;
+      } else if (char === ',' || char === ';') {
+        fields.push(current.trim());
+        current = '';
+      } else {
+        current += char;
+      }
+    }
+  }
+  fields.push(current.trim());
+  return fields;
+}

package/src/lib/llm/free-models.test.ts

@@ -0,0 +1,118 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import type { LLMModel } from './types.js';
+
+const viewerEnvUrl = new URL('../../../.env.local', import.meta.url);
+const VERIFY_OPENROUTER_MODELS = process.env.IFC_LITE_VERIFY_OPENROUTER_MODELS === '1';
+
+function parseEnvValue(envText: string, key: string): string {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = envText.match(new RegExp(`^${escapedKey}=(.*)$`, 'm'));
+  return match?.[1]?.trim() ?? '';
+}
+
+function parseCsvList(raw: string): string[] {
+  if (!raw) return [];
+  return raw
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+async function readConfiguredFreeModels(): Promise<string[] | null> {
+  const envOverride = process.env.VITE_LLM_FREE_MODELS ?? process.env.LLM_FREE_MODELS;
+  if (typeof envOverride === 'string' && envOverride.trim().length > 0) {
+    return parseCsvList(envOverride);
+  }
+
+  try {
+    const envText = await readFile(viewerEnvUrl, 'utf8');
+    const configuredFreeModels = parseCsvList(parseEnvValue(envText, 'VITE_LLM_FREE_MODELS'));
+    return configuredFreeModels.length > 0 ? configuredFreeModels : null;
+  } catch {
+    return null;
+  }
+}
+
+test('registry free models match configured env list', async (t) => {
+  const configuredFreeModels = await readConfiguredFreeModels();
+  if (!configuredFreeModels) {
+    t.skip('Viewer LLM env is not configured in this environment.');
+    return;
+  }
+
+  process.env.VITE_LLM_FREE_MODELS = configuredFreeModels.join(',');
+  process.env.VITE_LLM_PRO_MODELS_LOW = '';
+  process.env.VITE_LLM_PRO_MODELS_MEDIUM = '';
+  process.env.VITE_LLM_PRO_MODELS_HIGH = '';
+  process.env.VITE_LLM_IMAGE_MODELS = '';
+  process.env.VITE_LLM_FILE_ATTACHMENT_MODELS = '';
+
+  const { FREE_MODELS } = await import(`./models.ts?ts=${Date.now()}`) as { FREE_MODELS: LLMModel[] };
+  assert.deepEqual(
+    FREE_MODELS.map((model) => model.id),
+    configuredFreeModels,
+    'FREE_MODELS must follow VITE_LLM_FREE_MODELS order and values',
+  );
+});
+
+test('model capabilities follow override env lists', async () => {
+  process.env.VITE_LLM_FREE_MODELS = 'qwen/qwen3-coder,mistralai/devstral-2512';
+  process.env.VITE_LLM_PRO_MODELS_LOW = '';
+  process.env.VITE_LLM_PRO_MODELS_MEDIUM = '';
+  process.env.VITE_LLM_PRO_MODELS_HIGH = '';
+  process.env.VITE_LLM_IMAGE_MODELS = 'mistralai/devstral-2512';
+  process.env.VITE_LLM_FILE_ATTACHMENT_MODELS = 'qwen/qwen3-coder';
+
+  const { ALL_MODELS } = await import(`./models.ts?ts=${Date.now()}`) as { ALL_MODELS: LLMModel[] };
+  const qwen = ALL_MODELS.find((m) => m.id === 'qwen/qwen3-coder');
+  const devstral = ALL_MODELS.find((m) => m.id === 'mistralai/devstral-2512');
+
+  assert.ok(qwen, 'Expected qwen model in registry');
+  assert.ok(devstral, 'Expected devstral model in registry');
+  assert.equal(qwen.supportsImages, false);
+  assert.equal(qwen.supportsFileAttachments, true);
+  assert.equal(devstral.supportsImages, true);
+  assert.equal(devstral.supportsFileAttachments, false);
+});
+
+test('each configured free model exists in OpenRouter catalog', async (t) => {
+  if (!VERIFY_OPENROUTER_MODELS) {
+    t.skip('Set IFC_LITE_VERIFY_OPENROUTER_MODELS=1 to run the live OpenRouter catalog check.');
+    return;
+  }
+
+  const configuredFreeModels = await readConfiguredFreeModels();
+  if (!configuredFreeModels) {
+    t.skip('Viewer LLM env is not configured in this environment.');
+    return;
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 10_000);
+  try {
+    const response = await fetch('https://openrouter.ai/api/v1/models', { signal: controller.signal });
+    assert.equal(response.ok, true, `OpenRouter models API failed with HTTP ${response.status}`);
+
+    const payload = await response.json() as { data?: Array<{ id?: string }> };
+    const modelIdSet = new Set(
+      Array.isArray(payload.data)
+        ? payload.data.map((model) => model.id).filter((id): id is string => typeof id === 'string')
+        : [],
+    );
+
+    const missing = configuredFreeModels.filter((id) => !modelIdSet.has(id));
+    assert.deepEqual(
+      missing,
+      [],
+      `Configured free model IDs missing from OpenRouter catalog: ${missing.join(', ')}`,
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+});