@ai-sdk/revai 0.0.0-1c33ba03-20260114162300 → 0.0.0-4115c213-20260122152721

package/CHANGELOG.md

@@ -1,11 +1,40 @@
 # @ai-sdk/revai
 
-## 0.0.0-1c33ba03-20260114162300
+## 0.0.0-4115c213-20260122152721
 
 ### Patch Changes
 
-- Updated dependencies [261c011]
-  - @ai-sdk/provider-utils@0.0.0-1c33ba03-20260114162300
+- 4caafb2: chore: excluded tests from src folder in npm package
+- Updated dependencies [4caafb2]
+  - @ai-sdk/provider@0.0.0-4115c213-20260122152721
+  - @ai-sdk/provider-utils@0.0.0-4115c213-20260122152721
+
+## 2.0.10
+
+### Patch Changes
+
+- 2b8369d: chore: add docs to package dist
+
+## 2.0.9
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+
+## 2.0.8
+
+### Patch Changes
+
+- Updated dependencies [5c090e7]
+  - @ai-sdk/provider@3.0.4
+  - @ai-sdk/provider-utils@4.0.8
+
+## 2.0.7
+
+### Patch Changes
+
+- Updated dependencies [46f46e4]
+  - @ai-sdk/provider-utils@4.0.7
 
 ## 2.0.6
 

package/dist/index.js

@@ -455,7 +455,7 @@ var revaiTranscriptionResponseSchema = import_v42.z.object({
 });
 
 // src/version.ts
