@tanstack/ai-groq 0.5.3 → 0.5.4

package/dist/esm/adapters/text.js

@@ -1,69 +1,97 @@
+import { getGroqApiKeyFromEnv, withGroqDefaults } from "../utils/client.js";
+import { makeGroqStructuredOutputCompatible } from "../utils/schema-converter.js";
 import OpenAI from "openai";
 import { OpenAIBaseChatCompletionsTextAdapter } from "@tanstack/openai-base";
-import { withGroqDefaults, getGroqApiKeyFromEnv } from "../utils/client.js";
-import { makeGroqStructuredOutputCompatible } from "../utils/schema-converter.js";
-class GroqTextAdapter extends OpenAIBaseChatCompletionsTextAdapter {
-  kind = "text";
-  name = "groq";
-  constructor(config, model) {
-    super(model, "groq", new OpenAI(withGroqDefaults(config)));
-  }
-  makeStructuredOutputCompatible(schema, originalRequired) {
-    return makeGroqStructuredOutputCompatible(schema, originalRequired);
-  }
-  async *processStreamChunks(stream, options, aguiState) {
-    yield* super.processStreamChunks(
-      promoteGroqUsage(stream),
-      options,
-      aguiState
-    );
-  }
-  /**
-   * Surfaces Groq's reasoning deltas during streaming structured output.
-   * Groq emits `delta.reasoning` (or legacy `delta.reasoning_content`) on
-   * reasoning models when the caller sets `reasoning_format: 'parsed'` in
-   * modelOptions. The base's chatStream and structuredOutputStream both
-   * route reasoning through this hook.
-   */
-  extractReasoning(chunk) {
-    const delta = chunk.choices[0]?.delta;
-    const raw = delta?.reasoning ?? delta?.reasoning_content;
-    if (typeof raw === "string" && raw.length > 0) {
-      return { text: raw };
-    }
-    return void 0;
-  }
-  /**
-   * Groq's API rejects `response_format: json_schema` together with `tools`
-   * + `stream` (returns 400 — see Groq Structured Outputs docs:
-   * "Streaming and tool use are not currently supported with Structured
-   * Outputs."). Force the engine onto the legacy finalization path even
-   * though the OpenAI Chat Completions base would otherwise opt in.
-   */
-  supportsCombinedToolsAndSchema() {
-    return false;
-  }
-}
+//#region src/adapters/text.ts
+/**
+* Groq Text (Chat) Adapter
+*
+* Tree-shakeable adapter for Groq chat/text completion. Groq exposes an
+* OpenAI-compatible Chat Completions endpoint at `/openai/v1`, so we drive
+* it with the OpenAI SDK via a `baseURL` override (the same pattern as
+* `ai-grok`).
+*
+* Quirk: when usage is present on a stream, Groq historically delivered it
+* under `chunk.x_groq.usage` rather than `chunk.usage`. The override below
+* promotes it to the standard location so the base's RUN_FINISHED usage
+* accounting works unchanged.
+*/
+var GroqTextAdapter = class extends OpenAIBaseChatCompletionsTextAdapter {
+	kind = "text";
+	name = "groq";
+	constructor(config, model) {
+		super(model, "groq", new OpenAI(withGroqDefaults(config)));
+	}
+	makeStructuredOutputCompatible(schema, originalRequired) {
+		return makeGroqStructuredOutputCompatible(schema, originalRequired);
+	}
+	async *processStreamChunks(stream, options, aguiState) {
+		yield* super.processStreamChunks(promoteGroqUsage(stream), options, aguiState);
+	}
+	/**
+	* Surfaces Groq's reasoning deltas during streaming structured output.
+	* Groq emits `delta.reasoning` (or legacy `delta.reasoning_content`) on
+	* reasoning models when the caller sets `reasoning_format: 'parsed'` in
+	* modelOptions. The base's chatStream and structuredOutputStream both
+	* route reasoning through this hook.
+	*/
+	extractReasoning(chunk) {
+		const delta = chunk.choices[0]?.delta;
+		const raw = delta?.reasoning ?? delta?.reasoning_content;
+		if (typeof raw === "string" && raw.length > 0) return { text: raw };
+	}
+	/**
+	* Groq's API rejects `response_format: json_schema` together with `tools`
+	* + `stream` (returns 400 — see Groq Structured Outputs docs:
+	* "Streaming and tool use are not currently supported with Structured
+	* Outputs."). Force the engine onto the legacy finalization path even
+	* though the OpenAI Chat Completions base would otherwise opt in.
+	*/
+	supportsCombinedToolsAndSchema() {
+		return false;
+	}
+};
+/**
+* Promotes Groq's non-standard `x_groq.usage` to the standard `chunk.usage`
+* slot the base reads. Pass-through for chunks that already carry usage at
+* the documented location.
+*/
 async function* promoteGroqUsage(stream) {
-  for await (const chunk of stream) {
-    const groqChunk = chunk;
-    if (!chunk.usage && groqChunk.x_groq?.usage) {
-      yield { ...chunk, usage: groqChunk.x_groq.usage };
-    } else {
-      yield chunk;
-    }
-  }
+	for await (const chunk of stream) {
+		const groqChunk = chunk;
+		if (!chunk.usage && groqChunk.x_groq?.usage) yield {
+			...chunk,
+			usage: groqChunk.x_groq.usage
+		};
+		else yield chunk;
+	}
 }
