@ai-sdk/fal 2.0.10 → 2.0.12

package/src/fal-provider.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { createFal } from './fal-provider';
-import { FalImageModel } from './fal-image-model';
-
-vi.mock('./fal-image-model', () => ({
-  FalImageModel: vi.fn(),
-}));
-
-describe('createFal', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('image', () => {
-    it('should construct an image model with default configuration', () => {
-      const provider = createFal();
-      const modelId = 'fal-ai/flux/dev';
-
-      const model = provider.image(modelId);
-
-      expect(model).toBeInstanceOf(FalImageModel);
-      expect(FalImageModel).toHaveBeenCalledWith(
-        modelId,
-        expect.objectContaining({
-          provider: 'fal.image',
-          baseURL: 'https://fal.run',
-        }),
-      );
-    });
-
-    it('should respect custom configuration options', () => {
-      const customBaseURL = 'https://custom.fal.run';
-      const customHeaders = { 'X-Custom-Header': 'value' };
-      const mockFetch = vi.fn();
-
-      const provider = createFal({
-        apiKey: 'custom-api-key',
-        baseURL: customBaseURL,
-        headers: customHeaders,
-        fetch: mockFetch,
-      });
-      const modelId = 'fal-ai/flux/dev';
-
-      provider.image(modelId);
-
-      expect(FalImageModel).toHaveBeenCalledWith(
-        modelId,
-        expect.objectContaining({
-          baseURL: customBaseURL,
-          headers: expect.any(Function),
-          fetch: mockFetch,
-          provider: 'fal.image',
-        }),
-      );
-    });
-  });
-});

package/src/fal-speech-model.test.ts

@@ -1,128 +0,0 @@
-import { createTestServer } from '@ai-sdk/test-server/with-vitest';
-import { createFal } from './fal-provider';
-import { FalSpeechModel } from './fal-speech-model';
-import { describe, it, expect } from 'vitest';
-
-const provider = createFal({ apiKey: 'test-api-key' });
-const model = provider.speech('fal-ai/minimax/speech-02-hd');
-
-const server = createTestServer({
-  'https://fal.run/fal-ai/minimax/speech-02-hd': {},
-  'https://fal.media/files/test.mp3': {},
-});
-
-describe('FalSpeechModel.doGenerate', () => {
-  function prepareResponses({
-    jsonHeaders,
-    audioHeaders,
-  }: {
-    jsonHeaders?: Record<string, string>;
-    audioHeaders?: Record<string, string>;
-  } = {}) {
-    const audioBuffer = new Uint8Array(100);
-    server.urls['https://fal.run/fal-ai/minimax/speech-02-hd'].response = {
-      type: 'json-value',
-      headers: {
-        'content-type': 'application/json',
-        ...jsonHeaders,
-      },
-      body: {
-        audio: { url: 'https://fal.media/files/test.mp3' },
-        duration_ms: 1234,
-      },
-    };
-    server.urls['https://fal.media/files/test.mp3'].response = {
-      type: 'binary',
-      headers: {
-        'content-type': 'audio/mp3',
-        ...audioHeaders,
-      },
-      body: Buffer.from(audioBuffer),
-    };
-    return audioBuffer;
-  }
-
-  it('should pass text and default output_format', async () => {
-    prepareResponses();
-
-    await model.doGenerate({
-      text: 'Hello from the AI SDK!',
-    });
-
-    expect(await server.calls[0].requestBodyJson).toMatchObject({
-      text: 'Hello from the AI SDK!',
-      output_format: 'url',
-    });
-  });
-
-  it('should pass headers', async () => {
-    prepareResponses();
-
-    const provider = createFal({
-      apiKey: 'test-api-key',
-      headers: {
-        'Custom-Provider-Header': 'provider-header-value',
-      },
-    });
-
-    await provider.speech('fal-ai/minimax/speech-02-hd').doGenerate({
-      text: 'Hello from the AI SDK!',
-      headers: {
-        'Custom-Request-Header': 'request-header-value',
-      },
-    });
-
-    expect(server.calls[0].requestHeaders).toMatchObject({
-      authorization: 'Key test-api-key',
-      'content-type': 'application/json',
-      'custom-provider-header': 'provider-header-value',
-      'custom-request-header': 'request-header-value',
-    });
-  });
-
-  it('should return audio data', async () => {
-    const audio = prepareResponses();
-
-    const result = await model.doGenerate({
-      text: 'Hello from the AI SDK!',
-    });
-
-    expect(result.audio).toStrictEqual(audio);
-  });
-
-  it('should include response data with timestamp, modelId and headers', async () => {
-    prepareResponses({ jsonHeaders: { 'x-request-id': 'test-request-id' } });
-
-    const testDate = new Date(0);
-    const customModel = new FalSpeechModel('fal-ai/minimax/speech-02-hd', {
-      provider: 'fal.speech',
-      url: ({ path }) => path,
-      headers: () => ({}),
-      _internal: { currentDate: () => testDate },
-    });
-
-    const result = await customModel.doGenerate({
-      text: 'Hello from the AI SDK!',
-    });
-
-    expect(result.response).toMatchObject({
-      timestamp: testDate,
-      modelId: 'fal-ai/minimax/speech-02-hd',
-      headers: expect.objectContaining({ 'x-request-id': 'test-request-id' }),
-    });
-  });
-
-  it('should include warnings for unsupported settings', async () => {
-    prepareResponses();
-
-    const result = await model.doGenerate({
-      text: 'Hello from the AI SDK!',
-      language: 'en',
-      // invalid outputFormat triggers a warning and defaults to url
-      // (we still return audio via URL)
-      outputFormat: 'wav',
-    });
-
-    expect(result.warnings.length).toBeGreaterThan(0);
-  });
-});

