@johpaz/hive-sdk 0.0.18 → 0.1.4

package/packages/core/src/storage/usage.ts

@@ -1,20 +1,15 @@
-import { getDb } from "./SQLiteStorage.ts";
+import { getHiveDB } from "./HiveDBStorage.ts";
 import { randomUUID } from "crypto";
 import { logger } from "../utils/logger.ts";
 
 const log = logger.child("usage");
 
-// Precios en USD por millón de tokens (input / output)
-// Fuentes: docs.anthropic.com, openrouter.ai/api/v1/models, api-docs.deepseek.com, console.groq.com
 const MODEL_PRICING: Record<string, { inputPer1M: number; outputPer1M: number }> = {
-  // ── Anthropic (fuente: docs.anthropic.com) ──
   "claude-opus-4-6":           { inputPer1M: 5,    outputPer1M: 25   },
   "claude-sonnet-4-6":         { inputPer1M: 3,    outputPer1M: 15   },
   "claude-haiku-4-5-20251001": { inputPer1M: 1,    outputPer1M: 5    },
   "anthropic/claude-opus-4-6":   { inputPer1M: 5,  outputPer1M: 25   },
   "anthropic/claude-sonnet-4-6": { inputPer1M: 3,  outputPer1M: 15   },
-
-  // ── OpenAI (fuente: openrouter.ai/api/v1/models) ──
   "gpt-4o":         { inputPer1M: 2.5,  outputPer1M: 10    },
   "gpt-4o-mini":    { inputPer1M: 0.15, outputPer1M: 0.6   },
   "gpt-5.4":        { inputPer1M: 2.5,  outputPer1M: 15    },
@@ -25,11 +20,8 @@ const MODEL_PRICING: Record<string, { inputPer1M: number; outputPer1M: number }>
   "openai/gpt-5.4":     { inputPer1M: 2.5,  outputPer1M: 15  },
   "openai/gpt-5.4-pro": { inputPer1M: 30,   outputPer1M: 180 },
   "openai/gpt-5.2":     { inputPer1M: 1.75, outputPer1M: 14  },
-  // Groq OSS (fuente: console.groq.com)
   "openai/gpt-oss-120b": { inputPer1M: 0.15, outputPer1M: 0.6  },
   "openai/gpt-oss-20b":  { inputPer1M: 0.075, outputPer1M: 0.3 },
-
-  // ── Google Gemini (fuente: openrouter.ai/api/v1/models) ──
   "gemini-3.1-pro-preview":        { inputPer1M: 2,    outputPer1M: 12   },
   "gemini-3.1-flash-lite-preview":  { inputPer1M: 0.25, outputPer1M: 1.5  },
   "gemini-3-flash-preview":         { inputPer1M: 0.5,  outputPer1M: 3    },
@@ -41,8 +33,6 @@ const MODEL_PRICING: Record<string, { inputPer1M: number; outputPer1M: number }>
   "google/gemini-3.1-flash-lite-preview": { inputPer1M: 0.25, outputPer1M: 1.5 },
   "google/gemini-3-flash-preview":        { inputPer1M: 0.5,  outputPer1M: 3   },
   "google/gemini-2.5-flash":              { inputPer1M: 0.15, outputPer1M: 0.6 },
-
-  // ── Mistral (fuente: openrouter.ai/api/v1/models) ──
   "mistral-large-2512":             { inputPer1M: 0.5,  outputPer1M: 1.5  },
   "devstral-2512":                  { inputPer1M: 0.4,  outputPer1M: 2    },
   "ministral-14b-2512":             { inputPer1M: 0.2,  outputPer1M: 0.2  },
@@ -51,14 +41,10 @@ const MODEL_PRICING: Record<string, { inputPer1M: number; outputPer1M: number }>
   "mistral-small-3.2-24b-instruct": { inputPer1M: 0.1,  outputPer1M: 0.3  },
   "mistral-large-latest":           { inputPer1M: 0.5,  outputPer1M: 1.5  },
   "codestral-latest":               { inputPer1M: 0.2,  outputPer1M: 0.6  },
-
-  // ── DeepSeek (fuente: api-docs.deepseek.com/quick_start/pricing) ──
   "deepseek-chat":     { inputPer1M: 0.28, outputPer1M: 0.42 },
   "deepseek-reasoner": { inputPer1M: 0.28, outputPer1M: 0.42 },
   "deepseek/deepseek-v3.2":   { inputPer1M: 0.25, outputPer1M: 0.4  },
   "deepseek/deepseek-r1:free": { inputPer1M: 0,    outputPer1M: 0    },
-
-  // ── Kimi / Moonshot (fuente: openrouter.ai/moonshotai) ──
   "kimi-k2.5":          { inputPer1M: 0.45, outputPer1M: 2.2  },
   "kimi-k2":            { inputPer1M: 0.45, outputPer1M: 2.2  },
   "moonshot-v1-8k":     { inputPer1M: 1.67, outputPer1M: 1.67 },
@@ -66,23 +52,15 @@ const MODEL_PRICING: Record<string, { inputPer1M: number; outputPer1M: number }>
   "moonshot-v1-128k":   { inputPer1M: 8.33, outputPer1M: 8.33 },
   "moonshotai/kimi-k2.5":            { inputPer1M: 0.45, outputPer1M: 2.2 },
   "moonshotai/kimi-k2-instruct-0905": { inputPer1M: 0.45, outputPer1M: 2.2 },
-
-  // ── Meta Llama (vía OpenRouter) ──
   "meta-llama/llama-3.3-70b-instruct": { inputPer1M: 0.88, outputPer1M: 0.88 },
   "meta-llama/llama-4-maverick":       { inputPer1M: 0.2,  outputPer1M: 0.8  },
-
-  // ── Qwen (vía OpenRouter) ──
   "qwen/qwen3.5-plus-02-15":  { inputPer1M: 0.26, outputPer1M: 1.56 },
   "qwen/qwen3.5-flash-02-23": { inputPer1M: 0.1,  outputPer1M: 0.4  },
   "qwen/qwen3-32b":           { inputPer1M: 0,    outputPer1M: 0    },
-
-  // ── Groq (fuente: console.groq.com/docs/models) ──
   "llama-3.3-70b-versatile": { inputPer1M: 0.59, outputPer1M: 0.79 },
   "llama-3.1-8b-instant":    { inputPer1M: 0.05, outputPer1M: 0.08 },
   "groq/compound":            { inputPer1M: 0,    outputPer1M: 0    },
   "groq/compound-mini":       { inputPer1M: 0,    outputPer1M: 0    },
-
-  // ── Ollama local = siempre free ──
   "qwen3:4b":    { inputPer1M: 0, outputPer1M: 0 },
   "qwen3:8b":    { inputPer1M: 0, outputPer1M: 0 },
   "qwen3:14b":   { inputPer1M: 0, outputPer1M: 0 },
@@ -134,117 +112,101 @@ export interface UsageSummary {
   recentRecords: UsageRecord[];
 }
 
-export function recordUsage(options: {
+export async function recordUsage(options: {
   provider: string;
   model: string;
   inputTokens: number;
   outputTokens: number;
   latencyMs?: number;
-}): void {
+}): Promise<void> {
   try {
-    const db = getDb();
+    const db = await getHiveDB();
+    const col = db.collection<UsageRecord>("usage_records");
     const costUsd = calculateCost(options.model, options.inputTokens, options.outputTokens);
 
-    db.prepare(`
-      INSERT INTO usage_records (id, provider, model, input_tokens, output_tokens, cost_usd, latency_ms, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      randomUUID(),
-      options.provider,
-      options.model,
-      options.inputTokens,
-      options.outputTokens,
-      costUsd,
-      options.latencyMs || null,
-      Math.floor(Date.now() / 1000)
-    );
+    await col.put(randomUUID(), {
+      id: randomUUID(),
+      provider: options.provider,
+      model: options.model,
+      input_tokens: options.inputTokens,
+      output_tokens: options.outputTokens,
+      cost_usd: costUsd,
+      latency_ms: options.latencyMs ?? null,
+      toon_saved_tokens: 0,
+      toon_saved_cost: 0,
+      toon_json_bytes: 0,
+      toon_toon_bytes: 0,
+      toon_saved_bytes: 0,
+      toon_saved_percent: 0,
+      toon_json_tokens: 0,
+      toon_toon_tokens: 0,
+      toon_saved_tokens_pct: 0,
+      created_at: Math.floor(Date.now() / 1000),
+    });
+
     log.info(`[USAGE RECORDED] provider=${options.provider} model=${options.model} input=${options.inputTokens} output=${options.outputTokens} cost=$${costUsd.toFixed(4)}`);
   } catch (error) {
     console.error("Failed to record usage:", error);
   }
 }
 
-export function getUsageStats(hours: number = 24): UsageSummary {
+export async function getUsageStats(hours: number = 24): Promise<UsageSummary> {
   log.info(`[USAGE STATS] Fetching stats for last ${hours} hours`);
-  const db = getDb();
+  const db = await getHiveDB();
+  const col = db.collection<UsageRecord>("usage_records");
   const since = Math.floor(Date.now() / 1000) - (hours * 3600);
 
-  const totals = db.prepare(`
-    SELECT
-      COALESCE(SUM(input_tokens), 0) as total_input,
-      COALESCE(SUM(output_tokens), 0) as total_output,
-      COALESCE(SUM(cost_usd), 0) as total_cost,
-      COALESCE(SUM(toon_saved_tokens), 0) as toon_saved_tokens,
-      COALESCE(SUM(toon_saved_cost), 0) as toon_saved_cost,
-      COALESCE(SUM(toon_saved_bytes), 0) as toon_saved_bytes,
-      COALESCE(SUM(toon_saved_percent), 0) as toon_saved_percent,
-      COALESCE(SUM(toon_json_tokens), 0) as toon_json_tokens,
-      COALESCE(SUM(toon_toon_tokens), 0) as toon_toon_tokens
-    FROM usage_records
-    WHERE created_at >= ?
-  `).get(since) as { 
-    total_input: number; 
-    total_output: number; 
-    total_cost: number; 
-    toon_saved_tokens: number; 
-    toon_saved_cost: number;
-    toon_saved_bytes: number;
-    toon_saved_percent: number;
-    toon_json_tokens: number;
-    toon_toon_tokens: number;
-  };
-
-  const byProvider = db.prepare(`
-    SELECT
-      provider,
-      COALESCE(SUM(input_tokens), 0) as input_tokens,
-      COALESCE(SUM(output_tokens), 0) as output_tokens,
-      COALESCE(SUM(cost_usd), 0) as cost_usd
-    FROM usage_records
-    WHERE created_at >= ? AND provider != 'toon'
-    GROUP BY provider
-  `).all(since) as Array<{ provider: string; input_tokens: number; output_tokens: number; cost_usd: number }>;
+  const entries = await col.scan();
+  const records = entries.map(e => e.doc).filter(r => r.created_at >= since);
+
+  const totals = records.reduce((acc, r) => ({
+    total_input: acc.total_input + r.input_tokens,
+    total_output: acc.total_output + r.output_tokens,
+    total_cost: acc.total_cost + r.cost_usd,
+    toon_saved_tokens: acc.toon_saved_tokens + r.toon_saved_tokens,
+    toon_saved_cost: acc.toon_saved_cost + r.toon_saved_cost,
+    toon_saved_bytes: acc.toon_saved_bytes + r.toon_saved_bytes,
+    toon_saved_percent: acc.toon_saved_percent + r.toon_saved_percent,
+    toon_json_tokens: acc.toon_json_tokens + r.toon_json_tokens,
+    toon_toon_tokens: acc.toon_toon_tokens + r.toon_toon_tokens,
+  }), {
+    total_input: 0,
+    total_output: 0,
+    total_cost: 0,
+    toon_saved_tokens: 0,
+    toon_saved_cost: 0,
+    toon_saved_bytes: 0,
+    toon_saved_percent: 0,
+    toon_json_tokens: 0,
+    toon_toon_tokens: 0,
+  });
 
-  const byModel = db.prepare(`
-    SELECT
-      model,
-      provider,
-      COALESCE(SUM(input_tokens), 0) as input_tokens,
-      COALESCE(SUM(output_tokens), 0) as output_tokens,
-      COALESCE(SUM(cost_usd), 0) as cost_usd
-    FROM usage_records
-    WHERE created_at >= ? AND provider != 'toon'
-    GROUP BY model
-    ORDER BY cost_usd DESC
-  `).all(since) as Array<{ model: string; provider: string; input_tokens: number; output_tokens: number; cost_usd: number }>;
+  const providerMap: UsageSummary["byProvider"] = {};
+  const modelMap: UsageSummary["byModel"] = {};
 
-  const recentRecords = db.prepare(`
-    SELECT * FROM usage_records
-    WHERE created_at >= ?
-    ORDER BY created_at DESC
-    LIMIT 20
-  `).all(since) as UsageRecord[];
+  for (const r of records) {
+    if (r.provider === "toon") continue;
+    if (!providerMap[r.provider]) {
+      providerMap[r.provider] = { inputTokens: 0, outputTokens: 0, tokens: 0, costUsd: 0 };
+    }
+    providerMap[r.provider].inputTokens += r.input_tokens;
+    providerMap[r.provider].outputTokens += r.output_tokens;
+    providerMap[r.provider].tokens += r.input_tokens + r.output_tokens;
+    providerMap[r.provider].costUsd += r.cost_usd;
 
-  const providerMap: UsageSummary["byProvider"] = {};
-  for (const p of byProvider) {
-    providerMap[p.provider] = {
-      inputTokens: p.input_tokens,
-      outputTokens: p.output_tokens,
-      tokens: p.input_tokens + p.output_tokens,
-      costUsd: p.cost_usd
-    };
+    if (!modelMap[r.model]) {
+      modelMap[r.model] = { provider: r.provider, inputTokens: 0, outputTokens: 0, tokens: 0, costUsd: 0 };
+    }
+    modelMap[r.model].inputTokens += r.input_tokens;
+    modelMap[r.model].outputTokens += r.output_tokens;
+    modelMap[r.model].tokens += r.input_tokens + r.output_tokens;
+    modelMap[r.model].costUsd += r.cost_usd;
   }
 
-  const modelMap: UsageSummary["byModel"] = {};
-  for (const m of byModel) {
-    modelMap[m.model] = {
-      provider: m.provider,
-      inputTokens: m.input_tokens,
-      outputTokens: m.output_tokens,
-      tokens: m.input_tokens + m.output_tokens,
-      costUsd: m.cost_usd
-    };
-  }
+  const recentRecords = records
+    .filter(r => r.created_at >= since)
+    .sort((a, b) => b.created_at - a.created_at)
+    .slice(0, 20);
 
   const totalTokens = totals.total_input + totals.total_output;
   const totalIncludingSaved = totalTokens + totals.toon_saved_tokens;
@@ -252,7 +214,6 @@ export function getUsageStats(hours: number = 24): UsageSummary {
     ? (totals.toon_saved_tokens / totalIncludingSaved) * 100
     : 0;
 
-  // Calculate average bytes savings percent
   const toonSavedBytesPercent = totals.toon_toon_tokens > 0
     ? (totals.toon_saved_bytes / totals.toon_toon_tokens) * 100
     : 0;
@@ -271,7 +232,7 @@ export function getUsageStats(hours: number = 24): UsageSummary {
     toonSavingsPercent,
     byProvider: providerMap,
     byModel: modelMap,
-    recentRecords
+    recentRecords,
   };
 }
 
@@ -284,14 +245,9 @@ export function estimateCostForTokens(model: string, tokens: number): number {
   return (tokens / 1_000_000) * pricing.inputPer1M;
 }
 
-/**
- * Get average cost per token for a model (input + output average)
- */
 export function getAverageTokenCost(model: string): number {
-  // 1. Exact match
   let pricing = MODEL_PRICING[model];
 
-  // 2. Try stripping a single provider prefix (e.g. "openrouter/moonshotai/kimi" → "moonshotai/kimi")
   if (!pricing) {
     const slashIdx = model.indexOf('/');
     if (slashIdx !== -1) {
@@ -299,7 +255,6 @@ export function getAverageTokenCost(model: string): number {
     }
   }
 
-  // 3. Partial match — find any key whose name is contained in the model string
   if (!pricing) {
     for (const [key, p] of Object.entries(MODEL_PRICING)) {
       if (model.includes(key) || key.includes(model)) {
@@ -310,15 +265,10 @@ export function getAverageTokenCost(model: string): number {
   }
 
   if (!pricing) return 0;
-  // Average of input and output cost per token
   return (pricing.inputPer1M + pricing.outputPer1M) / 2 / 1_000_000;
 }
 
-/**
- * Record TOON savings for metrics tracking
- * This updates the usage_records table with complete TOON compression metrics
- */
-export function recordToonSavings(
+export async function recordToonSavings(
   analysis: {
     jsonBytes: number;
     toonBytes: number;
@@ -329,46 +279,35 @@ export function recordToonSavings(
     savedTokens: number;
     savedTokensPercent: number;
   },
-  costSaved: number, 
+  costSaved: number,
   category: string
-): void {
-  // Fire-and-forget to avoid blocking
-  Promise.resolve().then(async () => {
-    try {
-      const db = getDb();
-
-      // Insert TOON savings record with complete metrics
-      db.query(`
-        INSERT INTO usage_records (
-          id, provider, model, input_tokens, output_tokens, cost_usd,
-          toon_saved_tokens, toon_saved_cost,
-          toon_json_bytes, toon_toon_bytes, toon_saved_bytes, toon_saved_percent,
-          toon_json_tokens, toon_toon_tokens, toon_saved_tokens_pct,
-          created_at
-        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(
-        `toon_${category}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-        'toon',
-        category,
-        0,
-        0,
-        0,
-        Math.max(0, analysis.savedTokens),
-        costSaved,
-        analysis.jsonBytes,
-        analysis.toonBytes,
-        analysis.savedBytes,
-        Math.max(0, analysis.savedPercent),
-        analysis.jsonTokens,
-        analysis.toonTokens,
-        Math.max(0, analysis.savedTokensPercent),
-        Math.floor(Date.now() / 1000),
-      )
-
-      log.debug(`[TOON] Recorded ${analysis.savedTokens} tokens ($${costSaved.toFixed(6)}) saved for ${category}`)
-    } catch (error) {
-      log.warn(`[TOON] Failed to record savings:`, error)
-    }
-  })
+): Promise<void> {
+  try {
+    const db = await getHiveDB();
+    const col = db.collection<UsageRecord>("usage_records");
+
+    await col.put(`toon_${category}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`, {
+      id: `toon_${category}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      provider: "toon",
+      model: category,
+      input_tokens: 0,
+      output_tokens: 0,
+      cost_usd: 0,
+      latency_ms: null,
+      toon_saved_tokens: Math.max(0, analysis.savedTokens),
+      toon_saved_cost: costSaved,
+      toon_json_bytes: analysis.jsonBytes,
+      toon_toon_bytes: analysis.toonBytes,
+      toon_saved_bytes: analysis.savedBytes,
+      toon_saved_percent: Math.max(0, analysis.savedPercent),
+      toon_json_tokens: analysis.jsonTokens,
+      toon_toon_tokens: analysis.toonTokens,
+      toon_saved_tokens_pct: Math.max(0, analysis.savedTokensPercent),
+      created_at: Math.floor(Date.now() / 1000),
+    });
+
+    log.debug(`[TOON] Recorded ${analysis.savedTokens} tokens ($${costSaved.toFixed(6)}) saved for ${category}`);
+  } catch (error) {
+    log.warn(`[TOON] Failed to record savings:`, error);
+  }
 }

package/packages/core/src/tool-runtime/tool-runtime.test.ts

@@ -20,10 +20,18 @@ describe("tool runtime worker pool", () => {
   });
 
   it("runs multiple tools in parallel through worker scheduling", async () => {
+    // Per-tool delay + threshold sized for CI headroom: worker spawn/scheduling
+    // overhead is roughly fixed, so a larger delay keeps that overhead a small
+    // fraction of the budget instead of dominating it on a loaded runner.
+    // Serial execution would take ~3x the delay; the threshold stays well
+    // under that so the assertion still proves parallelism, not just patience.
+    const TOOL_DELAY_MS = 200;
+    const PARALLEL_THRESHOLD_MS = 450;
+
     const tools: RuntimeTool[] = ["slow_a", "slow_b", "slow_c"].map((name) => ({
       name,
       execute: async () => {
-        await delay(120);
+        await delay(TOOL_DELAY_MS);
         return { name };
       },
     }));
@@ -38,12 +46,12 @@ describe("tool runtime worker pool", () => {
       allTools: tools,
       toolConfig: {},
       hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 3, toolTimeoutMs: 1000, parallelToolCalls: true },
+      workerPool: { enabled: true, maxWorkers: 3, toolTimeoutMs: 5000, parallelToolCalls: true },
     });
     const elapsed = performance.now() - startedAt;
 
     expect(results.map((result) => (result.result as any).name)).toEqual(["slow_a", "slow_b", "slow_c"]);
-    expect(elapsed).toBeLessThan(260);
+    expect(elapsed).toBeLessThan(PARALLEL_THRESHOLD_MS);
   });
 
   it("preserves input order when tools complete out of order", async () => {

package/packages/core/src/tools/agents/get-available-models.ts

@@ -8,7 +8,8 @@
  */
 
 import type { Tool } from "../types.ts";
-import { getDb } from "../../storage/SQLiteStorage.ts";
+import { getHiveDB } from "../../storage/HiveDBStorage.ts";
+import type { HiveProviderDoc, HiveModelDoc } from "../../storage/hiveSeed.ts";
 
 export const getAvailableModelsTool: Tool = {
   name: "get_available_models",
@@ -31,7 +32,6 @@ export const getAvailableModelsTool: Tool = {
     },
   },
   execute: async (params: Record<string, unknown>) => {
-    const db = getDb();
     const { providerId, modelType, capabilities } = params as {
       providerId?: string;
       modelType?: string;
@@ -39,74 +39,70 @@ export const getAvailableModelsTool: Tool = {
     };
 
     try {
-      // Construir query con filtros opcionales
-      let query = `
-        SELECT 
-          p.id as provider_id,
-          p.name as provider_name,
-          p.category as provider_category,
-          m.id as model_id,
-          m.name as model_name,
-          m.model_type,
-          m.context_window,
-          m.capabilities
-        FROM models m
-        INNER JOIN providers p ON m.provider_id = p.id
-        WHERE m.enabled = 1 AND m.active = 1 AND p.enabled = 1 AND p.active = 1
-      `;
+      const db = await getHiveDB();
+      const providersCol = db.collection<HiveProviderDoc>("providers");
+      const modelsCol = db.collection<HiveModelDoc>("models");
 
-      const whereClauses: string[] = [];
-      const queryParams: string[] = [];
+      const [providers, models] = await Promise.all([
+        providersCol.scan(),
+        modelsCol.scan(),
+      ]);
+
+      const activeProviders = new Map(
+        providers
+          .filter(p => p.doc.enabled && p.doc.active)
+          .map(p => [p.id, p.doc])
+      );
+
+      let rows = models
+        .filter(m => m.doc.enabled && m.doc.active)
+        .map(m => {
+          const provider = activeProviders.get(m.doc.providerId);
+          if (!provider) return null;
+          return {
+            providerId: provider.id,
+            providerName: provider.name,
+            providerCategory: provider.category,
+            modelId: m.doc.id,
+            modelName: m.doc.name,
+            modelType: m.doc.modelType,
+            contextWindow: m.doc.contextWindow ?? null,
+            capabilities: m.doc.capabilities ?? null,
+          };
+        })
+        .filter(Boolean) as Array<{
+          providerId: string;
+          providerName: string;
+          providerCategory: string;
+          modelId: string;
+          modelName: string;
+          modelType: string;
+          contextWindow: number | null;
+          capabilities: string[] | null;
+        }>;
 
       if (providerId) {
-        whereClauses.push("p.id = ?");
-        queryParams.push(providerId as string);
+        rows = rows.filter(r => r.providerId === providerId);
       }
 
       if (modelType) {
-        whereClauses.push("m.model_type = ?");
-        queryParams.push(modelType as string);
+        rows = rows.filter(r => r.modelType === modelType);
       }
 
       if (capabilities) {
-        whereClauses.push("m.capabilities LIKE ?");
-        queryParams.push(`%${capabilities as string}%`);
-      }
-
-      if (whereClauses.length > 0) {
-        query += " AND " + whereClauses.join(" AND ");
+        const cap = capabilities.toLowerCase();
+        rows = rows.filter(r => r.capabilities?.some(c => c.toLowerCase().includes(cap)));
       }
 
-      query += " ORDER BY p.name, m.name";
-
-      // Ejecutar query
-      const rows = db.query<any, string[]>(query).all(...queryParams) as Array<{
-        provider_id: string;
-        provider_name: string;
-        provider_category: string;
-        model_id: string;
-        model_name: string;
-        model_type: string;
-        context_window: number | null;
-        capabilities: string | null;
-      }>;
-
-      // Transformar a formato amigable
-      const result = rows.map(row => ({
-        providerId: row.provider_id,
-        providerName: row.provider_name,
-        providerCategory: row.provider_category,
-        modelId: row.model_id,
-        modelName: row.model_name,
-        modelType: row.model_type,
-        contextWindow: row.context_window,
-        capabilities: row.capabilities ? JSON.parse(row.capabilities) : null,
-      }));
+      rows.sort((a, b) => {
+        if (a.providerName !== b.providerName) return a.providerName.localeCompare(b.providerName);
+        return a.modelName.localeCompare(b.modelName);
+      });
 
       return {
         ok: true,
-        count: result.length,
-        models: result,
+        count: rows.length,
+        models: rows,
       };
     } catch (error) {
       return {