@ai-sdk/groq 4.0.0-beta.5 → 4.0.0-beta.55

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

@@ -1,5 +1,4 @@
-import {
-  InvalidResponseDataError,
+import type {
   LanguageModelV4,
   LanguageModelV4CallOptions,
   LanguageModelV4Content,
@@ -11,28 +10,36 @@ import {
   SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
-  ParseResult,
+  StreamingToolCallTracker,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   generateId,
-  isParsableJson,
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
   parseProviderOptions,
   postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
+  type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { convertGroqUsage } from './convert-groq-usage';
 import { convertToGroqChatMessages } from './convert-to-groq-chat-messages';
 import { getResponseMetadata } from './get-response-metadata';
-import { GroqChatModelId, groqLanguageModelOptions } from './groq-chat-options';
+import {
+  groqLanguageModelChatOptions,
+  type GroqChatModelId,
+} from './groq-chat-language-model-options';
 import { groqErrorDataSchema, groqFailedResponseHandler } from './groq-error';
 import { prepareTools } from './groq-prepare-tools';
 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;
 };
@@ -48,6 +55,20 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
 
   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,19 +89,17 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
     stopSequences,
     responseFormat,
     seed,
-    stream,
+    reasoning,
     tools,
     toolChoice,
     providerOptions,
-  }: LanguageModelV4CallOptions & {
-    stream: boolean;
-  }) {
+  }: LanguageModelV4CallOptions) {
     const warnings: SharedV4Warning[] = [];
 
     const groqOptions = await parseProviderOptions({
       provider: 'groq',
       providerOptions,
-      schema: groqLanguageModelOptions,
+      schema: groqLanguageModelChatOptions,
     });
 
     const structuredOutputs = groqOptions?.structuredOutputs ?? true;
@@ -145,7 +164,21 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
 
         // 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:
@@ -162,10 +195,7 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
   async doGenerate(
     options: LanguageModelV4CallOptions,
   ): Promise<LanguageModelV4GenerateResult> {
-    const { args, warnings } = await this.getArgs({
-      ...options,
-      stream: false,
-    });
+    const { args, warnings } = await this.getArgs(options);
 
     const body = JSON.stringify(args);
 
@@ -178,7 +208,7 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
         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(
@@ -238,20 +268,17 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
   async doStream(
     options: LanguageModelV4CallOptions,
   ): Promise<LanguageModelV4StreamResult> {
-    const { args, warnings } = await this.getArgs({ ...options, stream: true });
+    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,15 +286,7 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
       fetch: this.config.fetch,
     });
 
-    const toolCalls: Array<{
-      id: string;
-      type: 'function';
-      function: {
-        name: string;
-        arguments: string;
-      };
-      hasFinished: boolean;
-    }> = [];
+    let toolCallTracker: StreamingToolCallTracker;
 
     let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
@@ -303,6 +322,10 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
           LanguageModelV4StreamPart
         >({
           start(controller) {
+            toolCallTracker = new StreamingToolCallTracker(controller, {
+              generateId,
+              typeValidation: 'required',
+            });
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
@@ -411,120 +434,7 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
               }
 
               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);
               }
             }
           },
@@ -538,6 +448,8 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
               controller.enqueue({ type: 'text-end', id: 'txt-0' });
             }
 
+            toolCallTracker.flush();
+
             controller.enqueue({
               type: 'finish',
               finishReason,
@@ -547,7 +459,7 @@ export class GroqChatLanguageModel implements LanguageModelV4 {
           },
         }),
       ),
-      request: { body },
+      request: { body: JSON.stringify(body) },
       response: { headers: responseHeaders },
     };
   }

package/src/groq-config.ts

