@ai-sdk/groq 3.0.12 → 3.0.13

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @ai-sdk/groq
 
+## 3.0.13
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+
 ## 3.0.12
 
 ### Patch Changes

package/dist/index.js

@@ -973,7 +973,7 @@ var groqTools = {
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.12" : "0.0.0-test";
+var VERSION = true ? "3.0.13" : "0.0.0-test";
 
 // src/groq-provider.ts
 function createGroq(options = {}) {

package/dist/index.mjs

@@ -971,7 +971,7 @@ var groqTools = {
 };
 
 // src/version.ts
-var VERSION = true ? "3.0.12" : "0.0.0-test";
+var VERSION = true ? "3.0.13" : "0.0.0-test";
 
 // src/groq-provider.ts
 function createGroq(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/groq",
-  "version": "3.0.12",
+  "version": "3.0.13",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "src",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -28,8 +29,8 @@
     "tsup": "^8",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@vercel/ai-tsconfig": "0.0.0",
-    "@ai-sdk/test-server": "1.0.1"
+    "@ai-sdk/test-server": "1.0.2",
+    "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

package/src/convert-groq-usage.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect } from 'vitest';
+import { convertGroqUsage } from './convert-groq-usage';
+
+describe('convertGroqUsage', () => {
+  it('should return undefined values when usage is null', () => {
+    const result = convertGroqUsage(null);
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    });
+  });
+
+  it('should return undefined values when usage is undefined', () => {
+    const result = convertGroqUsage(undefined);
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    });
+  });
+
+  it('should convert basic usage without token details', () => {
+    const result = convertGroqUsage({
+      prompt_tokens: 20,
+      completion_tokens: 10,
+    });
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: 20,
+        noCache: 20,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: 10,
+        text: 10,
+        reasoning: undefined,
+      },
+      raw: {
+        prompt_tokens: 20,
+        completion_tokens: 10,
+      },
+    });
+  });
+
+  it('should extract reasoning tokens from completion_tokens_details', () => {
+    const result = convertGroqUsage({
+      prompt_tokens: 79,
+      completion_tokens: 40,
+      completion_tokens_details: {
+        reasoning_tokens: 21,
+      },
+    });
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: 79,
+        noCache: 79,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: 40,
+        text: 19, // 40 - 21 = 19
+        reasoning: 21,
+      },
+      raw: {
+        prompt_tokens: 79,
+        completion_tokens: 40,
+        completion_tokens_details: {
+          reasoning_tokens: 21,
+        },
+      },
+    });
+  });
+
+  it('should handle null reasoning_tokens in completion_tokens_details', () => {
+    const result = convertGroqUsage({
+      prompt_tokens: 20,
+      completion_tokens: 10,
+      completion_tokens_details: {
+        reasoning_tokens: null,
+      },
+    });
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: 20,
+        noCache: 20,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: 10,
+        text: 10,
+        reasoning: undefined,
+      },
+      raw: {
+        prompt_tokens: 20,
+        completion_tokens: 10,
+        completion_tokens_details: {
+          reasoning_tokens: null,
+        },
+      },
+    });
+  });
+
+  it('should handle null completion_tokens_details', () => {
+    const result = convertGroqUsage({
+      prompt_tokens: 20,
+      completion_tokens: 10,
+      completion_tokens_details: null,
+    });
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: 20,
+        noCache: 20,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: 10,
+        text: 10,
+        reasoning: undefined,
+      },
+      raw: {
+        prompt_tokens: 20,
+        completion_tokens: 10,
+        completion_tokens_details: null,
+      },
+    });
+  });
+
+  it('should handle zero reasoning tokens', () => {
+    const result = convertGroqUsage({
+      prompt_tokens: 20,
+      completion_tokens: 10,
+      completion_tokens_details: {
+        reasoning_tokens: 0,
+      },
+    });
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: 20,
+        noCache: 20,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: 10,
+        text: 10,
+        reasoning: 0,
+      },
+      raw: {
+        prompt_tokens: 20,
+        completion_tokens: 10,
+        completion_tokens_details: {
+          reasoning_tokens: 0,
+        },
+      },
+    });
+  });
+
+  it('should handle all tokens being reasoning tokens', () => {
+    const result = convertGroqUsage({
+      prompt_tokens: 20,
+      completion_tokens: 50,
+      completion_tokens_details: {
+        reasoning_tokens: 50,
+      },
+    });
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: 20,
+        noCache: 20,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: 50,
+        text: 0, // 50 - 50 = 0
+        reasoning: 50,
+      },
+      raw: {
+        prompt_tokens: 20,
+        completion_tokens: 50,
+        completion_tokens_details: {
+          reasoning_tokens: 50,
+        },
+      },
+    });
+  });
+
+  it('should handle missing prompt_tokens and completion_tokens', () => {
+    const result = convertGroqUsage({});
+
+    expect(result).toStrictEqual({
+      inputTokens: {
+        total: 0,
+        noCache: 0,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: 0,
+        text: 0,
+        reasoning: undefined,
+      },
+      raw: {},
+    });
+  });
+});

