@ai-sdk/revai 2.0.7 → 2.0.9

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/revai
 
+## 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

package/dist/index.js

@@ -455,7 +455,7 @@ var revaiTranscriptionResponseSchema = import_v42.z.object({
 });
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "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 ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/revai-provider.ts
 function createRevai(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/revai",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "src",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -20,15 +21,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.3",
-    "@ai-sdk/provider-utils": "4.0.7"
+    "@ai-sdk/provider": "3.0.4",
+    "@ai-sdk/provider-utils": "4.0.8"
   },
   "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": "1.0.2",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

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.test.ts

@@ -0,0 +1,34 @@
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { revaiErrorDataSchema } from './revai-error';
+import { describe, it, expect } from 'vitest';
+
+describe('revaiErrorDataSchema', () => {
+  it('should parse Rev.ai resource exhausted error', async () => {
+    const error = `
+{"error":{"message":"{\\n  \\"error\\": {\\n    \\"code\\": 429,\\n    \\"message\\": \\"Resource has been exhausted (e.g. check quota).\\",\\n    \\"status\\": \\"RESOURCE_EXHAUSTED\\"\\n  }\\n}\\n","code":429}}
+`;
+
+    const result = await safeParseJSON({
+      text: error,
+      schema: revaiErrorDataSchema,
+    });
+
+    expect(result).toStrictEqual({
+      success: true,
+      value: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+      rawValue: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+    });
+  });
+});

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.test.ts

