modelfusion 0.101.0 → 0.102.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## v0.102.0 - 2023-12-22
+
+### Added
+
+- You can specify `numberOfGenerations` on image generation models and create multiple images by using the `fullResponse: true` option. Example:
+
+  ```ts
+  // generate 2 images:
+  const { images } = await generateImage(
+    openai.ImageGenerator({
+      model: "dall-e-3",
+      numberOfGenerations: 2,
+      size: "1024x1024",
+    }),
+    "the wicked witch of the west in the style of early 19th century painting",
+    { fullResponse: true }
+  );
+  ```
+
+- **breaking change**: Image generation models use a generalized `numberOfGenerations` parameter (instead of model specific parameters) to specify the number of generations.
+
 ## v0.101.0 - 2023-12-22
 
 ### Changed

package/model-function/generate-image/ImageGenerationModel.d.ts

@@ -2,11 +2,21 @@ import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 import { PromptTemplate } from "../PromptTemplate.js";
 export interface ImageGenerationModelSettings extends ModelSettings {
+    /**
+     * Number of images to generate.
+     *
+     * Specifies the number of images the model should generate for a given prompt.
+     *
+     * Does nothing if the model does not support this setting.
+     *
+     * Example: `numberOfGenerations: 2` // The model will produce 2 images
+     */
+    numberOfGenerations?: number;
 }
 export interface ImageGenerationModel<PROMPT, SETTINGS extends ImageGenerationModelSettings = ImageGenerationModelSettings> extends Model<SETTINGS> {
-    doGenerateImage(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateImages(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
         response: unknown;
-        base64Image: string;
+        base64Images: string[];
     }>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, PROMPT>): ImageGenerationModel<INPUT_PROMPT, SETTINGS>;
 }

package/model-function/generate-image/PromptTemplateImageGenerationModel.cjs

@@ -24,15 +24,15 @@ class PromptTemplateImageGenerationModel {
     get settings() {
         return this.model.settings;
     }
-    doGenerateImage(prompt, options) {
+    doGenerateImages(prompt, options) {
         const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateImage(mappedPrompt, options);
+        return this.model.doGenerateImages(mappedPrompt, options);
     }
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
     withPromptTemplate(promptTemplate) {
-        return new PromptTemplateImageGenerationModel({ model: this, promptTemplate: promptTemplate });
+        return new PromptTemplateImageGenerationModel({ model: this, promptTemplate });
     }
     withSettings(additionalSettings) {
         return new PromptTemplateImageGenerationModel({

package/model-function/generate-image/PromptTemplateImageGenerationModel.d.ts

@@ -10,9 +10,9 @@ export declare class PromptTemplateImageGenerationModel<PROMPT, MODEL_PROMPT, SE
     });
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): SETTINGS;
-    doGenerateImage(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateImages(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
         response: unknown;
-        base64Image: string;
+        base64Images: string[];
     }>;
     get settingsForEvent(): Partial<SETTINGS>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, PROMPT>): PromptTemplateImageGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;

package/model-function/generate-image/PromptTemplateImageGenerationModel.js

@@ -21,15 +21,15 @@ export class PromptTemplateImageGenerationModel {
     get settings() {
         return this.model.settings;
     }
-    doGenerateImage(prompt, options) {
+    doGenerateImages(prompt, options) {
         const mappedPrompt = this.promptTemplate.format(prompt);
-        return this.model.doGenerateImage(mappedPrompt, options);
+        return this.model.doGenerateImages(mappedPrompt, options);
     }
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
     withPromptTemplate(promptTemplate) {
-        return new PromptTemplateImageGenerationModel({ model: this, promptTemplate: promptTemplate });
+        return new PromptTemplateImageGenerationModel({ model: this, promptTemplate });
     }
     withSettings(additionalSettings) {
         return new PromptTemplateImageGenerationModel({

package/model-function/generate-image/generateImage.cjs

@@ -9,22 +9,24 @@ async function generateImage(model, prompt, options) {
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateImage(prompt, options);
+            const result = await model.doGenerateImages(prompt, options);
             return {
                 response: result.response,
-                extractedValue: result.base64Image,
+                extractedValue: result.base64Images,
             };
         },
     });
-    const imageBase64 = fullResponse.value;
-    const image = Buffer.from(imageBase64, "base64");
+    const imagesBase64 = fullResponse.value;
+    const images = imagesBase64.map((imageBase64) => Buffer.from(imageBase64, "base64"));
     return options?.fullResponse
         ? {
-            image,
-            imageBase64,
+            image: images[0],
+            imageBase64: imagesBase64[0],
+            images,
+            imagesBase64,
             response: fullResponse.response,
             metadata: fullResponse.metadata,
         }
-        : image;
+        : images[0];
 }
 exports.generateImage = generateImage;

package/model-function/generate-image/generateImage.d.ts

@@ -34,6 +34,8 @@ export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT
 }): Promise<{
     image: Buffer;
     imageBase64: string;
+    images: Buffer[];
+    imagesBase64: string[];
     response: unknown;
     metadata: ModelCallMetadata;
 }>;

package/model-function/generate-image/generateImage.js

@@ -6,21 +6,23 @@ export async function generateImage(model, prompt, options) {
         model,
         options,
         generateResponse: async (options) => {
-            const result = await model.doGenerateImage(prompt, options);
+            const result = await model.doGenerateImages(prompt, options);
             return {
                 response: result.response,
-                extractedValue: result.base64Image,
+                extractedValue: result.base64Images,
             };
         },
     });
-    const imageBase64 = fullResponse.value;
-    const image = Buffer.from(imageBase64, "base64");
+    const imagesBase64 = fullResponse.value;
+    const images = imagesBase64.map((imageBase64) => Buffer.from(imageBase64, "base64"));
     return options?.fullResponse
         ? {
-            image,
-            imageBase64,
+            image: images[0],
+            imageBase64: imagesBase64[0],
+            images,
+            imagesBase64,
             response: fullResponse.response,
             metadata: fullResponse.metadata,
         }
-        : image;
+        : images[0];
 }

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.cjs