package/src/fal-transcription-model.test.ts

@@ -1,181 +0,0 @@
-import { createTestServer } from '@ai-sdk/test-server/with-vitest';
-import { createFal } from './fal-provider';
-import { FalTranscriptionModel } from './fal-transcription-model';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { describe, it, expect } from 'vitest';
-
-const audioData = await readFile(path.join(__dirname, 'transcript-test.mp3'));
-const provider = createFal({ apiKey: 'test-api-key' });
-const model = provider.transcription('wizper');
-
-const server = createTestServer({
-  'https://queue.fal.run/fal-ai/wizper': {},
-  'https://queue.fal.run/fal-ai/wizper/requests/test-id': {},
-});
-
-describe('doGenerate', () => {
-  function prepareJsonResponse({
-    headers,
-  }: {
-    headers?: Record<string, string>;
-  } = {}) {
-    server.urls['https://queue.fal.run/fal-ai/wizper'].response = {
-      type: 'json-value',
-      headers,
-      body: {
-        status: 'COMPLETED',
-        request_id: 'test-id',
-        response_url:
-          'https://queue.fal.run/fal-ai/wizper/requests/test-id/result',
-        status_url: 'https://queue.fal.run/fal-ai/wizper/requests/test-id',
-        cancel_url:
-          'https://queue.fal.run/fal-ai/wizper/requests/test-id/cancel',
-        logs: null,
-        metrics: {},
-        queue_position: 0,
-      },
-    };
-    server.urls[
-      'https://queue.fal.run/fal-ai/wizper/requests/test-id'
-    ].response = {
-      type: 'json-value',
-      headers,
-      body: {
-        text: 'Hello world!',
-        chunks: [
-          {
-            text: 'Hello',
-            timestamp: [0, 1],
-            speaker: 'speaker_1',
-          },
-          {
-            text: ' ',
-            timestamp: [1, 2],
-            speaker: 'speaker_1',
-          },
-          {
-            text: 'world!',
-            timestamp: [2, 3],
-            speaker: 'speaker_1',
-          },
-        ],
-        diarization_segments: [
-          {
-            speaker: 'speaker_1',
-            timestamp: [0, 3],
-          },
-        ],
-      },
-    };
-  }
-
-  it('should pass the model', async () => {
-    prepareJsonResponse();
-
-    await model.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-    });
-
-    expect(await server.calls[0].requestBodyJson).toMatchObject({
-      audio_url: expect.stringMatching(/^data:audio\//),
-      task: 'transcribe',
-      diarize: true,
-      chunk_level: 'word',
-    });
-  });
-
-  it('should pass headers', async () => {
-    prepareJsonResponse();
-
-    const provider = createFal({
-      apiKey: 'test-api-key',
-      headers: {
-        'Custom-Provider-Header': 'provider-header-value',
-      },
-    });
-
-    await provider.transcription('wizper').doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-      headers: {
-        'Custom-Request-Header': 'request-header-value',
-      },
-    });
-
-    expect(server.calls[0].requestHeaders).toMatchObject({
-      authorization: 'Key test-api-key',
-      'content-type': 'application/json',
-      'custom-provider-header': 'provider-header-value',
-      'custom-request-header': 'request-header-value',
-    });
-  });
-
-  it('should extract the transcription text', async () => {
-    prepareJsonResponse();
-
-    const result = await model.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-    });
-
-    expect(result.text).toBe('Hello world!');
-  });
-
-  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 FalTranscriptionModel('wizper', {
-      provider: 'test-provider',
-      url: ({ path }) => path,
-      headers: () => ({}),
-      _internal: {
-        currentDate: () => testDate,
-      },
-    });
-
-    const result = await customModel.doGenerate({
-      audio: audioData,
-      mediaType: 'audio/wav',
-    });
-
-    expect(result.response).toMatchObject({
-      timestamp: testDate,
-      modelId: 'wizper',
-      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 FalTranscriptionModel('wizper', {
-      provider: 'test-provider',
-      url: ({ path }) => 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('wizper');
-  });
-});