@ai-sdk/prodia 2.0.0-beta.3 → 2.0.0-beta.5

package/src/prodia-image-model.ts

@@ -1,16 +1,23 @@
 import type { ImageModelV4, SharedV4Warning } from '@ai-sdk/provider';
-import type { InferSchema, Resolvable } from '@ai-sdk/provider-utils';
+import type { InferSchema } from '@ai-sdk/provider-utils';
 import {
   combineHeaders,
-  createJsonErrorResponseHandler,
-  type FetchFunction,
   lazySchema,
+  parseJSON,
   parseProviderOptions,
   postToApi,
   resolve,
   zodSchema,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
+import type { ProdiaModelConfig } from './prodia-api';
+import {
+  buildProdiaProviderMetadata,
+  parseMultipart,
+  prodiaFailedResponseHandler,
+  prodiaJobResultSchema,
+} from './prodia-api';
+import type { ProdiaJobResult } from './prodia-api';
 import type { ProdiaImageModelId } from './prodia-image-settings';
 
 export class ProdiaImageModel implements ImageModelV4 {
@@ -23,7 +30,7 @@ export class ProdiaImageModel implements ImageModelV4 {
 
   constructor(
     readonly modelId: ProdiaImageModelId,
-    private readonly config: ProdiaImageModelConfig,
+    private readonly config: ProdiaModelConfig,
   ) {}
 
   private async getArgs({
@@ -137,29 +144,7 @@ export class ProdiaImageModel implements ImageModelV4 {
       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,
-              }),
-              ...(jobResult.price?.dollars != null && {
-                dollars: jobResult.price.dollars,
-              }),
-            },
-          ],
+          images: [buildProdiaProviderMetadata(jobResult)],
         },
       },
       response: {
@@ -226,48 +211,6 @@ export type ProdiaImageModelOptions = InferSchema<
   typeof prodiaImageModelOptionsSchema
 >;
 
-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(),
-  price: z
-    .object({
-      product: z.string(),
-      dollars: z.number(),
-    })
-    .nullish(),
-});
-
-type ProdiaJobResult = z.infer<typeof prodiaJobResultSchema>;
-
 interface MultipartResult {
   jobResult: ProdiaJobResult;
   imageBytes: Uint8Array;
@@ -310,7 +253,10 @@ function createMultipartResponseHandler() {
 
       if (contentDisposition.includes('name="job"')) {
         const jsonStr = new TextDecoder().decode(part.body);
-        jobResult = prodiaJobResultSchema.parse(JSON.parse(jsonStr));
+        jobResult = await parseJSON({
+          text: jsonStr,
+          schema: zodSchema(prodiaJobResultSchema),
+        });
       } else if (contentDisposition.includes('name="output"')) {
         imageBytes = part.body;
       } else if (partContentType.startsWith('image/')) {
@@ -331,129 +277,3 @@ function createMultipartResponseHandler() {
     };
   };
 }
-
-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-language-model-settings.ts

@@ -0,0 +1,6 @@
+/**
+ * Prodia job types for language model (multimodal img2img).
+ */
+export type ProdiaLanguageModelId =
+  | 'inference.nano-banana.img2img.v2'
+  | (string & {});

package/src/prodia-language-model.ts

@@ -0,0 +1,395 @@
+import type {
+  LanguageModelV4,
+  LanguageModelV4CallOptions,
+  LanguageModelV4Content,
+  LanguageModelV4StreamPart,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
+import type { InferSchema } from '@ai-sdk/provider-utils';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  generateId,
+  lazySchema,
+  parseJSON,
+  parseProviderOptions,
+  postFormDataToApi,
+  resolve,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import type { ProdiaModelConfig } from './prodia-api';
+import {
+  buildProdiaProviderMetadata,
+  parseMultipart,
+  prodiaFailedResponseHandler,
+  prodiaJobResultSchema,
+} from './prodia-api';
+import type { ProdiaJobResult } from './prodia-api';
+import type { ProdiaLanguageModelId } from './prodia-language-model-settings';
+
+export class ProdiaLanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly supportedUrls = {};
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: ProdiaLanguageModelId,
+    private readonly config: ProdiaModelConfig,
+  ) {}
+
+  async doGenerate(options: LanguageModelV4CallOptions) {
+    const warnings: Array<SharedV4Warning> = [];
+
+    // Warn about unsupported LLM features
+    if (options.temperature !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'temperature' });
+    }
+    if (options.topP !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'topP' });
+    }
+    if (options.topK !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'topK' });
+    }
+    if (options.maxOutputTokens !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'maxOutputTokens' });
+    }
+    if (options.stopSequences !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'stopSequences' });
+    }
+    if (options.presencePenalty !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'presencePenalty' });
+    }
+    if (options.frequencyPenalty !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'frequencyPenalty' });
+    }
+    if (options.tools !== undefined && options.tools.length > 0) {
+      warnings.push({ type: 'unsupported', feature: 'tools' });
+    }
+    if (options.toolChoice !== undefined) {
+      warnings.push({ type: 'unsupported', feature: 'toolChoice' });
+    }
+    if (
+      options.responseFormat !== undefined &&
+      options.responseFormat.type !== 'text'
+    ) {
+      warnings.push({ type: 'unsupported', feature: 'responseFormat' });
+    }
+
+    const prodiaOptions = await parseProviderOptions({
+      provider: 'prodia',
+      providerOptions: options.providerOptions,
+      schema: prodiaLanguageModelOptionsSchema,
+    });
+
+    // Extract text prompt from messages
+    let prompt = '';
+    let systemMessage = '';
+    for (const message of options.prompt) {
+      if (message.role === 'system') {
+        systemMessage = message.content;
+      }
+    }
+    // Get text from the last user message
+    for (let i = options.prompt.length - 1; i >= 0; i--) {
+      const message = options.prompt[i];
+      if (message.role === 'user') {
+        for (const part of message.content) {
+          if (part.type === 'text') {
+            prompt += (prompt ? '\n' : '') + part.text;
+          }
+        }
+        break;
+      }
+    }
+    if (systemMessage) {
+      prompt = systemMessage + '\n' + prompt;
+    }
+
+    // Extract image from user messages
+    let imageBytes: Uint8Array | undefined;
+    let imageMediaType = 'image/png';
+    for (let i = options.prompt.length - 1; i >= 0; i--) {
+      const message = options.prompt[i];
+      if (message.role === 'user') {
+        for (const part of message.content) {
+          if (part.type === 'file' && part.mediaType.startsWith('image/')) {
+            if (part.data instanceof Uint8Array) {
+              imageBytes = part.data;
+            } else if (typeof part.data === 'string') {
+              // base64 encoded
+              imageBytes = convertBase64ToUint8Array(part.data);
+            } else if (part.data instanceof URL) {
+              const fetchFn = this.config.fetch ?? globalThis.fetch;
+              const response = await fetchFn(part.data.toString());
+              const arrayBuffer = await response.arrayBuffer();
+              imageBytes = new Uint8Array(arrayBuffer);
+            }
+            imageMediaType = part.mediaType;
+            break;
+          }
+        }
+        break;
+      }
+    }
+
+    const jobConfig: Record<string, unknown> = {
+      prompt,
+      include_messages: true,
+    };
+
+    if (prodiaOptions?.aspectRatio !== undefined) {
+      jobConfig.aspect_ratio = prodiaOptions.aspectRatio;
+    }
+
+    const body = {
+      type: this.modelId,
+      config: jobConfig,
+    };
+
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const combinedHeaders = combineHeaders(
+      await resolve(this.config.headers),
+      options.headers,
+    );
+
+    // Always use multipart form-data since img2img requires image input
+    const formData = new FormData();
+    formData.append(
+      'job',
+      new Blob([JSON.stringify(body)], { type: 'application/json' }),
+      'job.json',
+    );
+    if (imageBytes) {
+      const ext =
+        imageMediaType === 'image/png'
+          ? '.png'
+          : imageMediaType === 'image/jpeg'
+            ? '.jpg'
+            : imageMediaType === 'image/webp'
+              ? '.webp'
+              : '';
+      formData.append(
+        'input',
+        new Blob([imageBytes], { type: imageMediaType }),
+        'input' + ext,
+      );
+    }
+
+    const { value: multipartResult, responseHeaders } = await postFormDataToApi(
+      {
+        url: `${this.config.baseURL}/job?price=true`,
+        headers: {
+          ...combinedHeaders,
+          Accept: 'multipart/form-data',
+        },
+        formData,
+        failedResponseHandler: prodiaFailedResponseHandler,
+        successfulResponseHandler: createLanguageMultipartResponseHandler(),
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch,
+      },
+    );
+
+    const { jobResult, textContent, fileContent } = multipartResult;
+
+    const content: Array<LanguageModelV4Content> = [];
+    if (textContent !== undefined) {
+      content.push({ type: 'text', text: textContent });
+    }
+    for (const file of fileContent) {
+      content.push({
+        type: 'file',
+        mediaType: file.mediaType,
+        data: file.data,
+      });
+    }
+
+    return {
+      content,
+      finishReason: { unified: 'stop' as const, raw: undefined },
+      usage: {
+        inputTokens: {
+          total: undefined,
+          noCache: undefined,
+          cacheRead: undefined,
+          cacheWrite: undefined,
+        },
+        outputTokens: {
+          total: undefined,
+          text: undefined,
+          reasoning: undefined,
+        },
+      },
+      warnings,
+      providerMetadata: {
+        prodia: buildProdiaProviderMetadata(jobResult),
+      },
+      response: {
+        modelId: this.modelId,
+        timestamp: currentDate,
+        headers: responseHeaders,
+      },
+    };
+  }
+
+  async doStream(options: LanguageModelV4CallOptions) {
+    const result = await this.doGenerate(options);
+
+    const stream = new ReadableStream<LanguageModelV4StreamPart>({
+      start(controller) {
+        controller.enqueue({
+          type: 'stream-start',
+          warnings: result.warnings,
+        });
+
+        controller.enqueue({
+          type: 'response-metadata',
+          modelId: result.response?.modelId,
+          timestamp: result.response?.timestamp,
+        });
+
+        for (const part of result.content) {
+          if (part.type === 'text') {
+            const id = generateId();
+            controller.enqueue({ type: 'text-start', id });
+            controller.enqueue({
+              type: 'text-delta',
+              id,
+              delta: part.text,
+            });
+            controller.enqueue({ type: 'text-end', id });
+          } else if (part.type === 'file') {
+            controller.enqueue({
+              type: 'file',
+              mediaType: part.mediaType,
+              data: part.data,
+            });
+          }
+        }
+
+        controller.enqueue({
+          type: 'finish',
+          usage: result.usage,
+          finishReason: result.finishReason,
+          providerMetadata: result.providerMetadata,
+        });
+
+        controller.close();
+      },
+    });
+
+    return {
+      stream,
+      response: {
+        headers: result.response?.headers,
+      },
+    };
+  }
+}
+
+export const prodiaLanguageModelOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * Aspect ratio for the output image.
+       */
+      aspectRatio: z
+        .enum([
+          '1:1',
+          '2:3',
+          '3:2',
+          '4:5',
+          '5:4',
+          '4:7',
+          '7:4',
+          '9:16',
+          '16:9',
+          '9:21',
+          '21:9',
+        ])
+        .optional(),
+    }),
+  ),
+);
+
+export type ProdiaLanguageModelOptions = InferSchema<
+  typeof prodiaLanguageModelOptionsSchema
+>;
+
+interface LanguageMultipartResult {
+  jobResult: ProdiaJobResult;
+  textContent: string | undefined;
+  fileContent: Array<{ mediaType: string; data: Uint8Array }>;
+}
+
+function createLanguageMultipartResponseHandler() {
+  return async ({
+    response,
+  }: {
+    response: Response;
+  }): Promise<{
+    value: LanguageMultipartResult;
+    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 textContent: string | undefined;
+    const fileContent: Array<{ mediaType: string; data: Uint8Array }> = [];
+
+    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 = await parseJSON({
+          text: jsonStr,
+          schema: zodSchema(prodiaJobResultSchema),
+        });
+      } else if (contentDisposition.includes('name="output"')) {
+        if (
+          partContentType.startsWith('text/') ||
+          contentDisposition.includes('.txt')
+        ) {
+          textContent = new TextDecoder().decode(part.body);
+        } else if (partContentType.startsWith('image/')) {
+          fileContent.push({
+            mediaType: partContentType,
+            data: part.body,
+          });
+        }
+      }
+    }
+
+    if (!jobResult) {
+      throw new Error('Prodia multipart response missing job part');
+    }
+
+    return {
+      value: { jobResult, textContent, fileContent },
+      responseHeaders,
+    };
+  };
+}