@auxiora/model-registry 1.10.7

package/LICENSE

@@ -0,0 +1,191 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Auxiora Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@auxiora/model-registry",
+  "version": "1.10.7",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}

package/src/db.ts

@@ -0,0 +1,39 @@
+import { DatabaseSync } from 'node:sqlite';
+
+const SCHEMA_DDL = `
+  CREATE TABLE IF NOT EXISTS discovered_models (
+    id TEXT PRIMARY KEY,
+    provider_source TEXT NOT NULL,
+    model_id TEXT NOT NULL,
+    display_name TEXT NOT NULL,
+    context_length INTEGER DEFAULT 0,
+    supports_vision INTEGER DEFAULT 0,
+    supports_tools INTEGER DEFAULT 0,
+    supports_streaming INTEGER DEFAULT 1,
+    supports_image_gen INTEGER DEFAULT 0,
+    cost_per_1k_input REAL DEFAULT 0,
+    cost_per_1k_output REAL DEFAULT 0,
+    strengths TEXT DEFAULT '[]',
+    raw_metadata TEXT,
+    hf_model_card TEXT,
+    hf_downloads INTEGER,
+    hf_likes INTEGER,
+    hf_trending_score REAL,
+    hf_tags TEXT,
+    hf_benchmark_scores TEXT,
+    hf_inference_providers TEXT,
+    last_refreshed_at INTEGER NOT NULL,
+    created_at INTEGER NOT NULL,
+    enabled INTEGER DEFAULT 1
+  );
+  CREATE INDEX IF NOT EXISTS idx_models_source ON discovered_models(provider_source);
+  CREATE INDEX IF NOT EXISTS idx_models_enabled ON discovered_models(enabled);
+`;
+
+export function openDatabase(dbPath: string): DatabaseSync {
+  const db = new DatabaseSync(dbPath);
+  db.exec('PRAGMA journal_mode=WAL');
+  db.exec('PRAGMA foreign_keys=ON');
+  db.exec(SCHEMA_DDL);
+  return db;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { ModelRegistry } from './registry.js';
+export type {
+  DiscoveredModel,
+  ModelSearchOptions,
+  ModelCapabilitiesLike,
+} from './types.js';

package/src/registry.ts

@@ -0,0 +1,181 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { openDatabase } from './db.js';
+import type { DiscoveredModel, ModelCapabilitiesLike, ModelSearchOptions } from './types.js';
+
+type Row = Record<string, unknown>;
+
+function rowToModel(row: Row): DiscoveredModel {
+  return {
+    id: row.id as string,
+    providerSource: row.provider_source as string,
+    modelId: row.model_id as string,
+    displayName: row.display_name as string,
+    contextLength: row.context_length as number,
+    supportsVision: (row.supports_vision as number) === 1,
+    supportsTools: (row.supports_tools as number) === 1,
+    supportsStreaming: (row.supports_streaming as number) === 1,
+    supportsImageGen: (row.supports_image_gen as number) === 1,
+    costPer1kInput: row.cost_per_1k_input as number,
+    costPer1kOutput: row.cost_per_1k_output as number,
+    strengths: JSON.parse((row.strengths as string) || '[]') as string[],
+    rawMetadata: row.raw_metadata as string | undefined,
+    hfModelCard: row.hf_model_card as string | undefined,
+    hfDownloads: row.hf_downloads as number | undefined,
+    hfLikes: row.hf_likes as number | undefined,
+    hfTrendingScore: row.hf_trending_score as number | undefined,
+    hfTags: row.hf_tags ? JSON.parse(row.hf_tags as string) as string[] : undefined,
+    hfBenchmarkScores: row.hf_benchmark_scores
+      ? JSON.parse(row.hf_benchmark_scores as string) as Record<string, number>
+      : undefined,
+    hfInferenceProviders: row.hf_inference_providers
+      ? JSON.parse(row.hf_inference_providers as string) as string[]
+      : undefined,
+    lastRefreshedAt: row.last_refreshed_at as number,
+    createdAt: row.created_at as number,
+    enabled: (row.enabled as number) === 1,
+  };
+}
+
+export class ModelRegistry {
+  private db: DatabaseSync;
+
+  constructor(dbPath: string) {
+    this.db = openDatabase(dbPath);
+  }
+
+  upsertModels(models: DiscoveredModel[]): void {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO discovered_models (
+        id, provider_source, model_id, display_name, context_length,
+        supports_vision, supports_tools, supports_streaming, supports_image_gen,
+        cost_per_1k_input, cost_per_1k_output, strengths, raw_metadata,
+        hf_model_card, hf_downloads, hf_likes, hf_trending_score,
+        hf_tags, hf_benchmark_scores, hf_inference_providers,
+        last_refreshed_at, created_at, enabled
+      ) VALUES (
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?,
+        ?, ?, ?
+      )
+    `);
+
+    for (const m of models) {
+      stmt.run(
+        m.id, m.providerSource, m.modelId, m.displayName, m.contextLength,
+        m.supportsVision ? 1 : 0, m.supportsTools ? 1 : 0,
+        m.supportsStreaming ? 1 : 0, m.supportsImageGen ? 1 : 0,
+        m.costPer1kInput, m.costPer1kOutput,
+        JSON.stringify(m.strengths), m.rawMetadata ?? null,
+        m.hfModelCard ?? null, m.hfDownloads ?? null,
+        m.hfLikes ?? null, m.hfTrendingScore ?? null,
+        m.hfTags ? JSON.stringify(m.hfTags) : null,
+        m.hfBenchmarkScores ? JSON.stringify(m.hfBenchmarkScores) : null,
+        m.hfInferenceProviders ? JSON.stringify(m.hfInferenceProviders) : null,
+        m.lastRefreshedAt, m.createdAt,
+        m.enabled ? 1 : 0,
+      );
+    }
+  }
+
+  getModels(options?: ModelSearchOptions): DiscoveredModel[] {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (options?.source) {
+      conditions.push('provider_source = ?');
+      params.push(options.source);
+    }
+    if (options?.query) {
+      conditions.push('(display_name LIKE ? OR model_id LIKE ?)');
+      const q = `%${options.query}%`;
+      params.push(q, q);
+    }
+    if (options?.supportsVision !== undefined) {
+      conditions.push('supports_vision = ?');
+      params.push(options.supportsVision ? 1 : 0);
+    }
+    if (options?.supportsTools !== undefined) {
+      conditions.push('supports_tools = ?');
+      params.push(options.supportsTools ? 1 : 0);
+    }
+    if (options?.enabled !== undefined) {
+      conditions.push('enabled = ?');
+      params.push(options.enabled ? 1 : 0);
+    }
+
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = options?.limit ?? 200;
+    const offset = options?.offset ?? 0;
+
+    const rows = this.db.prepare(
+      `SELECT * FROM discovered_models ${where} ORDER BY display_name ASC LIMIT ? OFFSET ?`,
+    ).all(...params, limit, offset) as Row[];
+
+    return rows.map(rowToModel);
+  }
+
+  getModel(id: string): DiscoveredModel | undefined {
+    const row = this.db.prepare(
+      'SELECT * FROM discovered_models WHERE id = ?',
+    ).get(id) as Row | undefined;
+
+    return row ? rowToModel(row) : undefined;
+  }
+
+  /**
+   * Convert discovered models to the format ModelRouter expects.
+   * Returns Record<modelId, ModelCapabilities>.
+   */
+  toModelCapabilities(source: string): Record<string, ModelCapabilitiesLike> {
+    const models = this.getModels({ source, enabled: true });
+    const result: Record<string, ModelCapabilitiesLike> = {};
+
+    for (const m of models) {
+      result[m.modelId] = {
+        maxContextTokens: m.contextLength,
+        supportsVision: m.supportsVision,
+        supportsTools: m.supportsTools,
+        supportsStreaming: m.supportsStreaming,
+        supportsImageGen: m.supportsImageGen,
+        costPer1kInput: m.costPer1kInput,
+        costPer1kOutput: m.costPer1kOutput,
+        strengths: m.strengths,
+        isLocal: false,
+      };
+    }
+
+    return result;
+  }
+
+  search(query: string): DiscoveredModel[] {
+    return this.getModels({ query, enabled: true });
+  }
+
+  getTrending(limit = 20): DiscoveredModel[] {
+    const rows = this.db.prepare(
+      `SELECT * FROM discovered_models
+       WHERE hf_trending_score IS NOT NULL AND enabled = 1
+       ORDER BY hf_trending_score DESC
+       LIMIT ?`,
+    ).all(limit) as Row[];
+
+    return rows.map(rowToModel);
+  }
+
+  pruneStale(maxAgeMs: number): number {
+    const cutoff = Date.now() - maxAgeMs;
+    const result = this.db.prepare(
+      'DELETE FROM discovered_models WHERE last_refreshed_at < ?',
+    ).run(cutoff);
+    return result.changes;
+  }
+
+  setEnabled(id: string, enabled: boolean): void {
+    this.db.prepare(
+      'UPDATE discovered_models SET enabled = ? WHERE id = ?',
+    ).run(enabled ? 1 : 0, id);
+  }
+}

package/src/types.ts

@@ -0,0 +1,58 @@
+/**
+ * A model discovered from an external provider API (OpenRouter, HuggingFace, etc.).
+ */
+export interface DiscoveredModel {
+  /** Composite key: `${providerSource}:${modelId}` */
+  id: string;
+  /** Source provider that discovered this model */
+  providerSource: string;
+  /** Original model ID from the external API */
+  modelId: string;
+  displayName: string;
+  contextLength: number;
+  supportsVision: boolean;
+  supportsTools: boolean;
+  supportsStreaming: boolean;
+  supportsImageGen: boolean;
+  costPer1kInput: number;
+  costPer1kOutput: number;
+  strengths: string[];
+  rawMetadata?: string;
+  /** HuggingFace-specific fields */
+  hfModelCard?: string;
+  hfDownloads?: number;
+  hfLikes?: number;
+  hfTrendingScore?: number;
+  hfTags?: string[];
+  hfBenchmarkScores?: Record<string, number>;
+  hfInferenceProviders?: string[];
+  lastRefreshedAt: number;
+  createdAt: number;
+  enabled: boolean;
+}
+
+export interface ModelSearchOptions {
+  source?: string;
+  query?: string;
+  supportsVision?: boolean;
+  supportsTools?: boolean;
+  enabled?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+/**
+ * Structural type matching ModelCapabilities from @auxiora/providers
+ * to avoid a hard dependency on that package.
+ */
+export interface ModelCapabilitiesLike {
+  maxContextTokens: number;
+  supportsVision: boolean;
+  supportsTools: boolean;
+  supportsStreaming: boolean;
+  supportsImageGen: boolean;
+  costPer1kInput: number;
+  costPer1kOutput: number;
+  strengths: string[];
+  isLocal: boolean;
+}

package/tests/registry.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ModelRegistry } from '../src/registry.js';
+import type { DiscoveredModel } from '../src/types.js';
+
+function makeModel(overrides: Partial<DiscoveredModel> = {}): DiscoveredModel {
+  const now = Date.now();
+  return {
+    id: 'openrouter:test/model-1',
+    providerSource: 'openrouter',
+    modelId: 'test/model-1',
+    displayName: 'Test Model 1',
+    contextLength: 128000,
+    supportsVision: true,
+    supportsTools: true,
+    supportsStreaming: true,
+    supportsImageGen: false,
+    costPer1kInput: 0.003,
+    costPer1kOutput: 0.015,
+    strengths: ['reasoning', 'code'],
+    lastRefreshedAt: now,
+    createdAt: now,
+    enabled: true,
+    ...overrides,
+  };
+}
+
+describe('ModelRegistry', () => {
+  let registry: ModelRegistry;
+
+  beforeEach(() => {
+    registry = new ModelRegistry(':memory:');
+  });
+
+  describe('upsertModels', () => {
+    it('should insert models and retrieve them', () => {
+      const model = makeModel();
+      registry.upsertModels([model]);
+
+      const result = registry.getModel('openrouter:test/model-1');
+      expect(result).toBeDefined();
+      expect(result!.displayName).toBe('Test Model 1');
+      expect(result!.supportsVision).toBe(true);
+      expect(result!.strengths).toEqual(['reasoning', 'code']);
+    });
+
+    it('should upsert (update on conflict)', () => {
+      const model = makeModel();
+      registry.upsertModels([model]);
+
+      const updated = makeModel({ displayName: 'Updated Name', costPer1kInput: 0.005 });
+      registry.upsertModels([updated]);
+
+      const result = registry.getModel('openrouter:test/model-1');
+      expect(result!.displayName).toBe('Updated Name');
+      expect(result!.costPer1kInput).toBe(0.005);
+    });
+
+    it('should insert multiple models at once', () => {
+      const models = [
+        makeModel({ id: 'openrouter:a/model-a', modelId: 'a/model-a', displayName: 'Model A' }),
+        makeModel({ id: 'openrouter:b/model-b', modelId: 'b/model-b', displayName: 'Model B' }),
+        makeModel({ id: 'openrouter:c/model-c', modelId: 'c/model-c', displayName: 'Model C' }),
+      ];
+      registry.upsertModels(models);
+
+      const all = registry.getModels();
+      expect(all).toHaveLength(3);
+    });
+  });
+
+  describe('getModels', () => {
+    beforeEach(() => {
+      registry.upsertModels([
+        makeModel({ id: 'openrouter:a/big', modelId: 'a/big', displayName: 'Big Model', providerSource: 'openrouter', supportsVision: true }),
+        makeModel({ id: 'openrouter:a/small', modelId: 'a/small', displayName: 'Small Model', providerSource: 'openrouter', supportsVision: false }),
+        makeModel({ id: 'huggingface:b/chat', modelId: 'b/chat', displayName: 'Chat Model', providerSource: 'huggingface', supportsVision: false }),
+      ]);
+    });
+
+    it('should filter by source', () => {
+      const result = registry.getModels({ source: 'openrouter' });
+      expect(result).toHaveLength(2);
+      expect(result.every(m => m.providerSource === 'openrouter')).toBe(true);
+    });
+
+    it('should filter by vision support', () => {
+      const result = registry.getModels({ supportsVision: true });
+      expect(result).toHaveLength(1);
+      expect(result[0]!.displayName).toBe('Big Model');
+    });
+
+    it('should search by query', () => {
+      const result = registry.getModels({ query: 'chat' });
+      expect(result).toHaveLength(1);
+      expect(result[0]!.displayName).toBe('Chat Model');
+    });
+
+    it('should support limit and offset', () => {
+      const page1 = registry.getModels({ limit: 2, offset: 0 });
+      expect(page1).toHaveLength(2);
+
+      const page2 = registry.getModels({ limit: 2, offset: 2 });
+      expect(page2).toHaveLength(1);
+    });
+  });
+
+  describe('getModel', () => {
+    it('should return undefined for non-existent model', () => {
+      const result = registry.getModel('nonexistent');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('toModelCapabilities', () => {
+    it('should convert to ModelCapabilities format', () => {
+      registry.upsertModels([
+        makeModel({ id: 'openrouter:a/model', modelId: 'a/model', providerSource: 'openrouter' }),
+      ]);
+
+      const caps = registry.toModelCapabilities('openrouter');
+      expect(caps['a/model']).toBeDefined();
+      expect(caps['a/model']!.maxContextTokens).toBe(128000);
+      expect(caps['a/model']!.supportsVision).toBe(true);
+      expect(caps['a/model']!.isLocal).toBe(false);
+      expect(caps['a/model']!.strengths).toEqual(['reasoning', 'code']);
+    });
+
+    it('should exclude disabled models', () => {
+      registry.upsertModels([
+        makeModel({ id: 'openrouter:a/enabled', modelId: 'a/enabled', enabled: true }),
+        makeModel({ id: 'openrouter:a/disabled', modelId: 'a/disabled', enabled: false }),
+      ]);
+
+      const caps = registry.toModelCapabilities('openrouter');
+      expect(caps['a/enabled']).toBeDefined();
+      expect(caps['a/disabled']).toBeUndefined();
+    });
+  });
+
+  describe('search', () => {
+    it('should search by display name and model ID', () => {
+      registry.upsertModels([
+        makeModel({ id: 'or:anthropic/claude-3-opus', modelId: 'anthropic/claude-3-opus', displayName: 'Claude 3 Opus' }),
+        makeModel({ id: 'or:meta/llama-3', modelId: 'meta/llama-3', displayName: 'Llama 3' }),
+      ]);
+
+      const results = registry.search('claude');
+      expect(results).toHaveLength(1);
+      expect(results[0]!.displayName).toBe('Claude 3 Opus');
+    });
+  });
+
+  describe('getTrending', () => {
+    it('should return models sorted by trending score', () => {
+      registry.upsertModels([
+        makeModel({ id: 'hf:a', modelId: 'a', providerSource: 'huggingface', hfTrendingScore: 0.8 }),
+        makeModel({ id: 'hf:b', modelId: 'b', providerSource: 'huggingface', hfTrendingScore: 0.95 }),
+        makeModel({ id: 'hf:c', modelId: 'c', providerSource: 'huggingface', hfTrendingScore: 0.5 }),
+      ]);
+
+      const trending = registry.getTrending(2);
+      expect(trending).toHaveLength(2);
+      expect(trending[0]!.modelId).toBe('b');
+      expect(trending[1]!.modelId).toBe('a');
+    });
+
+    it('should exclude models without trending score', () => {
+      registry.upsertModels([
+        makeModel({ id: 'or:x', modelId: 'x', providerSource: 'openrouter' }),
+        makeModel({ id: 'hf:y', modelId: 'y', providerSource: 'huggingface', hfTrendingScore: 0.5 }),
+      ]);
+
+      const trending = registry.getTrending();
+      expect(trending).toHaveLength(1);
+      expect(trending[0]!.modelId).toBe('y');
+    });
+  });
+
+  describe('pruneStale', () => {
+    it('should delete models older than maxAge', () => {
+      const old = Date.now() - 10 * 24 * 60 * 60 * 1000; // 10 days ago
+      const recent = Date.now();
+
+      registry.upsertModels([
+        makeModel({ id: 'or:old', modelId: 'old', lastRefreshedAt: old }),
+        makeModel({ id: 'or:new', modelId: 'new', lastRefreshedAt: recent }),
+      ]);
+
+      const pruned = registry.pruneStale(7 * 24 * 60 * 60 * 1000); // 7 days
+      expect(pruned).toBe(1);
+
+      const remaining = registry.getModels();
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0]!.modelId).toBe('new');
+    });
+  });
+
+  describe('setEnabled', () => {
+    it('should disable and re-enable a model', () => {
+      registry.upsertModels([makeModel()]);
+
+      registry.setEnabled('openrouter:test/model-1', false);
+      let model = registry.getModel('openrouter:test/model-1');
+      expect(model!.enabled).toBe(false);
+
+      registry.setEnabled('openrouter:test/model-1', true);
+      model = registry.getModel('openrouter:test/model-1');
+      expect(model!.enabled).toBe(true);
+    });
+  });
+
+  describe('HuggingFace-specific fields', () => {
+    it('should persist and retrieve HF metadata', () => {
+      registry.upsertModels([
+        makeModel({
+          id: 'hf:meta/llama',
+          modelId: 'meta/llama',
+          providerSource: 'huggingface',
+          hfModelCard: '# Llama\n\nA great model.',
+          hfDownloads: 1500000,
+          hfLikes: 5000,
+          hfTrendingScore: 0.92,
+          hfTags: ['transformers', 'pytorch', 'llama'],
+          hfBenchmarkScores: { mmlu: 0.82, humaneval: 0.71 },
+          hfInferenceProviders: ['together', 'fireworks-ai'],
+        }),
+      ]);
+
+      const model = registry.getModel('hf:meta/llama')!;
+      expect(model.hfModelCard).toBe('# Llama\n\nA great model.');
+      expect(model.hfDownloads).toBe(1500000);
+      expect(model.hfLikes).toBe(5000);
+      expect(model.hfTrendingScore).toBe(0.92);
+      expect(model.hfTags).toEqual(['transformers', 'pytorch', 'llama']);
+      expect(model.hfBenchmarkScores).toEqual({ mmlu: 0.82, humaneval: 0.71 });
+      expect(model.hfInferenceProviders).toEqual(['together', 'fireworks-ai']);
+    });
+  });
+});