@mastra/core 0.24.1 → 0.24.2

package/dist/{chunk-II37LKES.js → chunk-EFNEFT4U.js}

@@ -6,7 +6,7 @@ import fs from 'fs';
 import { createRequire } from 'module';
 import os from 'os';
 import path from 'path';
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible-v5';
 import { createGoogleGenerativeAI } from '@ai-sdk/google-v5';
 import { createOpenAI } from '@ai-sdk/openai-v5';
@@ -2465,6 +2465,137 @@ var autoRefreshEnabled = process.env.MASTRA_AUTO_REFRESH_PROVIDERS === "true" ||
 if (autoRefreshEnabled) {
   GatewayRegistry.getInstance({ useDynamicLoading: isDev }).startAutoRefresh();
 }
+var AISDKV5LanguageModel = class {
+  /**
+   * The language model must specify which language model interface version it implements.
+   */
+  specificationVersion = "v2";
+  /**
+   * Name of the provider for logging purposes.
+   */
+  provider;
+  /**
+   * Provider-specific model ID for logging purposes.
+   */
+  modelId;
+  /**
+   * Supported URL patterns by media type for the provider.
+   *
+   * The keys are media type patterns or full media types (e.g. `*\/*` for everything, `audio/*`, `video/*`, or `application/pdf`).
+   * and the values are arrays of regular expressions that match the URL paths.
+   * The matching should be against lower-case URLs.
+   * Matched URLs are supported natively by the model and are not downloaded.
+   * @returns A map of supported URL patterns by media type (as a promise or a plain object).
+   */
+  supportedUrls;
+  #model;
+  constructor(config) {
+    this.#model = config;
+    this.provider = this.#model.provider;
+    this.modelId = this.#model.modelId;
+    this.supportedUrls = this.#model.supportedUrls;
+  }
+  async doGenerate(options) {
+    const result = await this.#model.doGenerate(options);
+    return {
+      request: result.request,
+      response: result.response,
+      stream: new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings: result.warnings });
+          controller.enqueue({
+            type: "response-metadata",
+            id: result.response?.id,
+            modelId: result.response?.modelId,
+            timestamp: result.response?.timestamp
+          });
+          for (const message of result.content) {
+            if (message.type === "tool-call") {
+              const toolCall = message;
+              controller.enqueue({
+                type: "tool-input-start",
+                id: toolCall.toolCallId,
+                toolName: toolCall.toolName
+              });
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCall.toolCallId,
+                delta: toolCall.input
+              });
+              controller.enqueue({
+                type: "tool-input-end",
+                id: toolCall.toolCallId
+              });
+              controller.enqueue(toolCall);
+            } else if (message.type === "text") {
+              const text = message;
+              const id = `msg_${randomUUID()}`;
+              controller.enqueue({
+                type: "text-start",
+                id,
+                providerMetadata: text.providerMetadata
+              });
+              controller.enqueue({
+                type: "text-delta",
+                id,
+                delta: text.text
+              });
+              controller.enqueue({
+                type: "text-end",
+                id
+              });
+            } else if (message.type === "reasoning") {
+              const id = `reasoning_${randomUUID()}`;
+              const reasoning = message;
+              controller.enqueue({
+                type: "reasoning-start",
+                id,
+                providerMetadata: reasoning.providerMetadata
+              });
+              controller.enqueue({
+                type: "reasoning-delta",
+                id,
+                delta: reasoning.text,
+                providerMetadata: reasoning.providerMetadata
+              });
+              controller.enqueue({
+                type: "reasoning-end",
+                id,
+                providerMetadata: reasoning.providerMetadata
+              });
+            } else if (message.type === "file") {
+              const file = message;
+              controller.enqueue({
+                type: "file",
+                mediaType: file.mediaType,
+                data: file.data
+              });
+            } else if (message.type === "source") {
+              const source = message;
+              controller.enqueue({
+                type: "source",
+                id: source.id,
+                sourceType: source.sourceType,
+                title: source.title,
+                providerMetadata: source.providerMetadata
+              });
+            }
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason: result.finishReason,
+            usage: result.usage,
+            providerMetadata: result.providerMetadata
+          });
+          controller.close();
+        }
+      })
+    };
+  }
+  async doStream(options) {
+    return await this.#model.doStream(options);
+  }
+};
 
 // src/llm/model/gateways/index.ts
 function findGatewayForModel(gatewayId, gateways2) {
@@ -2531,10 +2662,33 @@ var ModelRouterLanguageModel = class _ModelRouterLanguageModel {
     this.modelId = parsedConfig.id;
     this.config = parsedConfig;
   }
-  async doGenerate() {
-    throw new Error(
-      "doGenerate is not supported by Mastra model router. Mastra only uses streaming (doStream) for all LLM calls."
-    );
+  async doGenerate(options) {
+    let apiKey;
+    try {
+      if (this.config.url) {
+        apiKey = this.config.apiKey || "";
+      } else {
+        apiKey = this.config.apiKey || await this.gateway.getApiKey(this.config.routerId);
+      }
+    } catch (error) {
+      return {
+        stream: new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              type: "error",
+              error
+            });
+            controller.close();
+          }
+        })
+      };
+    }
+    const model = await this.resolveLanguageModel({
+      apiKey,
+      ...parseModelRouterId(this.config.routerId, this.gateway.prefix)
+    });
+    const aiSDKV5Model = new AISDKV5LanguageModel(model);
+    return aiSDKV5Model.doGenerate(options);
   }
   async doStream(options) {
     let apiKey;
@@ -2552,6 +2706,7 @@ var ModelRouterLanguageModel = class _ModelRouterLanguageModel {
               type: "error",
               error
             });
