@ai-sdk/prodia 1.0.5 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @ai-sdk/prodia
 
+## 1.0.6
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+
 ## 1.0.5
 
 ### Patch Changes

package/dist/index.js

@@ -376,7 +376,7 @@ var prodiaFailedResponseHandler = (0, import_provider_utils.createJsonErrorRespo
 });
 
 // src/version.ts
-var VERSION = true ? "1.0.5" : "0.0.0-test";
+var VERSION = true ? "1.0.6" : "0.0.0-test";
 
 // src/prodia-provider.ts
 var defaultBaseURL = "https://inference.prodia.com/v2";

package/dist/index.mjs

@@ -362,7 +362,7 @@ var prodiaFailedResponseHandler = createJsonErrorResponseHandler({
 });
 
 // src/version.ts
-var VERSION = true ? "1.0.5" : "0.0.0-test";
+var VERSION = true ? "1.0.6" : "0.0.0-test";
 
 // src/prodia-provider.ts
 var defaultBaseURL = "https://inference.prodia.com/v2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/prodia",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "src",
     "CHANGELOG.md"
   ],
   "exports": {
@@ -27,7 +28,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/index.ts

@@ -0,0 +1,5 @@
+export type { ProdiaImageProviderOptions } from './prodia-image-model';
+export type { ProdiaImageModelId } from './prodia-image-settings';
+export type { ProdiaProvider, ProdiaProviderSettings } from './prodia-provider';
+export { createProdia, prodia } from './prodia-provider';
+export { VERSION } from './version';

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

@@ -0,0 +1,502 @@
+import type { FetchFunction } from '@ai-sdk/provider-utils';
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { describe, expect, it } from 'vitest';
+import { ProdiaImageModel } from './prodia-image-model';
+
+const prompt = 'A cute baby sea otter';
+
+function createBasicModel({
+  headers,
+  fetch,
+  currentDate,
+}: {
+  headers?: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  currentDate?: () => Date;
+} = {}) {
+  return new ProdiaImageModel('inference.flux-fast.schnell.txt2img.v2', {
+    provider: 'prodia.image',
+    baseURL: 'https://api.example.com/v2',
+    headers: headers ?? (() => ({ Authorization: 'Bearer test-key' })),
+    fetch,
+    _internal: {
+      currentDate,
+    },
+  });
+}
+
+function createMultipartResponse(
+  jobResult: Record<string, unknown>,
+  imageContent: string = 'test-binary-content',
+): { body: Buffer; contentType: string } {
+  const boundary = 'test-boundary-12345';
+  const jobJson = JSON.stringify(jobResult);
+  const imageBuffer = Buffer.from(imageContent);
+
+  const parts = [
+    `--${boundary}\r\n`,
+    'Content-Disposition: form-data; name="job"; filename="job.json"\r\n',
+    'Content-Type: application/json\r\n',
+    '\r\n',
+    jobJson,
+    '\r\n',
+    `--${boundary}\r\n`,
+    'Content-Disposition: form-data; name="output"; filename="output.png"\r\n',
+    'Content-Type: image/png\r\n',
+    '\r\n',
+  ];
+
+  const headerPart = Buffer.from(parts.join(''));
+  const endPart = Buffer.from(`\r\n--${boundary}--\r\n`);
+
+  const body = Buffer.concat([headerPart, imageBuffer, endPart]);
+
+  return {
+    body,
+    contentType: `multipart/form-data; boundary=${boundary}`,
+  };
+}
+
+const defaultJobResult = {
+  id: 'job-123',
+  created_at: '2025-01-01T00:00:00Z',
+  updated_at: '2025-01-01T00:00:05Z',
+  state: { current: 'completed' },
+  config: { prompt, seed: 42 },
+  metrics: { elapsed: 2.5, ips: 10.5 },
+};
+
+describe('ProdiaImageModel', () => {
+  const multipartResponse = createMultipartResponse(defaultJobResult);
+
+  const server = createTestServer({
+    'https://api.example.com/v2/job': {
+      response: {
+        type: 'binary',
+        body: multipartResponse.body,
+        headers: {
+          'content-type': multipartResponse.contentType,
+        },
+      },
+    },
+  });
+
+  describe('doGenerate', () => {
+    it('passes the correct parameters including providerOptions', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: 12345,
+        providerOptions: {
+          prodia: {
+            steps: 4,
+          },
+        },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        type: 'inference.flux-fast.schnell.txt2img.v2',
+        config: {
+          prompt,
+          seed: 12345,
+          steps: 4,
+        },
+      });
+    });
+
+    it('includes width and height when size is provided', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: '1024x768',
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        type: 'inference.flux-fast.schnell.txt2img.v2',
+        config: {
+          prompt,
+          width: 1024,
+          height: 768,
+        },
+      });
+    });
+
+    it('provider options width/height take precedence over size', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: '1024x768',
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {
+          prodia: {
+            width: 512,
+            height: 512,
+          },
+        },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        type: 'inference.flux-fast.schnell.txt2img.v2',
+        config: {
+          prompt,
+          width: 512,
+          height: 512,
+        },
+      });
+    });
+
+    it('includes style_preset when stylePreset is provided', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {
+          prodia: {
+            stylePreset: 'anime',
+          },
+        },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        type: 'inference.flux-fast.schnell.txt2img.v2',
+        config: {
+          prompt,
+          style_preset: 'anime',
+        },
+      });
+    });
+
+    it('includes loras when provided', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {
+          prodia: {
+            loras: ['prodia/lora/flux/anime@v1', 'prodia/lora/flux/realism@v1'],
+          },
+        },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        type: 'inference.flux-fast.schnell.txt2img.v2',
+        config: {
+          prompt,
+          loras: ['prodia/lora/flux/anime@v1', 'prodia/lora/flux/realism@v1'],
+        },
+      });
+    });
+
+    it('includes progressive when provided', async () => {
+      const model = createBasicModel();
+
+      await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {
+          prodia: {
+            progressive: true,
+          },
+        },
+      });
+
+      expect(await server.calls[0].requestBodyJson).toStrictEqual({
+        type: 'inference.flux-fast.schnell.txt2img.v2',
+        config: {
+          prompt,
+          progressive: true,
+        },
+      });
+    });
+
+    it('calls the correct endpoint', 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).toBe('POST');
+      expect(server.calls[0].requestUrl).toBe('https://api.example.com/v2/job');
+    });
+
+    it('sends Accept: multipart/form-data header', 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].requestHeaders.accept).toBe(
+        'multipart/form-data; image/png',
+      );
+    });
+
+    it('merges provider and request headers', async () => {
+      const modelWithHeaders = createBasicModel({
+        headers: () => ({
+          'Custom-Provider-Header': 'provider-header-value',
+          Authorization: 'Bearer test-key',
+        }),
+      });
+
+      await modelWithHeaders.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        providerOptions: {},
+        headers: {
+          'Custom-Request-Header': 'request-header-value',
+        },
+        size: undefined,
+        seed: undefined,
+        aspectRatio: undefined,
+      });
+
+      expect(server.calls[0].requestHeaders).toMatchObject({
+        'content-type': 'application/json',
+        'custom-provider-header': 'provider-header-value',
+        'custom-request-header': 'request-header-value',
+        authorization: 'Bearer test-key',
+        accept: 'multipart/form-data; image/png',
+      });
+    });
+
+    it('returns image bytes from multipart response', async () => {
+      const model = createBasicModel();
+
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        seed: undefined,
+        aspectRatio: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.images).toHaveLength(1);
+      const image = result.images[0];
+      expect(image).toBeInstanceOf(Uint8Array);
+      expect(Buffer.from(image as Uint8Array<ArrayBufferLike>).toString()).toBe(
+        'test-binary-content',
+      );
+    });
+
+    it('returns provider metadata from job result', async () => {
+      const model = createBasicModel();
+
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        seed: undefined,
+        aspectRatio: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.providerMetadata?.prodia).toStrictEqual({
+        images: [
+          {
+            jobId: 'job-123',
+            seed: 42,
+            elapsed: 2.5,
+            iterationsPerSecond: 10.5,
+            createdAt: '2025-01-01T00:00:00Z',
+            updatedAt: '2025-01-01T00:00:05Z',
+          },
+        ],
+      });
+    });
+
+    it('omits optional metadata fields when not present in job result', async () => {
+      const minimalJobResult = {
+        id: 'job-456',
+        state: { current: 'completed' },
+        config: { prompt },
+      };
+      const response = createMultipartResponse(minimalJobResult);
+
+      server.urls['https://api.example.com/v2/job'].response = {
+        type: 'binary',
+        body: response.body,
+        headers: {
+          'content-type': response.contentType,
+        },
+      };
+
+      const model = createBasicModel();
+
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        seed: undefined,
+        aspectRatio: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.providerMetadata?.prodia).toStrictEqual({
+        images: [
+          {
+            jobId: 'job-456',
+          },
+        ],
+      });
+    });
+
+    it('warns on invalid size format', async () => {
+      const model = createBasicModel();
+
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: 'invalid' as `${number}x${number}`,
+        seed: undefined,
+        aspectRatio: undefined,
+        providerOptions: {},
+      });
+
+      expect(result.warnings).toMatchInlineSnapshot(`
+        [
+          {
+            "details": "Invalid size format: invalid. Expected format: WIDTHxHEIGHT (e.g., 1024x1024)",
+            "feature": "size",
+            "type": "unsupported",
+          },
+        ]
+      `);
+    });
+
+    it('handles API errors', async () => {
+      server.urls['https://api.example.com/v2/job'].response = {
+        type: 'error',
+        status: 400,
+        body: JSON.stringify({
+          message: 'Invalid prompt',
+          detail: 'Prompt cannot be empty',
+        }),
+      };
+
+      const model = createBasicModel();
+
+      await expect(
+        model.doGenerate({
+          prompt,
+          files: undefined,
+          mask: undefined,
+          n: 1,
+          providerOptions: {},
+          size: undefined,
+          seed: undefined,
+          aspectRatio: undefined,
+        }),
+      ).rejects.toMatchObject({
+        message: 'Prompt cannot be empty',
+        statusCode: 400,
+        url: 'https://api.example.com/v2/job',
+      });
+    });
+
+    it('includes timestamp, headers, and modelId in response metadata', async () => {
+      const response = createMultipartResponse(defaultJobResult);
+      server.urls['https://api.example.com/v2/job'].response = {
+        type: 'binary',
+        body: response.body,
+        headers: {
+          'content-type': response.contentType,
+        },
+      };
+
+      const testDate = new Date('2025-01-01T00:00:00Z');
+      const model = createBasicModel({
+        currentDate: () => testDate,
+      });
+
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        providerOptions: {},
+        size: undefined,
+        seed: undefined,
+        aspectRatio: undefined,
+      });
+
+      expect(result.response).toStrictEqual({
+        timestamp: testDate,
+        modelId: 'inference.flux-fast.schnell.txt2img.v2',
+        headers: expect.any(Object),
+      });
+    });
+  });
+
+  describe('constructor', () => {
+    it('exposes correct provider and model information', () => {
+      const model = createBasicModel();
+
+      expect(model.provider).toBe('prodia.image');
+      expect(model.modelId).toBe('inference.flux-fast.schnell.txt2img.v2');
+      expect(model.specificationVersion).toBe('v3');
+      expect(model.maxImagesPerCall).toBe(1);
+    });
+  });
+});

