@ai-sdk/groq 2.0.0-canary.8 → 2.0.0

package/dist/index.js

@@ -27,12 +27,12 @@ module.exports = __toCommonJS(src_exports);
 
 // src/groq-provider.ts
 var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 
 // src/groq-chat-language-model.ts
 var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_v43 = require("zod/v4");
 
 // src/convert-to-groq-chat-messages.ts
 var import_provider = require("@ai-sdk/provider");
@@ -90,7 +90,7 @@ function convertToGroqChatMessages(prompt) {
                 type: "function",
                 function: {
                   name: part.toolName,
-                  arguments: JSON.stringify(part.args)
+                  arguments: JSON.stringify(part.input)
                 }
               });
               break;
@@ -106,10 +106,23 @@ function convertToGroqChatMessages(prompt) {
       }
       case "tool": {
         for (const toolResponse of content) {
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
           messages.push({
             role: "tool",
             tool_call_id: toolResponse.toolCallId,
-            content: JSON.stringify(toolResponse.result)
+            content: contentValue
           });
         }
         break;
@@ -137,27 +150,33 @@ function getResponseMetadata({
 }
 
 // src/groq-chat-options.ts
-var import_zod = require("zod");
-var groqProviderOptions = import_zod.z.object({
-  reasoningFormat: import_zod.z.enum(["parsed", "raw", "hidden"]).nullish(),
+var import_v4 = require("zod/v4");
+var groqProviderOptions = import_v4.z.object({
+  reasoningFormat: import_v4.z.enum(["parsed", "raw", "hidden"]).optional(),
   /**
    * Whether to enable parallel function calling during tool use. Default to true.
    */
-  parallelToolCalls: import_zod.z.boolean().nullish(),
+  parallelToolCalls: import_v4.z.boolean().optional(),
   /**
    * A unique identifier representing your end-user, which can help OpenAI to
    * monitor and detect abuse. Learn more.
    */
-  user: import_zod.z.string().nullish()
+  user: import_v4.z.string().optional(),
+  /**
+   * Whether to use structured outputs.
+   *
+   * @default true
+   */
+  structuredOutputs: import_v4.z.boolean().optional()
 });
 
 // src/groq-error.ts
-var import_zod2 = require("zod");
+var import_v42 = require("zod/v4");
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var groqErrorDataSchema = import_zod2.z.object({
-  error: import_zod2.z.object({
-    message: import_zod2.z.string(),
-    type: import_zod2.z.string()
+var groqErrorDataSchema = import_v42.z.object({
+  error: import_v42.z.object({
+    message: import_v42.z.string(),
+    type: import_v42.z.string()
   })
 });
 var groqFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
@@ -186,7 +205,7 @@ function prepareTools({
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: tool.parameters
+          parameters: tool.inputSchema
         }
       });
     }
@@ -239,21 +258,18 @@ function mapGroqFinishReason(finishReason) {
 
 // src/groq-chat-language-model.ts
 var GroqChatLanguageModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.specificationVersion = "v2";
-    this.supportsStructuredOutputs = false;
-    this.defaultObjectGenerationMode = "json";
+    this.supportedUrls = {
+      "image/*": [/^https?:\/\/.*$/]
+    };
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
   get provider() {
     return this.config.provider;
   }
-  get supportsImageUrls() {
-    return !this.settings.downloadImages;
-  }
-  getArgs({
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -269,25 +285,27 @@ var GroqChatLanguageModel = class {
     toolChoice,
     providerOptions
   }) {
+    var _a, _b;
     const warnings = [];
+    const groqOptions = await (0, import_provider_utils2.parseProviderOptions)({
+      provider: "groq",
+      providerOptions,
+      schema: groqProviderOptions
+    });
+    const structuredOutputs = (_a = groqOptions == null ? void 0 : groqOptions.structuredOutputs) != null ? _a : true;
     if (topK != null) {
       warnings.push({
         type: "unsupported-setting",
         setting: "topK"
       });
     }
-    if (responseFormat != null && responseFormat.type === "json" && responseFormat.schema != null) {
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !structuredOutputs) {
       warnings.push({
         type: "unsupported-setting",
         setting: "responseFormat",
-        details: "JSON response format schema is not supported"
+        details: "JSON response format schema is only supported with structuredOutputs"
       });
     }
-    const groqOptions = (0, import_provider_utils2.parseProviderOptions)({
-      provider: "groq",
-      providerOptions,
-      schema: groqProviderOptions
-    });
     const {
       tools: groqTools,
       toolChoice: groqToolChoice,
@@ -309,10 +327,14 @@ var GroqChatLanguageModel = class {
         stop: stopSequences,
         seed,
         // response format:
-        response_format: (
-          // json object response format is not supported for streaming:
-          stream === false && (responseFormat == null ? void 0 : responseFormat.type) === "json" ? { type: "json_object" } : void 0
-        ),
+        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && responseFormat.schema != null ? {
+          type: "json_schema",
+          json_schema: {
+            schema: responseFormat.schema,
+            name: (_b = responseFormat.name) != null ? _b : "response",
+            description: responseFormat.description
+          }
+        } : { type: "json_object" } : void 0,
         // provider options:
         reasoning_format: groqOptions == null ? void 0 : groqOptions.reasoningFormat,
         // messages:
@@ -325,8 +347,11 @@ var GroqChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e;
-    const { args, warnings } = this.getArgs({ ...options, stream: false });
+    var _a, _b, _c, _d, _e, _f, _g;
+    const { args, warnings } = await this.getArgs({
+      ...options,
+      stream: false
+    });
     const body = JSON.stringify(args);
     const {
       responseHeaders,
@@ -347,29 +372,35 @@ var GroqChatLanguageModel = class {
       fetch: this.config.fetch
     });
     const choice = response.choices[0];
-    return {
-      text: choice.message.content != null ? { type: "text", text: choice.message.content } : void 0,
-      reasoning: choice.message.reasoning ? [
-        {
-          type: "reasoning",
-          reasoningType: "text",
-          text: choice.message.reasoning
-        }
-      ] : void 0,
-      toolCalls: (_a = choice.message.tool_calls) == null ? void 0 : _a.map((toolCall) => {
-        var _a2;
-        return {
+    const content = [];
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text });
+    }
+    const reasoning = choice.message.reasoning;
+    if (reasoning != null && reasoning.length > 0) {
+      content.push({
+        type: "reasoning",
+        text: reasoning
+      });
+    }
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
           type: "tool-call",
-          toolCallType: "function",
-          toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils2.generateId)(),
+          toolCallId: (_a = toolCall.id) != null ? _a : (0, import_provider_utils2.generateId)(),
           toolName: toolCall.function.name,
-          args: toolCall.function.arguments
-        };
-      }),
+          input: toolCall.function.arguments
+        });
+      }
+    }
+    return {
+      content,
       finishReason: mapGroqFinishReason(choice.finish_reason),
       usage: {
         inputTokens: (_c = (_b = response.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : void 0,
-        outputTokens: (_e = (_d = response.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : void 0
+        outputTokens: (_e = (_d = response.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : void 0,
+        totalTokens: (_g = (_f = response.usage) == null ? void 0 : _f.total_tokens) != null ? _g : void 0
       },
       response: {
         ...getResponseMetadata(response),
@@ -381,7 +412,7 @@ var GroqChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    const { args, warnings } = this.getArgs({ ...options, stream: true });
+    const { args, warnings } = await this.getArgs({ ...options, stream: true });
     const body = JSON.stringify({ ...args, stream: true });
     const { responseHeaders, value: response } = await (0, import_provider_utils2.postJsonToApi)({
       url: this.config.url({
@@ -402,15 +433,24 @@ var GroqChatLanguageModel = class {
     let finishReason = "unknown";
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let isFirstChunk = true;
+    let isActiveText = false;
+    let isActiveReasoning = false;
     let providerMetadata;
     return {
       stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -432,6 +472,7 @@ var GroqChatLanguageModel = class {
             if (((_a = value.x_groq) == null ? void 0 : _a.usage) != null) {
               usage.inputTokens = (_b = value.x_groq.usage.prompt_tokens) != null ? _b : void 0;
               usage.outputTokens = (_c = value.x_groq.usage.completion_tokens) != null ? _c : void 0;
+              usage.totalTokens = (_d = value.x_groq.usage.total_tokens) != null ? _d : void 0;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
@@ -442,16 +483,28 @@ var GroqChatLanguageModel = class {
             }
             const delta = choice.delta;
             if (delta.reasoning != null && delta.reasoning.length > 0) {
+              if (!isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = true;
+              }
               controller.enqueue({
-                type: "reasoning",
-                reasoningType: "text",
-                text: delta.reasoning
+                type: "reasoning-delta",
+                id: "reasoning-0",
+                delta: delta.reasoning
               });
             }
             if (delta.content != null && delta.content.length > 0) {
+              if (!isActiveText) {
+                controller.enqueue({ type: "text-start", id: "txt-0" });
+                isActiveText = true;
+              }
               controller.enqueue({
-                type: "text",
-                text: delta.content
+                type: "text-delta",
+                id: "txt-0",
+                delta: delta.content
               });
             }
             if (delta.tool_calls != null) {
@@ -470,39 +523,45 @@ var GroqChatLanguageModel = class {
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
+                  if (((_e = toolCallDelta.function) == null ? void 0 : _e.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: (_e = toolCallDelta.function.arguments) != null ? _e : ""
+                      arguments: (_f = toolCallDelta.function.arguments) != null ? _f : ""
                     },
                     hasFinished: false
                   };
                   const toolCall2 = toolCalls[index];
-                  if (((_f = toolCall2.function) == null ? void 0 : _f.name) != null && ((_g = toolCall2.function) == null ? void 0 : _g.arguments) != null) {
+                  if (((_g = toolCall2.function) == null ? void 0 : _g.name) != null && ((_h = toolCall2.function) == null ? void 0 : _h.arguments) != null) {
                     if (toolCall2.function.arguments.length > 0) {
                       controller.enqueue({
-                        type: "tool-call-delta",
-                        toolCallType: "function",
-                        toolCallId: toolCall2.id,
-                        toolName: toolCall2.function.name,
-                        argsTextDelta: toolCall2.function.arguments
+                        type: "tool-input-delta",
+                        id: toolCall2.id,
+                        delta: toolCall2.function.arguments
                       });
                     }
                     if ((0, import_provider_utils2.isParsableJson)(toolCall2.function.arguments)) {
+                      controller.enqueue({
+                        type: "tool-input-end",
+                        id: toolCall2.id
+                      });
                       controller.enqueue({
                         type: "tool-call",
-                        toolCallType: "function",
-                        toolCallId: (_h = toolCall2.id) != null ? _h : (0, import_provider_utils2.generateId)(),
+                        toolCallId: (_i = toolCall2.id) != null ? _i : (0, import_provider_utils2.generateId)(),
                         toolName: toolCall2.function.name,
-                        args: toolCall2.function.arguments
+                        input: toolCall2.function.arguments
                       });
                       toolCall2.hasFinished = true;
                     }
@@ -513,23 +572,24 @@ var GroqChatLanguageModel = class {
                 if (toolCall.hasFinished) {
                   continue;
                 }
-                if (((_i = toolCallDelta.function) == null ? void 0 : _i.arguments) != null) {
-                  toolCall.function.arguments += (_k = (_j = toolCallDelta.function) == null ? void 0 : _j.arguments) != null ? _k : "";
+                if (((_j = toolCallDelta.function) == null ? void 0 : _j.arguments) != null) {
+                  toolCall.function.arguments += (_l = (_k = toolCallDelta.function) == null ? void 0 : _k.arguments) != null ? _l : "";
                 }
                 controller.enqueue({
-                  type: "tool-call-delta",
-                  toolCallType: "function",
-                  toolCallId: toolCall.id,
-                  toolName: toolCall.function.name,
-                  argsTextDelta: (_l = toolCallDelta.function.arguments) != null ? _l : ""
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: (_m = toolCallDelta.function.arguments) != null ? _m : ""
                 });
-                if (((_m = toolCall.function) == null ? void 0 : _m.name) != null && ((_n = toolCall.function) == null ? void 0 : _n.arguments) != null && (0, import_provider_utils2.isParsableJson)(toolCall.function.arguments)) {
+                if (((_n = toolCall.function) == null ? void 0 : _n.name) != null && ((_o = toolCall.function) == null ? void 0 : _o.arguments) != null && (0, import_provider_utils2.isParsableJson)(toolCall.function.arguments)) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id
+                  });
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallType: "function",
-                    toolCallId: (_o = toolCall.id) != null ? _o : (0, import_provider_utils2.generateId)(),
+                    toolCallId: (_p = toolCall.id) != null ? _p : (0, import_provider_utils2.generateId)(),
                     toolName: toolCall.function.name,
-                    args: toolCall.function.arguments
+                    input: toolCall.function.arguments
                   });
                   toolCall.hasFinished = true;
                 }
@@ -537,6 +597,12 @@ var GroqChatLanguageModel = class {
             }
           },
           flush(controller) {
+            if (isActiveReasoning) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+            }
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "txt-0" });
+            }
             controller.enqueue({
               type: "finish",
               finishReason,
@@ -546,105 +612,234 @@ var GroqChatLanguageModel = class {
           }
         })
       ),
-      response: { headers: responseHeaders },
-      warnings,
-      request: { body }
+      request: { body },
+      response: { headers: responseHeaders }
     };
   }
 };
-var groqChatResponseSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  created: import_zod3.z.number().nullish(),
-  model: import_zod3.z.string().nullish(),
-  choices: import_zod3.z.array(
-    import_zod3.z.object({
-      message: import_zod3.z.object({
-        content: import_zod3.z.string().nullish(),
-        reasoning: import_zod3.z.string().nullish(),
-        tool_calls: import_zod3.z.array(
-          import_zod3.z.object({
-            id: import_zod3.z.string().nullish(),
-            type: import_zod3.z.literal("function"),
-            function: import_zod3.z.object({
-              name: import_zod3.z.string(),
-              arguments: import_zod3.z.string()
+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()
             })
           })
         ).nullish()
       }),
-      index: import_zod3.z.number(),
-      finish_reason: import_zod3.z.string().nullish()
+      index: import_v43.z.number(),
+      finish_reason: import_v43.z.string().nullish()
     })
   ),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number().nullish(),
-    completion_tokens: import_zod3.z.number().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()
   }).nullish()
 });
-var groqChatChunkSchema = import_zod3.z.union([
-  import_zod3.z.object({
-    id: import_zod3.z.string().nullish(),
-    created: import_zod3.z.number().nullish(),
-    model: import_zod3.z.string().nullish(),
-    choices: import_zod3.z.array(
-      import_zod3.z.object({
-        delta: import_zod3.z.object({
-          content: import_zod3.z.string().nullish(),
-          reasoning: import_zod3.z.string().nullish(),
-          tool_calls: import_zod3.z.array(
-            import_zod3.z.object({
-              index: import_zod3.z.number(),
-              id: import_zod3.z.string().nullish(),
-              type: import_zod3.z.literal("function").optional(),
-              function: import_zod3.z.object({
-                name: import_zod3.z.string().nullish(),
-                arguments: import_zod3.z.string().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()
               })
             })
           ).nullish()
         }).nullish(),
-        finish_reason: import_zod3.z.string().nullable().optional(),
-        index: import_zod3.z.number()
+        finish_reason: import_v43.z.string().nullable().optional(),
+        index: import_v43.z.number()
       })
     ),
-    x_groq: import_zod3.z.object({
-      usage: import_zod3.z.object({
-        prompt_tokens: import_zod3.z.number().nullish(),
-        completion_tokens: import_zod3.z.number().nullish()
+    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()
       }).nullish()
     }).nullish()
   }),
   groqErrorDataSchema
 ]);
 
+// src/groq-transcription-model.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_v44 = require("zod/v4");
+var groqProviderOptionsSchema = 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()
+});
+var GroqTranscriptionModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v2";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    audio,
+    mediaType,
+    providerOptions
+  }) {
+    var _a, _b, _c, _d, _e;
+    const warnings = [];
+    const groqOptions = await (0, import_provider_utils3.parseProviderOptions)({
+      provider: "groq",
+      providerOptions,
+      schema: groqProviderOptionsSchema
+    });
+    const formData = new FormData();
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([(0, import_provider_utils3.convertBase64ToUint8Array)(audio)]);
+    formData.append("model", this.modelId);
+    formData.append("file", new File([blob], "audio", { type: mediaType }));
+    if (groqOptions) {
+      const transcriptionModelOptions = {
+        language: (_a = groqOptions.language) != null ? _a : void 0,
+        prompt: (_b = groqOptions.prompt) != null ? _b : void 0,
+        response_format: (_c = groqOptions.responseFormat) != null ? _c : void 0,
+        temperature: (_d = groqOptions.temperature) != null ? _d : void 0,
+        timestamp_granularities: (_e = groqOptions.timestampGranularities) != null ? _e : void 0
+      };
+      for (const key in transcriptionModelOptions) {
+        const value = transcriptionModelOptions[key];
+        if (value !== void 0) {
+          formData.append(key, String(value));
+        }
+      }
+    }
+    return {
+      formData,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e;
+    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_utils3.postFormDataToApi)({
+      url: this.config.url({
+        path: "/audio/transcriptions",
+        modelId: this.modelId
+      }),
+      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: groqFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+        groqTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      text: response.text,
+      segments: (_e = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
+        text: segment.text,
+        startSecond: segment.start,
+        endSecond: segment.end
+      }))) != null ? _e : [],
+      language: response.language,
+      durationInSeconds: response.duration,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+var groqTranscriptionResponseSchema = import_v44.z.object({
+  task: import_v44.z.string(),
+  language: import_v44.z.string(),
+  duration: import_v44.z.number(),
+  text: import_v44.z.string(),
+  segments: import_v44.z.array(
+    import_v44.z.object({
+      id: import_v44.z.number(),
+      seek: import_v44.z.number(),
+      start: import_v44.z.number(),
+      end: import_v44.z.number(),
+      text: import_v44.z.string(),
+      tokens: import_v44.z.array(import_v44.z.number()),
+      temperature: import_v44.z.number(),
+      avg_logprob: import_v44.z.number(),
+      compression_ratio: import_v44.z.number(),
+      no_speech_prob: import_v44.z.number()
+    })
+  ),
+  x_groq: import_v44.z.object({
+    id: import_v44.z.string()
+  })
+});
+
 // src/groq-provider.ts
 function createGroq(options = {}) {
   var _a;
-  const baseURL = (_a = (0, import_provider_utils3.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://api.groq.com/openai/v1";
+  const baseURL = (_a = (0, import_provider_utils4.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://api.groq.com/openai/v1";
   const getHeaders = () => ({
-    Authorization: `Bearer ${(0, import_provider_utils3.loadApiKey)({
+    Authorization: `Bearer ${(0, import_provider_utils4.loadApiKey)({
       apiKey: options.apiKey,
       environmentVariableName: "GROQ_API_KEY",
       description: "Groq"
     })}`,
     ...options.headers
   });
-  const createChatModel = (modelId, settings = {}) => new GroqChatLanguageModel(modelId, settings, {
+  const createChatModel = (modelId) => new GroqChatLanguageModel(modelId, {
     provider: "groq.chat",
     url: ({ path }) => `${baseURL}${path}`,
     headers: getHeaders,
     fetch: options.fetch
   });
-  const createLanguageModel = (modelId, settings) => {
+  const createLanguageModel = (modelId) => {
     if (new.target) {
       throw new Error(
         "The Groq model function cannot be called with the new keyword."
       );
     }
-    return createChatModel(modelId, settings);
+    return createChatModel(modelId);
+  };
+  const createTranscriptionModel = (modelId) => {
+    return new GroqTranscriptionModel(modelId, {
+      provider: "groq.transcription",
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch
+    });
   };
-  const provider = function(modelId, settings) {
-    return createLanguageModel(modelId, settings);
+  const provider = function(modelId) {
+    return createLanguageModel(modelId);
   };
   provider.languageModel = createLanguageModel;
   provider.chat = createChatModel;
@@ -654,6 +849,7 @@ function createGroq(options = {}) {
   provider.imageModel = (modelId) => {
     throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
   };
+  provider.transcription = createTranscriptionModel;
   return provider;
 }
 var groq = createGroq();