@ai-sdk/fireworks 2.0.16 → 2.0.17

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @ai-sdk/fireworks
 
+## 2.0.17
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+- Updated dependencies [8dc54db]
+  - @ai-sdk/openai-compatible@2.0.17
+
 ## 2.0.16
 
 ### Patch Changes

package/dist/index.js

@@ -174,7 +174,7 @@ var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_v4 = require("zod/v4");
 
 // src/version.ts
-var VERSION = true ? "2.0.16" : "0.0.0-test";
+var VERSION = true ? "2.0.17" : "0.0.0-test";
 
 // src/fireworks-provider.ts
 var fireworksErrorSchema = import_v4.z.object({

package/dist/index.mjs

@@ -159,7 +159,7 @@ import {
 import { z } from "zod/v4";
 
 // src/version.ts
-var VERSION = true ? "2.0.16" : "0.0.0-test";
+var VERSION = true ? "2.0.17" : "0.0.0-test";
 
 // src/fireworks-provider.ts
 var fireworksErrorSchema = z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/fireworks",
-  "version": "2.0.16",
+  "version": "2.0.17",
   "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,7 +21,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/openai-compatible": "2.0.16",
+    "@ai-sdk/openai-compatible": "2.0.17",
     "@ai-sdk/provider": "3.0.4",
     "@ai-sdk/provider-utils": "4.0.8"
   },
@@ -29,7 +30,7 @@
     "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/fireworks-chat-options.ts

@@ -0,0 +1,20 @@
+// https://docs.fireworks.ai/docs/serverless-models#chat-models
+// Below is just a subset of the available models.
+export type FireworksChatModelId =
+  | 'accounts/fireworks/models/deepseek-v3'
+  | 'accounts/fireworks/models/llama-v3p3-70b-instruct'
+  | 'accounts/fireworks/models/llama-v3p2-3b-instruct'
+  | 'accounts/fireworks/models/llama-v3p1-405b-instruct'
+  | 'accounts/fireworks/models/llama-v3p1-8b-instruct'
+  | 'accounts/fireworks/models/mixtral-8x7b-instruct'
+  | 'accounts/fireworks/models/mixtral-8x22b-instruct'
+  | 'accounts/fireworks/models/mixtral-8x7b-instruct-hf'
+  | 'accounts/fireworks/models/qwen2p5-coder-32b-instruct'
+  | 'accounts/fireworks/models/qwen2p5-72b-instruct'
+  | 'accounts/fireworks/models/qwen-qwq-32b-preview'
+  | 'accounts/fireworks/models/qwen2-vl-72b-instruct'
+  | 'accounts/fireworks/models/llama-v3p2-11b-vision-instruct'
+  | 'accounts/fireworks/models/qwq-32b'
+  | 'accounts/fireworks/models/yi-large'
+  | 'accounts/fireworks/models/kimi-k2-instruct'
+  | (string & {});

package/src/fireworks-completion-options.ts

@@ -0,0 +1,5 @@
+// Below is just a subset of the available models.
+export type FireworksCompletionModelId =
+  | 'accounts/fireworks/models/llama-v3-8b-instruct'
+  | 'accounts/fireworks/models/llama-v2-34b-code'
+  | (string & {});

package/src/fireworks-embedding-options.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod/v4';
+
+// Below is just a subset of the available models.
+export type FireworksEmbeddingModelId =
+  | 'nomic-ai/nomic-embed-text-v1.5'
+  | (string & {});
+
+export const fireworksEmbeddingProviderOptions = z.object({});
+
+export type FireworksEmbeddingProviderOptions = z.infer<
+  typeof fireworksEmbeddingProviderOptions
+>;

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

@@ -0,0 +1,629 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { FireworksImageModel } from './fireworks-image-model';
+
+const prompt = 'A cute baby sea otter';
+
+function createBasicModel({
+  headers,
+  fetch,
+  currentDate,
+}: {
+  headers?: () => Record<string, string>;
+  fetch?: FetchFunction;
+  currentDate?: () => Date;
+} = {}) {
+  return new FireworksImageModel('accounts/fireworks/models/flux-1-dev-fp8', {
+    provider: 'fireworks',
+    baseURL: 'https://api.example.com',
+    headers: headers ?? (() => ({ 'api-key': 'test-key' })),
+    fetch,
+    _internal: {
+      currentDate,
+    },
+  });
+}
+
+function createSizeModel() {
+  return new FireworksImageModel(
+    'accounts/fireworks/models/playground-v2-5-1024px-aesthetic',
+    {
+      provider: 'fireworks',
+      baseURL: 'https://api.size-example.com',
+      headers: () => ({ 'api-key': 'test-key' }),
+    },
+  );
+}
+
+describe('FireworksImageModel', () => {
+  const server = createTestServer({
+    'https://api.example.com/*': {
+      response: {
+        type: 'binary',
+        body: Buffer.from('test-binary-content'),
+      },
+    },
+    'https://api.size-example.com/*': {
+      response: {
+        type: 'binary',
+        body: Buffer.from('test-binary-content'),
+      },
+    },
+  });
+
+  describe('doGenerate', () => {
+    it('should pass the correct parameters including aspect ratio and seed', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: '16:9',
+        seed: 42,
+        providerOptions: { fireworks: { additional_param: 'value' } },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        prompt,
+        aspect_ratio: '16:9',
+        seed: 42,
+        samples: 1,
+        additional_param: 'value',
+      });
+    });
+
+    it('should call the correct url', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: '16:9',
+        seed: 42,
+        providerOptions: { fireworks: { additional_param: 'value' } },
+      });
+
+      expect(server.calls[0].requestMethod).toStrictEqual('POST');
+      expect(server.calls[0].requestUrl).toStrictEqual(
+        'https://api.example.com/workflows/accounts/fireworks/models/flux-1-dev-fp8/text_to_image',
+      );
+    });
+
+    it('should pass headers', async () => {
+      const modelWithHeaders = createBasicModel({
+        headers: () => ({
+          'Custom-Provider-Header': 'provider-header-value',
+        }),
+      });
+
+      await modelWithHeaders.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({
+        'content-type': 'application/json',
+        'custom-provider-header': 'provider-header-value',
+        'custom-request-header': 'request-header-value',
+      });
+    });
+
+    it('should handle empty response body', async () => {
+      server.urls['https://api.example.com/*'].response = {
+        type: 'empty',
+      };
+
+      const model = createBasicModel();
+      await expect(
+        model.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          size: undefined,
+          aspectRatio: undefined,
+          seed: undefined,
+          providerOptions: {},
+        }),
+      ).rejects.toMatchObject({
+        message: 'Response body is empty',
+        statusCode: 200,
+        url: 'https://api.example.com/workflows/accounts/fireworks/models/flux-1-dev-fp8/text_to_image',
+        requestBodyValues: {
+          prompt: 'A cute baby sea otter',
+        },
+      });
+    });
+
+    it('should handle API errors', async () => {
+      server.urls['https://api.example.com/*'].response = {
+        type: 'error',
+        status: 400,
+        body: 'Bad Request',
+      };
+
+      const model = createBasicModel();
+      await expect(
+        model.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          size: undefined,
+          aspectRatio: undefined,
+          seed: undefined,
+          providerOptions: {},
+        }),
+      ).rejects.toMatchObject({
+        message: 'Bad Request',
+        statusCode: 400,
+        url: 'https://api.example.com/workflows/accounts/fireworks/models/flux-1-dev-fp8/text_to_image',
+        requestBodyValues: {
+          prompt: 'A cute baby sea otter',
+        },
+        responseBody: 'Bad Request',
+      });
+    });
+
+    it('should handle size parameter for supported models', async () => {
+      const sizeModel = createSizeModel();
+
+      await sizeModel.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: '1024x768',
+        aspectRatio: undefined,
+        seed: 42,
+        providerOptions: {},
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        prompt,
+        width: '1024',
+        height: '768',
+        seed: 42,
+        samples: 1,
+      });
+    });
+
+    describe('warnings', () => {
+      it('should return size warning on workflow model', async () => {
+        const model = createBasicModel();
+
+        const result1 = await model.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          size: '1024x1024',
+          aspectRatio: '1:1',
+          seed: 123,
+          providerOptions: {},
+        });
+
+        expect(result1.warnings).toMatchInlineSnapshot(`
+          [
+            {
+              "details": "This model does not support the \`size\` option. Use \`aspectRatio\` instead.",
+              "feature": "size",
+              "type": "unsupported",
+            },
+          ]
+        `);
+      });
+
+      it('should return aspectRatio warning on size-supporting model', async () => {
+        const sizeModel = createSizeModel();
+
+        const result2 = await sizeModel.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          size: '1024x1024',
+          aspectRatio: '1:1',
+          seed: 123,
+          providerOptions: {},
+        });
+
+        expect(result2.warnings).toMatchInlineSnapshot(`
+          [
+            {
+              "details": "This model does not support the \`aspectRatio\` option.",
+              "feature": "aspectRatio",
+              "type": "unsupported",
+            },
+          ]
+        `);
+      });
+    });
+
+    it('should respect the abort signal', async () => {
+      const model = createBasicModel();
+      const controller = new AbortController();
+
+      const generatePromise = model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+        abortSignal: controller.signal,
+      });
+
+      controller.abort();
+
+      await expect(generatePromise).rejects.toThrow(
+        'This operation was aborted',
+      );
+    });
+
+    it('should use custom fetch function when provided', async () => {
+      const mockFetch = vi.fn().mockResolvedValue(
+        new Response(Buffer.from('mock-image-data'), {
+          status: 200,
+        }),
+      );
+
+      const model = createBasicModel({
+        fetch: mockFetch,
+      });
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(mockFetch).toHaveBeenCalled();
+    });
+
+    it('should pass samples parameter to API', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 42,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(await server.calls[0].requestBodyJson).toHaveProperty(
+        'samples',
+        42,
+      );
+    });
+
+    describe('response metadata', () => {
+      it('should include timestamp, headers and modelId in response', async () => {
+        const testDate = new Date('2024-01-01T00:00:00Z');
+        const model = createBasicModel({
+          currentDate: () => testDate,
+        });
+
+        const result = await model.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          size: undefined,
+          aspectRatio: undefined,
+          seed: undefined,
+          providerOptions: {},
+        });
+
+        expect(result.response).toStrictEqual({
+          timestamp: testDate,
+          modelId: 'accounts/fireworks/models/flux-1-dev-fp8',
+          headers: expect.any(Object),
+        });
+      });
+
+      it('should include response headers from API call', async () => {
+        server.urls['https://api.example.com/*'].response = {
+          type: 'binary',
+          body: Buffer.from('test-binary-content'),
+          headers: {
+            'x-request-id': 'test-request-id',
+            'content-type': 'image/png',
+          },
+        };
+
+        const model = createBasicModel();
+        const result = await model.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          size: undefined,
+          aspectRatio: undefined,
+          seed: undefined,
+          providerOptions: {},
+        });
+
+        expect(result.response.headers).toStrictEqual({
+          'content-length': '19',
+          'x-request-id': 'test-request-id',
+          'content-type': 'image/png',
+        });
+      });
+    });
+  });
+
+  describe('constructor', () => {
+    it('should expose correct provider and model information', () => {
+      const model = createBasicModel();
+
+      expect(model.provider).toBe('fireworks');
+      expect(model.modelId).toBe('accounts/fireworks/models/flux-1-dev-fp8');
+      expect(model.specificationVersion).toBe('v3');
+      expect(model.maxImagesPerCall).toBe(1);
+    });
+  });
+
+  describe('Image Editing', () => {
+    const editServer = createTestServer({
+      'https://api.edit.example.com/*': {
+        response: {
+          type: 'binary',
+          body: Buffer.from('edited-image-data'),
+        },
+      },
+    });
+
+    function createKontextModel() {
+      return new FireworksImageModel(
+        'accounts/fireworks/models/flux-kontext-pro',
+        {
+          provider: 'fireworks',
+          baseURL: 'https://api.edit.example.com',
+          headers: () => ({ 'api-key': 'test-key' }),
+        },
+      );
+    }
+
+    it('should send edit request with files as data URI', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]); // PNG magic bytes
+
+      await createKontextModel().doGenerate({
+        prompt: 'Turn the cat into a dog',
+        files: [
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await editServer.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input_image": "data:image/png;base64,iVBORw==",
+          "prompt": "Turn the cat into a dog",
+          "samples": 1,
+        }
+      `);
+    });
+
+    it('should use correct URL for Kontext model (no text_to_image suffix)', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]);
+
+      await createKontextModel().doGenerate({
+        prompt: 'Edit this image',
+        files: [
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(editServer.calls[0].requestUrl).toBe(
+        'https://api.edit.example.com/workflows/accounts/fireworks/models/flux-kontext-pro',
+      );
+    });
+
+    it('should send edit request with URL-based file', async () => {
+      await createKontextModel().doGenerate({
+        prompt: 'Edit this image',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/input.png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await editServer.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input_image": "https://example.com/input.png",
+          "prompt": "Edit this image",
+          "samples": 1,
+        }
+      `);
+    });
+
+    it('should send edit request with base64 string data', async () => {
+      await createKontextModel().doGenerate({
+        prompt: 'Edit this image',
+        files: [
+          {
+            type: 'file',
+            data: 'iVBORw0KGgoAAAANSUhEUgAAAAE=',
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      const requestBody = await editServer.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "input_image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAE=",
+          "prompt": "Edit this image",
+          "samples": 1,
+        }
+      `);
+    });
+
+    it('should warn when multiple files are provided', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]);
+
+      const result = await createKontextModel().doGenerate({
+        prompt: 'Edit images',
+        files: [
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.warnings).toContainEqual({
+        type: 'other',
+        message:
+          'Fireworks only supports a single input image. Additional images are ignored.',
+      });
+    });
+
+    it('should warn when mask is provided', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]);
+      const maskData = new Uint8Array([255, 255, 255, 0]);
+
+      const result = await createKontextModel().doGenerate({
+        prompt: 'Edit with mask',
+        files: [
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: {
+          type: 'file',
+          data: maskData,
+          mediaType: 'image/png',
+        },
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.warnings).toContainEqual({
+        type: 'unsupported',
+        feature: 'mask',
+        details:
+          'Fireworks Kontext models do not support explicit masks. Use the prompt to describe the areas to edit.',
+      });
+    });
+
+    it('should pass provider options with edit request', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]);
+
+      await createKontextModel().doGenerate({
+        prompt: 'Edit with options',
+        files: [
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: '16:9',
+        seed: 42,
+        providerOptions: {
+          fireworks: {
+            output_format: 'jpeg',
+            safety_tolerance: 2,
+          },
+        },
+      });
+
+      const requestBody = await editServer.calls[0].requestBodyJson;
+      expect(requestBody).toMatchInlineSnapshot(`
+        {
+          "aspect_ratio": "16:9",
+          "input_image": "data:image/png;base64,iVBORw==",
+          "output_format": "jpeg",
+          "prompt": "Edit with options",
+          "safety_tolerance": 2,
+          "samples": 1,
+          "seed": 42,
+        }
+      `);
+    });
+  });
+});

package/src/fireworks-image-model.ts

@@ -0,0 +1,196 @@
+import { ImageModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertImageModelFileToDataUri,
+  createBinaryResponseHandler,
+  createStatusCodeErrorResponseHandler,
+  FetchFunction,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { FireworksImageModelId } from './fireworks-image-options';
+
+interface FireworksImageModelBackendConfig {
+  urlFormat: 'workflows' | 'workflows_edit' | 'image_generation';
+  supportsSize?: boolean;
+  supportsEditing?: boolean;
+}
+
+const modelToBackendConfig: Partial<
+  Record<FireworksImageModelId, FireworksImageModelBackendConfig>
+> = {
+  'accounts/fireworks/models/flux-1-dev-fp8': {
+    urlFormat: 'workflows',
+  },
+  'accounts/fireworks/models/flux-1-schnell-fp8': {
+    urlFormat: 'workflows',
+  },
+  'accounts/fireworks/models/flux-kontext-pro': {
+    urlFormat: 'workflows_edit',
+    supportsEditing: true,
+  },
+  'accounts/fireworks/models/flux-kontext-max': {
+    urlFormat: 'workflows_edit',
+    supportsEditing: true,
+  },
+  'accounts/fireworks/models/playground-v2-5-1024px-aesthetic': {
+    urlFormat: 'image_generation',
+    supportsSize: true,
+  },
+  'accounts/fireworks/models/japanese-stable-diffusion-xl': {
+    urlFormat: 'image_generation',
+    supportsSize: true,
+  },
+  'accounts/fireworks/models/playground-v2-1024px-aesthetic': {
+    urlFormat: 'image_generation',
+    supportsSize: true,
+  },
+  'accounts/fireworks/models/stable-diffusion-xl-1024-v1-0': {
+    urlFormat: 'image_generation',
+    supportsSize: true,
+  },
+  'accounts/fireworks/models/SSD-1B': {
+    urlFormat: 'image_generation',
+    supportsSize: true,
+  },
+};
+
+function getUrlForModel(
+  baseUrl: string,
+  modelId: FireworksImageModelId,
+  hasInputImage: boolean,
+): string {
+  const config = modelToBackendConfig[modelId];
+
+  switch (config?.urlFormat) {
+    case 'image_generation':
+      return `${baseUrl}/image_generation/${modelId}`;
+    case 'workflows_edit':
+      // Kontext models: use base URL for editing (no suffix)
+      return `${baseUrl}/workflows/${modelId}`;
+    case 'workflows':
+    default:
+      // Standard FLUX models: use text_to_image for generation,
+      // but if input_image provided, some models may support editing
+      if (hasInputImage && config?.supportsEditing) {
+        return `${baseUrl}/workflows/${modelId}`;
+      }
+      return `${baseUrl}/workflows/${modelId}/text_to_image`;
+  }
+}
+
+interface FireworksImageModelConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string>;
+  fetch?: FetchFunction;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class FireworksImageModel implements ImageModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly maxImagesPerCall = 1;
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: FireworksImageModelId,
+    private config: FireworksImageModelConfig,
+  ) {}
+
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal,
+    files,
+    mask,
+  }: Parameters<ImageModelV3['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<ImageModelV3['doGenerate']>>
+  > {
+    const warnings: Array<SharedV3Warning> = [];
+
+    const backendConfig = modelToBackendConfig[this.modelId];
+    if (!backendConfig?.supportsSize && size != null) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'size',
+        details:
+          'This model does not support the `size` option. Use `aspectRatio` instead.',
+      });
+    }
+
+    // Use supportsSize as a proxy for whether the model does not support
+    // aspectRatio. This invariant holds for the current set of models.
+    if (backendConfig?.supportsSize && aspectRatio != null) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'aspectRatio',
+        details: 'This model does not support the `aspectRatio` option.',
+      });
+    }
+
+    // Handle files for image editing
+    const hasInputImage = files != null && files.length > 0;
+    let inputImage: string | undefined;
+
+    if (hasInputImage) {
+      inputImage = convertImageModelFileToDataUri(files[0]);
+
+      if (files.length > 1) {
+        warnings.push({
+          type: 'other',
+          message:
+            'Fireworks only supports a single input image. Additional images are ignored.',
+        });
+      }
+    }
+
+    // Warn about mask - Fireworks Kontext models don't support explicit masks
+    if (mask != null) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'mask',
+        details:
+          'Fireworks Kontext models do not support explicit masks. Use the prompt to describe the areas to edit.',
+      });
+    }
+
+    const splitSize = size?.split('x');
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: getUrlForModel(this.config.baseURL, this.modelId, hasInputImage),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        prompt,
+        aspect_ratio: aspectRatio,
+        seed,
+        samples: n,
+        ...(inputImage && { input_image: inputImage }),
+        ...(splitSize && { width: splitSize[0], height: splitSize[1] }),
+        ...(providerOptions.fireworks ?? {}),
+      },
+      failedResponseHandler: createStatusCodeErrorResponseHandler(),
+      successfulResponseHandler: createBinaryResponseHandler(),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      images: [response],
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+      },
+    };
+  }
+}

package/src/fireworks-image-options.ts

@@ -0,0 +1,12 @@
+// https://fireworks.ai/models?type=image
+export type FireworksImageModelId =
+  | 'accounts/fireworks/models/flux-1-dev-fp8'
+  | 'accounts/fireworks/models/flux-1-schnell-fp8'
+  | 'accounts/fireworks/models/flux-kontext-pro'
+  | 'accounts/fireworks/models/flux-kontext-max'
+  | 'accounts/fireworks/models/playground-v2-5-1024px-aesthetic'
+  | 'accounts/fireworks/models/japanese-stable-diffusion-xl'
+  | 'accounts/fireworks/models/playground-v2-1024px-aesthetic'
+  | 'accounts/fireworks/models/SSD-1B'
+  | 'accounts/fireworks/models/stable-diffusion-xl-1024-v1-0'
+  | (string & {});

package/src/fireworks-provider.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
+import { createFireworks } from './fireworks-provider';
+import { LanguageModelV3, EmbeddingModelV3 } from '@ai-sdk/provider';
+import { loadApiKey } from '@ai-sdk/provider-utils';
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleCompletionLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+} from '@ai-sdk/openai-compatible';
+import { FireworksImageModel } from './fireworks-image-model';
+
+// Add type assertion for the mocked class
+const OpenAICompatibleChatLanguageModelMock =
+  OpenAICompatibleChatLanguageModel as unknown as Mock;
+
+vi.mock('@ai-sdk/openai-compatible', () => {
+  // Create mock constructor functions that behave like classes
+  const createMockConstructor = (providerName: string) => {
+    const mockConstructor = vi.fn().mockImplementation(function (
+      this: any,
+      modelId: string,
+      settings: any,
+    ) {
+      this.provider = providerName;
+      this.modelId = modelId;
+      this.settings = settings;
+    });
+    return mockConstructor;
+  };
+
+  return {
+    OpenAICompatibleChatLanguageModel: createMockConstructor('fireworks.chat'),
+    OpenAICompatibleCompletionLanguageModel: createMockConstructor(
+      'fireworks.completion',
+    ),
+    OpenAICompatibleEmbeddingModel: createMockConstructor(
+      'fireworks.embedding',
+    ),
+  };
+});
+
+vi.mock('@ai-sdk/provider-utils', async () => {
+  const actual = await vi.importActual('@ai-sdk/provider-utils');
+  return {
+    ...actual,
+    loadApiKey: vi.fn().mockReturnValue('mock-api-key'),
+    withoutTrailingSlash: vi.fn(url => url),
+  };
+});
+
+vi.mock('./fireworks-image-model', () => ({
+  FireworksImageModel: vi.fn(),
+}));
+
+describe('FireworksProvider', () => {
+  let mockLanguageModel: LanguageModelV3;
+  let mockEmbeddingModel: EmbeddingModelV3;
+
+  beforeEach(() => {
+    // Mock implementations of models
+    mockLanguageModel = {
+      // Add any required methods for LanguageModelV3
+    } as LanguageModelV3;
+    mockEmbeddingModel = {
+      // Add any required methods for EmbeddingModelV3
+    } as EmbeddingModelV3;
+
+    // Reset mocks
+    vi.clearAllMocks();
+  });
+
+  describe('createFireworks', () => {
+    it('should create a FireworksProvider instance with default options', () => {
+      const provider = createFireworks();
+      const model = provider('model-id');
+
+      // Use the mocked version
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      config.headers();
+
+      expect(loadApiKey).toHaveBeenCalledWith({
+        apiKey: undefined,
+        environmentVariableName: 'FIREWORKS_API_KEY',
+        description: 'Fireworks API key',
+      });
+    });
+
+    it('should create a FireworksProvider instance with custom options', () => {
+      const options = {
+        apiKey: 'custom-key',
+        baseURL: 'https://custom.url',
+        headers: { 'Custom-Header': 'value' },
+      };
+      const provider = createFireworks(options);
+      const model = provider('model-id');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      config.headers();
+
+      expect(loadApiKey).toHaveBeenCalledWith({
+        apiKey: 'custom-key',
+        environmentVariableName: 'FIREWORKS_API_KEY',
+        description: 'Fireworks API key',
+      });
+    });
+
+    it('should return a chat model when called as a function', () => {
+      const provider = createFireworks();
+      const modelId = 'foo-model-id';
+
+      const model = provider(modelId);
+      expect(model).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+  });
+
+  describe('chatModel', () => {
+    it('should construct a chat model with correct configuration', () => {
+      const provider = createFireworks();
+      const modelId = 'fireworks-chat-model';
+
+      const model = provider.chatModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+  });
+
+  describe('completionModel', () => {
+    it('should construct a completion model with correct configuration', () => {
+      const provider = createFireworks();
+      const modelId = 'fireworks-completion-model';
+
+      const model = provider.completionModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleCompletionLanguageModel);
+    });
+  });
+
+  describe('embeddingModel', () => {
+    it('should construct a text embedding model with correct configuration', () => {
+      const provider = createFireworks();
+      const modelId = 'fireworks-embedding-model';
+
+      const model = provider.embeddingModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleEmbeddingModel);
+    });
+  });
+
+  describe('image', () => {
+    it('should construct an image model with correct configuration', () => {
+      const provider = createFireworks();
+      const modelId = 'accounts/fireworks/models/flux-1-dev-fp8';
+
+      const model = provider.image(modelId);
+
+      expect(model).toBeInstanceOf(FireworksImageModel);
+      expect(FireworksImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          provider: 'fireworks.image',
+          baseURL: 'https://api.fireworks.ai/inference/v1',
+        }),
+      );
+    });
+
+    it('should use default settings when none provided', () => {
+      const provider = createFireworks();
+      const modelId = 'accounts/fireworks/models/flux-1-dev-fp8';
+
+      const model = provider.image(modelId);
+
+      expect(model).toBeInstanceOf(FireworksImageModel);
+      expect(FireworksImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.any(Object),
+      );
+    });
+
+    it('should respect custom baseURL', () => {
+      const customBaseURL = 'https://custom.api.fireworks.ai';
+      const provider = createFireworks({ baseURL: customBaseURL });
+      const modelId = 'accounts/fireworks/models/flux-1-dev-fp8';
+
+      provider.image(modelId);
+
+      expect(FireworksImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          baseURL: customBaseURL,
+        }),
+      );
+    });
+  });
+});

package/src/fireworks-provider.ts

@@ -0,0 +1,172 @@
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleCompletionLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+  ProviderErrorStructure,
+} from '@ai-sdk/openai-compatible';
+import {
+  EmbeddingModelV3,
+  ImageModelV3,
+  LanguageModelV3,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { FireworksChatModelId } from './fireworks-chat-options';
+import { FireworksCompletionModelId } from './fireworks-completion-options';
+import { FireworksEmbeddingModelId } from './fireworks-embedding-options';
+import { FireworksImageModel } from './fireworks-image-model';
+import { FireworksImageModelId } from './fireworks-image-options';
+import { VERSION } from './version';
+
+export type FireworksErrorData = z.infer<typeof fireworksErrorSchema>;
+
+const fireworksErrorSchema = z.object({
+  error: z.string(),
+});
+
+const fireworksErrorStructure: ProviderErrorStructure<FireworksErrorData> = {
+  errorSchema: fireworksErrorSchema,
+  errorToMessage: data => data.error,
+};
+
+export interface FireworksProviderSettings {
+  /**
+Fireworks API key. Default value is taken from the `FIREWORKS_API_KEY`
+environment variable.
+*/
+  apiKey?: string;
+  /**
+Base URL for the API calls.
+*/
+  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 FireworksProvider extends ProviderV3 {
+  /**
+Creates a model for text generation.
+*/
+  (modelId: FireworksChatModelId): LanguageModelV3;
+
+  /**
+Creates a chat model for text generation.
+*/
+  chatModel(modelId: FireworksChatModelId): LanguageModelV3;
+
+  /**
+Creates a completion model for text generation.
+*/
+  completionModel(modelId: FireworksCompletionModelId): LanguageModelV3;
+
+  /**
+Creates a chat model for text generation.
+*/
+  languageModel(modelId: FireworksChatModelId): LanguageModelV3;
+
+  /**
+Creates a text embedding model for text generation.
+*/
+  embeddingModel(modelId: FireworksEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: FireworksEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+Creates a model for image generation.
+*/
+  image(modelId: FireworksImageModelId): ImageModelV3;
+
+  /**
+Creates a model for image generation.
+*/
+  imageModel(modelId: FireworksImageModelId): ImageModelV3;
+}
+
+const defaultBaseURL = 'https://api.fireworks.ai/inference/v1';
+
+export function createFireworks(
+  options: FireworksProviderSettings = {},
+): FireworksProvider {
+  const baseURL = withoutTrailingSlash(options.baseURL ?? defaultBaseURL);
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'FIREWORKS_API_KEY',
+          description: 'Fireworks API key',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/fireworks/${VERSION}`,
+    );
+
+  interface CommonModelConfig {
+    provider: string;
+    url: ({ path }: { path: string }) => string;
+    headers: () => Record<string, string>;
+    fetch?: FetchFunction;
+  }
+
+  const getCommonModelConfig = (modelType: string): CommonModelConfig => ({
+    provider: `fireworks.${modelType}`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    fetch: options.fetch,
+  });
+
+  const createChatModel = (modelId: FireworksChatModelId) => {
+    return new OpenAICompatibleChatLanguageModel(modelId, {
+      ...getCommonModelConfig('chat'),
+      errorStructure: fireworksErrorStructure,
+    });
+  };
+
+  const createCompletionModel = (modelId: FireworksCompletionModelId) =>
+    new OpenAICompatibleCompletionLanguageModel(modelId, {
+      ...getCommonModelConfig('completion'),
+      errorStructure: fireworksErrorStructure,
+    });
+
+  const createEmbeddingModel = (modelId: FireworksEmbeddingModelId) =>
+    new OpenAICompatibleEmbeddingModel(modelId, {
+      ...getCommonModelConfig('embedding'),
+      errorStructure: fireworksErrorStructure,
+    });
+
+  const createImageModel = (modelId: FireworksImageModelId) =>
+    new FireworksImageModel(modelId, {
+      ...getCommonModelConfig('image'),
+      baseURL: baseURL ?? defaultBaseURL,
+    });
+
+  const provider = (modelId: FireworksChatModelId) => createChatModel(modelId);
+
+  provider.specificationVersion = 'v3' as const;
+  provider.completionModel = createCompletionModel;
+  provider.chatModel = createChatModel;
+  provider.languageModel = createChatModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  return provider;
+}
+
+export const fireworks = createFireworks();

package/src/index.ts

@@ -0,0 +1,13 @@
+export type {
+  FireworksEmbeddingModelId,
+  FireworksEmbeddingProviderOptions,
+} from './fireworks-embedding-options';
+export { FireworksImageModel } from './fireworks-image-model';
+export type { FireworksImageModelId } from './fireworks-image-options';
+export { fireworks, createFireworks } from './fireworks-provider';
+export type {
+  FireworksProvider,
+  FireworksProviderSettings,
+  FireworksErrorData,
+} from './fireworks-provider';
+export { VERSION } from './version';

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