@ai-sdk/replicate 2.0.7 → 2.0.9

package/CHANGELOG.md

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

@@ -227,7 +227,7 @@ var replicateImageProviderOptionsSchema = (0, import_provider_utils2.lazySchema)
 );
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/replicate-provider.ts
 function createReplicate(options = {}) {

package/dist/index.mjs

@@ -210,7 +210,7 @@ var replicateImageProviderOptionsSchema = lazySchema(
 );
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/replicate-provider.ts
 function createReplicate(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/replicate",
-  "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.8.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,7 @@
+export { createReplicate, replicate } from './replicate-provider';
+export type {
+  ReplicateProvider,
+  ReplicateProviderSettings,
+} from './replicate-provider';
+export type { ReplicateImageProviderOptions } from './replicate-image-model';
+export { VERSION } from './version';

package/src/replicate-error.ts

@@ -0,0 +1,13 @@
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+const replicateErrorSchema = z.object({
+  detail: z.string().optional(),
+  error: z.string().optional(),
+});
+
+export const replicateFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: replicateErrorSchema,
+  errorToMessage: error =>
+    error.detail ?? error.error ?? 'Unknown Replicate error',
+});

package/src/replicate-image-model.test.ts

@@ -0,0 +1,752 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { createReplicate } from './replicate-provider';
+import { ReplicateImageModel } from './replicate-image-model';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const prompt = 'The Loch Ness monster getting a manicure';
+
+const provider = createReplicate({ apiToken: 'test-api-token' });
+const model = provider.image('black-forest-labs/flux-schnell');
+
+describe('doGenerate', () => {
+  const testDate = new Date(2024, 0, 1);
+  const server = createTestServer({
+    'https://api.replicate.com/*': {},
+    'https://replicate.delivery/*': {
+      response: {
+        type: 'binary',
+        body: Buffer.from('test-binary-content'),
+      },
+    },
+  });
+
+  function prepareResponse({
+    output = ['https://replicate.delivery/xezq/abc/out-0.webp'],
+  }: { output?: string | Array<string> } = {}) {
+    server.urls['https://api.replicate.com/*'].response = {
+      type: 'json-value',
+      body: {
+        id: 's7x1e3dcmhrmc0cm8rbatcneec',
+        model: 'black-forest-labs/flux-schnell',
+        version: 'dp-4d0bcc010b3049749a251855f12800be',
+        input: {
+          num_outputs: 1,
+          prompt: 'The Loch Ness Monster getting a manicure',
+        },
+        logs: '',
+        output,
+        data_removed: false,
+        error: null,
+        status: 'processing',
+        created_at: '2025-01-08T13:24:38.692Z',
+        urls: {
+          cancel:
+            'https://api.replicate.com/v1/predictions/s7x1e3dcmhrmc0cm8rbatcneec/cancel',
+          get: 'https://api.replicate.com/v1/predictions/s7x1e3dcmhrmc0cm8rbatcneec',
+          stream:
+            'https://stream.replicate.com/v1/files/bcwr-3okdfv3o2wehstv5f2okyftwxy57hhypqsi6osiim5iaq5k7u24a',
+        },
+      },
+    };
+  }
+
+  it('should pass the model and the settings', async () => {
+    prepareResponse();
+
+    await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: '1024x768',
+      aspectRatio: '3:4',
+      seed: 123,
+      providerOptions: {
+        replicate: {
+          style: 'realistic_image',
+        },
+        other: {
+          something: 'else',
+        },
+      },
+    });
+
+    expect(await server.calls[0].requestBodyJson).toStrictEqual({
+      input: {
+        prompt,
+        num_outputs: 1,
+        aspect_ratio: '3:4',
+        size: '1024x768',
+        seed: 123,
+        style: 'realistic_image',
+      },
+    });
+  });
+
+  it('should call the correct url', async () => {
+    prepareResponse();
+
+    await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    expect(server.calls[0].requestMethod).toStrictEqual('POST');
+    expect(server.calls[0].requestUrl).toStrictEqual(
+      'https://api.replicate.com/v1/models/black-forest-labs/flux-schnell/predictions',
+    );
+  });
+
+  it('should pass headers and set the prefer header', async () => {
+    prepareResponse();
+
+    const provider = createReplicate({
+      apiToken: 'test-api-token',
+      headers: {
+        'Custom-Provider-Header': 'provider-header-value',
+      },
+    });
+
+    await provider.image('black-forest-labs/flux-schnell').doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    expect(server.calls[0].requestHeaders).toStrictEqual({
+      authorization: 'Bearer test-api-token',
+      'content-type': 'application/json',
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+      prefer: 'wait',
+    });
+
+    expect(server.calls[0].requestUserAgent).toContain(
+      `ai-sdk/replicate/0.0.0-test`,
+    );
+  });
+
+  it('should set custom wait time in prefer header when maxWaitTimeInSeconds is specified', async () => {
+    prepareResponse();
+
+    await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {
+        replicate: {
+          maxWaitTimeInSeconds: 120,
+        },
+      },
+    });
+
+    expect(server.calls[0].requestHeaders.prefer).toBe('wait=120');
+  });
+
+  it('should not include maxWaitTimeInSeconds in request body', async () => {
+    prepareResponse();
+
+    await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {
+        replicate: {
+          maxWaitTimeInSeconds: 120,
+          guidance_scale: 7.5,
+        },
+      },
+    });
+
+    const requestBody = await server.calls[0].requestBodyJson;
+    expect(requestBody.input.maxWaitTimeInSeconds).toBeUndefined();
+    expect(requestBody.input.guidance_scale).toBe(7.5);
+  });
+
+  it('should extract the generated image from array response', async () => {
+    prepareResponse({
+      output: ['https://replicate.delivery/xezq/abc/out-0.webp'],
+    });
+
+    const result = await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    expect(result.images).toStrictEqual([
+      new Uint8Array(Buffer.from('test-binary-content')),
+    ]);
+
+    expect(server.calls[1].requestMethod).toStrictEqual('GET');
+    expect(server.calls[1].requestUrl).toStrictEqual(
+      'https://replicate.delivery/xezq/abc/out-0.webp',
+    );
+  });
+
+  it('should extract the generated image from string response', async () => {
+    prepareResponse({
+      output: 'https://replicate.delivery/xezq/abc/out-0.webp',
+    });
+
+    const result = await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    expect(result.images).toStrictEqual([
+      new Uint8Array(Buffer.from('test-binary-content')),
+    ]);
+
+    expect(server.calls[1].requestMethod).toStrictEqual('GET');
+    expect(server.calls[1].requestUrl).toStrictEqual(
+      'https://replicate.delivery/xezq/abc/out-0.webp',
+    );
+  });
+
+  it('should return response metadata', async () => {
+    const modelWithTimestamp = new ReplicateImageModel(
+      'black-forest-labs/flux-schnell',
+      {
+        provider: 'replicate',
+        baseURL: 'https://api.replicate.com',
+        _internal: { currentDate: () => testDate },
+      },
+    );
+    prepareResponse({
+      output: ['https://replicate.delivery/xezq/abc/out-0.webp'],
+    });
+
+    const result = await modelWithTimestamp.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    expect(result.response).toStrictEqual({
+      timestamp: testDate,
+      modelId: 'black-forest-labs/flux-schnell',
+      headers: expect.any(Object),
+    });
+  });
+
+  it('should include response headers in metadata', async () => {
+    const modelWithTimestamp = new ReplicateImageModel(
+      'black-forest-labs/flux-schnell',
+      {
+        provider: 'replicate',
+        baseURL: 'https://api.replicate.com',
+        _internal: {
+          currentDate: () => testDate,
+        },
+      },
+    );
+    server.urls['https://api.replicate.com/*'].response = {
+      type: 'json-value',
+      headers: {
+        'custom-response-header': 'response-header-value',
+      },
+      body: {
+        id: 's7x1e3dcmhrmc0cm8rbatcneec',
+        model: 'black-forest-labs/flux-schnell',
+        version: 'dp-4d0bcc010b3049749a251855f12800be',
+        input: {
+          num_outputs: 1,
+          prompt: 'The Loch Ness Monster getting a manicure',
+        },
+        logs: '',
+        output: ['https://replicate.delivery/xezq/abc/out-0.webp'],
+        data_removed: false,
+        error: null,
+        status: 'processing',
+        created_at: '2025-01-08T13:24:38.692Z',
+        urls: {
+          cancel:
+            'https://api.replicate.com/v1/predictions/s7x1e3dcmhrmc0cm8rbatcneec/cancel',
+          get: 'https://api.replicate.com/v1/predictions/s7x1e3dcmhrmc0cm8rbatcneec',
+          stream:
+            'https://stream.replicate.com/v1/files/bcwr-3okdfv3o2wehstv5f2okyftwxy57hhypqsi6osiim5iaq5k7u24a',
+        },
+      },
+    };
+
+    const result = await modelWithTimestamp.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    expect(result.response).toStrictEqual({
+      timestamp: testDate,
+      modelId: 'black-forest-labs/flux-schnell',
+      headers: {
+        'content-length': '646',
+        'content-type': 'application/json',
+        'custom-response-header': 'response-header-value',
+      },
+    });
+  });
+
+  it('should set version in request body for versioned models', async () => {
+    prepareResponse();
+
+    const versionedModel = provider.image(
+      'bytedance/sdxl-lightning-4step:5599ed30703defd1d160a25a63321b4dec97101d98b4674bcc56e41f62f35637',
+    );
+
+    await versionedModel.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    expect(server.calls[0].requestMethod).toStrictEqual('POST');
+    expect(server.calls[0].requestUrl).toStrictEqual(
+      'https://api.replicate.com/v1/predictions',
+    );
+    expect(await server.calls[0].requestBodyJson).toStrictEqual({
+      input: {
+        prompt,
+        num_outputs: 1,
+      },
+      version:
+        '5599ed30703defd1d160a25a63321b4dec97101d98b4674bcc56e41f62f35637',
+    });
+  });
+
+  describe('Image Editing', () => {
+    it('should send image when URL file is provided', async () => {
+      prepareResponse();
+
+      await model.doGenerate({
+        prompt: 'Add a hat to the person',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/input.jpg',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input": {
+            "image": "https://example.com/input.jpg",
+            "num_outputs": 1,
+            "prompt": "Add a hat to the person",
+          },
+        }
+      `);
+    });
+
+    it('should convert Uint8Array file to data URI', async () => {
+      prepareResponse();
+
+      const testImageData = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+
+      await model.doGenerate({
+        prompt: 'Transform this image',
+        files: [
+          {
+            type: 'file',
+            data: testImageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody.input.image).toMatch(/^data:image\/png;base64,/);
+      expect(requestBody.input.prompt).toBe('Transform this image');
+    });
+
+    it('should convert file with base64 string data to data URI', async () => {
+      prepareResponse();
+
+      await model.doGenerate({
+        prompt: 'Edit this',
+        files: [
+          {
+            type: 'file',
+            data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody.input.image).toBe(
+        'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      );
+    });
+
+    it('should send mask for inpainting', async () => {
+      prepareResponse();
+
+      await model.doGenerate({
+        prompt: 'Replace the masked area with a tree',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/input.jpg',
+          },
+        ],
+        mask: {
+          type: 'url',
+          url: 'https://example.com/mask.png',
+        },
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input": {
+            "image": "https://example.com/input.jpg",
+            "mask": "https://example.com/mask.png",
+            "num_outputs": 1,
+            "prompt": "Replace the masked area with a tree",
+          },
+        }
+      `);
+    });
+
+    it('should warn when multiple files are provided', async () => {
+      prepareResponse();
+
+      const result = await model.doGenerate({
+        prompt: 'Edit multiple images',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/input1.jpg',
+          },
+          {
+            type: 'url',
+            url: 'https://example.com/input2.jpg',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.warnings).toMatchInlineSnapshot(`
+        [
+          {
+            "message": "This Replicate model only supports a single input image. Additional images are ignored.",
+            "type": "other",
+          },
+        ]
+      `);
+
+      // Should only use the first image
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody.input.image).toBe('https://example.com/input1.jpg');
+    });
+
+    it('should pass provider options with image editing', async () => {
+      prepareResponse();
+
+      await model.doGenerate({
+        prompt: 'Inpaint this area',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/input.jpg',
+          },
+        ],
+        mask: {
+          type: 'url',
+          url: 'https://example.com/mask.png',
+        },
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {
+          replicate: {
+            guidance_scale: 7.5,
+            num_inference_steps: 30,
+            negative_prompt: 'blurry, low quality',
+          },
+        },
+      });
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input": {
+            "guidance_scale": 7.5,
+            "image": "https://example.com/input.jpg",
+            "mask": "https://example.com/mask.png",
+            "negative_prompt": "blurry, low quality",
+            "num_inference_steps": 30,
+            "num_outputs": 1,
+            "prompt": "Inpaint this area",
+          },
+        }
+      `);
+    });
+  });
+
+  describe('Flux-2 Models', () => {
+    const flux2Model = provider.image('black-forest-labs/flux-2-pro');
+
+    it('should report maxImagesPerCall as 8 for Flux-2 models', () => {
+      expect(flux2Model.maxImagesPerCall).toBe(8);
+    });
+
+    it('should report maxImagesPerCall as 1 for non-Flux-2 models', () => {
+      expect(model.maxImagesPerCall).toBe(1);
+    });
+
+    it('should send single image as input_image for Flux-2 models', async () => {
+      prepareResponse();
+
+      await flux2Model.doGenerate({
+        prompt: 'Generate image in similar style',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/reference.jpg',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input": {
+            "input_image": "https://example.com/reference.jpg",
+            "num_outputs": 1,
+            "prompt": "Generate image in similar style",
+          },
+        }
+      `);
+    });
+
+    it('should send multiple images as input_image, input_image_2, etc. for Flux-2 models', async () => {
+      prepareResponse();
+
+      await flux2Model.doGenerate({
+        prompt: 'Combine styles from reference images',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/reference1.jpg',
+          },
+          {
+            type: 'url',
+            url: 'https://example.com/reference2.jpg',
+          },
+          {
+            type: 'url',
+            url: 'https://example.com/reference3.jpg',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input": {
+            "input_image": "https://example.com/reference1.jpg",
+            "input_image_2": "https://example.com/reference2.jpg",
+            "input_image_3": "https://example.com/reference3.jpg",
+            "num_outputs": 1,
+            "prompt": "Combine styles from reference images",
+          },
+        }
+      `);
+    });
+
+    it('should warn when more than 8 images are provided for Flux-2 models', async () => {
+      prepareResponse();
+
+      const result = await flux2Model.doGenerate({
+        prompt: 'Too many images',
+        files: [
+          { type: 'url', url: 'https://example.com/img1.jpg' },
+          { type: 'url', url: 'https://example.com/img2.jpg' },
+          { type: 'url', url: 'https://example.com/img3.jpg' },
+          { type: 'url', url: 'https://example.com/img4.jpg' },
+          { type: 'url', url: 'https://example.com/img5.jpg' },
+          { type: 'url', url: 'https://example.com/img6.jpg' },
+          { type: 'url', url: 'https://example.com/img7.jpg' },
+          { type: 'url', url: 'https://example.com/img8.jpg' },
+          { type: 'url', url: 'https://example.com/img9.jpg' },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.warnings).toMatchInlineSnapshot(`
+        [
+          {
+            "message": "Flux-2 models support up to 8 input images. Additional images are ignored.",
+            "type": "other",
+          },
+        ]
+      `);
+
+      // Should only include 8 images
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody.input.input_image).toBe(
+        'https://example.com/img1.jpg',
+      );
+      expect(requestBody.input.input_image_8).toBe(
+        'https://example.com/img8.jpg',
+      );
+      expect(requestBody.input.input_image_9).toBeUndefined();
+    });
+
+    it('should warn and ignore mask for Flux-2 models', async () => {
+      prepareResponse();
+
+      const result = await flux2Model.doGenerate({
+        prompt: 'Edit with mask',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/input.jpg',
+          },
+        ],
+        mask: {
+          type: 'url',
+          url: 'https://example.com/mask.png',
+        },
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.warnings).toMatchInlineSnapshot(`
+        [
+          {
+            "message": "Flux-2 models do not support mask input. The mask will be ignored.",
+            "type": "other",
+          },
+        ]
+      `);
+
+      const requestBody = await server.calls[0].requestBodyJson;
+      expect(requestBody.input.mask).toBeUndefined();
+    });
+
+    it('should call correct URL for Flux-2 models', async () => {
+      prepareResponse();
+
+      await flux2Model.doGenerate({
+        prompt: 'Generate something',
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(server.calls[0].requestUrl).toStrictEqual(
+        'https://api.replicate.com/v1/models/black-forest-labs/flux-2-pro/predictions',
+      );
+    });
+  });
+});

package/src/replicate-image-model.ts

@@ -0,0 +1,268 @@
+import type { ImageModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import type { Resolvable } from '@ai-sdk/provider-utils';
+import {
+  combineHeaders,
+  convertImageModelFileToDataUri,
+  createBinaryResponseHandler,
+  createJsonResponseHandler,
+  FetchFunction,
+  getFromApi,
+  InferSchema,
+  lazySchema,
+  parseProviderOptions,
+  postJsonToApi,
+  resolve,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { replicateFailedResponseHandler } from './replicate-error';
+import { ReplicateImageModelId } from './replicate-image-settings';
+
+interface ReplicateImageModelConfig {
+  provider: string;
+  baseURL: string;
+  headers?: Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+// Flux-2 models support up to 8 input images with input_image, input_image_2, etc.
+const FLUX_2_MODEL_PATTERN = /^black-forest-labs\/flux-2-/;
+const MAX_FLUX_2_INPUT_IMAGES = 8;
+
+export class ReplicateImageModel implements ImageModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get maxImagesPerCall(): number {
+    // Flux-2 models support up to 8 input images
+    return this.isFlux2Model ? MAX_FLUX_2_INPUT_IMAGES : 1;
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  private get isFlux2Model(): boolean {
+    return FLUX_2_MODEL_PATTERN.test(this.modelId);
+  }
+
+  constructor(
+    readonly modelId: ReplicateImageModelId,
+    private readonly config: ReplicateImageModelConfig,
+  ) {}
+
+  async doGenerate({
+    prompt,
+    n,
+    aspectRatio,
+    size,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal,
+    files,
+    mask,
+  }: Parameters<ImageModelV3['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<ImageModelV3['doGenerate']>>
+  > {
+    const warnings: Array<SharedV3Warning> = [];
+
+    const [modelId, version] = this.modelId.split(':');
+
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    // Parse provider options
+    const replicateOptions = await parseProviderOptions({
+      provider: 'replicate',
+      providerOptions,
+      schema: replicateImageProviderOptionsSchema,
+    });
+
+    // Handle image input from files
+    let imageInputs: Record<string, string> = {};
+    if (files != null && files.length > 0) {
+      if (this.isFlux2Model) {
+        // Flux-2 models use input_image, input_image_2, input_image_3, etc.
+        for (
+          let i = 0;
+          i < Math.min(files.length, MAX_FLUX_2_INPUT_IMAGES);
+          i++
+        ) {
+          const key = i === 0 ? 'input_image' : `input_image_${i + 1}`;
+          imageInputs[key] = convertImageModelFileToDataUri(files[i]);
+        }
+        if (files.length > MAX_FLUX_2_INPUT_IMAGES) {
+          warnings.push({
+            type: 'other',
+            message: `Flux-2 models support up to ${MAX_FLUX_2_INPUT_IMAGES} input images. Additional images are ignored.`,
+          });
+        }
+      } else {
+        // Other models use single 'image' parameter
+        imageInputs = { image: convertImageModelFileToDataUri(files[0]) };
+        if (files.length > 1) {
+          warnings.push({
+            type: 'other',
+            message:
+              'This Replicate model only supports a single input image. Additional images are ignored.',
+          });
+        }
+      }
+    }
+
+    // Handle mask input (not supported by Flux-2 models)
+    let maskInput: string | undefined;
+    if (mask != null) {
+      if (this.isFlux2Model) {
+        warnings.push({
+          type: 'other',
+          message:
+            'Flux-2 models do not support mask input. The mask will be ignored.',
+        });
+      } else {
+        maskInput = convertImageModelFileToDataUri(mask);
+      }
+    }
+
+    // Extract maxWaitTimeInSeconds from provider options and prepare the rest for the request body
+    const { maxWaitTimeInSeconds, ...inputOptions } = replicateOptions ?? {};
+
+    // Build the prefer header based on maxWaitTimeInSeconds:
+    // - undefined/null: use default sync wait (prefer: wait)
+    // - positive number: use custom wait duration (prefer: wait=N)
+    const preferHeader: Record<string, string> =
+      maxWaitTimeInSeconds != null
+        ? { prefer: `wait=${maxWaitTimeInSeconds}` }
+        : { prefer: 'wait' };
+
+    const {
+      value: { output },
+      responseHeaders,
+    } = await postJsonToApi({
+      url:
+        // different endpoints for versioned vs unversioned models:
+        version != null
+          ? `${this.config.baseURL}/predictions`
+          : `${this.config.baseURL}/models/${modelId}/predictions`,
+
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        headers,
+        preferHeader,
+      ),
+
+      body: {
+        input: {
+          prompt,
+          aspect_ratio: aspectRatio,
+          size,
+          seed,
+          num_outputs: n,
+          ...imageInputs,
+          ...(maskInput != null ? { mask: maskInput } : {}),
+          ...inputOptions,
+        },
+        // for versioned models, include the version in the body:
+        ...(version != null ? { version } : {}),
+      },
+
+      successfulResponseHandler: createJsonResponseHandler(
+        replicateImageResponseSchema,
+      ),
+      failedResponseHandler: replicateFailedResponseHandler,
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    // download the images:
+    const outputArray = Array.isArray(output) ? output : [output];
+    const images = await Promise.all(
+      outputArray.map(async url => {
+        const { value: image } = await getFromApi({
+          url,
+          successfulResponseHandler: createBinaryResponseHandler(),
+          failedResponseHandler: replicateFailedResponseHandler,
+          abortSignal,
+          fetch: this.config.fetch,
+        });
+        return image;
+      }),
+    );
+
+    return {
+      images,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+      },
+    };
+  }
+}
+
+const replicateImageResponseSchema = z.object({
+  output: z.union([z.array(z.string()), z.string()]),
+});
+
+/**
+ * Provider options schema for Replicate image generation.
+ *
+ * Note: Different Replicate models support different parameters.
+ * This schema includes common parameters, but you can pass any
+ * model-specific parameters through the passthrough.
+ */
+export const replicateImageProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        /**
+         * Maximum time in seconds to wait for the prediction to complete in sync mode.
+         * By default, Replicate uses sync mode with a 60-second timeout.
+         *
+         * - When not specified: Uses default 60-second sync wait (`prefer: wait`)
+         * - When set to a positive number: Uses that duration (`prefer: wait=N`)
+         */
+        maxWaitTimeInSeconds: z.number().positive().nullish(),
+
+        /**
+         * Guidance scale for classifier-free guidance.
+         * Higher values make the output more closely match the prompt.
+         */
+        guidance_scale: z.number().nullish(),
+
+        /**
+         * Number of denoising steps. More steps = higher quality but slower.
+         */
+        num_inference_steps: z.number().nullish(),
+
+        /**
+         * Negative prompt to guide what to avoid in the generation.
+         */
+        negative_prompt: z.string().nullish(),
+
+        /**
+         * Output image format.
+         */
+        output_format: z.enum(['png', 'jpg', 'webp']).nullish(),
+
+        /**
+         * Output image quality (1-100). Only applies to jpg and webp.
+         */
+        output_quality: z.number().min(1).max(100).nullish(),
+
+        /**
+         * Strength of the transformation for img2img (0-1).
+         * Lower values keep more of the original image.
+         */
+        strength: z.number().min(0).max(1).nullish(),
+      })
+      .passthrough(),
+  ),
+);
+
+export type ReplicateImageProviderOptions = InferSchema<
+  typeof replicateImageProviderOptionsSchema
+>;

package/src/replicate-image-settings.ts

@@ -0,0 +1,36 @@
+export type ReplicateImageModelId =
+  // Text-to-image models
+  | 'black-forest-labs/flux-1.1-pro'
+  | 'black-forest-labs/flux-1.1-pro-ultra'
+  | 'black-forest-labs/flux-dev'
+  | 'black-forest-labs/flux-pro'
+  | 'black-forest-labs/flux-schnell'
+  | 'bytedance/sdxl-lightning-4step'
+  | 'fofr/aura-flow'
+  | 'fofr/latent-consistency-model'
+  | 'fofr/realvisxl-v3-multi-controlnet-lora'
+  | 'fofr/sdxl-emoji'
+  | 'fofr/sdxl-multi-controlnet-lora'
+  | 'ideogram-ai/ideogram-v2'
+  | 'ideogram-ai/ideogram-v2-turbo'
+  | 'lucataco/dreamshaper-xl-turbo'
+  | 'lucataco/open-dalle-v1.1'
+  | 'lucataco/realvisxl-v2.0'
+  | 'lucataco/realvisxl2-lcm'
+  | 'luma/photon'
+  | 'luma/photon-flash'
+  | 'nvidia/sana'
+  | 'playgroundai/playground-v2.5-1024px-aesthetic'
+  | 'recraft-ai/recraft-v3'
+  | 'recraft-ai/recraft-v3-svg'
+  | 'stability-ai/stable-diffusion-3.5-large'
+  | 'stability-ai/stable-diffusion-3.5-large-turbo'
+  | 'stability-ai/stable-diffusion-3.5-medium'
+  | 'tstramer/material-diffusion'
+  // Inpainting and image editing models
+  | 'black-forest-labs/flux-fill-pro'
+  | 'black-forest-labs/flux-fill-dev'
+  // Flux-2 models (support up to 8 reference images)
+  | 'black-forest-labs/flux-2-pro'
+  | 'black-forest-labs/flux-2-dev'
+  | (string & {});

package/src/replicate-provider.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { createReplicate } from './replicate-provider';
+import { ReplicateImageModel } from './replicate-image-model';
+
+describe('createReplicate', () => {
+  it('creates a provider with required settings', () => {
+    const provider = createReplicate({ apiToken: 'test-token' });
+    expect(provider.image).toBeDefined();
+  });
+
+  it('creates a provider with custom settings', () => {
+    const provider = createReplicate({
+      apiToken: 'test-token',
+      baseURL: 'https://custom.replicate.com',
+    });
+    expect(provider.image).toBeDefined();
+  });
+
+  it('creates an image model instance', () => {
+    const provider = createReplicate({ apiToken: 'test-token' });
+    const model = provider.image('black-forest-labs/flux-schnell');
+    expect(model).toBeInstanceOf(ReplicateImageModel);
+  });
+});

package/src/replicate-provider.ts

@@ -0,0 +1,99 @@
+import { NoSuchModelError, ProviderV3 } from '@ai-sdk/provider';
+import type { FetchFunction } from '@ai-sdk/provider-utils';
+import { loadApiKey, withUserAgentSuffix } from '@ai-sdk/provider-utils';
+import { ReplicateImageModel } from './replicate-image-model';
+import { ReplicateImageModelId } from './replicate-image-settings';
+import { VERSION } from './version';
+
+export interface ReplicateProviderSettings {
+  /**
+API token that is being send using the `Authorization` header.
+It defaults to the `REPLICATE_API_TOKEN` environment variable.
+   */
+  apiToken?: string;
+
+  /**
+Use a different URL prefix for API calls, e.g. to use proxy servers.
+The default prefix is `https://api.replicate.com/v1`.
+   */
+  baseURL?: 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;
+}
+
+export interface ReplicateProvider extends ProviderV3 {
+  /**
+   * Creates a Replicate image generation model.
+   */
+  image(modelId: ReplicateImageModelId): ReplicateImageModel;
+
+  /**
+   * Creates a Replicate image generation model.
+   */
+  imageModel(modelId: ReplicateImageModelId): ReplicateImageModel;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+/**
+ * Create a Replicate provider instance.
+ */
+export function createReplicate(
+  options: ReplicateProviderSettings = {},
+): ReplicateProvider {
+  const createImageModel = (modelId: ReplicateImageModelId) =>
+    new ReplicateImageModel(modelId, {
+      provider: 'replicate',
+      baseURL: options.baseURL ?? 'https://api.replicate.com/v1',
+      headers: withUserAgentSuffix(
+        {
+          Authorization: `Bearer ${loadApiKey({
+            apiKey: options.apiToken,
+            environmentVariableName: 'REPLICATE_API_TOKEN',
+            description: 'Replicate',
+          })}`,
+          ...options.headers,
+        },
+        `ai-sdk/replicate/${VERSION}`,
+      ),
+      fetch: options.fetch,
+    });
+
+  const embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'embeddingModel',
+    });
+  };
+
+  return {
+    specificationVersion: 'v3' as const,
+    image: createImageModel,
+    imageModel: createImageModel,
+    languageModel: (modelId: string) => {
+      throw new NoSuchModelError({
+        modelId,
+        modelType: 'languageModel',
+      });
+    },
+    embeddingModel,
+    textEmbeddingModel: embeddingModel,
+  };
+}
+
+/**
+ * Default Replicate provider instance.
+ */
+export const replicate = createReplicate();

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