@ai-sdk/groq
Version:
The **[Groq provider](https://ai-sdk.dev/providers/ai-sdk-providers/groq)** for the [AI SDK](https://ai-sdk.dev/docs) contains language model support for the Groq chat and completion APIs, transcription support, and browser search tool.
1,028 lines (1,010 loc) • 32.4 kB
JavaScript
// src/groq-provider.ts
import {
NoSuchModelError
} from "@ai-sdk/provider";
import {
loadApiKey,
withoutTrailingSlash,
withUserAgentSuffix
} from "@ai-sdk/provider-utils";
// src/groq-chat-language-model.ts
import {
StreamingToolCallTracker,
combineHeaders,
createEventSourceResponseHandler,
createJsonResponseHandler,
generateId,
isCustomReasoning,
mapReasoningToProviderEffort,
parseProviderOptions,
postJsonToApi,
serializeModelOptions,
WORKFLOW_SERIALIZE,
WORKFLOW_DESERIALIZE
} from "@ai-sdk/provider-utils";
import { z as z3 } from "zod/v4";
// src/convert-groq-usage.ts
import { createNullLanguageModelUsage } from "@ai-sdk/provider-utils";
function convertGroqUsage(usage) {
var _a, _b, _c, _d, _e, _f;
if (usage == null) {
return createNullLanguageModelUsage();
}
const promptTokens = (_a = usage.prompt_tokens) != null ? _a : 0;
const cacheReadTokens = (_c = (_b = usage.prompt_tokens_details) == null ? void 0 : _b.cached_tokens) != null ? _c : void 0;
const completionTokens = (_d = usage.completion_tokens) != null ? _d : 0;
const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : void 0;
const textTokens = reasoningTokens != null ? completionTokens - reasoningTokens : completionTokens;
return {
inputTokens: {
total: promptTokens,
noCache: cacheReadTokens != null ? promptTokens - cacheReadTokens : promptTokens,
cacheRead: cacheReadTokens,
cacheWrite: void 0
},
outputTokens: {
total: completionTokens,
text: textTokens,
reasoning: reasoningTokens
},
raw: usage
};
}
// src/convert-to-groq-chat-messages.ts
import {
UnsupportedFunctionalityError
} from "@ai-sdk/provider";
import {
convertToBase64,
getTopLevelMediaType,
resolveFullMediaType
} from "@ai-sdk/provider-utils";
function convertToGroqChatMessages(prompt) {
var _a;
const messages = [];
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": {
switch (part.data.type) {
case "reference": {
throw new UnsupportedFunctionalityError({
functionality: "file parts with provider references"
});
}
case "text": {
throw new UnsupportedFunctionalityError({
functionality: "text file parts"
});
}
case "url":
case "data": {
if (getTopLevelMediaType(part.mediaType) !== "image") {
throw new UnsupportedFunctionalityError({
functionality: "Non-image file content parts"
});
}
return {
type: "image_url",
image_url: {
url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
}
};
}
}
}
}
})
});
break;
}
case "assistant": {
let text = "";
let reasoning = "";
const toolCalls = [];
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;
switch (output.type) {
case "text":
case "error-text":
contentValue = output.value;
break;
case "execution-denied":
contentValue = (_a = output.reason) != null ? _a : "Tool call 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 = role;
throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
}
}
}
return messages;
}
// src/get-response-metadata.ts
import { createLanguageModelResponseMetadata } from "@ai-sdk/provider-utils";
// src/groq-chat-language-model-options.ts
import { z } from "zod/v4";
var groqLanguageModelChatOptions = z.object({
reasoningFormat: z.enum(["parsed", "raw", "hidden"]).optional(),
/**
* Specifies the reasoning effort level for model inference.
* @see https://console.groq.com/docs/reasoning#reasoning-effort
*/
reasoningEffort: z.enum(["none", "default", "low", "medium", "high"]).optional(),
/**
* Whether to enable parallel function calling during tool use. Default to true.
*/
parallelToolCalls: z.boolean().optional(),
/**
* A unique identifier representing your end-user, which can help OpenAI to
* monitor and detect abuse. Learn more.
*/
user: z.string().optional(),
/**
* Whether to use structured outputs.
*
* @default true
*/
structuredOutputs: z.boolean().optional(),
/**
* Whether to use strict JSON schema validation.
* When true, the model uses constrained decoding to guarantee schema compliance.
* Only used when structured outputs are enabled and a schema is provided.
*
* @default true
*/
strictJsonSchema: z.boolean().optional(),
/**
* 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", "performance", "flex", "auto"]).optional()
});
// src/groq-error.ts
import { z as z2 } from "zod/v4";
import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
var groqErrorDataSchema = z2.object({
error: z2.object({
message: z2.string(),
type: z2.string()
})
});
var groqFailedResponseHandler = createJsonErrorResponseHandler({
errorSchema: groqErrorDataSchema,
errorToMessage: (data) => data.error.message
});
// src/groq-prepare-tools.ts
import {
UnsupportedFunctionalityError as UnsupportedFunctionalityError2
} from "@ai-sdk/provider";
// src/groq-browser-search-models.ts
var BROWSER_SEARCH_SUPPORTED_MODELS = [
"openai/gpt-oss-20b",
"openai/gpt-oss-120b"
];
function isBrowserSearchSupportedModel(modelId) {
return BROWSER_SEARCH_SUPPORTED_MODELS.includes(modelId);
}
function getSupportedModelsString() {
return BROWSER_SEARCH_SUPPORTED_MODELS.join(", ");
}
// src/groq-prepare-tools.ts
function prepareTools({
tools,
toolChoice,
modelId
}) {
tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
const toolWarnings = [];
if (tools == null) {
return { tools: void 0, toolChoice: void 0, toolWarnings };
}
const groqTools2 = [];
for (const tool of tools) {
if (tool.type === "provider") {
if (tool.id === "groq.browser_search") {
if (!isBrowserSearchSupportedModel(modelId)) {
toolWarnings.push({
type: "unsupported",
feature: `provider-defined tool ${tool.id}`,
details: `Browser search is only supported on the following models: ${getSupportedModelsString()}. Current model: ${modelId}`
});
} else {
groqTools2.push({
type: "browser_search"
});
}
} else {
toolWarnings.push({
type: "unsupported",
feature: `provider-defined tool ${tool.id}`
});
}
} else {
groqTools2.push({
type: "function",
function: {
name: tool.name,
description: tool.description,
parameters: tool.inputSchema,
...tool.strict != null ? { strict: tool.strict } : {}
}
});
}
}
if (toolChoice == null) {
return { tools: groqTools2, toolChoice: void 0, toolWarnings };
}
const type = toolChoice.type;
switch (type) {
case "auto":
case "none":
case "required":
return { tools: groqTools2, toolChoice: type, toolWarnings };
case "tool":
return {
tools: groqTools2,
toolChoice: {
type: "function",
function: {
name: toolChoice.toolName
}
},
toolWarnings
};
default: {
const _exhaustiveCheck = type;
throw new UnsupportedFunctionalityError2({
functionality: `tool choice type: ${_exhaustiveCheck}`
});
}
}
}
// src/map-groq-finish-reason.ts
function mapGroqFinishReason(finishReason) {
switch (finishReason) {
case "stop":
return "stop";
case "length":
return "length";
case "content_filter":
return "content-filter";
case "function_call":
case "tool_calls":
return "tool-calls";
default:
return "other";
}
}
// src/groq-chat-language-model.ts
var GroqChatLanguageModel = class _GroqChatLanguageModel {
constructor(modelId, config) {
this.specificationVersion = "v4";
this.supportedUrls = {
"image/*": [/^https?:\/\/.*$/]
};
this.modelId = modelId;
this.config = config;
}
static [WORKFLOW_SERIALIZE](model) {
return serializeModelOptions({
modelId: model.modelId,
config: model.config
});
}
static [WORKFLOW_DESERIALIZE](options) {
return new _GroqChatLanguageModel(options.modelId, options.config);
}
get provider() {
return this.config.provider;
}
async getArgs({
prompt,
maxOutputTokens,
temperature,
topP,
topK,
frequencyPenalty,
presencePenalty,
stopSequences,
responseFormat,
seed,
reasoning,
tools,
toolChoice,
providerOptions
}) {
var _a, _b, _c, _d;
const warnings = [];
const groqOptions = await parseProviderOptions({
provider: "groq",
providerOptions,
schema: groqLanguageModelChatOptions
});
const structuredOutputs = (_a = groqOptions == null ? void 0 : groqOptions.structuredOutputs) != null ? _a : true;
const strictJsonSchema = (_b = groqOptions == null ? void 0 : groqOptions.strictJsonSchema) != null ? _b : true;
if (topK != null) {
warnings.push({ type: "unsupported", feature: "topK" });
}
if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !structuredOutputs) {
warnings.push({
type: "unsupported",
feature: "responseFormat",
details: "JSON response format schema is only supported with structuredOutputs"
});
}
const {
tools: groqTools2,
toolChoice: groqToolChoice,
toolWarnings
} = prepareTools({ tools, toolChoice, modelId: this.modelId });
return {
args: {
// model id:
model: this.modelId,
// model specific settings:
user: groqOptions == null ? void 0 : groqOptions.user,
parallel_tool_calls: groqOptions == null ? void 0 : groqOptions.parallelToolCalls,
// standardized settings:
max_tokens: maxOutputTokens,
temperature,
top_p: topP,
frequency_penalty: frequencyPenalty,
presence_penalty: presencePenalty,
stop: stopSequences,
seed,
// response format:
response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && responseFormat.schema != null ? {
type: "json_schema",
json_schema: {
schema: responseFormat.schema,
strict: strictJsonSchema,
name: (_c = responseFormat.name) != null ? _c : "response",
description: responseFormat.description
}
} : { type: "json_object" } : void 0,
// provider options:
reasoning_format: groqOptions == null ? void 0 : groqOptions.reasoningFormat,
reasoning_effort: (_d = groqOptions == null ? void 0 : groqOptions.reasoningEffort) != null ? _d : isCustomReasoning(reasoning) && reasoning !== "none" ? mapReasoningToProviderEffort({
reasoning,
effortMap: {
minimal: "low",
low: "low",
medium: "medium",
high: "high",
xhigh: "high"
},
warnings
}) : void 0,
service_tier: groqOptions == null ? void 0 : groqOptions.serviceTier,
// messages:
messages: convertToGroqChatMessages(prompt),
// tools:
tools: groqTools2,
tool_choice: groqToolChoice
},
warnings: [...warnings, ...toolWarnings]
};
}
async doGenerate(options) {
var _a, _b, _c, _d;
const { args, warnings } = await this.getArgs(options);
const body = JSON.stringify(args);
const {
responseHeaders,
value: response,
rawValue: rawResponse
} = await postJsonToApi({
url: this.config.url({
path: "/chat/completions",
modelId: this.modelId
}),
headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
body: args,
failedResponseHandler: groqFailedResponseHandler,
successfulResponseHandler: createJsonResponseHandler(
groqChatResponseSchema
),
abortSignal: options.abortSignal,
fetch: this.config.fetch
});
const choice = response.choices[0];
const content = [];
const text = choice.message.content;
if (text != null && text.length > 0) {
content.push({ type: "text", text });
}
const reasoning = choice.message.reasoning;
if (reasoning != null && reasoning.length > 0) {
content.push({
type: "reasoning",
text: reasoning
});
}
if (choice.message.tool_calls != null) {
for (const toolCall of choice.message.tool_calls) {
content.push({
type: "tool-call",
toolCallId: (_c = toolCall.id) != null ? _c : generateId(),
toolName: toolCall.function.name,
input: toolCall.function.arguments
});
}
}
return {
content,
finishReason: {
unified: mapGroqFinishReason(choice.finish_reason),
raw: (_d = choice.finish_reason) != null ? _d : void 0
},
usage: convertGroqUsage(response.usage),
response: {
...createLanguageModelResponseMetadata(response),
headers: responseHeaders,
body: rawResponse
},
warnings,
request: { body }
};
}
async doStream(options) {
var _a, _b;
const { args, warnings } = await this.getArgs(options);
const body = { ...args, stream: true };
const { responseHeaders, value: response } = await postJsonToApi({
url: this.config.url({
path: "/chat/completions",
modelId: this.modelId
}),
headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
body,
failedResponseHandler: groqFailedResponseHandler,
successfulResponseHandler: createEventSourceResponseHandler(groqChatChunkSchema),
abortSignal: options.abortSignal,
fetch: this.config.fetch
});
let toolCallTracker;
let finishReason = {
unified: "other",
raw: void 0
};
let usage = void 0;
let isFirstChunk = true;
let isActiveText = false;
let isActiveReasoning = false;
let providerMetadata;
return {
stream: response.pipeThrough(
new TransformStream({
start(controller) {
toolCallTracker = new StreamingToolCallTracker(controller, {
generateId,
typeValidation: "required"
});
controller.enqueue({ type: "stream-start", warnings });
},
transform(chunk, controller) {
var _a2;
if (options.includeRawChunks) {
controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
}
if (!chunk.success) {
finishReason = {
unified: "error",
raw: void 0
};
controller.enqueue({ type: "error", error: chunk.error });
return;
}
const value = chunk.value;
if ("error" in value) {
finishReason = {
unified: "error",
raw: void 0
};
controller.enqueue({ type: "error", error: value.error });
return;
}
if (isFirstChunk) {
isFirstChunk = false;
controller.enqueue({
type: "response-metadata",
...createLanguageModelResponseMetadata(value)
});
}
if (((_a2 = value.x_groq) == null ? void 0 : _a2.usage) != null) {
usage = value.x_groq.usage;
}
const choice = value.choices[0];
if ((choice == null ? void 0 : choice.finish_reason) != null) {
finishReason = {
unified: mapGroqFinishReason(choice.finish_reason),
raw: choice.finish_reason
};
}
if ((choice == null ? void 0 : choice.delta) == null) {
return;
}
const delta = choice.delta;
if (delta.reasoning != null && delta.reasoning.length > 0) {
if (!isActiveReasoning) {
controller.enqueue({
type: "reasoning-start",
id: "reasoning-0"
});
isActiveReasoning = true;
}
controller.enqueue({
type: "reasoning-delta",
id: "reasoning-0",
delta: delta.reasoning
});
}
if (delta.content != null && delta.content.length > 0) {
if (isActiveReasoning) {
controller.enqueue({
type: "reasoning-end",
id: "reasoning-0"
});
isActiveReasoning = false;
}
if (!isActiveText) {
controller.enqueue({ type: "text-start", id: "txt-0" });
isActiveText = true;
}
controller.enqueue({
type: "text-delta",
id: "txt-0",
delta: delta.content
});
}
if (delta.tool_calls != null) {
if (isActiveReasoning) {
controller.enqueue({
type: "reasoning-end",
id: "reasoning-0"
});
isActiveReasoning = false;
}
for (const toolCallDelta of delta.tool_calls) {
toolCallTracker.processDelta(toolCallDelta);
}
}
},
flush(controller) {
if (isActiveReasoning) {
controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
}
if (isActiveText) {
controller.enqueue({ type: "text-end", id: "txt-0" });
}
toolCallTracker.flush();
controller.enqueue({
type: "finish",
finishReason,
usage: convertGroqUsage(usage),
...providerMetadata != null ? { providerMetadata } : {}
});
}
})
),
request: { body: JSON.stringify(body) },
response: { headers: responseHeaders }
};
}
};
var groqChatResponseSchema = z3.object({
id: z3.string().nullish(),
created: z3.number().nullish(),
model: z3.string().nullish(),
choices: z3.array(
z3.object({
message: z3.object({
content: z3.string().nullish(),
reasoning: z3.string().nullish(),
tool_calls: z3.array(
z3.object({
id: z3.string().nullish(),
type: z3.literal("function"),
function: z3.object({
name: z3.string(),
arguments: z3.string()
})
})
).nullish()
}),
index: z3.number(),
finish_reason: z3.string().nullish()
})
),
usage: z3.object({
prompt_tokens: z3.number().nullish(),
completion_tokens: z3.number().nullish(),
total_tokens: z3.number().nullish(),
prompt_tokens_details: z3.object({
cached_tokens: z3.number().nullish()
}).nullish(),
completion_tokens_details: z3.object({
reasoning_tokens: z3.number().nullish()
}).nullish()
}).nullish()
});
var groqChatChunkSchema = z3.union([
z3.object({
id: z3.string().nullish(),
created: z3.number().nullish(),
model: z3.string().nullish(),
choices: z3.array(
z3.object({
delta: z3.object({
content: z3.string().nullish(),
reasoning: z3.string().nullish(),
tool_calls: z3.array(
z3.object({
index: z3.number(),
id: z3.string().nullish(),
type: z3.literal("function").optional(),
function: z3.object({
name: z3.string().nullish(),
arguments: z3.string().nullish()
})
})
).nullish()
}).nullish(),
finish_reason: z3.string().nullable().optional(),
index: z3.number()
})
),
x_groq: z3.object({
usage: z3.object({
prompt_tokens: z3.number().nullish(),
completion_tokens: z3.number().nullish(),
total_tokens: z3.number().nullish(),
prompt_tokens_details: z3.object({
cached_tokens: z3.number().nullish()
}).nullish(),
completion_tokens_details: z3.object({
reasoning_tokens: z3.number().nullish()
}).nullish()
}).nullish()
}).nullish()
}),
groqErrorDataSchema
]);
// src/groq-transcription-model.ts
import {
combineHeaders as combineHeaders2,
convertBase64ToUint8Array,
createBinaryResponseHandler,
createJsonResponseHandler as createJsonResponseHandler2,
mediaTypeToExtension,
parseProviderOptions as parseProviderOptions2,
postFormDataToApi,
serializeModelOptions as serializeModelOptions2,
WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
} from "@ai-sdk/provider-utils";
import { z as z5 } from "zod/v4";
// src/groq-transcription-model-options.ts
import {
lazySchema,
zodSchema
} from "@ai-sdk/provider-utils";
import { z as z4 } from "zod/v4";
var groqTranscriptionModelOptions = lazySchema(
() => zodSchema(
z4.object({
language: z4.string().nullish(),
prompt: z4.string().nullish(),
responseFormat: z4.string().nullish(),
temperature: z4.number().min(0).max(1).nullish(),
timestampGranularities: z4.array(z4.string()).nullish()
})
)
);
// src/groq-transcription-model.ts
var GroqTranscriptionModel = class _GroqTranscriptionModel {
constructor(modelId, config) {
this.modelId = modelId;
this.config = config;
this.specificationVersion = "v4";
}
get provider() {
return this.config.provider;
}
static [WORKFLOW_SERIALIZE2](model) {
return serializeModelOptions2({
modelId: model.modelId,
config: model.config
});
}
static [WORKFLOW_DESERIALIZE2](options) {
return new _GroqTranscriptionModel(options.modelId, options.config);
}
async getArgs({
audio,
mediaType,
providerOptions
}) {
var _a, _b, _c, _d, _e;
const warnings = [];
const groqOptions = await parseProviderOptions2({
provider: "groq",
providerOptions,
schema: groqTranscriptionModelOptions
});
const formData = new FormData();
const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
formData.append("model", this.modelId);
const fileExtension = mediaTypeToExtension(mediaType);
formData.append(
"file",
new File([blob], "audio", { type: mediaType }),
`audio.${fileExtension}`
);
if (groqOptions) {
const transcriptionModelOptions = {
language: (_a = groqOptions.language) != null ? _a : void 0,
prompt: (_b = groqOptions.prompt) != null ? _b : void 0,
response_format: (_c = groqOptions.responseFormat) != null ? _c : void 0,
temperature: (_d = groqOptions.temperature) != null ? _d : void 0,
timestamp_granularities: (_e = groqOptions.timestampGranularities) != null ? _e : void 0
};
for (const key in transcriptionModelOptions) {
const value = transcriptionModelOptions[key];
if (value !== void 0) {
if (Array.isArray(value)) {
for (const item of value) {
formData.append(`${key}[]`, String(item));
}
} else {
formData.append(key, String(value));
}
}
}
}
return {
formData,
responseFormat: groqOptions == null ? void 0 : groqOptions.responseFormat,
warnings
};
}
async doGenerate(options) {
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
const { formData, responseFormat, warnings } = await this.getArgs(options);
const successfulResponseHandler = responseFormat === "text" ? groqTextTranscriptionResponseHandler : createJsonResponseHandler2(groqTranscriptionResponseSchema);
const {
value: response,
responseHeaders,
rawValue: rawResponse
} = await postFormDataToApi({
url: this.config.url({
path: "/audio/transcriptions",
modelId: this.modelId
}),
headers: combineHeaders2((_e = (_d = this.config).headers) == null ? void 0 : _e.call(_d), options.headers),
formData,
failedResponseHandler: groqFailedResponseHandler,
successfulResponseHandler,
abortSignal: options.abortSignal,
fetch: this.config.fetch
});
return {
text: response.text,
segments: (_i = (_h = (_f = response.segments) == null ? void 0 : _f.map((segment) => ({
text: segment.text,
startSecond: segment.start,
endSecond: segment.end
}))) != null ? _h : (_g = response.words) == null ? void 0 : _g.map((word) => ({
text: word.word,
startSecond: word.start,
endSecond: word.end
}))) != null ? _i : [],
language: (_j = response.language) != null ? _j : void 0,
durationInSeconds: (_k = response.duration) != null ? _k : void 0,
warnings,
response: {
timestamp: currentDate,
modelId: this.modelId,
headers: responseHeaders,
body: rawResponse
}
};
}
};
var groqTranscriptionResponseSchema = z5.object({
text: z5.string(),
x_groq: z5.object({
id: z5.string()
}),
// additional properties are returned when `response_format: 'verbose_json'` is
task: z5.string().nullish(),
language: z5.string().nullish(),
duration: z5.number().nullish(),
segments: z5.array(
z5.object({
id: z5.number(),
seek: z5.number(),
start: z5.number(),
end: z5.number(),
text: z5.string(),
tokens: z5.array(z5.number()),
temperature: z5.number(),
avg_logprob: z5.number(),
compression_ratio: z5.number(),
no_speech_prob: z5.number()
})
).nullish(),
words: z5.array(
z5.object({
word: z5.string(),
start: z5.number(),
end: z5.number()
})
).nullish()
});
var binaryResponseHandler = createBinaryResponseHandler();
var textDecoder = new TextDecoder();
var groqTextTranscriptionResponseHandler = async (options) => {
const { value, responseHeaders } = await binaryResponseHandler(options);
const text = textDecoder.decode(value);
return {
value: { text },
rawValue: text,
responseHeaders
};
};
// src/tool/browser-search.ts
import {
createProviderExecutedToolFactory,
lazySchema as lazySchema2,
zodSchema as zodSchema2
} from "@ai-sdk/provider-utils";
import { z as z6 } from "zod/v4";
var browserSearch = createProviderExecutedToolFactory({
id: "groq.browser_search",
inputSchema: lazySchema2(() => zodSchema2(z6.object({}))),
outputSchema: lazySchema2(() => zodSchema2(z6.object({})))
});
// src/groq-tools.ts
var groqTools = {
browserSearch
};
// src/version.ts
var VERSION = true ? "4.0.26" : "0.0.0-test";
// src/groq-provider.ts
function createGroq(options = {}) {
var _a;
const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://api.groq.com/openai/v1";
const getHeaders = () => withUserAgentSuffix(
{
Authorization: `Bearer ${loadApiKey({
apiKey: options.apiKey,
environmentVariableName: "GROQ_API_KEY",
description: "Groq"
})}`,
...options.headers
},
`ai-sdk/groq/${VERSION}`
);
const createChatModel = (modelId) => new GroqChatLanguageModel(modelId, {
provider: "groq.chat",
url: ({ path }) => `${baseURL}${path}`,
headers: getHeaders,
fetch: options.fetch
});
const createLanguageModel = (modelId) => {
if (new.target) {
throw new Error(
"The Groq model function cannot be called with the new keyword."
);
}
return createChatModel(modelId);
};
const createTranscriptionModel = (modelId) => {
return new GroqTranscriptionModel(modelId, {
provider: "groq.transcription",
url: ({ path }) => `${baseURL}${path}`,
headers: getHeaders,
fetch: options.fetch
});
};
const provider = function(modelId) {
return createLanguageModel(modelId);
};
provider.specificationVersion = "v4";
provider.languageModel = createLanguageModel;
provider.chat = createChatModel;
provider.embeddingModel = (modelId) => {
throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
};
provider.textEmbeddingModel = provider.embeddingModel;
provider.imageModel = (modelId) => {
throw new NoSuchModelError({ modelId, modelType: "imageModel" });
};
provider.transcription = createTranscriptionModel;
provider.transcriptionModel = createTranscriptionModel;
provider.tools = groqTools;
return provider;
}
var groq = createGroq();
export {
VERSION,
browserSearch,
createGroq,
groq
};
//# sourceMappingURL=index.js.map