@aeye/models 0.1.1 → 0.3.0

package/src/transformers/replicate/black-forest-labs-flux-2-pro.ts

@@ -0,0 +1,67 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number;
+    width?: number | null;
+    height?: number | null;
+    prompt: string;
+    resolution?: Schemas["resolution"];
+    aspect_ratio?: Schemas["aspect_ratio"];
+    input_images?: string[];
+    output_format?: Schemas["output_format"];
+    output_quality?: number;
+    safety_tolerance?: number;
+  };
+  Output: string;
+  resolution: "match_input_image" | "0.5 MP" | "1 MP" | "2 MP" | "4 MP";
+  aspect_ratio: "match_input_image" | "custom" | "1:1" | "16:9" | "3:2" | "2:3" | "4:5" | "5:4" | "9:16" | "3:4" | "4:3";
+  output_format: "webp" | "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-2-pro": (() => {
+    const transformer: ReplicateTransformer = {
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => {
+          const input: Schemas["Input"] = {
+            prompt: request.prompt,
+            seed: request.seed,
+            ...request.extra,
+          };
+
+          if (request.size) {
+            if (['1:1', '16:9', '3:2', '2:3', '4:5', '5:4', '9:16', '3:4', '4:3', 'match_input_image'].includes(request.size)) {
+              input.aspect_ratio = request.size as Schemas["aspect_ratio"];
+            } else if (request.size.includes('x')) {
+              const [width, height] = request.size.split('x').map(Number);
+              if (!isNaN(width) && !isNaN(height)) {
+                input.width = width;
+                input.height = height;
+                input.aspect_ratio = 'custom';
+              }
+            }
+          }
+
+          return input;
+        },
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          input_images: [await toURL(request.image)],
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+    };
+    return transformer;
+  })()
+}

package/src/transformers/replicate/black-forest-labs-flux-canny-dev.ts

@@ -0,0 +1,51 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number;
+    prompt: string;
+    guidance?: number;
+    megapixels?: Schemas["megapixels"];
+    num_outputs?: number;
+    control_image: string;
+    output_format?: Schemas["output_format"];
+    output_quality?: number;
+    num_inference_steps?: number;
+    disable_safety_checker?: boolean;
+  };
+  Output: string[];
+  megapixels: "1" | "0.25" | "match_input";
+  output_format: "webp" | "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-canny-dev": (() => {
+    const transformer: ReplicateTransformer = { 
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({ 
+          prompt: request.prompt,
+          num_outputs: request.n,
+          seed: request.seed,
+          ...request.extra,
+        } as Schemas["Input"]),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: response.map(url => ({ url })),
+        }),
+      },
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          control_image: await toURL(request.image),
+          num_outputs: request.n,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: response.map(url => ({ url })),
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-canny-pro.ts

@@ -0,0 +1,47 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number | null;
+    steps?: number;
+    prompt: string;
+    guidance?: number;
+    control_image: string;
+    output_format?: Schemas["output_format"];
+    safety_tolerance?: number;
+    prompt_upsampling?: boolean;
+  };
+  Output: string;
+  output_format: "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-canny-pro": (() => {
+    const transformer: ReplicateTransformer = {
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          control_image: await toURL(request.image),
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          // control_image is required and must be provided in request.extra for imageGenerate
+          seed: request.seed,
+          ...request.extra,
+        } as Schemas["Input"]),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+    };
+    return transformer;
+  })()
+}

package/src/transformers/replicate/black-forest-labs-flux-depth-dev.ts

@@ -0,0 +1,40 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number;
+    prompt: string;
+    guidance?: number;
+    megapixels?: Schemas["megapixels"];
+    num_outputs?: number;
+    control_image: string;
+    output_format?: Schemas["output_format"];
+    output_quality?: number;
+    num_inference_steps?: number;
+    disable_safety_checker?: boolean;
+  };
+  Output: string[];
+  megapixels: "1" | "0.25" | "match_input";
+  output_format: "webp" | "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-depth-dev": (() => {
+    const transformer: ReplicateTransformer = {
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          control_image: await toURL(request.image),
+          num_outputs: request.n,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: response.map((url) => ({ url })),
+        }),
+      },
+    };
+    return transformer;
+  })()
+}

package/src/transformers/replicate/black-forest-labs-flux-depth-pro.ts

