modelfusion 0.0.44

package/model-provider/openai/chat/OpenAIChatStreamIterable.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIChatFullDeltaIterableQueue = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const AsyncQueue_js_1 = require("../../../model-function/generate-text/AsyncQueue.cjs");
+const parseEventSourceReadableStream_js_1 = require("../../../model-function/generate-text/parseEventSourceReadableStream.cjs");
+const chatResponseStreamEventSchema = zod_1.z.object({
+    choices: zod_1.z.array(zod_1.z.object({
+        delta: zod_1.z.object({
+            role: zod_1.z.enum(["assistant", "user"]).optional(),
+            content: zod_1.z.string().nullable().optional(),
+            function_call: zod_1.z
+                .object({
+                name: zod_1.z.string().optional(),
+                arguments: zod_1.z.string().optional(),
+            })
+                .optional(),
+        }),
+        finish_reason: zod_1.z.enum(["stop", "length"]).nullable(),
+        index: zod_1.z.number(),
+    })),
+    created: zod_1.z.number(),
+    id: zod_1.z.string(),
+    model: zod_1.z.string(),
+    object: zod_1.z.string(),
+});
+async function createOpenAIChatFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    const streamDelta = [];
+    // process the stream asynchonously (no 'await' on purpose):
+    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
+        stream,
+        callback: (event) => {
+            if (event.type !== "event") {
+                return;
+            }
+            const data = event.data;
+            if (data === "[DONE]") {
+                queue.close();
+                return;
+            }
+            try {
+                const json = secure_json_parse_1.default.parse(data);
+                const parseResult = chatResponseStreamEventSchema.safeParse(json);
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    queue.close();
+                    return;
+                }
+                const event = parseResult.data;
+                for (let i = 0; i < event.choices.length; i++) {
+                    const eventChoice = event.choices[i];
+                    const delta = eventChoice.delta;
+                    if (streamDelta[i] == null) {
+                        streamDelta[i] = {
+                            role: undefined,
+                            content: "",
+                            isComplete: false,
+                            delta,
+                        };
+                    }
+                    const choice = streamDelta[i];
+                    choice.delta = delta;
+                    if (eventChoice.finish_reason != null) {
+                        choice.isComplete = true;
+                    }
+                    if (delta.content != undefined) {
+                        choice.content += delta.content;
+                    }
+                    if (delta.function_call != undefined) {
+                        if (choice.function_call == undefined) {
+                            choice.function_call = {
+                                name: "",
+                                arguments: "",
+                            };
+                        }
+                        if (delta.function_call.name != undefined) {
+                            choice.function_call.name += delta.function_call.name;
+                        }
+                        if (delta.function_call.arguments != undefined) {
+                            choice.function_call.arguments += delta.function_call.arguments;
+                        }
+                    }
+                    if (delta.role != undefined) {
+                        choice.role = delta.role;
+                    }
+                }
+                // Since we're mutating the choices array in an async scenario,
+                // we need to make a deep copy:
+                const streamDeltaDeepCopy = JSON.parse(JSON.stringify(streamDelta));
+                queue.push({
+                    type: "delta",
+                    fullDelta: streamDeltaDeepCopy,
+                });
+            }
+            catch (error) {
+                queue.push({ type: "error", error });
+                queue.close();
+                return;
+            }
+        },
+    });
+    return queue;
+}
+exports.createOpenAIChatFullDeltaIterableQueue = createOpenAIChatFullDeltaIterableQueue;

package/model-provider/openai/chat/OpenAIChatStreamIterable.d.ts