-var VERSION = true ? "0.0.0-1c33ba03-20260114162300" : "0.0.0-test";
+var VERSION = true ? "0.0.0-4115c213-20260122152721" : "0.0.0-test";
 
 // src/revai-provider.ts
 function createRevai(options = {}) {

package/dist/index.mjs

@@ -443,7 +443,7 @@ var revaiTranscriptionResponseSchema = z2.object({
 });
 
 // src/version.ts
-var VERSION = true ? "0.0.0-1c33ba03-20260114162300" : "0.0.0-test";
+var VERSION = true ? "0.0.0-4115c213-20260122152721" : "0.0.0-test";
 
 // src/revai-provider.ts
 function createRevai(options = {}) {

package/docs/160-revai.mdx

@@ -0,0 +1,206 @@
+---
+title: Rev.ai
+description: Learn how to use the Rev.ai provider for the AI SDK.
+---
+
+# Rev.ai Provider
+
+The [Rev.ai](https://www.rev.ai/) provider contains language model support for the Rev.ai transcription API.
+
+## Setup
+
+The Rev.ai provider is available in the `@ai-sdk/revai` module. You can install it with
+
+<Tabs items={['pnpm', 'npm', 'yarn', 'bun']}>
+  <Tab>
+    <Snippet text="pnpm add @ai-sdk/revai" dark />
+  </Tab>
+  <Tab>
+    <Snippet text="npm install @ai-sdk/revai" dark />
+  </Tab>
+  <Tab>
+    <Snippet text="yarn add @ai-sdk/revai" dark />
+  </Tab>
+
+  <Tab>
+    <Snippet text="bun add @ai-sdk/revai" dark />
+  </Tab>
+</Tabs>
+
+## Provider Instance
+
+You can import the default provider instance `revai` from `@ai-sdk/revai`:
+
+```ts
+import { revai } from '@ai-sdk/revai';
+```
+
+If you need a customized setup, you can import `createRevai` from `@ai-sdk/revai` and create a provider instance with your settings:
+
+```ts
+import { createRevai } from '@ai-sdk/revai';
+
+const revai = createRevai({
+  // custom settings, e.g.
+  fetch: customFetch,
+});
+```
+
+You can use the following optional settings to customize the Rev.ai provider instance:
+
+- **apiKey** _string_
+
+  API key that is being sent using the `Authorization` header.
+  It defaults to the `REVAI_API_KEY` environment variable.
+
+- **headers** _Record&lt;string,string&gt;_
+
+  Custom headers to include in the requests.
+
+- **fetch** _(input: RequestInfo, init?: RequestInit) => Promise&lt;Response&gt;_
+
+  Custom [fetch](https://developer.mozilla.org/en-US/docs/Web/API/fetch) implementation.
+  Defaults to the global `fetch` function.
+  You can use it as a middleware to intercept requests,
+  or to provide a custom fetch implementation for e.g. testing.
+
+## Transcription Models
+
+You can create models that call the [Rev.ai transcription API](https://www.rev.ai/docs/api/transcription)
+using the `.transcription()` factory method.
+
+The first argument is the model id e.g. `machine`.
+
+```ts
+const model = revai.transcription('machine');
+```
+
+You can also pass additional provider-specific options using the `providerOptions` argument. For example, supplying the input language in ISO-639-1 (e.g. `en`) format can sometimes improve transcription performance if known beforehand.
+
+```ts highlight="6"
+import { experimental_transcribe as transcribe } from 'ai';
+import { revai } from '@ai-sdk/revai';
+import { readFile } from 'fs/promises';
+
+const result = await transcribe({
+  model: revai.transcription('machine'),
+  audio: await readFile('audio.mp3'),
+  providerOptions: { revai: { language: 'en' } },
+});
+```
+
+The following provider options are available:
+
+- **metadata** _string_
+
+  Optional metadata that was provided during job submission.
+
+- **notification_config** _object_
+
+  Optional configuration for a callback url to invoke when processing is complete.
+
+  - **url** _string_ - Callback url to invoke when processing is complete.
+  - **auth_headers** _object_ - Optional authorization headers, if needed to invoke the callback.
+    - **Authorization** _string_ - Authorization header value.
+
+- **delete_after_seconds** _integer_
+
+  Amount of time after job completion when job is auto-deleted.
+
+- **verbatim** _boolean_
+
+  Configures the transcriber to transcribe every syllable, including all false starts and disfluencies.
+
+- **rush** _boolean_
+
+  [HIPAA Unsupported] Only available for human transcriber option. When set to true, your job is given higher priority.
+
+- **skip_diarization** _boolean_
+
+  Specify if speaker diarization will be skipped by the speech engine.
+
+- **skip_postprocessing** _boolean_
+
+  Only available for English and Spanish languages. User-supplied preference on whether to skip post-processing operations.
+
+- **skip_punctuation** _boolean_
+
+  Specify if "punct" type elements will be skipped by the speech engine.
+
+- **remove_disfluencies** _boolean_
+
+  When set to true, disfluencies (like 'ums' and 'uhs') will not appear in the transcript.
+
+- **remove_atmospherics** _boolean_
+
+  When set to true, atmospherics (like `<laugh>`, `<affirmative>`) will not appear in the transcript.
+
+- **filter_profanity** _boolean_
+
+  When enabled, profanities will be filtered by replacing characters with asterisks except for the first and last.
+
+- **speaker_channels_count** _integer_
+
+  Only available for English, Spanish and French languages. Specify the total number of unique speaker channels in the audio.
+
+- **speakers_count** _integer_
+
+  Only available for English, Spanish and French languages. Specify the total number of unique speakers in the audio.
+
+- **diarization_type** _string_
+
+  Specify diarization type. Possible values: "standard" (default), "premium".
+
+- **custom_vocabulary_id** _string_
+
+  Supply the id of a pre-completed custom vocabulary submitted through the Custom Vocabularies API.
+
+- **custom_vocabularies** _Array_
+
+  Specify a collection of custom vocabulary to be used for this job.
+
+- **strict_custom_vocabulary** _boolean_
+
+  If true, only exact phrases will be used as custom vocabulary.
+
+- **summarization_config** _object_
+
+  Specify summarization options.
+
+  - **model** _string_ - Model type for summarization. Possible values: "standard" (default), "premium".
+  - **type** _string_ - Summarization formatting type. Possible values: "paragraph" (default), "bullets".
+  - **prompt** _string_ - Custom prompt for flexible summaries (mutually exclusive with type).
+
+- **translation_config** _object_
+
+  Specify translation options.
+
+  - **target_languages** _Array_ - Array of target languages for translation.
+  - **model** _string_ - Model type for translation. Possible values: "standard" (default), "premium".
+
+- **language** _string_
+
+  Language is provided as a ISO 639-1 language code. Default is "en".
+
+- **forced_alignment** _boolean_
+
+  When enabled, provides improved accuracy for per-word timestamps for a transcript.
+  Default is `false`.
+
+  Currently supported languages:
+
+  - English (en, en-us, en-gb)
+  - French (fr)
+  - Italian (it)
+  - German (de)
+  - Spanish (es)
+
+  Note: This option is not available in low-cost environment.
+
+### Model Capabilities
+
+| Model      | Transcription       | Duration            | Segments            | Language            |
+| ---------- | ------------------- | ------------------- | ------------------- | ------------------- |
+| `machine`  | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
+| `low_cost` | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
+| `fusion`   | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/revai",
-  "version": "0.0.0-1c33ba03-20260114162300",
+  "version": "0.0.0-4115c213-20260122152721",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,9 +8,18 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "docs/**/*",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "!src/**/__snapshots__",
+    "!src/**/__fixtures__",
     "CHANGELOG.md",
     "README.md"
   ],
+  "directories": {
+    "doc": "./docs"
+  },
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -20,15 +29,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.3",
-    "@ai-sdk/provider-utils": "0.0.0-1c33ba03-20260114162300"
+    "@ai-sdk/provider": "0.0.0-4115c213-20260122152721",
+    "@ai-sdk/provider-utils": "0.0.0-4115c213-20260122152721"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.6.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "1.0.1",
+    "@ai-sdk/test-server": "0.0.0-4115c213-20260122152721",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
@@ -54,7 +63,7 @@
   "scripts": {
     "build": "tsup --tsconfig tsconfig.build.json",
     "build:watch": "tsup --tsconfig tsconfig.build.json --watch",
-    "clean": "del-cli dist",
+    "clean": "del-cli dist docs",
     "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --noEmit",
     "prettier-check": "prettier --check \"./**/*.ts*\"",

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createRevai, revai } from './revai-provider';
+export type { RevaiProvider, RevaiProviderSettings } from './revai-provider';
+export { VERSION } from './version';

package/src/revai-api-types.ts

@@ -0,0 +1,274 @@
+export type RevaiTranscriptionAPITypes = {
+  /**
+   * Optional metadata that was provided during job submission.
+   */
+  metadata?: string | null;
+
+  /**
+   * Optional configuration for a callback url to invoke when processing is complete,
+   * in addition to auth headers if they are needed to invoke the callback url.
+   * Cannot be set if callback_url is set. This option will not be visible in the submission response.
+   */
+  notification_config?: {
+    /**
+     * Optional callback url to invoke when processing is complete
+     */
+    url: string;
+    /**
+     * Optional authorization headers, if they are needed to invoke the callback.
+     * There are a few constraints: 1) the "Authorization" header is the only header that can be passed in,
+     * and 2) the header value must be of the form <scheme> <token>.
+     * For example: {"Authorization": "Bearer $BEARER_TOKEN"}
+     */
+    auth_headers?: {
+      /**
+       * Authorization header
+       */
+      Authorization: string;
+    } | null;
+  } | null;
+
+  /**
+   * Amount of time after job completion when job is auto-deleted. Present only when preference set in job request.
+   */
+  delete_after_seconds?: number | null;
+
+  /**
+   * Select which service you would like to transcribe this file with.
+   * - machine: the default and routes to our standard (Reverb) model.
+   * - low_cost: low-cost transcription which uses quantized ASR model (Reverb Turbo) with low-cost environment.
+   * - fusion: higher quality ASR that combines multiple models to achieve the best results. Typically has better support for rare words.
+   * @default "machine"
+   */
+  transcriber?: 'machine' | 'low_cost' | 'fusion' | null;
+
+  /**
+   * Configures the transcriber to transcribe every syllable. This will include all false starts and disfluencies in the transcript.
+   *
+   * The behavior depends on the transcriber option:
+   * - machine: the default is true. To turn it off false should be explicitly provided
+   * - human: the default is false To turn it on true should be explicitly provided
+   */
+  verbatim?: boolean;
+
+  /**
+   * [HIPAA Unsupported] Only available for human transcriber option
+   * When this field is set to true your job is given higher priority and will be worked on sooner by our human transcribers.
+   * @default false
+   */
+  rush?: boolean | null;
+
+  /**
+   * [HIPAA Unsupported] Only available for human transcriber option
+   * When this field is set to true the behavior will mock a normal human transcription job except no transcription will happen.
+   * The primary use case is to test integrations without being charged for human transcription.
+   * @default false
+   */
+  test_mode?: boolean | null;
+
+  /**
+   * [HIPAA Unsupported] Only available for human transcriber option.
+   * Use this option to specify which sections of the transcript need to be transcribed.
+   * Segments must be at least 1 minute in length and cannot overlap.
+   */
+  segments_to_transcribe?: Array<{
+    /**
+     * The timestamp of the beginning of the segment relative to the beginning of the audio in seconds (centisecond precision)
+     */
+    start: number;
+    /**
+     * The timestamp of the end of the segment relative to the beginning of the audio in seconds (centisecond precision)
+     */
+    end: number;
+  }> | null;
+
+  /**
+   * [HIPAA Unsupported] Only available for human transcriber option.
+   * Use this option to specify up to 100 names of speakers in the transcript.
+   * Names may only be up to 50 characters long.
+   */
+  speaker_names?: Array<{
+    /**
+     * The name of the speaker to be used when labeling monologues. Max of 50 characters.
+     */
+    display_name: string;
+  }> | null;
+
+  /**
+   * Specify if speaker diarization will be skipped by the speech engine
+   * @default false
+   */
+  skip_diarization?: boolean | null;
+
+  /**
+   * Only available for English and Spanish languages.
+   * User-supplied preference on whether to skip post-processing operations such as inverse text normalization (ITN), casing and punctuation.
+   * @default false
+   */
+  skip_postprocessing?: boolean | null;
+
+  /**
+   * Specify if "punct" type elements will be skipped by the speech engine.
+   * For JSON outputs, this includes removing spaces. For text outputs, words will still be delimited by a space
+   * @default false
+   */
+  skip_punctuation?: boolean | null;
+
+  /**
+   * Currently we only define disfluencies as 'ums' and 'uhs'.
+   * When set to true, disfluencies will not appear in the transcript.
+   * This option also removes atmospherics if the remove_atmospherics is not set.
+   * This option is not available for human transcription jobs.
+   * @default false
+   */
+  remove_disfluencies?: boolean | null;
+
+  /**
+   * We define many atmospherics such <laugh>, <affirmative> etc.
+   * When set to true, atmospherics will not appear in the transcript.
+   * This option is not available for human transcription jobs.
+   * @default false
+   */
+  remove_atmospherics?: boolean | null;
+
+  /**
+   * Enabling this option will filter for approx. 600 profanities, which cover most use cases.
+   * If a transcribed word matches a word on this list, then all the characters of that word will be replaced by asterisks
+   * except for the first and last character.
+   * @default false
+   */
+  filter_profanity?: boolean | null;
+
+  /**
+   * Only available for English, Spanish and French languages.
+   * Use to specify the total number of unique speaker channels in the audio.
+   *
+   * Given the number of audio channels provided, each channel will be transcribed separately and the channel id assigned to the speaker label.
+   * The final output will be a combination of all individual channel outputs.
+   * Overlapping monologues will have ordering broken by the order in which the first spoken element of each monologue occurs.
+   * If speaker_channels_count is greater than the actual channels in the audio, the job will fail with invalid_media.
+   * This option is not available for human transcription jobs.
+   */
+  speaker_channels_count?: number | null;
+
+  /**
+   * Only available for English, Spanish and French languages.
+   * Use to specify the total number of unique speakers in the audio.
+   *
+   * Given the count of speakers provided, it will be used to improve the diarization accuracy.
+   * This option is not available for human transcription jobs.
+   * @default null
+   */
+  speakers_count?: number | null;
+
+  /**
+   * Use to specify diarization type. This option is not available for human transcription jobs and low-cost environment.
+   * @default "standard"
+   */
+  diarization_type?: 'standard' | 'premium' | null;
+
+  /**
+   * This feature is in beta. You can supply the id of a pre-completed custom vocabulary that you submitted through the Custom Vocabularies API
+   * instead of uploading the list of phrases using the custom_vocabularies parameter.
+   * Using custom_vocabulary_id or custom_vocabularies with the same list of phrases yields the same transcription result,
+   * but custom_vocabulary_id enables your submission to finish processing faster by 6 seconds on average.
+   *
+   * You cannot use both custom_vocabulary_id and custom_vocabularies at the same time, and doing so will result in a 400 response.
+   * If the supplied id represents an incomplete, deleted, or non-existent custom vocabulary then you will receive a 404 response.
+   */
+  custom_vocabulary_id?: string | null;
+
+  /**
+   * Specify a collection of custom vocabulary to be used for this job.
+   * Custom vocabulary informs and biases the speech recognition to find those phrases (at the cost of slightly slower transcription).
+   */
+  custom_vocabularies?: Array<object>;
+
+  /**
+   * If true, only exact phrases will be used as custom vocabulary, i.e. phrases will not be split into individual words for processing.
+   * By default is enabled.
+   */
+  strict_custom_vocabulary?: boolean;
+
+  /**
+   * Use to specify summarization options. This option is not available for human transcription jobs.
+   */
+  summarization_config?: {
+    /**
+     * Model type for summarization.
+     * @default "standard"
+     */
+    model?: 'standard' | 'premium' | null;
+    /**
+     * Summarization formatting type. Use Paragraph for a text summary or Bullets for a list of topics.
+     * prompt and type parameters are mutuially exclusive.
+     * @default "paragraph"
+     */
+    type?: 'paragraph' | 'bullets' | null;
+    /**
+     * Custom prompt. Provides the most flexible way to create summaries, but may lead to unpredictable results.
+     * Summary is produced in Markdown format.
+     * prompt and type parameters are mutuially exclusive.
+     */
+    prompt?: string | null;
+  } | null;
+
+  /**
+   * Use to specify translation options. This option is not available for human transcription jobs.
+   */
+  translation_config?: {
+    /**
+     * Target languages for translation.
+     */
+    target_languages: Array<{
+      /**
+       * Target language for translation.
+       */
+      language:
+        | 'en'
+        | 'en-us'
+        | 'en-gb'
+        | 'ar'
+        | 'pt'
+        | 'pt-br'
+        | 'pt-pt'
+        | 'fr'
+        | 'fr-ca'
+        | 'es'
+        | 'es-es'
+        | 'es-la'
+        | 'it'
+        | 'ja'
+        | 'ko'
+        | 'de'
+        | 'ru';
+    }>;
+    /**
+     * Model type for translation.
+     * @default "standard"
+     */
+    model?: 'standard' | 'premium' | null;
+  } | null;
+
+  /**
+   * Language is provided as a ISO 639-1 language code, with exceptions.
+   * Only 1 language can be selected per audio, i.e. no multiple languages in one transcription job.
+   * @default "en"
+   */
+  language?: string | null;
+
+  /**
+   * Provides improved accuracy for per-word timestamps for a transcript.
+   *
+   * The following languages are currently supported:
+   * - English (en, en-us, en-gb)
+   * - French (fr)
+   * - Italian (it)
+   * - German (de)
+   * - Spanish (es)
+   *
+   * This option is not available in low-cost environment
+   * @default false
+   */
+  forced_alignment?: boolean | null;
+};

package/src/revai-config.ts

@@ -0,0 +1,9 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+export type RevaiConfig = {
+  provider: string;
+  url: (options: { modelId: string; path: string }) => string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+};

package/src/revai-error.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod/v4';
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+
+export const revaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.number(),
+  }),
+});
+
+export type RevaiErrorData = z.infer<typeof revaiErrorDataSchema>;
+
+export const revaiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: revaiErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});