@@ -0,0 +1,35 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number | null;
+    steps?: number;
+    prompt: string;
+    guidance?: number;
+    control_image: string;
+    output_format?: Schemas["output_format"];
+    safety_tolerance?: number;
+    prompt_upsampling?: boolean;
+  };
+  Output: string;
+  output_format: "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-depth-pro": (() => {
+    const transformer: ReplicateTransformer = { 
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({ 
+          prompt: request.prompt,
+          control_image: await toURL(request.image),
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-dev-lora.ts

@@ -0,0 +1,64 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number;
+    image?: string;
+    prompt: string;
+    go_fast?: boolean;
+    guidance?: number;
+    extra_lora?: string;
+    lora_scale?: number;
+    megapixels?: Schemas["megapixels"];
+    num_outputs?: number;
+    aspect_ratio?: Schemas["aspect_ratio"];
+    hf_api_token?: string;
+    lora_weights?: string;
+    output_format?: Schemas["output_format"];
+    output_quality?: number;
+    prompt_strength?: number;
+    extra_lora_scale?: number;
+    civitai_api_token?: string;
+    num_inference_steps?: number;
+    disable_safety_checker?: boolean;
+  };
+  Output: string[];
+  megapixels: "1" | "0.25";
+  aspect_ratio: "1:1" | "16:9" | "21:9" | "3:2" | "2:3" | "4:5" | "5:4" | "3:4" | "4:3" | "9:16" | "9:21";
+  output_format: "webp" | "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-dev-lora": (() => {
+    const transformer: ReplicateTransformer = {
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          num_outputs: request.n,
+          seed: request.seed,
+          output_quality: request.quality === 'low' ? 60 : request.quality === 'high' ? 100 : 80,
+          output_format: request.extra?.output_format || "webp",
+          aspect_ratio: request.extra?.aspect_ratio || "1:1",
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: response.map(url => ({ url })),
+        }),
+      },
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          image: await toURL(request.image),
+          num_outputs: request.n,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: response.map(url => ({ url })),
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-dev.ts

@@ -0,0 +1,55 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number;
+    image?: string;
+    prompt: string;
+    go_fast?: boolean;
+    guidance?: number;
+    megapixels?: Schemas["megapixels"];
+    num_outputs?: number;
+    aspect_ratio?: Schemas["aspect_ratio"];
+    output_format?: Schemas["output_format"];
+    output_quality?: number;
+    prompt_strength?: number;
+    num_inference_steps?: number;
+    disable_safety_checker?: boolean;
+  };
+  Output: string[];
+  megapixels: "1" | "0.25";
+  aspect_ratio: "1:1" | "16:9" | "21:9" | "3:2" | "2:3" | "4:5" | "5:4" | "3:4" | "4:3" | "9:16" | "9:21";
+  output_format: "webp" | "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-dev": (() => {
+    const transformer: ReplicateTransformer = {
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          num_outputs: request.n,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: await Promise.all(response.map(async (url) => ({ url: await toURL(url) }))),
+        }),
+      },
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          image: await toURL(request.image),
+          num_outputs: request.n,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: await Promise.all(response.map(async (url) => ({ url: await toURL(url) }))),
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-fill-dev.ts

@@ -0,0 +1,44 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    mask?: string;
+    seed?: number;
+    image: string;
+    prompt: string;
+    guidance?: number;
+    lora_scale?: number;
+    megapixels?: Schemas["megapixels"];
+    num_outputs?: number;
+    lora_weights?: string;
+    output_format?: Schemas["output_format"];
+    output_quality?: number;
+    num_inference_steps?: number;
+    disable_safety_checker?: boolean;
+  };
+  Output: string[];
+  megapixels: "1" | "0.25" | "match_input";
+  output_format: "webp" | "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-fill-dev": (() => {
+    const transformer: ReplicateTransformer = {
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          image: await toURL(request.image),
+          mask: request.mask ? await toURL(request.mask) : undefined,
+          num_outputs: request.n,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: response.map((url) => ({ url })),
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-fill-pro.ts

@@ -0,0 +1,42 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    mask?: string;
+    seed?: number;
+    image: string;
+    steps?: number;
+    prompt: string;
+    guidance?: number;
+    outpaint?: Schemas["outpaint"];
+    output_format?: Schemas["output_format"];
+    safety_tolerance?: number;
+    prompt_upsampling?: boolean;
+  };
+  Output: string;
+  outpaint: "None" | "Zoom out 1.5x" | "Zoom out 2x" | "Make square" | "Left outpaint" | "Right outpaint" | "Top outpaint" | "Bottom outpaint";
+  output_format: "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-fill-pro": (() => {
+    const transformer: ReplicateTransformer = {
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => {
+          return {
+            prompt: request.prompt,
+            image: await toURL(request.image),
+            mask: request.mask ? await toURL(request.mask) : undefined,
+            seed: request.seed,
+            ...request.extra,
+          };
+        },
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-kontext-dev.ts

@@ -0,0 +1,37 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number;
+    prompt: string;
+    guidance?: number;
+    input_image: string;
+    aspect_ratio?: Schemas["aspect_ratio"];
+    output_format?: Schemas["output_format"];
+    output_quality?: number;
+    num_inference_steps?: number;
+    disable_safety_checker?: boolean;
+  };
+  Output: string;
+  aspect_ratio: "1:1" | "16:9" | "21:9" | "3:2" | "2:3" | "4:5" | "5:4" | "3:4" | "4:3" | "9:16" | "9:21" | "match_input_image";
+  output_format: "webp" | "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-kontext-dev": (() => {
+    const transformer: ReplicateTransformer = {
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          input_image: await toURL(request.image),
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+    };
+    return transformer;
+  })()
+}

package/src/transformers/replicate/black-forest-labs-flux-kontext-max.ts

@@ -0,0 +1,46 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number | null;
+    prompt: string;
+    input_image?: string | null;
+    aspect_ratio?: Schemas["aspect_ratio"];
+    output_format?: Schemas["output_format"];
+    safety_tolerance?: number;
+    prompt_upsampling?: boolean;
+  };
+  Output: string;
+  aspect_ratio: "match_input_image" | "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | "3:2" | "2:3" | "4:5" | "5:4" | "21:9" | "9:21" | "2:1" | "1:2";
+  output_format: "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-kontext-max": (() => {
+    const transformer: ReplicateTransformer = {
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          input_image: await toURL(request.image),
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-kontext-pro.ts

@@ -0,0 +1,46 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number | null;
+    prompt: string;
+    input_image?: string | null;
+    aspect_ratio?: Schemas["aspect_ratio"];
+    output_format?: Schemas["output_format"];
+    safety_tolerance?: number;
+    prompt_upsampling?: boolean;
+  };
+  Output: string;
+  aspect_ratio: "match_input_image" | "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | "3:2" | "2:3" | "4:5" | "5:4" | "21:9" | "9:21" | "2:1" | "1:2";
+  output_format: "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-kontext-pro": (() => {
+    const transformer: ReplicateTransformer = {
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+      imageEdit: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => ({
+          prompt: request.prompt,
+          input_image: await toURL(request.image),
+          seed: request.seed,
+          ...request.extra,
+        }),
+        parseResponse: async (response: Schemas["Output"], ctx) => ({
+          images: [{ url: await toURL(response) }],
+        }),
+      },
+    };
+    return transformer;
+  })(),
+}

package/src/transformers/replicate/black-forest-labs-flux-pro-finetuned.ts

@@ -0,0 +1,70 @@
+import { toURL } from '@aeye/core';
+import { ReplicateTransformer } from '@aeye/replicate';
+
+type Schemas = {
+  Input: {
+    seed?: number;
+    steps?: number;
+    width?: number;
+    height?: number;
+    prompt: string;
+    guidance?: number;
+    finetune_id: string;
+    aspect_ratio?: Schemas["aspect_ratio"];
+    image_prompt?: string;
+    output_format?: Schemas["output_format"];
+    safety_tolerance?: number;
+    finetune_strength?: number;
+    prompt_upsampling?: boolean;
+  };
+  Output: string;
+  Status: "starting" | "processing" | "succeeded" | "canceled" | "failed";
+  aspect_ratio: "custom" | "1:1" | "16:9" | "3:2" | "2:3" | "4:5" | "5:4" | "9:16" | "3:4" | "4:3";
+  output_format: "jpg" | "png";
+};
+
+export default {
+  "black-forest-labs/flux-pro-finetuned": (() => {
+    const transformer: ReplicateTransformer = {
+      imageGenerate: {
+        convertRequest: async (request, ctx): Promise<Schemas["Input"]> => {
+          const input: Schemas["Input"] = {
+            prompt: request.prompt,
+            finetune_id: request.extra?.finetune_id,
+            ...request.extra,
+          };
+
+          if (request.seed !== undefined) {
+            input.seed = request.seed;
+          }
+
+          if (request.size) {
+            const validRatios = ["1:1", "16:9", "3:2", "2:3", "4:5", "5:4", "9:16", "3:4", "4:3"];
+            if (validRatios.includes(request.size)) {
+              input.aspect_ratio = request.size as Schemas["aspect_ratio"];
+            } else {
+              const parts = request.size.split("x").map(Number);
+              if (parts.length === 2 && !parts.some(isNaN)) {
+                input.aspect_ratio = "custom";
+                input.width = parts[0];
+                input.height = parts[1];
+              }
+            }
+          }
+
+          if (request.extra?.image_prompt) {
+            input.image_prompt = await toURL(request.extra.image_prompt);
+          }
+
+          return input;
+        },
+        parseResponse: async (response: Schemas["Output"], ctx) => {
+          return {
+            images: [{ url: await toURL(response) }],
+          };
+        },
+      },
+    };
+    return transformer;
+  })(),
+}