+            controller.close();
           }
         })
       };
@@ -2560,7 +2715,8 @@ var ModelRouterLanguageModel = class _ModelRouterLanguageModel {
       apiKey,
       ...parseModelRouterId(this.config.routerId, this.gateway.prefix)
     });
-    return model.doStream(options);
+    const aiSDKV5Model = new AISDKV5LanguageModel(model);
+    return aiSDKV5Model.doStream(options);
   }
   async resolveLanguageModel({
     modelId,
@@ -2597,19 +2753,21 @@ function isOpenAICompatibleObjectConfig(modelConfig) {
   return false;
 }
 async function resolveModelConfig(modelConfig, runtimeContext = new RuntimeContext(), mastra) {
+  if (typeof modelConfig === "function") {
+    modelConfig = await modelConfig({ runtimeContext, mastra });
+  }
+  if (modelConfig instanceof ModelRouterLanguageModel || modelConfig instanceof AISDKV5LanguageModel) {
+    return modelConfig;
+  }
   if (typeof modelConfig === "object" && "specificationVersion" in modelConfig) {
+    if (modelConfig.specificationVersion === "v2") {
+      return new AISDKV5LanguageModel(modelConfig);
+    }
     return modelConfig;
   }
   if (typeof modelConfig === "string" || isOpenAICompatibleObjectConfig(modelConfig)) {
     return new ModelRouterLanguageModel(modelConfig);
   }
-  if (typeof modelConfig === "function") {
-    const fromDynamic = await modelConfig({ runtimeContext, mastra });
-    if (typeof fromDynamic === "string" || isOpenAICompatibleObjectConfig(fromDynamic)) {
-      return new ModelRouterLanguageModel(fromDynamic);
-    }
-    return fromDynamic;
-  }
   throw new Error("Invalid model configuration provided");
 }
 var ModelRouterEmbeddingModel = class {
@@ -2714,5 +2872,5 @@ var ModelRouterEmbeddingModel = class {
 };
 
 export { ModelRouterEmbeddingModel, ModelRouterLanguageModel, PROVIDER_REGISTRY, getProviderConfig, parseModelString, resolveModelConfig };
-//# sourceMappingURL=chunk-II37LKES.js.map
-//# sourceMappingURL=chunk-II37LKES.js.map
+//# sourceMappingURL=chunk-EFNEFT4U.js.map
+//# sourceMappingURL=chunk-EFNEFT4U.js.map