@@ -0,0 +1,19 @@
+import { DeltaEvent } from "../../../model-function/generate-text/DeltaEvent.js";
+export type OpenAIChatDelta = Array<{
+    role: "assistant" | "user" | undefined;
+    content: string;
+    function_call?: {
+        name: string;
+        arguments: string;
+    };
+    isComplete: boolean;
+    delta: {
+        role?: "assistant" | "user";
+        content?: string | null;
+        function_call?: {
+            name?: string;
+            arguments?: string;
+        };
+    };
+}>;
+export declare function createOpenAIChatFullDeltaIterableQueue(stream: ReadableStream<Uint8Array>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;

package/model-provider/openai/chat/OpenAIChatStreamIterable.js

@@ -0,0 +1,105 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { AsyncQueue } from "../../../model-function/generate-text/AsyncQueue.js";
+import { parseEventSourceReadableStream } from "../../../model-function/generate-text/parseEventSourceReadableStream.js";
+const chatResponseStreamEventSchema = z.object({
+    choices: z.array(z.object({
+        delta: z.object({
+            role: z.enum(["assistant", "user"]).optional(),
+            content: z.string().nullable().optional(),
+            function_call: z
+                .object({
+                name: z.string().optional(),
+                arguments: z.string().optional(),
+            })
+                .optional(),
+        }),
+        finish_reason: z.enum(["stop", "length"]).nullable(),
+        index: z.number(),
+    })),
+    created: z.number(),
+    id: z.string(),
+    model: z.string(),
+    object: z.string(),
+});
+export async function createOpenAIChatFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue();
+    const streamDelta = [];
+    // process the stream asynchonously (no 'await' on purpose):
+    parseEventSourceReadableStream({
+        stream,
+        callback: (event) => {
+            if (event.type !== "event") {
+                return;
+            }
+            const data = event.data;
+            if (data === "[DONE]") {
+                queue.close();
+                return;
+            }
+            try {
+                const json = SecureJSON.parse(data);
+                const parseResult = chatResponseStreamEventSchema.safeParse(json);
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    queue.close();
+                    return;
+                }
+                const event = parseResult.data;
+                for (let i = 0; i < event.choices.length; i++) {
+                    const eventChoice = event.choices[i];
+                    const delta = eventChoice.delta;
+                    if (streamDelta[i] == null) {
+                        streamDelta[i] = {
+                            role: undefined,
+                            content: "",
+                            isComplete: false,
+                            delta,
+                        };
+                    }
+                    const choice = streamDelta[i];
+                    choice.delta = delta;
+                    if (eventChoice.finish_reason != null) {
+                        choice.isComplete = true;
+                    }
+                    if (delta.content != undefined) {
+                        choice.content += delta.content;
+                    }
+                    if (delta.function_call != undefined) {
+                        if (choice.function_call == undefined) {
+                            choice.function_call = {
+                                name: "",
+                                arguments: "",
+                            };
+                        }
+                        if (delta.function_call.name != undefined) {
+                            choice.function_call.name += delta.function_call.name;
+                        }
+                        if (delta.function_call.arguments != undefined) {
+                            choice.function_call.arguments += delta.function_call.arguments;
+                        }
+                    }
+                    if (delta.role != undefined) {
+                        choice.role = delta.role;
+                    }
+                }
+                // Since we're mutating the choices array in an async scenario,
+                // we need to make a deep copy:
+                const streamDeltaDeepCopy = JSON.parse(JSON.stringify(streamDelta));
+                queue.push({
+                    type: "delta",
+                    fullDelta: streamDeltaDeepCopy,
+                });
+            }
+            catch (error) {
+                queue.push({ type: "error", error });
+                queue.close();
+                return;
+            }
+        },
+    });
+    return queue;
+}

package/model-provider/openai/chat/countOpenAIChatMessageTokens.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countOpenAIChatPromptTokens = exports.countOpenAIChatMessageTokens = exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = exports.OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = void 0;
+const countTokens_js_1 = require("../../../model-function/tokenize-text/countTokens.cjs");
+const TikTokenTokenizer_js_1 = require("../TikTokenTokenizer.cjs");
+/**
+ * Prompt tokens that are included automatically for every full
+ * chat prompt (several messages) that is sent to OpenAI.
+ */
+exports.OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = 2;
+/**
+ * Prompt tokens that are included automatically for every
+ * message that is sent to OpenAI.
+ */
+exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = 5;
+async function countOpenAIChatMessageTokens({ message, model, }) {
+    return (exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT +
+        (await (0, countTokens_js_1.countTokens)(new TikTokenTokenizer_js_1.TikTokenTokenizer({ model }), message.content ?? "")));
+}
+exports.countOpenAIChatMessageTokens = countOpenAIChatMessageTokens;
+async function countOpenAIChatPromptTokens({ messages, model, }) {
+    let tokens = exports.OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT;
+    for (const message of messages) {
+        tokens += await countOpenAIChatMessageTokens({ message, model });
+    }
+    return tokens;
+}
+exports.countOpenAIChatPromptTokens = countOpenAIChatPromptTokens;

package/model-provider/openai/chat/countOpenAIChatMessageTokens.d.ts