@@ -1,9 +1,9 @@
-import { FetchFunction } from '@ai-sdk/provider-utils';
+import type { 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,13 +1,13 @@
 import {
-  LanguageModelV4CallOptions,
-  SharedV4Warning,
   UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   getSupportedModelsString,
   isBrowserSearchSupportedModel,
 } from './groq-browser-search-models';
-import { GroqChatModelId } from './groq-chat-options';
+import type { GroqChatModelId } from './groq-chat-language-model-options';
 
 export function prepareTools({
   tools,

package/src/groq-provider.ts

@@ -1,18 +1,18 @@
 import {
-  LanguageModelV4,
   NoSuchModelError,
-  ProviderV4,
-  TranscriptionModelV4,
+  type LanguageModelV4,
+  type ProviderV4,
+  type TranscriptionModelV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   loadApiKey,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { GroqChatLanguageModel } from './groq-chat-language-model';
-import { GroqChatModelId } from './groq-chat-options';
-import { GroqTranscriptionModelId } from './groq-transcription-options';
+import type { GroqChatModelId } from './groq-chat-language-model-options';
+import type { GroqTranscriptionModelId } from './groq-transcription-model-options';
 import { GroqTranscriptionModel } from './groq-transcription-model';
 
 import { groqTools } from './groq-tools';

package/src/{groq-transcription-options.ts → groq-transcription-model-options.ts}

@@ -1,4 +1,8 @@
-import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type GroqTranscriptionModelId =

package/src/groq-transcription-model.ts

@@ -1,4 +1,4 @@
-import { TranscriptionModelV4, SharedV4Warning } from '@ai-sdk/provider';
+import type { TranscriptionModelV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertBase64ToUint8Array,
@@ -6,15 +6,18 @@ import {
   mediaTypeToExtension,
   parseProviderOptions,
   postFormDataToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
-import { GroqConfig } from './groq-config';
+import type { GroqConfig } from './groq-config';
 import { groqFailedResponseHandler } from './groq-error';
 import {
-  GroqTranscriptionModelId,
   groqTranscriptionModelOptions,
-} from './groq-transcription-options';
-import { GroqTranscriptionAPITypes } from './groq-api-types';
+  type GroqTranscriptionModelId,
+} from './groq-transcription-model-options';
+import type { GroqTranscriptionAPITypes } from './groq-api-types';
 
 interface GroqTranscriptionModelConfig extends GroqConfig {
   _internal?: {
@@ -29,6 +32,20 @@ export class GroqTranscriptionModel implements TranscriptionModelV4 {
     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,
@@ -115,7 +132,7 @@ export class GroqTranscriptionModel implements TranscriptionModelV4 {
         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/index.ts

@@ -1,10 +1,12 @@
 export { createGroq, groq } from './groq-provider';
 export type { GroqProvider, GroqProviderSettings } from './groq-provider';
 export type {
-  GroqLanguageModelOptions,
-  /** @deprecated Use `GroqLanguageModelOptions` instead. */
-  GroqLanguageModelOptions as GroqProviderOptions,
-} from './groq-chat-options';
-export type { GroqTranscriptionModelOptions } from './groq-transcription-options';
+  GroqLanguageModelChatOptions,
+  /** @deprecated Use `GroqLanguageModelChatOptions` instead. */
+  GroqLanguageModelChatOptions as GroqLanguageModelOptions,
+  /** @deprecated Use `GroqLanguageModelChatOptions` instead. */
+  GroqLanguageModelChatOptions as GroqProviderOptions,
+} from './groq-chat-language-model-options';
+export type { GroqTranscriptionModelOptions } from './groq-transcription-model-options';
 export { browserSearch } from './tool/browser-search';
 export { VERSION } from './version';

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

@@ -1,4 +1,4 @@
-import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
 
 export function mapGroqFinishReason(
   finishReason: string | null | undefined,

package/src/tool/browser-search.ts

@@ -1,4 +1,8 @@
-import { createProviderToolFactory } from '@ai-sdk/provider-utils';
+import {
+  createProviderExecutedToolFactory,
+  lazySchema,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 /**
@@ -13,16 +17,20 @@ import { z } from 'zod/v4';
  *
  * @see https://console.groq.com/docs/browser-search
  */
-export const browserSearch = createProviderToolFactory<
+export const browserSearch = createProviderExecutedToolFactory<
   {
     // Browser search doesn't take input parameters - it's controlled by the prompt
     // The tool is activated automatically when included in the tools array
   },
+  {
+    // Browser search doesn't have any output parameters
+  },
   {
     // No configuration options needed - the tool works automatically
     // when included in the tools array for supported models
   }
 >({
   id: 'groq.browser_search',
-  inputSchema: z.object({}),
+  inputSchema: lazySchema(() => zodSchema(z.object({}))),
+  outputSchema: lazySchema(() => zodSchema(z.object({}))),
 });

package/dist/index.d.mts

@@ -1,112 +0,0 @@
-import { ProviderV4, LanguageModelV4, TranscriptionModelV4 } 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 ProviderV4 {
-    /**
-     * Creates a model for text generation.
-     */
-    (modelId: GroqChatModelId): LanguageModelV4;
-    /**
-     * Creates an Groq chat model for text generation.
-     */
-    languageModel(modelId: GroqChatModelId): LanguageModelV4;
-    /**
-     * Creates a model for transcription.
-     */
-    transcription(modelId: GroqTranscriptionModelId): TranscriptionModelV4;
-    /**
-     * 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 };