@ai-sdk/groq 3.0.14 → 3.0.15

package/src/groq-chat-options.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { groqProviderOptions, GroqProviderOptions } from './groq-chat-options';
-
-describe('groqProviderOptions', () => {
-  describe('reasoningEffort', () => {
-    it('accepts valid reasoningEffort values', () => {
-      const validValues = ['none', 'default', 'low', 'medium', 'high'] as const;
-
-      validValues.forEach(value => {
-        const result = groqProviderOptions.safeParse({
-          reasoningEffort: value,
-        });
-        expect(result.success).toBe(true);
-        expect(result.data?.reasoningEffort).toBe(value);
-      });
-    });
-
-    it('rejects invalid reasoningEffort values', () => {
-      const invalidValues = [
-        'invalid',
-        'high-effort',
-        'minimal',
-        'maximum',
-        '',
-      ];
-
-      invalidValues.forEach(value => {
-        const result = groqProviderOptions.safeParse({
-          reasoningEffort: value,
-        });
-        expect(result.success).toBe(false);
-      });
-    });
-
-    it('allows reasoningEffort to be undefined', () => {
-      const result = groqProviderOptions.safeParse({});
-      expect(result.success).toBe(true);
-      expect(result.data?.reasoningEffort).toBeUndefined();
-    });
-
-    it('allows reasoningEffort to be omitted explicitly', () => {
-      const result = groqProviderOptions.safeParse({
-        reasoningEffort: undefined,
-      });
-      expect(result.success).toBe(true);
-      expect(result.data?.reasoningEffort).toBeUndefined();
-    });
-  });
-
-  describe('combined options with reasoningEffort', () => {
-    it('accepts reasoningEffort with other valid options', () => {
-      const result = groqProviderOptions.safeParse({
-        reasoningEffort: 'high',
-        parallelToolCalls: true,
-        user: 'test-user',
-        structuredOutputs: false,
-        serviceTier: 'flex',
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.data?.reasoningEffort).toBe('high');
-      expect(result.data?.parallelToolCalls).toBe(true);
-      expect(result.data?.user).toBe('test-user');
-    });
-
-    it('rejects when reasoningEffort is invalid among valid options', () => {
-      const result = groqProviderOptions.safeParse({
-        reasoningEffort: 'ultra-high',
-        parallelToolCalls: true,
-        user: 'test-user',
-      });
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('all reasoningEffort enum variants', () => {
-    it('validates all reasoningEffort variants individually', () => {
-      const variants: Array<'none' | 'default' | 'low' | 'medium' | 'high'> = [
-        'none',
-        'default',
-        'low',
-        'medium',
-        'high',
-      ];
-
-      variants.forEach(variant => {
-        const result = groqProviderOptions.safeParse({
-          reasoningEffort: variant,
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-          expect(result.data.reasoningEffort).toBe(variant);
-        }
-      });
-    });
-  });
-
-  describe('type inference', () => {
-    it('infers GroqProviderOptions type correctly', () => {
-      const options: GroqProviderOptions = {
-        reasoningEffort: 'medium',
-        parallelToolCalls: false,
-      };
-
-      expect(options.reasoningEffort).toBe('medium');
-      expect(options.parallelToolCalls).toBe(false);
-    });
-  });
-});

package/src/groq-prepare-tools.test.ts

@@ -1,272 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { prepareTools } from './groq-prepare-tools';
-
-describe('prepareTools', () => {
-  it('should return undefined tools and toolChoice when tools are null', () => {
-    const result = prepareTools({
-      tools: undefined,
-      modelId: 'gemma2-9b-it',
-    });
-
-    expect(result).toEqual({
-      tools: undefined,
-      toolChoice: undefined,
-      toolWarnings: [],
-    });
-  });
-
-  it('should return undefined tools and toolChoice when tools are empty', () => {
-    const result = prepareTools({
-      tools: [],
-      modelId: 'gemma2-9b-it',
-    });
-
-    expect(result).toEqual({
-      tools: undefined,
-      toolChoice: undefined,
-      toolWarnings: [],
-    });
-  });
-
-  it('should correctly prepare function tools', () => {
-    const result = prepareTools({
-      tools: [
-        {
-          type: 'function',
-          name: 'testFunction',
-          description: 'A test function',
-          inputSchema: { type: 'object', properties: {} },
-        },
-      ],
-      modelId: 'gemma2-9b-it',
-    });
-
-    expect(result.tools).toEqual([
-      {
-        type: 'function',
-        function: {
-          name: 'testFunction',
-          description: 'A test function',
-          parameters: { type: 'object', properties: {} },
-        },
-      },
-    ]);
-    expect(result.toolChoice).toBeUndefined();
-    expect(result.toolWarnings).toEqual([]);
-  });
-
-  it('should add warnings for unsupported provider-defined tools', () => {
-    const result = prepareTools({
-      tools: [
-        {
-          type: 'provider',
-          id: 'some.unsupported_tool',
-          name: 'unsupported_tool',
-          args: {},
-        },
-      ],
-      modelId: 'gemma2-9b-it',
-    });
-
-    expect(result.tools).toEqual([]);
-    expect(result.toolChoice).toBeUndefined();
-    expect(result.toolWarnings).toMatchInlineSnapshot(`
-      [
-        {
-          "feature": "provider-defined tool some.unsupported_tool",
-          "type": "unsupported",
-        },
-      ]
-    `);
-  });
-
-  it('should handle tool choice "auto"', () => {
-    const result = prepareTools({
-      tools: [
-        {
-          type: 'function',
-          name: 'testFunction',
-          description: 'Test',
-          inputSchema: {},
-        },
-      ],
-      toolChoice: { type: 'auto' },
-      modelId: 'gemma2-9b-it',
-    });
-    expect(result.toolChoice).toEqual('auto');
-  });
-
-  it('should handle tool choice "required"', () => {
-    const result = prepareTools({
-      tools: [
-        {
-          type: 'function',
-          name: 'testFunction',
-          description: 'Test',
-          inputSchema: {},
-        },
-      ],
-      toolChoice: { type: 'required' },
-      modelId: 'gemma2-9b-it',
-    });
-    expect(result.toolChoice).toEqual('required');
-  });
-
-  it('should handle tool choice "none"', () => {
-    const result = prepareTools({
-      tools: [
-        {
-          type: 'function',
-          name: 'testFunction',
-          description: 'Test',
-          inputSchema: {},
-        },
-      ],
-      toolChoice: { type: 'none' },
-      modelId: 'gemma2-9b-it',
-    });
-    expect(result.toolChoice).toEqual('none');
-  });
-
-  it('should handle tool choice "tool"', () => {
-    const result = prepareTools({
-      tools: [
-        {
-          type: 'function',
-          name: 'testFunction',
-          description: 'Test',
-          inputSchema: {},
-        },
-      ],
-      toolChoice: { type: 'tool', toolName: 'testFunction' },
-      modelId: 'gemma2-9b-it',
-    });
-    expect(result.toolChoice).toEqual({
-      type: 'function',
-      function: { name: 'testFunction' },
-    });
-  });
-
-  describe('browser search tool', () => {
-    it('should handle browser search tool with supported model', () => {
-      const result = prepareTools({
-        tools: [
-          {
-            type: 'provider',
-            id: 'groq.browser_search',
-            name: 'browser_search',
-            args: {},
-          },
-        ],
-        modelId: 'openai/gpt-oss-120b', // Supported model
-      });
-
-      expect(result.tools).toEqual([
-        {
-          type: 'browser_search',
-        },
-      ]);
-      expect(result.toolWarnings).toEqual([]);
-    });
-
-    it('should warn when browser search is used with unsupported model', () => {
-      const result = prepareTools({
-        tools: [
-          {
-            type: 'provider',
-            id: 'groq.browser_search',
-            name: 'browser_search',
-            args: {},
-          },
-        ],
-        modelId: 'gemma2-9b-it', // Unsupported model
-      });
-
-      expect(result.tools).toEqual([]);
-      expect(result.toolWarnings).toMatchInlineSnapshot(`
-        [
-          {
-            "details": "Browser search is only supported on the following models: openai/gpt-oss-20b, openai/gpt-oss-120b. Current model: gemma2-9b-it",
-            "feature": "provider-defined tool groq.browser_search",
-            "type": "unsupported",
-          },
-        ]
-      `);
-    });
-
-    it('should handle mixed tools with model validation', () => {
-      const result = prepareTools({
-        tools: [
-          {
-            type: 'function',
-            name: 'test-tool',
-            description: 'A test tool',
-            inputSchema: { type: 'object', properties: {} },
-          },
-          {
-            type: 'provider',
-            id: 'groq.browser_search',
-            name: 'browser_search',
-            args: {},
-          },
-        ],
-        modelId: 'openai/gpt-oss-20b', // Supported model
-      });
-
-      expect(result.tools).toEqual([
-        {
-          type: 'function',
-          function: {
-            name: 'test-tool',
-            description: 'A test tool',
-            parameters: { type: 'object', properties: {} },
-          },
-        },
-        {
-          type: 'browser_search',
-        },
-      ]);
-      expect(result.toolWarnings).toEqual([]);
-    });
-
-    it('should validate all browser search supported models', () => {
-      const supportedModels = ['openai/gpt-oss-20b', 'openai/gpt-oss-120b'];
-
-      supportedModels.forEach(modelId => {
-        const result = prepareTools({
-          tools: [
-            {
-              type: 'provider',
-              id: 'groq.browser_search',
-              name: 'browser_search',
-              args: {},
-            },
-          ],
-          modelId: modelId as any,
-        });
-
-        expect(result.tools).toEqual([{ type: 'browser_search' }]);
-        expect(result.toolWarnings).toEqual([]);
-      });
-    });
-
-    it('should handle browser search with tool choice', () => {
-      const result = prepareTools({
-        tools: [
-          {
-            type: 'provider',
-            id: 'groq.browser_search',
-            name: 'browser_search',
-            args: {},
-          },
-        ],
-        toolChoice: { type: 'required' },
-        modelId: 'openai/gpt-oss-120b',
-      });
-
-      expect(result.tools).toEqual([{ type: 'browser_search' }]);
-      expect(result.toolChoice).toEqual('required');
-      expect(result.toolWarnings).toEqual([]);
-    });
-  });
-});

package/src/groq-transcription-model.test.ts

@@ -1,185 +0,0 @@
-import { createTestServer } from '@ai-sdk/test-server/with-vitest';
-import { GroqTranscriptionModel } from './groq-transcription-model';
-import { createGroq } from './groq-provider';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { describe, it, expect, vi } from 'vitest';
-
-vi.mock('./version', () => ({
-  VERSION: '0.0.0-test',
-}));
-
-const audioData = await readFile(path.join(__dirname, 'transcript-test.mp3'));
-const provider = createGroq({ apiKey: 'test-api-key' });
-const model = provider.transcription('whisper-large-v3-turbo');
-
-const server = createTestServer({
-  'https://api.groq.com/openai/v1/audio/transcriptions': {},
-});
-
-describe('doGenerate', () => {
-  function prepareJsonResponse({
-    headers,
-  }: {
-    headers?: Record<string, string>;
-  } = {}) {
-    server.urls[
-      'https://api.groq.com/openai/v1/audio/transcriptions'
-    ].response = {
-      type: 'json-value',
-      headers,
-      body: {
-        task: 'transcribe',
-        language: 'English',
-        duration: 2.5,
-        text: 'Hello world!',
-        segments: [
-          {
-            id: 0,
-            seek: 0,
-            start: 0,
-            end: 2.48,
-            text: 'Hello world!',
-            tokens: [50365, 2425, 490, 264],
-            temperature: 0,
-            avg_logprob: -0.29010406,
-            compression_ratio: 0.7777778,
-            no_speech_prob: 0.032802984,
-          },
-        ],
-        x_groq: { id: 'req_01jrh9nn61f24rydqq1r4b3yg5' },
-      },
-    };
-  }
-
-  it('should pass the model', async () => {
-    prepareJsonResponse();
-
-    await model.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-    });
-
-    expect(await server.calls[0].requestBodyMultipart).toMatchObject({
-      model: 'whisper-large-v3-turbo',
-    });
-  });
-
-  it('should pass headers', async () => {
-    prepareJsonResponse();
-
-    const provider = createGroq({
-      apiKey: 'test-api-key',
-      headers: {
-        'Custom-Provider-Header': 'provider-header-value',
-      },
-    });
-
-    await provider.transcription('whisper-large-v3-turbo').doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-      headers: {
-        'Custom-Request-Header': 'request-header-value',
-      },
-    });
-
-    expect(server.calls[0].requestHeaders).toMatchObject({
-      authorization: 'Bearer test-api-key',
-      'content-type': expect.stringMatching(
-        /^multipart\/form-data; boundary=----formdata-undici-\d+$/,
-      ),
-      'custom-provider-header': 'provider-header-value',
-      'custom-request-header': 'request-header-value',
-    });
-    expect(server.calls[0].requestUserAgent).toContain(
-      `ai-sdk/groq/0.0.0-test`,
-    );
-  });
-
-  it('should extract the transcription text', async () => {
-    prepareJsonResponse();
-
-    const result = await model.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-    });
-
-    expect(result.text).toBe('Hello world!');
-  });
-
-  it('should include response data with timestamp, modelId and headers', async () => {
-    prepareJsonResponse({
-      headers: {
-        'x-request-id': 'test-request-id',
-        'x-ratelimit-remaining': '123',
-      },
-    });
-
-    const testDate = new Date(0);
-    const customModel = new GroqTranscriptionModel('whisper-large-v3-turbo', {
-      provider: 'test-provider',
-      url: () => 'https://api.groq.com/openai/v1/audio/transcriptions',
-      headers: () => ({}),
-      _internal: {
-        currentDate: () => testDate,
-      },
-    });
-
-    const result = await customModel.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-    });
-
-    expect(result.response).toMatchObject({
-      timestamp: testDate,
-      modelId: 'whisper-large-v3-turbo',
-      headers: {
-        'content-type': 'application/json',
-        'x-request-id': 'test-request-id',
-        'x-ratelimit-remaining': '123',
-      },
-    });
-  });
-
-  it('should use real date when no custom date provider is specified', async () => {
-    prepareJsonResponse();
-
-    const testDate = new Date(0);
-    const customModel = new GroqTranscriptionModel('whisper-large-v3-turbo', {
-      provider: 'test-provider',
-      url: () => 'https://api.groq.com/openai/v1/audio/transcriptions',
-      headers: () => ({}),
-      _internal: {
-        currentDate: () => testDate,
-      },
-    });
-
-    const result = await customModel.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-    });
-
-    expect(result.response.timestamp.getTime()).toEqual(testDate.getTime());
-    expect(result.response.modelId).toBe('whisper-large-v3-turbo');
-  });
-
-  it('should correctly pass provider options when they are an array', async () => {
-    prepareJsonResponse();
-
-    await model.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-      providerOptions: {
-        groq: {
-          timestampGranularities: ['segment'],
-          responseFormat: 'verbose_json',
-        },
-      },
-    });
-
-    expect(await server.calls[0].requestBodyMultipart).toMatchObject({
-      'timestamp_granularities[]': 'segment',
-      response_format: 'verbose_json',
-    });
-  });
-});