package/src/revai-provider.ts

@@ -0,0 +1,120 @@
+import {
+  TranscriptionModelV3,
+  ProviderV3,
+  NoSuchModelError,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { RevaiTranscriptionModel } from './revai-transcription-model';
+import { RevaiTranscriptionModelId } from './revai-transcription-options';
+import { VERSION } from './version';
+
+export interface RevaiProvider extends ProviderV3 {
+  (
+    modelId: 'machine',
+    settings?: {},
+  ): {
+    transcription: RevaiTranscriptionModel;
+  };
+
+  /**
+Creates a model for transcription.
+   */
+  transcription(modelId: RevaiTranscriptionModelId): TranscriptionModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+export interface RevaiProviderSettings {
+  /**
+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 a Rev.ai provider instance.
+ */
+export function createRevai(
+  options: RevaiProviderSettings = {},
+): RevaiProvider {
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'REVAI_API_KEY',
+          description: 'Rev.ai',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/revai/${VERSION}`,
+    );
+
+  const createTranscriptionModel = (modelId: RevaiTranscriptionModelId) =>
+    new RevaiTranscriptionModel(modelId, {
+      provider: `revai.transcription`,
+      url: ({ path }) => `https://api.rev.ai${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function (modelId: RevaiTranscriptionModelId) {
+    return {
+      transcription: createTranscriptionModel(modelId),
+    };
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+
+  provider.languageModel = () => {
+    throw new NoSuchModelError({
+      modelId: 'unknown',
+      modelType: 'languageModel',
+      message: 'Rev.ai does not provide language models',
+    });
+  };
+
+  provider.embeddingModel = () => {
+    throw new NoSuchModelError({
+      modelId: 'unknown',
+      modelType: 'embeddingModel',
+      message: 'Rev.ai does not provide text embedding models',
+    });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+
+  provider.imageModel = () => {
+    throw new NoSuchModelError({
+      modelId: 'unknown',
+      modelType: 'imageModel',
+      message: 'Rev.ai does not provide image models',
+    });
+  };
+
+  return provider as RevaiProvider;
+}
+
+/**
+Default Rev.ai provider instance.
+ */
+export const revai = createRevai();

package/src/revai-transcription-model.ts

@@ -0,0 +1,516 @@
+import {
+  AISDKError,
+  TranscriptionModelV3,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  mediaTypeToExtension,
+  delay,
+  getFromApi,
+  parseProviderOptions,
+  postFormDataToApi,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { RevaiConfig } from './revai-config';
+import { revaiFailedResponseHandler } from './revai-error';
+import { RevaiTranscriptionModelId } from './revai-transcription-options';
+import { RevaiTranscriptionAPITypes } from './revai-api-types';
+
+// https://docs.rev.ai/api/asynchronous/reference/#operation/SubmitTranscriptionJob
+const revaiProviderOptionsSchema = z.object({
+  /**
+   * Optional metadata string to associate with the transcription job.
+   */
+  metadata: z.string().nullish(),
+  /**
+   * Configuration for webhook notifications when job is complete.
+   */
+  notification_config: z
+    .object({
+      /**
+       * URL to send the notification to.
+       */
+      url: z.string(),
+      /**
+       * Optional authorization headers for the notification request.
+       */
+      auth_headers: z
+        .object({
+          Authorization: z.string(),
+        })
+        .nullish(),
+    })
+    .nullish(),
+  /**
+   * Number of seconds after which the job will be automatically deleted.
+   */
+  delete_after_seconds: z.number().nullish(),
+  /**
+   * Whether to include filler words and false starts in the transcription.
+   */
+  verbatim: z.boolean().optional(),
+  /**
+   * Whether to prioritize the job for faster processing.
+   */
+  rush: z.boolean().nullish().default(false),
+  /**
+   * Whether to run the job in test mode.
+   */
+  test_mode: z.boolean().nullish().default(false),
+  /**
+   * Specific segments of the audio to transcribe.
+   */
+  segments_to_transcribe: z
+    .array(
+      z.object({
+        /**
+         * Start time of the segment in seconds.
+         */
+        start: z.number(),
+        /**
+         * End time of the segment in seconds.
+         */
+        end: z.number(),
+      }),
+    )
+    .nullish(),
+  /**
+   * Names to assign to speakers in the transcription.
+   */
+  speaker_names: z
+    .array(
+      z.object({
+        /**
+         * Display name for the speaker.
+         */
+        display_name: z.string(),
+      }),
+    )
+    .nullish(),
+  /**
+   * Whether to skip speaker diarization.
+   */
+  skip_diarization: z.boolean().nullish().default(false),
+  /**
+   * Whether to skip post-processing steps.
+   */
+  skip_postprocessing: z.boolean().nullish().default(false),
+  /**
+   * Whether to skip adding punctuation to the transcription.
+   */
+  skip_punctuation: z.boolean().nullish().default(false),
+  /**
+   * Whether to remove disfluencies (um, uh, etc.) from the transcription.
+   */
+  remove_disfluencies: z.boolean().nullish().default(false),
+  /**
+   * Whether to remove atmospheric sounds from the transcription.
+   */
+  remove_atmospherics: z.boolean().nullish().default(false),
+  /**
+   * Whether to filter profanity from the transcription.
+   */
+  filter_profanity: z.boolean().nullish().default(false),
+  /**
+   * Number of speaker channels in the audio.
+   */
+  speaker_channels_count: z.number().nullish(),
+  /**
+   * Expected number of speakers in the audio.
+   */
+  speakers_count: z.number().nullish(),
+  /**
+   * Type of diarization to use.
+   */
+  diarization_type: z
+    .enum(['standard', 'premium'])
+    .nullish()
+    .default('standard'),
+  /**
+   * ID of a custom vocabulary to use for the transcription.
+   */
+  custom_vocabulary_id: z.string().nullish(),
+  /**
+   * Custom vocabularies to use for the transcription.
+   */
+  custom_vocabularies: z.array(z.object({})).optional(),
+  /**
+   * Whether to strictly enforce custom vocabulary.
+   */
+  strict_custom_vocabulary: z.boolean().optional(),
+  /**
+   * Configuration for generating a summary of the transcription.
+   */
+  summarization_config: z
+    .object({
+      /**
+       * Model to use for summarization.
+       */
+      model: z.enum(['standard', 'premium']).nullish().default('standard'),
+      /**
+       * Format of the summary.
+       */
+      type: z.enum(['paragraph', 'bullets']).nullish().default('paragraph'),
+      /**
+       * Custom prompt for the summarization.
+       */
+      prompt: z.string().nullish(),
+    })
+    .nullish(),
+  /**
+   * Configuration for translating the transcription.
+   */
+  translation_config: z
+    .object({
+      /**
+       * Target languages for translation.
+       */
+      target_languages: z.array(
+        z.object({
+          /**
+           * Language code for translation target.
+           */
+          language: z.enum([
+            'en',
+            'en-us',
+            'en-gb',
+            'ar',
+            'pt',
+            'pt-br',
+            'pt-pt',
+            'fr',
+            'fr-ca',
+            'es',
+            'es-es',
+            'es-la',
+            'it',
+            'ja',
+            'ko',
+            'de',
+            'ru',
+          ]),
+        }),
+      ),
+      /**
+       * Model to use for translation.
+       */
+      model: z.enum(['standard', 'premium']).nullish().default('standard'),
+    })
+    .nullish(),
+  /**
+   * Language of the audio content.
+   */
+  language: z.string().nullish().default('en'),
+  /**
+   * Whether to perform forced alignment.
+   */
+  forced_alignment: z.boolean().nullish().default(false),
+});
+
+export type RevaiTranscriptionCallOptions = z.infer<
+  typeof revaiProviderOptionsSchema
+>;
+
+interface RevaiTranscriptionModelConfig extends RevaiConfig {
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class RevaiTranscriptionModel implements TranscriptionModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: RevaiTranscriptionModelId,
+    private readonly config: RevaiTranscriptionModelConfig,
+  ) {}
+
+  private async getArgs({
+    audio,
+    mediaType,
+    providerOptions,
+  }: Parameters<TranscriptionModelV3['doGenerate']>[0]) {
+    const warnings: SharedV3Warning[] = [];
+
+    // Parse provider options
+    const revaiOptions = await parseProviderOptions({
+      provider: 'revai',
+      providerOptions,
+      schema: revaiProviderOptionsSchema,
+    });
+
+    // Create form data with base fields
+    const formData = new FormData();
+    const blob =
+      audio instanceof Uint8Array
+        ? new Blob([audio])
+        : new Blob([convertBase64ToUint8Array(audio)]);
+
+    const fileExtension = mediaTypeToExtension(mediaType);
+    formData.append(
+      'media',
+      new File([blob], 'audio', { type: mediaType }),
+      `audio.${fileExtension}`,
+    );
+    const transcriptionModelOptions: RevaiTranscriptionAPITypes = {
+      transcriber: this.modelId,
+    };
+
+    // Add provider-specific options
+    if (revaiOptions) {
+      const formDataConfig: RevaiTranscriptionAPITypes = {
+        metadata: revaiOptions.metadata ?? undefined,
+        notification_config: revaiOptions.notification_config ?? undefined,
+        delete_after_seconds: revaiOptions.delete_after_seconds ?? undefined,
+        verbatim: revaiOptions.verbatim ?? undefined,
+        rush: revaiOptions.rush ?? undefined,
+        test_mode: revaiOptions.test_mode ?? undefined,
+        segments_to_transcribe:
+          revaiOptions.segments_to_transcribe ?? undefined,
+        speaker_names: revaiOptions.speaker_names ?? undefined,
+        skip_diarization: revaiOptions.skip_diarization ?? undefined,
+        skip_postprocessing: revaiOptions.skip_postprocessing ?? undefined,
+        skip_punctuation: revaiOptions.skip_punctuation ?? undefined,
+        remove_disfluencies: revaiOptions.remove_disfluencies ?? undefined,
+        remove_atmospherics: revaiOptions.remove_atmospherics ?? undefined,
+        filter_profanity: revaiOptions.filter_profanity ?? undefined,
+        speaker_channels_count:
+          revaiOptions.speaker_channels_count ?? undefined,
+        speakers_count: revaiOptions.speakers_count ?? undefined,
+        diarization_type: revaiOptions.diarization_type ?? undefined,
+        custom_vocabulary_id: revaiOptions.custom_vocabulary_id ?? undefined,
+        custom_vocabularies: revaiOptions.custom_vocabularies ?? undefined,
+        strict_custom_vocabulary:
+          revaiOptions.strict_custom_vocabulary ?? undefined,
+        summarization_config: revaiOptions.summarization_config ?? undefined,
+        translation_config: revaiOptions.translation_config ?? undefined,
+        language: revaiOptions.language ?? undefined,
+        forced_alignment: revaiOptions.forced_alignment ?? undefined,
+      };
+
+      for (const key in formDataConfig) {
+        const value = formDataConfig[key as keyof RevaiTranscriptionAPITypes];
+        if (value !== undefined) {
+          (transcriptionModelOptions as Record<string, unknown>)[
+            key as keyof RevaiTranscriptionAPITypes
+          ] = value;
+        }
+      }
+    }
+
+    formData.append('config', JSON.stringify(transcriptionModelOptions));
+
+    return {
+      formData,
+      warnings,
+    };
+  }
+
+  async doGenerate(
+    options: Parameters<TranscriptionModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const { formData, warnings } = await this.getArgs(options);
+
+    const { value: submissionResponse } = await postFormDataToApi({
+      url: this.config.url({
+        path: '/speechtotext/v1/jobs',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: revaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        revaiTranscriptionJobResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    if (submissionResponse.status === 'failed') {
+      throw new AISDKError({
+        message: 'Failed to submit transcription job to Rev.ai',
+        name: 'TranscriptionJobSubmissionFailed',
+        cause: submissionResponse,
+      });
+    }
+
+    const jobId = submissionResponse.id;
+    const timeoutMs = 60 * 1000; // 60 seconds timeout
+    const startTime = Date.now();
+    const pollingInterval = 1000;
+    let jobResponse = submissionResponse;
+
+    while (jobResponse.status !== 'transcribed') {
+      // Check if we've exceeded the timeout
+      if (Date.now() - startTime > timeoutMs) {
+        throw new AISDKError({
+          message: 'Transcription job polling timed out',
+          name: 'TranscriptionJobPollingTimedOut',
+          cause: submissionResponse,
+        });
+      }
+
+      // Poll for job status
+      const pollingResult = await getFromApi({
+        url: this.config.url({
+          path: `/speechtotext/v1/jobs/${jobId}`,
+          modelId: this.modelId,
+        }),
+        headers: combineHeaders(this.config.headers(), options.headers),
+        failedResponseHandler: revaiFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          revaiTranscriptionJobResponseSchema,
+        ),
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch,
+      });
+
+      jobResponse = pollingResult.value;
+
+      if (jobResponse.status === 'failed') {
+        throw new AISDKError({
+          message: 'Transcription job failed',
+          name: 'TranscriptionJobFailed',
+          cause: jobResponse,
+        });
+      }
+
+      // Wait before polling again (only if we need to continue polling)
+      if (jobResponse.status !== 'transcribed') {
+        await delay(pollingInterval);
+      }
+    }
+
+    const {
+      value: transcriptionResult,
+      responseHeaders,
+      rawValue: rawResponse,
+    } = await getFromApi({
+      url: this.config.url({
+        path: `/speechtotext/v1/jobs/${jobId}/transcript`,
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      failedResponseHandler: revaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        revaiTranscriptionResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    let durationInSeconds = 0;
+    const segments: {
+      text: string;
+      startSecond: number;
+      endSecond: number;
+    }[] = [];
+
+    for (const monologue of transcriptionResult.monologues ?? []) {
+      // Process each monologue to extract segments with timing information
+      let currentSegmentText = '';
+      let segmentStartSecond = 0;
+      let hasStartedSegment = false;
+
+      for (const element of monologue?.elements ?? []) {
+        // Add the element value to the current segment text
+        currentSegmentText += element.value;
+
+        // For text elements, track timing information
+        if (element.type === 'text') {
+          // Update the overall duration if this is the latest timestamp
+          if (element.end_ts && element.end_ts > durationInSeconds) {
+            durationInSeconds = element.end_ts;
+          }
+
+          // If this is the first text element in a segment, mark the start time
+          if (!hasStartedSegment && typeof element.ts === 'number') {
+            segmentStartSecond = element.ts;
+            hasStartedSegment = true;
+          }
+
+          // If we have an end timestamp, we can complete a segment
+          if (typeof element.end_ts === 'number' && hasStartedSegment) {
+            // Only add non-empty segments
+            if (currentSegmentText.trim()) {
+              segments.push({
+                text: currentSegmentText.trim(),
+                startSecond: segmentStartSecond,
+                endSecond: element.end_ts,
+              });
+            }
+
+            // Reset for the next segment
+            currentSegmentText = '';
+            hasStartedSegment = false;
+          }
+        }
+      }
+
+      // Handle any remaining segment text that wasn't added
+      if (hasStartedSegment && currentSegmentText.trim()) {
+        const endSecond =
+          durationInSeconds > segmentStartSecond
+            ? durationInSeconds
+            : segmentStartSecond + 1;
+        segments.push({
+          text: currentSegmentText.trim(),
+          startSecond: segmentStartSecond,
+          endSecond: endSecond,
+        });
+      }
+    }
+
+    return {
+      text:
+        transcriptionResult.monologues
+          ?.map(monologue =>
+            monologue?.elements?.map(element => element.value).join(''),
+          )
+          .join(' ') ?? '',
+      segments,
+      language: submissionResponse.language ?? undefined,
+      durationInSeconds,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+    };
+  }
+}
+
+const revaiTranscriptionJobResponseSchema = z.object({
+  id: z.string().nullish(),
+  status: z.string().nullish(),
+  language: z.string().nullish(),
+});
+
+const revaiTranscriptionResponseSchema = z.object({
+  monologues: z
+    .array(
+      z.object({
+        elements: z
+          .array(
+            z.object({
+              type: z.string().nullish(),
+              value: z.string().nullish(),
+              ts: z.number().nullish(),
+              end_ts: z.number().nullish(),
+            }),
+          )
+          .nullish(),
+      }),
+    )
+    .nullish(),
+});

package/src/revai-transcription-options.ts

@@ -0,0 +1 @@
+export type RevaiTranscriptionModelId = 'machine' | 'low_cost' | 'fusion';

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';