@ai-sdk/groq 4.0.0-beta.3 → 4.0.0-beta.30

package/dist/index.js

@@ -1,40 +1,29 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  browserSearch: () => browserSearch,
-  createGroq: () => createGroq,
-  groq: () => groq
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/groq-provider.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/groq-chat-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  StreamingToolCallTracker,
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
+  parseProviderOptions,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/convert-groq-usage.ts
 function convertGroqUsage(usage) {
@@ -76,8 +65,10 @@ function convertGroqUsage(usage) {
 }
 
 // src/convert-to-groq-chat-messages.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import { convertToBase64, isProviderReference } from "@ai-sdk/provider-utils";
 function convertToGroqChatMessages(prompt) {
   var _a;
   const messages = [];
@@ -100,8 +91,13 @@ function convertToGroqChatMessages(prompt) {
                 return { type: "text", text: part.text };
               }
               case "file": {
+                if (isProviderReference(part.data)) {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: "file parts with provider references"
+                  });
+                }
                 if (!part.mediaType.startsWith("image/")) {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "Non-image file content parts"
                   });
                 }
@@ -109,7 +105,7 @@ function convertToGroqChatMessages(prompt) {
                 return {
                   type: "image_url",
                   image_url: {
-                    url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${(0, import_provider_utils.convertToBase64)(part.data)}`
+                    url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
                   }
                 };
               }
@@ -207,29 +203,29 @@ function getResponseMetadata({
 }
 
 // src/groq-chat-options.ts
-var import_v4 = require("zod/v4");
-var groqLanguageModelOptions = import_v4.z.object({
-  reasoningFormat: import_v4.z.enum(["parsed", "raw", "hidden"]).optional(),
+import { z } from "zod/v4";
+var groqLanguageModelOptions = z.object({
+  reasoningFormat: z.enum(["parsed", "raw", "hidden"]).optional(),
   /**
    * Specifies the reasoning effort level for model inference.
    * @see https://console.groq.com/docs/reasoning#reasoning-effort
    */
-  reasoningEffort: import_v4.z.enum(["none", "default", "low", "medium", "high"]).optional(),
+  reasoningEffort: z.enum(["none", "default", "low", "medium", "high"]).optional(),
   /**
    * Whether to enable parallel function calling during tool use. Default to true.
    */
-  parallelToolCalls: import_v4.z.boolean().optional(),
+  parallelToolCalls: z.boolean().optional(),
   /**
    * A unique identifier representing your end-user, which can help OpenAI to
    * monitor and detect abuse. Learn more.
    */
-  user: import_v4.z.string().optional(),
+  user: z.string().optional(),
   /**
    * Whether to use structured outputs.
    *
    * @default true
    */
-  structuredOutputs: import_v4.z.boolean().optional(),
+  structuredOutputs: z.boolean().optional(),
   /**
    * Whether to use strict JSON schema validation.
    * When true, the model uses constrained decoding to guarantee schema compliance.
@@ -237,34 +233,37 @@ var groqLanguageModelOptions = import_v4.z.object({
    *
    * @default true
    */
-  strictJsonSchema: import_v4.z.boolean().optional(),
+  strictJsonSchema: z.boolean().optional(),
   /**
    * Service tier for the request.
    * - 'on_demand': Default tier with consistent performance and fairness
+   * - 'performance': Prioritized tier for latency-sensitive workloads
    * - 'flex': Higher throughput tier optimized for workloads that can handle occasional request failures
    * - 'auto': Uses on_demand rate limits, then falls back to flex tier if exceeded
    *
    * @default 'on_demand'
    */
-  serviceTier: import_v4.z.enum(["on_demand", "flex", "auto"]).optional()
+  serviceTier: z.enum(["on_demand", "performance", "flex", "auto"]).optional()
 });
 
 // src/groq-error.ts
-var import_v42 = require("zod/v4");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var groqErrorDataSchema = import_v42.z.object({
-  error: import_v42.z.object({
-    message: import_v42.z.string(),
-    type: import_v42.z.string()
+import { z as z2 } from "zod/v4";
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+var groqErrorDataSchema = z2.object({
+  error: z2.object({
+    message: z2.string(),
+    type: z2.string()
   })
 });
-var groqFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
+var groqFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: groqErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
 
 // src/groq-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 
 // src/groq-browser-search-models.ts
 var BROWSER_SEARCH_SUPPORTED_MODELS = [
@@ -344,7 +343,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -369,15 +368,24 @@ function mapGroqFinishReason(finishReason) {
 }
 
 // src/groq-chat-language-model.ts
-var GroqChatLanguageModel = class {
+var GroqChatLanguageModel = class _GroqChatLanguageModel {
   constructor(modelId, config) {
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
     this.supportedUrls = {
       "image/*": [/^https?:\/\/.*$/]
     };
     this.modelId = modelId;
     this.config = config;
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _GroqChatLanguageModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
@@ -392,14 +400,14 @@ var GroqChatLanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
-    stream,
+    reasoning,
     tools,
     toolChoice,
     providerOptions
   }) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const warnings = [];
-    const groqOptions = await (0, import_provider_utils3.parseProviderOptions)({
+    const groqOptions = await parseProviderOptions({
       provider: "groq",
       providerOptions,
       schema: groqLanguageModelOptions
@@ -448,7 +456,17 @@ var GroqChatLanguageModel = class {
         } : { type: "json_object" } : void 0,
         // provider options:
         reasoning_format: groqOptions == null ? void 0 : groqOptions.reasoningFormat,
-        reasoning_effort: groqOptions == null ? void 0 : groqOptions.reasoningEffort,
+        reasoning_effort: (_d = groqOptions == null ? void 0 : groqOptions.reasoningEffort) != null ? _d : isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
+          reasoning,
+          effortMap: {
+            minimal: "low",
+            low: "low",
+            medium: "medium",
+            high: "high",
+            xhigh: "high"
+          },
+          warnings
+        }) : void 0,
         service_tier: groqOptions == null ? void 0 : groqOptions.serviceTier,
         // messages:
         messages: convertToGroqChatMessages(prompt),
@@ -460,25 +478,22 @@ var GroqChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b;
-    const { args, warnings } = await this.getArgs({
-      ...options,
-      stream: false
-    });
+    var _a, _b, _c, _d;
+    const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body: args,
       failedResponseHandler: groqFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         groqChatResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -501,7 +516,7 @@ var GroqChatLanguageModel = class {
       for (const toolCall of choice.message.tool_calls) {
         content.push({
           type: "tool-call",
-          toolCallId: (_a = toolCall.id) != null ? _a : (0, import_provider_utils3.generateId)(),
+          toolCallId: (_c = toolCall.id) != null ? _c : generateId(),
           toolName: toolCall.function.name,
           input: toolCall.function.arguments
         });
@@ -511,7 +526,7 @@ var GroqChatLanguageModel = class {
       content,
       finishReason: {
         unified: mapGroqFinishReason(choice.finish_reason),
-        raw: (_b = choice.finish_reason) != null ? _b : void 0
+        raw: (_d = choice.finish_reason) != null ? _d : void 0
       },
       usage: convertGroqUsage(response.usage),
       response: {
@@ -524,24 +539,25 @@ var GroqChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    const { args, warnings } = await this.getArgs({ ...options, stream: true });
-    const body = JSON.stringify({ ...args, stream: true });
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    var _a, _b;
+    const { args, warnings } = await this.getArgs(options);
+    const body = { ...args, stream: true };
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
-      body: {
-        ...args,
-        stream: true
-      },
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      body,
       failedResponseHandler: groqFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(groqChatChunkSchema),
+      successfulResponseHandler: createEventSourceResponseHandler(groqChatChunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const toolCalls = [];
+    const toolCallTracker = new StreamingToolCallTracker({
+      generateId,
+      typeValidation: "required"
+    });
     let finishReason = {
       unified: "other",
       raw: void 0
@@ -558,7 +574,7 @@ var GroqChatLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+            var _a2;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -586,7 +602,7 @@ var GroqChatLanguageModel = class {
                 ...getResponseMetadata(value)
               });
             }
-            if (((_a = value.x_groq) == null ? void 0 : _a.usage) != null) {
+            if (((_a2 = value.x_groq) == null ? void 0 : _a2.usage) != null) {
               usage = value.x_groq.usage;
             }
             const choice = value.choices[0];
@@ -641,90 +657,10 @@ var GroqChatLanguageModel = class {
                 isActiveReasoning = false;
               }
               for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index;
-                if (toolCalls[index] == null) {
-                  if (toolCallDelta.type !== "function") {
-                    throw new import_provider3.InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function' type.`
-                    });
-                  }
-                  if (toolCallDelta.id == null) {
-                    throw new import_provider3.InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'id' to be a string.`
-                    });
-                  }
-                  if (((_b = toolCallDelta.function) == null ? void 0 : _b.name) == null) {
-                    throw new import_provider3.InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function.name' to be a string.`
-                    });
-                  }
-                  controller.enqueue({
-                    type: "tool-input-start",
-                    id: toolCallDelta.id,
-                    toolName: toolCallDelta.function.name
-                  });
-                  toolCalls[index] = {
-                    id: toolCallDelta.id,
-                    type: "function",
-                    function: {
-                      name: toolCallDelta.function.name,
-                      arguments: (_c = toolCallDelta.function.arguments) != null ? _c : ""
-                    },
-                    hasFinished: false
-                  };
-                  const toolCall2 = toolCalls[index];
-                  if (((_d = toolCall2.function) == null ? void 0 : _d.name) != null && ((_e = toolCall2.function) == null ? void 0 : _e.arguments) != null) {
-                    if (toolCall2.function.arguments.length > 0) {
-                      controller.enqueue({
-                        type: "tool-input-delta",
-                        id: toolCall2.id,
-                        delta: toolCall2.function.arguments
-                      });
-                    }
-                    if ((0, import_provider_utils3.isParsableJson)(toolCall2.function.arguments)) {
-                      controller.enqueue({
-                        type: "tool-input-end",
-                        id: toolCall2.id
-                      });
-                      controller.enqueue({
-                        type: "tool-call",
-                        toolCallId: (_f = toolCall2.id) != null ? _f : (0, import_provider_utils3.generateId)(),
-                        toolName: toolCall2.function.name,
-                        input: toolCall2.function.arguments
-                      });
-                      toolCall2.hasFinished = true;
-                    }
-                  }
-                  continue;
-                }
-                const toolCall = toolCalls[index];
-                if (toolCall.hasFinished) {
-                  continue;
-                }
-                if (((_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null) {
-                  toolCall.function.arguments += (_i = (_h = toolCallDelta.function) == null ? void 0 : _h.arguments) != null ? _i : "";
-                }
-                controller.enqueue({
-                  type: "tool-input-delta",
-                  id: toolCall.id,
-                  delta: (_j = toolCallDelta.function.arguments) != null ? _j : ""
-                });
-                if (((_k = toolCall.function) == null ? void 0 : _k.name) != null && ((_l = toolCall.function) == null ? void 0 : _l.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments)) {
-                  controller.enqueue({
-                    type: "tool-input-end",
-                    id: toolCall.id
-                  });
-                  controller.enqueue({
-                    type: "tool-call",
-                    toolCallId: (_m = toolCall.id) != null ? _m : (0, import_provider_utils3.generateId)(),
-                    toolName: toolCall.function.name,
-                    input: toolCall.function.arguments
-                  });
-                  toolCall.hasFinished = true;
-                }
+                toolCallTracker.processDelta(
+                  toolCallDelta,
+                  controller.enqueue.bind(controller)
+                );
               }
             }
           },
