ai 7.0.106 → 7.0.108

package/dist/index.js

@@ -774,6 +774,9 @@ function asImageModelV4(model) {
   });
 }
 
+// src/model/as-language-model-v4.ts
+import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+
 // src/model/as-language-model-v3.ts
 function asLanguageModelV3(model) {
   if (model.specificationVersion === "v3") {
@@ -861,11 +864,131 @@ function asLanguageModelV4(model) {
   const v3Model = model.specificationVersion === "v2" ? asLanguageModelV3(model) : model;
   return new Proxy(v3Model, {
     get(target, prop) {
-      if (prop === "specificationVersion") return "v4";
-      return target[prop];
+      switch (prop) {
+        case "specificationVersion":
+          return "v4";
+        case "doGenerate":
+          return async (options) => {
+            const result = await target.doGenerate({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt)
+            });
+            return {
+              ...result,
+              content: result.content.map(convertV3ContentToV4)
+            };
+          };
+        case "doStream":
+          return async (options) => {
+            const result = await target.doStream({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt)
+            });
+            return {
+              ...result,
+              stream: convertV3StreamToV4(result.stream)
+            };
+          };
+        default:
+          return target[prop];
+      }
+    }
+  });
+}
+function convertV4PromptToV3(prompt) {
+  return prompt.map((message) => {
+    if (message.role === "system") {
+      return message;
     }
+    return {
+      ...message,
+      content: message.content.map((part) => {
+        switch (part.type) {
+          case "file":
+            return {
+              ...part,
+              data: convertV4FileDataToV3(part.data)
+            };
+          case "tool-result":
+            return {
+              ...part,
+              output: convertV4ToolResultOutputToV3(part.output)
+            };
+          default:
+            return part;
+        }
+      })
+    };
   });
 }
