@ai-sdk/groq 0.0.0-013d7476-20250808163325 → 0.0.0-4115c213-20260122152721

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;
+}

package/src/get-response-metadata.ts

@@ -0,0 +1,15 @@
+export function getResponseMetadata({
+  id,
+  model,
+  created,
+}: {
+  id?: string | undefined | null;
+  created?: number | undefined | null;
+  model?: string | undefined | null;
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined,
+  };
+}

package/src/groq-api-types.ts

@@ -0,0 +1,100 @@
+export type GroqChatPrompt = Array<GroqMessage>;
+
+export type GroqMessage =
+  | GroqSystemMessage
+  | GroqUserMessage
+  | GroqAssistantMessage
+  | GroqToolMessage;
+
+export interface GroqSystemMessage {
+  role: 'system';
+  content: string;
+}
+
+export interface GroqUserMessage {
+  role: 'user';
+  content: string | Array<GroqContentPart>;
+}
+
+export type GroqContentPart = GroqContentPartText | GroqContentPartImage;
+
+export interface GroqContentPartImage {
+  type: 'image_url';
+  image_url: { url: string };
+}
+
+export interface GroqContentPartText {
+  type: 'text';
+  text: string;
+}
+
+export interface GroqAssistantMessage {
+  role: 'assistant';
+  content?: string | null;
+  reasoning?: string;
+  tool_calls?: Array<GroqMessageToolCall>;
+}
+
+export interface GroqMessageToolCall {
+  type: 'function';
+  id: string;
+  function: {
+    arguments: string;
+    name: string;
+  };
+}
+
+export interface GroqToolMessage {
+  role: 'tool';
+  content: string;
+  tool_call_id: string;
+}
+
+export interface GroqTranscriptionAPITypes {
+  /**
+   * The audio file object for direct upload to translate/transcribe.
+   * Required unless using url instead.
+   */
+  file?: string;
+
+  /**
+   * The audio URL to translate/transcribe (supports Base64URL).
+   * Required unless using file instead.
+   */
+  url?: string;
+
+  /**
+   * The language of the input audio. Supplying the input language in ISO-639-1 (i.e. en, tr`) format will improve accuracy and latency.
+   * The translations endpoint only supports 'en' as a parameter option.
+   */
+  language?: string;
+
+  /**
+   * ID of the model to use.
+   */
+  model: string;
+
+  /**
+   * Prompt to guide the model's style or specify how to spell unfamiliar words. (limited to 224 tokens)
+   */
+  prompt?: string;
+
+  /**
+   * Define the output response format.
+   * Set to verbose_json to receive timestamps for audio segments.
+   * Set to text to return a text response.
+   */
+  response_format?: string;
+
+  /**
+   * The temperature between 0 and 1. For translations and transcriptions, we recommend the default value of 0.
+   */
+  temperature?: number;
+
+  /**
+   * The timestamp granularities to populate for this transcription. response_format must be set verbose_json to use timestamp granularities.
+   * Either or both of word and segment are supported.
+   * segment returns full metadata and word returns only word, start, and end timestamps. To get both word-level timestamps and full segment metadata, include both values in the array.
+   */
+  timestamp_granularities?: Array<string>;
+}

package/src/groq-browser-search-models.ts

@@ -0,0 +1,26 @@
+import { GroqChatModelId } from './groq-chat-options';
+
+/**
+ * Models that support browser search functionality.
+ * Based on: https://console.groq.com/docs/browser-search
+ */
+export const BROWSER_SEARCH_SUPPORTED_MODELS: readonly GroqChatModelId[] = [
+  'openai/gpt-oss-20b',
+  'openai/gpt-oss-120b',
+] as const;
+
+/**
+ * Check if a model supports browser search functionality.
+ */
+export function isBrowserSearchSupportedModel(
+  modelId: GroqChatModelId,
+): boolean {
+  return BROWSER_SEARCH_SUPPORTED_MODELS.includes(modelId);
+}
+
+/**
+ * Get a formatted list of supported models for error messages.
+ */
+export function getSupportedModelsString(): string {
+  return BROWSER_SEARCH_SUPPORTED_MODELS.join(', ');
+}