[Init] Initial commit - NetMesh terminal manager

infrastructure/ai/cattyProviderModels.ts

@@ -0,0 +1,169 @@
+import { decryptField } from '../persistence/secureFieldAdapter';
+import { buildModelDiscoveryHeaders, resolveModelsDiscoveryEndpoint } from './modelDiscoveryHeaders';
+import { normalizeOllamaSdkBaseURL } from './ollamaCompatBaseUrl';
+import { buildProviderProbeUrl } from './providerConnectionProbe';
+import { sanitizeContextWindow } from './contextCompaction';
+import { PROVIDER_PRESETS, resolveProviderStyle, type ProviderConfig } from './types';
+import {
+  buildProviderSeedModels,
+  mergeComposerModels,
+  type ComposerPickerModel,
+} from './composerPicker';
+
+export interface ProviderModelCatalog {
+  models: ComposerPickerModel[];
+  fetched: boolean;
+  error?: string;
+}
+
+type FetchBridge = {
+  aiFetch?: (
+    url: string,
+    method?: string,
+    headers?: Record<string, string>,
+    body?: string,
+    providerId?: string,
+    skipHostCheck?: boolean,
+    followRedirects?: boolean,
+    skipTLSVerify?: boolean,
+  ) => Promise<{ ok: boolean; status?: number; data: string; error?: string }>;
+  aiAllowlistAddHost?: (baseURL: string) => Promise<{ ok: boolean }>;
+};
+
+const catalogCache = new Map<string, { models: ComposerPickerModel[]; expiresAt: number }>();
+const CATALOG_TTL_MS = 5 * 60 * 1000;
+
+/** Length + FNV-1a of the stored secret so a key rotation busts the catalog cache. */
+function credentialFingerprint(value: string | undefined): string {
+  const raw = String(value || '');
+  if (!raw) return '0';
+  let hash = 2166136261;
+  for (let i = 0; i < raw.length; i += 1) {
+    hash ^= raw.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${raw.length}:${(hash >>> 0).toString(16)}`;
+}
+
+export function readCachedProviderModelCatalog(
+  provider: ProviderConfig,
+): ComposerPickerModel[] | null {
+  const cached = catalogCache.get(providerModelCacheKey(provider));
+  if (!cached || cached.expiresAt <= Date.now()) return null;
+  return cached.models;
+}
+
+export function providerModelCacheKey(provider: ProviderConfig): string {
+  return [
+    provider.id,
+    provider.providerId,
+    provider.style ?? '',
+    provider.baseURL ?? '',
+    provider.skipTLSVerify ? '1' : '0',
+    credentialFingerprint(provider.apiKey),
+  ].join('|');
+}
+
+export function resolveProviderDiscoveryBaseURL(provider: ProviderConfig): string {
+  const raw = provider.baseURL || PROVIDER_PRESETS[provider.providerId]?.defaultBaseURL || '';
+  if (!raw) return '';
+  return provider.providerId === 'ollama' ? normalizeOllamaSdkBaseURL(raw) : raw;
+}
+
+export function seedProviderModelCatalog(provider: ProviderConfig): ProviderModelCatalog {
+  return {
+    models: buildProviderSeedModels(provider),
+    fetched: false,
+  };
+}
+
+export function clearProviderModelCatalogCache(): void {
+  catalogCache.clear();
+}
+
+function parseDiscoveredModels(parsed: unknown): ComposerPickerModel[] {
+  const record = parsed && typeof parsed === 'object' ? parsed as Record<string, unknown> : {};
+  const rawModels = Array.isArray(record.data)
+    ? record.data
+    : Array.isArray(record.models)
+      ? record.models
+      : [];
+  return rawModels
+    .map((raw): ComposerPickerModel | null => {
+      if (!raw || typeof raw !== 'object') return null;
+      const model = raw as Record<string, unknown>;
+      if (typeof model.id !== 'string' || !model.id) return null;
+      const contextWindow = sanitizeContextWindow(
+        model.context_length
+          ?? model.context_window
+          ?? model.contextWindow
+          ?? model.context
+          ?? model.max_context_tokens,
+      );
+      return {
+        id: model.id,
+        name: typeof model.name === 'string' && model.name ? model.name : model.id,
+        ...(contextWindow != null ? { contextWindow } : {}),
+      };
+    })
+    .filter((model): model is ComposerPickerModel => model != null)
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export async function fetchProviderModelCatalog(
+  provider: ProviderConfig,
+  bridge: FetchBridge | undefined,
+): Promise<ProviderModelCatalog> {
+  const seed = seedProviderModelCatalog(provider);
+  const cacheKey = providerModelCacheKey(provider);
+  const cached = catalogCache.get(cacheKey);
+  if (cached && cached.expiresAt > Date.now()) {
+    return {
+      models: mergeComposerModels(seed.models, cached.models),
+      fetched: true,
+    };
+  }
+
+  const style = resolveProviderStyle(provider);
+  const endpoint = resolveModelsDiscoveryEndpoint(style, undefined);
+  const baseURL = resolveProviderDiscoveryBaseURL(provider);
+  if (!endpoint || !baseURL || !bridge?.aiFetch) {
+    return seed;
+  }
+
+  try {
+    const apiKey = await decryptField(provider.apiKey);
+    if (provider.providerId !== 'ollama' && !apiKey) {
+      return seed;
+    }
+    if (bridge.aiAllowlistAddHost) {
+      await bridge.aiAllowlistAddHost(baseURL);
+    }
+    const url = buildProviderProbeUrl(baseURL, endpoint);
+    const headers = buildModelDiscoveryHeaders(style, apiKey);
+    const result = await bridge.aiFetch(
+      url,
+      'GET',
+      headers,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      provider.skipTLSVerify,
+    );
+    if (!result.ok) {
+      return { ...seed, error: result.error || 'Failed to fetch models' };
+    }
+    const fetched = parseDiscoveredModels(JSON.parse(result.data) as unknown);
+    catalogCache.set(cacheKey, { models: fetched, expiresAt: Date.now() + CATALOG_TTL_MS });
+    return {
+      models: mergeComposerModels(seed.models, fetched),
+      fetched: true,
+    };
+  } catch (error) {
+    return {
+      ...seed,
+      error: error instanceof Error ? error.message : 'Failed to fetch models',
+    };
+  }
+}