@@ -0,0 +1,282 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { RevaiTranscriptionModel } from './revai-transcription-model';
+import { createRevai } from './revai-provider';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const audioData = await readFile(path.join(__dirname, 'transcript-test.mp3'));
+const provider = createRevai({ apiKey: 'test-api-key' });
+const model = provider.transcription('machine');
+
+const server = createTestServer({
+  'https://api.rev.ai/speechtotext/v1/jobs': {},
+  'https://api.rev.ai/speechtotext/v1/jobs/test-id': {},
+  'https://api.rev.ai/speechtotext/v1/jobs/test-id/transcript': {},
+});
+
+describe('doGenerate', () => {
+  function prepareJsonResponse({
+    headers,
+  }: {
+    headers?: Record<string, string>;
+  } = {}) {
+    server.urls['https://api.rev.ai/speechtotext/v1/jobs'].response = {
+      type: 'json-value',
+      headers,
+      body: {
+        id: 'test-id',
+        status: 'in_progress',
+        language: 'en',
+        created_on: '2018-05-05T23:23:22.29Z',
+        transcriber: 'machine',
+      },
+    };
+    server.urls['https://api.rev.ai/speechtotext/v1/jobs/test-id'].response = {
+      type: 'json-value',
+      headers,
+      body: {
+        id: 'test-id',
+        status: 'transcribed',
+        language: 'en',
+        created_on: '2018-05-05T23:23:22.29Z',
+        transcriber: 'machine',
+      },
+    };
+    server.urls[
+      'https://api.rev.ai/speechtotext/v1/jobs/test-id/transcript'
+    ].response = {
+      type: 'json-value',
+      headers,
+      body: {
+        monologues: [
+          {
+            speaker: 1,
+            elements: [
+              {
+                type: 'text',
+                value: 'Hello',
+                ts: 0.5,
+                end_ts: 1.5,
+                confidence: 1,
+              },
+              {
+                type: 'punct',
+                value: ' ',
+              },
+              {
+                type: 'text',
+                value: 'World',
+                ts: 1.75,
+                end_ts: 2.85,
+                confidence: 0.8,
+              },
+              {
+                type: 'punct',
+                value: '.',
+              },
+            ],
+          },
+          {
+            speaker: 2,
+            elements: [
+              {
+                type: 'text',
+                value: 'monologues',
+                ts: 3,
+                end_ts: 3.5,
+                confidence: 1,
+              },
+              {
+                type: 'punct',
+                value: ' ',
+              },
+              {
+                type: 'text',
+                value: 'are',
+                ts: 3.6,
+                end_ts: 3.9,
+                confidence: 1,
+              },
+              {
+                type: 'punct',
+                value: ' ',
+              },
+              {
+                type: 'text',
+                value: 'a',
+                ts: 4,
+                end_ts: 4.3,
+                confidence: 1,
+              },
+              {
+                type: 'punct',
+                value: ' ',
+              },
+              {
+                type: 'text',
+                value: 'block',
+                ts: 4.5,
+                end_ts: 5.5,
+                confidence: 1,
+              },
+              {
+                type: 'punct',
+                value: ' ',
+              },
+              {
+                type: 'text',
+                value: 'of',
+                ts: 5.75,
+                end_ts: 6.14,
+                confidence: 1,
+              },
+              {
+                type: 'punct',
+                value: ' ',
+              },
+              {
+                type: 'unknown',
+                value: '<inaudible>',
+              },
+              {
+                type: 'punct',
+                value: ' ',
+              },
+              {
+                type: 'text',
+                value: 'text',
+                ts: 6.5,
+                end_ts: 7.78,
+                confidence: 1,
+              },
+              {
+                type: 'punct',
+                value: '.',
+              },
+            ],
+          },
+        ],
+      },
+    };
+  }
+
+  it('should pass the model', async () => {
+    prepareJsonResponse();
+
+    await model.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(await server.calls[0].requestBodyMultipart).toMatchObject({
+      media: expect.any(File),
+      config: '{"transcriber":"machine"}',
+    });
+  });
+
+  it('should pass headers', async () => {
+    prepareJsonResponse();
+
+    const provider = createRevai({
+      apiKey: 'test-api-key',
+      headers: {
+        'Custom-Provider-Header': 'provider-header-value',
+      },
+    });
+
+    await provider.transcription('machine').doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    expect(server.calls[0].requestHeaders).toMatchObject({
+      authorization: 'Bearer test-api-key',
+      'content-type': expect.stringMatching(
+        /^multipart\/form-data; boundary=----formdata-undici-\d+$/,
+      ),
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+    });
+
+    expect(server.calls[0].requestUserAgent).toContain(
+      `ai-sdk/revai/0.0.0-test`,
+    );
+  });
+
+  it('should extract the transcription text', async () => {
+    prepareJsonResponse();
+
+    const result = await model.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(result.text).toBe(
+      'Hello World. monologues are a block of <inaudible> text.',
+    );
+  });
+
+  it('should include response data with timestamp, modelId and headers', async () => {
+    prepareJsonResponse({
+      headers: {
+        'x-request-id': 'test-request-id',
+        'x-ratelimit-remaining': '123',
+      },
+    });
+
+    const testDate = new Date(0);
+    const customModel = new RevaiTranscriptionModel('machine', {
+      provider: 'test-provider',
+      url: ({ path }) => `https://api.rev.ai${path}`,
+      headers: () => ({}),
+      _internal: {
+        currentDate: () => testDate,
+      },
+    });
+
+    const result = await customModel.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(result.response).toMatchObject({
+      timestamp: testDate,
+      modelId: 'machine',
+      headers: {
+        'content-type': 'application/json',
+        'x-request-id': 'test-request-id',
+        'x-ratelimit-remaining': '123',
+      },
+    });
+  });
+
+  it('should use real date when no custom date provider is specified', async () => {
+    prepareJsonResponse();
+
+    const testDate = new Date(0);
+    const customModel = new RevaiTranscriptionModel('machine', {
+      provider: 'test-provider',
+      url: ({ path }) => `https://api.rev.ai${path}`,
+      headers: () => ({}),
+      _internal: {
+        currentDate: () => testDate,
+      },
+    });
+
+    const result = await customModel.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(result.response.timestamp.getTime()).toEqual(testDate.getTime());
+    expect(result.response.modelId).toBe('machine');
+  });
+});

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';