Remove prepareInputs in favor of FileEncodingStrategy

This allows the user to determine if file uploads, falling back to
base64 should be used or just sticking to one approach.

The tests have been updated to validate the file upload payload and
to ensure the url is correctly passed to the prediction create method.

Author: aron

index.d.ts

@@ -108,6 +108,8 @@ declare module "replicate" {
 
   export type Training = Prediction;
 
+  export type FileEncodingStrategy = "default" | "upload" | "data-uri";
+
   export interface Page<T> {
     previous?: string;
     next?: string;
@@ -134,16 +136,14 @@ declare module "replicate" {
         input: Request | string,
         init?: RequestInit
       ) => Promise<Response>;
-      prepareInputs?: (
-        input: Record<string, any>
-      ) => Promise<Record<string, any>>;
+      fileEncodingStrategy?: FileEncodingStrategy;
     });
 
     auth: string;
     userAgent?: string;
     baseUrl?: string;
     fetch: (input: Request | string, init?: RequestInit) => Promise<Response>;
-    prepareInputs: (input: Record<string, any>) => Promise<Record<string, any>>;
+    fileEncodingStrategy: FileEncodingStrategy;
 
     run(
       identifier: `${string}/${string}` | `${string}/${string}:${string}`,
@@ -315,9 +315,4 @@ declare module "replicate" {
     current: number;
     total: number;
   } | null;
-
-  export function transformFileInputs(
-    inputs: Record<string, any>,
-    options: { fallbackToDataURI: boolean }
-  ): Promise<Record<string, any>>;
 }

index.js

@@ -48,23 +48,15 @@ class Replicate {
    * @param {string} options.userAgent - Identifier of your app
    * @param {string} [options.baseUrl] - Defaults to https://api.replicate.com/v1
    * @param {Function} [options.fetch] - Fetch function to use. Defaults to `globalThis.fetch`
-   * @param {Function} [options.prepareInput] - Function to prepare input data before sending it to the API.
+   * @param {"default" | "upload" | "data-uri"} [options.fileEncodingStrategy] - Determines the file encoding strategy to use
    */
   constructor(options = {}) {
     this.auth = options.auth || process.env.REPLICATE_API_TOKEN;
     this.userAgent =
       options.userAgent || `replicate-javascript/${packageJSON.version}`;
     this.baseUrl = options.baseUrl || "https://api.replicate.com/v1";
     this.fetch = options.fetch || globalThis.fetch;
-    this.prepareInputs =
-      options.prepareInputs ||
-      (async (inputs) => {
-        try {
-          return await transformFileInputsToReplicateFileURLs(this, inputs);
-        } catch (error) {
-          return await transformFileInputsToBase64EncodedDataURIs(inputs);
-        }
-      });
+    this.fileEncodingStrategy = options.fileEncodingStrategy ?? "default";
 
     this.accounts = {
       current: accounts.current.bind(this),

index.test.ts

@@ -228,7 +228,7 @@ describe("Replicate client", () => {
         ? [
             {
               type: "file",
-              value: new File(["hello world"], "hello.txt", {
+              value: new File(["hello world"], "file_hello.txt", {
                 type: "text/plain",
               }),
               expected: "data:text/plain;base64,aGVsbG8gd29ybGQ=",
@@ -249,16 +249,22 @@ describe("Replicate client", () => {
 
     test.each(fileTestCases)(
       "converts a $type input into a Replicate file URL",
-      async ({ value: data, expected }) => {
+      async ({ value: data, type }) => {
+        const mockedFetch = jest.spyOn(client, "fetch");
+
         nock(BASE_URL)
           .post("/files")
+          .matchHeader("Content-Type", "multipart/form-data")
           .reply(201, {
             urls: {
               get: "https://replicate.com/api/files/123",
             },
           })
-          .post("/predictions")
-          .reply(201, (uri: string, body: Record<string, any>) => {
+          .post(
+            "/predictions",
+            (body) => body.input.data === "https://replicate.com/api/files/123"
+          )
+          .reply(201, (_uri: string, body: Record<string, any>) => {
             return body;
           });
 
@@ -272,6 +278,20 @@ describe("Replicate client", () => {
           stream: true,
         });
 
+        expect(client.fetch).toHaveBeenCalledWith(
+          new URL("https://api.replicate.com/v1/files"),
+          {
+            method: "POST",
+            body: expect.any(FormData),
+            headers: expect.objectContaining({
+              "Content-Type": "multipart/form-data",
+            }),
+          }
+        );
+        const form = mockedFetch.mock.calls[0][1]?.body as FormData;
+        // @ts-ignore
+        expect(form?.get("content")?.name).toMatch(new RegExp(`^${type}_`));
+
         expect(prediction.input).toEqual({
           prompt: "Tell me a story",
           data: "https://replicate.com/api/files/123",

lib/deployments.js

@@ -1,3 +1,5 @@
+const { transformFileInputs } = require("./util");
+
 /**
  * Create a new prediction with a deployment
  *
@@ -28,7 +30,11 @@ async function createPrediction(deployment_owner, deployment_name, options) {
       method: "POST",
       data: {
         ...data,
-        input: await this.prepareInputs(input),
+        input: await transformFileInputs(
+          this,
+          input,
+          this.fileEncodingStrategy
+        ),
         stream,
       },
     }

lib/predictions.js

@@ -1,3 +1,5 @@
+const { transformFileInputs } = require("./util");
+
 /**
  * Create a new prediction
  *
@@ -28,7 +30,11 @@ async function createPrediction(options) {
       method: "POST",
       data: {
         ...data,
-        input: await this.prepareInputs(input),
+        input: await transformFileInputs(
+          this,
+          input,
+          this.fileEncodingStrategy
+        ),
         version,
         stream,
       },
@@ -38,7 +44,11 @@ async function createPrediction(options) {
       method: "POST",
       data: {
         ...data,
-        input: await this.prepareInputs(input),
+        input: await transformFileInputs(
+          this,
+          input,
+          this.fileEncodingStrategy
+        ),
         stream,
       },
     });

lib/util.js

@@ -150,12 +150,38 @@ async function withAutomaticRetries(request, options = {}) {
       }
       attempts += 1;
     }
-    /* eslint-enable no-await-in-loop */
   } while (attempts < maxRetries);
 
   return request();
 }
 
+/**
+ * Walks the inputs and, for any File or Blob, tries to upload it to Replicate
+ * and replaces the input with the URL of the uploaded file.
+ *
+ * @param {Replicate} client - The client used to upload the file
+ * @param {object} inputs - The inputs to transform
+ * @param {"default" | "upload" | "data-uri"} strategy - Whether to upload files to Replicate, encode as dataURIs or try both.
+ * @returns {object} - The transformed inputs
+ * @throws {ApiError} If the request to upload the file fails
+ */
+async function transformFileInputs(client, inputs, strategy) {
+  switch (strategy) {
+    case "data-uri":
+      return await transformFileInputsToBase64EncodedDataURIs(client, inputs);
+    case "upload":
+      return await transformFileInputsToReplicateFileURLs(client, inputs);
+    case "default":
+      try {
+        return await transformFileInputsToReplicateFileURLs(client, inputs);
+      } catch (error) {
+        return await transformFileInputsToBase64EncodedDataURIs(inputs);
+      }
+    default:
+      throw new Error(`Unexpected file upload strategy: ${strategy}`);
+  }
+}
+
 /**
  * Walks the inputs and, for any File or Blob, tries to upload it to Replicate
  * and replaces the input with the URL of the uploaded file.