@@ -0,0 +1,20 @@
+import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
+import { OpenAIChatModelType } from "./OpenAIChatModel.js";
+/**
+ * Prompt tokens that are included automatically for every full
+ * chat prompt (several messages) that is sent to OpenAI.
+ */
+export declare const OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = 2;
+/**
+ * Prompt tokens that are included automatically for every
+ * message that is sent to OpenAI.
+ */
+export declare const OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = 5;
+export declare function countOpenAIChatMessageTokens({ message, model, }: {
+    message: OpenAIChatMessage;
+    model: OpenAIChatModelType;
+}): Promise<number>;
+export declare function countOpenAIChatPromptTokens({ messages, model, }: {
+    messages: OpenAIChatMessage[];
+    model: OpenAIChatModelType;
+}): Promise<number>;

package/model-provider/openai/chat/countOpenAIChatMessageTokens.js

@@ -0,0 +1,23 @@
+import { countTokens } from "../../../model-function/tokenize-text/countTokens.js";
+import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
+/**
+ * Prompt tokens that are included automatically for every full
+ * chat prompt (several messages) that is sent to OpenAI.
+ */
+export const OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = 2;
+/**
+ * Prompt tokens that are included automatically for every
+ * message that is sent to OpenAI.
+ */
+export const OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = 5;
+export async function countOpenAIChatMessageTokens({ message, model, }) {
+    return (OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT +
+        (await countTokens(new TikTokenTokenizer({ model }), message.content ?? "")));
+}
+export async function countOpenAIChatPromptTokens({ messages, model, }) {
+    let tokens = OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT;
+    for (const message of messages) {
+        tokens += await countOpenAIChatMessageTokens({ message, model });
+    }
+    return tokens;
+}

package/model-provider/openai/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIChatFunctionPrompt = exports.OpenAIError = void 0;
+__exportStar(require("./OpenAICostCalculator.cjs"), exports);
+var OpenAIError_js_1 = require("./OpenAIError.cjs");
+Object.defineProperty(exports, "OpenAIError", { enumerable: true, get: function () { return OpenAIError_js_1.OpenAIError; } });
+__exportStar(require("./OpenAIImageGenerationModel.cjs"), exports);
+__exportStar(require("./OpenAIModelSettings.cjs"), exports);
+__exportStar(require("./OpenAITextEmbeddingModel.cjs"), exports);
+__exportStar(require("./OpenAITextGenerationModel.cjs"), exports);
+__exportStar(require("./OpenAITranscriptionModel.cjs"), exports);
+__exportStar(require("./TikTokenTokenizer.cjs"), exports);
+__exportStar(require("./chat/OpenAIChatMessage.cjs"), exports);
+__exportStar(require("./chat/OpenAIChatModel.cjs"), exports);
+var OpenAIChatPrompt_js_1 = require("./chat/OpenAIChatPrompt.cjs");
+Object.defineProperty(exports, "OpenAIChatFunctionPrompt", { enumerable: true, get: function () { return OpenAIChatPrompt_js_1.OpenAIChatFunctionPrompt; } });
+__exportStar(require("./chat/countOpenAIChatMessageTokens.cjs"), exports);

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

@@ -0,0 +1,13 @@
+export * from "./OpenAICostCalculator.js";
+export { OpenAIError, OpenAIErrorData } from "./OpenAIError.js";
+export * from "./OpenAIImageGenerationModel.js";
+export * from "./OpenAIModelSettings.js";
+export * from "./OpenAITextEmbeddingModel.js";
+export * from "./OpenAITextGenerationModel.js";
+export * from "./OpenAITranscriptionModel.js";
+export * from "./TikTokenTokenizer.js";
+export * from "./chat/OpenAIChatMessage.js";
+export * from "./chat/OpenAIChatModel.js";
+export { OpenAIChatFunctionPrompt, OpenAIFunctionDescription, } from "./chat/OpenAIChatPrompt.js";
+export { OpenAIChatDelta } from "./chat/OpenAIChatStreamIterable.js";
+export * from "./chat/countOpenAIChatMessageTokens.js";

package/model-provider/openai/index.js

@@ -0,0 +1,12 @@
+export * from "./OpenAICostCalculator.js";
+export { OpenAIError } from "./OpenAIError.js";
+export * from "./OpenAIImageGenerationModel.js";
+export * from "./OpenAIModelSettings.js";
+export * from "./OpenAITextEmbeddingModel.js";
+export * from "./OpenAITextGenerationModel.js";
+export * from "./OpenAITranscriptionModel.js";
+export * from "./TikTokenTokenizer.js";
+export * from "./chat/OpenAIChatMessage.js";
+export * from "./chat/OpenAIChatModel.js";
+export { OpenAIChatFunctionPrompt, } from "./chat/OpenAIChatPrompt.js";
+export * from "./chat/countOpenAIChatMessageTokens.js";