@@ -735,6 +671,7 @@ var GroqChatLanguageModel = class {
             if (isActiveText) {
               controller.enqueue({ type: "text-end", id: "txt-0" });
             }
+            toolCallTracker.flush(controller.enqueue.bind(controller));
             controller.enqueue({
               type: "finish",
               finishReason,
@@ -744,83 +681,83 @@ var GroqChatLanguageModel = class {
           }
         })
       ),
-      request: { body },
+      request: { body: JSON.stringify(body) },
       response: { headers: responseHeaders }
     };
   }
 };
-var groqChatResponseSchema = import_v43.z.object({
-  id: import_v43.z.string().nullish(),
-  created: import_v43.z.number().nullish(),
-  model: import_v43.z.string().nullish(),
-  choices: import_v43.z.array(
-    import_v43.z.object({
-      message: import_v43.z.object({
-        content: import_v43.z.string().nullish(),
-        reasoning: import_v43.z.string().nullish(),
-        tool_calls: import_v43.z.array(
-          import_v43.z.object({
-            id: import_v43.z.string().nullish(),
-            type: import_v43.z.literal("function"),
-            function: import_v43.z.object({
-              name: import_v43.z.string(),
-              arguments: import_v43.z.string()
+var groqChatResponseSchema = z3.object({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        content: z3.string().nullish(),
+        reasoning: z3.string().nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string().nullish(),
+            type: z3.literal("function"),
+            function: z3.object({
+              name: z3.string(),
+              arguments: z3.string()
             })
           })
         ).nullish()
       }),
-      index: import_v43.z.number(),
-      finish_reason: import_v43.z.string().nullish()
+      index: z3.number(),
+      finish_reason: z3.string().nullish()
     })
   ),
-  usage: import_v43.z.object({
-    prompt_tokens: import_v43.z.number().nullish(),
-    completion_tokens: import_v43.z.number().nullish(),
-    total_tokens: import_v43.z.number().nullish(),
-    prompt_tokens_details: import_v43.z.object({
-      cached_tokens: import_v43.z.number().nullish()
+  usage: z3.object({
+    prompt_tokens: z3.number().nullish(),
+    completion_tokens: z3.number().nullish(),
+    total_tokens: z3.number().nullish(),
+    prompt_tokens_details: z3.object({
+      cached_tokens: z3.number().nullish()
     }).nullish(),
-    completion_tokens_details: import_v43.z.object({
-      reasoning_tokens: import_v43.z.number().nullish()
+    completion_tokens_details: z3.object({
+      reasoning_tokens: z3.number().nullish()
     }).nullish()
   }).nullish()
 });
-var groqChatChunkSchema = import_v43.z.union([
-  import_v43.z.object({
-    id: import_v43.z.string().nullish(),
-    created: import_v43.z.number().nullish(),
-    model: import_v43.z.string().nullish(),
-    choices: import_v43.z.array(
-      import_v43.z.object({
-        delta: import_v43.z.object({
-          content: import_v43.z.string().nullish(),
-          reasoning: import_v43.z.string().nullish(),
-          tool_calls: import_v43.z.array(
-            import_v43.z.object({
-              index: import_v43.z.number(),
-              id: import_v43.z.string().nullish(),
-              type: import_v43.z.literal("function").optional(),
-              function: import_v43.z.object({
-                name: import_v43.z.string().nullish(),
-                arguments: import_v43.z.string().nullish()
+var groqChatChunkSchema = z3.union([
+  z3.object({
+    id: z3.string().nullish(),
+    created: z3.number().nullish(),
+    model: z3.string().nullish(),
+    choices: z3.array(
+      z3.object({
+        delta: z3.object({
+          content: z3.string().nullish(),
+          reasoning: z3.string().nullish(),
+          tool_calls: z3.array(
+            z3.object({
+              index: z3.number(),
+              id: z3.string().nullish(),
+              type: z3.literal("function").optional(),
+              function: z3.object({
+                name: z3.string().nullish(),
+                arguments: z3.string().nullish()
               })
             })
           ).nullish()
         }).nullish(),
-        finish_reason: import_v43.z.string().nullable().optional(),
-        index: import_v43.z.number()
+        finish_reason: z3.string().nullable().optional(),
+        index: z3.number()
       })
     ),
-    x_groq: import_v43.z.object({
-      usage: import_v43.z.object({
-        prompt_tokens: import_v43.z.number().nullish(),
-        completion_tokens: import_v43.z.number().nullish(),
-        total_tokens: import_v43.z.number().nullish(),
-        prompt_tokens_details: import_v43.z.object({
-          cached_tokens: import_v43.z.number().nullish()
+    x_groq: z3.object({
+      usage: z3.object({
+        prompt_tokens: z3.number().nullish(),
+        completion_tokens: z3.number().nullish(),
+        total_tokens: z3.number().nullish(),
+        prompt_tokens_details: z3.object({
+          cached_tokens: z3.number().nullish()
         }).nullish(),
-        completion_tokens_details: import_v43.z.object({
-          reasoning_tokens: import_v43.z.number().nullish()
+        completion_tokens_details: z3.object({
+          reasoning_tokens: z3.number().nullish()
         }).nullish()
       }).nullish()
     }).nullish()
@@ -829,34 +766,53 @@ var groqChatChunkSchema = import_v43.z.union([
 ]);
 
 // src/groq-transcription-model.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
+import {
+  combineHeaders as combineHeaders2,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  mediaTypeToExtension,
+  parseProviderOptions as parseProviderOptions2,
+  postFormDataToApi,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
 
 // src/groq-transcription-options.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-var groqTranscriptionModelOptions = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v44.z.object({
-      language: import_v44.z.string().nullish(),
-      prompt: import_v44.z.string().nullish(),
-      responseFormat: import_v44.z.string().nullish(),
-      temperature: import_v44.z.number().min(0).max(1).nullish(),
-      timestampGranularities: import_v44.z.array(import_v44.z.string()).nullish()
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+var groqTranscriptionModelOptions = lazySchema(
+  () => zodSchema(
+    z4.object({
+      language: z4.string().nullish(),
+      prompt: z4.string().nullish(),
+      responseFormat: z4.string().nullish(),
+      temperature: z4.number().min(0).max(1).nullish(),
+      timestampGranularities: z4.array(z4.string()).nullish()
     })
   )
 );
 
 // src/groq-transcription-model.ts
-var GroqTranscriptionModel = class {
+var GroqTranscriptionModel = class _GroqTranscriptionModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
   }
   get provider() {
     return this.config.provider;
   }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _GroqTranscriptionModel(options.modelId, options.config);
+  }
   async getArgs({
     audio,
     mediaType,
@@ -864,15 +820,15 @@ var GroqTranscriptionModel = class {
   }) {
     var _a, _b, _c, _d, _e;
     const warnings = [];
-    const groqOptions = await (0, import_provider_utils5.parseProviderOptions)({
+    const groqOptions = await parseProviderOptions2({
       provider: "groq",
       providerOptions,
       schema: groqTranscriptionModelOptions
     });
     const formData = new FormData();
-    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([(0, import_provider_utils5.convertBase64ToUint8Array)(audio)]);
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
     formData.append("model", this.modelId);
-    const fileExtension = (0, import_provider_utils5.mediaTypeToExtension)(mediaType);
+    const fileExtension = mediaTypeToExtension(mediaType);
     formData.append(
       "file",
       new File([blob], "audio", { type: mediaType }),
@@ -905,22 +861,22 @@ var GroqTranscriptionModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
     const { formData, warnings } = await this.getArgs(options);
     const {
       value: response,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils5.postFormDataToApi)({
+    } = await postFormDataToApi({
       url: this.config.url({
         path: "/audio/transcriptions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2((_e = (_d = this.config).headers) == null ? void 0 : _e.call(_d), options.headers),
       formData,
       failedResponseHandler: groqFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         groqTranscriptionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -928,13 +884,13 @@ var GroqTranscriptionModel = class {
     });
     return {
       text: response.text,
-      segments: (_e = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
+      segments: (_g = (_f = response.segments) == null ? void 0 : _f.map((segment) => ({
         text: segment.text,
         startSecond: segment.start,
         endSecond: segment.end
-      }))) != null ? _e : [],
-      language: (_f = response.language) != null ? _f : void 0,
-      durationInSeconds: (_g = response.duration) != null ? _g : void 0,
+      }))) != null ? _g : [],
+      language: (_h = response.language) != null ? _h : void 0,
+      durationInSeconds: (_i = response.duration) != null ? _i : void 0,
       warnings,
       response: {
         timestamp: currentDate,
@@ -945,37 +901,37 @@ var GroqTranscriptionModel = class {
     };
   }
 };
-var groqTranscriptionResponseSchema = import_v45.z.object({
-  text: import_v45.z.string(),
-  x_groq: import_v45.z.object({
-    id: import_v45.z.string()
+var groqTranscriptionResponseSchema = z5.object({
+  text: z5.string(),
+  x_groq: z5.object({
+    id: z5.string()
   }),
   // additional properties are returned when `response_format: 'verbose_json'` is
-  task: import_v45.z.string().nullish(),
-  language: import_v45.z.string().nullish(),
-  duration: import_v45.z.number().nullish(),
-  segments: import_v45.z.array(
-    import_v45.z.object({
-      id: import_v45.z.number(),
-      seek: import_v45.z.number(),
-      start: import_v45.z.number(),
-      end: import_v45.z.number(),
-      text: import_v45.z.string(),
-      tokens: import_v45.z.array(import_v45.z.number()),
-      temperature: import_v45.z.number(),
-      avg_logprob: import_v45.z.number(),
-      compression_ratio: import_v45.z.number(),
-      no_speech_prob: import_v45.z.number()
+  task: z5.string().nullish(),
+  language: z5.string().nullish(),
+  duration: z5.number().nullish(),
+  segments: z5.array(
+    z5.object({
+      id: z5.number(),
+      seek: z5.number(),
+      start: z5.number(),
+      end: z5.number(),
+      text: z5.string(),
+      tokens: z5.array(z5.number()),
+      temperature: z5.number(),
+      avg_logprob: z5.number(),
+      compression_ratio: z5.number(),
+      no_speech_prob: z5.number()
     })
   ).nullish()
 });
 
 // src/tool/browser-search.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var browserSearch = (0, import_provider_utils6.createProviderToolFactory)({
+import { createProviderToolFactory } from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var browserSearch = createProviderToolFactory({
   id: "groq.browser_search",
-  inputSchema: import_v46.z.object({})
+  inputSchema: z6.object({})
 });
 
 // src/groq-tools.ts
@@ -984,15 +940,15 @@ var groqTools = {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.3" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.30" : "0.0.0-test";
 
 // src/groq-provider.ts
 function createGroq(options = {}) {
   var _a;
-  const baseURL = (_a = (0, import_provider_utils7.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://api.groq.com/openai/v1";
-  const getHeaders = () => (0, import_provider_utils7.withUserAgentSuffix)(
+  const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://api.groq.com/openai/v1";
+  const getHeaders = () => withUserAgentSuffix(
     {
-      Authorization: `Bearer ${(0, import_provider_utils7.loadApiKey)({
+      Authorization: `Bearer ${loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "GROQ_API_KEY",
         description: "Groq"
@@ -1026,15 +982,15 @@ function createGroq(options = {}) {
   const provider = function(modelId) {
     return createLanguageModel(modelId);
   };
-  provider.specificationVersion = "v3";
+  provider.specificationVersion = "v4";
   provider.languageModel = createLanguageModel;
   provider.chat = createChatModel;
   provider.embeddingModel = (modelId) => {
-    throw new import_provider4.NoSuchModelError({ modelId, modelType: "embeddingModel" });
+    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
   };
   provider.textEmbeddingModel = provider.embeddingModel;
   provider.imageModel = (modelId) => {
-    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
   };
   provider.transcription = createTranscriptionModel;
   provider.transcriptionModel = createTranscriptionModel;
@@ -1042,11 +998,10 @@ function createGroq(options = {}) {
   return provider;
 }
 var groq = createGroq();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   VERSION,
   browserSearch,
   createGroq,
   groq
-});
+};
 //# sourceMappingURL=index.js.map