@@ -37,13 +37,15 @@ class Automatic1111ImageGenerationModel extends AbstractModel_js_1.AbstractModel
                 url: api.assembleUrl(`/txt2img`),
                 headers: api.headers,
                 body: {
-                    height: this.settings.height,
-                    width: this.settings.width,
                     prompt: input.prompt,
                     negative_prompt: input.negativePrompt,
+                    seed: this.settings.seed,
+                    batch_size: this.settings.numberOfGenerations,
+                    height: this.settings.height,
+                    width: this.settings.width,
+                    cfg_scale: this.settings.cfgScale,
                     sampler_index: this.settings.sampler,
                     steps: this.settings.steps,
-                    seed: input.seed,
                     override_settings: {
                         sd_model_checkpoint: this.settings.model,
                     },
@@ -62,11 +64,11 @@ class Automatic1111ImageGenerationModel extends AbstractModel_js_1.AbstractModel
             steps: this.settings.steps,
         };
     }
-    async doGenerateImage(prompt, options) {
+    async doGenerateImages(prompt, options) {
         const response = await this.callAPI(prompt, options);
         return {
             response,
-            base64Image: response.images[0],
+            base64Images: response.images,
         };
     }
     withTextPrompt() {

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.d.ts

@@ -8,11 +8,25 @@ import { PromptTemplateImageGenerationModel } from "../../model-function/generat
 import { Automatic1111ImageGenerationPrompt } from "./Automatic1111ImageGenerationPrompt.js";
 export interface Automatic1111ImageGenerationSettings extends ImageGenerationModelSettings {
     api?: ApiConfiguration;
+    /**
+     * Stable Diffusion checkpoint.
+     */
     model: string;
     height?: number;
     width?: number;
+    /**
+     * Sampling method.
+     */
     sampler?: string;
+    /**
+     * Sampling steps.
+     */
     steps?: number;
+    /**
+     * CFG Scale.
+     */
+    cfgScale?: number;
+    seed?: number;
 }
 /**
  * Create an image generation model that calls the AUTOMATIC1111 Stable Diffusion Web UI API.
@@ -25,13 +39,13 @@ export declare class Automatic1111ImageGenerationModel extends AbstractModel<Aut
     get modelName(): string;
     callAPI(input: Automatic1111ImageGenerationPrompt, options?: FunctionOptions): Promise<Automatic1111ImageGenerationResponse>;
     get settingsForEvent(): Partial<Automatic1111ImageGenerationSettings>;
-    doGenerateImage(prompt: Automatic1111ImageGenerationPrompt, options?: FunctionOptions): Promise<{
+    doGenerateImages(prompt: Automatic1111ImageGenerationPrompt, options?: FunctionOptions): Promise<{
         response: {
             images: string[];
             parameters: {};
             info: string;
         };
-        base64Image: string;
+        base64Images: string[];
     }>;
     withTextPrompt(): PromptTemplateImageGenerationModel<string, Automatic1111ImageGenerationPrompt, Automatic1111ImageGenerationSettings, this>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, Automatic1111ImageGenerationPrompt>): PromptTemplateImageGenerationModel<INPUT_PROMPT, Automatic1111ImageGenerationPrompt, Automatic1111ImageGenerationSettings, this>;

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.js

@@ -34,13 +34,15 @@ export class Automatic1111ImageGenerationModel extends AbstractModel {
                 url: api.assembleUrl(`/txt2img`),
                 headers: api.headers,
                 body: {
-                    height: this.settings.height,
-                    width: this.settings.width,
                     prompt: input.prompt,
                     negative_prompt: input.negativePrompt,
+                    seed: this.settings.seed,
+                    batch_size: this.settings.numberOfGenerations,
+                    height: this.settings.height,
+                    width: this.settings.width,
+                    cfg_scale: this.settings.cfgScale,
                     sampler_index: this.settings.sampler,
                     steps: this.settings.steps,
-                    seed: input.seed,
                     override_settings: {
                         sd_model_checkpoint: this.settings.model,
                     },
@@ -59,11 +61,11 @@ export class Automatic1111ImageGenerationModel extends AbstractModel {
             steps: this.settings.steps,
         };
     }
-    async doGenerateImage(prompt, options) {
+    async doGenerateImages(prompt, options) {
         const response = await this.callAPI(prompt, options);
         return {
             response,
-            base64Image: response.images[0],
+            base64Images: response.images,
         };
     }
     withTextPrompt() {

package/model-provider/automatic1111/Automatic1111ImageGenerationPrompt.d.ts

@@ -2,7 +2,6 @@ import { PromptTemplate } from "../../model-function/PromptTemplate.js";
 export type Automatic1111ImageGenerationPrompt = {
     prompt: string;
     negativePrompt?: string;
-    seed?: number;
 };
 /**
  * Formats a basic text prompt as an Automatic1111 prompt.

package/model-provider/llamacpp/LlamaCppTextGenerationModel.d.ts

@@ -65,8 +65,8 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
             generation_settings: {
                 model: string;
                 stream: boolean;
-                mirostat: number;
                 seed: number;
+                mirostat: number;
                 stop: string[];
                 frequency_penalty: number;
                 ignore_eos: boolean;
@@ -155,8 +155,8 @@ declare const llamaCppTextGenerationResponseSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         model: string;
         stream: boolean;
-        mirostat: number;
         seed: number;
+        mirostat: number;
         stop: string[];
         frequency_penalty: number;
         ignore_eos: boolean;
@@ -179,8 +179,8 @@ declare const llamaCppTextGenerationResponseSchema: z.ZodObject<{
     }, {
         model: string;
         stream: boolean;
-        mirostat: number;
         seed: number;
+        mirostat: number;
         stop: string[];
         frequency_penalty: number;
         ignore_eos: boolean;
@@ -247,8 +247,8 @@ declare const llamaCppTextGenerationResponseSchema: z.ZodObject<{
     generation_settings: {
         model: string;
         stream: boolean;
-        mirostat: number;
         seed: number;
+        mirostat: number;
         stop: string[];
         frequency_penalty: number;
         ignore_eos: boolean;
@@ -295,8 +295,8 @@ declare const llamaCppTextGenerationResponseSchema: z.ZodObject<{
     generation_settings: {
         model: string;
         stream: boolean;
-        mirostat: number;
         seed: number;
+        mirostat: number;
         stop: string[];
         frequency_penalty: number;
         ignore_eos: boolean;
@@ -360,8 +360,8 @@ export declare const LlamaCppTextGenerationResponseFormat: {
             generation_settings: {
                 model: string;
                 stream: boolean;
-                mirostat: number;
                 seed: number;
+                mirostat: number;
                 stop: string[];
                 frequency_penalty: number;
                 ignore_eos: boolean;

package/model-provider/openai/OpenAIImageGenerationModel.cjs

@@ -60,7 +60,7 @@ const calculateOpenAIImageGenerationCostInMillicents = ({ model, settings, }) =>
     if (cost == null) {
         return null;
     }
-    return (settings.n ?? 1) * cost;
+    return (settings.numberOfGenerations ?? 1) * cost;
 };
 exports.calculateOpenAIImageGenerationCostInMillicents = calculateOpenAIImageGenerationCostInMillicents;
 /**
@@ -88,38 +88,48 @@ class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
-        const run = options?.run;
+        const api = this.settings.api ?? new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
+        const userId = options?.run?.userId;
         const responseFormat = options?.responseFormat;
-        const callSettings = {
-            ...this.settings,
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            abortSignal: run?.abortSignal,
-            responseFormat,
-            prompt,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAIImageGenerationAPI(callSettings),
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => {
+                return (0, postToApi_js_1.postJsonToApi)({
+                    url: api.assembleUrl("/images/generations"),
+                    headers: api.headers,
+                    body: {
+                        prompt,
+                        n: this.settings.numberOfGenerations,
+                        size: this.settings.size,
+                        response_format: responseFormat.type,
+                        user: this.settings.isUserIdForwardingEnabled ? userId : undefined,
+                    },
+                    failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
+                    successfulResponseHandler: responseFormat?.handler,
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "n",
+            "numberOfGenerations",
             "size",
             "quality",
             "style",
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateImage(prompt, options) {
+    async doGenerateImages(prompt, options) {
         const response = await this.callAPI(prompt, {
             responseFormat: exports.OpenAIImageGenerationResponseFormat.base64Json,
             ...options,
         });
         return {
             response,
-            base64Image: response.data[0].b64_json,
+            base64Images: response.data.map((item) => item.b64_json),
         };
     }
     withPromptTemplate(promptTemplate) {
@@ -155,19 +165,3 @@ exports.OpenAIImageGenerationResponseFormat = {
         handler: (0, postToApi_js_1.createJsonResponseHandler)(openAIImageGenerationBase64JsonSchema),
     },
 };
-async function callOpenAIImageGenerationAPI({ api = new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration(), abortSignal, prompt, n, size, responseFormat, user, }) {
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl("/images/generations"),
-        headers: api.headers,
-        body: {
-            prompt,
-            n,
-            size,
-            response_format: responseFormat.type,
-            user,
-        },
-        failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
-        successfulResponseHandler: responseFormat?.handler,
-        abortSignal,
-    });
-}

package/model-provider/openai/OpenAIImageGenerationModel.d.ts

@@ -24,7 +24,6 @@ export declare const calculateOpenAIImageGenerationCostInMillicents: ({ model, s
 export type OpenAIImageModelType = keyof typeof OPENAI_IMAGE_MODELS;
 export interface OpenAIImageGenerationCallSettings {
     model: OpenAIImageModelType;
-    n?: number;
     size?: "256x256" | "512x512" | "1024x1024" | "1792x1024" | "1024x1792";
     quality?: "standard" | "hd";
     style?: "vivid" | "natural";
@@ -52,14 +51,14 @@ export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImag
         responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
     } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAIImageGenerationSettings>;
-    doGenerateImage(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateImages(prompt: string, options?: FunctionOptions): Promise<{
         response: {
             data: {
                 b64_json: string;
             }[];
             created: number;
         };
-        base64Image: string;
+        base64Images: string[];
     }>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, string>): PromptTemplateImageGenerationModel<INPUT_PROMPT, string, OpenAIImageGenerationSettings, this>;
     withSettings(additionalSettings: Partial<OpenAIImageGenerationSettings>): this;

package/model-provider/openai/OpenAIImageGenerationModel.js

@@ -57,7 +57,7 @@ export const calculateOpenAIImageGenerationCostInMillicents = ({ model, settings
     if (cost == null) {
         return null;
     }
-    return (settings.n ?? 1) * cost;
+    return (settings.numberOfGenerations ?? 1) * cost;
 };
 /**
  * Create an image generation model that calls the OpenAI AI image creation API.
@@ -84,38 +84,48 @@ export class OpenAIImageGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(prompt, options) {
-        const run = options?.run;
+        const api = this.settings.api ?? new OpenAIApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
+        const userId = options?.run?.userId;
         const responseFormat = options?.responseFormat;
-        const callSettings = {
-            ...this.settings,
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            abortSignal: run?.abortSignal,
-            responseFormat,
-            prompt,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAIImageGenerationAPI(callSettings),
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => {
+                return postJsonToApi({
+                    url: api.assembleUrl("/images/generations"),
+                    headers: api.headers,
+                    body: {
+                        prompt,
+                        n: this.settings.numberOfGenerations,
+                        size: this.settings.size,
+                        response_format: responseFormat.type,
+                        user: this.settings.isUserIdForwardingEnabled ? userId : undefined,
+                    },
+                    failedResponseHandler: failedOpenAICallResponseHandler,
+                    successfulResponseHandler: responseFormat?.handler,
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "n",
+            "numberOfGenerations",
             "size",
             "quality",
             "style",
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateImage(prompt, options) {
+    async doGenerateImages(prompt, options) {
         const response = await this.callAPI(prompt, {
             responseFormat: OpenAIImageGenerationResponseFormat.base64Json,
             ...options,
         });
         return {
             response,
-            base64Image: response.data[0].b64_json,
+            base64Images: response.data.map((item) => item.b64_json),
         };
     }
     withPromptTemplate(promptTemplate) {
@@ -150,19 +160,3 @@ export const OpenAIImageGenerationResponseFormat = {
         handler: createJsonResponseHandler(openAIImageGenerationBase64JsonSchema),
     },
 };
-async function callOpenAIImageGenerationAPI({ api = new OpenAIApiConfiguration(), abortSignal, prompt, n, size, responseFormat, user, }) {
-    return postJsonToApi({
-        url: api.assembleUrl("/images/generations"),
-        headers: api.headers,
-        body: {
-            prompt,
-            n,
-            size,
-            response_format: responseFormat.type,
-            user,
-        },
-        failedResponseHandler: failedOpenAICallResponseHandler,
-        successfulResponseHandler: responseFormat?.handler,
-        abortSignal,
-    });
-}

package/model-provider/stability/StabilityApiConfiguration.cjs

@@ -1,13 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StabilityApiConfiguration = void 0;
-const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
+const BaseUrlPartsApiConfiguration_js_1 = require("../../core/api/BaseUrlPartsApiConfiguration.cjs");
 const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
-class StabilityApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api.stability.ai/v1", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the Stability AI API.
+ * It calls the API at https://api.stability.ai/v1 by default.
+ */
+class StabilityApiConfiguration extends BaseUrlPartsApiConfiguration_js_1.BaseUrlPartsApiConfiguration {
+    constructor({ protocol = "https", host = "api.stability.ai", port = "443", path = "/v1", apiKey, headers, retry, throttle, } = {}) {
         super({
-            baseUrl,
-            headers: {
+            protocol,
+            host,
+            port,
+            path,
+            headers: headers ?? {
                 Authorization: `Bearer ${(0, loadApiKey_js_1.loadApiKey)({
                     apiKey,
                     environmentVariableName: "STABILITY_API_KEY",

package/model-provider/stability/StabilityApiConfiguration.d.ts

@@ -1,11 +1,10 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
-import { RetryFunction } from "../../core/api/RetryFunction.js";
-import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
-export declare class StabilityApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl, apiKey, retry, throttle, }?: {
-        baseUrl?: string;
+import { BaseUrlPartsApiConfiguration, BaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlPartsApiConfiguration.js";
+/**
+ * Creates an API configuration for the Stability AI API.
+ * It calls the API at https://api.stability.ai/v1 by default.
+ */
+export declare class StabilityApiConfiguration extends BaseUrlPartsApiConfiguration {
+    constructor({ protocol, host, port, path, apiKey, headers, retry, throttle, }?: Partial<BaseUrlPartsApiConfigurationOptions> & {
         apiKey?: string;
-        retry?: RetryFunction;
-        throttle?: ThrottleFunction;
     });
 }

package/model-provider/stability/StabilityApiConfiguration.js

@@ -1,10 +1,17 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { BaseUrlPartsApiConfiguration, } from "../../core/api/BaseUrlPartsApiConfiguration.js";
 import { loadApiKey } from "../../core/api/loadApiKey.js";
-export class StabilityApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api.stability.ai/v1", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the Stability AI API.
+ * It calls the API at https://api.stability.ai/v1 by default.
+ */
+export class StabilityApiConfiguration extends BaseUrlPartsApiConfiguration {
+    constructor({ protocol = "https", host = "api.stability.ai", port = "443", path = "/v1", apiKey, headers, retry, throttle, } = {}) {
         super({
-            baseUrl,
-            headers: {
+            protocol,
+            host,
+            port,
+            path,
+            headers: headers ?? {
                 Authorization: `Bearer ${loadApiKey({
                     apiKey,
                     environmentVariableName: "STABILITY_API_KEY",

package/model-provider/stability/StabilityError.cjs

@@ -1,37 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.failedStabilityCallResponseHandler = exports.StabilityError = exports.stabilityErrorDataSchema = void 0;
+exports.failedStabilityCallResponseHandler = void 0;
 const zod_1 = require("zod");
-const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
-exports.stabilityErrorDataSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
+const stabilityErrorDataSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
     message: zod_1.z.string(),
 }));
-class StabilityError extends ApiCallError_js_1.ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = data.message, }) {
-        super({ message, statusCode, requestBodyValues, url });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.data = data;
-    }
-}
-exports.StabilityError = StabilityError;
-const failedStabilityCallResponseHandler = async ({ response, url, requestBodyValues }) => {
-    const responseBody = await response.text();
-    const parsedError = (0, parseJSON_js_1.parseJSON)({
-        text: responseBody,
-        schema: exports.stabilityErrorDataSchema,
-    });
-    return new StabilityError({
-        url,
-        requestBodyValues,
-        statusCode: response.status,
-        data: parsedError,
-    });
-};
-exports.failedStabilityCallResponseHandler = failedStabilityCallResponseHandler;
+exports.failedStabilityCallResponseHandler = (0, postToApi_js_1.createJsonErrorResponseHandler)({
+    errorSchema: stabilityErrorDataSchema,
+    errorToMessage: (error) => error.message,
+});

package/model-provider/stability/StabilityError.d.ts

@@ -1,18 +1,9 @@
 import { ApiCallError } from "../../core/api/ApiCallError.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
 import { ZodSchema } from "../../core/schema/ZodSchema.js";
-export declare const stabilityErrorDataSchema: ZodSchema<{
+declare const stabilityErrorDataSchema: ZodSchema<{
     message: string;
 }>;
 export type StabilityErrorData = (typeof stabilityErrorDataSchema)["_type"];
-export declare class StabilityError extends ApiCallError {
-    readonly data: StabilityErrorData;
-    constructor({ data, statusCode, url, requestBodyValues, message, }: {
-        message?: string;
-        statusCode: number;
-        url: string;
-        requestBodyValues: unknown;
-        data: StabilityErrorData;
-    });
-}
 export declare const failedStabilityCallResponseHandler: ResponseHandler<ApiCallError>;
+export {};

package/model-provider/stability/StabilityError.js

@@ -1,32 +1,10 @@
 import { z } from "zod";
-import { ApiCallError } from "../../core/api/ApiCallError.js";
+import { createJsonErrorResponseHandler, } from "../../core/api/postToApi.js";
 import { ZodSchema } from "../../core/schema/ZodSchema.js";
-import { parseJSON } from "../../core/schema/parseJSON.js";
-export const stabilityErrorDataSchema = new ZodSchema(z.object({
+const stabilityErrorDataSchema = new ZodSchema(z.object({
     message: z.string(),
 }));
-export class StabilityError extends ApiCallError {
-    constructor({ data, statusCode, url, requestBodyValues, message = data.message, }) {
-        super({ message, statusCode, requestBodyValues, url });
-        Object.defineProperty(this, "data", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.data = data;
-    }
-}
-export const failedStabilityCallResponseHandler = async ({ response, url, requestBodyValues }) => {
-    const responseBody = await response.text();
-    const parsedError = parseJSON({
-        text: responseBody,
-        schema: stabilityErrorDataSchema,
-    });
-    return new StabilityError({
-        url,
-        requestBodyValues,
-        statusCode: response.status,
-        data: parsedError,
-    });
-};
+export const failedStabilityCallResponseHandler = createJsonErrorResponseHandler({
+    errorSchema: stabilityErrorDataSchema,
+    errorToMessage: (error) => error.message,
+});

package/model-provider/stability/StabilityFacade.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageGenerator = void 0;
+exports.Api = exports.ImageGenerator = void 0;
+const StabilityApiConfiguration_js_1 = require("./StabilityApiConfiguration.cjs");
 const StabilityImageGenerationModel_js_1 = require("./StabilityImageGenerationModel.cjs");
 /**
  * Create an image generation model that calls the Stability AI image generation API.
@@ -10,12 +11,11 @@ const StabilityImageGenerationModel_js_1 = require("./StabilityImageGenerationMo
  * @example
  * const image = await generateImage(
  *   stability.ImageGenerator({
- *     model: "stable-diffusion-512-v2-1",
+ *     model: "stable-diffusion-v1-6",
  *     cfgScale: 7,
  *     clipGuidancePreset: "FAST_BLUE",
  *     height: 512,
  *     width: 512,
- *     samples: 1,
  *     steps: 30,
  *   })
  *   [
@@ -30,3 +30,11 @@ function ImageGenerator(settings) {
     return new StabilityImageGenerationModel_js_1.StabilityImageGenerationModel(settings);
 }
 exports.ImageGenerator = ImageGenerator;
+/**
+ * Creates an API configuration for the Stability AI API.
+ * It calls the API at https://api.stability.ai/v1 by default.
+ */
+function Api(settings) {
+    return new StabilityApiConfiguration_js_1.StabilityApiConfiguration(settings);
+}
+exports.Api = Api;

package/model-provider/stability/StabilityFacade.d.ts

@@ -1,3 +1,5 @@
+import { BaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlPartsApiConfiguration.js";
+import { StabilityApiConfiguration } from "./StabilityApiConfiguration.js";
 import { StabilityImageGenerationModel, StabilityImageGenerationSettings } from "./StabilityImageGenerationModel.js";
 /**
  * Create an image generation model that calls the Stability AI image generation API.
@@ -7,12 +9,11 @@ import { StabilityImageGenerationModel, StabilityImageGenerationSettings } from
  * @example
  * const image = await generateImage(
  *   stability.ImageGenerator({
- *     model: "stable-diffusion-512-v2-1",
+ *     model: "stable-diffusion-v1-6",
  *     cfgScale: 7,
  *     clipGuidancePreset: "FAST_BLUE",
  *     height: 512,
  *     width: 512,
- *     samples: 1,
  *     steps: 30,
  *   })
  *   [
@@ -24,3 +25,10 @@ import { StabilityImageGenerationModel, StabilityImageGenerationSettings } from
  * @returns A new instance of {@link StabilityImageGenerationModel}.
  */
 export declare function ImageGenerator(settings: StabilityImageGenerationSettings): StabilityImageGenerationModel;
+/**
+ * Creates an API configuration for the Stability AI API.
+ * It calls the API at https://api.stability.ai/v1 by default.
+ */
+export declare function Api(settings: Partial<BaseUrlPartsApiConfigurationOptions> & {
+    apiKey?: string;
+}): StabilityApiConfiguration;

package/model-provider/stability/StabilityFacade.js

@@ -1,3 +1,4 @@
+import { StabilityApiConfiguration } from "./StabilityApiConfiguration.js";
 import { StabilityImageGenerationModel, } from "./StabilityImageGenerationModel.js";
 /**
  * Create an image generation model that calls the Stability AI image generation API.
@@ -7,12 +8,11 @@ import { StabilityImageGenerationModel, } from "./StabilityImageGenerationModel.
  * @example
  * const image = await generateImage(
  *   stability.ImageGenerator({
- *     model: "stable-diffusion-512-v2-1",
+ *     model: "stable-diffusion-v1-6",
  *     cfgScale: 7,
  *     clipGuidancePreset: "FAST_BLUE",
  *     height: 512,
  *     width: 512,
- *     samples: 1,
  *     steps: 30,
  *   })
  *   [
@@ -26,3 +26,10 @@ import { StabilityImageGenerationModel, } from "./StabilityImageGenerationModel.
 export function ImageGenerator(settings) {
     return new StabilityImageGenerationModel(settings);
 }
+/**
+ * Creates an API configuration for the Stability AI API.
+ * It calls the API at https://api.stability.ai/v1 by default.
+ */
+export function Api(settings) {
+    return new StabilityApiConfiguration(settings);
+}

package/model-provider/stability/StabilityImageGenerationModel.cjs

@@ -9,6 +9,10 @@ const PromptTemplateImageGenerationModel_js_1 = require("../../model-function/ge
 const StabilityApiConfiguration_js_1 = require("./StabilityApiConfiguration.cjs");
 const StabilityError_js_1 = require("./StabilityError.cjs");
 const StabilityImageGenerationPrompt_js_1 = require("./StabilityImageGenerationPrompt.cjs");
+const stabilityImageGenerationModels = [
+    "stable-diffusion-v1-6",
+    "stable-diffusion-xl-1024-v1-0",
+];
 /**
  * Create an image generation model that calls the Stability AI image generation API.
  *
@@ -16,13 +20,12 @@ const StabilityImageGenerationPrompt_js_1 = require("./StabilityImageGenerationP
  *
  * @example
  * const image = await generateImage(
- *   new StabilityImageGenerationModel({
- *     model: "stable-diffusion-512-v2-1",
+ *   stability.ImageGenerator({
+ *     model: "stable-diffusion-v1-6",
  *     cfgScale: 7,
  *     clipGuidancePreset: "FAST_BLUE",
  *     height: 512,
  *     width: 512,
- *     samples: 1,
  *     steps: 30,
  *   })
  *   [
@@ -45,37 +48,50 @@ class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async callAPI(input, options) {
+        const api = this.settings.api ?? new StabilityApiConfiguration_js_1.StabilityApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callStabilityImageGenerationAPI({
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                engineId: this.settings.model,
-                textPrompts: input,
+            call: async () => (0, postToApi_js_1.postJsonToApi)({
+                url: api.assembleUrl(`/generation/${this.settings.model}/text-to-image`),
+                headers: api.headers,
+                body: {
+                    height: this.settings.height,
+                    width: this.settings.width,
+                    text_prompts: input,
+                    cfg_scale: this.settings.cfgScale,
+                    clip_guidance_preset: this.settings.clipGuidancePreset,
+                    sampler: this.settings.sampler,
+                    samples: this.settings.numberOfGenerations,
+                    seed: this.settings.seed,
+                    steps: this.settings.steps,
+                    style_preset: this.settings.stylePreset,
+                },
+                failedResponseHandler: StabilityError_js_1.failedStabilityCallResponseHandler,
+                successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(stabilityImageGenerationResponseSchema),
+                abortSignal,
             }),
         });
     }
     get settingsForEvent() {
-        const eventSettingProperties = [
-            "baseUrl",
-            "height",
-            "width",
-            "cfgScale",
-            "clipGuidancePreset",
-            "sampler",
-            "samples",
-            "seed",
-            "steps",
-            "stylePreset",
-        ];
-        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+        return {
+            numberOfGenerations: this.settings.numberOfGenerations,
+            height: this.settings.height,
+            width: this.settings.width,
+            cfgScale: this.settings.cfgScale,
+            clipGuidancePreset: this.settings.clipGuidancePreset,
+            sampler: this.settings.sampler,
+            seed: this.settings.seed,
+            steps: this.settings.steps,
+            stylePreset: this.settings.stylePreset,
+        };
     }
-    async doGenerateImage(prompt, options) {
+    async doGenerateImages(prompt, options) {
         const response = await this.callAPI(prompt, options);
         return {
             response,
-            base64Image: response.artifacts[0].base64,
+            base64Images: response.artifacts.map((artifact) => artifact.base64),
         };
     }
     withTextPrompt() {
@@ -92,12 +108,6 @@ class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
     }
 }
 exports.StabilityImageGenerationModel = StabilityImageGenerationModel;
-const stabilityImageGenerationModels = [
-    "stable-diffusion-v1-5",
-    "stable-diffusion-512-v2-1",
-    "stable-diffusion-xl-1024-v0-9",
-    "stable-diffusion-xl-1024-v1-0",
-];
 const stabilityImageGenerationResponseSchema = zod_1.z.object({
     artifacts: zod_1.z.array(zod_1.z.object({
         base64: zod_1.z.string(),
@@ -105,24 +115,3 @@ const stabilityImageGenerationResponseSchema = zod_1.z.object({
         finishReason: zod_1.z.enum(["SUCCESS", "ERROR", "CONTENT_FILTERED"]),
     })),
 });
-async function callStabilityImageGenerationAPI({ api = new StabilityApiConfiguration_js_1.StabilityApiConfiguration(), abortSignal, engineId, height, width, textPrompts, cfgScale, clipGuidancePreset, sampler, samples, seed, steps, stylePreset, }) {
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl(`/generation/${engineId}/text-to-image`),
-        headers: api.headers,
-        body: {
-            height,
-            width,
-            text_prompts: textPrompts,
-            cfg_scale: cfgScale,
-            clip_guidance_preset: clipGuidancePreset,
-            sampler,
-            samples,
-            seed,
-            steps,
-            style_preset: stylePreset,
-        },
-        failedResponseHandler: StabilityError_js_1.failedStabilityCallResponseHandler,
-        successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)(stabilityImageGenerationResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/stability/StabilityImageGenerationModel.d.ts

@@ -6,6 +6,39 @@ import { PromptTemplate } from "../../model-function/PromptTemplate.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
 import { PromptTemplateImageGenerationModel } from "../../model-function/generate-image/PromptTemplateImageGenerationModel.js";
 import { StabilityImageGenerationPrompt } from "./StabilityImageGenerationPrompt.js";
+declare const stabilityImageGenerationModels: readonly ["stable-diffusion-v1-6", "stable-diffusion-xl-1024-v1-0"];
+export type StabilityImageGenerationModelType = (typeof stabilityImageGenerationModels)[number] | (string & {});
+export type StabilityImageGenerationStylePreset = "3d-model" | "analog-film" | "anime" | "cinematic" | "comic-book" | "digital-art" | "enhance" | "fantasy-art" | "isometric" | "line-art" | "low-poly" | "modeling-compound" | "neon-punk" | "origami" | "photographic" | "pixel-art" | "tile-texture";
+export type StabilityImageGenerationSampler = "DDIM" | "DDPM" | "K_DPMPP_2M" | "K_DPMPP_2S_ANCESTRAL" | "K_DPM_2" | "K_DPM_2_ANCESTRAL" | "K_EULER" | "K_EULER_ANCESTRAL" | "K_HEUN" | "K_LMS";
+export type StabilityClipGuidancePreset = "FAST_BLUE" | "FAST_GREEN" | "NONE" | "SIMPLE" | "SLOW" | "SLOWER" | "SLOWEST";
+export interface StabilityImageGenerationSettings extends ImageGenerationModelSettings {
+    api?: ApiConfiguration;
+    model: StabilityImageGenerationModelType;
+    height?: number;
+    width?: number;
+    /**
+     * How strictly the diffusion process adheres to the prompt text (higher values keep your image closer to your prompt)
+     */
+    cfgScale?: number;
+    clipGuidancePreset?: StabilityClipGuidancePreset;
+    /**
+     * Which sampler to use for the diffusion process.
+     * If this value is omitted we'll automatically select an appropriate sampler for you.
+     */
+    sampler?: StabilityImageGenerationSampler;
+    /**
+     * Random noise seed (omit this option or use 0 for a random seed).
+     */
+    seed?: number;
+    /**
+     * Number of diffusion steps to run.
+     */
+    steps?: number;
+    /**
+     * Pass in a style preset to guide the image model towards a particular style.
+     */
+    stylePreset?: StabilityImageGenerationStylePreset;
+}
 /**
  * Create an image generation model that calls the Stability AI image generation API.
  *
@@ -13,13 +46,12 @@ import { StabilityImageGenerationPrompt } from "./StabilityImageGenerationPrompt
  *
  * @example
  * const image = await generateImage(
- *   new StabilityImageGenerationModel({
- *     model: "stable-diffusion-512-v2-1",
+ *   stability.ImageGenerator({
+ *     model: "stable-diffusion-v1-6",
  *     cfgScale: 7,
  *     clipGuidancePreset: "FAST_BLUE",
  *     height: 512,
  *     width: 512,
- *     samples: 1,
  *     steps: 30,
  *   })
  *   [
@@ -34,7 +66,7 @@ export declare class StabilityImageGenerationModel extends AbstractModel<Stabili
     get modelName(): StabilityImageGenerationModelType;
     callAPI(input: StabilityImageGenerationPrompt, options?: FunctionOptions): Promise<StabilityImageGenerationResponse>;
     get settingsForEvent(): Partial<StabilityImageGenerationSettings>;
-    doGenerateImage(prompt: StabilityImageGenerationPrompt, options?: FunctionOptions): Promise<{
+    doGenerateImages(prompt: StabilityImageGenerationPrompt, options?: FunctionOptions): Promise<{
         response: {
             artifacts: {
                 base64: string;
@@ -42,27 +74,12 @@ export declare class StabilityImageGenerationModel extends AbstractModel<Stabili
                 finishReason: "SUCCESS" | "ERROR" | "CONTENT_FILTERED";
             }[];
         };
-        base64Image: string;
+        base64Images: string[];
     }>;
     withTextPrompt(): PromptTemplateImageGenerationModel<string, StabilityImageGenerationPrompt, StabilityImageGenerationSettings, this>;
     withPromptTemplate<INPUT_PROMPT>(promptTemplate: PromptTemplate<INPUT_PROMPT, StabilityImageGenerationPrompt>): PromptTemplateImageGenerationModel<INPUT_PROMPT, StabilityImageGenerationPrompt, StabilityImageGenerationSettings, this>;
     withSettings(additionalSettings: StabilityImageGenerationSettings): this;
 }
-declare const stabilityImageGenerationModels: readonly ["stable-diffusion-v1-5", "stable-diffusion-512-v2-1", "stable-diffusion-xl-1024-v0-9", "stable-diffusion-xl-1024-v1-0"];
-export type StabilityImageGenerationModelType = (typeof stabilityImageGenerationModels)[number] | (string & {});
-export interface StabilityImageGenerationSettings extends ImageGenerationModelSettings {
-    api?: ApiConfiguration;
-    model: StabilityImageGenerationModelType;
-    height?: number;
-    width?: number;
-    cfgScale?: number;
-    clipGuidancePreset?: string;
-    sampler?: StabilityImageGenerationSampler;
-    samples?: number;
-    seed?: number;
-    steps?: number;
-    stylePreset?: StabilityImageGenerationStylePreset;
-}
 declare const stabilityImageGenerationResponseSchema: z.ZodObject<{
     artifacts: z.ZodArray<z.ZodObject<{
         base64: z.ZodString;
@@ -91,6 +108,4 @@ declare const stabilityImageGenerationResponseSchema: z.ZodObject<{
     }[];
 }>;
 export type StabilityImageGenerationResponse = z.infer<typeof stabilityImageGenerationResponseSchema>;
-export type StabilityImageGenerationStylePreset = "enhance" | "anime" | "photographic" | "digital-art" | "comic-book" | "fantasy-art" | "line-art" | "analog-film" | "neon-punk" | "isometric" | "low-poly" | "origami" | "modeling-compound" | "cinematic" | "3d-model" | "pixel-art" | "tile-texture";
-export type StabilityImageGenerationSampler = "DDIM" | "DDPM" | "K_DPMPP_2M" | "K_DPMPP_2S_ANCESTRAL" | "K_DPM_2" | "K_DPM_2_ANCESTRAL" | "K_EULER" | "K_EULER_ANCESTRAL" | "K_HEUN" | "K_LMS";
 export {};

package/model-provider/stability/StabilityImageGenerationModel.js

@@ -6,6 +6,10 @@ import { PromptTemplateImageGenerationModel } from "../../model-function/generat
 import { StabilityApiConfiguration } from "./StabilityApiConfiguration.js";
 import { failedStabilityCallResponseHandler } from "./StabilityError.js";
 import { mapBasicPromptToStabilityFormat, } from "./StabilityImageGenerationPrompt.js";
+const stabilityImageGenerationModels = [
+    "stable-diffusion-v1-6",
+    "stable-diffusion-xl-1024-v1-0",
+];
 /**
  * Create an image generation model that calls the Stability AI image generation API.
  *
@@ -13,13 +17,12 @@ import { mapBasicPromptToStabilityFormat, } from "./StabilityImageGenerationProm
  *
  * @example
  * const image = await generateImage(
- *   new StabilityImageGenerationModel({
- *     model: "stable-diffusion-512-v2-1",
+ *   stability.ImageGenerator({
+ *     model: "stable-diffusion-v1-6",
  *     cfgScale: 7,
  *     clipGuidancePreset: "FAST_BLUE",
  *     height: 512,
  *     width: 512,
- *     samples: 1,
  *     steps: 30,
  *   })
  *   [
@@ -42,37 +45,50 @@ export class StabilityImageGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(input, options) {
+        const api = this.settings.api ?? new StabilityApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return callWithRetryAndThrottle({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callStabilityImageGenerationAPI({
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                engineId: this.settings.model,
-                textPrompts: input,
+            call: async () => postJsonToApi({
+                url: api.assembleUrl(`/generation/${this.settings.model}/text-to-image`),
+                headers: api.headers,
+                body: {
+                    height: this.settings.height,
+                    width: this.settings.width,
+                    text_prompts: input,
+                    cfg_scale: this.settings.cfgScale,
+                    clip_guidance_preset: this.settings.clipGuidancePreset,
+                    sampler: this.settings.sampler,
+                    samples: this.settings.numberOfGenerations,
+                    seed: this.settings.seed,
+                    steps: this.settings.steps,
+                    style_preset: this.settings.stylePreset,
+                },
+                failedResponseHandler: failedStabilityCallResponseHandler,
+                successfulResponseHandler: createJsonResponseHandler(stabilityImageGenerationResponseSchema),
+                abortSignal,
             }),
         });
     }
     get settingsForEvent() {
-        const eventSettingProperties = [
-            "baseUrl",
-            "height",
-            "width",
-            "cfgScale",
-            "clipGuidancePreset",
-            "sampler",
-            "samples",
-            "seed",
-            "steps",
-            "stylePreset",
-        ];
-        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+        return {
+            numberOfGenerations: this.settings.numberOfGenerations,
+            height: this.settings.height,
+            width: this.settings.width,
+            cfgScale: this.settings.cfgScale,
+            clipGuidancePreset: this.settings.clipGuidancePreset,
+            sampler: this.settings.sampler,
+            seed: this.settings.seed,
+            steps: this.settings.steps,
+            stylePreset: this.settings.stylePreset,
+        };
     }
-    async doGenerateImage(prompt, options) {
+    async doGenerateImages(prompt, options) {
         const response = await this.callAPI(prompt, options);
         return {
             response,
-            base64Image: response.artifacts[0].base64,
+            base64Images: response.artifacts.map((artifact) => artifact.base64),
         };
     }
     withTextPrompt() {
@@ -88,12 +104,6 @@ export class StabilityImageGenerationModel extends AbstractModel {
         return new StabilityImageGenerationModel(Object.assign({}, this.settings, additionalSettings));
     }
 }
-const stabilityImageGenerationModels = [
-    "stable-diffusion-v1-5",
-    "stable-diffusion-512-v2-1",
-    "stable-diffusion-xl-1024-v0-9",
-    "stable-diffusion-xl-1024-v1-0",
-];
 const stabilityImageGenerationResponseSchema = z.object({
     artifacts: z.array(z.object({
         base64: z.string(),
@@ -101,24 +111,3 @@ const stabilityImageGenerationResponseSchema = z.object({
         finishReason: z.enum(["SUCCESS", "ERROR", "CONTENT_FILTERED"]),
     })),
 });
-async function callStabilityImageGenerationAPI({ api = new StabilityApiConfiguration(), abortSignal, engineId, height, width, textPrompts, cfgScale, clipGuidancePreset, sampler, samples, seed, steps, stylePreset, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/generation/${engineId}/text-to-image`),
-        headers: api.headers,
-        body: {
-            height,
-            width,
-            text_prompts: textPrompts,
-            cfg_scale: cfgScale,
-            clip_guidance_preset: clipGuidancePreset,
-            sampler,
-            samples,
-            seed,
-            steps,
-            style_preset: stylePreset,
-        },
-        failedResponseHandler: failedStabilityCallResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler(stabilityImageGenerationResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/stability/index.cjs

@@ -26,10 +26,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stability = exports.StabilityError = void 0;
+exports.stability = void 0;
 __exportStar(require("./StabilityApiConfiguration.cjs"), exports);
-var StabilityError_js_1 = require("./StabilityError.cjs");
-Object.defineProperty(exports, "StabilityError", { enumerable: true, get: function () { return StabilityError_js_1.StabilityError; } });
 exports.stability = __importStar(require("./StabilityFacade.cjs"));
 __exportStar(require("./StabilityImageGenerationModel.cjs"), exports);
 __exportStar(require("./StabilityImageGenerationPrompt.cjs"), exports);

package/model-provider/stability/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./StabilityApiConfiguration.js";
-export { StabilityError, StabilityErrorData } from "./StabilityError.js";
+export { StabilityErrorData } from "./StabilityError.js";
 export * as stability from "./StabilityFacade.js";
 export * from "./StabilityImageGenerationModel.js";
 export * from "./StabilityImageGenerationPrompt.js";

package/model-provider/stability/index.js

@@ -1,5 +1,4 @@
 export * from "./StabilityApiConfiguration.js";
-export { StabilityError } from "./StabilityError.js";
 export * as stability from "./StabilityFacade.js";
 export * from "./StabilityImageGenerationModel.js";
 export * from "./StabilityImageGenerationPrompt.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building multi-modal AI applications.",
-  "version": "0.101.0",
+  "version": "0.102.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [