modelfusion 0.0.44

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

@@ -0,0 +1,38 @@
+import z from "zod";
+import { BasicTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
+import { Run } from "../../run/Run.js";
+import { RetryFunction } from "../../util/api/RetryFunction.js";
+import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
+export interface LlamaCppTokenizerSettings {
+    baseUrl?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+}
+/**
+ * Tokenizer for LlamaCpp.
+
+ * @example
+ * const tokenizer = new LlamaCppTokenizer();
+ *
+ * const text = "At first, Nox didn't know what to do with the pup.";
+ *
+ * const tokenCount = await countTokens(tokenizer, text);
+ * const tokens = await tokenizer.tokenize(text);
+ * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
+ * const reconstructedText = await tokenizer.detokenize(tokens);
+ */
+export declare class LlamaCppTokenizer implements BasicTokenizer {
+    readonly settings: LlamaCppTokenizerSettings;
+    constructor(settings?: LlamaCppTokenizerSettings);
+    callTokenizeAPI(text: string, context?: Run): Promise<LlamaCppTokenizationResponse>;
+    tokenize(text: string): Promise<number[]>;
+}
+declare const llamaCppTokenizationResponseSchema: z.ZodObject<{
+    tokens: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    tokens: number[];
+}, {
+    tokens: number[];
+}>;
+export type LlamaCppTokenizationResponse = z.infer<typeof llamaCppTokenizationResponseSchema>;
+export {};

package/model-provider/llamacpp/LlamaCppTokenizer.js

@@ -0,0 +1,57 @@
+import z from "zod";
+import { callWithRetryAndThrottle } from "../../util/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../util/api/postToApi.js";
+import { failedLlamaCppCallResponseHandler } from "./LlamaCppError.js";
+/**
+ * Tokenizer for LlamaCpp.
+
+ * @example
+ * const tokenizer = new LlamaCppTokenizer();
+ *
+ * const text = "At first, Nox didn't know what to do with the pup.";
+ *
+ * const tokenCount = await countTokens(tokenizer, text);
+ * const tokens = await tokenizer.tokenize(text);
+ * const tokensAndTokenTexts = await tokenizer.tokenizeWithTexts(text);
+ * const reconstructedText = await tokenizer.detokenize(tokens);
+ */
+export class LlamaCppTokenizer {
+    constructor(settings = {}) {
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.settings = settings;
+    }
+    async callTokenizeAPI(text, context) {
+        return callWithRetryAndThrottle({
+            retry: this.settings.retry,
+            throttle: this.settings.throttle,
+            call: async () => callLlamaCppTokenizeAPI({
+                abortSignal: context?.abortSignal,
+                text,
+                ...this.settings,
+            }),
+        });
+    }
+    async tokenize(text) {
+        const response = await this.callTokenizeAPI(text);
+        return response.tokens;
+    }
+}
+const llamaCppTokenizationResponseSchema = z.object({
+    tokens: z.array(z.number()),
+});
+async function callLlamaCppTokenizeAPI({ baseUrl = "http://127.0.0.1:8080", abortSignal, text, }) {
+    return postJsonToApi({
+        url: `${baseUrl}/tokenize`,
+        body: {
+            content: text,
+        },
+        failedResponseHandler: failedLlamaCppCallResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(llamaCppTokenizationResponseSchema),
+        abortSignal,
+    });
+}

package/model-provider/llamacpp/index.cjs

@@ -0,0 +1,22 @@
+"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.LlamaCppError = void 0;
+var LlamaCppError_js_1 = require("./LlamaCppError.cjs");
+Object.defineProperty(exports, "LlamaCppError", { enumerable: true, get: function () { return LlamaCppError_js_1.LlamaCppError; } });
+__exportStar(require("./LlamaCppTextEmbeddingModel.cjs"), exports);
+__exportStar(require("./LlamaCppTextGenerationModel.cjs"), exports);
+__exportStar(require("./LlamaCppTokenizer.cjs"), exports);

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

@@ -0,0 +1,4 @@
+export { LlamaCppError, LlamaCppErrorData } from "./LlamaCppError.js";
+export * from "./LlamaCppTextEmbeddingModel.js";
+export * from "./LlamaCppTextGenerationModel.js";
+export * from "./LlamaCppTokenizer.js";

package/model-provider/llamacpp/index.js

@@ -0,0 +1,4 @@
+export { LlamaCppError } from "./LlamaCppError.js";
+export * from "./LlamaCppTextEmbeddingModel.js";
+export * from "./LlamaCppTextGenerationModel.js";
+export * from "./LlamaCppTokenizer.js";

package/model-provider/openai/OpenAICostCalculator.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICostCalculator = void 0;
+const OpenAIImageGenerationModel_js_1 = require("./OpenAIImageGenerationModel.cjs");
+const OpenAITextEmbeddingModel_js_1 = require("./OpenAITextEmbeddingModel.cjs");
+const OpenAITextGenerationModel_js_1 = require("./OpenAITextGenerationModel.cjs");
+const OpenAITranscriptionModel_js_1 = require("./OpenAITranscriptionModel.cjs");
+const OpenAIChatModel_js_1 = require("./chat/OpenAIChatModel.cjs");
+class OpenAICostCalculator {
+    constructor() {
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+    }
+    async calculateCostInMillicents(call) {
+        const type = call.type;
+        const model = call.model.modelName;
+        switch (type) {
+            case "image-generation": {
+                return (0, OpenAIImageGenerationModel_js_1.calculateOpenAIImageGenerationCostInMillicents)({
+                    settings: call.settings,
+                });
+            }
+            case "text-embedding": {
+                if (model == null) {
+                    return null;
+                }
+                if ((0, OpenAITextEmbeddingModel_js_1.isOpenAIEmbeddingModel)(model)) {
+                    return (0, OpenAITextEmbeddingModel_js_1.calculateOpenAIEmbeddingCostInMillicents)({
+                        model,
+                        responses: call.response,
+                    });
+                }
+                break;
+            }
+            case "json-generation":
+            case "text-generation": {
+                if (model == null) {
+                    return null;
+                }
+                if ((0, OpenAIChatModel_js_1.isOpenAIChatModel)(model)) {
+                    return (0, OpenAIChatModel_js_1.calculateOpenAIChatCostInMillicents)({
+                        model,
+                        response: call.response,
+                    });
+                }
+                if ((0, OpenAITextGenerationModel_js_1.isOpenAITextGenerationModel)(model)) {
+                    return (0, OpenAITextGenerationModel_js_1.calculateOpenAITextGenerationCostInMillicents)({
+                        model,
+                        response: call.response,
+                    });
+                }
+                break;
+            }
+            case "transcription": {
+                if (model == null) {
+                    return null;
+                }
+                return (0, OpenAITranscriptionModel_js_1.calculateOpenAITranscriptionCostInMillicents)({
+                    model: model,
+                    response: call.response,
+                });
+            }
+        }
+        return null;
+    }
+}
+exports.OpenAICostCalculator = OpenAICostCalculator;

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

@@ -0,0 +1,6 @@
+import { CostCalculator } from "../../cost/CostCalculator.js";
+import { SuccessfulModelCall } from "../../model-function/SuccessfulModelCall.js";
+export declare class OpenAICostCalculator implements CostCalculator {
+    readonly provider = "openai";
+    calculateCostInMillicents(call: SuccessfulModelCall): Promise<number | null>;
+}

package/model-provider/openai/OpenAICostCalculator.js

@@ -0,0 +1,67 @@
+import { calculateOpenAIImageGenerationCostInMillicents, } from "./OpenAIImageGenerationModel.js";
+import { calculateOpenAIEmbeddingCostInMillicents, isOpenAIEmbeddingModel, } from "./OpenAITextEmbeddingModel.js";
+import { calculateOpenAITextGenerationCostInMillicents, isOpenAITextGenerationModel, } from "./OpenAITextGenerationModel.js";
+import { calculateOpenAITranscriptionCostInMillicents, } from "./OpenAITranscriptionModel.js";
+import { calculateOpenAIChatCostInMillicents, isOpenAIChatModel, } from "./chat/OpenAIChatModel.js";
+export class OpenAICostCalculator {
+    constructor() {
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+    }
+    async calculateCostInMillicents(call) {
+        const type = call.type;
+        const model = call.model.modelName;
+        switch (type) {
+            case "image-generation": {
+                return calculateOpenAIImageGenerationCostInMillicents({
+                    settings: call.settings,
+                });
+            }
+            case "text-embedding": {
+                if (model == null) {
+                    return null;
+                }
+                if (isOpenAIEmbeddingModel(model)) {
+                    return calculateOpenAIEmbeddingCostInMillicents({
+                        model,
+                        responses: call.response,
+                    });
+                }
+                break;
+            }
+            case "json-generation":
+            case "text-generation": {
+                if (model == null) {
+                    return null;
+                }
+                if (isOpenAIChatModel(model)) {
+                    return calculateOpenAIChatCostInMillicents({
+                        model,
+                        response: call.response,
+                    });
+                }
+                if (isOpenAITextGenerationModel(model)) {
+                    return calculateOpenAITextGenerationCostInMillicents({
+                        model,
+                        response: call.response,
+                    });
+                }
+                break;
+            }
+            case "transcription": {
+                if (model == null) {
+                    return null;
+                }
+                return calculateOpenAITranscriptionCostInMillicents({
+                    model: model,
+                    response: call.response,
+                });
+            }
+        }
+        return null;
+    }
+}

package/model-provider/openai/OpenAIError.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failedOpenAICallResponseHandler = exports.OpenAIError = exports.openAIErrorDataSchema = 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.openAIErrorDataSchema = zod_1.z.object({
+    error: zod_1.z.object({
+        message: zod_1.z.string(),
+        type: zod_1.z.string(),
+        param: zod_1.z.any().nullable(),
+        code: zod_1.z.string().nullable(),
+    }),
+});
+class OpenAIError extends ApiCallError_js_1.ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.error.message, }) {
+        super({
+            message,
+            statusCode,
+            requestBodyValues,
+            url,
+            isRetryable: (statusCode === 429 &&
+                // insufficient_quota is also reported as a 429, but it's not retryable:
+                data.error.type !== "insufficient_quota") ||
+                statusCode >= 500,
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+exports.OpenAIError = OpenAIError;
+const failedOpenAICallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = exports.openAIErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+    return new OpenAIError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};
+exports.failedOpenAICallResponseHandler = failedOpenAICallResponseHandler;

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+export declare const openAIErrorDataSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        type: z.ZodString;
+        param: z.ZodNullable<z.ZodAny>;
+        code: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: string | null;
+        message: string;
+        type: string;
+        param?: any;
+    }, {
+        code: string | null;
+        message: string;
+        type: string;
+        param?: any;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: string | null;
+        message: string;
+        type: string;
+        param?: any;
+    };
+}, {
+    error: {
+        code: string | null;
+        message: string;
+        type: string;
+        param?: any;
+    };
+}>;
+export type OpenAIErrorData = z.infer<typeof openAIErrorDataSchema>;
+export declare class OpenAIError extends ApiCallError {
+    readonly data: OpenAIErrorData;
+    constructor({ data, statusCode, url, requestBodyValues, message, }: {
+        message?: string;
+        statusCode: number;
+        url: string;
+        requestBodyValues: unknown;
+        data: OpenAIErrorData;
+    });
+}
+export declare const failedOpenAICallResponseHandler: ResponseHandler<ApiCallError>;

package/model-provider/openai/OpenAIError.js

@@ -0,0 +1,42 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { ApiCallError } from "../../util/api/ApiCallError.js";
+export const openAIErrorDataSchema = z.object({
+    error: z.object({
+        message: z.string(),
+        type: z.string(),
+        param: z.any().nullable(),
+        code: z.string().nullable(),
+    }),
+});
+export class OpenAIError extends ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.error.message, }) {
+        super({
+            message,
+            statusCode,
+            requestBodyValues,
+            url,
+            isRetryable: (statusCode === 429 &&
+                // insufficient_quota is also reported as a 429, but it's not retryable:
+                data.error.type !== "insufficient_quota") ||
+                statusCode >= 500,
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+export const failedOpenAICallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = openAIErrorDataSchema.parse(SecureJSON.parse(responseBody));
+    return new OpenAIError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};

package/model-provider/openai/OpenAIImageGenerationModel.cjs

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIImageGenerationResponseFormat = exports.OpenAIImageGenerationModel = exports.calculateOpenAIImageGenerationCostInMillicents = 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 OpenAIError_js_1 = require("./OpenAIError.cjs");
+/**
+ * @see https://openai.com/pricing
+ */
+const sizeToCostInMillicents = {
+    "1024x1024": 2000,
+    "512x512": 1800,
+    "256x256": 1600,
+};
+const calculateOpenAIImageGenerationCostInMillicents = ({ settings, }) => (settings.n ?? 1) * sizeToCostInMillicents[settings.size ?? "1024x1024"];
+exports.calculateOpenAIImageGenerationCostInMillicents = calculateOpenAIImageGenerationCostInMillicents;
+/**
+ * Create an image generation model that calls the OpenAI AI image creation API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/images/create
+ *
+ * @example
+ * const { image } = await generateImage(
+ *   new OpenAIImageGenerationModel({ size: "512x512" }),
+ *   "the wicked witch of the west in the style of early 19th century painting"
+ * );
+ */
+class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "openai"
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    get apiKey() {
+        const apiKey = this.settings.apiKey ?? process.env.OPENAI_API_KEY;
+        if (apiKey == null) {
+            throw new Error(`OpenAI API key is missing. Pass it as an argument to the constructor or set it as an environment variable named OPENAI_API_KEY.`);
+        }
+        return apiKey;
+    }
+    async callAPI(prompt, options) {
+        const run = options?.run;
+        const settings = options?.settings;
+        const responseFormat = options?.responseFormat;
+        const callSettings = Object.assign({
+            apiKey: this.apiKey,
+            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
+        }, this.settings, settings, {
+            abortSignal: run?.abortSignal,
+            prompt,
+            responseFormat,
+        });
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: callSettings.retry,
+            throttle: callSettings.throttle,
+            call: async () => callOpenAIImageGenerationAPI(callSettings),
+        });
+    }
+    generateImageResponse(prompt, options) {
+        return this.callAPI(prompt, {
+            responseFormat: exports.OpenAIImageGenerationResponseFormat.base64Json,
+            functionId: options?.functionId,
+            settings: options?.settings,
+            run: options?.run,
+        });
+    }
+    extractBase64Image(response) {
+        return response.data[0].b64_json;
+    }
+    withSettings(additionalSettings) {
+        return new OpenAIImageGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.OpenAIImageGenerationModel = OpenAIImageGenerationModel;
+const openAIImageGenerationUrlSchema = zod_1.z.object({
+    created: zod_1.z.number(),
+    data: zod_1.z.array(zod_1.z.object({
+        url: zod_1.z.string(),
+    })),
+});
+const openAIImageGenerationBase64JsonSchema = zod_1.z.object({
+    created: zod_1.z.number(),
+    data: zod_1.z.array(zod_1.z.object({
+        b64_json: zod_1.z.string(),
+    })),
+});
+exports.OpenAIImageGenerationResponseFormat = {
+    url: {
+        type: "url",
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(openAIImageGenerationUrlSchema),
+    },
+    base64Json: {
+        type: "b64_json",
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(openAIImageGenerationBase64JsonSchema),
+    },
+};
+async function callOpenAIImageGenerationAPI({ baseUrl = "https://api.openai.com/v1", abortSignal, apiKey, prompt, n, size, responseFormat, user, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: `${baseUrl}/images/generations`,
+        apiKey,
+        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

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
+import { ResponseHandler } from "../../util/api/postToApi.js";
+import { OpenAIModelSettings } from "./OpenAIModelSettings.js";
+export interface OpenAIImageGenerationCallSettings {
+    n?: number;
+    size?: "256x256" | "512x512" | "1024x1024";
+}
+export declare const calculateOpenAIImageGenerationCostInMillicents: ({ settings, }: {
+    settings: OpenAIImageGenerationSettings;
+}) => number;
+export interface OpenAIImageGenerationSettings extends ImageGenerationModelSettings, OpenAIImageGenerationCallSettings, OpenAIModelSettings {
+    isUserIdForwardingEnabled?: boolean;
+}
+/**
+ * Create an image generation model that calls the OpenAI AI image creation API.
+ *
+ * @see https://platform.openai.com/docs/api-reference/images/create
+ *
+ * @example
+ * const { image } = await generateImage(
+ *   new OpenAIImageGenerationModel({ size: "512x512" }),
+ *   "the wicked witch of the west in the style of early 19th century painting"
+ * );
+ */
+export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImageGenerationSettings> implements ImageGenerationModel<string, OpenAIImageGenerationBase64JsonResponse, OpenAIImageGenerationSettings> {
+    constructor(settings: OpenAIImageGenerationSettings);
+    readonly provider: "openai";
+    readonly modelName: null;
+    private get apiKey();
+    callAPI<RESULT>(prompt: string, options: {
+        responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
+    } & FunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
+        user?: string;
+    }>>): Promise<RESULT>;
+    generateImageResponse(prompt: string, options?: FunctionOptions<OpenAIImageGenerationSettings>): Promise<{
+        data: {
+            b64_json: string;
+        }[];
+        created: number;
+    }>;
+    extractBase64Image(response: OpenAIImageGenerationBase64JsonResponse): string;
+    withSettings(additionalSettings: Partial<OpenAIImageGenerationSettings>): this;
+}
+export type OpenAIImageGenerationResponseFormatType<T> = {
+    type: "b64_json" | "url";
+    handler: ResponseHandler<T>;
+};
+declare const openAIImageGenerationUrlSchema: z.ZodObject<{
+    created: z.ZodNumber;
+    data: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        url: string;
+    }[];
+    created: number;
+}, {
+    data: {
+        url: string;
+    }[];
+    created: number;
+}>;
+export type OpenAIImageGenerationUrlResponse = z.infer<typeof openAIImageGenerationUrlSchema>;
+declare const openAIImageGenerationBase64JsonSchema: z.ZodObject<{
+    created: z.ZodNumber;
+    data: z.ZodArray<z.ZodObject<{
+        b64_json: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        b64_json: string;
+    }, {
+        b64_json: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        b64_json: string;
+    }[];
+    created: number;
+}, {
+    data: {
+        b64_json: string;
+    }[];
+    created: number;
+}>;
+export type OpenAIImageGenerationBase64JsonResponse = z.infer<typeof openAIImageGenerationBase64JsonSchema>;
+export declare const OpenAIImageGenerationResponseFormat: {
+    url: {
+        type: "url";
+        handler: ResponseHandler<{
+            data: {
+                url: string;
+            }[];
+            created: number;
+        }>;
+    };
+    base64Json: {
+        type: "b64_json";
+        handler: ResponseHandler<{
+            data: {
+                b64_json: string;
+            }[];
+            created: number;
+        }>;
+    };
+};
+export {};