@ai-sdk/assemblyai 0.0.0-64aae7dd-20260114144918

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2023 Vercel, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,38 @@
+# AI SDK - AssemblyAI Provider
+
+The **[AssemblyAI provider](https://ai-sdk.dev/providers/ai-sdk-providers/assemblyai)** for the [AI SDK](https://ai-sdk.dev/docs)
+contains transcription model support for the AssemblyAI transcription API.
+
+## Setup
+
+The AssemblyAI provider is available in the `@ai-sdk/assemblyai` module. You can install it with
+
+```bash
+npm i @ai-sdk/assemblyai
+```
+
+## Provider Instance
+
+You can import the default provider instance `assemblyai` from `@ai-sdk/assemblyai`:
+
+```ts
+import { assemblyai } from '@ai-sdk/assemblyai';
+```
+
+## Example
+
+```ts
+import { assemblyai } from '@ai-sdk/assemblyai';
+import { experimental_transcribe as transcribe } from 'ai';
+
+const { text } = await transcribe({
+  model: assemblyai.transcription('best'),
+  audio: new URL(
+    'https://github.com/vercel/ai/raw/refs/heads/main/examples/ai-functions/data/galileo.mp3',
+  ),
+});
+```
+
+## Documentation
+
+Please check out the **[AssemblyAI provider documentation](https://ai-sdk.dev/providers/ai-sdk-providers/assemblyai)** for more information.

package/dist/index.d.mts

@@ -0,0 +1,82 @@
+import { TranscriptionModelV3, ProviderV3 } from '@ai-sdk/provider';
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+type AssemblyAIConfig = {
+    provider: string;
+    url: (options: {
+        modelId: string;
+        path: string;
+    }) => string;
+    headers: () => Record<string, string | undefined>;
+    fetch?: FetchFunction;
+    generateId?: () => string;
+};
+
+type AssemblyAITranscriptionModelId = 'best' | 'nano';
+
+interface AssemblyAITranscriptionModelConfig extends AssemblyAIConfig {
+    _internal?: {
+        currentDate?: () => Date;
+    };
+    /**
+     * The polling interval for checking transcript status in milliseconds.
+     */
+    pollingInterval?: number;
+}
+declare class AssemblyAITranscriptionModel implements TranscriptionModelV3 {
+    readonly modelId: AssemblyAITranscriptionModelId;
+    private readonly config;
+    readonly specificationVersion = "v3";
+    private readonly POLLING_INTERVAL_MS;
+    get provider(): string;
+    constructor(modelId: AssemblyAITranscriptionModelId, config: AssemblyAITranscriptionModelConfig);
+    private getArgs;
+    /**
+     * Polls the given transcript until we have a status other than `processing` or `queued`.
+     *
+     * @see https://www.assemblyai.com/docs/getting-started/transcribe-an-audio-file#step-33
+     */
+    private waitForCompletion;
+    doGenerate(options: Parameters<TranscriptionModelV3['doGenerate']>[0]): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>>;
+}
+
+interface AssemblyAIProvider extends ProviderV3 {
+    (modelId: 'best', settings?: {}): {
+        transcription: AssemblyAITranscriptionModel;
+    };
+    /**
+  Creates a model for transcription.
+     */
+    transcription(modelId: AssemblyAITranscriptionModelId): TranscriptionModelV3;
+    /**
+     * @deprecated Use `embeddingModel` instead.
+     */
+    textEmbeddingModel(modelId: string): never;
+}
+interface AssemblyAIProviderSettings {
+    /**
+  API key for authenticating requests.
+       */
+    apiKey?: string;
+    /**
+  Custom headers to include in the requests.
+       */
+    headers?: Record<string, string>;
+    /**
+  Custom fetch implementation. You can use it as a middleware to intercept requests,
+  or to provide a custom fetch implementation for e.g. testing.
+      */
+    fetch?: FetchFunction;
+}
+/**
+Create an AssemblyAI provider instance.
+ */
+declare function createAssemblyAI(options?: AssemblyAIProviderSettings): AssemblyAIProvider;
+/**
+Default AssemblyAI provider instance.
+ */
+declare const assemblyai: AssemblyAIProvider;
+
+declare const VERSION: string;
+
+export { type AssemblyAIProvider, type AssemblyAIProviderSettings, VERSION, assemblyai, createAssemblyAI };

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+import { TranscriptionModelV3, ProviderV3 } from '@ai-sdk/provider';
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+type AssemblyAIConfig = {
+    provider: string;
+    url: (options: {
+        modelId: string;
+        path: string;
+    }) => string;
+    headers: () => Record<string, string | undefined>;
+    fetch?: FetchFunction;
+    generateId?: () => string;
+};
+
+type AssemblyAITranscriptionModelId = 'best' | 'nano';
+
+interface AssemblyAITranscriptionModelConfig extends AssemblyAIConfig {
+    _internal?: {
+        currentDate?: () => Date;
+    };
+    /**
+     * The polling interval for checking transcript status in milliseconds.
+     */
+    pollingInterval?: number;
+}
+declare class AssemblyAITranscriptionModel implements TranscriptionModelV3 {
+    readonly modelId: AssemblyAITranscriptionModelId;
+    private readonly config;
+    readonly specificationVersion = "v3";
+    private readonly POLLING_INTERVAL_MS;
+    get provider(): string;
+    constructor(modelId: AssemblyAITranscriptionModelId, config: AssemblyAITranscriptionModelConfig);
+    private getArgs;
+    /**
+     * Polls the given transcript until we have a status other than `processing` or `queued`.
+     *
+     * @see https://www.assemblyai.com/docs/getting-started/transcribe-an-audio-file#step-33
+     */
+    private waitForCompletion;
+    doGenerate(options: Parameters<TranscriptionModelV3['doGenerate']>[0]): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>>;
+}
+
+interface AssemblyAIProvider extends ProviderV3 {
+    (modelId: 'best', settings?: {}): {
+        transcription: AssemblyAITranscriptionModel;
+    };
+    /**
+  Creates a model for transcription.
+     */
+    transcription(modelId: AssemblyAITranscriptionModelId): TranscriptionModelV3;
+    /**
+     * @deprecated Use `embeddingModel` instead.
+     */
+    textEmbeddingModel(modelId: string): never;
+}
+interface AssemblyAIProviderSettings {
+    /**
+  API key for authenticating requests.
+       */
+    apiKey?: string;
+    /**
+  Custom headers to include in the requests.
+       */
+    headers?: Record<string, string>;
+    /**
+  Custom fetch implementation. You can use it as a middleware to intercept requests,
+  or to provide a custom fetch implementation for e.g. testing.
+      */
+    fetch?: FetchFunction;
+}
+/**
+Create an AssemblyAI provider instance.
+ */
+declare function createAssemblyAI(options?: AssemblyAIProviderSettings): AssemblyAIProvider;
+/**
+Default AssemblyAI provider instance.
+ */
+declare const assemblyai: AssemblyAIProvider;
+
+declare const VERSION: string;
+
+export { type AssemblyAIProvider, type AssemblyAIProviderSettings, VERSION, assemblyai, createAssemblyAI };

package/dist/index.js

@@ -0,0 +1,456 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  VERSION: () => VERSION,
+  assemblyai: () => assemblyai,
+  createAssemblyAI: () => createAssemblyAI
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/assemblyai-provider.ts
+var import_provider = require("@ai-sdk/provider");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+
+// src/assemblyai-transcription-model.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_v42 = require("zod/v4");
+
+// src/assemblyai-error.ts
+var import_v4 = require("zod/v4");
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var assemblyaiErrorDataSchema = import_v4.z.object({
+  error: import_v4.z.object({
+    message: import_v4.z.string(),
+    code: import_v4.z.number()
+  })
+});
+var assemblyaiFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+  errorSchema: assemblyaiErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/assemblyai-transcription-model.ts
+var assemblyaiProviderOptionsSchema = import_v42.z.object({
+  /**
+   * End time of the audio in milliseconds.
+   */
+  audioEndAt: import_v42.z.number().int().nullish(),
+  /**
+   * Start time of the audio in milliseconds.
+   */
+  audioStartFrom: import_v42.z.number().int().nullish(),
+  /**
+   * Whether to automatically generate chapters for the transcription.
+   */
+  autoChapters: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to automatically generate highlights for the transcription.
+   */
+  autoHighlights: import_v42.z.boolean().nullish(),
+  /**
+   * Boost parameter for the transcription.
+   * Allowed values: 'low', 'default', 'high'.
+   */
+  boostParam: import_v42.z.string().nullish(),
+  /**
+   * Whether to enable content safety filtering.
+   */
+  contentSafety: import_v42.z.boolean().nullish(),
+  /**
+   * Confidence threshold for content safety filtering (25-100).
+   */
+  contentSafetyConfidence: import_v42.z.number().int().min(25).max(100).nullish(),
+  /**
+   * Custom spelling rules for the transcription.
+   */
+  customSpelling: import_v42.z.array(
+    import_v42.z.object({
+      from: import_v42.z.array(import_v42.z.string()),
+      to: import_v42.z.string()
+    })
+  ).nullish(),
+  /**
+   * Whether to include filler words (um, uh, etc.) in the transcription.
+   */
+  disfluencies: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to enable entity detection.
+   */
+  entityDetection: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to filter profanity from the transcription.
+   */
+  filterProfanity: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to format text with punctuation and capitalization.
+   */
+  formatText: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to enable IAB categories detection.
+   */
+  iabCategories: import_v42.z.boolean().nullish(),
+  /**
+   * Language code for the transcription.
+   */
+  languageCode: import_v42.z.union([import_v42.z.literal("en"), import_v42.z.string()]).nullish(),
+  /**
+   * Confidence threshold for language detection.
+   */
+  languageConfidenceThreshold: import_v42.z.number().nullish(),
+  /**
+   * Whether to enable language detection.
+   */
+  languageDetection: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to process audio as multichannel.
+   */
+  multichannel: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to add punctuation to the transcription.
+   */
+  punctuate: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to redact personally identifiable information (PII).
+   */
+  redactPii: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to redact PII in the audio file.
+   */
+  redactPiiAudio: import_v42.z.boolean().nullish(),
+  /**
+   * Audio format for PII redaction.
+   */
+  redactPiiAudioQuality: import_v42.z.string().nullish(),
+  /**
+   * List of PII types to redact.
+   */
+  redactPiiPolicies: import_v42.z.array(import_v42.z.string()).nullish(),
+  /**
+   * Substitution method for redacted PII.
+   */
+  redactPiiSub: import_v42.z.string().nullish(),
+  /**
+   * Whether to enable sentiment analysis.
+   */
+  sentimentAnalysis: import_v42.z.boolean().nullish(),
+  /**
+   * Whether to identify different speakers in the audio.
+   */
+  speakerLabels: import_v42.z.boolean().nullish(),
+  /**
+   * Number of speakers expected in the audio.
+   */
+  speakersExpected: import_v42.z.number().int().nullish(),
+  /**
+   * Threshold for speech detection (0-1).
+   */
+  speechThreshold: import_v42.z.number().min(0).max(1).nullish(),
+  /**
+   * Whether to generate a summary of the transcription.
+   */
+  summarization: import_v42.z.boolean().nullish(),
+  /**
+   * Model to use for summarization.
+   */
+  summaryModel: import_v42.z.string().nullish(),
+  /**
+   * Type of summary to generate.
+   */
+  summaryType: import_v42.z.string().nullish(),
+  /**
+   * Name of the authentication header for webhook requests.
+   */
+  webhookAuthHeaderName: import_v42.z.string().nullish(),
+  /**
+   * Value of the authentication header for webhook requests.
+   */
+  webhookAuthHeaderValue: import_v42.z.string().nullish(),
+  /**
+   * URL to send webhook notifications to.
+   */
+  webhookUrl: import_v42.z.string().nullish(),
+  /**
+   * List of words to boost recognition for.
+   */
+  wordBoost: import_v42.z.array(import_v42.z.string()).nullish()
+});
+var AssemblyAITranscriptionModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.POLLING_INTERVAL_MS = 3e3;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    providerOptions
+  }) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H;
+    const warnings = [];
+    const assemblyaiOptions = await (0, import_provider_utils2.parseProviderOptions)({
+      provider: "assemblyai",
+      providerOptions,
+      schema: assemblyaiProviderOptionsSchema
+    });
+    const body = {
+      speech_model: this.modelId
+    };
+    if (assemblyaiOptions) {
+      body.audio_end_at = (_a = assemblyaiOptions.audioEndAt) != null ? _a : void 0;
+      body.audio_start_from = (_b = assemblyaiOptions.audioStartFrom) != null ? _b : void 0;
+      body.auto_chapters = (_c = assemblyaiOptions.autoChapters) != null ? _c : void 0;
+      body.auto_highlights = (_d = assemblyaiOptions.autoHighlights) != null ? _d : void 0;
+      body.boost_param = (_e = assemblyaiOptions.boostParam) != null ? _e : void 0;
+      body.content_safety = (_f = assemblyaiOptions.contentSafety) != null ? _f : void 0;
+      body.content_safety_confidence = (_g = assemblyaiOptions.contentSafetyConfidence) != null ? _g : void 0;
+      body.custom_spelling = (_h = assemblyaiOptions.customSpelling) != null ? _h : void 0;
+      body.disfluencies = (_i = assemblyaiOptions.disfluencies) != null ? _i : void 0;
+      body.entity_detection = (_j = assemblyaiOptions.entityDetection) != null ? _j : void 0;
+      body.filter_profanity = (_k = assemblyaiOptions.filterProfanity) != null ? _k : void 0;
+      body.format_text = (_l = assemblyaiOptions.formatText) != null ? _l : void 0;
+      body.iab_categories = (_m = assemblyaiOptions.iabCategories) != null ? _m : void 0;
+      body.language_code = (_n = assemblyaiOptions.languageCode) != null ? _n : void 0;
+      body.language_confidence_threshold = (_o = assemblyaiOptions.languageConfidenceThreshold) != null ? _o : void 0;
+      body.language_detection = (_p = assemblyaiOptions.languageDetection) != null ? _p : void 0;
+      body.multichannel = (_q = assemblyaiOptions.multichannel) != null ? _q : void 0;
+      body.punctuate = (_r = assemblyaiOptions.punctuate) != null ? _r : void 0;
+      body.redact_pii = (_s = assemblyaiOptions.redactPii) != null ? _s : void 0;
+      body.redact_pii_audio = (_t = assemblyaiOptions.redactPiiAudio) != null ? _t : void 0;
+      body.redact_pii_audio_quality = (_u = assemblyaiOptions.redactPiiAudioQuality) != null ? _u : void 0;
+      body.redact_pii_policies = (_v = assemblyaiOptions.redactPiiPolicies) != null ? _v : void 0;
+      body.redact_pii_sub = (_w = assemblyaiOptions.redactPiiSub) != null ? _w : void 0;
+      body.sentiment_analysis = (_x = assemblyaiOptions.sentimentAnalysis) != null ? _x : void 0;
+      body.speaker_labels = (_y = assemblyaiOptions.speakerLabels) != null ? _y : void 0;
+      body.speakers_expected = (_z = assemblyaiOptions.speakersExpected) != null ? _z : void 0;
+      body.speech_threshold = (_A = assemblyaiOptions.speechThreshold) != null ? _A : void 0;
+      body.summarization = (_B = assemblyaiOptions.summarization) != null ? _B : void 0;
+      body.summary_model = (_C = assemblyaiOptions.summaryModel) != null ? _C : void 0;
+      body.summary_type = (_D = assemblyaiOptions.summaryType) != null ? _D : void 0;
+      body.webhook_auth_header_name = (_E = assemblyaiOptions.webhookAuthHeaderName) != null ? _E : void 0;
+      body.webhook_auth_header_value = (_F = assemblyaiOptions.webhookAuthHeaderValue) != null ? _F : void 0;
+      body.webhook_url = (_G = assemblyaiOptions.webhookUrl) != null ? _G : void 0;
+      body.word_boost = (_H = assemblyaiOptions.wordBoost) != null ? _H : void 0;
+    }
+    return {
+      body,
+      warnings
+    };
+  }
+  /**
+   * Polls the given transcript until we have a status other than `processing` or `queued`.
+   *
+   * @see https://www.assemblyai.com/docs/getting-started/transcribe-an-audio-file#step-33
+   */
+  async waitForCompletion(transcriptId, headers, abortSignal) {
+    var _a, _b;
+    const pollingInterval = (_a = this.config.pollingInterval) != null ? _a : this.POLLING_INTERVAL_MS;
+    while (true) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        throw new Error("Transcription request was aborted");
+      }
+      const response = await fetch(
+        this.config.url({
+          path: `/v2/transcript/${transcriptId}`,
+          modelId: this.modelId
+        }),
+        {
+          method: "GET",
+          headers: (0, import_provider_utils2.combineHeaders)(
+            this.config.headers(),
+            headers
+          ),
+          signal: abortSignal
+        }
+      );
+      if (!response.ok) {
+        throw await assemblyaiFailedResponseHandler({
+          response,
+          url: this.config.url({
+            path: `/v2/transcript/${transcriptId}`,
+            modelId: this.modelId
+          }),
+          requestBodyValues: {}
+        });
+      }
+      const transcript = assemblyaiTranscriptionResponseSchema.parse(
+        await response.json()
+      );
+      if (transcript.status === "completed") {
+        return {
+          transcript,
+          responseHeaders: (0, import_provider_utils2.extractResponseHeaders)(response)
+        };
+      }
+      if (transcript.status === "error") {
+        throw new Error(
+          `Transcription failed: ${(_b = transcript.error) != null ? _b : "Unknown error"}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+    }
+  }
+  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 { value: uploadResponse } = await (0, import_provider_utils2.postToApi)({
+      url: this.config.url({
+        path: "/v2/upload",
+        modelId: ""
+      }),
+      headers: {
+        "Content-Type": "application/octet-stream",
+        ...(0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers)
+      },
+      body: {
+        content: options.audio,
+        values: options.audio
+      },
+      failedResponseHandler: assemblyaiFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+        assemblyaiUploadResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { body, warnings } = await this.getArgs(options);
+    const { value: submitResponse } = await (0, import_provider_utils2.postJsonToApi)({
+      url: this.config.url({
+        path: "/v2/transcript",
+        modelId: this.modelId
+      }),
+      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      body: {
+        ...body,
+        audio_url: uploadResponse.upload_url
+      },
+      failedResponseHandler: assemblyaiFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+        assemblyaiSubmitResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const { transcript, responseHeaders } = await this.waitForCompletion(
+      submitResponse.id,
+      options.headers,
+      options.abortSignal
+    );
+    return {
+      text: (_d = transcript.text) != null ? _d : "",
+      segments: (_f = (_e = transcript.words) == null ? void 0 : _e.map((word) => ({
+        text: word.text,
+        startSecond: word.start,
+        endSecond: word.end
+      }))) != null ? _f : [],
+      language: (_g = transcript.language_code) != null ? _g : void 0,
+      durationInSeconds: (_k = (_j = transcript.audio_duration) != null ? _j : (_i = (_h = transcript.words) == null ? void 0 : _h.at(-1)) == null ? void 0 : _i.end) != null ? _k : void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        // Headers from final GET request
+        body: transcript
+        // Raw response from final GET request
+      }
+    };
+  }
+};
+var assemblyaiUploadResponseSchema = import_v42.z.object({
+  upload_url: import_v42.z.string()
+});
+var assemblyaiSubmitResponseSchema = import_v42.z.object({
+  id: import_v42.z.string(),
+  status: import_v42.z.enum(["queued", "processing", "completed", "error"])
+});
+var assemblyaiTranscriptionResponseSchema = import_v42.z.object({
+  id: import_v42.z.string(),
+  status: import_v42.z.enum(["queued", "processing", "completed", "error"]),
+  text: import_v42.z.string().nullish(),
+  language_code: import_v42.z.string().nullish(),
+  words: import_v42.z.array(
+    import_v42.z.object({
+      start: import_v42.z.number(),
+      end: import_v42.z.number(),
+      text: import_v42.z.string()
+    })
+  ).nullish(),
+  audio_duration: import_v42.z.number().nullish(),
+  error: import_v42.z.string().nullish()
+});
+
+// src/version.ts
+var VERSION = true ? "0.0.0-64aae7dd-20260114144918" : "0.0.0-test";
+
+// src/assemblyai-provider.ts
+function createAssemblyAI(options = {}) {
+  const getHeaders = () => (0, import_provider_utils3.withUserAgentSuffix)(
+    {
+      authorization: (0, import_provider_utils3.loadApiKey)({
+        apiKey: options.apiKey,
+        environmentVariableName: "ASSEMBLYAI_API_KEY",
+        description: "AssemblyAI"
+      }),
+      ...options.headers
+    },
+    `ai-sdk/assemblyai/${VERSION}`
+  );
+  const createTranscriptionModel = (modelId) => new AssemblyAITranscriptionModel(modelId, {
+    provider: `assemblyai.transcription`,
+    url: ({ path }) => `https://api.assemblyai.com${path}`,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const provider = function(modelId) {
+    return {
+      transcription: createTranscriptionModel(modelId)
+    };
+  };
+  provider.specificationVersion = "v3";
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+  provider.languageModel = () => {
+    throw new import_provider.NoSuchModelError({
+      modelId: "unknown",
+      modelType: "languageModel",
+      message: "AssemblyAI does not provide language models"
+    });
+  };
+  provider.embeddingModel = (modelId) => {
+    throw new import_provider.NoSuchModelError({ modelId, modelType: "embeddingModel" });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new import_provider.NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
+  return provider;
+}
+var assemblyai = createAssemblyAI();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VERSION,
+  assemblyai,
+  createAssemblyAI
+});
+//# sourceMappingURL=index.js.map