package/src/convert-groq-usage.ts

@@ -0,0 +1,64 @@
+import { LanguageModelV3Usage } from '@ai-sdk/provider';
+
+export function convertGroqUsage(
+  usage:
+    | {
+        prompt_tokens?: number | null | undefined;
+        completion_tokens?: number | null | undefined;
+        prompt_tokens_details?:
+          | {
+              cached_tokens?: number | null | undefined;
+            }
+          | null
+          | undefined;
+        completion_tokens_details?:
+          | {
+              reasoning_tokens?: number | null | undefined;
+            }
+          | null
+          | undefined;
+      }
+    | undefined
+    | null,
+): LanguageModelV3Usage {
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: {
+        total: undefined,
+        text: undefined,
+        reasoning: undefined,
+      },
+      raw: undefined,
+    };
+  }
+
+  const promptTokens = usage.prompt_tokens ?? 0;
+  const completionTokens = usage.completion_tokens ?? 0;
+  const reasoningTokens =
+    usage.completion_tokens_details?.reasoning_tokens ?? undefined;
+  const textTokens =
+    reasoningTokens != null
+      ? completionTokens - reasoningTokens
+      : completionTokens;
+
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens,
+      cacheRead: undefined,
+      cacheWrite: undefined,
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: textTokens,
+      reasoning: reasoningTokens,
+    },
+    raw: usage,
+  };
+}

package/src/convert-to-groq-chat-messages.test.ts

@@ -0,0 +1,205 @@
+import { convertToGroqChatMessages } from './convert-to-groq-chat-messages';
+import { describe, it, expect } from 'vitest';
+
+describe('user messages', () => {
+  it('should convert messages with image parts', async () => {
+    const result = convertToGroqChatMessages([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Hello' },
+          {
+            type: 'file',
+            data: 'AAECAw==',
+            mediaType: 'image/png',
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": [
+            {
+              "text": "Hello",
+              "type": "text",
+            },
+            {
+              "image_url": {
+                "url": "data:image/png;base64,AAECAw==",
+              },
+              "type": "image_url",
+            },
+          ],
+          "role": "user",
+        },
+      ]
+    `);
+  });
+
+  it('should convert messages with image parts from Uint8Array', async () => {
+    const result = convertToGroqChatMessages([
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Hi' },
+          {
+            type: 'file',
+            data: new Uint8Array([0, 1, 2, 3]),
+            mediaType: 'image/png',
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": [
+            {
+              "text": "Hi",
+              "type": "text",
+            },
+            {
+              "image_url": {
+                "url": "data:image/png;base64,AAECAw==",
+              },
+              "type": "image_url",
+            },
+          ],
+          "role": "user",
+        },
+      ]
+    `);
+  });
+
+  it('should convert messages with only a text part to a string content', async () => {
+    const result = convertToGroqChatMessages([
+      {
+        role: 'user',
+        content: [{ type: 'text', text: 'Hello' }],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "Hello",
+          "role": "user",
+        },
+      ]
+    `);
+  });
+});
+
+describe('tool calls', () => {
+  it('should stringify arguments to tool calls', () => {
+    const result = convertToGroqChatMessages([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            input: { foo: 'bar123' },
+            toolCallId: 'quux',
+            toolName: 'thwomp',
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'quux',
+            toolName: 'thwomp',
+            output: { type: 'json', value: { oof: '321rab' } },
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "",
+          "role": "assistant",
+          "tool_calls": [
+            {
+              "function": {
+                "arguments": "{"foo":"bar123"}",
+                "name": "thwomp",
+              },
+              "id": "quux",
+              "type": "function",
+            },
+          ],
+        },
+        {
+          "content": "{"oof":"321rab"}",
+          "role": "tool",
+          "tool_call_id": "quux",
+        },
+      ]
+    `);
+  });
+
+  it('should send reasoning if present', () => {
+    const result = convertToGroqChatMessages([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'reasoning',
+            text: 'I think the tool will return the correct value.',
+          },
+          {
+            type: 'tool-call',
+            input: { foo: 'bar123' },
+            toolCallId: 'quux',
+            toolName: 'thwomp',
+          },
+        ],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "",
+          "reasoning": "I think the tool will return the correct value.",
+          "role": "assistant",
+          "tool_calls": [
+            {
+              "function": {
+                "arguments": "{"foo":"bar123"}",
+                "name": "thwomp",
+              },
+              "id": "quux",
+              "type": "function",
+            },
+          ],
+        },
+      ]
+    `);
+  });
+
+  it('should not include reasoning field when no reasoning content is present', () => {
+    const result = convertToGroqChatMessages([
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello, how can I help you?' }],
+      },
+    ]);
+
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "Hello, how can I help you?",
+          "role": "assistant",
+        },
+      ]
+    `);
+  });
+});

