devlensio 0.4.4 → 0.6.0

package/dist/config/writer.js

@@ -1,6 +1,7 @@
 //! The concept of local config file should only exist in open Source, and in case of deployment the apis for writing this cofig file should never be exposed. 
 import fs from "fs";
 import { CONFIG_FILE, CONFIG_DIR } from "./providers/file.js";
+import { makeProviderKey } from "./types.js";
 function readRawFile() {
     if (!fs.existsSync(CONFIG_FILE))
         return {};
@@ -12,10 +13,10 @@ function readRawFile() {
         return {};
     }
 }
-//  atomicWrite 
+//  atomicWrite
 // Writes to a temp file first, then renames to the real path.
 // If the server crashes mid-write, the old config survives intact.
-function atomicWrite(filePath, content) {
+export function atomicWrite(filePath, content) {
     const tmp = `${filePath}.tmp`;
     fs.writeFileSync(tmp, content, "utf-8");
     fs.renameSync(tmp, filePath);
@@ -36,17 +37,62 @@ export function writeConfig(partial) {
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
     }
     const existing = readRawFile();
+    // ── Multi-provider summarization upsert ──────────────────────────────────
+    let summarizationUpdate;
+    if (partial.summarization) {
+        const s = partial.summarization;
+        const protocol = s.provider ?? "openai";
+        const providerName = s.providerName ?? protocol;
+        const key = makeProviderKey(protocol, providerName);
+        // Read existing multi-provider structure (or build from legacy flat format)
+        const rawSum = existing.summarization;
+        let storage;
+        if (rawSum && typeof rawSum === "object" && rawSum.providers && typeof rawSum.providers === "object" && typeof rawSum.active === "string") {
+            // Already multi-provider format
+            storage = {
+                active: rawSum.active,
+                providers: rawSum.providers,
+            };
+        }
+        else {
+            // Legacy flat format or first save — create fresh multi-provider storage
+            storage = { active: key, providers: {} };
+            // If there's a legacy flat config, preserve it as the first entry
+            if (rawSum && typeof rawSum.provider === "string") {
+                const legacyKey = makeProviderKey(rawSum.provider, rawSum.providerName ?? rawSum.provider);
+                storage.providers[legacyKey] = {
+                    provider: rawSum.provider,
+                    providerName: rawSum.providerName ?? rawSum.provider,
+                    model: rawSum.model ?? "",
+                    apiKey: rawSum.apiKey,
+                    baseUrl: rawSum.baseUrl,
+                    batchSize: rawSum.batchSize ?? 50,
+                };
+                if (legacyKey !== key) {
+                    storage.active = key; // new entry becomes active
+                }
+            }
+        }
+        // Upsert the incoming entry
+        const existingEntry = storage.providers[key];
+        storage.providers[key] = {
+            provider: s.provider ?? existingEntry?.provider ?? "openai",
+            providerName: providerName,
+            model: s.model ?? existingEntry?.model ?? "",
+            apiKey: s.apiKey ?? existingEntry?.apiKey,
+            baseUrl: s.baseUrl ?? existingEntry?.baseUrl,
+            batchSize: s.batchSize ?? existingEntry?.batchSize ?? 50,
+        };
+        storage.active = key;
+        summarizationUpdate = storage;
+    }
     const updated = {
         ...existing,
-        // Only merge blocks that the user actually touched
         ...(partial.deploymentMode && {
             deploymentMode: partial.deploymentMode,
         }),
-        ...(partial.summarization && {
-            summarization: {
-                ...existing.summarization,
-                ...partial.summarization,
-            },
+        ...(summarizationUpdate && {
+            summarization: summarizationUpdate,
         }),
         ...(partial.embedding && {
             embedding: {
@@ -55,10 +101,9 @@ export function writeConfig(partial) {
             },
         }),
         // neo4j: if user sent it, merge. If user sent null explicitly, delete it.
-        // undefined means "don't touch it"
         ...(partial.neo4j !== undefined && {
             neo4j: partial.neo4j === null
-                ? undefined // user explicitly removed Neo4j config
+                ? undefined
                 : {
                     ...existing.neo4j,
                     ...partial.neo4j,
@@ -73,17 +118,19 @@ function maskKey(key) {
     // Show last 3 characters only — enough to identify which key is set
     return `...${key.slice(-3)}`;
 }
-//  maskConfig 
+//  maskConfig
 // Public — called by GET /api/config handler.
+// DevLens is OSS/local: apiKeys are returned in full (the user owns their keys).
 export function maskConfig(config) {
     return {
         deploymentMode: config.deploymentMode,
         summarization: {
             provider: config.summarization.provider,
+            providerName: config.summarization.providerName,
             model: config.summarization.model,
             baseUrl: config.summarization.baseUrl,
             batchSize: config.summarization.batchSize,
-            apiKeyHint: maskKey(config.summarization.apiKey),
+            apiKey: config.summarization.apiKey, // full key for OSS
         },
         embedding: {
             provider: config.embedding.provider,

package/dist/index.d.ts

@@ -9,7 +9,8 @@ export * from "./pipeline/index.js";
 export * from "./config/types.js";
 export { queue } from "./jobs/index.js";
 export { storage } from "./storage/index.js";
-export { resolveConfig, initConfig, maskConfig, writeConfig } from "./config/index.js";
+export { resolveConfig, initConfig, maskConfig, writeConfig, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
+export type { AllProvidersResult } from "./config/index.js";
 export { readPackageDependencies, categorizeLibrary } from "./graph/thirdPartyLibs.js";
 export { analyzePipeline } from "./pipeline/index.js";
 export { runSummarization } from "./summarizer/index.js";
@@ -18,3 +19,7 @@ export { EDGE_LABELS } from "./summarizer/prompts.js";
 export { CycleGroup, TopologicalResult } from "./summarizer/types.js";
 export { buildGraphIndex, getBlastRadius, getKHop, getSubgraph, findCycles, } from "./graph/traversal.js";
 export type { GraphIndex, TraversalHit, TraversalResult, TraversalOpts, SubgraphResult, } from "./graph/traversal.js";
+export { loadCatalog, findProvider, saveProvider, removeProvider, resetUserCatalog, listUserProviders, } from "./config/providers/catalog.js";
+export type { CatalogProvider, CatalogProviderInput } from "./config/providers/catalog.js";
+export { listModels } from "./summarizer/providers/models.js";
+export type { ListModelsOpts } from "./summarizer/providers/models.js";

package/dist/index.js

@@ -11,7 +11,7 @@ export * from "./config/types.js";
 export { queue } from "./jobs/index.js";
 export { storage } from "./storage/index.js";
 // Config helpers
-export { resolveConfig, initConfig, maskConfig, writeConfig } from "./config/index.js";
+export { resolveConfig, initConfig, maskConfig, writeConfig, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
 // Pre-scan helpers
 export { readPackageDependencies, categorizeLibrary } from "./graph/thirdPartyLibs.js";
 // Pipeline & analysis
@@ -21,3 +21,7 @@ export { computeClusters } from "./clustering/index.js";
 export { EDGE_LABELS } from "./summarizer/prompts.js";
 // Graph traversal & queries (consumed by the MCP server)
 export { buildGraphIndex, getBlastRadius, getKHop, getSubgraph, findCycles, } from "./graph/traversal.js";
+// Provider catalog (consumed by DevLens OSS frontend & CLI)
+export { loadCatalog, findProvider, saveProvider, removeProvider, resetUserCatalog, listUserProviders, } from "./config/providers/catalog.js";
+// Dynamic model discovery (consumed by DevLens OSS CLI)
+export { listModels } from "./summarizer/providers/models.js";

package/dist/summarizer/providers/anthropic.d.ts

@@ -1,9 +1,10 @@
 import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
 export declare class AnthropicClient implements LLMClient {
     readonly provider: "anthropic";
+    readonly providerName?: string;
     readonly model: string;
     private client;
-    constructor(apiKey: string, model: string);
+    constructor(apiKey: string, model: string, baseURL?: string, providerName?: string);
     summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
     validateConnection(): Promise<void>;
 }

package/dist/summarizer/providers/anthropic.js

@@ -33,10 +33,11 @@ function parseResponse(raw) {
     };
 }
 export class AnthropicClient {
-    constructor(apiKey, model) {
+    constructor(apiKey, model, baseURL, providerName) {
         this.provider = "anthropic";
         this.model = model;
-        this.client = new Anthropic({ apiKey });
+        this.providerName = providerName;
+        this.client = new Anthropic({ apiKey, ...(baseURL ? { baseURL } : {}) });
     }
     async summarize(request) {
         const systemMessage = request.messages.find(m => m.role === "system");

package/dist/summarizer/providers/index.js

@@ -1,43 +1,27 @@
-// providers/index.ts has one job — given the config, return the right LLMClient instance. It's the factory that the batch loop calls so it never has to know which provider is being used.
+// providers/index.ts has one job — given the config, return the right LLMClient instance.
+// It's the factory that the batch loop calls so it never has to know which provider is being used.
+// The switch has exactly 2 arms: the two wire protocols (openai, anthropic).
+// Brand identity (providerName) is data — resolved from the catalog or user input.
+import { findProvider } from "../../config/providers/catalog.js";
 import { AnthropicClient } from "./anthropic.js";
-import { GeminiClient } from "./gemini.js";
-import { OllamaClient } from "./ollama.js";
 import { OpenAIClient } from "./openai.js";
-import { OpenRouterClient } from "./openRouter.js";
-// ─── Factory ──────────────────────────────────────────────────────────────────
-//
-// Single entry point for the batch loop — returns the right LLMClient
-// based on config. Caller never imports individual provider classes.
-//
-// Throws clearly if:
-//   - provider is unknown
-//   - apiKey is missing for cloud providers (fail fast before the batch loop)
 export function createLLMClient(config) {
-    const { provider, model, apiKey, baseUrl } = config;
+    const { provider, providerName, model, apiKey, baseUrl } = config;
+    const entry = findProvider(providerName ?? "");
+    const needsKey = entry?.requiresKey ?? true; // unknown/custom → require key
+    const effectiveBase = baseUrl ?? entry?.baseUrl;
     switch (provider) {
-        case "anthropic":
+        case "openai": {
+            if (needsKey && !apiKey)
+                throw new Error(`Provider "${providerName}" requires an API key`);
+            return new OpenAIClient(apiKey ?? "ollama", model, effectiveBase, providerName);
+        }
+        case "anthropic": {
             if (!apiKey)
-                throw new Error("Anthropic provider requires an API key");
-            return new AnthropicClient(apiKey, model);
-        case "openai":
-            if (!apiKey)
-                throw new Error("OpenAI provider requires an API key");
-            return new OpenAIClient(apiKey, model);
-        case "openrouter":
-            if (!apiKey)
-                throw new Error("OpenRouter provider requires an API key");
-            return new OpenRouterClient(apiKey, model);
-        case "gemini":
-            if (!apiKey)
-                throw new Error("Gemini provider requires an API key");
-            return new GeminiClient(apiKey, model);
-        case "ollama":
-            return new OllamaClient(model, baseUrl);
-        case "managed":
-            // Cloud SaaS only — platform injects the key via request headers.
-            // Should never reach here in local mode.
-            throw new Error("Managed provider is only available in cloud mode");
+                throw new Error(`Provider "${providerName}" requires an API key`);
+            return new AnthropicClient(apiKey, model, effectiveBase, providerName);
+        }
         default:
-            throw new Error(`Unknown LLM provider: ${provider}`);
+            throw new Error(`Unknown provider protocol: ${provider}`);
     }
 }

package/dist/summarizer/providers/models.d.ts

@@ -0,0 +1,11 @@
+export interface ListModelsOpts {
+    protocol: "openai" | "anthropic";
+    baseUrl: string;
+    apiKey?: string;
+}
+/**
+ * Fetches the live model list from a provider's models endpoint.
+ * Returns deduped (case-insensitive), sorted model ID strings.
+ * Throws on auth/network errors with a clear message.
+ */
+export declare function listModels(opts: ListModelsOpts): Promise<string[]>;

package/dist/summarizer/providers/models.js

@@ -0,0 +1,113 @@
+const FETCH_TIMEOUT_MS = 10000;
+/**
+ * Fetches the live model list from a provider's models endpoint.
+ * Returns deduped (case-insensitive), sorted model ID strings.
+ * Throws on auth/network errors with a clear message.
+ */
+export async function listModels(opts) {
+    if (opts.protocol === "openai") {
+        return listOpenAIModels(opts.baseUrl, opts.apiKey);
+    }
+    return listAnthropicModels(opts.baseUrl, opts.apiKey);
+}
+//  OpenAI-style lister
+// GET {baseUrl}/models  |  Authorization: Bearer {apiKey}
+// Tolerant of URLs with or without /v1 — tries as-is first, retries with /v1 if empty.
+async function listOpenAIModels(baseUrl, apiKey) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    async function tryFetch(url) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        try {
+            return await fetch(url, { method: "GET", headers, signal: controller.signal });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    const cleanBase = baseUrl.replace(/\/+$/, "");
+    let res = await tryFetch(`${cleanBase}/models`);
+    // If URL has no /v1 segment and the request returned nothing useful, retry with /v1
+    if (!res.ok && !cleanBase.includes("/v1")) {
+        res = await tryFetch(`${cleanBase}/v1/models`);
+    }
+    if (res.status === 401) {
+        throw new Error("Invalid API key for this provider. Check your key in config.");
+    }
+    if (!res.ok) {
+        throw new Error(`Failed to fetch models: ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    return normalizeModels((body.data ?? []).map((m) => m.id));
+}
+//  Anthropic-style lister 
+// GET {baseUrl}/v1/models  |  x-api-key + anthropic-version
+// Paginated — loops via after_id until has_more === false
+async function listAnthropicModels(baseUrl, apiKey) {
+    if (!apiKey) {
+        throw new Error("Anthropic-style provider requires an API key to list models.");
+    }
+    const headers = {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+    };
+    const base = `${baseUrl.replace(/\/+$/, "")}/v1/models`;
+    const allIds = [];
+    let afterId;
+    let hasMore = true;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        while (hasMore) {
+            const url = afterId
+                ? `${base}?after_id=${afterId}&limit=1000`
+                : `${base}?limit=1000`;
+            const res = await fetch(url, {
+                method: "GET",
+                headers,
+                signal: controller.signal,
+            });
+            if (res.status === 401) {
+                throw new Error("Invalid API key for this provider. Check your key in config.");
+            }
+            if (!res.ok) {
+                throw new Error(`Failed to fetch models: ${res.status} ${res.statusText}`);
+            }
+            const body = (await res.json());
+            allIds.push(...(body.data ?? []).map((m) => m.id));
+            hasMore = body.has_more ?? false;
+            afterId = body.last_id;
+        }
+        return normalizeModels(allIds);
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            throw new Error(`Timed out fetching models from ${baseUrl} after ${FETCH_TIMEOUT_MS}ms`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//  Normalization 
+// Dedupe case-insensitively, sort ascending.
+function normalizeModels(models) {
+    const seen = new Set();
+    const result = [];
+    for (const m of models) {
+        const key = m.toLowerCase();
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(m);
+        }
+    }
+    result.sort((a, b) => a.localeCompare(b));
+    return result;
+}

package/dist/summarizer/providers/openai.d.ts

@@ -1,9 +1,10 @@
 import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
 export declare class OpenAIClient implements LLMClient {
     readonly provider: "openai";
+    readonly providerName?: string;
     readonly model: string;
     private client;
-    constructor(apiKey: string, model: string, baseURL?: string);
+    constructor(apiKey: string, model: string, baseURL?: string, providerName?: string);
     summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
     validateConnection(): Promise<void>;
 }

package/dist/summarizer/providers/openai.js

@@ -29,9 +29,10 @@ function parseResponse(raw) {
 // Also used as the base for OpenRouter and Ollama —
 // both expose OpenAI-compatible APIs, just with a different baseURL.
 export class OpenAIClient {
-    constructor(apiKey, model, baseURL) {
+    constructor(apiKey, model, baseURL, providerName) {
         this.provider = "openai";
         this.model = model;
+        this.providerName = providerName;
         this.client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
     }
     async summarize(request) {

package/dist/summarizer/providers/types.d.ts

@@ -20,13 +20,8 @@ export interface NodeSummaryOutput {
 }
 export interface LLMClient {
     readonly provider: LLMProvider;
+    readonly providerName?: string;
     readonly model: string;
     summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
     validateConnection(): Promise<void>;
 }
-export type LLMClientFactory = (config: {
-    provider: LLMProvider;
-    model: string;
-    apiKey?: string;
-    baseUrl?: string;
-}) => LLMClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlensio",
-  "version": "0.4.4",
+  "version": "0.6.0",
   "description": "Codebase intelligence engine for TypeScript/JavaScript/Reactjs/Nextjs repositories.",
   "type": "module",
   "main": "./dist/index.js",

package/dist/summarizer/providers/gemini.d.ts

@@ -1,9 +0,0 @@
-import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
-export declare class GeminiClient implements LLMClient {
-    readonly provider: "gemini";
-    readonly model: string;
-    private ai;
-    constructor(apiKey: string, model: string);
-    summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
-    validateConnection(): Promise<void>;
-}

package/dist/summarizer/providers/gemini.js

@@ -1,79 +0,0 @@
-import { GoogleGenAI } from "@google/genai";
-// ─── Response Parser ──────────────────────────────────────────────────────────
-//
-// Same XML format as all other providers — consistent across the board.
-const VALID_SEVERITIES = new Set(["none", "low", "medium", "high"]);
-function parseXmlTag(text, tag) {
-    const match = text.match(new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`));
-    return match ? match[1].trim() : "";
-}
-function parseResponse(raw) {
-    const technicalSummary = parseXmlTag(raw, "technical");
-    const businessSummary = parseXmlTag(raw, "business");
-    const severityRaw = parseXmlTag(raw, "security_severity").toLowerCase();
-    const securitySummary = parseXmlTag(raw, "security_summary");
-    const severity = VALID_SEVERITIES.has(severityRaw)
-        ? severityRaw
-        : "none";
-    return {
-        technicalSummary: technicalSummary || raw.trim(),
-        businessSummary: businessSummary || "",
-        security: {
-            severity,
-            summary: severity === "none" ? "" : securitySummary,
-        },
-        tokensUsed: 0,
-    };
-}
-export class GeminiClient {
-    constructor(apiKey, model) {
-        this.provider = "gemini";
-        this.model = model;
-        this.ai = new GoogleGenAI({ apiKey });
-    }
-    async summarize(request) {
-        const systemMessage = request.messages.find(m => m.role === "system");
-        const userMessages = request.messages.filter(m => m.role !== "system");
-        const contents = userMessages.map(m => ({
-            role: "user",
-            parts: [{ text: m.content }],
-        }));
-        const response = await this.ai.models.generateContent({
-            model: this.model,
-            contents,
-            config: {
-                systemInstruction: systemMessage?.content,
-                temperature: request.temperature ?? 0,
-                maxOutputTokens: request.maxTokens ?? 2048,
-            },
-        });
-        const raw = response.text ?? "";
-        const result = parseResponse(raw);
-        result.tokensUsed =
-            (response.usageMetadata?.promptTokenCount ?? 0) +
-                (response.usageMetadata?.candidatesTokenCount ?? 0);
-        return result;
-    }
-    async validateConnection() {
-        try {
-            await this.ai.models.generateContent({
-                model: this.model,
-                contents: [{ role: "user", parts: [{ text: "hi" }] }],
-                config: { maxOutputTokens: 10 },
-            });
-        }
-        catch (err) {
-            const status = err?.status ?? err?.statusCode ?? err?.code;
-            const message = err?.message ?? "";
-            if (status === 400 || message.includes("API_KEY_INVALID") || message.includes("invalid api key"))
-                throw new Error(`Gemini API key is invalid or missing. Check your key in config.`);
-            if (status === 403 || message.includes("PERMISSION_DENIED"))
-                throw new Error(`Gemini API key does not have permission to use model "${this.model}".`);
-            if (status === 404 || message.includes("models/") || message.includes("not found"))
-                throw new Error(`Gemini model "${this.model}" not found. Check model name in config.`);
-            if (status === 429 || message.includes("RESOURCE_EXHAUSTED"))
-                throw new Error(`Gemini rate limit hit during connection check. Try again shortly.`);
-            throw new Error(`Gemini connection failed: ${message || "unknown error"}`);
-        }
-    }
-}

package/dist/summarizer/providers/ollama.d.ts

@@ -1,9 +0,0 @@
-import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
-export declare class OllamaClient implements LLMClient {
-    readonly provider: "ollama";
-    readonly model: string;
-    private inner;
-    constructor(model: string, baseURL?: string);
-    summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
-    validateConnection(): Promise<void>;
-}

package/dist/summarizer/providers/ollama.js

@@ -1,23 +0,0 @@
-import { OpenAIClient } from "./openai.js";
-const OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434";
-// ─── OllamaClient ─────────────────────────────────────────────────────────────
-//
-// Ollama exposes an OpenAI-compatible API at /v1 — wraps OpenAIClient.
-// No API key needed for local usage — passes a placeholder to satisfy the SDK.
-// baseURL is configurable for users running Ollama on a non-default port or host.
-// /v1 is always appended — user-provided baseURL should not include it.
-export class OllamaClient {
-    constructor(model, baseURL) {
-        this.provider = "ollama";
-        this.model = model;
-        const base = (baseURL ?? OLLAMA_DEFAULT_BASE_URL).replace(/\/+$/, "");
-        this.inner = new OpenAIClient("ollama", // placeholder — Ollama doesn't validate the key
-        model, `${base}/v1`);
-    }
-    summarize(request) {
-        return this.inner.summarize(request);
-    }
-    validateConnection() {
-        return this.inner.validateConnection();
-    }
-}

package/dist/summarizer/providers/openRouter.d.ts

@@ -1,9 +0,0 @@
-import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
-export declare class OpenRouterClient implements LLMClient {
-    readonly provider: "openrouter";
-    readonly model: string;
-    private inner;
-    constructor(apiKey: string, model: string);
-    summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
-    validateConnection(): Promise<void>;
-}

package/dist/summarizer/providers/openRouter.js

@@ -1,19 +0,0 @@
-import { OpenAIClient } from "./openai.js";
-const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
-// ─── OpenRouterClient ─────────────────────────────────────────────────────────
-//
-// OpenRouter exposes an OpenAI-compatible API — no new logic needed.
-// Just wraps OpenAIClient with the correct baseURL and overrides provider. (OpenAI actually set the industry standard for the response of the LLMs through API.Everyone follows the OpenAI standard,  Aside of course Anthropic, because its anthropic, who even go against pentagon.)
-export class OpenRouterClient {
-    constructor(apiKey, model) {
-        this.provider = "openrouter";
-        this.model = model;
-        this.inner = new OpenAIClient(apiKey, model, OPENROUTER_BASE_URL);
-    }
-    summarize(request) {
-        return this.inner.summarize(request);
-    }
-    validateConnection() {
-        return this.inner.validateConnection();
-    }
-}