@ai-sdk/elevenlabs/dist/index.mjs

The **[ElevenLabs provider](https://ai-sdk.dev/providers/ai-sdk-providers/elevenlabs)** for the [AI SDK](https://ai-sdk.dev/docs) contains language model support for the ElevenLabs chat and completion APIs and embedding model support for the ElevenLabs em

// src/elevenlabs-provider.ts
import {
  NoSuchModelError
} from "@ai-sdk/provider";
import { loadApiKey } from "@ai-sdk/provider-utils";

// src/elevenlabs-transcription-model.ts
import {
  combineHeaders,
  convertBase64ToUint8Array,
  createJsonResponseHandler,
  parseProviderOptions,
  postFormDataToApi
} from "@ai-sdk/provider-utils";
import { z as z2 } from "zod/v4";

// src/elevenlabs-error.ts
import { z } from "zod/v4";
import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
var elevenlabsErrorDataSchema = z.object({
  error: z.object({
    message: z.string(),
    code: z.number()
  })
});
var elevenlabsFailedResponseHandler = createJsonErrorResponseHandler({
  errorSchema: elevenlabsErrorDataSchema,
  errorToMessage: (data) => data.error.message
});

// src/elevenlabs-transcription-model.ts
var elevenLabsProviderOptionsSchema = z2.object({
  languageCode: z2.string().nullish(),
  tagAudioEvents: z2.boolean().nullish().default(true),
  numSpeakers: z2.number().int().min(1).max(32).nullish(),
  timestampsGranularity: z2.enum(["none", "word", "character"]).nullish().default("word"),
  diarize: z2.boolean().nullish().default(false),
  fileFormat: z2.enum(["pcm_s16le_16", "other"]).nullish().default("other")
});
var ElevenLabsTranscriptionModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v2";
  }
  get provider() {
    return this.config.provider;
  }
  async getArgs({
    audio,
    mediaType,
    providerOptions
  }) {
    var _a, _b, _c, _d, _e;
    const warnings = [];
    const elevenlabsOptions = await parseProviderOptions({
      provider: "elevenlabs",
      providerOptions,
      schema: elevenLabsProviderOptionsSchema
    });
    const formData = new FormData();
    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
    formData.append("model_id", this.modelId);
    formData.append("file", new File([blob], "audio", { type: mediaType }));
    formData.append("diarize", "true");
    if (elevenlabsOptions) {
      const transcriptionModelOptions = {
        language_code: (_a = elevenlabsOptions.languageCode) != null ? _a : void 0,
        tag_audio_events: (_b = elevenlabsOptions.tagAudioEvents) != null ? _b : void 0,
        num_speakers: (_c = elevenlabsOptions.numSpeakers) != null ? _c : void 0,
        timestamps_granularity: (_d = elevenlabsOptions.timestampsGranularity) != null ? _d : void 0,
        file_format: (_e = elevenlabsOptions.fileFormat) != null ? _e : void 0
      };
      if (typeof elevenlabsOptions.diarize === "boolean") {
        formData.append("diarize", String(elevenlabsOptions.diarize));
      }
      for (const key in transcriptionModelOptions) {
        const value = transcriptionModelOptions[key];
        if (value !== void 0) {
          formData.append(key, String(value));
        }
      }
    }
    return {
      formData,
      warnings
    };
  }
  async doGenerate(options) {
    var _a, _b, _c, _d, _e, _f, _g, _h;
    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, warnings } = await this.getArgs(options);
    const {
      value: response,
      responseHeaders,
      rawValue: rawResponse
    } = await postFormDataToApi({
      url: this.config.url({
        path: "/v1/speech-to-text",
        modelId: this.modelId
      }),
      headers: combineHeaders(this.config.headers(), options.headers),
      formData,
      failedResponseHandler: elevenlabsFailedResponseHandler,
      successfulResponseHandler: createJsonResponseHandler(
        elevenlabsTranscriptionResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    return {
      text: response.text,
      segments: (_e = (_d = response.words) == null ? void 0 : _d.map((word) => {
        var _a2, _b2;
        return {
          text: word.text,
          startSecond: (_a2 = word.start) != null ? _a2 : 0,
          endSecond: (_b2 = word.end) != null ? _b2 : 0
        };
      })) != null ? _e : [],
      language: response.language_code,
      durationInSeconds: (_h = (_g = (_f = response.words) == null ? void 0 : _f.at(-1)) == null ? void 0 : _g.end) != null ? _h : void 0,
      warnings,
      response: {
        timestamp: currentDate,
        modelId: this.modelId,
        headers: responseHeaders,
        body: rawResponse
      }
    };
  }
};
var elevenlabsTranscriptionResponseSchema = z2.object({
  language_code: z2.string(),
  language_probability: z2.number(),
  text: z2.string(),
  words: z2.array(
    z2.object({
      text: z2.string(),
      type: z2.enum(["word", "spacing", "audio_event"]),
      start: z2.number().nullish(),
      end: z2.number().nullish(),
      speaker_id: z2.string().nullish(),
      characters: z2.array(
        z2.object({
          text: z2.string(),
          start: z2.number().nullish(),
          end: z2.number().nullish()
        })
      ).nullish()
    })
  ).nullish()
});

// src/elevenlabs-provider.ts
function createElevenLabs(options = {}) {
  const getHeaders = () => ({
    "xi-api-key": loadApiKey({
      apiKey: options.apiKey,
      environmentVariableName: "ELEVENLABS_API_KEY",
      description: "ElevenLabs"
    }),
    ...options.headers
  });
  const createTranscriptionModel = (modelId) => new ElevenLabsTranscriptionModel(modelId, {
    provider: `elevenlabs.transcription`,
    url: ({ path }) => `https://api.elevenlabs.io${path}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const provider = function(modelId) {
    return {
      transcription: createTranscriptionModel(modelId)
    };
  };
  provider.transcription = createTranscriptionModel;
  provider.transcriptionModel = createTranscriptionModel;
  provider.languageModel = () => {
    throw new NoSuchModelError({
      modelId: "unknown",
      modelType: "languageModel",
      message: "ElevenLabs does not provide language models"
    });
  };
  provider.textEmbeddingModel = () => {
    throw new NoSuchModelError({
      modelId: "unknown",
      modelType: "textEmbeddingModel",
      message: "ElevenLabs does not provide text embedding models"
    });
  };
  provider.imageModel = () => {
    throw new NoSuchModelError({
      modelId: "unknown",
      modelType: "imageModel",
      message: "ElevenLabs does not provide image models"
    });
  };
  return provider;
}
var elevenlabs = createElevenLabs();
export {
  createElevenLabs,
  elevenlabs
};
//# sourceMappingURL=index.mjs.map