package/src/convert-to-groq-chat-messages.ts

@@ -0,0 +1,147 @@
+import {
+  LanguageModelV3Prompt,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+import { GroqChatPrompt } from './groq-api-types';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+
+export function convertToGroqChatMessages(
+  prompt: LanguageModelV3Prompt,
+): GroqChatPrompt {
+  const messages: GroqChatPrompt = [];
+
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case 'system': {
+        messages.push({ role: 'system', content });
+        break;
+      }
+
+      case 'user': {
+        if (content.length === 1 && content[0].type === 'text') {
+          messages.push({ role: 'user', content: content[0].text });
+          break;
+        }
+
+        messages.push({
+          role: 'user',
+          content: content.map(part => {
+            switch (part.type) {
+              case 'text': {
+                return { type: 'text', text: part.text };
+              }
+              case 'file': {
+                if (!part.mediaType.startsWith('image/')) {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: 'Non-image file content parts',
+                  });
+                }
+
+                const mediaType =
+                  part.mediaType === 'image/*' ? 'image/jpeg' : part.mediaType;
+
+                return {
+                  type: 'image_url',
+                  image_url: {
+                    url:
+                      part.data instanceof URL
+                        ? part.data.toString()
+                        : `data:${mediaType};base64,${convertToBase64(part.data)}`,
+                  },
+                };
+              }
+            }
+          }),
+        });
+
+        break;
+      }
+
+      case 'assistant': {
+        let text = '';
+        let reasoning = '';
+        const toolCalls: Array<{
+          id: string;
+          type: 'function';
+          function: { name: string; arguments: string };
+        }> = [];
+
+        for (const part of content) {
+          switch (part.type) {
+            // groq supports reasoning for tool-calls in multi-turn conversations
+            // https://github.com/vercel/ai/issues/7860
+            case 'reasoning': {
+              reasoning += part.text;
+              break;
+            }
+
+            case 'text': {
+              text += part.text;
+              break;
+            }
+
+            case 'tool-call': {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: 'function',
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input),
+                },
+              });
+              break;
+            }
+          }
+        }
+
+        messages.push({
+          role: 'assistant',
+          content: text,
+          ...(reasoning.length > 0 ? { reasoning } : null),
+          ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : null),
+        });
+
+        break;
+      }
+
+      case 'tool': {
+        for (const toolResponse of content) {
+          if (toolResponse.type === 'tool-approval-response') {
+            continue;
+          }
+          const output = toolResponse.output;
+
+          let contentValue: string;
+          switch (output.type) {
+            case 'text':
+            case 'error-text':
+              contentValue = output.value;
+              break;
+            case 'execution-denied':
+              contentValue = output.reason ?? 'Tool execution denied.';
+              break;
+            case 'content':
+            case 'json':
+            case 'error-json':
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+
+          messages.push({
+            role: 'tool',
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+          });
+        }
+        break;
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return messages;
+}