ai 4.1.55 → 4.1.57

package/dist/index.mjs

@@ -5994,6 +5994,62 @@ var DefaultStreamTextResult = class {
   }
 };
 
+// core/util/merge-objects.ts
+function mergeObjects(target, source) {
+  if (target === void 0 && source === void 0) {
+    return void 0;
+  }
+  if (target === void 0) {
+    return source;
+  }
+  if (source === void 0) {
+    return target;
+  }
+  const result = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      if (sourceValue === void 0)
+        continue;
+      const targetValue = key in target ? target[key] : void 0;
+      const isSourceObject = sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && !(sourceValue instanceof Date) && !(sourceValue instanceof RegExp);
+      const isTargetObject = targetValue !== null && targetValue !== void 0 && typeof targetValue === "object" && !Array.isArray(targetValue) && !(targetValue instanceof Date) && !(targetValue instanceof RegExp);
+      if (isSourceObject && isTargetObject) {
+        result[key] = mergeObjects(
+          targetValue,
+          sourceValue
+        );
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+
+// core/middleware/default-settings-middleware.ts
+function defaultSettingsMiddleware({
+  settings
+}) {
+  return {
+    middlewareVersion: "v1",
+    transformParams: async ({ params }) => {
+      var _a17;
+      return {
+        ...settings,
+        ...params,
+        providerMetadata: mergeObjects(
+          settings.providerMetadata,
+          params.providerMetadata
+        ),
+        // special case for temperature 0
+        // TODO remove when temperature defaults to undefined
+        temperature: params.temperature === 0 || params.temperature == null ? (_a17 = settings.temperature) != null ? _a17 : 0 : params.temperature
+      };
+    }
+  };
+}
+
 // core/util/get-potential-start-index.ts
 function getPotentialStartIndex(text2, searchedText) {
   if (searchedText.length === 0) {
@@ -6104,6 +6160,89 @@ function extractReasoningMiddleware({
   };
 }
 
+// core/middleware/simulate-streaming-middleware.ts
+function simulateStreamingMiddleware() {
+  return {
+    middlewareVersion: "v1",
+    wrapStream: async ({ doGenerate }) => {
+      const result = await doGenerate();
+      const simulatedStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "response-metadata", ...result.response });
+          if (result.reasoning) {
+            if (typeof result.reasoning === "string") {
+              controller.enqueue({
+                type: "reasoning",
+                textDelta: result.reasoning
+              });
+            } else {
+              for (const reasoning of result.reasoning) {
+                switch (reasoning.type) {
+                  case "text": {
+                    controller.enqueue({
+                      type: "reasoning",
+                      textDelta: reasoning.text
+                    });
+                    if (reasoning.signature != null) {
+                      controller.enqueue({
+                        type: "reasoning-signature",
+                        signature: reasoning.signature
+                      });
+                    }
+                    break;
+                  }
+                  case "redacted": {
+                    controller.enqueue({
+                      type: "redacted-reasoning",
+                      data: reasoning.data
+                    });
+                    break;
+                  }
+                }
+              }
+            }
+          }
+          if (result.text) {
+            controller.enqueue({
+              type: "text-delta",
+              textDelta: result.text
+            });
+          }
+          if (result.toolCalls) {
+            for (const toolCall of result.toolCalls) {
+              controller.enqueue({
+                type: "tool-call-delta",
+                toolCallType: "function",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                argsTextDelta: toolCall.args
+              });
+              controller.enqueue({
+                type: "tool-call",
+                ...toolCall
+              });
+            }
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason: result.finishReason,
+            usage: result.usage,
+            logprobs: result.logprobs,
+            providerMetadata: result.providerMetadata
+          });
+          controller.close();
+        }
+      });
+      return {
+        stream: simulatedStream,
+        rawCall: result.rawCall,
+        rawResponse: result.rawResponse,
+        warnings: result.warnings
+      };
+    }
+  };
+}
+
 // core/middleware/wrap-language-model.ts
 var wrapLanguageModel = ({
   model,
@@ -6139,12 +6278,19 @@ var doWrap = ({
     async doGenerate(params) {
       const transformedParams = await doTransform({ params, type: "generate" });
       const doGenerate = async () => model.doGenerate(transformedParams);
-      return wrapGenerate ? wrapGenerate({ doGenerate, params: transformedParams, model }) : doGenerate();
+      const doStream = async () => model.doStream(transformedParams);
+      return wrapGenerate ? wrapGenerate({
+        doGenerate,
+        doStream,
+        params: transformedParams,
+        model
+      }) : doGenerate();
     },
     async doStream(params) {
       const transformedParams = await doTransform({ params, type: "stream" });
+      const doGenerate = async () => model.doGenerate(transformedParams);
       const doStream = async () => model.doStream(transformedParams);
-      return wrapStream ? wrapStream({ doStream, params: transformedParams, model }) : doStream();
+      return wrapStream ? wrapStream({ doGenerate, doStream, params: transformedParams, model }) : doStream();
     }
   };
 };
@@ -7632,6 +7778,7 @@ export {
   createDataStreamResponse,
   createIdGenerator5 as createIdGenerator,
   customProvider,
+  defaultSettingsMiddleware,
   embed,
   embedMany,
   createMCPClient as experimental_createMCPClient,
@@ -7652,6 +7799,7 @@ export {
   processDataStream,
   processTextStream,
   simulateReadableStream,
+  simulateStreamingMiddleware,
   smoothStream,
   streamObject,
   streamText,