@ai-sdk/deepinfra 2.0.15 → 2.0.17

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @ai-sdk/deepinfra
 
+## 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
+
+- Updated dependencies [78555ad]
+  - @ai-sdk/openai-compatible@2.0.16
+
 ## 2.0.15
 
 ### Patch Changes

package/dist/index.js

@@ -161,7 +161,7 @@ async function fileToBlob(file) {
 }
 
 // src/version.ts
-var VERSION = true ? "2.0.15" : "0.0.0-test";
+var VERSION = true ? "2.0.17" : "0.0.0-test";
 
 // src/deepinfra-provider.ts
 function createDeepInfra(options = {}) {

package/dist/index.mjs

@@ -150,7 +150,7 @@ async function fileToBlob(file) {
 }
 
 // src/version.ts
-var VERSION = true ? "2.0.15" : "0.0.0-test";
+var VERSION = true ? "2.0.17" : "0.0.0-test";
 
 // src/deepinfra-provider.ts
 function createDeepInfra(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/deepinfra",
-  "version": "2.0.15",
+  "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.15",
+    "@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/deepinfra-chat-options.ts

@@ -0,0 +1,69 @@
+// https://deepinfra.com/models/text-generation
+export type DeepInfraChatModelId =
+  | '01-ai/Yi-34B-Chat'
+  | 'Austism/chronos-hermes-13b-v2'
+  | 'bigcode/starcoder2-15b-instruct-v0.1'
+  | 'bigcode/starcoder2-15b'
+  | 'codellama/CodeLlama-34b-Instruct-hf'
+  | 'codellama/CodeLlama-70b-Instruct-hf'
+  | 'cognitivecomputations/dolphin-2.6-mixtral-8x7b'
+  | 'cognitivecomputations/dolphin-2.9.1-llama-3-70b'
+  | 'databricks/dbrx-instruct'
+  | 'deepinfra/airoboros-70b'
+  | 'deepseek-ai/DeepSeek-V3'
+  | 'google/codegemma-7b-it'
+  | 'google/gemma-1.1-7b-it'
+  | 'google/gemma-2-27b-it'
+  | 'google/gemma-2-9b-it'
+  | 'Gryphe/MythoMax-L2-13b-turbo'
+  | 'Gryphe/MythoMax-L2-13b'
+  | 'HuggingFaceH4/zephyr-orpo-141b-A35b-v0.1'
+  | 'KoboldAI/LLaMA2-13B-Tiefighter'
+  | 'lizpreciatior/lzlv_70b_fp16_hf'
+  | 'mattshumer/Reflection-Llama-3.1-70B'
+  | 'meta-llama/Llama-2-13b-chat-hf'
+  | 'meta-llama/Llama-2-70b-chat-hf'
+  | 'meta-llama/Llama-2-7b-chat-hf'
+  | 'meta-llama/Llama-3.2-11B-Vision-Instruct'
+  | 'meta-llama/Llama-3.2-1B-Instruct'
+  | 'meta-llama/Llama-3.2-3B-Instruct'
+  | 'meta-llama/Llama-3.2-90B-Vision-Instruct'
+  | 'meta-llama/Llama-3.3-70B-Instruct-Turbo'
+  | 'meta-llama/Llama-3.3-70B-Instruct'
+  | 'meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8'
+  | 'meta-llama/Llama-4-Scout-17B-16E-Instruct'
+  | 'meta-llama/Meta-Llama-3-70B-Instruct'
+  | 'meta-llama/Meta-Llama-3-8B-Instruct'
+  | 'meta-llama/Meta-Llama-3.1-405B-Instruct'
+  | 'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3.1-70B-Instruct'
+  | 'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3.1-8B-Instruct'
+  | 'microsoft/Phi-3-medium-4k-instruct'
+  | 'microsoft/WizardLM-2-7B'
+  | 'microsoft/WizardLM-2-8x22B'
+  | 'mistralai/Mistral-7B-Instruct-v0.1'
+  | 'mistralai/Mistral-7B-Instruct-v0.2'
+  | 'mistralai/Mistral-7B-Instruct-v0.3'
+  | 'mistralai/Mistral-Nemo-Instruct-2407'
+  | 'mistralai/Mixtral-8x22B-Instruct-v0.1'
+  | 'mistralai/Mixtral-8x22B-v0.1'
+  | 'mistralai/Mixtral-8x7B-Instruct-v0.1'
+  | 'NousResearch/Hermes-3-Llama-3.1-405B'
+  | 'nvidia/Llama-3.1-Nemotron-70B-Instruct'
+  | 'nvidia/Nemotron-4-340B-Instruct'
+  | 'openbmb/MiniCPM-Llama3-V-2_5'
+  | 'openchat/openchat_3.5'
+  | 'openchat/openchat-3.6-8b'
+  | 'Phind/Phind-CodeLlama-34B-v2'
+  | 'Qwen/Qwen2-72B-Instruct'
+  | 'Qwen/Qwen2-7B-Instruct'
+  | 'Qwen/Qwen2.5-72B-Instruct'
+  | 'Qwen/Qwen2.5-7B-Instruct'
+  | 'Qwen/Qwen2.5-Coder-32B-Instruct'
+  | 'Qwen/Qwen2.5-Coder-7B'
+  | 'Qwen/QwQ-32B-Preview'
+  | 'Sao10K/L3-70B-Euryale-v2.1'
+  | 'Sao10K/L3-8B-Lunaris-v1'
+  | 'Sao10K/L3.1-70B-Euryale-v2.2'
+  | (string & {});

package/src/deepinfra-completion-options.ts

@@ -0,0 +1,4 @@
+import { DeepInfraChatModelId } from './deepinfra-chat-options';
+
+// Use the same model IDs as chat
+export type DeepInfraCompletionModelId = DeepInfraChatModelId;

package/src/deepinfra-embedding-options.ts

@@ -0,0 +1,19 @@
+// https://deepinfra.com/models/embeddings
+export type DeepInfraEmbeddingModelId =
+  | 'BAAI/bge-base-en-v1.5'
+  | 'BAAI/bge-large-en-v1.5'
+  | 'BAAI/bge-m3'
+  | 'intfloat/e5-base-v2'
+  | 'intfloat/e5-large-v2'
+  | 'intfloat/multilingual-e5-large'
+  | 'sentence-transformers/all-MiniLM-L12-v2'
+  | 'sentence-transformers/all-MiniLM-L6-v2'
+  | 'sentence-transformers/all-mpnet-base-v2'
+  | 'sentence-transformers/clip-ViT-B-32'
+  | 'sentence-transformers/clip-ViT-B-32-multilingual-v1'
+  | 'sentence-transformers/multi-qa-mpnet-base-dot-v1'
+  | 'sentence-transformers/paraphrase-MiniLM-L6-v2'
+  | 'shibing624/text2vec-base-chinese'
+  | 'thenlper/gte-base'
+  | 'thenlper/gte-large'
+  | (string & {});

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

@@ -0,0 +1,431 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { describe, expect, it } from 'vitest';
+import { DeepInfraImageModel } from './deepinfra-image-model';
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+const prompt = 'A cute baby sea otter';
+
+function createBasicModel({
+  headers,
+  fetch,
+  currentDate,
+}: {
+  headers?: () => Record<string, string>;
+  fetch?: FetchFunction;
+  currentDate?: () => Date;
+} = {}) {
+  return new DeepInfraImageModel('stability-ai/sdxl', {
+    provider: 'deepinfra',
+    baseURL: 'https://api.example.com',
+    headers: headers ?? (() => ({ 'api-key': 'test-key' })),
+    fetch,
+    _internal: {
+      currentDate,
+    },
+  });
+}
+
+describe('DeepInfraImageModel', () => {
+  const testDate = new Date('2024-01-01T00:00:00Z');
+  const server = createTestServer({
+    'https://api.example.com/*': {
+      response: {
+        type: 'json-value',
+        body: {
+          images: ['data:image/png;base64,test-image-data'],
+        },
+      },
+    },
+  });
+
+  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: { deepinfra: { additional_param: 'value' } },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        prompt,
+        aspect_ratio: '16:9',
+        seed: 42,
+        num_images: 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: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(server.calls[0].requestMethod).toStrictEqual('POST');
+      expect(server.calls[0].requestUrl).toStrictEqual(
+        'https://api.example.com/stability-ai/sdxl',
+      );
+    });
+
+    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 API errors', async () => {
+      server.urls['https://api.example.com/*'].response = {
+        type: 'error',
+        status: 400,
+        body: JSON.stringify({
+          error: {
+            message: 'Bad Request',
+          },
+        }),
+      };
+
+      const model = createBasicModel();
+      await expect(
+        model.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          size: undefined,
+          aspectRatio: undefined,
+          seed: undefined,
+          providerOptions: {},
+        }),
+      ).rejects.toThrow('Bad Request');
+    });
+
+    it('should handle size parameter', async () => {
+      const model = createBasicModel();
+
+      await model.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,
+        num_images: 1,
+      });
+    });
+
+    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',
+      );
+    });
+
+    describe('response metadata', () => {
+      it('should include timestamp, headers and modelId in response', async () => {
+        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: 'stability-ai/sdxl',
+          headers: expect.any(Object),
+        });
+      });
+
+      it('should include response headers from API call', async () => {
+        server.urls['https://api.example.com/*'].response = {
+          type: 'json-value',
+          headers: {
+            'x-request-id': 'test-request-id',
+          },
+          body: {
+            images: ['data:image/png;base64,test-image-data'],
+          },
+        };
+
+        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': '52',
+          'x-request-id': 'test-request-id',
+          'content-type': 'application/json',
+        });
+      });
+    });
+  });
+
+  describe('constructor', () => {
+    it('should expose correct provider and model information', () => {
+      const model = createBasicModel();
+
+      expect(model.provider).toBe('deepinfra');
+      expect(model.modelId).toBe('stability-ai/sdxl');
+      expect(model.specificationVersion).toBe('v3');
+      expect(model.maxImagesPerCall).toBe(1);
+    });
+  });
+
+  describe('Image Editing', () => {
+    const editServer = createTestServer({
+      'https://edit.example.com/openai/images/edits': {
+        response: {
+          type: 'json-value',
+          body: {
+            created: 1234567890,
+            data: [{ b64_json: 'edited-image-base64' }],
+          },
+        },
+      },
+    });
+
+    // Model with baseURL that will resolve to edit endpoint
+    const editModel = new DeepInfraImageModel(
+      'black-forest-labs/FLUX.1-Kontext-dev',
+      {
+        provider: 'deepinfra',
+        baseURL: 'https://edit.example.com/inference',
+        headers: () => ({ 'api-key': 'test-key' }),
+      },
+    );
+
+    it('should send edit request with files', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]); // PNG magic bytes
+
+      const result = await editModel.doGenerate({
+        prompt: 'Turn the cat into a dog',
+        files: [
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: '1024x1024',
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.images).toStrictEqual(['edited-image-base64']);
+      expect(editServer.calls[0].requestUrl).toBe(
+        'https://edit.example.com/openai/images/edits',
+      );
+    });
+
+    it('should send edit request with files and mask', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]);
+      const maskData = new Uint8Array([255, 255, 255, 0]);
+
+      const result = await editModel.doGenerate({
+        prompt: 'Add a flamingo to the pool',
+        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.images).toStrictEqual(['edited-image-base64']);
+      expect(editServer.calls[0].requestUrl).toBe(
+        'https://edit.example.com/openai/images/edits',
+      );
+    });
+
+    it('should send edit request with multiple images', async () => {
+      const image1 = new Uint8Array([137, 80, 78, 71]);
+      const image2 = new Uint8Array([137, 80, 78, 71]);
+
+      const result = await editModel.doGenerate({
+        prompt: 'Combine these images',
+        files: [
+          {
+            type: 'file',
+            data: image1,
+            mediaType: 'image/png',
+          },
+          {
+            type: 'file',
+            data: image2,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.images).toStrictEqual(['edited-image-base64']);
+    });
+
+    it('should include response metadata for edit requests', async () => {
+      const testDate = new Date('2024-01-01T00:00:00Z');
+      const modelWithDate = new DeepInfraImageModel(
+        'black-forest-labs/FLUX.1-Kontext-dev',
+        {
+          provider: 'deepinfra',
+          baseURL: 'https://edit.example.com/inference',
+          headers: () => ({ 'api-key': 'test-key' }),
+          _internal: {
+            currentDate: () => testDate,
+          },
+        },
+      );
+
+      const imageData = new Uint8Array([137, 80, 78, 71]);
+
+      const result = await modelWithDate.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(result.response).toStrictEqual({
+        timestamp: testDate,
+        modelId: 'black-forest-labs/FLUX.1-Kontext-dev',
+        headers: expect.any(Object),
+      });
+    });
+
+    it('should pass provider options in edit request', async () => {
+      const imageData = new Uint8Array([137, 80, 78, 71]);
+
+      await editModel.doGenerate({
+        prompt: 'Edit with custom options',
+        files: [
+          {
+            type: 'file',
+            data: imageData,
+            mediaType: 'image/png',
+          },
+        ],
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {
+          deepinfra: {
+            guidance: 7.5,
+          },
+        },
+      });
+
+      // The request should have been made to the edit endpoint
+      expect(editServer.calls[0].requestUrl).toBe(
+        'https://edit.example.com/openai/images/edits',
+      );
+    });
+  });
+});

package/src/deepinfra-image-model.ts

@@ -0,0 +1,194 @@
+import {
+  ImageModelV3,
+  ImageModelV3File,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  convertToFormData,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  downloadBlob,
+  FetchFunction,
+  postFormDataToApi,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { DeepInfraImageModelId } from './deepinfra-image-settings';
+import { z } from 'zod/v4';
+
+interface DeepInfraImageModelConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string>;
+  fetch?: FetchFunction;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class DeepInfraImageModel implements ImageModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly maxImagesPerCall = 1;
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: DeepInfraImageModelId,
+    private config: DeepInfraImageModelConfig,
+  ) {}
+
+  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 currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    // Image editing mode - use OpenAI-compatible /images/edits endpoint
+    if (files != null && files.length > 0) {
+      const { value: response, responseHeaders } = await postFormDataToApi({
+        url: this.getEditUrl(),
+        headers: combineHeaders(this.config.headers(), headers),
+        formData: convertToFormData<DeepInfraFormDataInput>(
+          {
+            model: this.modelId,
+            prompt,
+            image: await Promise.all(files.map(file => fileToBlob(file))),
+            mask: mask != null ? await fileToBlob(mask) : undefined,
+            n,
+            size,
+            ...(providerOptions.deepinfra ?? {}),
+          },
+          { useArrayBrackets: false },
+        ),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: deepInfraEditErrorSchema,
+          errorToMessage: error => error.error?.message ?? 'Unknown error',
+        }),
+        successfulResponseHandler: createJsonResponseHandler(
+          deepInfraEditResponseSchema,
+        ),
+        abortSignal,
+        fetch: this.config.fetch,
+      });
+
+      return {
+        images: response.data.map(item => item.b64_json),
+        warnings,
+        response: {
+          timestamp: currentDate,
+          modelId: this.modelId,
+          headers: responseHeaders,
+        },
+      };
+    }
+
+    // Standard image generation mode
+    // Some deepinfra models support size while others support aspect ratio.
+    // Allow passing either and leave it up to the server to validate.
+    const splitSize = size?.split('x');
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: `${this.config.baseURL}/${this.modelId}`,
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        prompt,
+        num_images: n,
+        ...(aspectRatio && { aspect_ratio: aspectRatio }),
+        ...(splitSize && { width: splitSize[0], height: splitSize[1] }),
+        ...(seed != null && { seed }),
+        ...(providerOptions.deepinfra ?? {}),
+      },
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: deepInfraErrorSchema,
+        errorToMessage: error => error.detail.error,
+      }),
+      successfulResponseHandler: createJsonResponseHandler(
+        deepInfraImageResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      images: response.images.map(image =>
+        image.replace(/^data:image\/\w+;base64,/, ''),
+      ),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+      },
+    };
+  }
+
+  private getEditUrl(): string {
+    // Use OpenAI-compatible endpoint for image editing
+    // baseURL is typically https://api.deepinfra.com/v1/inference
+    // We need to use https://api.deepinfra.com/v1/openai/images/edits
+    const baseUrl = this.config.baseURL.replace('/inference', '/openai');
+    return `${baseUrl}/images/edits`;
+  }
+}
+
+export const deepInfraErrorSchema = z.object({
+  detail: z.object({
+    error: z.string(),
+  }),
+});
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+export const deepInfraImageResponseSchema = z.object({
+  images: z.array(z.string()),
+});
+
+// Schema for OpenAI-compatible image edit endpoint errors
+export const deepInfraEditErrorSchema = z.object({
+  error: z
+    .object({
+      message: z.string(),
+    })
+    .optional(),
+});
+
+// Schema for OpenAI-compatible image edit endpoint response
+export const deepInfraEditResponseSchema = z.object({
+  data: z.array(z.object({ b64_json: z.string() })),
+});
+
+type DeepInfraFormDataInput = {
+  model: string;
+  prompt: string | undefined;
+  image: Blob | Blob[];
+  mask?: Blob;
+  n: number;
+  size: `${number}x${number}` | undefined;
+  [key: string]: unknown;
+};
+
+async function fileToBlob(file: ImageModelV3File): Promise<Blob> {
+  if (file.type === 'url') {
+    return downloadBlob(file.url);
+  }
+
+  const data =
+    file.data instanceof Uint8Array
+      ? file.data
+      : convertBase64ToUint8Array(file.data);
+
+  return new Blob([data as BlobPart], { type: file.mediaType });
+}

package/src/deepinfra-image-settings.ts

@@ -0,0 +1,12 @@
+// https://deepinfra.com/models/text-to-image
+export type DeepInfraImageModelId =
+  | 'stabilityai/sd3.5'
+  | 'black-forest-labs/FLUX-1.1-pro'
+  | 'black-forest-labs/FLUX-1-schnell'
+  | 'black-forest-labs/FLUX-1-dev'
+  | 'black-forest-labs/FLUX-pro'
+  | 'black-forest-labs/FLUX.1-Kontext-dev'
+  | 'black-forest-labs/FLUX.1-Kontext-pro'
+  | 'stabilityai/sd3.5-medium'
+  | 'stabilityai/sdxl-turbo'
+  | (string & {});

package/src/deepinfra-provider.test.ts

@@ -0,0 +1,184 @@
+import { DeepInfraImageModel } from './deepinfra-image-model';
+import { createDeepInfra } from './deepinfra-provider';
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleCompletionLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+} from '@ai-sdk/openai-compatible';
+import { LanguageModelV3, EmbeddingModelV3 } from '@ai-sdk/provider';
+import { loadApiKey } from '@ai-sdk/provider-utils';
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
+
+// Add type assertion for the mocked class
+const OpenAICompatibleChatLanguageModelMock =
+  OpenAICompatibleChatLanguageModel as unknown as Mock;
+
+vi.mock('@ai-sdk/openai-compatible', () => ({
+  OpenAICompatibleChatLanguageModel: vi.fn(),
+  OpenAICompatibleCompletionLanguageModel: vi.fn(),
+  OpenAICompatibleEmbeddingModel: vi.fn(),
+}));
+
+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('./deepinfra-image-model', () => ({
+  DeepInfraImageModel: vi.fn(),
+}));
+
+describe('DeepInfraProvider', () => {
+  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('createDeepInfra', () => {
+    it('should create a DeepInfraProvider instance with default options', () => {
+      const provider = createDeepInfra();
+      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: 'DEEPINFRA_API_KEY',
+        description: "DeepInfra's API key",
+      });
+    });
+
+    it('should create a DeepInfraProvider instance with custom options', () => {
+      const options = {
+        apiKey: 'custom-key',
+        baseURL: 'https://custom.url',
+        headers: { 'Custom-Header': 'value' },
+      };
+      const provider = createDeepInfra(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: 'DEEPINFRA_API_KEY',
+        description: "DeepInfra's API key",
+      });
+    });
+
+    it('should return a chat model when called as a function', () => {
+      const provider = createDeepInfra();
+      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 = createDeepInfra();
+      const modelId = 'deepinfra-chat-model';
+
+      const model = provider.chatModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+      expect(OpenAICompatibleChatLanguageModelMock).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          provider: 'deepinfra.chat',
+        }),
+      );
+    });
+  });
+
+  describe('completionModel', () => {
+    it('should construct a completion model with correct configuration', () => {
+      const provider = createDeepInfra();
+      const modelId = 'deepinfra-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 = createDeepInfra();
+      const modelId = 'deepinfra-embedding-model';
+
+      const model = provider.embeddingModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleEmbeddingModel);
+    });
+  });
+
+  describe('image', () => {
+    it('should construct an image model with correct configuration', () => {
+      const provider = createDeepInfra();
+      const modelId = 'deepinfra-image-model';
+
+      const model = provider.image(modelId);
+
+      expect(model).toBeInstanceOf(DeepInfraImageModel);
+      expect(DeepInfraImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          provider: 'deepinfra.image',
+          baseURL: 'https://api.deepinfra.com/v1/inference',
+        }),
+      );
+    });
+
+    it('should use default settings when none provided', () => {
+      const provider = createDeepInfra();
+      const modelId = 'deepinfra-image-model';
+
+      const model = provider.image(modelId);
+
+      expect(model).toBeInstanceOf(DeepInfraImageModel);
+      expect(DeepInfraImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.any(Object),
+      );
+    });
+
+    it('should respect custom baseURL', () => {
+      const customBaseURL = 'https://custom.api.deepinfra.com';
+      const provider = createDeepInfra({ baseURL: customBaseURL });
+      const modelId = 'deepinfra-image-model';
+
+      const model = provider.image(modelId);
+
+      expect(DeepInfraImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          baseURL: `${customBaseURL}/inference`,
+        }),
+      );
+    });
+  });
+});

