@mastra/core 0.20.0 → 0.20.1-alpha.2

package/dist/{chunk-2SH5WPUA.cjs → chunk-BG5FC6ZZ.cjs}

@@ -2,6 +2,352 @@
 
 var chunkUU5L5GDY_cjs = require('./chunk-UU5L5GDY.cjs');
 var chunkWM4VQWOZ_cjs = require('./chunk-WM4VQWOZ.cjs');
+var crypto = require('crypto');
+var anthropicV5 = require('@ai-sdk/anthropic-v5');
+var googleV5 = require('@ai-sdk/google-v5');
+var openaiCompatibleV5 = require('@ai-sdk/openai-compatible-v5');
+var openaiV5 = require('@ai-sdk/openai-v5');
+var xaiV5 = require('@ai-sdk/xai-v5');
+var aiSdkProviderV5 = require('@openrouter/ai-sdk-provider-v5');
+
+// src/llm/model/gateway-resolver.ts
+function parseModelRouterId(routerId, gatewayPrefix) {
+  if (gatewayPrefix && !routerId.startsWith(`${gatewayPrefix}/`)) {
+    throw new Error(`Expected ${gatewayPrefix}/ in model router ID ${routerId}`);
+  }
+  const idParts = routerId.split("/");
+  if (gatewayPrefix && idParts.length < 3) {
+    throw new Error(
+      `Expected atleast 3 id parts ${gatewayPrefix}/provider/model, but only saw ${idParts.length} in ${routerId}`
+    );
+  }
+  const providerId = idParts.at(gatewayPrefix ? 1 : 0);
+  const modelId = idParts.slice(gatewayPrefix ? 2 : 1).join(`/`);
+  if (!routerId.includes(`/`) || !providerId || !modelId) {
+    throw new Error(
+      `Attempted to parse provider/model from ${routerId} but this ID doesn't appear to contain a provider`
+    );
+  }
+  return {
+    providerId,
+    modelId
+  };
+}
+
+// src/llm/model/gateways/base.ts
+var MastraModelGateway = class {
+};
+
+// src/llm/model/gateways/constants.ts
+var PROVIDERS_WITH_INSTALLED_PACKAGES = ["anthropic", "google", "openai", "openrouter", "xai"];
+var EXCLUDED_PROVIDERS = ["github-copilot"];
+
+// src/llm/model/gateways/models-dev.ts
+var OPENAI_COMPATIBLE_OVERRIDES = {
+  cerebras: {
+    url: "https://api.cerebras.ai/v1/chat/completions"
+  },
+  xai: {
+    url: "https://api.x.ai/v1/chat/completions"
+  },
+  mistral: {
+    url: "https://api.mistral.ai/v1/chat/completions"
+  },
+  groq: {
+    url: "https://api.groq.com/openai/v1/chat/completions"
+  },
+  togetherai: {
+    url: "https://api.together.xyz/v1/chat/completions"
+  },
+  deepinfra: {
+    url: "https://api.deepinfra.com/v1/openai/chat/completions"
+  },
+  perplexity: {
+    url: "https://api.perplexity.ai/chat/completions"
+  },
+  vercel: {
+    url: "https://ai-gateway.vercel.sh/v1/chat/completions",
+    apiKeyEnvVar: "AI_GATEWAY_API_KEY"
+  }
+};
+var ModelsDevGateway = class extends MastraModelGateway {
+  name = "models.dev";
+  prefix = void 0;
+  // No prefix for registry gateway
+  providerConfigs = {};
+  constructor(providerConfigs) {
+    super();
+    if (providerConfigs) this.providerConfigs = providerConfigs;
+  }
+  async fetchProviders() {
+    console.info("Fetching providers from models.dev API...");
+    const response = await fetch("https://models.dev/api.json");
+    if (!response.ok) {
+      throw new Error(`Failed to fetch from models.dev: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const providerConfigs = {};
+    for (const [providerId, providerInfo] of Object.entries(data)) {
+      if (EXCLUDED_PROVIDERS.includes(providerId)) continue;
+      if (!providerInfo || typeof providerInfo !== "object" || !providerInfo.models) continue;
+      const normalizedId = providerId;
+      const isOpenAICompatible = providerInfo.npm === "@ai-sdk/openai-compatible" || providerInfo.npm === "@ai-sdk/gateway" || // Vercel AI Gateway is OpenAI-compatible
+      normalizedId in OPENAI_COMPATIBLE_OVERRIDES;
+      const hasInstalledPackage = PROVIDERS_WITH_INSTALLED_PACKAGES.includes(providerId);
+      const hasApiAndEnv = providerInfo.api && providerInfo.env && providerInfo.env.length > 0;
+      if (isOpenAICompatible || hasInstalledPackage || hasApiAndEnv) {
+        const modelIds = Object.keys(providerInfo.models).sort();
+        let url = providerInfo.api || OPENAI_COMPATIBLE_OVERRIDES[normalizedId]?.url;
+        if (!hasInstalledPackage && url && !url.includes("/chat/completions") && !url.includes("/messages")) {
+          url = url.replace(/\/$/, "") + "/chat/completions";
+        }
+        if (!hasInstalledPackage && !url) {
+          console.info(`Skipping ${normalizedId}: No API URL available`);
+          continue;
+        }
+        const apiKeyEnvVar = providerInfo.env?.[0] || `${normalizedId.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+        const apiKeyHeader = !hasInstalledPackage ? OPENAI_COMPATIBLE_OVERRIDES[normalizedId]?.apiKeyHeader || "Authorization" : void 0;
+        providerConfigs[normalizedId] = {
+          url,
+          apiKeyEnvVar,
+          apiKeyHeader,
+          name: providerInfo.name || providerId.charAt(0).toUpperCase() + providerId.slice(1),
+          models: modelIds,
+          docUrl: providerInfo.doc,
+          // Include documentation URL if available
+          gateway: `models.dev`
+        };
+      } else {
+        console.info(`Skipped provider ${providerInfo.name}`);
+      }
+    }
+    this.providerConfigs = providerConfigs;
+    console.info(`Found ${Object.keys(providerConfigs).length} OpenAI-compatible providers`);
+    console.info("Providers:", Object.keys(providerConfigs).sort());
+    return providerConfigs;
+  }
+  buildUrl(routerId, envVars) {
+    const { providerId } = parseModelRouterId(routerId);
+    const config = this.providerConfigs[providerId];
+    if (!config?.url) {
+      return;
+    }
+    const baseUrlEnvVar = `${providerId.toUpperCase().replace(/-/g, "_")}_BASE_URL`;
+    const customBaseUrl = envVars?.[baseUrlEnvVar] || process.env[baseUrlEnvVar];
+    return customBaseUrl || config.url;
+  }
+  getApiKey(modelId) {
+    const [provider, model] = modelId.split("/");
+    if (!provider || !model) {
+      throw new Error(`Could not identify provider from model id ${modelId}`);
+    }
+    const config = this.providerConfigs[provider];
+    if (!config) {
+      throw new Error(`Could not find config for provider ${provider} with model id ${modelId}`);
+    }
+    const apiKey = typeof config.apiKeyEnvVar === `string` ? process.env[config.apiKeyEnvVar] : void 0;
+    if (!apiKey) {
+      throw new Error(`Could not find API key process.env.${config.apiKeyEnvVar} for model id ${modelId}`);
+    }
+    return Promise.resolve(apiKey);
+  }
+  async resolveLanguageModel({
+    modelId,
+    providerId,
+    apiKey
+  }) {
+    const baseURL = this.buildUrl(`${providerId}/${modelId}`);
+    switch (providerId) {
+      case "openai":
+        return openaiV5.createOpenAI({ apiKey }).responses(modelId);
+      case "gemini":
+      case "google":
+        return googleV5.createGoogleGenerativeAI({
+          apiKey
+        }).chat(modelId);
+      case "anthropic":
+        return anthropicV5.createAnthropic({ apiKey })(modelId);
+      case "openrouter":
+        return aiSdkProviderV5.createOpenRouter({ apiKey })(modelId);
+      case "xai":
+        return xaiV5.createXai({
+          apiKey
+        })(modelId);
+      default:
+        if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
+        return openaiCompatibleV5.createOpenAICompatible({ name: providerId, apiKey, baseURL }).chatModel(modelId);
+    }
+  }
+};
+var NetlifyGateway = class extends MastraModelGateway {
+  name = "netlify";
+  prefix = "netlify";
+  // All providers will be prefixed with "netlify/"
+  tokenCache = new chunkUU5L5GDY_cjs.InMemoryServerCache();
+  async fetchProviders() {
+    console.info("Fetching providers from Netlify AI Gateway...");
+    const response = await fetch("https://api.netlify.com/api/v1/ai-gateway/providers");
+    if (!response.ok) {
+      throw new Error(`Failed to fetch from Netlify: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const netlify = {
+      apiKeyEnvVar: ["NETLIFY_TOKEN", "NETLIFY_SITE_ID"],
+      apiKeyHeader: "Authorization",
+      // Netlify uses standard Bearer auth
+      name: `Netlify`,
+      gateway: `netlify`,
+      models: [],
+      docUrl: "https://docs.netlify.com/build/ai-gateway/overview/"
+    };
+    for (const [providerId, provider] of Object.entries(data.providers)) {
+      for (const model of provider.models) {
+        netlify.models.push(`${providerId}/${model}`);
+      }
+    }
+    console.info(`Found ${Object.keys(data.providers).length} models via Netlify Gateway`);
+    return { netlify };
+  }
+  async buildUrl(routerId, envVars) {
+    const siteId = envVars?.["NETLIFY_SITE_ID"] || process.env["NETLIFY_SITE_ID"];
+    const netlifyToken = envVars?.["NETLIFY_TOKEN"] || process.env["NETLIFY_TOKEN"];
+    if (!netlifyToken) {
+      throw new chunkWM4VQWOZ_cjs.MastraError({
+        id: "NETLIFY_GATEWAY_NO_TOKEN",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Missing NETLIFY_TOKEN environment variable required for model: ${routerId}`
+      });
+    }
+    if (!siteId) {
+      throw new chunkWM4VQWOZ_cjs.MastraError({
+        id: "NETLIFY_GATEWAY_NO_SITE_ID",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Missing NETLIFY_SITE_ID environment variable required for model: ${routerId}`
+      });
+    }
+    try {
+      const tokenData = await this.getOrFetchToken(siteId, netlifyToken);
+      return tokenData.url.endsWith(`/`) ? tokenData.url.substring(0, tokenData.url.length - 1) : tokenData.url;
+    } catch (error) {
+      throw new chunkWM4VQWOZ_cjs.MastraError({
+        id: "NETLIFY_GATEWAY_TOKEN_ERROR",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Failed to get Netlify AI Gateway token for model ${routerId}: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  /**
+   * Get cached token or fetch a new site-specific AI Gateway token from Netlify
+   */
+  async getOrFetchToken(siteId, netlifyToken) {
+    const cacheKey = `netlify-token:${siteId}:${netlifyToken}`;
+    const cached = await this.tokenCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now() / 1e3 + 60) {
+      return { token: cached.token, url: cached.url };
+    }
+    const response = await fetch(`https://api.netlify.com/api/v1/sites/${siteId}/ai-gateway/token`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${netlifyToken}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to get Netlify AI Gateway token: ${response.status} ${error}`);
+    }
+    const tokenResponse = await response.json();
+    await this.tokenCache.set(cacheKey, {
+      token: tokenResponse.token,
+      url: tokenResponse.url,
+      expiresAt: tokenResponse.expires_at
+    });
+    return { token: tokenResponse.token, url: tokenResponse.url };
+  }
+  /**
+   * Get cached token or fetch a new site-specific AI Gateway token from Netlify
+   */
+  async getApiKey(modelId) {
+    const siteId = process.env["NETLIFY_SITE_ID"];
+    const netlifyToken = process.env["NETLIFY_TOKEN"];
+    if (!netlifyToken) {
+      throw new chunkWM4VQWOZ_cjs.MastraError({
+        id: "NETLIFY_GATEWAY_NO_TOKEN",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Missing NETLIFY_TOKEN environment variable required for model: ${modelId}`
+      });
+    }
+    if (!siteId) {
+      throw new chunkWM4VQWOZ_cjs.MastraError({
+        id: "NETLIFY_GATEWAY_NO_SITE_ID",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Missing NETLIFY_SITE_ID environment variable required for model: ${modelId}`
+      });
+    }
+    try {
+      return (await this.getOrFetchToken(siteId, netlifyToken)).token;
+    } catch (error) {
+      throw new chunkWM4VQWOZ_cjs.MastraError({
+        id: "NETLIFY_GATEWAY_TOKEN_ERROR",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Failed to get Netlify AI Gateway token for model ${modelId}: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  async resolveLanguageModel({
+    modelId,
+    providerId,
+    apiKey
+  }) {
+    const baseURL = await this.buildUrl(`${providerId}/${modelId}`);
+    switch (providerId) {
+      case "openai":
+        return openaiV5.createOpenAI({ apiKey, baseURL }).responses(modelId);
+      case "gemini":
+        return googleV5.createGoogleGenerativeAI({
+          baseURL: `${baseURL}/v1beta/`,
+          apiKey,
+          headers: {
+            "user-agent": "google-genai-sdk/"
+          }
+        }).chat(modelId);
+      case "anthropic":
+        return anthropicV5.createAnthropic({
+          apiKey,
+          baseURL: `${baseURL}/v1/`,
+          headers: {
+            "anthropic-version": "2023-06-01",
+            "user-agent": "anthropic/"
+          }
+        })(modelId);
+      default:
+        return openaiCompatibleV5.createOpenAICompatible({ name: providerId, apiKey, baseURL }).chatModel(modelId);
+    }
+  }
+};
+
+// src/llm/model/gateways/index.ts
+function findGatewayForModel(gatewayId, gateways2) {
+  const prefixedGateway = gateways2.find((g) => g.prefix && gatewayId.startsWith(`${g.prefix}/`));
+  if (prefixedGateway) {
+    return prefixedGateway;
+  }
+  const unprefixedGateways = gateways2.filter((g) => !g.prefix);
+  for (const gateway of unprefixedGateways) {
+    return gateway;
+  }
+  throw new chunkWM4VQWOZ_cjs.MastraError({
+    id: "MODEL_ROUTER_NO_GATEWAY_FOUND",
+    category: "USER",
+    domain: "MODEL_ROUTER",
+    text: `No Mastra model router gateway found for model id ${gatewayId}`
+  });
+}
 
 // src/llm/model/provider-registry.generated.ts
 var PROVIDER_REGISTRY = {
@@ -53,7 +399,6 @@ var PROVIDER_REGISTRY = {
   xai: {
     url: "https://api.x.ai/v1/chat/completions",
     apiKeyEnvVar: "XAI_API_KEY",
-    apiKeyHeader: "Authorization",
     name: "xAI",
     models: [
       "grok-2",
@@ -139,33 +484,6 @@ var PROVIDER_REGISTRY = {
     docUrl: "https://console.groq.com/docs/models",
     gateway: "models.dev"
   },
-  "github-copilot": {
-    url: "https://api.githubcopilot.com/chat/completions",
-    apiKeyEnvVar: "GITHUB_TOKEN",
-    apiKeyHeader: "Authorization",
-    name: "GitHub Copilot",
-    models: [
-      "claude-3.5-sonnet",
-      "claude-3.7-sonnet",
-      "claude-3.7-sonnet-thought",
-      "claude-opus-4",
-      "claude-opus-41",
-      "claude-sonnet-4",
-      "claude-sonnet-4.5",
-      "gemini-2.0-flash-001",
-      "gemini-2.5-pro",
-      "gpt-4.1",
-      "gpt-4o",
-      "gpt-5",
-      "gpt-5-mini",
-      "grok-code-fast-1",
-      "o3",
-      "o3-mini",
-      "o4-mini"
-    ],
-    docUrl: "https://docs.github.com/en/copilot",
-    gateway: "models.dev"
-  },
   mistral: {
     url: "https://api.mistral.ai/v1/chat/completions",
     apiKeyEnvVar: "MISTRAL_API_KEY",
@@ -243,6 +561,7 @@ var PROVIDER_REGISTRY = {
       "openai/gpt-4o",
       "openai/gpt-4o-mini",
       "openai/gpt-5",
+      "openai/gpt-5-codex",
       "openai/gpt-5-mini",
       "openai/gpt-5-nano",
       "openai/gpt-oss-120b",
@@ -484,20 +803,22 @@ var PROVIDER_REGISTRY = {
     url: "https://opencode.ai/zen/v1/chat/completions",
     apiKeyEnvVar: "OPENCODE_API_KEY",
     apiKeyHeader: "Authorization",
-    name: "opencode zen",
+    name: "OpenCode Zen",
     models: [
       "claude-3-5-haiku",
       "claude-opus-4-1",
       "claude-sonnet-4",
       "claude-sonnet-4-5",
       "code-supernova",
+      "glm-4.6",
       "gpt-5",
+      "gpt-5-codex",
       "grok-code",
       "kimi-k2",
       "qwen3-coder",
       "qwen3-max"
     ],
-    docUrl: "https://opencode.ai/docs",
+    docUrl: "https://opencode.ai/docs/zen",
     gateway: "models.dev"
   },
   fastrouter: {
@@ -525,9 +846,7 @@ var PROVIDER_REGISTRY = {
     gateway: "models.dev"
   },
   google: {
-    url: "https://generativelanguage.googleapis.com/v1beta/chat/completions",
     apiKeyEnvVar: "GOOGLE_GENERATIVE_AI_API_KEY",
-    apiKeyHeader: "Authorization",
     name: "Google",
     models: [
       "gemini-1.5-flash",
@@ -582,11 +901,10 @@ var PROVIDER_REGISTRY = {
     gateway: "models.dev"
   },
   openai: {
-    url: "https://api.openai.com/v1/chat/completions",
     apiKeyEnvVar: "OPENAI_API_KEY",
-    apiKeyHeader: "Authorization",
     name: "OpenAI",
     models: [
+      "codex-mini-latest",
       "gpt-3.5-turbo",
       "gpt-4",
       "gpt-4-turbo",
@@ -600,6 +918,7 @@ var PROVIDER_REGISTRY = {
       "gpt-4o-mini",
       "gpt-5",
       "gpt-5-chat-latest",
+      "gpt-5-codex",
       "gpt-5-mini",
       "gpt-5-nano",
       "o1",
@@ -635,9 +954,8 @@ var PROVIDER_REGISTRY = {
     gateway: "models.dev"
   },
   openrouter: {
-    url: "https://openrouter.ai/api/v1/chat/completions",
+    url: "https://openrouter.ai/api/v1",
     apiKeyEnvVar: "OPENROUTER_API_KEY",
-    apiKeyHeader: "Authorization",
     name: "OpenRouter",
     models: [
       "anthropic/claude-3.5-haiku",
@@ -697,6 +1015,7 @@ var PROVIDER_REGISTRY = {
       "openai/gpt-4o-mini",
       "openai/gpt-5",
       "openai/gpt-5-chat",
+      "openai/gpt-5-codex",
       "openai/gpt-5-mini",
       "openai/gpt-5-nano",
       "openai/gpt-oss-120b",
@@ -771,7 +1090,8 @@ var PROVIDER_REGISTRY = {
       "hf:moonshotai/Kimi-K2-Instruct",
       "hf:moonshotai/Kimi-K2-Instruct-0905",
       "hf:openai/gpt-oss-120b",
-      "hf:zai-org/GLM-4.5"
+      "hf:zai-org/GLM-4.5",
+      "hf:zai-org/GLM-4.6"
     ],
     docUrl: "https://synthetic.new/pricing",
     gateway: "models.dev"
@@ -888,9 +1208,7 @@ var PROVIDER_REGISTRY = {
     gateway: "models.dev"
   },
   anthropic: {
-    url: "https://api.anthropic.com/v1/chat/completions",
     apiKeyEnvVar: "ANTHROPIC_API_KEY",
-    apiKeyHeader: "x-api-key",
     name: "Anthropic",
     models: [
       "claude-3-5-haiku-20241022",
@@ -977,38 +1295,39 @@ var PROVIDER_REGISTRY = {
     name: "Netlify",
     gateway: "netlify",
     models: [
-      "anthropic/claude-3-5-haiku-20241022",
       "anthropic/claude-opus-4-20250514",
+      "anthropic/claude-sonnet-4-5-20250929",
       "anthropic/claude-sonnet-4-20250514",
       "anthropic/claude-3-7-sonnet-20250219",
+      "anthropic/claude-3-7-sonnet-latest",
+      "anthropic/claude-3-5-haiku-20241022",
       "anthropic/claude-3-5-haiku-latest",
       "anthropic/claude-3-haiku-20240307",
       "anthropic/claude-opus-4-1-20250805",
-      "anthropic/claude-sonnet-4-5-20250929",
-      "anthropic/claude-3-7-sonnet-latest",
       "gemini/gemini-2.5-pro",
-      "gemini/gemini-2.5-flash",
-      "gemini/gemini-flash-lite-latest",
-      "gemini/gemini-2.0-flash-lite",
-      "gemini/gemini-2.5-flash-image-preview",
       "gemini/gemini-flash-latest",
-      "gemini/gemini-2.5-flash-preview-09-2025",
+      "gemini/gemini-2.5-flash",
       "gemini/gemini-2.5-flash-lite-preview-09-2025",
       "gemini/gemini-2.5-flash-lite",
+      "gemini/gemini-2.5-flash-preview-09-2025",
+      "gemini/gemini-flash-lite-latest",
       "gemini/gemini-2.0-flash",
+      "gemini/gemini-2.0-flash-lite",
+      "gemini/gemini-2.5-flash-image-preview",
+      "openai/gpt-4.1-mini",
+      "openai/gpt-4.1-nano",
+      "openai/gpt-4o",
+      "openai/gpt-5-pro",
+      "openai/gpt-4o-mini",
       "openai/o4-mini",
       "openai/o3",
       "openai/o3-mini",
       "openai/codex-mini-latest",
+      "openai/gpt-5",
       "openai/gpt-5-codex",
       "openai/gpt-5-mini",
       "openai/gpt-5-nano",
-      "openai/gpt-4.1",
-      "openai/gpt-4.1-mini",
-      "openai/gpt-4.1-nano",
-      "openai/gpt-4o",
-      "openai/gpt-4o-mini",
-      "openai/gpt-5"
+      "openai/gpt-4.1"
     ],
     docUrl: "https://docs.netlify.com/build/ai-gateway/overview/"
   }
@@ -1034,331 +1353,12 @@ function parseModelString(modelString) {
   };
 }
 
-// src/llm/model/gateways/base.ts
-var MastraModelGateway = class {
-};
-
-// src/llm/model/gateways/models-dev.ts
-var OPENAI_COMPATIBLE_OVERRIDES = {
-  openai: {
-    url: "https://api.openai.com/v1/chat/completions"
-  },
-  anthropic: {
-    url: "https://api.anthropic.com/v1/chat/completions",
-    apiKeyHeader: "x-api-key"
-  },
-  cerebras: {
-    url: "https://api.cerebras.ai/v1/chat/completions"
-  },
-  xai: {
-    url: "https://api.x.ai/v1/chat/completions"
-  },
-  mistral: {
-    url: "https://api.mistral.ai/v1/chat/completions"
-  },
-  google: {
-    url: "https://generativelanguage.googleapis.com/v1beta/chat/completions"
-  },
-  groq: {
-    url: "https://api.groq.com/openai/v1/chat/completions"
-  },
-  togetherai: {
-    url: "https://api.together.xyz/v1/chat/completions"
-  },
-  deepinfra: {
-    url: "https://api.deepinfra.com/v1/openai/chat/completions"
-  },
-  perplexity: {
-    url: "https://api.perplexity.ai/chat/completions"
-  },
-  vercel: {
-    url: "https://ai-gateway.vercel.sh/v1/chat/completions",
-    apiKeyEnvVar: "AI_GATEWAY_API_KEY"
-  }
-};
-var ModelsDevGateway = class extends MastraModelGateway {
-  name = "models.dev";
-  prefix = void 0;
-  // No prefix for registry gateway
-  providerConfigs = {};
-  constructor(providerConfigs) {
-    super();
-    if (providerConfigs) this.providerConfigs = providerConfigs;
-  }
-  async fetchProviders() {
-    console.info("Fetching providers from models.dev API...");
-    const response = await fetch("https://models.dev/api.json");
-    if (!response.ok) {
-      throw new Error(`Failed to fetch from models.dev: ${response.statusText}`);
-    }
-    const data = await response.json();
-    const providerConfigs = {};
-    for (const [providerId, providerInfo] of Object.entries(data)) {
-      if (!providerInfo || typeof providerInfo !== "object" || !providerInfo.models) continue;
-      const normalizedId = providerId;
-      const isOpenAICompatible = providerInfo.npm === "@ai-sdk/openai-compatible" || providerInfo.npm === "@ai-sdk/gateway" || // Vercel AI Gateway is OpenAI-compatible
-      normalizedId in OPENAI_COMPATIBLE_OVERRIDES;
-      const hasApiAndEnv = providerInfo.api && providerInfo.env && providerInfo.env.length > 0;
-      if (isOpenAICompatible || hasApiAndEnv) {
-        const modelIds = Object.keys(providerInfo.models).sort();
-        let url = providerInfo.api || OPENAI_COMPATIBLE_OVERRIDES[normalizedId]?.url;
-        if (url && !url.includes("/chat/completions") && !url.includes("/messages")) {
-          url = url.replace(/\/$/, "") + "/chat/completions";
-        }
-        if (!url) {
-          console.info(`Skipping ${normalizedId}: No API URL available`);
-          continue;
-        }
-        const apiKeyEnvVar = providerInfo.env?.[0] || `${normalizedId.toUpperCase().replace(/-/g, "_")}_API_KEY`;
-        const apiKeyHeader = OPENAI_COMPATIBLE_OVERRIDES[normalizedId]?.apiKeyHeader || "Authorization";
-        providerConfigs[normalizedId] = {
-          url,
-          apiKeyEnvVar,
-          apiKeyHeader,
-          name: providerInfo.name || providerId.charAt(0).toUpperCase() + providerId.slice(1),
-          models: modelIds.filter((id) => !id.includes(`codex`)),
-          // codex requires responses api
-          docUrl: providerInfo.doc,
-          // Include documentation URL if available
-          gateway: `models.dev`
-        };
-      } else {
-        console.info(`Skipped provider ${providerInfo.name}`);
-      }
-    }
-    this.providerConfigs = providerConfigs;
-    console.info(`Found ${Object.keys(providerConfigs).length} OpenAI-compatible providers`);
-    console.info("Providers:", Object.keys(providerConfigs).sort());
-    return providerConfigs;
-  }
-  buildUrl(modelId, envVars) {
-    const [provider, ...modelParts] = modelId.split("/");
-    if (!provider || !modelParts.length) {
-      return false;
-    }
-    const config = this.providerConfigs[provider];
-    if (!config?.url) {
-      return false;
-    }
-    const baseUrlEnvVar = `${provider.toUpperCase().replace(/-/g, "_")}_BASE_URL`;
-    const customBaseUrl = envVars[baseUrlEnvVar];
-    return customBaseUrl || config.url;
-  }
-  buildHeaders(modelId, envVars) {
-    const [provider] = modelId.split("/");
-    if (!provider) {
-      return {};
-    }
-    const config = this.providerConfigs[provider];
-    if (!config) {
-      return {};
-    }
-    const apiKey = typeof config.apiKeyEnvVar === `string` ? envVars[config.apiKeyEnvVar] : void 0;
-    if (!apiKey) {
-      return {};
-    }
-    const headers = {};
-    if (config.apiKeyHeader === "Authorization" || !config.apiKeyHeader) {
-      headers["Authorization"] = `Bearer ${apiKey}`;
-    } else {
-      headers[config.apiKeyHeader] = apiKey;
-    }
-    if (provider === "anthropic") {
-      headers["anthropic-version"] = "2023-06-01";
-    }
-    return headers;
-  }
-};
-
-// src/llm/model/gateways/netlify.ts
-var NetlifyGateway = class extends MastraModelGateway {
-  name = "netlify";
-  prefix = "netlify";
-  // All providers will be prefixed with "netlify/"
-  tokenCache = new chunkUU5L5GDY_cjs.InMemoryServerCache();
-  async fetchProviders() {
-    console.info("Fetching providers from Netlify AI Gateway...");
-    const response = await fetch("https://api.netlify.com/api/v1/ai-gateway/providers");
-    if (!response.ok) {
-      throw new Error(`Failed to fetch from Netlify: ${response.statusText}`);
-    }
-    const data = await response.json();
-    const netlify = {
-      apiKeyEnvVar: ["NETLIFY_TOKEN", "NETLIFY_SITE_ID"],
-      apiKeyHeader: "Authorization",
-      // Netlify uses standard Bearer auth
-      name: `Netlify`,
-      gateway: `netlify`,
-      models: [],
-      docUrl: "https://docs.netlify.com/build/ai-gateway/overview/"
-    };
-    for (const [providerId, provider] of Object.entries(data.providers)) {
-      for (const model of provider.models) {
-        netlify.models.push(`${providerId}/${model}`);
-      }
-    }
-    console.info(`Found ${Object.keys(data.providers).length} models via Netlify Gateway`);
-    return { netlify };
-  }
-  async buildUrl(modelId, envVars) {
-    if (!modelId.startsWith(`${this.prefix}/`)) {
-      return false;
-    }
-    const parts = modelId.split("/");
-    if (parts.length < 3) {
-      return false;
-    }
-    const provider = parts[1];
-    if (!provider) {
-      return false;
-    }
-    const siteId = envVars["NETLIFY_SITE_ID"];
-    const netlifyToken = envVars["NETLIFY_TOKEN"];
-    if (!netlifyToken) {
-      throw new chunkWM4VQWOZ_cjs.MastraError({
-        id: "NETLIFY_GATEWAY_NO_TOKEN",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_TOKEN environment variable required for model: ${modelId}`
-      });
-    }
-    if (!siteId) {
-      throw new chunkWM4VQWOZ_cjs.MastraError({
-        id: "NETLIFY_GATEWAY_NO_SITE_ID",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_SITE_ID environment variable required for model: ${modelId}`
-      });
-    }
-    try {
-      const tokenData = await this.getOrFetchToken(siteId, netlifyToken);
-      return `${tokenData.url}chat/completions`;
-    } catch (error) {
-      throw new chunkWM4VQWOZ_cjs.MastraError({
-        id: "NETLIFY_GATEWAY_TOKEN_ERROR",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Failed to get Netlify AI Gateway token for model ${modelId}: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  /**
-   * Get cached token or fetch a new site-specific AI Gateway token from Netlify
-   */
-  async getOrFetchToken(siteId, netlifyToken) {
-    const cacheKey = `netlify-token:${siteId}:${netlifyToken}`;
-    const cached = await this.tokenCache.get(cacheKey);
-    if (cached && cached.expiresAt > Date.now() / 1e3 + 60) {
-      return { token: cached.token, url: cached.url };
-    }
-    const response = await fetch(`https://api.netlify.com/api/v1/sites/${siteId}/ai-gateway/token`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${netlifyToken}`
-      }
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to get Netlify AI Gateway token: ${response.status} ${error}`);
-    }
-    const tokenResponse = await response.json();
-    await this.tokenCache.set(cacheKey, {
-      token: tokenResponse.token,
-      url: tokenResponse.url,
-      expiresAt: tokenResponse.expires_at
-    });
-    return { token: tokenResponse.token, url: tokenResponse.url };
-  }
-  async buildHeaders(modelId, envVars) {
-    const siteId = envVars["NETLIFY_SITE_ID"];
-    const netlifyToken = envVars["NETLIFY_TOKEN"];
-    if (!netlifyToken) {
-      throw new chunkWM4VQWOZ_cjs.MastraError({
-        id: "NETLIFY_GATEWAY_NO_TOKEN",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_TOKEN environment variable required for model: ${modelId}`
-      });
-    }
-    if (!siteId) {
-      throw new chunkWM4VQWOZ_cjs.MastraError({
-        id: "NETLIFY_GATEWAY_NO_SITE_ID",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_SITE_ID environment variable required for model: ${modelId}`
-      });
-    }
-    try {
-      const tokenData = await this.getOrFetchToken(siteId, netlifyToken);
-      return {
-        Authorization: `Bearer ${tokenData.token}`
-      };
-    } catch (error) {
-      throw new chunkWM4VQWOZ_cjs.MastraError({
-        id: "NETLIFY_GATEWAY_TOKEN_ERROR",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Failed to get Netlify AI Gateway token for model ${modelId}: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-};
-
-// src/llm/model/gateway-resolver.ts
+// src/llm/model/router.ts
 function getStaticProvidersByGateway(name) {
   return Object.fromEntries(Object.entries(PROVIDER_REGISTRY).filter(([_provider, config]) => config.gateway === name));
 }
 var gateways = [new NetlifyGateway(), new ModelsDevGateway(getStaticProvidersByGateway(`models.dev`))];
-function findGatewayForModel(modelId) {
-  const prefixedGateway = gateways.find((g) => g.prefix && modelId.startsWith(`${g.prefix}/`));
-  if (prefixedGateway) {
-    return prefixedGateway;
-  }
-  const unprefixedGateways = gateways.filter((g) => !g.prefix);
-  for (const gateway of unprefixedGateways) {
-    return gateway;
-  }
-  return null;
-}
-async function resolveModelConfig(modelId, envVars = process.env) {
-  const gateway = findGatewayForModel(modelId);
-  if (!gateway) {
-    return { url: false, headers: {}, resolvedModelId: modelId };
-  }
-  const url = await gateway.buildUrl(modelId, envVars);
-  if (url === false) {
-    return { url: false, headers: {}, resolvedModelId: modelId };
-  }
-  const headers = gateway.buildHeaders ? await gateway.buildHeaders(modelId, envVars) : {};
-  let resolvedModelId = modelId;
-  const prefix = gateway.prefix ? `${gateway.prefix}/` : null;
-  if (prefix && resolvedModelId.startsWith(prefix)) {
-    resolvedModelId = resolvedModelId.substring(prefix.length);
-  }
-  const firstSlashIndex = resolvedModelId.indexOf("/");
-  if (firstSlashIndex !== -1) {
-    resolvedModelId = resolvedModelId.substring(firstSlashIndex + 1);
-  }
-  return { url, headers, resolvedModelId };
-}
-
-// src/llm/model/openai-compatible.ts
-function resolveApiKey({ provider, apiKey }) {
-  if (apiKey) return apiKey;
-  if (provider) {
-    const config = getProviderConfig(provider);
-    if (typeof config?.apiKeyEnvVar === `string`) {
-      return process.env[config.apiKeyEnvVar];
-    }
-    if (Array.isArray(config?.apiKeyEnvVar)) {
-      for (const key of config.apiKeyEnvVar) {
-        if (process.env[key]) return process.env[key];
-      }
-    }
-  }
-  return void 0;
-}
-var OpenAICompatibleModel = class {
+var ModelRouterLanguageModel = class _ModelRouterLanguageModel {
   specificationVersion = "v2";
   defaultObjectGenerationMode = "json";
   supportsStructuredOutputs = true;
@@ -1367,215 +1367,29 @@ var OpenAICompatibleModel = class {
   modelId;
   provider;
   config;
-  fullModelId;
-  // Store the full model ID for gateway resolution
+  gateway;
   constructor(config) {
-    let parsedConfig;
-    if (typeof config === "string") {
-      let isUrl = false;
-      try {
-        new URL(config);
-        isUrl = true;
-      } catch {
-      }
-      if (isUrl) {
-        parsedConfig = {
-          id: "unknown",
-          url: config
-        };
-        this.provider = "openai-compatible";
-        this.fullModelId = "unknown";
-        this.config = { id: "unknown", url: config };
-      } else {
-        this.fullModelId = config;
-        const firstSlashIndex = config.indexOf("/");
-        if (firstSlashIndex !== -1) {
-          const provider = config.substring(0, firstSlashIndex);
-          const modelId = config.substring(firstSlashIndex + 1);
-          parsedConfig = {
-            id: modelId,
-            apiKey: resolveApiKey({ provider })
-          };
-          this.provider = provider;
-        } else {
-          throw new Error(`Invalid model string: "${config}". Use "provider/model" format or a direct URL.`);
-        }
-      }
-    } else {
-      parsedConfig = config;
-      this.fullModelId = config.id;
-      const parsed = parseModelString(config.id);
-      this.provider = parsed.provider || "openai-compatible";
-      if (parsed.provider && parsed.modelId !== config.id) {
-        parsedConfig.id = parsed.modelId;
-      }
-      if (!parsedConfig.apiKey) {
-        parsedConfig.apiKey = resolveApiKey({ provider: parsed.provider || void 0 });
-      }
+    if (typeof config === `string`) config = { id: config };
+    const parsedConfig = { ...config, routerId: config.id };
+    this.gateway = findGatewayForModel(config.id, gateways);
+    const parsed = parseModelRouterId(config.id, this.gateway.prefix);
+    this.provider = parsed.providerId || "openai-compatible";
+    if (parsed.providerId && parsed.modelId !== config.id) {
+      parsedConfig.id = parsed.modelId;
     }
     this.modelId = parsedConfig.id;
     this.config = parsedConfig;
-  }
-  convertMessagesToOpenAI(messages) {
-    return messages.map((msg) => {
-      if (msg.role === "system") {
-        return {
-          role: "system",
-          content: msg.content
-        };
-      }
-      if (msg.role === "user") {
-        const contentParts = msg.content.map((part) => {
-          if (part.type === "text") {
-            return { type: "text", text: part.text };
-          }
-          if (part.type === "file") {
-            return {
-              type: "image_url",
-              image_url: { url: part.data }
-            };
-          }
-          return null;
-        }).filter(Boolean);
-        if (contentParts.every((p) => p?.type === "text")) {
-          return {
-            role: "user",
-            content: contentParts.map((p) => p?.text || "").join("")
-          };
-        }
-        return {
-          role: "user",
-          content: contentParts
-        };
-      }
-      if (msg.role === "assistant") {
-        const textContent = msg.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-        const toolCalls = msg.content.filter((part) => part.type === "tool-call").map((part) => ({
-          id: part.toolCallId,
-          type: "function",
-          function: {
-            name: part.toolName,
-            arguments: JSON.stringify(part.input || {})
-          }
-        }));
-        return {
-          role: "assistant",
-          content: textContent || null,
-          ...toolCalls.length > 0 && { tool_calls: toolCalls }
-        };
-      }
-      if (msg.role === "tool") {
-        return msg.content.map((toolResponse) => ({
-          role: "tool",
-          tool_call_id: toolResponse.toolCallId,
-          content: JSON.stringify(toolResponse.output)
-        }));
-      }
-      return msg;
-    }).flat();
-  }
-  convertToolsToOpenAI(tools) {
-    if (!tools || Object.keys(tools).length === 0) return void 0;
-    return Object.entries(tools).map(([name, tool]) => {
-      if (tool.type === "function") {
-        return {
-          type: "function",
-          function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.inputSchema || {}
-          }
-        };
-      }
-      return {
-        type: "function",
-        function: {
-          name,
-          description: `Provider tool: ${name}`,
-          parameters: {}
-        }
-      };
-    });
-  }
-  mapFinishReason(reason) {
-    switch (reason) {
-      case "stop":
-        return "stop";
-      case "length":
-      case "max_tokens":
-        return "length";
-      case "tool_calls":
-      case "function_call":
-        return "tool-calls";
-      case "content_filter":
-        return "content-filter";
-      default:
-        return "unknown";
-    }
-  }
-  /**
-   * Resolve URL and headers for the request
-   * This is called fresh for each request to ensure we get the latest values
-   * (e.g., Netlify tokens can expire and need to be refreshed)
-   */
-  async resolveRequestConfig() {
-    const shouldUseGateway = !this.config.url;
-    if (shouldUseGateway) {
-      const { url, headers, resolvedModelId } = await resolveModelConfig(this.fullModelId);
-      if (url === false) {
-        throw new Error(`No gateway can handle model: ${this.fullModelId}`);
-      }
-      const finalHeaders = {
-        "Content-Type": "application/json",
-        ...headers,
-        ...this.config.headers
-      };
-      return { url, headers: finalHeaders, modelId: resolvedModelId };
-    } else {
-      if (!this.config.url) {
-        throw new Error("URL is required for OpenAI-compatible model");
-      }
-      const headers = {
-        "Content-Type": "application/json",
-        ...this.config.headers
-      };
-      if (this.config.apiKey) {
-        const providerConfig = this.provider !== "openai-compatible" ? getProviderConfig(this.provider) : void 0;
-        if (providerConfig?.apiKeyHeader === "x-api-key") {
-          headers["x-api-key"] = this.config.apiKey;
-        } else {
-          headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-        }
-      }
-      return { url: this.config.url, headers, modelId: this.modelId };
-    }
-  }
-  validateApiKey() {
-    const willUseGateway = !this.config.url;
-    if (willUseGateway) {
-      return;
-    }
-    if (!this.config.apiKey && this.provider !== "openai-compatible") {
-      const providerConfig = getProviderConfig(this.provider);
-      if (providerConfig?.apiKeyEnvVar) {
-        throw new Error(
-          `API key not found for provider "${this.provider}". Please set the ${providerConfig.apiKeyEnvVar} environment variable.`
-        );
-      } else {
-        throw new Error(
-          `API key not found for provider "${this.provider}". Please provide an API key in the configuration.`
-        );
-      }
-    }
+    this.gateway = findGatewayForModel(parsedConfig.routerId, gateways);
   }
   async doGenerate() {
     throw new Error(
-      "doGenerate is not supported by OpenAICompatibleModel. Mastra only uses streaming (doStream) for all LLM calls."
+      "doGenerate is not supported by Mastra model router. Mastra only uses streaming (doStream) for all LLM calls."
     );
   }
   async doStream(options) {
+    let apiKey;
     try {
-      this.validateApiKey();
+      apiKey = await this.gateway.getApiKey(this.config.routerId);
     } catch (error) {
       return {
         stream: new ReadableStream({
@@ -1585,242 +1399,32 @@ var OpenAICompatibleModel = class {
               error: error instanceof Error ? error.message : String(error)
             });
           }
-        }),
-        warnings: []
-      };
-    }
-    try {
-      const { url, headers, modelId: resolvedModelId } = await this.resolveRequestConfig();
-      const { prompt, tools, toolChoice, providerOptions } = options;
-      const body = {
-        messages: this.convertMessagesToOpenAI(prompt),
-        model: resolvedModelId,
-        stream: true,
-        ...providerOptions
-      };
-      const openAITools = this.convertToolsToOpenAI(tools);
-      if (openAITools) {
-        body.tools = openAITools;
-        if (toolChoice) {
-          body.tool_choice = toolChoice.type === "none" ? "none" : toolChoice.type === "required" ? "required" : toolChoice.type === "auto" ? "auto" : toolChoice.type === "tool" ? { type: "function", function: { name: toolChoice.toolName } } : "auto";
-        }
-      }
-      if (options.responseFormat?.type === "json") {
-        body.response_format = {
-          type: "json_schema",
-          json_schema: {
-            name: "response",
-            strict: true,
-            schema: options.responseFormat.schema
-          }
-        };
-      }
-      const fetchArgs = {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body),
-        signal: options.abortSignal
-      };
-      const response = await fetch(url, fetchArgs);
-      if (!response.ok) {
-        const error = await response.text();
-        if (response.status === 401 || response.status === 403) {
-          const providerConfig = getProviderConfig(this.provider);
-          if (providerConfig?.apiKeyEnvVar) {
-            throw new Error(
-              `Authentication failed for provider "${this.provider}". Please ensure the ${providerConfig.apiKeyEnvVar} environment variable is set with a valid API key.`
-            );
-          }
-        }
-        throw new Error(`OpenAI-compatible API error: ${response.status} - ${error}`);
-      }
-      const reader = response.body?.getReader();
-      if (!reader) {
-        throw new Error("Response body is not readable");
-      }
-      const decoder = new TextDecoder();
-      let buffer = "";
-      let sentStart = false;
-      const toolCallBuffers = /* @__PURE__ */ new Map();
-      const mapFinishReason = this.mapFinishReason.bind(this);
-      const modelId = this.modelId;
-      let isActiveText = false;
-      const stream = new ReadableStream({
-        async start(controller) {
-          try {
-            controller.enqueue({
-              type: "stream-start",
-              warnings: []
-            });
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                for (const [_, toolCall] of toolCallBuffers) {
-                  if (!toolCall.sent && toolCall.id && toolCall.name && toolCall.args) {
-                    controller.enqueue({
-                      type: "tool-call",
-                      toolCallId: toolCall.id,
-                      toolName: toolCall.name,
-                      input: toolCall.args || "{}"
-                    });
-                  }
-                }
-                controller.close();
-                break;
-              }
-              buffer += decoder.decode(value, { stream: true });
-              const lines = buffer.split("\n");
-              buffer = lines.pop() || "";
-              for (const line of lines) {
-                if (line.trim() === "" || line.trim() === "data: [DONE]") {
-                  continue;
-                }
-                if (line.startsWith("data: ")) {
-                  try {
-                    const data = JSON.parse(line.slice(6));
-                    if (!sentStart && data.id) {
-                      controller.enqueue({
-                        type: "response-metadata",
-                        id: data.id,
-                        modelId: data.model || modelId,
-                        timestamp: new Date(data.created ? data.created * 1e3 : Date.now())
-                      });
-                      sentStart = true;
-                    }
-                    const choice = data.choices?.[0];
-                    if (!choice) continue;
-                    if (choice.delta?.content) {
-                      if (!isActiveText) {
-                        controller.enqueue({ type: "text-start", id: "text-1" });
-                        isActiveText = true;
-                      }
-                      controller.enqueue({
-                        type: "text-delta",
-                        id: "text-1",
-                        delta: choice.delta.content
-                      });
-                    } else if (isActiveText) {
-                      controller.enqueue({ type: "text-end", id: "text-1" });
-                      isActiveText = false;
-                    }
-                    if (choice.delta?.tool_calls) {
-                      for (const toolCall of choice.delta.tool_calls) {
-                        const index = toolCall.index;
-                        if (!toolCallBuffers.has(index)) {
-                          if (toolCall.id && toolCall.function?.name) {
-                            controller.enqueue({
-                              type: "tool-input-start",
-                              id: toolCall.id,
-                              toolName: toolCall.function.name
-                            });
-                          }
-                          toolCallBuffers.set(index, {
-                            id: toolCall.id || "",
-                            name: toolCall.function?.name || "",
-                            args: ""
-                          });
-                        }
-                        const buffer2 = toolCallBuffers.get(index);
-                        if (toolCall.id) {
-                          buffer2.id = toolCall.id;
-                        }
-                        if (toolCall.function?.name) {
-                          buffer2.name = toolCall.function.name;
-                        }
-                        if (toolCall.function?.arguments) {
-                          buffer2.args += toolCall.function.arguments;
-                          controller.enqueue({
-                            type: "tool-input-delta",
-                            id: buffer2.id,
-                            delta: toolCall.function.arguments
-                          });
-                          try {
-                            JSON.parse(buffer2.args);
-                            if (buffer2.id && buffer2.name) {
-                              controller.enqueue({
-                                type: "tool-input-end",
-                                id: buffer2.id
-                              });
-                              controller.enqueue({
-                                type: "tool-call",
-                                toolCallId: buffer2.id,
-                                toolName: buffer2.name,
-                                input: buffer2.args
-                              });
-                              toolCallBuffers.set(index, {
-                                id: buffer2.id,
-                                name: buffer2.name,
-                                args: buffer2.args,
-                                sent: true
-                              });
-                            }
-                          } catch {
-                          }
-                        }
-                      }
-                    }
-                    if (choice.finish_reason) {
-                      toolCallBuffers.clear();
-                      controller.enqueue({
-                        type: "finish",
-                        finishReason: mapFinishReason(choice.finish_reason),
-                        usage: data.usage ? {
-                          inputTokens: data.usage.prompt_tokens || 0,
-                          outputTokens: data.usage.completion_tokens || 0,
-                          totalTokens: data.usage.total_tokens || 0
-                        } : {
-                          inputTokens: 0,
-                          outputTokens: 0,
-                          totalTokens: 0
-                        }
-                      });
-                    }
-                  } catch (e) {
-                    console.error("Error parsing SSE data:", e);
-                  }
-                }
-              }
-            }
-          } catch (error) {
-            return {
-              stream: new ReadableStream({
-                start(controller2) {
-                  controller2.enqueue({
-                    type: "error",
-                    error: error instanceof Error ? error.message : String(error)
-                  });
-                }
-              }),
-              warnings: []
-            };
-          }
-        }
-      });
-      return {
-        stream,
-        request: { body: JSON.stringify(body) },
-        response: { headers: Object.fromEntries(response.headers.entries()) },
-        warnings: []
-      };
-    } catch (error) {
-      return {
-        stream: new ReadableStream({
-          start(controller) {
-            controller.enqueue({
-              type: "error",
-              error: error instanceof Error ? error.message : String(error)
-            });
-          }
-        }),
-        warnings: []
+        })
       };
     }
+    const model = await this.resolveLanguageModel({
+      apiKey,
+      ...parseModelRouterId(this.config.routerId, this.gateway.prefix)
+    });
+    return model.doStream(options);
+  }
+  async resolveLanguageModel({
+    modelId,
+    providerId,
+    apiKey
+  }) {
+    const key = crypto.createHash("sha256").update(this.gateway.name + modelId + providerId + apiKey).digest("hex");
+    if (_ModelRouterLanguageModel.modelInstances.has(key)) return _ModelRouterLanguageModel.modelInstances.get(key);
+    const modelInstance = await this.gateway.resolveLanguageModel({ modelId, providerId, apiKey });
+    _ModelRouterLanguageModel.modelInstances.set(key, modelInstance);
+    return modelInstance;
   }
+  static modelInstances = /* @__PURE__ */ new Map();
 };
 
-exports.OpenAICompatibleModel = OpenAICompatibleModel;
+exports.ModelRouterLanguageModel = ModelRouterLanguageModel;
 exports.PROVIDER_REGISTRY = PROVIDER_REGISTRY;
 exports.getProviderConfig = getProviderConfig;
 exports.parseModelString = parseModelString;
-//# sourceMappingURL=chunk-2SH5WPUA.cjs.map
-//# sourceMappingURL=chunk-2SH5WPUA.cjs.map
+//# sourceMappingURL=chunk-BG5FC6ZZ.cjs.map
+//# sourceMappingURL=chunk-BG5FC6ZZ.cjs.map