package/model-provider/stability/StabilityError.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failedStabilityCallResponseHandler = exports.StabilityError = exports.stabilityErrorDataSchema = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const ApiCallError_js_1 = require("../../util/api/ApiCallError.cjs");
+exports.stabilityErrorDataSchema = 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 = exports.stabilityErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+    return new StabilityError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};
+exports.failedStabilityCallResponseHandler = failedStabilityCallResponseHandler;

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+export declare const stabilityErrorDataSchema: z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>;
+export type StabilityErrorData = z.infer<typeof stabilityErrorDataSchema>;
+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>;

package/model-provider/stability/StabilityError.js

@@ -0,0 +1,28 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+export const stabilityErrorDataSchema = 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 = stabilityErrorDataSchema.parse(SecureJSON.parse(responseBody));
+    return new StabilityError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};

package/model-provider/stability/StabilityImageGenerationModel.cjs

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StabilityImageGenerationModel = void 0;
+const zod_1 = require("zod");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const callWithRetryAndThrottle_js_1 = require("../../util/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../util/api/postToApi.cjs");
+const StabilityError_js_1 = require("./StabilityError.cjs");
+/**
+ * Create an image generation model that calls the Stability AI image generation API.
+ *
+ * @see https://api.stability.ai/docs#tag/v1generation/operation/textToImage
+ *
+ * @example
+ * const { image } = await generateImage(
+ *   new StabilityImageGenerationModel({
+ *     model: "stable-diffusion-512-v2-1",
+ *     cfgScale: 7,
+ *     clipGuidancePreset: "FAST_BLUE",
+ *     height: 512,
+ *     width: 512,
+ *     samples: 1,
+ *     steps: 30,
+ *   })
+ *   [
+ *     { text: "the wicked witch of the west" },
+ *     { text: "style of early 19th century painting", weight: 0.5 },
+ *   ]
+ * );
+ */
+class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "stability"
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.STABILITY_API_KEY;
+        if (apiKey == null) {
+            throw new Error("No API key provided. Either pass an API key to the constructor or set the STABILITY_API_KEY environment variable.");
+        }
+        return apiKey;
+    }
+    async callAPI(input, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            engineId: this.settings.model,
+            textPrompts: input,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callStabilityImageGenerationAPI(callSettings),
+        });
+    }
+    generateImageResponse(prompt, options) {
+        return this.callAPI(prompt, options);
+    }
+    extractBase64Image(response) {
+        return response.artifacts[0].base64;
+    }
+    withSettings(additionalSettings) {
+        return new StabilityImageGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.StabilityImageGenerationModel = StabilityImageGenerationModel;
+const stabilityImageGenerationResponseSchema = zod_1.z.object({
+    artifacts: zod_1.z.array(zod_1.z.object({
+        base64: zod_1.z.string(),
+        seed: zod_1.z.number(),
+        finishReason: zod_1.z.enum(["SUCCESS", "ERROR", "CONTENT_FILTERED"]),
+    })),
+});
+/**
+ * Call the Stability AI API for image generation.
+ *
+ * @see https://api.stability.ai/docs#tag/v1generation/operation/textToImage
+ *
+ * @example
+ * const imageResponse = await callStabilityImageGenerationAPI({
+ *   apiKey: STABILITY_API_KEY,
+ *   engineId: "stable-diffusion-512-v2-1",
+ *   textPrompts: [
+ *     { text: "the wicked witch of the west" },
+ *     { text: "style of early 19th century painting", weight: 0.5 },
+ *   ],
+ *   cfgScale: 7,
+ *   clipGuidancePreset: "FAST_BLUE",
+ *   height: 512,
+ *   width: 512,
+ *   samples: 1,
+ *   steps: 30,
+ * });
+ *
+ * imageResponse.artifacts.forEach((image, index) => {
+ *   fs.writeFileSync(
+ *     `./stability-image-example-${index}.png`,
+ *     Buffer.from(image.base64, "base64")
+ *   );
+ * });
+ */
+async function callStabilityImageGenerationAPI({ baseUrl = "https://api.stability.ai/v1", abortSignal, apiKey, engineId, height, width, textPrompts, cfgScale, clipGuidancePreset, sampler, samples, seed, steps, stylePreset, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/generation/${engineId}/text-to-image`,
+        apiKey,
+        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,
+    });
+}