package/src/deepinfra-provider.ts

@@ -0,0 +1,161 @@
+import {
+  LanguageModelV3,
+  EmbeddingModelV3,
+  ProviderV3,
+  ImageModelV3,
+} from '@ai-sdk/provider';
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleCompletionLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+} from '@ai-sdk/openai-compatible';
+import {
+  FetchFunction,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { DeepInfraChatModelId } from './deepinfra-chat-options';
+import { DeepInfraEmbeddingModelId } from './deepinfra-embedding-options';
+import { DeepInfraCompletionModelId } from './deepinfra-completion-options';
+import { DeepInfraImageModelId } from './deepinfra-image-settings';
+import { DeepInfraImageModel } from './deepinfra-image-model';
+import { VERSION } from './version';
+
+export interface DeepInfraProviderSettings {
+  /**
+DeepInfra API key.
+*/
+  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 DeepInfraProvider extends ProviderV3 {
+  /**
+Creates a model for text generation.
+*/
+  (modelId: DeepInfraChatModelId): LanguageModelV3;
+
+  /**
+Creates a chat model for text generation.
+*/
+  chatModel(modelId: DeepInfraChatModelId): LanguageModelV3;
+
+  /**
+Creates a model for image generation.
+  */
+  image(modelId: DeepInfraImageModelId): ImageModelV3;
+
+  /**
+Creates a model for image generation.
+  */
+  imageModel(modelId: DeepInfraImageModelId): ImageModelV3;
+
+  /**
+Creates a chat model for text generation.
+*/
+  languageModel(modelId: DeepInfraChatModelId): LanguageModelV3;
+
+  /**
+Creates a completion model for text generation.
+*/
+  completionModel(modelId: DeepInfraCompletionModelId): LanguageModelV3;
+
+  /**
+Creates a embedding model for text generation.
+*/
+  embeddingModel(modelId: DeepInfraEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: DeepInfraEmbeddingModelId): EmbeddingModelV3;
+}
+
+export function createDeepInfra(
+  options: DeepInfraProviderSettings = {},
+): DeepInfraProvider {
+  const baseURL = withoutTrailingSlash(
+    options.baseURL ?? 'https://api.deepinfra.com/v1',
+  );
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'DEEPINFRA_API_KEY',
+          description: "DeepInfra's API key",
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/deepinfra/${VERSION}`,
+    );
+
+  interface CommonModelConfig {
+    provider: string;
+    url: ({ path }: { path: string }) => string;
+    headers: () => Record<string, string>;
+    fetch?: FetchFunction;
+  }
+
+  const getCommonModelConfig = (modelType: string): CommonModelConfig => ({
+    provider: `deepinfra.${modelType}`,
+    url: ({ path }) => `${baseURL}/openai${path}`,
+    headers: getHeaders,
+    fetch: options.fetch,
+  });
+
+  const createChatModel = (modelId: DeepInfraChatModelId) => {
+    return new OpenAICompatibleChatLanguageModel(
+      modelId,
+      getCommonModelConfig('chat'),
+    );
+  };
+
+  const createCompletionModel = (modelId: DeepInfraCompletionModelId) =>
+    new OpenAICompatibleCompletionLanguageModel(
+      modelId,
+      getCommonModelConfig('completion'),
+    );
+
+  const createEmbeddingModel = (modelId: DeepInfraEmbeddingModelId) =>
+    new OpenAICompatibleEmbeddingModel(
+      modelId,
+      getCommonModelConfig('embedding'),
+    );
+
+  const createImageModel = (modelId: DeepInfraImageModelId) =>
+    new DeepInfraImageModel(modelId, {
+      ...getCommonModelConfig('image'),
+      baseURL: baseURL
+        ? `${baseURL}/inference`
+        : 'https://api.deepinfra.com/v1/inference',
+    });
+
+  const provider = (modelId: DeepInfraChatModelId) => createChatModel(modelId);
+
+  provider.specificationVersion = 'v3' as const;
+  provider.completionModel = createCompletionModel;
+  provider.chatModel = createChatModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.languageModel = createChatModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+
+  return provider;
+}
+
+export const deepinfra = createDeepInfra();

package/src/index.ts

@@ -0,0 +1,7 @@
+export { createDeepInfra, deepinfra } from './deepinfra-provider';
+export type {
+  DeepInfraProvider,
+  DeepInfraProviderSettings,
+} from './deepinfra-provider';
+export type { OpenAICompatibleErrorData as DeepInfraErrorData } from '@ai-sdk/openai-compatible';
+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';