+function convertV4FileDataToV3(data) {
+  switch (data.type) {
+    case "data":
+      return data.data;
+    case "url":
+      return data.url;
+    case "reference":
+    case "text":
+      return data;
+  }
+}
+function convertV4ToolResultOutputToV3(output) {
+  if (output.type !== "content") {
+    return output;
+  }
+  return {
+    ...output,
+    value: output.value.map((part) => {
+      if (part.type !== "file") {
+        return part;
+      }
+      switch (part.data.type) {
+        case "data":
+          return {
+            type: "file-data",
+            data: typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data),
+            mediaType: part.mediaType,
+            filename: part.filename,
+            providerOptions: part.providerOptions
+          };
+        case "url":
+          return {
+            type: "file-url",
+            url: part.data.url.toString(),
+            providerOptions: part.providerOptions
+          };
+        case "reference":
+          return {
+            type: "file-id",
+            fileId: part.data.reference,
+            providerOptions: part.providerOptions
+          };
+        case "text":
+          return part;
+      }
+    })
+  };
+}
+function convertV3ContentToV4(content) {
+  return content.type === "file" ? {
+    ...content,
+    data: { type: "data", data: content.data }
+  } : content;
+}
+function convertV3StreamToV4(stream) {
+  return stream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        controller.enqueue(
+          chunk.type === "file" ? {
+            ...chunk,
+            data: { type: "data", data: chunk.data }
+          } : chunk
+        );
+      }
+    })
+  );
+}
 
 // src/model/as-reranking-model-v4.ts
 function asRerankingModelV4(model) {
@@ -1211,7 +1334,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.106" : "0.0.0-test";
+var VERSION = true ? "7.0.108" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -3010,7 +3133,7 @@ function collectToolApprovals({
 // src/generate-text/generated-file.ts
 import {
   convertBase64ToUint8Array,
-  convertUint8ArrayToBase64
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642
 } from "@ai-sdk/provider-utils";
 var DefaultGeneratedFile = class {
   constructor({
@@ -3027,7 +3150,7 @@ var DefaultGeneratedFile = class {
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
     if (this.base64Data == null) {
-      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
+      this.base64Data = convertUint8ArrayToBase642(this.uint8ArrayData);
     }
     return this.base64Data;
   }
@@ -4439,7 +4562,8 @@ async function parseToolCall({
   repairToolCall,
   refineToolInput,
   messages,
-  instructions
+  instructions,
+  abortSignal
 }) {
   try {
     if (tools == null) {
@@ -4462,20 +4586,26 @@ async function parseToolCall({
       }
       let repairedToolCall = null;
       try {
-        repairedToolCall = await repairToolCall({
-          toolCall,
-          tools,
-          inputSchema: async ({ toolName }) => {
-            var _a25;
-            const inputSchema = (_a25 = getOwn(tools, toolName)) == null ? void 0 : _a25.inputSchema;
-            return await asSchema3(inputSchema).jsonSchema;
-          },
-          instructions,
-          system: instructions,
-          messages,
-          error
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+        repairedToolCall = await waitForPromiseWithAbortSignal({
+          promise: repairToolCall({
+            toolCall,
+            tools,
+            inputSchema: async ({ toolName }) => {
+              var _a25;
+              const inputSchema = (_a25 = getOwn(tools, toolName)) == null ? void 0 : _a25.inputSchema;
+              return await asSchema3(inputSchema).jsonSchema;
+            },
+            instructions,
+            system: instructions,
+            messages,
+            error,
+            abortSignal
+          }),
+          abortSignal
         });
       } catch (repairError) {
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
         throw new ToolCallRepairError({
           cause: repairError,
           originalError: error
@@ -4484,12 +4614,15 @@ async function parseToolCall({
       if (repairedToolCall == null) {
         throw error;
       }
-      return await refineParsedToolCallInput({
+      const parsedRepairedToolCall = await refineParsedToolCallInput({
         toolCall: await doParseToolCall({ toolCall: repairedToolCall, tools }),
         refineToolInput
       });
+      abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+      return parsedRepairedToolCall;
     }
   } catch (error) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
     const parsedInput = await safeParseJSON3({ text: toolCall.input });
     const input = parsedInput.success ? parsedInput.value : toolCall.input;
     const tool3 = getOwn(tools, toolCall.toolName);
@@ -4508,6 +4641,34 @@ async function parseToolCall({
     };
   }
 }
+async function waitForPromiseWithAbortSignal({
+  promise,
+  abortSignal
+}) {
+  if (abortSignal == null) {
+    return await promise;
+  }
+  return await new Promise((resolve3, reject) => {
+    const cleanup = () => {
+      abortSignal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortSignal.reason);
+    };
+    Promise.resolve(promise).then((value) => {
+      cleanup();
+      resolve3(value);
+    }).catch((error) => {
+      cleanup();
+      reject(error);
+    });
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+    if (abortSignal.aborted) {
+      onAbort();
+    }
+  });
+}
 async function refineParsedToolCallInput({
   toolCall,
   refineToolInput
@@ -5514,7 +5675,7 @@ function sortToolResultContentByToolCallOrder({
 import { convertBase64ToUint8Array as convertBase64ToUint8Array2 } from "@ai-sdk/provider-utils";
 
 // src/util/canonical-hash.ts
-import { convertUint8ArrayToBase64 as convertUint8ArrayToBase642 } from "@ai-sdk/provider-utils";
+import { convertUint8ArrayToBase64 as convertUint8ArrayToBase643 } from "@ai-sdk/provider-utils";
 var encoder = new TextEncoder();
 function canonicalJSON(value) {
   if (value === null || value === void 0) {
@@ -5533,7 +5694,7 @@ function canonicalJSON(value) {
   return `{${entries.join(",")}}`;
 }
 function toBase64url(bytes) {
-  return convertUint8ArrayToBase642(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  return convertUint8ArrayToBase643(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 async function hashCanonical(value) {
   const digest = await crypto.subtle.digest(
@@ -6191,11 +6352,12 @@ async function generateText({
                 ).map(
                   (toolCall) => parseToolCall({
                     toolCall,
-                    tools: stepExecutionTools,
+                    tools: stepModelTools,
                     repairToolCall,
                     refineToolInput,
                     instructions: stepInstructions,
-                    messages: stepMessages
+                    messages: stepMessages,
+                    abortSignal: mergedAbortSignal
                   })
                 )
               );
@@ -6265,22 +6427,29 @@ async function generateText({
                 if (tool3 == null) {
                   continue;
                 }
-                if (tool3.onInputStart != null) {
-                  await tool3.onInputStart({
-                    toolCallId: toolCall.toolCallId,
-                    messages: stepMessages,
-                    abortSignal: mergedAbortSignal,
-                    context: runtimeContext
-                  });
-                }
-                if ((tool3 == null ? void 0 : tool3.onInputAvailable) != null) {
-                  await tool3.onInputAvailable({
-                    input: toolCall.input,
-                    toolCallId: toolCall.toolCallId,
-                    messages: stepMessages,
-                    abortSignal: mergedAbortSignal,
-                    context: runtimeContext
+                if (tool3.onInputStart != null || tool3.onInputAvailable != null) {
+                  const context = await validateToolContext({
+                    toolName: toolCall.toolName,
+                    context: getOwn(toolsContext, toolCall.toolName),
+                    contextSchema: tool3.contextSchema
                   });
+                  if (tool3.onInputStart != null) {
+                    await tool3.onInputStart({
+                      toolCallId: toolCall.toolCallId,
+                      messages: stepMessages,
+                      abortSignal: mergedAbortSignal,
+                      context
+                    });
+                  }
+                  if (tool3.onInputAvailable != null) {
+                    await tool3.onInputAvailable({
+                      input: toolCall.input,
+                      toolCallId: toolCall.toolCallId,
+                      messages: stepMessages,
+                      abortSignal: mergedAbortSignal,
+                      context
+                    });
+                  }
                 }
                 const toolApprovalStatus = await resolveToolApproval({
                   tools: stepExecutionTools,
@@ -6783,10 +6952,13 @@ function writeToServerResponse({
   stream
 }) {
   const statusCode = status != null ? status : 200;
+  if (headers != null) {
+    response.setHeaders(headers);
+  }
   if (statusText !== void 0) {
-    response.writeHead(statusCode, statusText, headers);
+    response.writeHead(statusCode, statusText);
   } else {
-    response.writeHead(statusCode, headers);
+    response.writeHead(statusCode);
   }
   const reader = stream.getReader();
   const read = async () => {
@@ -6826,11 +6998,9 @@ function pipeTextStreamToResponse({
     response,
     status,
     statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, {
-        "content-type": "text/plain; charset=utf-8"
-      }).entries()
-    ),
+    headers: prepareHeaders(headers, {
+      "content-type": "text/plain; charset=utf-8"
+    }),
     stream: stream.pipeThrough(new TextEncoderStream())
   });
 }
@@ -6916,9 +7086,7 @@ function pipeUIMessageStreamToResponse({
     response,
     status,
     statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS).entries()
-    ),
+    headers: prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS),
     stream: sseStream.pipeThrough(new TextEncoderStream())
   });
 }
@@ -8796,33 +8964,60 @@ function invokeToolCallbacksFromStream({
   tools,
   stepInputMessages,
   abortSignal,
-  runtimeContext
+  toolsContext
 }) {
   if (tools == null) return stream;
-  const ongoingToolCallToolNames = createIdMap();
+  let ongoingToolCalls = createIdMap();
+  const getValidatedContext = ({
+    toolCallId,
+    toolName
+  }) => {
+    const ongoingToolCall = ongoingToolCalls[toolCallId];
+    if ((ongoingToolCall == null ? void 0 : ongoingToolCall.validatedContext) != null) {
+      return ongoingToolCall.validatedContext;
+    }
+    const tool3 = getOwn(tools, toolName);
+    const validatedContext = validateToolContext({
+      toolName,
+      context: getOwn(toolsContext, toolName),
+      contextSchema: tool3 == null ? void 0 : tool3.contextSchema
+    });
+    if (ongoingToolCall != null) {
+      ongoingToolCall.validatedContext = validatedContext;
+    }
+    return validatedContext;
+  };
   return stream.pipeThrough(
     new TransformStream({
       async transform(chunk, controller) {
+        var _a25, _b25;
         controller.enqueue(chunk);
         if (isStreamRetryAttemptBoundaryPart(chunk)) {
+          ongoingToolCalls = createIdMap();
           return;
         }
         switch (chunk.type) {
           case "tool-input-start": {
-            ongoingToolCallToolNames[chunk.id] = chunk.toolName;
+            ongoingToolCalls[chunk.id] = {
+              toolName: chunk.toolName,
+              validatedContext: void 0
+            };
             const tool3 = getOwn(tools, chunk.toolName);
             if ((tool3 == null ? void 0 : tool3.onInputStart) != null) {
               await tool3.onInputStart({
                 toolCallId: chunk.id,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext
+                context: await getValidatedContext({
+                  toolCallId: chunk.id,
+                  toolName: chunk.toolName
+                })
               });
             }
             break;
           }
           case "tool-input-delta": {
-            const toolName = ongoingToolCallToolNames[chunk.id];
+            const toolName = (_a25 = ongoingToolCalls[chunk.id]) == null ? void 0 : _a25.toolName;
             const tool3 = getOwn(tools, toolName);
             if ((tool3 == null ? void 0 : tool3.onInputDelta) != null) {
               await tool3.onInputDelta({
@@ -8830,23 +9025,32 @@ function invokeToolCallbacksFromStream({
                 toolCallId: chunk.id,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext
+                context: await getValidatedContext({
+                  toolCallId: chunk.id,
+                  toolName
+                })
               });
             }
             break;
           }
           case "tool-call": {
-            const toolName = ongoingToolCallToolNames[chunk.toolCallId];
+            const toolName = (_b25 = ongoingToolCalls[chunk.toolCallId]) == null ? void 0 : _b25.toolName;
             const tool3 = getOwn(tools, toolName);
-            delete ongoingToolCallToolNames[chunk.toolCallId];
             if (!chunk.invalid && (tool3 == null ? void 0 : tool3.onInputAvailable) != null) {
+              const validatedContext = getValidatedContext({
+                toolCallId: chunk.toolCallId,
+                toolName
+              });
+              delete ongoingToolCalls[chunk.toolCallId];
               await tool3.onInputAvailable({
                 input: chunk.input,
                 toolCallId: chunk.toolCallId,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext
+                context: await validatedContext
               });
+            } else {
+              delete ongoingToolCalls[chunk.toolCallId];
             }
           }
         }
@@ -9047,6 +9251,7 @@ async function streamLanguageModelCall({
       messages: standardizedPrompt.messages,
       repairToolCall,
       refineToolInput,
+      abortSignal,
       callId: effectiveCallId,
       provider: resolvedModel.provider,
       modelId: resolvedModel.modelId,
@@ -9069,6 +9274,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
   messages,
   repairToolCall,
   refineToolInput,
+  abortSignal,
   callId,
   provider,
   modelId,
@@ -9256,27 +9462,28 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             },
             callbacks: onLanguageModelCallEnd
           });
+          const enforcedToolChoice = toolChoice.type === "required" || toolChoice.type === "tool" ? toolChoice : void 0;
+          const toolChoiceViolationError = enforcedToolChoice != null && ![...toolCallsByToolCallId.values()].some(
+            (toolCall) => enforcedToolChoice.type === "required" || toolCall.toolName === enforcedToolChoice.toolName
+          ) ? new ToolChoiceViolationError({
+            toolChoice: enforcedToolChoice,
+            finishReason: chunk.finishReason.unified,
+            provider,
+            modelId,
+            content: rawModelCallContent
+          }) : void 0;
           controller.enqueue({
             type: "model-call-end",
-            finishReason: chunk.finishReason.unified,
+            finishReason: toolChoiceViolationError == null ? chunk.finishReason.unified : "error",
             rawFinishReason: chunk.finishReason.raw,
             usage,
             providerMetadata: chunk.providerMetadata,
             performance
           });
-          const enforcedToolChoice = toolChoice.type === "required" || toolChoice.type === "tool" ? toolChoice : void 0;
-          if (enforcedToolChoice != null && ![...toolCallsByToolCallId.values()].some(
-            (toolCall) => enforcedToolChoice.type === "required" || toolCall.toolName === enforcedToolChoice.toolName
-          )) {
+          if (toolChoiceViolationError != null) {
             controller.enqueue({
               type: "error",
-              error: new ToolChoiceViolationError({
-                toolChoice: enforcedToolChoice,
-                finishReason: chunk.finishReason.unified,
-                provider,
-                modelId,
-                content: rawModelCallContent
-              })
+              error: toolChoiceViolationError
             });
             break;
           }
@@ -9291,7 +9498,8 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
               repairToolCall,
               refineToolInput,
               instructions,
-              messages
+              messages,
+              abortSignal
             });
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
             controller.enqueue(toolCall);
@@ -10881,7 +11089,7 @@ var DefaultStreamTextResult = class {
             tools: stepExecutionTools,
             stepInputMessages: stepMessages,
             abortSignal,
-            runtimeContext
+            toolsContext
           });
           const runInTracingChannelSpanInStep = telemetryDispatcher.runInTracingChannelSpan == null ? void 0 : (options) => runInStepTracingChannelContext(
             () => telemetryDispatcher.runInTracingChannelSpan(options)
@@ -12893,16 +13101,16 @@ import {
 // src/prompt/data-content.ts
 import {
   convertBase64ToUint8Array as convertBase64ToUint8Array3,
-  convertUint8ArrayToBase64 as convertUint8ArrayToBase643
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase644
 } from "@ai-sdk/provider-utils";
 function convertDataContentToBase64String(content) {
   if (typeof content === "string") {
     return content;
   }
   if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase643(new Uint8Array(content));
+    return convertUint8ArrayToBase644(new Uint8Array(content));
   }
-  return convertUint8ArrayToBase643(content);
+  return convertUint8ArrayToBase644(content);
 }
 function convertDataContentToUint8Array(content) {
   if (content instanceof Uint8Array) {
@@ -15331,8 +15539,13 @@ function createDownload(options) {
 // src/util/data-url.ts
 var { atob: atob2 } = globalThis;
 function getTextFromDataUrl(dataUrl) {
+  var _a25;
   const [header, base64Content] = dataUrl.split(",");
   const mediaType = header.split(";")[0].split(":")[1];
+  const charsetMatch = /(?:^|;)\s*charset\s*=\s*(?:"([^"]+)"|([^;\s]+))/i.exec(
+    header
+  );
+  const charset = (_a25 = charsetMatch == null ? void 0 : charsetMatch[1]) != null ? _a25 : charsetMatch == null ? void 0 : charsetMatch[2];
   if (mediaType == null || base64Content == null) {
     throw new InvalidArgumentError({
       parameter: "dataUrl",
@@ -15341,7 +15554,13 @@ function getTextFromDataUrl(dataUrl) {
     });
   }
   try {
-    return atob2(base64Content);
+    const byteString = atob2(base64Content);
+    if (charset == null) {
+      return byteString;
+    }
+    return new TextDecoder(charset).decode(
+      Uint8Array.from(byteString, (byte) => byte.codePointAt(0))
+    );
   } catch (e) {
     throw new InvalidArgumentError({
       parameter: "dataUrl",
@@ -16010,7 +16229,7 @@ async function generateSpeech({
   abortSignal,
   headers
 }) {
-  var _a25;
+  var _a25, _b25;
   const resolvedModel = resolveSpeechModel(model);
   if (!resolvedModel) {
     throw new Error("Model could not be resolved");
@@ -16044,19 +16263,41 @@ async function generateSpeech({
     provider: resolvedModel.provider,
     model: resolvedModel.modelId
   });
+  const detectedMediaType = detectMediaType4({
+    data: result.audio,
+    topLevelType: "audio"
+  });
   return new DefaultSpeechResult({
     audio: new DefaultGeneratedAudioFile({
       data: result.audio,
-      mediaType: (_a25 = detectMediaType4({
-        data: result.audio,
-        topLevelType: "audio"
-      })) != null ? _a25 : "audio/mp3"
+      mediaType: (_b25 = (_a25 = detectedMediaType != null ? detectedMediaType : getResponseAudioMediaType(result.response.headers)) != null ? _a25 : getOutputFormatMediaType(outputFormat)) != null ? _b25 : "audio/mp3"
     }),
     warnings: result.warnings,
     responses: [result.response],
     providerMetadata: result.providerMetadata
   });
 }
+function getResponseAudioMediaType(headers) {
+  var _a25;
+  const mediaType = (_a25 = Object.entries(headers != null ? headers : {}).find(
+    ([name25]) => name25.toLowerCase() === "content-type"
+  )) == null ? void 0 : _a25[1];
+  if (mediaType == null) {
+    return void 0;
+  }
+  const normalizedMediaType = mediaType.split(";", 1)[0].trim().toLowerCase();
+  if (normalizedMediaType.length === 0) {
+    return void 0;
+  }
+  return normalizedMediaType.startsWith("audio/") ? normalizedMediaType : void 0;
+}
+function getOutputFormatMediaType(outputFormat) {
+  if (outputFormat == null) {
+    return void 0;
+  }
+  const normalizedOutputFormat = outputFormat.trim().toLowerCase();
+  return normalizedOutputFormat === "pcm" || normalizedOutputFormat === "audio/pcm" ? "audio/pcm" : void 0;
+}
 var DefaultSpeechResult = class {
   constructor(options) {
     var _a25;
@@ -16364,7 +16605,7 @@ async function experimental_generateVideo({
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
-  const { retry } = prepareRetries({
+  const { maxRetries, retry } = prepareRetries({
     maxRetries: maxRetriesArg,
     abortSignal
   });
@@ -16424,6 +16665,7 @@ async function experimental_generateVideo({
           callOptions,
           poll,
           webhook,
+          maxRetries,
           retry
         });
       }
@@ -16512,6 +16754,7 @@ async function executeStartStatusFlow({
   callOptions,
   poll: pollConfig,
   webhook: webhookFactory,
+  maxRetries,
   retry
 }) {
   var _a25, _b25, _c, _d;
@@ -16553,6 +16796,9 @@ async function executeStartStatusFlow({
   const timeoutMs = (_c = pollConfig == null ? void 0 : pollConfig.timeoutMs) != null ? _c : 6e5;
   const delay = (_d = pollConfig == null ? void 0 : pollConfig.delay) != null ? _d : defaultDelay;
   const startTime = Date.now();
+  const pollingTimeoutError = new Error(
+    `Video generation timed out after ${timeoutMs}ms.`
+  );
   if (webhookReceived != null) {
     await waitForWebhook({
       received: webhookReceived,
@@ -16565,22 +16811,65 @@ async function executeStartStatusFlow({
     if (webhookReceived == null) {
       const elapsedMs = Date.now() - startTime;
       if (elapsedMs >= timeoutMs) {
-        throw new Error(`Video generation timed out after ${timeoutMs}ms.`);
+        throw pollingTimeoutError;
       }
       await delay(Math.min(intervalMs, timeoutMs - elapsedMs), {
         abortSignal: callOptions.abortSignal
       });
       if (Date.now() - startTime >= timeoutMs) {
-        throw new Error(`Video generation timed out after ${timeoutMs}ms.`);
+        throw pollingTimeoutError;
+      }
+    }
+    let statusResult;
+    if (webhookReceived != null) {
+      statusResult = await retry(
+        () => model.doStatus({
+          operation: startResult.operation,
+          abortSignal: callOptions.abortSignal,
+          headers: callOptions.headers
+        })
+      );
+    } else {
+      const statusTimeoutController = new AbortController();
+      const statusAbortSignal = mergeAbortSignals(
+        callOptions.abortSignal,
+        statusTimeoutController.signal
+      );
+      const statusTimeoutId = setTimeout(
+        () => statusTimeoutController.abort(pollingTimeoutError),
+        timeoutMs - (Date.now() - startTime)
+      );
+      const statusTimeoutPromise = new Promise((_, reject) => {
+        statusTimeoutController.signal.addEventListener(
+          "abort",
+          () => reject(pollingTimeoutError),
+          { once: true }
+        );
+      });
+      const { retry: statusRetry } = prepareRetries({
+        maxRetries,
+        abortSignal: statusAbortSignal
+      });
+      try {
+        statusResult = await Promise.race([
+          statusRetry(
+            () => model.doStatus({
+              operation: startResult.operation,
+              abortSignal: statusAbortSignal,
+              headers: callOptions.headers
+            })
+          ),
+          statusTimeoutPromise
+        ]);
+      } catch (error) {
+        if (statusTimeoutController.signal.aborted) {
+          throw pollingTimeoutError;
+        }
+        throw error;
+      } finally {
+        clearTimeout(statusTimeoutId);
       }
     }
-    const statusResult = await retry(
-      () => model.doStatus({
-        operation: startResult.operation,
-        abortSignal: callOptions.abortSignal,
-        headers: callOptions.headers
-      })
-    );
     if (statusResult.status === "error") {
       throw new Error(statusResult.error);
     }
@@ -17551,7 +17840,9 @@ function wrapProvider({
     },
     transcriptionModel: providerV4.transcriptionModel,
     speechModel: providerV4.speechModel,
-    rerankingModel: providerV4.rerankingModel
+    rerankingModel: providerV4.rerankingModel,
+    ...providerV4.files != null ? { files: providerV4.files } : {},
+    ...providerV4.skills != null ? { skills: providerV4.skills } : {}
   };
 }
 
@@ -21532,6 +21823,10 @@ import {
   resolve as resolve2
 } from "@ai-sdk/provider-utils";
 import { EmptyResponseBodyError as EmptyResponseBodyError3 } from "@ai-sdk/provider";
+function appendPathToUrl(url, path) {
+  const queryOrFragmentStart = url.search(/[?#]/);
+  return queryOrFragmentStart === -1 ? `${url}${path}` : `${url.slice(0, queryOrFragmentStart)}${path}${url.slice(queryOrFragmentStart)}`;
+}
 var HttpChatTransport = class {
   constructor({
     api = "/api/chat",
@@ -21588,7 +21883,7 @@ var HttpChatTransport = class {
     const response = await fetch2(api, {
       method: "POST",
       headers: {
-        "Content-Type": "application/json",
+        "content-type": "application/json",
         ...headers
       },
       body: JSON.stringify(body),
@@ -21626,7 +21921,7 @@ var HttpChatTransport = class {
       credentials: resolvedCredentials,
       requestMetadata: options.metadata
     }));
-    const api = (_b25 = preparedRequest == null ? void 0 : preparedRequest.api) != null ? _b25 : `${this.api}/${options.chatId}/stream`;
+    const api = (_b25 = preparedRequest == null ? void 0 : preparedRequest.api) != null ? _b25 : appendPathToUrl(this.api, `/${options.chatId}/stream`);
     const headers = (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? normalizeHeaders(preparedRequest.headers) : baseHeaders;
     const credentials = (_c = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _c : resolvedCredentials;
     const fetch2 = (_d = this.fetch) != null ? _d : globalThis.fetch;
@@ -22212,7 +22507,7 @@ function lastAssistantMessageIsCompleteWithApprovalResponses({
     // has at least one tool approval response
     lastStepToolInvocations.filter((part) => part.state === "approval-responded").length > 0 && // all tool approvals must have a response
     lastStepToolInvocations.every(
-      (part) => part.state === "output-available" || part.state === "output-error" || part.state === "output-denied" || part.state === "approval-responded"
+      (part) => part.state === "output-available" && part.preliminary !== true || part.state === "output-error" || part.state === "output-denied" || part.state === "approval-responded"
     )
   );
 }
@@ -22233,7 +22528,7 @@ function lastAssistantMessageIsCompleteWithToolCalls({
   }, -1);
   const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter(isToolUIPart).filter((part) => !part.providerExecuted);
   return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every(
-    (part) => part.state === "output-available" || part.state === "output-error"
+    (part) => part.state === "output-available" && part.preliminary !== true || part.state === "output-error"
   );
 }