fix: /models

server/modules/providers/services/provider-models.service.ts

@@ -1,11 +1,16 @@
 import { spawn } from 'node:child_process';
 import fsSync from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 
 import crossSpawn from 'cross-spawn';
 
 import type { LLMProvider, ProviderModelOption, ProviderModelsDefinition } from '@/shared/types.js';
 
 const OPEN_CODE_MODELS_TIMEOUT_MS = 20_000;
+export const PROVIDER_MODELS_CACHE_TTL_MS = 2 * 24 * 60 * 60 * 1000;
+const PROVIDER_MODELS_CACHE_VERSION = 1;
 
 /**
  * Claude (Anthropic) — SDK-style ids used by the UI and claude-sdk.js.
@@ -101,6 +106,31 @@ const BUILTIN_BY_PROVIDER: Record<Exclude<LLMProvider, 'opencode'>, ProviderMode
   gemini: GEMINI_MODELS,
 };
 
+type ProviderModelsOptions = {
+  cwd?: string;
+};
+
+type ProviderModelsLoader = (
+  provider: LLMProvider,
+  options?: ProviderModelsOptions,
+) => Promise<ProviderModelsDefinition>;
+
+type ProviderModelsCacheEntry = {
+  expiresAt: number;
+  models: ProviderModelsDefinition;
+};
+
+type ProviderModelsCacheFile = {
+  version: number;
+  entries: Record<string, ProviderModelsCacheEntry>;
+};
+
+type ProviderModelsServiceDependencies = {
+  cachePath?: string;
+  loadModels?: ProviderModelsLoader;
+  now?: () => number;
+};
+
 const MODEL_ID_LINE = /^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/i;
 
 const parseOpenCodeModelsStdout = (stdout: string): string[] => {
@@ -144,6 +174,81 @@ const resolveOpenCodeCwd = (cwd?: string): string => {
   return process.cwd();
 };
 
+const getProviderModelsCachePath = (): string =>
+  process.env.CLOUDCLI_PROVIDER_MODELS_CACHE_PATH
+  || path.join(os.homedir(), '.cloudcli', 'provider-models-cache.json');
+
+const getProviderModelsCacheKey = (
+  provider: LLMProvider,
+  options?: ProviderModelsOptions,
+): string => {
+  if (provider === 'opencode') {
+    return `${provider}:${resolveOpenCodeCwd(options?.cwd)}`;
+  }
+
+  return provider;
+};
+
+const isProviderModelOption = (value: unknown): value is ProviderModelOption => (
+  Boolean(value)
+  && typeof value === 'object'
+  && typeof (value as ProviderModelOption).value === 'string'
+  && typeof (value as ProviderModelOption).label === 'string'
+);
+
+const isProviderModelsDefinition = (value: unknown): value is ProviderModelsDefinition => (
+  Boolean(value)
+  && typeof value === 'object'
+  && Array.isArray((value as ProviderModelsDefinition).OPTIONS)
+  && (value as ProviderModelsDefinition).OPTIONS.every(isProviderModelOption)
+  && typeof (value as ProviderModelsDefinition).DEFAULT === 'string'
+);
+
+const isProviderModelsCacheEntry = (value: unknown): value is ProviderModelsCacheEntry => (
+  Boolean(value)
+  && typeof value === 'object'
+  && typeof (value as ProviderModelsCacheEntry).expiresAt === 'number'
+  && isProviderModelsDefinition((value as ProviderModelsCacheEntry).models)
+);
+
+const readProviderModelsCacheFile = async (
+  cachePath: string,
+): Promise<ProviderModelsCacheFile | null> => {
+  try {
+    const raw = await readFile(cachePath, 'utf8');
+    const parsed = JSON.parse(raw) as Partial<ProviderModelsCacheFile>;
+    if (parsed.version !== PROVIDER_MODELS_CACHE_VERSION || !parsed.entries || typeof parsed.entries !== 'object') {
+      return null;
+    }
+
+    const entries = Object.fromEntries(
+      Object.entries(parsed.entries).filter((entry): entry is [string, ProviderModelsCacheEntry] =>
+        isProviderModelsCacheEntry(entry[1]),
+      ),
+    );
+    return { version: PROVIDER_MODELS_CACHE_VERSION, entries };
+  } catch {
+    return null;
+  }
+};
+
+const writeProviderModelsCacheFile = async (
+  cachePath: string,
+  entries: Map<string, ProviderModelsCacheEntry>,
+  now: number,
+): Promise<void> => {
+  const serializableEntries = Object.fromEntries(
+    [...entries.entries()].filter(([, entry]) => entry.expiresAt > now),
+  );
+  const payload: ProviderModelsCacheFile = {
+    version: PROVIDER_MODELS_CACHE_VERSION,
+    entries: serializableEntries,
+  };
+
+  await mkdir(path.dirname(cachePath), { recursive: true });
+  await writeFile(cachePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+};
+
 const runOpenCodeModelsCommand = (cwd?: string): Promise<string> =>
   new Promise((resolve, reject) => {
     const spawnFn = process.platform === 'win32' ? crossSpawn : spawn;
@@ -222,7 +327,133 @@ async function getProviderModelsInternal(
   }
 }
 
-export const providerModelsService = {
-  getProviderModels: (provider: LLMProvider, options?: { cwd?: string }): Promise<ProviderModelsDefinition> =>
-    getProviderModelsInternal(provider, options),
+export const createProviderModelsService = (dependencies: ProviderModelsServiceDependencies = {}) => {
+  const memoryCache = new Map<string, ProviderModelsCacheEntry>();
+  const pendingRequests = new Map<string, Promise<ProviderModelsDefinition>>();
+  const loadModels = dependencies.loadModels ?? getProviderModelsInternal;
+  const now = dependencies.now ?? (() => Date.now());
+  let persistedCacheLoaded = false;
+  let persistedCacheLoadPromise: Promise<void> | null = null;
+
+  const loadPersistedCache = async (cachePath: string): Promise<void> => {
+    if (persistedCacheLoaded) {
+      return;
+    }
+
+    if (!persistedCacheLoadPromise) {
+      persistedCacheLoadPromise = (async () => {
+        const cacheFile = await readProviderModelsCacheFile(cachePath);
+        const currentTime = now();
+        for (const [key, entry] of Object.entries(cacheFile?.entries ?? {})) {
+          if (entry.expiresAt > currentTime) {
+            memoryCache.set(key, entry);
+          }
+        }
+        persistedCacheLoaded = true;
+      })().finally(() => {
+        persistedCacheLoadPromise = null;
+      });
+    }
+
+    await persistedCacheLoadPromise;
+  };
+
+  const persistCache = async (cachePath: string): Promise<void> => {
+    try {
+      await writeProviderModelsCacheFile(cachePath, memoryCache, now());
+    } catch (error) {
+      console.warn('Unable to persist provider models cache:', error);
+    }
+  };
+
+  const setCacheEntry = async (
+    cachePath: string,
+    cacheKey: string,
+    models: ProviderModelsDefinition,
+  ): Promise<void> => {
+    const entry = {
+      expiresAt: now() + PROVIDER_MODELS_CACHE_TTL_MS,
+      models,
+    };
+    memoryCache.set(cacheKey, entry);
+
+    await persistCache(cachePath);
+  };
+
+  const loadAndCacheModels = (
+    provider: LLMProvider,
+    options: ProviderModelsOptions | undefined,
+    cachePath: string,
+    cacheKey: string,
+  ): Promise<ProviderModelsDefinition> => {
+    const request = loadModels(provider, options)
+      .then(async (models) => {
+        await setCacheEntry(cachePath, cacheKey, models);
+        return models;
+      })
+      .finally(() => {
+        pendingRequests.delete(cacheKey);
+      });
+
+    pendingRequests.set(cacheKey, request);
+    return request;
+  };
+
+  const pruneExpiredMemoryEntry = (cacheKey: string, currentTime: number): ProviderModelsDefinition | null => {
+    const cachedEntry = memoryCache.get(cacheKey);
+    if (!cachedEntry) {
+      return null;
+    }
+
+    if (cachedEntry.expiresAt > currentTime) {
+      return cachedEntry.models;
+    }
+
+    memoryCache.delete(cacheKey);
+    return null;
+  };
+
+  const getProviderModels = async (
+    provider: LLMProvider,
+    options?: ProviderModelsOptions,
+  ): Promise<ProviderModelsDefinition> => {
+    const cachePath = dependencies.cachePath ?? getProviderModelsCachePath();
+    const cacheKey = getProviderModelsCacheKey(provider, options);
+    const cachedModels = pruneExpiredMemoryEntry(cacheKey, now());
+    if (cachedModels) {
+      return cachedModels;
+    }
+
+    const pendingRequest = pendingRequests.get(cacheKey);
+    if (pendingRequest) {
+      return pendingRequest;
+    }
+
+    await loadPersistedCache(cachePath);
+    const persistedModels = pruneExpiredMemoryEntry(cacheKey, now());
+    if (persistedModels) {
+      return persistedModels;
+    }
+
+    const postLoadPendingRequest = pendingRequests.get(cacheKey);
+    if (postLoadPendingRequest) {
+      return postLoadPendingRequest;
+    }
+
+    return loadAndCacheModels(provider, options, cachePath, cacheKey);
+  };
+
+  const clearCache = (): void => {
+    memoryCache.clear();
+    pendingRequests.clear();
+    persistedCacheLoaded = false;
+    persistedCacheLoadPromise = null;
+  };
+
+  return {
+    getProviderModels,
+    clearCache,
+  };
 };
+
+export const providerModelsService = createProviderModelsService();

server/modules/providers/tests/provider-models.service.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  createProviderModelsService,
+  PROVIDER_MODELS_CACHE_TTL_MS,
+} from '@/modules/providers/services/provider-models.service.js';
+import type { LLMProvider, ProviderModelsDefinition } from '@/shared/types.js';
+
+const createModels = (value: string): ProviderModelsDefinition => ({
+  OPTIONS: [{ value, label: value }],
+  DEFAULT: value,
+});
+
+test('provider models are cached for the two-day ttl', async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'provider-model-cache-ttl-'));
+  let currentTime = 1_000;
+  let loadCount = 0;
+
+  try {
+    const service = createProviderModelsService({
+      cachePath: path.join(tempRoot, 'models-cache.json'),
+      now: () => currentTime,
+      loadModels: async (provider: LLMProvider) => {
+        loadCount += 1;
+        return createModels(`${provider}-${loadCount}`);
+      },
+    });
+
+    const first = await service.getProviderModels('codex');
+    const cached = await service.getProviderModels('codex');
+    assert.equal(loadCount, 1);
+    assert.equal(cached.DEFAULT, first.DEFAULT);
+
+    currentTime += PROVIDER_MODELS_CACHE_TTL_MS - 1;
+    await service.getProviderModels('codex');
+    assert.equal(loadCount, 1);
+
+    currentTime += 2;
+    const refreshed = await service.getProviderModels('codex');
+    assert.equal(loadCount, 2);
+    assert.equal(refreshed.DEFAULT, 'codex-2');
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('provider model cache is persisted across service instances', async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'provider-model-cache-file-'));
+  const cachePath = path.join(tempRoot, 'models-cache.json');
+
+  try {
+    const writer = createProviderModelsService({
+      cachePath,
+      loadModels: async () => createModels('gemini-cached'),
+    });
+    await writer.getProviderModels('gemini');
+
+    const reader = createProviderModelsService({
+      cachePath,
+      loadModels: async () => {
+        throw new Error('loader should not be called for persisted cache hits');
+      },
+    });
+    const models = await reader.getProviderModels('gemini');
+    assert.equal(models.DEFAULT, 'gemini-cached');
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('concurrent provider model requests share one load operation', async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'provider-model-cache-pending-'));
+  let loadCount = 0;
+
+  try {
+    const service = createProviderModelsService({
+      cachePath: path.join(tempRoot, 'models-cache.json'),
+      loadModels: async () => {
+        loadCount += 1;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        return createModels('claude-cached');
+      },
+    });
+
+    const [first, second] = await Promise.all([
+      service.getProviderModels('claude'),
+      service.getProviderModels('claude'),
+    ]);
+
+    assert.equal(loadCount, 1);
+    assert.equal(first.DEFAULT, 'claude-cached');
+    assert.equal(second.DEFAULT, 'claude-cached');
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('opencode model cache is scoped by workspace cwd', async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'provider-model-cache-opencode-'));
+  const workspaceA = path.join(tempRoot, 'workspace-a');
+  const workspaceB = path.join(tempRoot, 'workspace-b');
+  let loadCount = 0;
+
+  try {
+    await mkdir(workspaceA, { recursive: true });
+    await mkdir(workspaceB, { recursive: true });
+
+    const service = createProviderModelsService({
+      cachePath: path.join(tempRoot, 'models-cache.json'),
+      loadModels: async () => {
+        loadCount += 1;
+        return createModels(`opencode-${loadCount}`);
+      },
+    });
+
+    await service.getProviderModels('opencode', { cwd: workspaceA });
+    await service.getProviderModels('opencode', { cwd: workspaceA });
+    await service.getProviderModels('opencode', { cwd: workspaceB });
+
+    assert.equal(loadCount, 2);
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});