llmist 15.3.0 → 15.4.0

package/dist/index.cjs

@@ -1326,24 +1326,23 @@ function isKnownModelPattern(model) {
   return KNOWN_MODEL_PATTERNS.some((pattern) => pattern.test(model));
 }
 function resolveModel(model, options = {}) {
-  if (model.includes(":")) {
-    return model;
-  }
   const normalized = model.toLowerCase();
   if (MODEL_ALIASES[normalized]) {
     return MODEL_ALIASES[normalized];
   }
-  const modelLower = model.toLowerCase();
-  if (modelLower.startsWith("gpt")) {
+  if (model.includes(":")) {
+    return model;
+  }
+  if (normalized.startsWith("gpt")) {
     return `openai:${model}`;
   }
-  if (modelLower.startsWith("claude")) {
+  if (normalized.startsWith("claude")) {
     return `anthropic:${model}`;
   }
-  if (modelLower.startsWith("gemini")) {
+  if (normalized.startsWith("gemini")) {
     return `gemini:${model}`;
   }
-  if (modelLower.match(/^o\d/)) {
+  if (normalized.match(/^o\d/)) {
     return `openai:${model}`;
   }
   if (!isKnownModelPattern(model)) {
@@ -1408,7 +1407,16 @@ var init_model_shortcuts = __esm({
       "gemini-flash": "gemini:gemini-2.5-flash",
       "flash-lite": "gemini:gemini-2.5-flash-lite",
       "gemini-pro": "gemini:gemini-3-pro-preview",
-      pro: "gemini:gemini-3-pro-preview"
+      pro: "gemini:gemini-3-pro-preview",
+      // OpenRouter aliases (or: prefix for short)
+      "or:sonnet": "openrouter:anthropic/claude-sonnet-4-5",
+      "or:opus": "openrouter:anthropic/claude-opus-4-5",
+      "or:haiku": "openrouter:anthropic/claude-haiku-4-5",
+      "or:gpt4o": "openrouter:openai/gpt-4o",
+      "or:gpt5": "openrouter:openai/gpt-5.2",
+      "or:flash": "openrouter:google/gemini-2.5-flash",
+      "or:llama": "openrouter:meta-llama/llama-3.3-70b-instruct",
+      "or:deepseek": "openrouter:deepseek/deepseek-r1"
     };
     KNOWN_MODEL_PATTERNS = [
       /^gpt-?\d/i,
@@ -6262,84 +6270,111 @@ var init_huggingface_models = __esm({
   }
 });
 
-// src/providers/huggingface.ts
-function createHuggingFaceProviderFromEnv() {
-  const token = readEnvVar("HF_TOKEN") || readEnvVar("HUGGING_FACE_API_KEY");
-  if (!isNonEmpty(token)) {
-    return null;
-  }
-  if (!token.startsWith("hf_")) {
-    console.warn(
-      "Warning: HF token should start with 'hf_'. Authentication may fail if token format is incorrect."
-    );
-  }
-  const endpointUrl = readEnvVar("HF_ENDPOINT_URL");
-  const baseURL = endpointUrl || "https://router.huggingface.co/v1";
-  const endpointType = endpointUrl ? "dedicated" : "serverless";
-  const client = new import_openai.default({
-    apiKey: token.trim(),
-    baseURL,
-    timeout: 6e4,
-    // 60s timeout - HF free tier can be slower than OpenAI
-    maxRetries: 0
-    // Disable SDK retries - llmist handles all retries at application level
-  });
-  return new HuggingFaceProvider(client, endpointType);
-}
-var import_openai, ROLE_MAP, HuggingFaceProvider;
-var init_huggingface = __esm({
-  "src/providers/huggingface.ts"() {
+// src/providers/openai-compatible-provider.ts
+var import_openai, ROLE_MAP, OpenAICompatibleProvider;
+var init_openai_compatible_provider = __esm({
+  "src/providers/openai-compatible-provider.ts"() {
     "use strict";
     import_openai = __toESM(require("openai"), 1);
     init_messages();
     init_base_provider();
     init_constants2();
-    init_huggingface_models();
-    init_utils();
     ROLE_MAP = {
       system: "system",
       user: "user",
       assistant: "assistant"
     };
-    HuggingFaceProvider = class extends BaseProviderAdapter {
-      providerId = "huggingface";
-      endpointType;
-      constructor(client, endpointType = "serverless") {
+    OpenAICompatibleProvider = class extends BaseProviderAdapter {
+      /**
+       * Short alias for the provider (e.g., "or" for openrouter, "hf" for huggingface).
+       * If not set, only the full providerId is accepted.
+       */
+      providerAlias;
+      config;
+      constructor(client, config) {
         super(client);
-        this.endpointType = endpointType;
+        this.config = config;
       }
+      /**
+       * Check if this provider supports the given model descriptor.
+       * Accepts both the full providerId and the short alias.
+       */
       supports(descriptor) {
-        return descriptor.provider === this.providerId || descriptor.provider === "hf";
+        return descriptor.provider === this.providerId || this.providerAlias !== void 0 && descriptor.provider === this.providerAlias;
       }
-      getModelSpecs() {
-        return HUGGINGFACE_MODELS;
+      /**
+       * Get custom headers to include in requests.
+       * Override in subclasses for provider-specific headers.
+       */
+      getCustomHeaders() {
+        return this.config.customHeaders ?? {};
+      }
+      /**
+       * Enhance error messages with provider-specific guidance.
+       * Override in subclasses for better error messages.
+       */
+      enhanceError(error) {
+        if (error instanceof Error) {
+          return error;
+        }
+        return new Error(String(error));
+      }
+      /**
+       * Build provider-specific request parameters.
+       * Override in subclasses to add custom parameters from `extra`.
+       *
+       * @param extra - The extra options from LLMGenerationOptions
+       * @returns Object with provider-specific params to merge into the request
+       */
+      buildProviderSpecificParams(_extra) {
+        return {};
       }
       buildApiRequest(options, descriptor, _spec, messages) {
         const { maxTokens, temperature, topP, stopSequences, extra } = options;
-        return {
+        const request = {
           model: descriptor.name,
-          messages: messages.map((message) => this.convertToHuggingFaceMessage(message)),
-          // HF accepts max_tokens (like many providers), though OpenAI uses max_completion_tokens
-          ...maxTokens !== void 0 ? { max_tokens: maxTokens } : {},
-          temperature,
-          top_p: topP,
-          stop: stopSequences,
+          messages: messages.map((message) => this.convertMessage(message)),
           stream: true,
-          stream_options: { include_usage: true },
-          ...extra ?? {}
+          stream_options: { include_usage: true }
         };
+        if (maxTokens !== void 0) {
+          request.max_tokens = maxTokens;
+        }
+        if (temperature !== void 0) {
+          request.temperature = temperature;
+        }
+        if (topP !== void 0) {
+          request.top_p = topP;
+        }
+        if (stopSequences) {
+          request.stop = stopSequences;
+        }
+        const providerParams = this.buildProviderSpecificParams(extra);
+        Object.assign(request, providerParams);
+        if (extra) {
+          const handledKeys = Object.keys(providerParams);
+          for (const [key, value] of Object.entries(extra)) {
+            if (!handledKeys.includes(key) && !this.isProviderSpecificKey(key)) {
+              request[key] = value;
+            }
+          }
+        }
+        return request;
       }
       /**
-       * Convert an LLMMessage to HuggingFace's ChatCompletionMessageParam.
-       * HF uses OpenAI-compatible format.
-       * Handles role-specific content type requirements:
-       * - system/assistant: string content only
-       * - user: string or multimodal array content (for vision models)
+       * Check if a key should be filtered from passthrough.
+       * Override in subclasses to filter provider-specific keys from extra.
        */
-      convertToHuggingFaceMessage(message) {
+      isProviderSpecificKey(_key) {
+        return false;
+      }
+      /**
+       * Convert an LLMMessage to OpenAI's ChatCompletionMessageParam format.
+       */
+      convertMessage(message) {
         const role = ROLE_MAP[message.role];
         if (role === "user") {
-          const content = this.convertToHuggingFaceContent(message.content);
+          const content = this.convertContent(message.content);
           return {
             role: "user",
             content,
@@ -6361,11 +6396,9 @@ var init_huggingface = __esm({
         };
       }
       /**
-       * Convert llmist content to HuggingFace's content format.
-       * Optimizes by returning string for text-only content, array for multimodal.
-       * Note: Multimodal support will be added in Phase 2.
+       * Convert llmist content to OpenAI's content format.
        */
-      convertToHuggingFaceContent(content) {
+      convertContent(content) {
         if (typeof content === "string") {
           return content;
         }
@@ -6378,16 +6411,14 @@ var init_huggingface = __esm({
           }
           if (part.type === "audio") {
             throw new Error(
-              "Hugging Face chat completions do not currently support audio input in llmist. Audio support will be added in Phase 2."
+              `${this.providerId} does not support audio input through llmist. Check provider docs for model-specific audio support.`
             );
           }
           throw new Error(`Unsupported content type: ${part.type}`);
         });
       }
       /**
-       * Convert an image content part to HuggingFace's image_url format.
-       * Supports both URLs and base64 data URLs (OpenAI-compatible format).
-       * Note: Image support requires vision-capable models on HF.
+       * Convert an image content part to OpenAI's image_url format.
        */
       convertImagePart(part) {
         if (part.source.type === "url") {
@@ -6405,33 +6436,22 @@ var init_huggingface = __esm({
       }
       async executeStreamRequest(payload, signal) {
         const client = this.client;
+        const headers = this.getCustomHeaders();
+        const requestOptions = {};
+        if (signal) {
+          requestOptions.signal = signal;
+        }
+        if (Object.keys(headers).length > 0) {
+          requestOptions.headers = headers;
+        }
         try {
-          const stream2 = await client.chat.completions.create(payload, signal ? { signal } : void 0);
+          const stream2 = await client.chat.completions.create(
+            payload,
+            Object.keys(requestOptions).length > 0 ? requestOptions : void 0
+          );
           return stream2;
         } catch (error) {
-          if (error instanceof Error) {
-            if (error.message.includes("rate limit") || error.message.includes("429")) {
-              throw new Error(
-                `HF rate limit exceeded. Free tier has limits. Consider upgrading or using a dedicated endpoint. Original error: ${error.message}`
-              );
-            }
-            if (error.message.includes("model not found") || error.message.includes("404")) {
-              throw new Error(
-                `Model not available on HF ${this.endpointType} inference. Check model name or try a different endpoint type. Original error: ${error.message}`
-              );
-            }
-            if (error.message.includes("401") || error.message.includes("unauthorized")) {
-              throw new Error(
-                `HF authentication failed. Check that HF_TOKEN or HUGGING_FACE_API_KEY is set correctly and starts with 'hf_'. Original error: ${error.message}`
-              );
-            }
-            if (error.message.includes("400") || error.name === "BadRequestError") {
-              throw new Error(
-                `HF bad request (often transient on serverless). Original error: ${error.message}`
-              );
-            }
-          }
-          throw error;
+          throw this.enhanceError(error);
         }
       }
       async *normalizeProviderStream(iterable) {
@@ -6446,7 +6466,6 @@ var init_huggingface = __esm({
             inputTokens: chunk.usage.prompt_tokens,
             outputTokens: chunk.usage.completion_tokens,
             totalTokens: chunk.usage.total_tokens,
-            // HF doesn't currently support prompt caching, but structure is ready
             cachedInputTokens: 0
           } : void 0;
           if (finishReason || usage) {
@@ -6455,21 +6474,8 @@ var init_huggingface = __esm({
         }
       }
       /**
-       * Count tokens in messages using character-based fallback estimation.
-       *
-       * Hugging Face doesn't provide a native token counting API yet, so we use
-       * a simple character-based heuristic (4 chars per token) which is reasonably
-       * accurate for most models.
-       *
-       * Future enhancement: Could integrate tiktoken for common model families
-       * (Llama, Mistral) that use known tokenizers.
-       *
-       * @param messages - The messages to count tokens for
-       * @param descriptor - Model descriptor containing the model name
-       * @param _spec - Optional model specification (currently unused)
-       * @returns Promise resolving to the estimated input token count
-       *
-       * @throws Never throws - returns 0 on error with warning
+       * Count tokens using character-based fallback estimation.
+       * Most meta-providers don't have a native token counting API.
        */
       async countTokens(messages, descriptor, _spec) {
         try {
@@ -6492,6 +6498,87 @@ var init_huggingface = __esm({
   }
 });
 
+// src/providers/huggingface.ts
+function createHuggingFaceProviderFromEnv() {
+  const token = readEnvVar("HF_TOKEN") || readEnvVar("HUGGING_FACE_API_KEY");
+  if (!isNonEmpty(token)) {
+    return null;
+  }
+  if (!token.startsWith("hf_")) {
+    console.warn(
+      "Warning: HF token should start with 'hf_'. Authentication may fail if token format is incorrect."
+    );
+  }
+  const endpointUrl = readEnvVar("HF_ENDPOINT_URL");
+  const baseURL = endpointUrl || "https://router.huggingface.co/v1";
+  const endpointType = endpointUrl ? "dedicated" : "serverless";
+  const config = {
+    endpointType
+  };
+  const client = new import_openai2.default({
+    apiKey: token.trim(),
+    baseURL,
+    timeout: 6e4,
+    // 60s timeout - HF free tier can be slower than OpenAI
+    maxRetries: 0
+    // Disable SDK retries - llmist handles all retries at application level
+  });
+  return new HuggingFaceProvider(client, config);
+}
+var import_openai2, HuggingFaceProvider;
+var init_huggingface = __esm({
+  "src/providers/huggingface.ts"() {
+    "use strict";
+    import_openai2 = __toESM(require("openai"), 1);
+    init_huggingface_models();
+    init_openai_compatible_provider();
+    init_utils();
+    HuggingFaceProvider = class extends OpenAICompatibleProvider {
+      providerId = "huggingface";
+      providerAlias = "hf";
+      constructor(client, config = {}) {
+        super(client, { endpointType: "serverless", ...config });
+      }
+      getModelSpecs() {
+        return HUGGINGFACE_MODELS;
+      }
+      /**
+       * Enhance error messages with HuggingFace-specific guidance.
+       */
+      enhanceError(error) {
+        if (!(error instanceof Error)) {
+          return new Error(String(error));
+        }
+        const message = error.message.toLowerCase();
+        if (message.includes("rate limit") || message.includes("429")) {
+          return new Error(
+            `HF rate limit exceeded. Free tier has limits. Consider upgrading or using a dedicated endpoint.
+Original error: ${error.message}`
+          );
+        }
+        if (message.includes("model not found") || message.includes("404")) {
+          return new Error(
+            `Model not available on HF ${this.config.endpointType} inference. Check model name or try a different endpoint type.
+Original error: ${error.message}`
+          );
+        }
+        if (message.includes("401") || message.includes("unauthorized")) {
+          return new Error(
+            `HF authentication failed. Check that HF_TOKEN or HUGGING_FACE_API_KEY is set correctly and starts with 'hf_'.
+Original error: ${error.message}`
+          );
+        }
+        if (message.includes("400") || message.includes("bad request")) {
+          return new Error(
+            `HF bad request (often transient on serverless). Original error: ${error.message}`
+          );
+        }
+        return error;
+      }
+    };
+  }
+});
+
 // src/providers/openai-image-models.ts
 function getOpenAIImageModelSpec(modelId) {
   return openaiImageModels.find((m) => m.modelId === modelId);
@@ -7338,13 +7425,13 @@ function sanitizeExtra(extra, allowTemperature) {
   return Object.fromEntries(Object.entries(extra).filter(([key]) => key !== "temperature"));
 }
 function createOpenAIProviderFromEnv() {
-  return createProviderFromEnv("OPENAI_API_KEY", import_openai2.default, OpenAIChatProvider);
+  return createProviderFromEnv("OPENAI_API_KEY", import_openai3.default, OpenAIChatProvider);
 }
-var import_openai2, import_tiktoken, ROLE_MAP2, OpenAIChatProvider;
+var import_openai3, import_tiktoken, ROLE_MAP2, OpenAIChatProvider;
 var init_openai = __esm({
   "src/providers/openai.ts"() {
     "use strict";
-    import_openai2 = __toESM(require("openai"), 1);
+    import_openai3 = __toESM(require("openai"), 1);
     import_tiktoken = require("tiktoken");
     init_messages();
     init_base_provider();
@@ -7643,6 +7730,475 @@ var init_openai = __esm({
   }
 });
 
+// src/providers/openrouter-models.ts
+var OPENROUTER_MODELS;
+var init_openrouter_models = __esm({
+  "src/providers/openrouter-models.ts"() {
+    "use strict";
+    OPENROUTER_MODELS = [
+      // ============================================================
+      // Anthropic Claude Models (via OpenRouter)
+      // ============================================================
+      {
+        provider: "openrouter",
+        modelId: "anthropic/claude-sonnet-4-5",
+        displayName: "Claude Sonnet 4.5 (OpenRouter)",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 3,
+          output: 15
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          notes: "Anthropic Claude via OpenRouter. Pricing may vary."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "anthropic/claude-opus-4-5",
+        displayName: "Claude Opus 4.5 (OpenRouter)",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 15,
+          output: 75
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          notes: "Anthropic Claude Opus via OpenRouter. Most capable Claude model."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "anthropic/claude-haiku-4-5",
+        displayName: "Claude Haiku 4.5 (OpenRouter)",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3,
+        pricing: {
+          input: 0.8,
+          output: 4
+        },
+        knowledgeCutoff: "2025-02",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Claude 4",
+          notes: "Anthropic Claude Haiku via OpenRouter. Fast and efficient."
+        }
+      },
+      // ============================================================
+      // OpenAI GPT Models (via OpenRouter)
+      // ============================================================
+      {
+        provider: "openrouter",
+        modelId: "openai/gpt-4o",
+        displayName: "GPT-4o (OpenRouter)",
+        contextWindow: 128e3,
+        maxOutputTokens: 16384,
+        pricing: {
+          input: 2.5,
+          output: 10
+        },
+        knowledgeCutoff: "2024-10",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true
+        },
+        metadata: {
+          family: "GPT-4",
+          notes: "OpenAI GPT-4o via OpenRouter."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "openai/gpt-4o-mini",
+        displayName: "GPT-4o Mini (OpenRouter)",
+        contextWindow: 128e3,
+        maxOutputTokens: 16384,
+        pricing: {
+          input: 0.15,
+          output: 0.6
+        },
+        knowledgeCutoff: "2024-10",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true
+        },
+        metadata: {
+          family: "GPT-4",
+          notes: "OpenAI GPT-4o Mini via OpenRouter. Cost-effective option."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "openai/gpt-5.2",
+        displayName: "GPT-5.2 (OpenRouter)",
+        contextWindow: 1e6,
+        maxOutputTokens: 128e3,
+        pricing: {
+          input: 5,
+          output: 20
+        },
+        knowledgeCutoff: "2025-03",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "GPT-5",
+          notes: "OpenAI GPT-5.2 via OpenRouter. Latest flagship model."
+        }
+      },
+      // ============================================================
+      // Google Gemini Models (via OpenRouter)
+      // ============================================================
+      {
+        provider: "openrouter",
+        modelId: "google/gemini-2.5-flash",
+        displayName: "Gemini 2.5 Flash (OpenRouter)",
+        contextWindow: 1e6,
+        maxOutputTokens: 65536,
+        pricing: {
+          input: 0.15,
+          output: 0.6
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Gemini 2.5",
+          notes: "Google Gemini 2.5 Flash via OpenRouter. Fast and cost-effective."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "google/gemini-2.5-pro",
+        displayName: "Gemini 2.5 Pro (OpenRouter)",
+        contextWindow: 1e6,
+        maxOutputTokens: 65536,
+        pricing: {
+          input: 2.5,
+          output: 10
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true,
+          reasoning: true
+        },
+        metadata: {
+          family: "Gemini 2.5",
+          notes: "Google Gemini 2.5 Pro via OpenRouter."
+        }
+      },
+      // ============================================================
+      // Meta Llama Models (via OpenRouter)
+      // ============================================================
+      {
+        provider: "openrouter",
+        modelId: "meta-llama/llama-3.3-70b-instruct",
+        displayName: "Llama 3.3 70B Instruct (OpenRouter)",
+        contextWindow: 128e3,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.4,
+          output: 0.4
+        },
+        knowledgeCutoff: "2024-12",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: false
+        },
+        metadata: {
+          family: "Llama 3.3",
+          notes: "Meta Llama 3.3 70B via OpenRouter. Excellent open-source model."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "meta-llama/llama-4-maverick",
+        displayName: "Llama 4 Maverick (OpenRouter)",
+        contextWindow: 1e6,
+        maxOutputTokens: 128e3,
+        pricing: {
+          input: 0.2,
+          output: 0.6
+        },
+        knowledgeCutoff: "2025-04",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: true
+        },
+        metadata: {
+          family: "Llama 4",
+          notes: "Meta Llama 4 Maverick via OpenRouter. Latest Llama generation."
+        }
+      },
+      // ============================================================
+      // DeepSeek Models (via OpenRouter)
+      // ============================================================
+      {
+        provider: "openrouter",
+        modelId: "deepseek/deepseek-r1",
+        displayName: "DeepSeek R1 (OpenRouter)",
+        contextWindow: 64e3,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.55,
+          output: 2.19
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: false,
+          reasoning: true
+        },
+        metadata: {
+          family: "DeepSeek R1",
+          notes: "DeepSeek R1 via OpenRouter. Strong reasoning capabilities."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "deepseek/deepseek-chat",
+        displayName: "DeepSeek Chat (OpenRouter)",
+        contextWindow: 64e3,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.14,
+          output: 0.28
+        },
+        knowledgeCutoff: "2025-01",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: false
+        },
+        metadata: {
+          family: "DeepSeek V3",
+          notes: "DeepSeek Chat via OpenRouter. Very cost-effective."
+        }
+      },
+      // ============================================================
+      // Mistral Models (via OpenRouter)
+      // ============================================================
+      {
+        provider: "openrouter",
+        modelId: "mistralai/mistral-large",
+        displayName: "Mistral Large (OpenRouter)",
+        contextWindow: 128e3,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 2,
+          output: 6
+        },
+        knowledgeCutoff: "2024-11",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: false
+        },
+        metadata: {
+          family: "Mistral Large",
+          notes: "Mistral Large via OpenRouter. Strong multilingual capabilities."
+        }
+      },
+      {
+        provider: "openrouter",
+        modelId: "mistralai/mixtral-8x22b-instruct",
+        displayName: "Mixtral 8x22B Instruct (OpenRouter)",
+        contextWindow: 65536,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.9,
+          output: 0.9
+        },
+        knowledgeCutoff: "2024-04",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: false
+        },
+        metadata: {
+          family: "Mixtral",
+          notes: "Mixtral 8x22B via OpenRouter. Sparse MoE architecture."
+        }
+      },
+      // ============================================================
+      // Qwen Models (via OpenRouter)
+      // ============================================================
+      {
+        provider: "openrouter",
+        modelId: "qwen/qwen-2.5-72b-instruct",
+        displayName: "Qwen 2.5 72B Instruct (OpenRouter)",
+        contextWindow: 131072,
+        maxOutputTokens: 8192,
+        pricing: {
+          input: 0.35,
+          output: 0.4
+        },
+        knowledgeCutoff: "2024-09",
+        features: {
+          streaming: true,
+          functionCalling: true,
+          vision: false
+        },
+        metadata: {
+          family: "Qwen 2.5",
+          notes: "Qwen 2.5 72B via OpenRouter. Strong coding and math."
+        }
+      }
+    ];
+  }
+});
+
+// src/providers/openrouter.ts
+function createOpenRouterProviderFromEnv() {
+  const apiKey = readEnvVar("OPENROUTER_API_KEY");
+  if (!isNonEmpty(apiKey)) {
+    return null;
+  }
+  const config = {
+    siteUrl: readEnvVar("OPENROUTER_SITE_URL"),
+    appName: readEnvVar("OPENROUTER_APP_NAME") || "llmist"
+  };
+  const client = new import_openai4.default({
+    apiKey: apiKey.trim(),
+    baseURL: "https://openrouter.ai/api/v1",
+    timeout: 12e4,
+    // 2 minute timeout
+    maxRetries: 0
+    // Disable SDK retries - llmist handles all retries at application level
+  });
+  return new OpenRouterProvider(client, config);
+}
+var import_openai4, OpenRouterProvider;
+var init_openrouter = __esm({
+  "src/providers/openrouter.ts"() {
+    "use strict";
+    import_openai4 = __toESM(require("openai"), 1);
+    init_openai_compatible_provider();
+    init_openrouter_models();
+    init_utils();
+    OpenRouterProvider = class extends OpenAICompatibleProvider {
+      providerId = "openrouter";
+      providerAlias = "or";
+      constructor(client, config = {}) {
+        super(client, config);
+      }
+      getModelSpecs() {
+        return OPENROUTER_MODELS;
+      }
+      /**
+       * Get custom headers for OpenRouter analytics.
+       */
+      getCustomHeaders() {
+        const headers = {};
+        if (this.config.siteUrl) {
+          headers["HTTP-Referer"] = this.config.siteUrl;
+        }
+        if (this.config.appName) {
+          headers["X-Title"] = this.config.appName;
+        }
+        return headers;
+      }
+      /**
+       * Build OpenRouter-specific request parameters from `extra.routing`.
+       */
+      buildProviderSpecificParams(extra) {
+        const routing = extra?.routing;
+        if (!routing) {
+          return {};
+        }
+        const params = {};
+        if (routing.models && routing.models.length > 0) {
+          params.models = routing.models;
+        }
+        if (routing.route) {
+          params.route = routing.route;
+        }
+        if (routing.provider) {
+          params.provider = { order: [routing.provider] };
+        } else if (routing.order && routing.order.length > 0) {
+          params.provider = { order: routing.order };
+        }
+        return params;
+      }
+      /**
+       * Filter out the 'routing' key from extra passthrough.
+       */
+      isProviderSpecificKey(key) {
+        return key === "routing";
+      }
+      /**
+       * Enhance error messages with OpenRouter-specific guidance.
+       */
+      enhanceError(error) {
+        if (!(error instanceof Error)) {
+          return new Error(String(error));
+        }
+        const message = error.message.toLowerCase();
+        if (message.includes("402") || message.includes("insufficient")) {
+          return new Error(
+            `OpenRouter: Insufficient credits. Add funds at https://openrouter.ai/credits
+Original error: ${error.message}`
+          );
+        }
+        if (message.includes("429") || message.includes("rate limit")) {
+          return new Error(
+            `OpenRouter: Rate limit exceeded. Consider upgrading your plan or reducing request frequency.
+Original error: ${error.message}`
+          );
+        }
+        if (message.includes("503") || message.includes("unavailable")) {
+          return new Error(
+            `OpenRouter: Model temporarily unavailable. Try a different model or use the 'models' fallback option for automatic retry.
+Original error: ${error.message}`
+          );
+        }
+        if (message.includes("401") || message.includes("unauthorized") || message.includes("invalid")) {
+          return new Error(
+            `OpenRouter: Authentication failed. Check that OPENROUTER_API_KEY is set correctly.
+Original error: ${error.message}`
+          );
+        }
+        return error;
+      }
+    };
+  }
+});
+
 // src/providers/discovery.ts
 function discoverProviderAdapters() {
   const adapters = [];
@@ -7662,11 +8218,13 @@ var init_discovery = __esm({
     init_gemini();
     init_huggingface();
     init_openai();
+    init_openrouter();
     DISCOVERERS = [
       createOpenAIProviderFromEnv,
       createAnthropicProviderFromEnv,
       createGeminiProviderFromEnv,
-      createHuggingFaceProviderFromEnv
+      createHuggingFaceProviderFromEnv,
+      createOpenRouterProviderFromEnv
     ];
   }
 });
@@ -13126,6 +13684,8 @@ __export(index_exports, {
   ModelIdentifierParser: () => ModelIdentifierParser,
   ModelRegistry: () => ModelRegistry,
   OpenAIChatProvider: () => OpenAIChatProvider,
+  OpenAICompatibleProvider: () => OpenAICompatibleProvider,
+  OpenRouterProvider: () => OpenRouterProvider,
   RateLimitTracker: () => RateLimitTracker,
   SimpleSessionManager: () => SimpleSessionManager,
   SlidingWindowStrategy: () => SlidingWindowStrategy,
@@ -13147,6 +13707,7 @@ __export(index_exports, {
   createLogger: () => createLogger,
   createMediaOutput: () => createMediaOutput,
   createOpenAIProviderFromEnv: () => createOpenAIProviderFromEnv,
+  createOpenRouterProviderFromEnv: () => createOpenRouterProviderFromEnv,
   createSubagent: () => createSubagent,
   defaultLogger: () => defaultLogger,
   detectAudioMimeType: () => detectAudioMimeType,
@@ -14497,6 +15058,8 @@ init_discovery();
 init_gemini();
 init_huggingface();
 init_openai();
+init_openai_compatible_provider();
+init_openrouter();
 
 // src/session/manager.ts
 var BaseSessionManager = class {
@@ -14771,6 +15334,8 @@ function getHostExports2(ctx) {
   ModelIdentifierParser,
   ModelRegistry,
   OpenAIChatProvider,
+  OpenAICompatibleProvider,
+  OpenRouterProvider,
   RateLimitTracker,
   SimpleSessionManager,
   SlidingWindowStrategy,
@@ -14792,6 +15357,7 @@ function getHostExports2(ctx) {
   createLogger,
   createMediaOutput,
   createOpenAIProviderFromEnv,
+  createOpenRouterProviderFromEnv,
   createSubagent,
   defaultLogger,
   detectAudioMimeType,