+/**
+* Creates a Groq text adapter with explicit API key.
+*
+* @example
+* ```typescript
+* const adapter = createGroqText('llama-3.3-70b-versatile', "gsk_...");
+* ```
+*/
 function createGroqText(model, apiKey, config) {
-  return new GroqTextAdapter({ apiKey, ...config }, model);
+	return new GroqTextAdapter({
+		apiKey,
+		...config
+	}, model);
 }
+/**
+* Creates a Groq text adapter with API key from `GROQ_API_KEY`.
+*
+* @example
+* ```typescript
+* const adapter = groqText('llama-3.3-70b-versatile');
+* ```
+*/
 function groqText(model, config) {
-  const apiKey = getGroqApiKeyFromEnv();
-  return createGroqText(model, apiKey, config);
+	return createGroqText(model, getGroqApiKeyFromEnv(), config);
 }
-export {
-  GroqTextAdapter,
-  createGroqText,
-  groqText
-};
-//# sourceMappingURL=text.js.map
+//#endregion
+export { GroqTextAdapter, createGroqText, groqText };
+
+//# sourceMappingURL=text.js.map

package/dist/esm/adapters/text.js.map

@@ -1 +1 @@
-{"version":3,"file":"text.js","sources":["../../../src/adapters/text.ts"],"sourcesContent":["import OpenAI from 'openai'\nimport { OpenAIBaseChatCompletionsTextAdapter } from '@tanstack/openai-base'\nimport { getGroqApiKeyFromEnv, withGroqDefaults } from '../utils/client'\nimport { makeGroqStructuredOutputCompatible } from '../utils/schema-converter'\nimport type { Modality, TextOptions } from '@tanstack/ai'\nimport type {\n  GROQ_CHAT_MODELS,\n  GroqChatModelToolCapabilitiesByName,\n  ResolveInputModalities,\n  ResolveProviderOptions,\n} from '../model-meta'\nimport type { GroqMessageMetadataByModality } from '../message-types'\nimport type { GroqClientConfig } from '../utils/client'\n\ntype ResolveToolCapabilities<TModel extends string> =\n  TModel extends keyof GroqChatModelToolCapabilitiesByName\n    ? NonNullable<GroqChatModelToolCapabilitiesByName[TModel]>\n    : readonly []\n\n/**\n * Configuration for Groq text adapter\n */\nexport interface GroqTextConfig extends GroqClientConfig {}\n\n/**\n * Re-export of the public provider options type\n */\nexport type { ExternalTextProviderOptions as GroqTextProviderOptions } from '../text/text-provider-options'\n\n/**\n * Groq Text (Chat) Adapter\n *\n * Tree-shakeable adapter for Groq chat/text completion. Groq exposes an\n * OpenAI-compatible Chat Completions endpoint at `/openai/v1`, so we drive\n * it with the OpenAI SDK via a `baseURL` override (the same pattern as\n * `ai-grok`).\n *\n * Quirk: when usage is present on a stream, Groq historically delivered it\n * under `chunk.x_groq.usage` rather than `chunk.usage`. The override below\n * promotes it to the standard location so the base's RUN_FINISHED usage\n * accounting works unchanged.\n */\nexport class GroqTextAdapter<\n  TModel extends (typeof GROQ_CHAT_MODELS)[number],\n  TProviderOptions extends Record<string, any> = ResolveProviderOptions<TModel>,\n  TInputModalities extends ReadonlyArray<Modality> =\n    ResolveInputModalities<TModel>,\n  TToolCapabilities extends ReadonlyArray<string> =\n    ResolveToolCapabilities<TModel>,\n> extends OpenAIBaseChatCompletionsTextAdapter<\n  TModel,\n  TProviderOptions,\n  TInputModalities,\n  GroqMessageMetadataByModality,\n  TToolCapabilities\n> {\n  override readonly kind = 'text' as const\n  override readonly name = 'groq' as const\n\n  constructor(config: GroqTextConfig, model: TModel) {\n    super(model, 'groq', new OpenAI(withGroqDefaults(config)))\n  }\n\n  protected override makeStructuredOutputCompatible(\n    schema: Record<string, any>,\n    originalRequired?: Array<string>,\n  ): Record<string, any> {\n    return makeGroqStructuredOutputCompatible(schema, originalRequired)\n  }\n\n  protected override async *processStreamChunks(\n    stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>,\n    options: TextOptions,\n    aguiState: {\n      runId: string\n      threadId: string\n      messageId: string\n      hasEmittedRunStarted: boolean\n    },\n  ) {\n    yield* super.processStreamChunks(\n      promoteGroqUsage(stream),\n      options,\n      aguiState,\n    )\n  }\n\n  /**\n   * Surfaces Groq's reasoning deltas during streaming structured output.\n   * Groq emits `delta.reasoning` (or legacy `delta.reasoning_content`) on\n   * reasoning models when the caller sets `reasoning_format: 'parsed'` in\n   * modelOptions. The base's chatStream and structuredOutputStream both\n   * route reasoning through this hook.\n   */\n  protected override extractReasoning(\n    chunk: OpenAI.Chat.Completions.ChatCompletionChunk,\n  ): { text: string } | undefined {\n    const delta = chunk.choices[0]?.delta as\n      | { reasoning?: unknown; reasoning_content?: unknown }\n      | undefined\n    const raw = delta?.reasoning ?? delta?.reasoning_content\n    if (typeof raw === 'string' && raw.length > 0) {\n      return { text: raw }\n    }\n    return undefined\n  }\n\n  /**\n   * Groq's API rejects `response_format: json_schema` together with `tools`\n   * + `stream` (returns 400 — see Groq Structured Outputs docs:\n   * \"Streaming and tool use are not currently supported with Structured\n   * Outputs.\"). Force the engine onto the legacy finalization path even\n   * though the OpenAI Chat Completions base would otherwise opt in.\n   */\n  override supportsCombinedToolsAndSchema(): boolean {\n    return false\n  }\n}\n\n/**\n * Promotes Groq's non-standard `x_groq.usage` to the standard `chunk.usage`\n * slot the base reads. Pass-through for chunks that already carry usage at\n * the documented location.\n */\nasync function* promoteGroqUsage(\n  stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>,\n): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk> {\n  for await (const chunk of stream) {\n    const groqChunk = chunk as typeof chunk & {\n      x_groq?: { usage?: OpenAI.Chat.Completions.ChatCompletionChunk['usage'] }\n    }\n    if (!chunk.usage && groqChunk.x_groq?.usage) {\n      yield { ...chunk, usage: groqChunk.x_groq.usage }\n    } else {\n      yield chunk\n    }\n  }\n}\n\n/**\n * Creates a Groq text adapter with explicit API key.\n *\n * @example\n * ```typescript\n * const adapter = createGroqText('llama-3.3-70b-versatile', \"gsk_...\");\n * ```\n */\nexport function createGroqText<\n  TModel extends (typeof GROQ_CHAT_MODELS)[number],\n>(\n  model: TModel,\n  apiKey: string,\n  config?: Omit<GroqTextConfig, 'apiKey'>,\n): GroqTextAdapter<TModel> {\n  return new GroqTextAdapter({ apiKey, ...config }, model)\n}\n\n/**\n * Creates a Groq text adapter with API key from `GROQ_API_KEY`.\n *\n * @example\n * ```typescript\n * const adapter = groqText('llama-3.3-70b-versatile');\n * ```\n */\nexport function groqText<TModel extends (typeof GROQ_CHAT_MODELS)[number]>(\n  model: TModel,\n  config?: Omit<GroqTextConfig, 'apiKey'>,\n): GroqTextAdapter<TModel> {\n  const apiKey = getGroqApiKeyFromEnv()\n  return createGroqText(model, apiKey, config)\n}\n"],"names":[],"mappings":";;;;AA0CO,MAAM,wBAOH,qCAMR;AAAA,EACkB,OAAO;AAAA,EACP,OAAO;AAAA,EAEzB,YAAY,QAAwB,OAAe;AACjD,UAAM,OAAO,QAAQ,IAAI,OAAO,iBAAiB,MAAM,CAAC,CAAC;AAAA,EAC3D;AAAA,EAEmB,+BACjB,QACA,kBACqB;AACrB,WAAO,mCAAmC,QAAQ,gBAAgB;AAAA,EACpE;AAAA,EAEA,OAA0B,oBACxB,QACA,SACA,WAMA;AACA,WAAO,MAAM;AAAA,MACX,iBAAiB,MAAM;AAAA,MACvB;AAAA,MACA;AAAA,IAAA;AAAA,EAEJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASmB,iBACjB,OAC8B;AAC9B,UAAM,QAAQ,MAAM,QAAQ,CAAC,GAAG;AAGhC,UAAM,MAAM,OAAO,aAAa,OAAO;AACvC,QAAI,OAAO,QAAQ,YAAY,IAAI,SAAS,GAAG;AAC7C,aAAO,EAAE,MAAM,IAAA;AAAA,IACjB;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASS,iCAA0C;AACjD,WAAO;AAAA,EACT;AACF;AAOA,gBAAgB,iBACd,QAC4D;AAC5D,mBAAiB,SAAS,QAAQ;AAChC,UAAM,YAAY;AAGlB,QAAI,CAAC,MAAM,SAAS,UAAU,QAAQ,OAAO;AAC3C,YAAM,EAAE,GAAG,OAAO,OAAO,UAAU,OAAO,MAAA;AAAA,IAC5C,OAAO;AACL,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAUO,SAAS,eAGd,OACA,QACA,QACyB;AACzB,SAAO,IAAI,gBAAgB,EAAE,QAAQ,GAAG,OAAA,GAAU,KAAK;AACzD;AAUO,SAAS,SACd,OACA,QACyB;AACzB,QAAM,SAAS,qBAAA;AACf,SAAO,eAAe,OAAO,QAAQ,MAAM;AAC7C;"}
+{"version":3,"file":"text.js","names":[],"sources":["../../../src/adapters/text.ts"],"sourcesContent":["import OpenAI from 'openai'\nimport { OpenAIBaseChatCompletionsTextAdapter } from '@tanstack/openai-base'\nimport { getGroqApiKeyFromEnv, withGroqDefaults } from '../utils/client'\nimport { makeGroqStructuredOutputCompatible } from '../utils/schema-converter'\nimport type { Modality, TextOptions } from '@tanstack/ai'\nimport type {\n  GROQ_CHAT_MODELS,\n  GroqChatModelToolCapabilitiesByName,\n  ResolveInputModalities,\n  ResolveProviderOptions,\n} from '../model-meta'\nimport type { GroqMessageMetadataByModality } from '../message-types'\nimport type { GroqClientConfig } from '../utils/client'\n\ntype ResolveToolCapabilities<TModel extends string> =\n  TModel extends keyof GroqChatModelToolCapabilitiesByName\n    ? NonNullable<GroqChatModelToolCapabilitiesByName[TModel]>\n    : readonly []\n\n/**\n * Configuration for Groq text adapter\n */\nexport interface GroqTextConfig extends GroqClientConfig {}\n\n/**\n * Re-export of the public provider options type\n */\nexport type { ExternalTextProviderOptions as GroqTextProviderOptions } from '../text/text-provider-options'\n\n/**\n * Groq Text (Chat) Adapter\n *\n * Tree-shakeable adapter for Groq chat/text completion. Groq exposes an\n * OpenAI-compatible Chat Completions endpoint at `/openai/v1`, so we drive\n * it with the OpenAI SDK via a `baseURL` override (the same pattern as\n * `ai-grok`).\n *\n * Quirk: when usage is present on a stream, Groq historically delivered it\n * under `chunk.x_groq.usage` rather than `chunk.usage`. The override below\n * promotes it to the standard location so the base's RUN_FINISHED usage\n * accounting works unchanged.\n */\nexport class GroqTextAdapter<\n  TModel extends (typeof GROQ_CHAT_MODELS)[number],\n  TProviderOptions extends Record<string, any> = ResolveProviderOptions<TModel>,\n  TInputModalities extends ReadonlyArray<Modality> =\n    ResolveInputModalities<TModel>,\n  TToolCapabilities extends ReadonlyArray<string> =\n    ResolveToolCapabilities<TModel>,\n> extends OpenAIBaseChatCompletionsTextAdapter<\n  TModel,\n  TProviderOptions,\n  TInputModalities,\n  GroqMessageMetadataByModality,\n  TToolCapabilities\n> {\n  override readonly kind = 'text' as const\n  override readonly name = 'groq' as const\n\n  constructor(config: GroqTextConfig, model: TModel) {\n    super(model, 'groq', new OpenAI(withGroqDefaults(config)))\n  }\n\n  protected override makeStructuredOutputCompatible(\n    schema: Record<string, any>,\n    originalRequired?: Array<string>,\n  ): Record<string, any> {\n    return makeGroqStructuredOutputCompatible(schema, originalRequired)\n  }\n\n  protected override async *processStreamChunks(\n    stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>,\n    options: TextOptions,\n    aguiState: {\n      runId: string\n      threadId: string\n      messageId: string\n      hasEmittedRunStarted: boolean\n    },\n  ) {\n    yield* super.processStreamChunks(\n      promoteGroqUsage(stream),\n      options,\n      aguiState,\n    )\n  }\n\n  /**\n   * Surfaces Groq's reasoning deltas during streaming structured output.\n   * Groq emits `delta.reasoning` (or legacy `delta.reasoning_content`) on\n   * reasoning models when the caller sets `reasoning_format: 'parsed'` in\n   * modelOptions. The base's chatStream and structuredOutputStream both\n   * route reasoning through this hook.\n   */\n  protected override extractReasoning(\n    chunk: OpenAI.Chat.Completions.ChatCompletionChunk,\n  ): { text: string } | undefined {\n    const delta = chunk.choices[0]?.delta as\n      | { reasoning?: unknown; reasoning_content?: unknown }\n      | undefined\n    const raw = delta?.reasoning ?? delta?.reasoning_content\n    if (typeof raw === 'string' && raw.length > 0) {\n      return { text: raw }\n    }\n    return undefined\n  }\n\n  /**\n   * Groq's API rejects `response_format: json_schema` together with `tools`\n   * + `stream` (returns 400 — see Groq Structured Outputs docs:\n   * \"Streaming and tool use are not currently supported with Structured\n   * Outputs.\"). Force the engine onto the legacy finalization path even\n   * though the OpenAI Chat Completions base would otherwise opt in.\n   */\n  override supportsCombinedToolsAndSchema(): boolean {\n    return false\n  }\n}\n\n/**\n * Promotes Groq's non-standard `x_groq.usage` to the standard `chunk.usage`\n * slot the base reads. Pass-through for chunks that already carry usage at\n * the documented location.\n */\nasync function* promoteGroqUsage(\n  stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>,\n): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk> {\n  for await (const chunk of stream) {\n    const groqChunk = chunk as typeof chunk & {\n      x_groq?: { usage?: OpenAI.Chat.Completions.ChatCompletionChunk['usage'] }\n    }\n    if (!chunk.usage && groqChunk.x_groq?.usage) {\n      yield { ...chunk, usage: groqChunk.x_groq.usage }\n    } else {\n      yield chunk\n    }\n  }\n}\n\n/**\n * Creates a Groq text adapter with explicit API key.\n *\n * @example\n * ```typescript\n * const adapter = createGroqText('llama-3.3-70b-versatile', \"gsk_...\");\n * ```\n */\nexport function createGroqText<\n  TModel extends (typeof GROQ_CHAT_MODELS)[number],\n>(\n  model: TModel,\n  apiKey: string,\n  config?: Omit<GroqTextConfig, 'apiKey'>,\n): GroqTextAdapter<TModel> {\n  return new GroqTextAdapter({ apiKey, ...config }, model)\n}\n\n/**\n * Creates a Groq text adapter with API key from `GROQ_API_KEY`.\n *\n * @example\n * ```typescript\n * const adapter = groqText('llama-3.3-70b-versatile');\n * ```\n */\nexport function groqText<TModel extends (typeof GROQ_CHAT_MODELS)[number]>(\n  model: TModel,\n  config?: Omit<GroqTextConfig, 'apiKey'>,\n): GroqTextAdapter<TModel> {\n  const apiKey = getGroqApiKeyFromEnv()\n  return createGroqText(model, apiKey, config)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0CA,IAAa,kBAAb,cAOU,qCAMR;CACA,OAAyB;CACzB,OAAyB;CAEzB,YAAY,QAAwB,OAAe;EACjD,MAAM,OAAO,QAAQ,IAAI,OAAO,iBAAiB,MAAM,CAAC,CAAC;CAC3D;CAEA,+BACE,QACA,kBACqB;EACrB,OAAO,mCAAmC,QAAQ,gBAAgB;CACpE;CAEA,OAA0B,oBACxB,QACA,SACA,WAMA;EACA,OAAO,MAAM,oBACX,iBAAiB,MAAM,GACvB,SACA,SACF;CACF;;;;;;;;CASA,iBACE,OAC8B;EAC9B,MAAM,QAAQ,MAAM,QAAQ,EAAE,EAAE;EAGhC,MAAM,MAAM,OAAO,aAAa,OAAO;EACvC,IAAI,OAAO,QAAQ,YAAY,IAAI,SAAS,GAC1C,OAAO,EAAE,MAAM,IAAI;CAGvB;;;;;;;;CASA,iCAAmD;EACjD,OAAO;CACT;AACF;;;;;;AAOA,gBAAgB,iBACd,QAC4D;CAC5D,WAAW,MAAM,SAAS,QAAQ;EAChC,MAAM,YAAY;EAGlB,IAAI,CAAC,MAAM,SAAS,UAAU,QAAQ,OACpC,MAAM;GAAE,GAAG;GAAO,OAAO,UAAU,OAAO;EAAM;OAEhD,MAAM;CAEV;AACF;;;;;;;;;AAUA,SAAgB,eAGd,OACA,QACA,QACyB;CACzB,OAAO,IAAI,gBAAgB;EAAE;EAAQ,GAAG;CAAO,GAAG,KAAK;AACzD;;;;;;;;;AAUA,SAAgB,SACd,OACA,QACyB;CAEzB,OAAO,eAAe,OADP,qBACc,GAAQ,MAAM;AAC7C"}

package/dist/esm/adapters/transcription.js

@@ -1,179 +1,217 @@
+import { getGroqApiKeyFromEnv, withGroqDefaults } from "../utils/client.js";
+import { base64ToArrayBuffer, generateId } from "@tanstack/ai-utils";
 import { BaseTranscriptionAdapter } from "@tanstack/ai/adapters";
-import { generateId, base64ToArrayBuffer } from "@tanstack/ai-utils";
-import { withGroqDefaults, getGroqApiKeyFromEnv } from "../utils/client.js";
+//#region src/adapters/transcription.ts
+/**
+* Flattens the `openai` SDK's `HeadersLike` config value into a plain record so
+* it can be merged into the raw `fetch` request this adapter issues. Handles
+* the shapes callers actually pass (`Headers`, an entries array, or a plain
+* object); null/undefined values are dropped.
+*
+* ponytail: doesn't unwrap the SDK's internal `NullableHeaders` class; forward
+* that shape here if the SDK ever hands it to adapter config.
+*/
 function normalizeHeaders(headers) {
-  const out = {};
-  if (!headers) return out;
-  const assign = (key, value) => {
-    if (value != null) out[key] = String(value);
-  };
-  if (headers instanceof Headers) {
-    headers.forEach((value, key) => assign(key, value));
-  } else if (Array.isArray(headers)) {
-    for (const [key, value] of headers) assign(key, value);
-  } else {
-    for (const [key, value] of Object.entries(headers)) assign(key, value);
-  }
-  return out;
-}
-class GroqTranscriptionAdapter extends BaseTranscriptionAdapter {
-  name = "groq";
-  apiKey;
-  baseURL;
-  defaultHeaders;
-  constructor(config, model) {
-    super(model, {});
-    const resolved = withGroqDefaults(config);
-    this.apiKey = resolved.apiKey;
-    this.baseURL = resolved.baseURL ?? "https://api.groq.com/openai/v1";
-    this.defaultHeaders = normalizeHeaders(resolved.defaultHeaders);
-  }
-  async transcribe(options) {
-    const { model, audio, language, prompt, responseFormat, modelOptions } = options;
-    if (responseFormat === "srt" || responseFormat === "vtt") {
-      throw new Error(
-        `Groq transcription does not support responseFormat='${responseFormat}'. Supported values: 'json', 'text', 'verbose_json'.`
-      );
-    }
-    const effectiveFormat = responseFormat ?? "verbose_json";
-    const useVerbose = effectiveFormat === "verbose_json";
-    const form = new FormData();
-    form.append("model", model);
-    form.append("response_format", effectiveFormat);
-    if (language !== void 0) form.append("language", language);
-    if (prompt !== void 0) form.append("prompt", prompt);
-    if (modelOptions?.temperature !== void 0) {
-      form.append("temperature", String(modelOptions.temperature));
-    }
-    if (modelOptions?.timestamp_granularities !== void 0) {
-      for (const g of modelOptions.timestamp_granularities) {
-        form.append("timestamp_granularities[]", g);
-      }
-    }
-    if (typeof audio === "string" && /^https?:\/\//.test(audio)) {
-      form.append("url", audio);
-    } else {
-      form.append("file", this.prepareAudioFile(audio));
-    }
-    try {
-      options.logger.request(
-        `activity=transcription provider=${this.name} model=${model} verbose=${useVerbose}`,
-        { provider: this.name, model }
-      );
-      const response = await fetch(`${this.baseURL}/audio/transcriptions`, {
-        method: "POST",
-        headers: {
-          ...this.defaultHeaders,
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: form
-      });
-      if (!response.ok) {
-        const body = await response.json().catch(() => null);
-        const message = body?.error?.message ?? `Groq API error ${response.status}`;
-        throw new Error(message);
-      }
-      if (useVerbose) {
-        const data = await response.json();
-        const requestId = data.x_groq?.id ?? generateId(this.name);
-        const segments = data.segments?.map(
-          (seg) => ({
-            id: seg.id,
-            start: seg.start,
-            end: seg.end,
-            text: seg.text,
-            confidence: Math.exp(seg.avg_logprob)
-          })
-        );
-        const words = data.words?.map((w) => ({
-          word: w.word,
-          start: w.start,
-          end: w.end
-        }));
-        return {
-          id: requestId,
-          model,
-          text: data.text,
-          ...data.language !== void 0 && { language: data.language },
-          ...data.duration !== void 0 && { duration: data.duration },
-          ...segments !== void 0 && { segments },
-          ...words !== void 0 && { words }
-        };
-      } else if (effectiveFormat === "text") {
-        const text = await response.text();
-        return {
-          id: generateId(this.name),
-          model,
-          text,
-          ...language !== void 0 && { language }
-        };
-      } else {
-        const data = await response.json();
-        return {
-          id: data.x_groq?.id ?? generateId(this.name),
-          model,
-          text: data.text,
-          ...language !== void 0 && { language }
-        };
-      }
-    } catch (error) {
-      options.logger.errors(`${this.name}.transcribe fatal`, {
-        error,
-        source: `${this.name}.transcribe`
-      });
-      throw error;
-    }
-  }
-  prepareAudioFile(audio) {
-    if (typeof File !== "undefined" && audio instanceof File) {
-      return audio;
-    }
-    if (typeof Blob !== "undefined" && audio instanceof Blob) {
-      this.ensureFileSupport();
-      return new File([audio], "audio.mp3", {
-        type: audio.type || "audio/mpeg"
-      });
-    }
-    if (typeof ArrayBuffer !== "undefined" && audio instanceof ArrayBuffer) {
-      this.ensureFileSupport();
-      return new File([audio], "audio.mp3", { type: "audio/mpeg" });
-    }
-    if (typeof audio === "string") {
-      this.ensureFileSupport();
-      if (audio.startsWith("data:")) {
-        const parts = audio.split(",");
-        const header = parts[0];
-        const base64Data = parts[1] || "";
-        const mimeMatch = header?.match(/data:([^;]+)/);
-        const mimeType = mimeMatch?.[1] || "audio/mpeg";
-        const bytes2 = base64ToArrayBuffer(base64Data);
-        const extension = mimeType.split("/")[1] || "mp3";
-        return new File([bytes2], `audio.${extension}`, { type: mimeType });
-      }
-      const bytes = base64ToArrayBuffer(audio);
-      return new File([bytes], "audio.mp3", { type: "audio/mpeg" });
-    }
-    throw new Error("Invalid audio input type");
-  }
-  // Throws on Node < 20 where the global `File` constructor is unavailable.
-  ensureFileSupport() {
-    if (typeof File === "undefined") {
-      throw new Error(
-        "`File` is not available in this environment. Use Node.js 20 or newer, or pass a File object directly."
-      );
-    }
-  }
+	const out = {};
+	if (!headers) return out;
+	const assign = (key, value) => {
+		if (value != null) out[key] = String(value);
+	};
+	if (headers instanceof Headers) headers.forEach((value, key) => assign(key, value));
+	else if (Array.isArray(headers)) for (const [key, value] of headers) assign(key, value);
+	else for (const [key, value] of Object.entries(headers)) assign(key, value);
+	return out;
 }
+/**
+* Groq Transcription (Speech-to-Text) Adapter
+*
+* Tree-shakeable adapter for Groq audio transcription. Supports
+* whisper-large-v3 and whisper-large-v3-turbo.
+*
+* Features:
+* - Audio file uploads (File, Blob, ArrayBuffer, base64/data URL)
+* - Remote audio URLs passed directly via Groq's `url` field — no upload needed
+* - Verbose JSON response with segment and word timestamps
+* - Language detection or specification (ISO-639-1)
+* - Confidence scores derived from segment avg_logprob
+*/
+var GroqTranscriptionAdapter = class extends BaseTranscriptionAdapter {
+	name = "groq";
+	apiKey;
+	baseURL;
+	defaultHeaders;
+	constructor(config, model) {
+		super(model, {});
+		const resolved = withGroqDefaults(config);
+		this.apiKey = resolved.apiKey;
+		this.baseURL = resolved.baseURL ?? "https://api.groq.com/openai/v1";
+		this.defaultHeaders = normalizeHeaders(resolved.defaultHeaders);
+	}
+	async transcribe(options) {
+		const { model, audio, language, prompt, responseFormat, modelOptions } = options;
+		if (responseFormat === "srt" || responseFormat === "vtt") throw new Error(`Groq transcription does not support responseFormat='${responseFormat}'. Supported values: 'json', 'text', 'verbose_json'.`);
+		const effectiveFormat = responseFormat ?? "verbose_json";
+		const useVerbose = effectiveFormat === "verbose_json";
+		const form = new FormData();
+		form.append("model", model);
+		form.append("response_format", effectiveFormat);
+		if (language !== void 0) form.append("language", language);
+		if (prompt !== void 0) form.append("prompt", prompt);
+		if (modelOptions?.temperature !== void 0) form.append("temperature", String(modelOptions.temperature));
+		if (modelOptions?.timestamp_granularities !== void 0) for (const g of modelOptions.timestamp_granularities) form.append("timestamp_granularities[]", g);
+		if (typeof audio === "string" && /^https?:\/\//.test(audio)) form.append("url", audio);
+		else form.append("file", this.prepareAudioFile(audio));
+		try {
+			options.logger.request(`activity=transcription provider=${this.name} model=${model} verbose=${useVerbose}`, {
+				provider: this.name,
+				model
+			});
+			const response = await fetch(`${this.baseURL}/audio/transcriptions`, {
+				method: "POST",
+				headers: {
+					...this.defaultHeaders,
+					Authorization: `Bearer ${this.apiKey}`
+				},
+				body: form
+			});
+			if (!response.ok) {
+				const message = ((await response.json().catch(() => null))?.error)?.message ?? `Groq API error ${response.status}`;
+				throw new Error(message);
+			}
+			if (useVerbose) {
+				const data = await response.json();
+				const requestId = data.x_groq?.id ?? generateId(this.name);
+				const segments = data.segments?.map((seg) => ({
+					id: seg.id,
+					start: seg.start,
+					end: seg.end,
+					text: seg.text,
+					confidence: Math.exp(seg.avg_logprob)
+				}));
+				const words = data.words?.map((w) => ({
+					word: w.word,
+					start: w.start,
+					end: w.end
+				}));
+				return {
+					id: requestId,
+					model,
+					text: data.text,
+					...data.language !== void 0 && { language: data.language },
+					...data.duration !== void 0 && { duration: data.duration },
+					...segments !== void 0 && { segments },
+					...words !== void 0 && { words }
+				};
+			} else if (effectiveFormat === "text") {
+				const text = await response.text();
+				return {
+					id: generateId(this.name),
+					model,
+					text,
+					...language !== void 0 && { language }
+				};
+			} else {
+				const data = await response.json();
+				return {
+					id: data.x_groq?.id ?? generateId(this.name),
+					model,
+					text: data.text,
+					...language !== void 0 && { language }
+				};
+			}
+		} catch (error) {
+			options.logger.errors(`${this.name}.transcribe fatal`, {
+				error,
+				source: `${this.name}.transcribe`
+			});
+			throw error;
+		}
+	}
+	prepareAudioFile(audio) {
+		if (typeof File !== "undefined" && audio instanceof File) return audio;
+		if (typeof Blob !== "undefined" && audio instanceof Blob) {
+			this.ensureFileSupport();
+			return new File([audio], "audio.mp3", { type: audio.type || "audio/mpeg" });
+		}
+		if (typeof ArrayBuffer !== "undefined" && audio instanceof ArrayBuffer) {
+			this.ensureFileSupport();
+			return new File([audio], "audio.mp3", { type: "audio/mpeg" });
+		}
+		if (typeof audio === "string") {
+			this.ensureFileSupport();
+			if (audio.startsWith("data:")) {
+				const parts = audio.split(",");
+				const header = parts[0];
+				const base64Data = parts[1] || "";
+				const mimeType = (header?.match(/data:([^;]+)/))?.[1] || "audio/mpeg";
+				const bytes = base64ToArrayBuffer(base64Data);
+				const extension = mimeType.split("/")[1] || "mp3";
+				return new File([bytes], `audio.${extension}`, { type: mimeType });
+			}
+			const bytes = base64ToArrayBuffer(audio);
+			return new File([bytes], "audio.mp3", { type: "audio/mpeg" });
+		}
+		throw new Error("Invalid audio input type");
+	}
+	ensureFileSupport() {
+		if (typeof File === "undefined") throw new Error("`File` is not available in this environment. Use Node.js 20 or newer, or pass a File object directly.");
+	}
+};
+/**
+* Creates a Groq transcription adapter with an explicit API key.
+* Type resolution happens here at the call site.
+*
+* @param model - The model name (e.g., 'whisper-large-v3-turbo')
+* @param apiKey - Your Groq API key
+* @param config - Optional additional configuration
+* @returns Configured Groq transcription adapter instance
+*
+* @example
+* ```typescript
+* const adapter = createGroqTranscription('whisper-large-v3-turbo', 'gsk_...');
+*
+* const result = await generateTranscription({
+*   adapter,
+*   audio: audioFile,
+*   language: 'en',
+* });
+* ```
+*/
 function createGroqTranscription(model, apiKey, config) {
-  return new GroqTranscriptionAdapter({ apiKey, ...config }, model);
+	return new GroqTranscriptionAdapter({
+		apiKey,
+		...config
+	}, model);
 }
+/**
+* Creates a Groq transcription adapter using the `GROQ_API_KEY` environment
+* variable. Type resolution happens here at the call site.
+*
+* Looks for `GROQ_API_KEY` in:
+* - `process.env` (Node.js)
+* - `window.env` (browser with injected env)
+*
+* @param model - The model name (e.g., 'whisper-large-v3-turbo')
+* @param config - Optional configuration (excluding apiKey which is auto-detected)
+* @returns Configured Groq transcription adapter instance
+* @throws Error if GROQ_API_KEY is not found in environment
+*
+* @example
+* ```typescript
+* const adapter = groqTranscription('whisper-large-v3-turbo');
+*
+* const result = await generateTranscription({
+*   adapter,
+*   audio: 'https://example.com/audio.mp3',
+* });
+*
+* console.log(result.text)
+* ```
+*/
 function groqTranscription(model, config) {
-  const apiKey = getGroqApiKeyFromEnv();
-  return createGroqTranscription(model, apiKey, config);
+	return createGroqTranscription(model, getGroqApiKeyFromEnv(), config);
 }
-export {
-  GroqTranscriptionAdapter,
-  createGroqTranscription,
-  groqTranscription
-};
-//# sourceMappingURL=transcription.js.map
+//#endregion
+export { GroqTranscriptionAdapter, createGroqTranscription, groqTranscription };
+
+//# sourceMappingURL=transcription.js.map