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

package/src/groq-chat-language-model.ts

@@ -1,25 +1,29 @@
 import {
-  InvalidResponseDataError,
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  LanguageModelV3Content,
-  LanguageModelV3FinishReason,
-  LanguageModelV3GenerateResult,
-  LanguageModelV3StreamPart,
-  LanguageModelV3StreamResult,
-  SharedV3ProviderMetadata,
-  SharedV3Warning,
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4Content,
+  LanguageModelV4FinishReason,
+  LanguageModelV4GenerateResult,
+  LanguageModelV4StreamPart,
+  LanguageModelV4StreamResult,
+  SharedV4ProviderMetadata,
+  SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   FetchFunction,
   ParseResult,
+  StreamingToolCallTracker,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   generateId,
-  isParsableJson,
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
   parseProviderOptions,
   postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { convertGroqUsage } from './convert-groq-usage';
@@ -32,13 +36,13 @@ import { mapGroqFinishReason } from './map-groq-finish-reason';
 
 type GroqChatConfig = {
   provider: string;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   url: (options: { modelId: string; path: string }) => string;
   fetch?: FetchFunction;
 };
 
-export class GroqChatLanguageModel implements LanguageModelV3 {
-  readonly specificationVersion = 'v3';
+export class GroqChatLanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
 
   readonly modelId: GroqChatModelId;
 
@@ -48,6 +52,20 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
 
   private readonly config: GroqChatConfig;
 
+  static [WORKFLOW_SERIALIZE](model: GroqChatLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: GroqChatModelId;
+    config: GroqChatConfig;
+  }) {
+    return new GroqChatLanguageModel(options.modelId, options.config);
+  }
+
   constructor(modelId: GroqChatModelId, config: GroqChatConfig) {
     this.modelId = modelId;
     this.config = config;
@@ -68,14 +86,12 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
     stopSequences,
     responseFormat,
     seed,
-    stream,
+    reasoning,
     tools,
     toolChoice,
     providerOptions,
-  }: LanguageModelV3CallOptions & {
-    stream: boolean;
-  }) {
-    const warnings: SharedV3Warning[] = [];
+  }: LanguageModelV4CallOptions) {
+    const warnings: SharedV4Warning[] = [];
 
     const groqOptions = await parseProviderOptions({
       provider: 'groq',
@@ -145,7 +161,21 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
 
         // provider options:
         reasoning_format: groqOptions?.reasoningFormat,
-        reasoning_effort: groqOptions?.reasoningEffort,
+        reasoning_effort:
+          groqOptions?.reasoningEffort ??
+          (isCustomReasoning(reasoning) && reasoning !== 'none'
+            ? mapReasoningToProviderEffort({
+                reasoning,
+                effortMap: {
+                  minimal: 'low',
+                  low: 'low',
+                  medium: 'medium',
+                  high: 'high',
+                  xhigh: 'high',
+                },
+                warnings,
+              })
+            : undefined),
         service_tier: groqOptions?.serviceTier,
 
         // messages:
@@ -160,12 +190,9 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
   }
 
   async doGenerate(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3GenerateResult> {
-    const { args, warnings } = await this.getArgs({
-      ...options,
-      stream: false,
-    });
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4GenerateResult> {
+    const { args, warnings } = await this.getArgs(options);
 
     const body = JSON.stringify(args);
 
@@ -178,7 +205,7 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
         path: '/chat/completions',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body: args,
       failedResponseHandler: groqFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -189,7 +216,7 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
     });
 
     const choice = response.choices[0];
-    const content: Array<LanguageModelV3Content> = [];
+    const content: Array<LanguageModelV4Content> = [];
 
     // text content:
     const text = choice.message.content;
@@ -236,22 +263,19 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
   }
 
   async doStream(
-    options: LanguageModelV3CallOptions,
-  ): Promise<LanguageModelV3StreamResult> {
-    const { args, warnings } = await this.getArgs({ ...options, stream: true });
+    options: LanguageModelV4CallOptions,
+  ): Promise<LanguageModelV4StreamResult> {
+    const { args, warnings } = await this.getArgs(options);
 
-    const body = JSON.stringify({ ...args, stream: true });
+    const body = { ...args, stream: true };
 
     const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: '/chat/completions',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers(), options.headers),
-      body: {
-        ...args,
-        stream: true,
-      },
+      headers: combineHeaders(this.config.headers?.(), options.headers),
+      body,
       failedResponseHandler: groqFailedResponseHandler,
       successfulResponseHandler:
         createEventSourceResponseHandler(groqChatChunkSchema),
@@ -259,17 +283,12 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
-    const toolCalls: Array<{
-      id: string;
-      type: 'function';
-      function: {
-        name: string;
-        arguments: string;
-      };
-      hasFinished: boolean;
-    }> = [];
-
-    let finishReason: LanguageModelV3FinishReason = {
+    const toolCallTracker = new StreamingToolCallTracker({
+      generateId,
+      typeValidation: 'required',
+    });
+
+    let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
       raw: undefined,
     };
@@ -295,12 +314,12 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
     let isActiveText = false;
     let isActiveReasoning = false;
 
-    let providerMetadata: SharedV3ProviderMetadata | undefined;
+    let providerMetadata: SharedV4ProviderMetadata | undefined;
     return {
       stream: response.pipeThrough(
         new TransformStream<
           ParseResult<z.infer<typeof groqChatChunkSchema>>,
-          LanguageModelV3StreamPart
+          LanguageModelV4StreamPart
         >({
           start(controller) {
             controller.enqueue({ type: 'stream-start', warnings });
@@ -411,120 +430,10 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
               }
 
               for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index;
-
-                if (toolCalls[index] == null) {
-                  if (toolCallDelta.type !== 'function') {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function' type.`,
-                    });
-                  }
-
-                  if (toolCallDelta.id == null) {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'id' to be a string.`,
-                    });
-                  }
-
-                  if (toolCallDelta.function?.name == null) {
-                    throw new 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: toolCallDelta.function.arguments ?? '',
-                    },
-                    hasFinished: false,
-                  };
-
-                  const toolCall = toolCalls[index];
-
-                  if (
-                    toolCall.function?.name != null &&
-                    toolCall.function?.arguments != null
-                  ) {
-                    // send delta if the argument text has already started:
-                    if (toolCall.function.arguments.length > 0) {
-                      controller.enqueue({
-                        type: 'tool-input-delta',
-                        id: toolCall.id,
-                        delta: toolCall.function.arguments,
-                      });
-                    }
-
-                    // check if tool call is complete
-                    // (some providers send the full tool call in one chunk):
-                    if (isParsableJson(toolCall.function.arguments)) {
-                      controller.enqueue({
-                        type: 'tool-input-end',
-                        id: toolCall.id,
-                      });
-
-                      controller.enqueue({
-                        type: 'tool-call',
-                        toolCallId: toolCall.id ?? generateId(),
-                        toolName: toolCall.function.name,
-                        input: toolCall.function.arguments,
-                      });
-                      toolCall.hasFinished = true;
-                    }
-                  }
-
-                  continue;
-                }
-
-                // existing tool call, merge if not finished
-                const toolCall = toolCalls[index];
-
-                if (toolCall.hasFinished) {
-                  continue;
-                }
-
-                if (toolCallDelta.function?.arguments != null) {
-                  toolCall.function!.arguments +=
-                    toolCallDelta.function?.arguments ?? '';
-                }
-
-                // send delta
-                controller.enqueue({
-                  type: 'tool-input-delta',
-                  id: toolCall.id,
-                  delta: toolCallDelta.function.arguments ?? '',
-                });
-
-                // check if tool call is complete
-                if (
-                  toolCall.function?.name != null &&
-                  toolCall.function?.arguments != null &&
-                  isParsableJson(toolCall.function.arguments)
-                ) {
-                  controller.enqueue({
-                    type: 'tool-input-end',
-                    id: toolCall.id,
-                  });
-
-                  controller.enqueue({
-                    type: 'tool-call',
-                    toolCallId: toolCall.id ?? generateId(),
-                    toolName: toolCall.function.name,
-                    input: toolCall.function.arguments,
-                  });
-                  toolCall.hasFinished = true;
-                }
+                toolCallTracker.processDelta(
+                  toolCallDelta,
+                  controller.enqueue.bind(controller),
+                );
               }
             }
           },
@@ -538,6 +447,8 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
               controller.enqueue({ type: 'text-end', id: 'txt-0' });
             }
 
+            toolCallTracker.flush(controller.enqueue.bind(controller));
+
             controller.enqueue({
               type: 'finish',
               finishReason,
@@ -547,7 +458,7 @@ export class GroqChatLanguageModel implements LanguageModelV3 {
           },
         }),
       ),
-      request: { body },
+      request: { body: JSON.stringify(body) },
       response: { headers: responseHeaders },
     };
   }

package/src/groq-chat-options.ts

@@ -67,12 +67,13 @@ export const groqLanguageModelOptions = z.object({
   /**
    * 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: z.enum(['on_demand', 'flex', 'auto']).optional(),
+  serviceTier: z.enum(['on_demand', 'performance', 'flex', 'auto']).optional(),
 });
 
 export type GroqLanguageModelOptions = z.infer<typeof groqLanguageModelOptions>;

package/src/groq-config.ts

@@ -3,7 +3,7 @@ import { FetchFunction } from '@ai-sdk/provider-utils';
 export type GroqConfig = {
   provider: string;
   url: (options: { modelId: string; path: string }) => string;
-  headers: () => Record<string, string | undefined>;
+  headers?: () => Record<string, string | undefined>;
   fetch?: FetchFunction;
   generateId?: () => string;
 };

package/src/groq-prepare-tools.ts

@@ -1,6 +1,6 @@
 import {
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
 import {
@@ -14,8 +14,8 @@ export function prepareTools({
   toolChoice,
   modelId,
 }: {
-  tools: LanguageModelV3CallOptions['tools'];
-  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice?: LanguageModelV4CallOptions['toolChoice'];
   modelId: GroqChatModelId;
 }): {
   tools:
@@ -40,12 +40,12 @@ export function prepareTools({
     | 'none'
     | 'required'
     | undefined;
-  toolWarnings: SharedV3Warning[];
+  toolWarnings: SharedV4Warning[];
 } {
   // when the tools array is empty, change it to undefined to prevent errors:
   tools = tools?.length ? tools : undefined;
 
-  const toolWarnings: SharedV3Warning[] = [];
+  const toolWarnings: SharedV4Warning[] = [];
 
   if (tools == null) {
     return { tools: undefined, toolChoice: undefined, toolWarnings };

package/src/groq-provider.ts

@@ -1,8 +1,8 @@
 import {
-  LanguageModelV3,
+  LanguageModelV4,
   NoSuchModelError,
-  ProviderV3,
-  TranscriptionModelV3,
+  ProviderV4,
+  TranscriptionModelV4,
 } from '@ai-sdk/provider';
 import {
   FetchFunction,
@@ -17,21 +17,21 @@ import { GroqTranscriptionModel } from './groq-transcription-model';
 
 import { groqTools } from './groq-tools';
 import { VERSION } from './version';
-export interface GroqProvider extends ProviderV3 {
+export interface GroqProvider extends ProviderV4 {
   /**
    * Creates a model for text generation.
    */
-  (modelId: GroqChatModelId): LanguageModelV3;
+  (modelId: GroqChatModelId): LanguageModelV4;
 
   /**
    * Creates an Groq chat model for text generation.
    */
-  languageModel(modelId: GroqChatModelId): LanguageModelV3;
+  languageModel(modelId: GroqChatModelId): LanguageModelV4;
 
   /**
    * Creates a model for transcription.
    */
-  transcription(modelId: GroqTranscriptionModelId): TranscriptionModelV3;
+  transcription(modelId: GroqTranscriptionModelId): TranscriptionModelV4;
 
   /**
    * Tools provided by Groq.
@@ -118,7 +118,7 @@ export function createGroq(options: GroqProviderSettings = {}): GroqProvider {
     return createLanguageModel(modelId);
   };
 
-  provider.specificationVersion = 'v3' as const;
+  provider.specificationVersion = 'v4' as const;
   provider.languageModel = createLanguageModel;
   provider.chat = createChatModel;
 

package/src/groq-transcription-model.ts

@@ -1,4 +1,4 @@
-import { TranscriptionModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import { TranscriptionModelV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertBase64ToUint8Array,
@@ -6,6 +6,9 @@ import {
   mediaTypeToExtension,
   parseProviderOptions,
   postFormDataToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { GroqConfig } from './groq-config';
@@ -22,13 +25,27 @@ interface GroqTranscriptionModelConfig extends GroqConfig {
   };
 }
 
-export class GroqTranscriptionModel implements TranscriptionModelV3 {
-  readonly specificationVersion = 'v3';
+export class GroqTranscriptionModel implements TranscriptionModelV4 {
+  readonly specificationVersion = 'v4';
 
   get provider(): string {
     return this.config.provider;
   }
 
+  static [WORKFLOW_SERIALIZE](model: GroqTranscriptionModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: GroqTranscriptionModelId;
+    config: GroqTranscriptionModelConfig;
+  }) {
+    return new GroqTranscriptionModel(options.modelId, options.config);
+  }
+
   constructor(
     readonly modelId: GroqTranscriptionModelId,
     private readonly config: GroqTranscriptionModelConfig,
@@ -38,8 +55,8 @@ export class GroqTranscriptionModel implements TranscriptionModelV3 {
     audio,
     mediaType,
     providerOptions,
-  }: Parameters<TranscriptionModelV3['doGenerate']>[0]) {
-    const warnings: SharedV3Warning[] = [];
+  }: Parameters<TranscriptionModelV4['doGenerate']>[0]) {
+    const warnings: SharedV4Warning[] = [];
 
     // Parse provider options
     const groqOptions = await parseProviderOptions({
@@ -101,8 +118,8 @@ export class GroqTranscriptionModel implements TranscriptionModelV3 {
   }
 
   async doGenerate(
-    options: Parameters<TranscriptionModelV3['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>> {
+    options: Parameters<TranscriptionModelV4['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<TranscriptionModelV4['doGenerate']>>> {
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
     const { formData, warnings } = await this.getArgs(options);
 
@@ -115,7 +132,7 @@ export class GroqTranscriptionModel implements TranscriptionModelV3 {
         path: '/audio/transcriptions',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       formData,
       failedResponseHandler: groqFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(

package/src/map-groq-finish-reason.ts

@@ -1,8 +1,8 @@
-import { LanguageModelV3FinishReason } from '@ai-sdk/provider';
+import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 export function mapGroqFinishReason(
   finishReason: string | null | undefined,
-): LanguageModelV3FinishReason['unified'] {
+): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {
     case 'stop':
       return 'stop';

package/dist/index.d.mts

@@ -1,112 +0,0 @@
-import { ProviderV3, LanguageModelV3, TranscriptionModelV3 } from '@ai-sdk/provider';
-import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { InferSchema, FetchFunction } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
-
-type GroqChatModelId = 'gemma2-9b-it' | 'llama-3.1-8b-instant' | 'llama-3.3-70b-versatile' | 'meta-llama/llama-guard-4-12b' | 'openai/gpt-oss-120b' | 'openai/gpt-oss-20b' | 'deepseek-r1-distill-llama-70b' | 'meta-llama/llama-4-maverick-17b-128e-instruct' | 'meta-llama/llama-4-scout-17b-16e-instruct' | 'meta-llama/llama-prompt-guard-2-22m' | 'meta-llama/llama-prompt-guard-2-86m' | 'moonshotai/kimi-k2-instruct-0905' | 'qwen/qwen3-32b' | 'llama-guard-3-8b' | 'llama3-70b-8192' | 'llama3-8b-8192' | 'mixtral-8x7b-32768' | 'qwen-qwq-32b' | 'qwen-2.5-32b' | 'deepseek-r1-distill-qwen-32b' | (string & {});
-declare const groqLanguageModelOptions: z.ZodObject<{
-    reasoningFormat: z.ZodOptional<z.ZodEnum<{
-        parsed: "parsed";
-        raw: "raw";
-        hidden: "hidden";
-    }>>;
-    reasoningEffort: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        default: "default";
-        low: "low";
-        medium: "medium";
-        high: "high";
-    }>>;
-    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
-    structuredOutputs: z.ZodOptional<z.ZodBoolean>;
-    strictJsonSchema: z.ZodOptional<z.ZodBoolean>;
-    serviceTier: z.ZodOptional<z.ZodEnum<{
-        on_demand: "on_demand";
-        flex: "flex";
-        auto: "auto";
-    }>>;
-}, z.core.$strip>;
-type GroqLanguageModelOptions = z.infer<typeof groqLanguageModelOptions>;
-
-type GroqTranscriptionModelId = 'whisper-large-v3-turbo' | 'whisper-large-v3' | (string & {});
-declare const groqTranscriptionModelOptions: _ai_sdk_provider_utils.LazySchema<{
-    language?: string | null | undefined;
-    prompt?: string | null | undefined;
-    responseFormat?: string | null | undefined;
-    temperature?: number | null | undefined;
-    timestampGranularities?: string[] | null | undefined;
-}>;
-type GroqTranscriptionModelOptions = InferSchema<typeof groqTranscriptionModelOptions>;
-
-declare const groqTools: {
-    browserSearch: _ai_sdk_provider_utils.ProviderToolFactory<{}, {}>;
-};
-
-interface GroqProvider extends ProviderV3 {
-    /**
-     * Creates a model for text generation.
-     */
-    (modelId: GroqChatModelId): LanguageModelV3;
-    /**
-     * Creates an Groq chat model for text generation.
-     */
-    languageModel(modelId: GroqChatModelId): LanguageModelV3;
-    /**
-     * Creates a model for transcription.
-     */
-    transcription(modelId: GroqTranscriptionModelId): TranscriptionModelV3;
-    /**
-     * Tools provided by Groq.
-     */
-    tools: typeof groqTools;
-    /**
-     * @deprecated Use `embeddingModel` instead.
-     */
-    textEmbeddingModel(modelId: string): never;
-}
-interface GroqProviderSettings {
-    /**
-     * Base URL for the Groq API calls.
-     */
-    baseURL?: string;
-    /**
-     * API key for authenticating requests.
-     */
-    apiKey?: string;
-    /**
-     * Custom headers to include in the requests.
-     */
-    headers?: Record<string, string>;
-    /**
-     * Custom fetch implementation. You can use it as a middleware to intercept requests,
-     * or to provide a custom fetch implementation for e.g. testing.
-     */
-    fetch?: FetchFunction;
-}
-/**
- * Create an Groq provider instance.
- */
-declare function createGroq(options?: GroqProviderSettings): GroqProvider;
-/**
- * Default Groq provider instance.
- */
-declare const groq: GroqProvider;
-
-/**
- * Browser search tool for Groq models.
- *
- * Provides interactive browser search capabilities that go beyond traditional web search
- * by navigating websites interactively and providing more detailed results.
- *
- * Currently supported on:
- * - openai/gpt-oss-20b
- * - openai/gpt-oss-120b
- *
- * @see https://console.groq.com/docs/browser-search
- */
-declare const browserSearch: _ai_sdk_provider_utils.ProviderToolFactory<{}, {}>;
-
-declare const VERSION: string;
-
-export { type GroqLanguageModelOptions, type GroqProvider, type GroqLanguageModelOptions as GroqProviderOptions, type GroqProviderSettings, type GroqTranscriptionModelOptions, VERSION, browserSearch, createGroq, groq };