package/src/prodia-image-model.ts

@@ -0,0 +1,450 @@
+import type { ImageModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import type { InferSchema, Resolvable } from '@ai-sdk/provider-utils';
+import {
+  combineHeaders,
+  createJsonErrorResponseHandler,
+  type FetchFunction,
+  lazySchema,
+  parseProviderOptions,
+  postToApi,
+  resolve,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import type { ProdiaImageModelId } from './prodia-image-settings';
+
+export class ProdiaImageModel implements ImageModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly maxImagesPerCall = 1;
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: ProdiaImageModelId,
+    private readonly config: ProdiaImageModelConfig,
+  ) {}
+
+  private async getArgs({
+    prompt,
+    size,
+    seed,
+    providerOptions,
+  }: Parameters<ImageModelV3['doGenerate']>[0]) {
+    const warnings: Array<SharedV3Warning> = [];
+
+    const prodiaOptions = await parseProviderOptions({
+      provider: 'prodia',
+      providerOptions,
+      schema: prodiaImageProviderOptionsSchema,
+    });
+
+    let width: number | undefined;
+    let height: number | undefined;
+    if (size) {
+      const [widthStr, heightStr] = size.split('x');
+      width = Number(widthStr);
+      height = Number(heightStr);
+      if (
+        !widthStr ||
+        !heightStr ||
+        !Number.isFinite(width) ||
+        !Number.isFinite(height)
+      ) {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'size',
+          details: `Invalid size format: ${size}. Expected format: WIDTHxHEIGHT (e.g., 1024x1024)`,
+        });
+        width = undefined;
+        height = undefined;
+      }
+    }
+
+    const jobConfig: Record<string, unknown> = {
+      prompt,
+    };
+
+    if (prodiaOptions?.width !== undefined) {
+      jobConfig.width = prodiaOptions.width;
+    } else if (width !== undefined) {
+      jobConfig.width = width;
+    }
+
+    if (prodiaOptions?.height !== undefined) {
+      jobConfig.height = prodiaOptions.height;
+    } else if (height !== undefined) {
+      jobConfig.height = height;
+    }
+
+    if (seed !== undefined) {
+      jobConfig.seed = seed;
+    }
+    if (prodiaOptions?.steps !== undefined) {
+      jobConfig.steps = prodiaOptions.steps;
+    }
+    if (prodiaOptions?.stylePreset !== undefined) {
+      jobConfig.style_preset = prodiaOptions.stylePreset;
+    }
+    if (prodiaOptions?.loras !== undefined && prodiaOptions.loras.length > 0) {
+      jobConfig.loras = prodiaOptions.loras;
+    }
+    if (prodiaOptions?.progressive !== undefined) {
+      jobConfig.progressive = prodiaOptions.progressive;
+    }
+
+    const body = {
+      type: this.modelId,
+      config: jobConfig,
+    };
+
+    return { body, warnings };
+  }
+
+  async doGenerate(
+    options: Parameters<ImageModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<ImageModelV3['doGenerate']>>> {
+    const { body, warnings } = await this.getArgs(options);
+
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const combinedHeaders = combineHeaders(
+      await resolve(this.config.headers),
+      options.headers,
+    );
+
+    const { value: multipartResult, responseHeaders } = await postToApi({
+      url: `${this.config.baseURL}/job`,
+      headers: {
+        ...combinedHeaders,
+        Accept: 'multipart/form-data; image/png',
+        'Content-Type': 'application/json',
+      },
+      body: {
+        content: JSON.stringify(body),
+        values: body,
+      },
+      failedResponseHandler: prodiaFailedResponseHandler,
+      successfulResponseHandler: createMultipartResponseHandler(),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const { jobResult, imageBytes } = multipartResult;
+
+    return {
+      images: [imageBytes],
+      warnings,
+      providerMetadata: {
+        prodia: {
+          images: [
+            {
+              jobId: jobResult.id,
+              ...(jobResult.config?.seed != null && {
+                seed: jobResult.config.seed,
+              }),
+              ...(jobResult.metrics?.elapsed != null && {
+                elapsed: jobResult.metrics.elapsed,
+              }),
+              ...(jobResult.metrics?.ips != null && {
+                iterationsPerSecond: jobResult.metrics.ips,
+              }),
+              ...(jobResult.created_at != null && {
+                createdAt: jobResult.created_at,
+              }),
+              ...(jobResult.updated_at != null && {
+                updatedAt: jobResult.updated_at,
+              }),
+            },
+          ],
+        },
+      },
+      response: {
+        modelId: this.modelId,
+        timestamp: currentDate,
+        headers: responseHeaders,
+      },
+    };
+  }
+}
+
+const stylePresets = [
+  '3d-model',
+  'analog-film',
+  'anime',
+  'cinematic',
+  'comic-book',
+  'digital-art',
+  'enhance',
+  'fantasy-art',
+  'isometric',
+  'line-art',
+  'low-poly',
+  'neon-punk',
+  'origami',
+  'photographic',
+  'pixel-art',
+  'texture',
+  'craft-clay',
+] as const;
+
+export const prodiaImageProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * Amount of computational iterations to run. More is typically higher quality.
+       */
+      steps: z.number().int().min(1).max(4).optional(),
+      /**
+       * Width of the output image in pixels.
+       */
+      width: z.number().int().min(256).max(1920).optional(),
+      /**
+       * Height of the output image in pixels.
+       */
+      height: z.number().int().min(256).max(1920).optional(),
+      /**
+       * Apply a visual theme to your output image.
+       */
+      stylePreset: z.enum(stylePresets).optional(),
+      /**
+       * Augment the output with a LoRa model.
+       */
+      loras: z.array(z.string()).max(3).optional(),
+      /**
+       * When using JPEG output, return a progressive JPEG.
+       */
+      progressive: z.boolean().optional(),
+    }),
+  ),
+);
+
+export type ProdiaImageProviderOptions = InferSchema<
+  typeof prodiaImageProviderOptionsSchema
+>;
+
+interface ProdiaImageModelConfig {
+  provider: string;
+  baseURL: string;
+  headers?: Resolvable<Record<string, string | undefined>>;
+  fetch?: FetchFunction;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+const prodiaJobResultSchema = z.object({
+  id: z.string(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+  expires_at: z.string().optional(),
+  state: z
+    .object({
+      current: z.string(),
+    })
+    .optional(),
+  config: z
+    .object({
+      seed: z.number().optional(),
+    })
+    .passthrough()
+    .optional(),
+  metrics: z
+    .object({
+      elapsed: z.number().optional(),
+      ips: z.number().optional(),
+    })
+    .optional(),
+});
+
+type ProdiaJobResult = z.infer<typeof prodiaJobResultSchema>;
+
+interface MultipartResult {
+  jobResult: ProdiaJobResult;
+  imageBytes: Uint8Array;
+}
+
+function createMultipartResponseHandler() {
+  return async ({
+    response,
+  }: {
+    response: Response;
+  }): Promise<{
+    value: MultipartResult;
+    responseHeaders: Record<string, string>;
+  }> => {
+    const contentType = response.headers.get('content-type') ?? '';
+    const responseHeaders: Record<string, string> = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+
+    const boundaryMatch = contentType.match(/boundary=([^\s;]+)/);
+    if (!boundaryMatch) {
+      throw new Error(
+        `Prodia response missing multipart boundary in content-type: ${contentType}`,
+      );
+    }
+    const boundary = boundaryMatch[1];
+
+    const arrayBuffer = await response.arrayBuffer();
+    const bytes = new Uint8Array(arrayBuffer);
+
+    const parts = parseMultipart(bytes, boundary);
+
+    let jobResult: ProdiaJobResult | undefined;
+    let imageBytes: Uint8Array | undefined;
+
+    for (const part of parts) {
+      const contentDisposition = part.headers['content-disposition'] ?? '';
+      const partContentType = part.headers['content-type'] ?? '';
+
+      if (contentDisposition.includes('name="job"')) {
+        const jsonStr = new TextDecoder().decode(part.body);
+        jobResult = prodiaJobResultSchema.parse(JSON.parse(jsonStr));
+      } else if (contentDisposition.includes('name="output"')) {
+        imageBytes = part.body;
+      } else if (partContentType.startsWith('image/')) {
+        imageBytes = part.body;
+      }
+    }
+
+    if (!jobResult) {
+      throw new Error('Prodia multipart response missing job part');
+    }
+    if (!imageBytes) {
+      throw new Error('Prodia multipart response missing output image');
+    }
+
+    return {
+      value: { jobResult, imageBytes },
+      responseHeaders,
+    };
+  };
+}
+
+interface MultipartPart {
+  headers: Record<string, string>;
+  body: Uint8Array;
+}
+
+function parseMultipart(data: Uint8Array, boundary: string): MultipartPart[] {
+  const parts: MultipartPart[] = [];
+  const boundaryBytes = new TextEncoder().encode(`--${boundary}`);
+  const endBoundaryBytes = new TextEncoder().encode(`--${boundary}--`);
+
+  const positions: number[] = [];
+  for (let i = 0; i <= data.length - boundaryBytes.length; i++) {
+    let match = true;
+    for (let j = 0; j < boundaryBytes.length; j++) {
+      if (data[i + j] !== boundaryBytes[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      positions.push(i);
+    }
+  }
+
+  for (let i = 0; i < positions.length - 1; i++) {
+    const start = positions[i] + boundaryBytes.length;
+    const end = positions[i + 1];
+
+    let isEndBoundary = true;
+    for (let j = 0; j < endBoundaryBytes.length && isEndBoundary; j++) {
+      if (data[positions[i] + j] !== endBoundaryBytes[j]) {
+        isEndBoundary = false;
+      }
+    }
+    if (
+      isEndBoundary &&
+      positions[i] + endBoundaryBytes.length <= data.length
+    ) {
+      continue;
+    }
+
+    let partStart = start;
+    if (data[partStart] === 0x0d && data[partStart + 1] === 0x0a) {
+      partStart += 2;
+    } else if (data[partStart] === 0x0a) {
+      partStart += 1;
+    }
+
+    let partEnd = end;
+    if (data[partEnd - 2] === 0x0d && data[partEnd - 1] === 0x0a) {
+      partEnd -= 2;
+    } else if (data[partEnd - 1] === 0x0a) {
+      partEnd -= 1;
+    }
+
+    const partData = data.slice(partStart, partEnd);
+
+    let headerEnd = -1;
+    for (let j = 0; j < partData.length - 3; j++) {
+      if (
+        partData[j] === 0x0d &&
+        partData[j + 1] === 0x0a &&
+        partData[j + 2] === 0x0d &&
+        partData[j + 3] === 0x0a
+      ) {
+        headerEnd = j;
+        break;
+      }
+      if (partData[j] === 0x0a && partData[j + 1] === 0x0a) {
+        headerEnd = j;
+        break;
+      }
+    }
+
+    if (headerEnd === -1) {
+      continue;
+    }
+
+    const headerBytes = partData.slice(0, headerEnd);
+    const headerStr = new TextDecoder().decode(headerBytes);
+    const headers: Record<string, string> = {};
+    for (const line of headerStr.split(/\r?\n/)) {
+      const colonIdx = line.indexOf(':');
+      if (colonIdx > 0) {
+        const key = line.slice(0, colonIdx).trim().toLowerCase();
+        const value = line.slice(colonIdx + 1).trim();
+        headers[key] = value;
+      }
+    }
+
+    let bodyStart = headerEnd + 2;
+    if (partData[headerEnd] === 0x0d) {
+      bodyStart = headerEnd + 4;
+    }
+    const body = partData.slice(bodyStart);
+
+    parts.push({ headers, body });
+  }
+
+  return parts;
+}
+
+const prodiaErrorSchema = z.object({
+  message: z.string().optional(),
+  detail: z.unknown().optional(),
+  error: z.string().optional(),
+});
+
+const prodiaFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: prodiaErrorSchema,
+  errorToMessage: error => {
+    const parsed = prodiaErrorSchema.safeParse(error);
+    if (!parsed.success) return 'Unknown Prodia error';
+    const { message, detail, error: errorField } = parsed.data;
+    if (typeof detail === 'string') return detail;
+    if (detail != null) {
+      try {
+        return JSON.stringify(detail);
+      } catch {
+        // ignore
+      }
+    }
+    return errorField ?? message ?? 'Unknown Prodia error';
+  },
+});

package/src/prodia-image-settings.ts

@@ -0,0 +1,7 @@
+/**
+ * Prodia job types for image generation.
+ */
+export type ProdiaImageModelId =
+  | 'inference.flux-fast.schnell.txt2img.v2'
+  | 'inference.flux.schnell.txt2img.v2'
+  | (string & {});

package/src/prodia-provider.test.ts

@@ -0,0 +1,123 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { describe, expect, it } from 'vitest';
+import { createProdia } from './prodia-provider';
+
+function createMultipartResponse(
+  jobResult: Record<string, unknown>,
+  imageContent: string = 'test-image',
+): { body: Buffer; contentType: string } {
+  const boundary = 'test-boundary-12345';
+  const jobJson = JSON.stringify(jobResult);
+  const imageBuffer = Buffer.from(imageContent);
+
+  const parts = [
+    `--${boundary}\r\n`,
+    'Content-Disposition: form-data; name="job"; filename="job.json"\r\n',
+    'Content-Type: application/json\r\n',
+    '\r\n',
+    jobJson,
+    '\r\n',
+    `--${boundary}\r\n`,
+    'Content-Disposition: form-data; name="output"; filename="output.png"\r\n',
+    'Content-Type: image/png\r\n',
+    '\r\n',
+  ];
+
+  const headerPart = Buffer.from(parts.join(''));
+  const endPart = Buffer.from(`\r\n--${boundary}--\r\n`);
+
+  const body = Buffer.concat([headerPart, imageBuffer, endPart]);
+
+  return {
+    body,
+    contentType: `multipart/form-data; boundary=${boundary}`,
+  };
+}
+
+const defaultJobResult = {
+  id: 'job-123',
+  state: { current: 'completed' },
+  config: { prompt: 'test' },
+};
+
+const multipartResponse = createMultipartResponse(defaultJobResult);
+
+const server = createTestServer({
+  'https://api.example.com/v2/job': {
+    response: {
+      type: 'binary',
+      body: multipartResponse.body,
+      headers: {
+        'content-type': multipartResponse.contentType,
+      },
+    },
+  },
+});
+
+describe('Prodia provider', () => {
+  it('creates image models via .image and .imageModel', () => {
+    const provider = createProdia();
+
+    const imageModel = provider.image('inference.flux-fast.schnell.txt2img.v2');
+    const imageModel2 = provider.imageModel(
+      'inference.flux.schnell.txt2img.v2',
+    );
+
+    expect(imageModel.provider).toBe('prodia.image');
+    expect(imageModel.modelId).toBe('inference.flux-fast.schnell.txt2img.v2');
+    expect(imageModel2.modelId).toBe('inference.flux.schnell.txt2img.v2');
+    expect(imageModel.specificationVersion).toBe('v3');
+  });
+
+  it('configures baseURL and headers correctly', async () => {
+    const provider = createProdia({
+      apiKey: 'test-api-key',
+      baseURL: 'https://api.example.com/v2',
+      headers: {
+        'x-extra-header': 'extra',
+      },
+    });
+
+    const model = provider.image('inference.flux-fast.schnell.txt2img.v2');
+
+    await model.doGenerate({
+      prompt: 'A serene mountain landscape at sunset',
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      seed: undefined,
+      aspectRatio: undefined,
+      providerOptions: {},
+    });
+
+    expect(server.calls[0].requestUrl).toBe('https://api.example.com/v2/job');
+    expect(server.calls[0].requestMethod).toBe('POST');
+    expect(server.calls[0].requestHeaders.authorization).toBe(
+      'Bearer test-api-key',
+    );
+    expect(server.calls[0].requestHeaders['x-extra-header']).toBe('extra');
+    expect(server.calls[0].requestHeaders.accept).toBe(
+      'multipart/form-data; image/png',
+    );
+    expect(await server.calls[0].requestBodyJson).toMatchObject({
+      type: 'inference.flux-fast.schnell.txt2img.v2',
+      config: {
+        prompt: 'A serene mountain landscape at sunset',
+      },
+    });
+
+    expect(server.calls[0].requestUserAgent).toContain('ai-sdk/prodia/');
+  });
+
+  it('throws NoSuchModelError for unsupported model types', () => {
+    const provider = createProdia();
+
+    expect(() => provider.languageModel('some-id')).toThrowError(
+      'No such languageModel',
+    );
+    expect(() => provider.embeddingModel('some-id')).toThrowError(
+      'No such embeddingModel',
+    );
+  });
+});

package/src/prodia-provider.ts

@@ -0,0 +1,107 @@
+import {
+  type ImageModelV3,
+  NoSuchModelError,
+  type ProviderV3,
+} from '@ai-sdk/provider';
+import type { FetchFunction } from '@ai-sdk/provider-utils';
+import {
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { ProdiaImageModel } from './prodia-image-model';
+import type { ProdiaImageModelId } from './prodia-image-settings';
+import { VERSION } from './version';
+
+export interface ProdiaProviderSettings {
+  /**
+   * Prodia API key. Default value is taken from the `PRODIA_TOKEN` environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * Base URL for the API calls. Defaults to `https://inference.prodia.com/v2`.
+   */
+  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 ProdiaProvider extends ProviderV3 {
+  /**
+   * Creates a model for image generation.
+   */
+  image(modelId: ProdiaImageModelId): ImageModelV3;
+
+  /**
+   * Creates a model for image generation.
+   */
+  imageModel(modelId: ProdiaImageModelId): ImageModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+const defaultBaseURL = 'https://inference.prodia.com/v2';
+
+export function createProdia(
+  options: ProdiaProviderSettings = {},
+): ProdiaProvider {
+  const baseURL = withoutTrailingSlash(options.baseURL ?? defaultBaseURL);
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'PRODIA_TOKEN',
+          description: 'Prodia',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/prodia/${VERSION}`,
+    );
+
+  const createImageModel = (modelId: ProdiaImageModelId) =>
+    new ProdiaImageModel(modelId, {
+      provider: 'prodia.image',
+      baseURL: baseURL ?? defaultBaseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'embeddingModel',
+    });
+  };
+
+  const languageModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'languageModel',
+    });
+  };
+
+  return {
+    specificationVersion: 'v3',
+    imageModel: createImageModel,
+    image: createImageModel,
+    languageModel,
+    embeddingModel,
+    textEmbeddingModel: embeddingModel,
+  };
+}
+
+export const prodia = createProdia();

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