@tanstack/ai-grok 0.14.1 → 0.14.3

package/dist/esm/adapters/transcription.js

@@ -1,122 +0,0 @@
-import { BaseTranscriptionAdapter } from "@tanstack/ai/adapters";
-import { generateId } from "@tanstack/ai-utils";
-import { getGrokApiKeyFromEnv } from "../utils/client.js";
-import "@tanstack/openai-base";
-import { toAudioFile } from "../utils/audio.js";
-const DEFAULT_GROK_BASE_URL = "https://api.x.ai/v1";
-class GrokTranscriptionAdapter extends BaseTranscriptionAdapter {
-  name = "grok";
-  apiKey;
-  baseURL;
-  defaultHeaders;
-  constructor(config, model) {
-    super(model, config);
-    this.apiKey = config.apiKey;
-    this.baseURL = (config.baseURL ?? DEFAULT_GROK_BASE_URL).replace(/\/+$/, "");
-    this.defaultHeaders = config.defaultHeaders ?? {};
-  }
-  async transcribe(options) {
-    const { logger } = options;
-    const { model, audio, language, modelOptions } = options;
-    logger.request(
-      `activity=generateTranscription provider=grok model=${model}`,
-      { provider: "grok", model }
-    );
-    const file = toAudioFile(audio, modelOptions?.audio_format);
-    const form = buildTranscriptionFormData({ file, language, modelOptions });
-    try {
-      const response = await fetch(`${this.baseURL}/stt`, {
-        method: "POST",
-        headers: {
-          // `defaultHeaders` first so Authorization always wins.
-          ...this.defaultHeaders,
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: form
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(
-          `Grok transcription request failed: ${response.status} ${errorText}`
-        );
-      }
-      const data = await response.json();
-      const words = data.words?.map(
-        (w) => {
-          const tw = {
-            word: w.text,
-            start: w.start,
-            end: w.end
-          };
-          if (w.confidence !== void 0) tw.confidence = w.confidence;
-          if (w.speaker !== void 0) tw.speaker = w.speaker;
-          return tw;
-        }
-      );
-      const resolvedLanguage = data.language ?? language;
-      const usage = data.duration !== void 0 && data.duration > 0 ? {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0,
-        durationSeconds: data.duration
-      } : void 0;
-      return {
-        id: generateId(this.name),
-        model,
-        text: data.text,
-        ...resolvedLanguage !== void 0 && { language: resolvedLanguage },
-        duration: data.duration,
-        ...words !== void 0 && { words },
-        ...usage !== void 0 && { usage }
-      };
-    } catch (error) {
-      logger.errors("grok.transcribe fatal", {
-        error,
-        source: "grok.transcribe"
-      });
-      throw error;
-    }
-  }
-}
-function buildTranscriptionFormData(options) {
-  const { file, language, modelOptions } = options;
-  const form = new FormData();
-  form.set("file", file);
-  if (language) form.set("language", language);
-  if (modelOptions?.audio_format !== void 0) {
-    form.set("audio_format", modelOptions.audio_format);
-  }
-  if (modelOptions?.sample_rate !== void 0) {
-    form.set("sample_rate", String(modelOptions.sample_rate));
-  }
-  if (modelOptions?.inverse_text_normalization !== void 0) {
-    form.set(
-      "format",
-      modelOptions.inverse_text_normalization ? "true" : "false"
-    );
-  }
-  if (modelOptions?.multichannel !== void 0) {
-    form.set("multichannel", modelOptions.multichannel ? "true" : "false");
-  }
-  if (modelOptions?.channels !== void 0) {
-    form.set("channels", String(modelOptions.channels));
-  }
-  if (modelOptions?.diarize !== void 0) {
-    form.set("diarize", modelOptions.diarize ? "true" : "false");
-  }
-  return form;
-}
-function createGrokTranscription(model, apiKey, config) {
-  return new GrokTranscriptionAdapter({ apiKey, ...config }, model);
-}
-function grokTranscription(model, config) {
-  const apiKey = getGrokApiKeyFromEnv();
-  return createGrokTranscription(model, apiKey, config);
-}
-export {
-  GrokTranscriptionAdapter,
-  buildTranscriptionFormData,
-  createGrokTranscription,
-  grokTranscription
-};
-//# sourceMappingURL=transcription.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"transcription.js","sources":["../../../src/adapters/transcription.ts"],"sourcesContent":["import { BaseTranscriptionAdapter } from '@tanstack/ai/adapters'\nimport { generateId, getGrokApiKeyFromEnv, toAudioFile } from '../utils'\nimport type {\n  TokenUsage,\n  TranscriptionOptions,\n  TranscriptionResult,\n  TranscriptionWord,\n} from '@tanstack/ai'\nimport type { GrokTranscriptionModel } from '../model-meta'\nimport type { GrokTranscriptionProviderOptions } from '../audio/transcription-provider-options'\n\n/**\n * Grok-specific extension of `TranscriptionWord` that surfaces the extra\n * fields xAI returns when diarization / confidence are enabled. The base\n * cross-provider `TranscriptionWord` contract doesn't include these, so\n * callers who know they're using Grok can narrow with:\n *\n * ```ts\n * const words = result.words as Array<GrokTranscriptionWord> | undefined\n * ```\n */\nexport interface GrokTranscriptionWord extends TranscriptionWord {\n  /** Model confidence for the word, when xAI returns one. */\n  confidence?: number\n  /** Speaker index, populated when `modelOptions.diarize === true`. */\n  speaker?: number\n}\n\nconst DEFAULT_GROK_BASE_URL = 'https://api.x.ai/v1'\n\n/**\n * Configuration for the Grok transcription adapter.\n *\n * Uses direct `fetch` rather than the OpenAI SDK because xAI's `/v1/stt`\n * endpoint is not OpenAI-compatible.\n */\nexport interface GrokTranscriptionConfig {\n  apiKey: string\n  baseURL?: string\n  /** Additional headers to merge into every request (e.g., test IDs). */\n  defaultHeaders?: Record<string, string>\n}\n\n/**\n * xAI STT response shape from `POST /v1/stt`.\n * Grok returns word-level timestamps only; no segment array.\n */\ninterface GrokSTTWord {\n  text: string\n  start: number\n  end: number\n  confidence?: number\n  speaker?: number\n}\n\ninterface GrokSTTResponse {\n  text: string\n  language?: string\n  duration?: number\n  words?: Array<GrokSTTWord>\n  channels?: Array<unknown>\n}\n\n/**\n * Grok Speech-to-Text Adapter.\n *\n * Talks to `POST {baseURL}/stt` per\n * https://docs.x.ai/developers/rest-api-reference/inference/voice\n */\nexport class GrokTranscriptionAdapter<\n  TModel extends GrokTranscriptionModel,\n> extends BaseTranscriptionAdapter<TModel, GrokTranscriptionProviderOptions> {\n  readonly name = 'grok' as const\n\n  private readonly apiKey: string\n  private readonly baseURL: string\n  private readonly defaultHeaders: Record<string, string>\n\n  constructor(config: GrokTranscriptionConfig, model: TModel) {\n    super(model, config)\n    this.apiKey = config.apiKey\n    this.baseURL = (config.baseURL ?? DEFAULT_GROK_BASE_URL).replace(/\\/+$/, '')\n    this.defaultHeaders = config.defaultHeaders ?? {}\n  }\n\n  async transcribe(\n    options: TranscriptionOptions<GrokTranscriptionProviderOptions>,\n  ): Promise<TranscriptionResult> {\n    const { logger } = options\n    const { model, audio, language, modelOptions } = options\n\n    logger.request(\n      `activity=generateTranscription provider=grok model=${model}`,\n      { provider: 'grok', model },\n    )\n\n    const file = toAudioFile(audio, modelOptions?.audio_format)\n    const form = buildTranscriptionFormData({ file, language, modelOptions })\n\n    try {\n      const response = await fetch(`${this.baseURL}/stt`, {\n        method: 'POST',\n        headers: {\n          // `defaultHeaders` first so Authorization always wins.\n          ...this.defaultHeaders,\n          Authorization: `Bearer ${this.apiKey}`,\n        },\n        body: form,\n      })\n\n      if (!response.ok) {\n        const errorText = await response.text()\n        throw new Error(\n          `Grok transcription request failed: ${response.status} ${errorText}`,\n        )\n      }\n\n      const data = (await response.json()) as GrokSTTResponse\n\n      const words: Array<TranscriptionWord> | undefined = data.words?.map(\n        (w) => {\n          // Construct a GrokTranscriptionWord so that `confidence` and\n          // `speaker` (when xAI returns them under `diarize` / confidence\n          // mode) are preserved on the result. The returned array is typed\n          // as `Array<TranscriptionWord>` per the cross-provider contract;\n          // callers who want the extras narrow via `as Array<GrokTranscriptionWord>`.\n          const tw: GrokTranscriptionWord = {\n            word: w.text,\n            start: w.start,\n            end: w.end,\n          }\n          if (w.confidence !== undefined) tw.confidence = w.confidence\n          if (w.speaker !== undefined) tw.speaker = w.speaker\n          return tw\n        },\n      )\n\n      const resolvedLanguage = data.language ?? language\n      // xAI's /v1/stt response carries no token counts — STT is duration-billed —\n      // so surface the audio duration as `durationSeconds`, mirroring the\n      // whisper-1 path in the OpenAI transcription adapter.\n      const usage: TokenUsage | undefined =\n        data.duration !== undefined && data.duration > 0\n          ? {\n              promptTokens: 0,\n              completionTokens: 0,\n              totalTokens: 0,\n              durationSeconds: data.duration,\n            }\n          : undefined\n      return {\n        id: generateId(this.name),\n        model,\n        text: data.text,\n        ...(resolvedLanguage !== undefined && { language: resolvedLanguage }),\n        duration: data.duration,\n        ...(words !== undefined && { words }),\n        ...(usage !== undefined && { usage }),\n      }\n    } catch (error) {\n      logger.errors('grok.transcribe fatal', {\n        error,\n        source: 'grok.transcribe',\n      })\n      throw error\n    }\n  }\n}\n\n/**\n * Build the multipart/form-data body for `POST /v1/stt`, coercing SDK-level\n * model options into xAI's wire format (booleans as `'true'`/`'false'`\n * strings, numeric fields stringified, etc.).\n *\n * Wire-field mapping:\n *   - `modelOptions.inverse_text_normalization` → `format` (xAI's chosen\n *     wire-field name for the ITN boolean; the SDK surfaces it under the\n *     clearer `inverse_text_normalization` key).\n *   - `modelOptions.audio_format`, `sample_rate`, `multichannel`, `channels`,\n *     `diarize` map to same-named form fields.\n */\nexport function buildTranscriptionFormData(options: {\n  file: File\n  language: string | undefined\n  modelOptions: GrokTranscriptionProviderOptions | undefined\n}): FormData {\n  const { file, language, modelOptions } = options\n  const form = new FormData()\n  form.set('file', file)\n  if (language) form.set('language', language)\n  if (modelOptions?.audio_format !== undefined) {\n    form.set('audio_format', modelOptions.audio_format)\n  }\n  if (modelOptions?.sample_rate !== undefined) {\n    form.set('sample_rate', String(modelOptions.sample_rate))\n  }\n  if (modelOptions?.inverse_text_normalization !== undefined) {\n    form.set(\n      'format',\n      modelOptions.inverse_text_normalization ? 'true' : 'false',\n    )\n  }\n  if (modelOptions?.multichannel !== undefined) {\n    form.set('multichannel', modelOptions.multichannel ? 'true' : 'false')\n  }\n  if (modelOptions?.channels !== undefined) {\n    form.set('channels', String(modelOptions.channels))\n  }\n  if (modelOptions?.diarize !== undefined) {\n    form.set('diarize', modelOptions.diarize ? 'true' : 'false')\n  }\n  return form\n}\n\n/**\n * Creates a Grok transcription adapter with an explicit API key.\n *\n * @example\n * ```typescript\n * const adapter = createGrokTranscription('grok-stt', 'xai-...')\n * const result = await generateTranscription({\n *   adapter,\n *   audio: audioFile,\n *   language: 'en',\n * })\n * ```\n */\nexport function createGrokTranscription<TModel extends GrokTranscriptionModel>(\n  model: TModel,\n  apiKey: string,\n  config?: Omit<GrokTranscriptionConfig, 'apiKey'>,\n): GrokTranscriptionAdapter<TModel> {\n  return new GrokTranscriptionAdapter({ apiKey, ...config }, model)\n}\n\n/**\n * Creates a Grok transcription adapter, reading the API key from\n * `XAI_API_KEY` in the environment.\n *\n * @throws Error if `XAI_API_KEY` is not set.\n */\nexport function grokTranscription<TModel extends GrokTranscriptionModel>(\n  model: TModel,\n  config?: Omit<GrokTranscriptionConfig, 'apiKey'>,\n): GrokTranscriptionAdapter<TModel> {\n  const apiKey = getGrokApiKeyFromEnv()\n  return createGrokTranscription(model, apiKey, config)\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/adapters/tts.d.ts

@@ -1,70 +0,0 @@
-import { BaseTTSAdapter } from '@tanstack/ai/adapters';
-import { TTSOptions, TTSResult } from '@tanstack/ai';
-import { GrokTTSModel } from '../model-meta.js';
-import { GrokTTSCodec, GrokTTSProviderOptions } from '../audio/tts-provider-options.js';
-/**
- * Configuration for the Grok TTS adapter.
- *
- * Unlike chat/image/summarize adapters, TTS does not use the OpenAI SDK
- * because xAI's `/v1/tts` endpoint is not OpenAI-compatible. This config
- * is a minimal subset suitable for direct `fetch` calls.
- */
-export interface GrokSpeechConfig {
-    apiKey: string;
-    baseURL?: string;
-    /** Additional headers to merge into every request (e.g., test IDs). */
-    defaultHeaders?: Record<string, string>;
-}
-/**
- * Grok Text-to-Speech Adapter.
- *
- * Talks to `POST {baseURL}/tts` per
- * https://docs.x.ai/developers/model-capabilities/audio/text-to-speech
- */
-export declare class GrokSpeechAdapter<TModel extends GrokTTSModel> extends BaseTTSAdapter<TModel, GrokTTSProviderOptions> {
-    readonly name: "grok";
-    private readonly apiKey;
-    private readonly baseURL;
-    private readonly defaultHeaders;
-    constructor(config: GrokSpeechConfig, model: TModel);
-    generateSpeech(options: TTSOptions<GrokTTSProviderOptions>): Promise<TTSResult>;
-}
-/**
- * Build the JSON body for `POST /v1/tts`, resolving codec / sample-rate / voice
- * defaults in one place.
- *
- * Returns the request `body`, the resolved `codec`, and the `sampleRateForContentType`
- * used by the caller to label the response via `getContentType`.
- */
-export declare function buildTTSRequestBody(options: {
-    text: string;
-    voice: string | undefined;
-    format: TTSOptions['format'] | undefined;
-    modelOptions: GrokTTSProviderOptions | undefined;
-}): {
-    body: Record<string, unknown>;
-    codec: GrokTTSCodec;
-    sampleRateForContentType: number;
-};
-export declare function getContentType(codec: GrokTTSCodec, sampleRate: number): string;
-/**
- * Creates a Grok speech (TTS) adapter with an explicit API key.
- *
- * @example
- * ```typescript
- * const adapter = createGrokSpeech('grok-tts', 'xai-...')
- * const result = await generateSpeech({
- *   adapter,
- *   text: 'Hello from Grok',
- *   voice: 'eve',
- * })
- * ```
- */
-export declare function createGrokSpeech<TModel extends GrokTTSModel>(model: TModel, apiKey: string, config?: Omit<GrokSpeechConfig, 'apiKey'>): GrokSpeechAdapter<TModel>;
-/**
- * Creates a Grok speech (TTS) adapter, reading the API key from
- * `XAI_API_KEY` in the environment.
- *
- * @throws Error if `XAI_API_KEY` is not set.
- */
-export declare function grokSpeech<TModel extends GrokTTSModel>(model: TModel, config?: Omit<GrokSpeechConfig, 'apiKey'>): GrokSpeechAdapter<TModel>;

package/dist/esm/adapters/tts.js

@@ -1,142 +0,0 @@
-import { BaseTTSAdapter } from "@tanstack/ai/adapters";
-import { generateId } from "@tanstack/ai-utils";
-import { getGrokApiKeyFromEnv } from "../utils/client.js";
-import "@tanstack/openai-base";
-import { arrayBufferToBase64 } from "../utils/audio.js";
-const DEFAULT_GROK_BASE_URL = "https://api.x.ai/v1";
-class GrokSpeechAdapter extends BaseTTSAdapter {
-  name = "grok";
-  apiKey;
-  baseURL;
-  defaultHeaders;
-  constructor(config, model) {
-    super(model, config);
-    this.apiKey = config.apiKey;
-    this.baseURL = (config.baseURL ?? DEFAULT_GROK_BASE_URL).replace(/\/+$/, "");
-    this.defaultHeaders = config.defaultHeaders ?? {};
-  }
-  async generateSpeech(options) {
-    const { logger } = options;
-    const { model, text, voice, format, modelOptions } = options;
-    logger.request(`activity=generateSpeech provider=grok model=${model}`, {
-      provider: "grok",
-      model
-    });
-    const { body, codec, sampleRateForContentType } = buildTTSRequestBody({
-      text,
-      voice,
-      format,
-      modelOptions
-    });
-    try {
-      const response = await fetch(`${this.baseURL}/tts`, {
-        method: "POST",
-        headers: {
-          // `defaultHeaders` first so the adapter's Authorization / Content-Type
-          // always win — otherwise a caller-supplied `Authorization` header
-          // could silently clobber the bearer token.
-          ...this.defaultHeaders,
-          Authorization: `Bearer ${this.apiKey}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(
-          `Grok TTS request failed: ${response.status} ${errorText}`
-        );
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      const audio = arrayBufferToBase64(arrayBuffer);
-      return {
-        id: generateId(this.name),
-        model,
-        audio,
-        format: codec,
-        contentType: getContentType(codec, sampleRateForContentType)
-      };
-    } catch (error) {
-      logger.errors("grok.generateSpeech fatal", {
-        error,
-        source: "grok.generateSpeech"
-      });
-      throw error;
-    }
-  }
-}
-function buildTTSRequestBody(options) {
-  const { text, voice, format, modelOptions } = options;
-  const codec = pickCodec(modelOptions?.codec, format);
-  const callerSampleRate = modelOptions?.sample_rate;
-  const pcmDefault = 24e3;
-  const needsRateInContentType = codec === "pcm";
-  const outputFormat = { codec };
-  if (callerSampleRate !== void 0) {
-    outputFormat.sample_rate = callerSampleRate;
-  } else if (needsRateInContentType) {
-    outputFormat.sample_rate = pcmDefault;
-  }
-  if (codec === "mp3" && modelOptions?.bit_rate !== void 0) {
-    outputFormat.bit_rate = modelOptions.bit_rate;
-  }
-  const sampleRateForContentType = callerSampleRate ?? pcmDefault;
-  const body = {
-    text,
-    voice_id: voice ?? "eve",
-    language: modelOptions?.language ?? "en",
-    output_format: outputFormat
-  };
-  if (modelOptions?.optimize_streaming_latency !== void 0) {
-    body.optimize_streaming_latency = modelOptions.optimize_streaming_latency;
-  }
-  if (modelOptions?.text_normalization !== void 0) {
-    body.text_normalization = modelOptions.text_normalization;
-  }
-  return { body, codec, sampleRateForContentType };
-}
-function pickCodec(codecOverride, format) {
-  if (codecOverride) return codecOverride;
-  if (!format) return "mp3";
-  switch (format) {
-    case "mp3":
-    case "wav":
-    case "pcm":
-      return format;
-    case "flac":
-    case "opus":
-    case "aac":
-      return "mp3";
-    default:
-      return "mp3";
-  }
-}
-function getContentType(codec, sampleRate) {
-  switch (codec) {
-    case "mp3":
-      return "audio/mpeg";
-    case "wav":
-      return "audio/wav";
-    case "pcm":
-      return `audio/L16;rate=${sampleRate}`;
-    case "mulaw":
-      return sampleRate === 8e3 ? "audio/basic" : `audio/PCMU;rate=${sampleRate}`;
-    case "alaw":
-      return sampleRate === 8e3 ? "audio/x-alaw-basic" : `audio/PCMA;rate=${sampleRate}`;
-  }
-}
-function createGrokSpeech(model, apiKey, config) {
-  return new GrokSpeechAdapter({ apiKey, ...config }, model);
-}
-function grokSpeech(model, config) {
-  const apiKey = getGrokApiKeyFromEnv();
-  return createGrokSpeech(model, apiKey, config);
-}
-export {
-  GrokSpeechAdapter,
-  buildTTSRequestBody,
-  createGrokSpeech,
-  getContentType,
-  grokSpeech
-};
-//# sourceMappingURL=tts.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tts.js","sources":["../../../src/adapters/tts.ts"],"sourcesContent":["import { BaseTTSAdapter } from '@tanstack/ai/adapters'\nimport { arrayBufferToBase64, generateId, getGrokApiKeyFromEnv } from '../utils'\nimport type { TTSOptions, TTSResult } from '@tanstack/ai'\nimport type { GrokTTSModel } from '../model-meta'\nimport type {\n  GrokTTSCodec,\n  GrokTTSProviderOptions,\n} from '../audio/tts-provider-options'\n\nconst DEFAULT_GROK_BASE_URL = 'https://api.x.ai/v1'\n\n/**\n * Configuration for the Grok TTS adapter.\n *\n * Unlike chat/image/summarize adapters, TTS does not use the OpenAI SDK\n * because xAI's `/v1/tts` endpoint is not OpenAI-compatible. This config\n * is a minimal subset suitable for direct `fetch` calls.\n */\nexport interface GrokSpeechConfig {\n  apiKey: string\n  baseURL?: string\n  /** Additional headers to merge into every request (e.g., test IDs). */\n  defaultHeaders?: Record<string, string>\n}\n\n/**\n * Grok Text-to-Speech Adapter.\n *\n * Talks to `POST {baseURL}/tts` per\n * https://docs.x.ai/developers/model-capabilities/audio/text-to-speech\n */\nexport class GrokSpeechAdapter<\n  TModel extends GrokTTSModel,\n> extends BaseTTSAdapter<TModel, GrokTTSProviderOptions> {\n  readonly name = 'grok' as const\n\n  private readonly apiKey: string\n  private readonly baseURL: string\n  private readonly defaultHeaders: Record<string, string>\n\n  constructor(config: GrokSpeechConfig, model: TModel) {\n    super(model, config)\n    this.apiKey = config.apiKey\n    this.baseURL = (config.baseURL ?? DEFAULT_GROK_BASE_URL).replace(/\\/+$/, '')\n    this.defaultHeaders = config.defaultHeaders ?? {}\n  }\n\n  async generateSpeech(\n    options: TTSOptions<GrokTTSProviderOptions>,\n  ): Promise<TTSResult> {\n    const { logger } = options\n    const { model, text, voice, format, modelOptions } = options\n\n    logger.request(`activity=generateSpeech provider=grok model=${model}`, {\n      provider: 'grok',\n      model,\n    })\n\n    const { body, codec, sampleRateForContentType } = buildTTSRequestBody({\n      text,\n      voice,\n      format,\n      modelOptions,\n    })\n\n    try {\n      const response = await fetch(`${this.baseURL}/tts`, {\n        method: 'POST',\n        headers: {\n          // `defaultHeaders` first so the adapter's Authorization / Content-Type\n          // always win — otherwise a caller-supplied `Authorization` header\n          // could silently clobber the bearer token.\n          ...this.defaultHeaders,\n          Authorization: `Bearer ${this.apiKey}`,\n          'Content-Type': 'application/json',\n        },\n        body: JSON.stringify(body),\n      })\n\n      if (!response.ok) {\n        const errorText = await response.text()\n        throw new Error(\n          `Grok TTS request failed: ${response.status} ${errorText}`,\n        )\n      }\n\n      const arrayBuffer = await response.arrayBuffer()\n      const audio = arrayBufferToBase64(arrayBuffer)\n\n      return {\n        id: generateId(this.name),\n        model,\n        audio,\n        format: codec,\n        contentType: getContentType(codec, sampleRateForContentType),\n      }\n    } catch (error) {\n      logger.errors('grok.generateSpeech fatal', {\n        error,\n        source: 'grok.generateSpeech',\n      })\n      throw error\n    }\n  }\n}\n\n/**\n * Build the JSON body for `POST /v1/tts`, resolving codec / sample-rate / voice\n * defaults in one place.\n *\n * Returns the request `body`, the resolved `codec`, and the `sampleRateForContentType`\n * used by the caller to label the response via `getContentType`.\n */\nexport function buildTTSRequestBody(options: {\n  text: string\n  voice: string | undefined\n  format: TTSOptions['format'] | undefined\n  modelOptions: GrokTTSProviderOptions | undefined\n}): {\n  body: Record<string, unknown>\n  codec: GrokTTSCodec\n  sampleRateForContentType: number\n} {\n  const { text, voice, format, modelOptions } = options\n\n  const codec = pickCodec(modelOptions?.codec, format)\n\n  // Only forward `sample_rate` when either:\n  //   - the caller explicitly set `modelOptions.sample_rate`, or\n  //   - the codec's Content-Type carries the rate (pcm → audio/L16;rate=…).\n  // For mp3/wav/opus/aac/flac we leave sample_rate unset so xAI's server\n  // default applies.\n  const callerSampleRate = modelOptions?.sample_rate\n  // Default sample rate documented in GrokTTSProviderOptions is 24000 Hz —\n  // used only when we MUST attach a rate to the contentType (pcm) and the\n  // caller didn't pick one.\n  const pcmDefault = 24000\n  const needsRateInContentType = codec === 'pcm'\n\n  const outputFormat: Record<string, unknown> = { codec }\n  if (callerSampleRate !== undefined) {\n    outputFormat.sample_rate = callerSampleRate\n  } else if (needsRateInContentType) {\n    outputFormat.sample_rate = pcmDefault\n  }\n  if (codec === 'mp3' && modelOptions?.bit_rate !== undefined) {\n    outputFormat.bit_rate = modelOptions.bit_rate\n  }\n\n  // pcm embeds the rate in `audio/L16;rate=…`; mulaw/alaw embed it in\n  // `audio/PCMU;rate=…` / `audio/PCMA;rate=…` when non-default. mp3/wav\n  // don't carry a rate parameter so the value is unused for those.\n  const sampleRateForContentType = callerSampleRate ?? pcmDefault\n\n  const body: Record<string, unknown> = {\n    text,\n    voice_id: voice ?? 'eve',\n    language: modelOptions?.language ?? 'en',\n    output_format: outputFormat,\n  }\n  if (modelOptions?.optimize_streaming_latency !== undefined) {\n    body.optimize_streaming_latency = modelOptions.optimize_streaming_latency\n  }\n  if (modelOptions?.text_normalization !== undefined) {\n    body.text_normalization = modelOptions.text_normalization\n  }\n\n  return { body, codec, sampleRateForContentType }\n}\n\n/**\n * Maps the cross-provider `TTSOptions.format` onto Grok's supported codecs.\n * `opus`, `aac`, and `flac` are not supported by xAI TTS (which only exposes\n * mp3/wav/pcm/mulaw/alaw) — we fall back to mp3. An explicit\n * `modelOptions.codec` always wins.\n */\nfunction pickCodec(\n  codecOverride: GrokTTSCodec | undefined,\n  format: TTSOptions['format'] | undefined,\n): GrokTTSCodec {\n  if (codecOverride) return codecOverride\n  if (!format) return 'mp3'\n  switch (format) {\n    case 'mp3':\n    case 'wav':\n    case 'pcm':\n      return format\n    case 'flac':\n    case 'opus':\n    case 'aac':\n      return 'mp3'\n    default:\n      return 'mp3'\n  }\n}\n\nexport function getContentType(\n  codec: GrokTTSCodec,\n  sampleRate: number,\n): string {\n  switch (codec) {\n    case 'mp3':\n      return 'audio/mpeg'\n    case 'wav':\n      return 'audio/wav'\n    case 'pcm':\n      // `audio/L16` requires a `rate` parameter per RFC 3551/3555.\n      return `audio/L16;rate=${sampleRate}`\n    case 'mulaw':\n      // `audio/basic` is 8 kHz mono by RFC 2046 registration. For non-8kHz\n      // streams xAI still produces mulaw-encoded bytes at the requested\n      // rate, but the registered MIME can't carry that rate — so we use\n      // the non-standard but commonly-supported `audio/PCMU;rate=…` (RFC 3551\n      // RTP payload name) whenever the caller asked for a rate other than\n      // 8000, and keep `audio/basic` for the standard 8kHz case.\n      return sampleRate === 8000\n        ? 'audio/basic'\n        : `audio/PCMU;rate=${sampleRate}`\n    case 'alaw':\n      return sampleRate === 8000\n        ? 'audio/x-alaw-basic'\n        : `audio/PCMA;rate=${sampleRate}`\n  }\n}\n\n/**\n * Creates a Grok speech (TTS) adapter with an explicit API key.\n *\n * @example\n * ```typescript\n * const adapter = createGrokSpeech('grok-tts', 'xai-...')\n * const result = await generateSpeech({\n *   adapter,\n *   text: 'Hello from Grok',\n *   voice: 'eve',\n * })\n * ```\n */\nexport function createGrokSpeech<TModel extends GrokTTSModel>(\n  model: TModel,\n  apiKey: string,\n  config?: Omit<GrokSpeechConfig, 'apiKey'>,\n): GrokSpeechAdapter<TModel> {\n  return new GrokSpeechAdapter({ apiKey, ...config }, model)\n}\n\n/**\n * Creates a Grok speech (TTS) adapter, reading the API key from\n * `XAI_API_KEY` in the environment.\n *\n * @throws Error if `XAI_API_KEY` is not set.\n */\nexport function grokSpeech<TModel extends GrokTTSModel>(\n  model: TModel,\n  config?: Omit<GrokSpeechConfig, 'apiKey'>,\n): GrokSpeechAdapter<TModel> {\n  const apiKey = getGrokApiKeyFromEnv()\n  return createGrokSpeech(model, apiKey, config)\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/adapters/video.d.ts

@@ -1,128 +0,0 @@
-import { BaseVideoAdapter, DurationOptions } from '@tanstack/ai/adapters';
-import { VideoGenerationOptions, VideoJobResult, VideoStatusResult, VideoUrlResult } from '@tanstack/ai';
-import { GrokVideoModel } from '../model-meta.js';
-import { GrokVideoModelDurationByName, GrokVideoModelInputModalitiesByName, GrokVideoModelProviderOptionsByName, GrokVideoModelSizeByName, GrokVideoProviderOptions } from '../video/video-provider-options.js';
-import { GrokClientConfig } from '../utils.js';
-/**
- * Configuration for Grok video adapter.
- *
- * @experimental Video generation is an experimental feature and may change.
- */
-export interface GrokVideoConfig extends GrokClientConfig {
-}
-/**
- * Grok Video Generation Adapter (xAI Imagine API)
- *
- * Tree-shakeable adapter for the grok-imagine video models using the
- * async jobs/polling architecture: create a generation request, poll it,
- * then read the completed video URL.
- *
- * `grok-imagine-video` (v1.0) supports text-to-video and image-to-video.
- * `grok-imagine-video-1.5` is image-to-video only — every request needs an
- * image prompt part as the starting frame, and the adapter rejects a
- * text-only prompt with a clear error rather than a raw API 400.
- *
- * The Imagine video endpoints are not part of the OpenAI SDK surface (and
- * xAI rejects the SDK's multipart paths), so requests are plain JSON calls
- * issued with the configured `fetch` (or the global one).
- *
- * @experimental Video generation is an experimental feature and may change.
- *
- * Features:
- * - Async job-based video generation (1–15 second clips with audio)
- * - Aspect-ratio sizing via the "aspectRatio_resolution" size template
- *   (e.g. '16:9_720p'), consistent with the grok-imagine image models
- * - Image-to-video via an `image` prompt part (starting frame URL or data URI)
- * - Usage reporting: billed seconds (`unitsBilled`) and exact cost
- */
-export declare class GrokVideoAdapter<TModel extends GrokVideoModel> extends BaseVideoAdapter<TModel, GrokVideoProviderOptions, GrokVideoModelProviderOptionsByName, GrokVideoModelSizeByName, GrokVideoModelInputModalitiesByName, GrokVideoModelDurationByName> {
-    readonly name: "grok";
-    private readonly clientConfig;
-    constructor(config: GrokVideoConfig, model: TModel);
-    private get fetch();
-    private request;
-    /**
-     * Reads the error message out of an Imagine API error body
-     * (`{"code": "...", "error": "..."}`), falling back to the raw text.
-     */
-    private errorMessage;
-    createVideoJob(options: VideoGenerationOptions<GrokVideoProviderOptions, GrokVideoModelSizeByName[TModel], GrokVideoModelDurationByName[TModel]>): Promise<VideoJobResult>;
-    private retrieveJob;
-    getVideoStatus(jobId: string): Promise<VideoStatusResult>;
-    getVideoUrl(jobId: string): Promise<VideoUrlResult>;
-    /**
-     * Maps Imagine API job statuses onto the generic video status set. The
-     * API reports 'pending' while queued/generating (with a numeric
-     * `progress`), then a terminal 'done' / 'failed' / 'expired'.
-     */
-    protected mapStatus(apiStatus: string | undefined): 'pending' | 'processing' | 'completed' | 'failed';
-    /**
-     * Both grok-imagine video models accept a continuous 1–15 integer-second
-     * range. Consumers can use this to render UI without provider knowledge.
-     */
-    availableDurations(): DurationOptions<GrokVideoModelDurationByName[TModel]>;
-    /**
-     * Coerce a raw seconds value to the closest valid duration (clamped to
-     * [1, 15] and rounded to whole seconds).
-     */
-    snapDuration(seconds: number): GrokVideoModelDurationByName[TModel] | undefined;
-}
-/**
- * Creates a Grok video adapter with an explicit API key.
- * Type resolution happens here at the call site.
- *
- * @experimental Video generation is an experimental feature and may change.
- *
- * @param model - The model name (e.g., 'grok-imagine-video')
- * @param apiKey - Your xAI API key
- * @param config - Optional additional configuration
- * @returns Configured Grok video adapter instance with resolved types
- *
- * @example
- * ```typescript
- * // grok-imagine-video (v1.0) supports text-to-video.
- * const adapter = createGrokVideo('grok-imagine-video', 'xai-...');
- *
- * const { jobId } = await generateVideo({
- *   adapter,
- *   prompt: 'A beautiful sunset over the ocean',
- *   size: '16:9_720p',
- *   duration: 5
- * });
- * ```
- */
-export declare function createGrokVideo<TModel extends GrokVideoModel>(model: TModel, apiKey: string, config?: Omit<GrokVideoConfig, 'apiKey'>): GrokVideoAdapter<TModel>;
-/**
- * Creates a Grok video adapter with automatic API key detection from environment variables.
- * Type resolution happens here at the call site.
- *
- * Looks for `XAI_API_KEY` in:
- * - `process.env` (Node.js)
- * - `window.env` (Browser with injected env)
- *
- * @experimental Video generation is an experimental feature and may change.
- *
- * @param model - The model name (e.g., 'grok-imagine-video-1.5')
- * @param config - Optional configuration (excluding apiKey which is auto-detected)
- * @returns Configured Grok video adapter instance with resolved types
- * @throws Error if XAI_API_KEY is not found in environment
- *
- * @example
- * ```typescript
- * // Automatically uses XAI_API_KEY from environment
- * const adapter = grokVideo('grok-imagine-video-1.5');
- *
- * // Image-to-video only: the prompt must carry a starting-frame image part.
- * const { jobId } = await generateVideo({
- *   adapter,
- *   prompt: [
- *     { type: 'text', content: 'Make the cat start playing the piano' },
- *     { type: 'image', source: { type: 'url', value: 'https://example.com/cat.png' } },
- *   ],
- * });
- *
- * // Poll for status
- * const status = await getVideoJobStatus({ adapter, jobId });
- * ```
- */
-export declare function grokVideo<TModel extends GrokVideoModel>(model: TModel, config?: Omit<GrokVideoConfig, 'apiKey'>): GrokVideoAdapter<TModel>;