modelfusion 0.133.0 → 0.135.0

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

@@ -1,230 +0,0 @@
-import { z } from "zod";
-import { FunctionCallOptions } from "../../core/FunctionOptions.js";
-import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { ResponseHandler } from "../../core/api/postToApi.js";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
-import { TextGenerationFinishReason } from "../../model-function/generate-text/TextGenerationResult.js";
-export interface AbstractOpenAICompletionModelSettings extends TextGenerationModelSettings {
-    api?: ApiConfiguration;
-    model: string;
-    suffix?: string;
-    temperature?: number;
-    topP?: number;
-    logprobs?: number;
-    echo?: boolean;
-    presencePenalty?: number;
-    frequencyPenalty?: number;
-    bestOf?: number;
-    logitBias?: Record<number, number>;
-    seed?: number | null;
-    isUserIdForwardingEnabled?: boolean;
-}
-/**
- * Abstract completion model that calls an API that is compatible with the OpenAI completions API.
- *
- * @see https://platform.openai.com/docs/api-reference/completions/create
- */
-export declare abstract class AbstractOpenAICompletionModel<SETTINGS extends AbstractOpenAICompletionModelSettings> extends AbstractModel<SETTINGS> {
-    constructor(settings: SETTINGS);
-    callAPI<RESULT>(prompt: string, callOptions: FunctionCallOptions, options: {
-        responseFormat: OpenAITextResponseFormatType<RESULT>;
-    }): Promise<RESULT>;
-    doGenerateTexts(prompt: string, options: FunctionCallOptions): Promise<{
-        rawResponse: {
-            object: "text_completion";
-            model: string;
-            usage: {
-                prompt_tokens: number;
-                completion_tokens: number;
-                total_tokens: number;
-            };
-            id: string;
-            created: number;
-            choices: {
-                text: string;
-                index: number;
-                finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-                logprobs?: any;
-            }[];
-            system_fingerprint?: string | undefined;
-        };
-        textGenerationResults: {
-            finishReason: TextGenerationFinishReason;
-            text: string;
-        }[];
-        usage: {
-            promptTokens: number;
-            completionTokens: number;
-            totalTokens: number;
-        };
-    }>;
-    restoreGeneratedTexts(rawResponse: unknown): {
-        rawResponse: {
-            object: "text_completion";
-            model: string;
-            usage: {
-                prompt_tokens: number;
-                completion_tokens: number;
-                total_tokens: number;
-            };
-            id: string;
-            created: number;
-            choices: {
-                text: string;
-                index: number;
-                finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-                logprobs?: any;
-            }[];
-            system_fingerprint?: string | undefined;
-        };
-        textGenerationResults: {
-            finishReason: TextGenerationFinishReason;
-            text: string;
-        }[];
-        usage: {
-            promptTokens: number;
-            completionTokens: number;
-            totalTokens: number;
-        };
-    };
-    private processTextGenerationResponse;
-    private translateFinishReason;
-    doStreamText(prompt: string, options: FunctionCallOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
-        object: "text_completion";
-        model: string;
-        id: string;
-        created: number;
-        choices: {
-            text: string;
-            index: number;
-            finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-        }[];
-        system_fingerprint?: string | undefined;
-    }>>>;
-    extractTextDelta(delta: unknown): string | undefined;
-    withJsonOutput(): this;
-}
-declare const OpenAICompletionResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    choices: z.ZodArray<z.ZodObject<{
-        finish_reason: z.ZodNullable<z.ZodOptional<z.ZodEnum<["stop", "length", "content_filter"]>>>;
-        index: z.ZodNumber;
-        logprobs: z.ZodNullable<z.ZodAny>;
-        text: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        text: string;
-        index: number;
-        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-        logprobs?: any;
-    }, {
-        text: string;
-        index: number;
-        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-        logprobs?: any;
-    }>, "many">;
-    created: z.ZodNumber;
-    model: z.ZodString;
-    system_fingerprint: z.ZodOptional<z.ZodString>;
-    object: z.ZodLiteral<"text_completion">;
-    usage: z.ZodObject<{
-        prompt_tokens: z.ZodNumber;
-        completion_tokens: z.ZodNumber;
-        total_tokens: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    }, {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    object: "text_completion";
-    model: string;
-    usage: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-    id: string;
-    created: number;
-    choices: {
-        text: string;
-        index: number;
-        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-        logprobs?: any;
-    }[];
-    system_fingerprint?: string | undefined;
-}, {
-    object: "text_completion";
-    model: string;
-    usage: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-    id: string;
-    created: number;
-    choices: {
-        text: string;
-        index: number;
-        finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-        logprobs?: any;
-    }[];
-    system_fingerprint?: string | undefined;
-}>;
-export type OpenAICompletionResponse = z.infer<typeof OpenAICompletionResponseSchema>;
-export type OpenAITextResponseFormatType<T> = {
-    stream: boolean;
-    handler: ResponseHandler<T>;
-};
-export declare const OpenAITextResponseFormat: {
-    /**
-     * Returns the response as a JSON object.
-     */
-    json: {
-        stream: boolean;
-        handler: ResponseHandler<{
-            object: "text_completion";
-            model: string;
-            usage: {
-                prompt_tokens: number;
-                completion_tokens: number;
-                total_tokens: number;
-            };
-            id: string;
-            created: number;
-            choices: {
-                text: string;
-                index: number;
-                finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-                logprobs?: any;
-            }[];
-            system_fingerprint?: string | undefined;
-        }>;
-    };
-    /**
-     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
-     * of the response stream.
-     */
-    deltaIterable: {
-        stream: boolean;
-        handler: ({ response }: {
-            response: Response;
-        }) => Promise<AsyncIterable<import("../../index.js").Delta<{
-            object: "text_completion";
-            model: string;
-            id: string;
-            created: number;
-            choices: {
-                text: string;
-                index: number;
-                finish_reason?: "length" | "stop" | "content_filter" | null | undefined;
-            }[];
-            system_fingerprint?: string | undefined;
-        }>>>;
-    };
-};
-export {};

package/model-provider/openai/AbstractOpenAICompletionModel.js

@@ -1,176 +0,0 @@
-import { z } from "zod";
-import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
-import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { zodSchema } from "../../core/schema/ZodSchema.js";
-import { validateTypes } from "../../core/schema/validateTypes.js";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { createEventSourceResponseHandler } from "../../util/streaming/createEventSourceResponseHandler.js";
-import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
-import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
-/**
- * Abstract completion model that calls an API that is compatible with the OpenAI completions API.
- *
- * @see https://platform.openai.com/docs/api-reference/completions/create
- */
-export class AbstractOpenAICompletionModel extends AbstractModel {
-    constructor(settings) {
-        super({ settings });
-    }
-    async callAPI(prompt, callOptions, options) {
-        const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const user = this.settings.isUserIdForwardingEnabled
-            ? callOptions.run?.userId
-            : undefined;
-        const abortSignal = callOptions.run?.abortSignal;
-        const openaiResponseFormat = options.responseFormat;
-        // empty arrays are not allowed for stop:
-        const stopSequences = this.settings.stopSequences != null &&
-            Array.isArray(this.settings.stopSequences) &&
-            this.settings.stopSequences.length === 0
-            ? undefined
-            : this.settings.stopSequences;
-        return callWithRetryAndThrottle({
-            retry: api.retry,
-            throttle: api.throttle,
-            call: async () => postJsonToApi({
-                url: api.assembleUrl("/completions"),
-                headers: api.headers({
-                    functionType: callOptions.functionType,
-                    functionId: callOptions.functionId,
-                    run: callOptions.run,
-                    callId: callOptions.callId,
-                }),
-                body: {
-                    stream: openaiResponseFormat.stream,
-                    model: this.settings.model,
-                    prompt,
-                    suffix: this.settings.suffix,
-                    max_tokens: this.settings.maxGenerationTokens,
-                    temperature: this.settings.temperature,
-                    top_p: this.settings.topP,
-                    n: this.settings.numberOfGenerations,
-                    logprobs: this.settings.logprobs,
-                    echo: this.settings.echo,
-                    stop: stopSequences,
-                    seed: this.settings.seed,
-                    presence_penalty: this.settings.presencePenalty,
-                    frequency_penalty: this.settings.frequencyPenalty,
-                    best_of: this.settings.bestOf,
-                    logit_bias: this.settings.logitBias,
-                    user,
-                },
-                failedResponseHandler: failedOpenAICallResponseHandler,
-                successfulResponseHandler: openaiResponseFormat.handler,
-                abortSignal,
-            }),
-        });
-    }
-    async doGenerateTexts(prompt, options) {
-        return this.processTextGenerationResponse(await this.callAPI(prompt, options, {
-            responseFormat: OpenAITextResponseFormat.json,
-        }));
-    }
-    restoreGeneratedTexts(rawResponse) {
-        return this.processTextGenerationResponse(validateTypes({
-            value: rawResponse,
-            schema: zodSchema(OpenAICompletionResponseSchema),
-        }));
-    }
-    processTextGenerationResponse(rawResponse) {
-        return {
-            rawResponse,
-            textGenerationResults: rawResponse.choices.map((choice) => {
-                return {
-                    finishReason: this.translateFinishReason(choice.finish_reason),
-                    text: choice.text,
-                };
-            }),
-            usage: {
-                promptTokens: rawResponse.usage.prompt_tokens,
-                completionTokens: rawResponse.usage.completion_tokens,
-                totalTokens: rawResponse.usage.total_tokens,
-            },
-        };
-    }
-    translateFinishReason(finishReason) {
-        switch (finishReason) {
-            case "stop":
-                return "stop";
-            case "length":
-                return "length";
-            case "content_filter":
-                return "content-filter";
-            default:
-                return "unknown";
-        }
-    }
-    doStreamText(prompt, options) {
-        return this.callAPI(prompt, options, {
-            responseFormat: OpenAITextResponseFormat.deltaIterable,
-        });
-    }
-    extractTextDelta(delta) {
-        const chunk = delta;
-        const firstChoice = chunk.choices[0];
-        if (firstChoice.index > 0) {
-            return undefined;
-        }
-        return chunk.choices[0].text;
-    }
-    withJsonOutput() {
-        return this;
-    }
-}
-const OpenAICompletionResponseSchema = z.object({
-    id: z.string(),
-    choices: z.array(z.object({
-        finish_reason: z
-            .enum(["stop", "length", "content_filter"])
-            .optional()
-            .nullable(),
-        index: z.number(),
-        logprobs: z.nullable(z.any()),
-        text: z.string(),
-    })),
-    created: z.number(),
-    model: z.string(),
-    system_fingerprint: z.string().optional(),
-    object: z.literal("text_completion"),
-    usage: z.object({
-        prompt_tokens: z.number(),
-        completion_tokens: z.number(),
-        total_tokens: z.number(),
-    }),
-});
-const openaiCompletionStreamChunkSchema = z.object({
-    choices: z.array(z.object({
-        text: z.string(),
-        finish_reason: z
-            .enum(["stop", "length", "content_filter"])
-            .optional()
-            .nullable(),
-        index: z.number(),
-    })),
-    created: z.number(),
-    id: z.string(),
-    model: z.string(),
-    system_fingerprint: z.string().optional(),
-    object: z.literal("text_completion"),
-});
-export const OpenAITextResponseFormat = {
-    /**
-     * Returns the response as a JSON object.
-     */
-    json: {
-        stream: false,
-        handler: createJsonResponseHandler(zodSchema(OpenAICompletionResponseSchema)),
-    },
-    /**
-     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
-     * of the response stream.
-     */
-    deltaIterable: {
-        stream: true,
-        handler: createEventSourceResponseHandler(zodSchema(openaiCompletionStreamChunkSchema)),
-    },
-};

package/model-provider/openai/AbstractOpenAITextEmbeddingModel.cjs

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractOpenAITextEmbeddingModel = void 0;
-const zod_1 = require("zod");
-const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
-const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
-const OpenAIError_js_1 = require("./OpenAIError.cjs");
-/**
- * Abstract text embedding model that calls an API that is compatible with the OpenAI embedding API.
- *
- * @see https://platform.openai.com/docs/api-reference/embeddings
- */
-class AbstractOpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
-    constructor(settings) {
-        super({ settings });
-        Object.defineProperty(this, "isParallelizable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-    }
-    get maxValuesPerCall() {
-        return this.settings.maxValuesPerCall ?? 2048;
-    }
-    async callAPI(texts, callOptions) {
-        const api = this.settings.api ?? new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
-        const abortSignal = callOptions.run?.abortSignal;
-        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: api.retry,
-            throttle: api.throttle,
-            call: async () => (0, postToApi_js_1.postJsonToApi)({
-                url: api.assembleUrl("/embeddings"),
-                headers: api.headers({
-                    functionType: callOptions.functionType,
-                    functionId: callOptions.functionId,
-                    run: callOptions.run,
-                    callId: callOptions.callId,
-                }),
-                body: {
-                    model: this.modelName,
-                    input: texts,
-                    dimensions: this.settings.dimensions,
-                    user: this.settings.isUserIdForwardingEnabled
-                        ? callOptions.run?.userId
-                        : undefined,
-                },
-                failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
-                successfulResponseHandler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(openAITextEmbeddingResponseSchema)),
-                abortSignal,
-            }),
-        });
-    }
-    async doEmbedValues(texts, callOptions) {
-        if (texts.length > this.maxValuesPerCall) {
-            throw new Error(`The OpenAI embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
-        }
-        const rawResponse = await this.callAPI(texts, callOptions);
-        return {
-            rawResponse,
-            embeddings: rawResponse.data.map((data) => data.embedding),
-        };
-    }
-}
-exports.AbstractOpenAITextEmbeddingModel = AbstractOpenAITextEmbeddingModel;
-const openAITextEmbeddingResponseSchema = zod_1.z.object({
-    object: zod_1.z.literal("list"),
-    data: zod_1.z.array(zod_1.z.object({
-        object: zod_1.z.literal("embedding"),
-        embedding: zod_1.z.array(zod_1.z.number()),
-        index: zod_1.z.number(),
-    })),
-    model: zod_1.z.string(),
-    usage: zod_1.z
-        .object({
-        prompt_tokens: zod_1.z.number(),
-        total_tokens: zod_1.z.number(),
-    })
-        .optional(), // for openai-compatible models
-});

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

@@ -1,92 +0,0 @@
-import { z } from "zod";
-import { FunctionCallOptions } from "../../core/FunctionOptions.js";
-import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
-export interface AbstractOpenAITextEmbeddingModelSettings extends EmbeddingModelSettings {
-    api?: ApiConfiguration;
-    model: string;
-    dimensions?: number;
-    maxValuesPerCall?: number | undefined;
-    isUserIdForwardingEnabled?: boolean;
-}
-/**
- * Abstract text embedding model that calls an API that is compatible with the OpenAI embedding API.
- *
- * @see https://platform.openai.com/docs/api-reference/embeddings
- */
-export declare abstract class AbstractOpenAITextEmbeddingModel<SETTINGS extends AbstractOpenAITextEmbeddingModelSettings> extends AbstractModel<SETTINGS> {
-    constructor(settings: SETTINGS);
-    get maxValuesPerCall(): number;
-    readonly isParallelizable = true;
-    callAPI(texts: Array<string>, callOptions: FunctionCallOptions): Promise<OpenAITextEmbeddingResponse>;
-    doEmbedValues(texts: string[], callOptions: FunctionCallOptions): Promise<{
-        rawResponse: {
-            object: "list";
-            data: {
-                object: "embedding";
-                embedding: number[];
-                index: number;
-            }[];
-            model: string;
-            usage?: {
-                prompt_tokens: number;
-                total_tokens: number;
-            } | undefined;
-        };
-        embeddings: number[][];
-    }>;
-}
-declare const openAITextEmbeddingResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    data: z.ZodArray<z.ZodObject<{
-        object: z.ZodLiteral<"embedding">;
-        embedding: z.ZodArray<z.ZodNumber, "many">;
-        index: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        object: "embedding";
-        embedding: number[];
-        index: number;
-    }, {
-        object: "embedding";
-        embedding: number[];
-        index: number;
-    }>, "many">;
-    model: z.ZodString;
-    usage: z.ZodOptional<z.ZodObject<{
-        prompt_tokens: z.ZodNumber;
-        total_tokens: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        prompt_tokens: number;
-        total_tokens: number;
-    }, {
-        prompt_tokens: number;
-        total_tokens: number;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: "list";
-    data: {
-        object: "embedding";
-        embedding: number[];
-        index: number;
-    }[];
-    model: string;
-    usage?: {
-        prompt_tokens: number;
-        total_tokens: number;
-    } | undefined;
-}, {
-    object: "list";
-    data: {
-        object: "embedding";
-        embedding: number[];
-        index: number;
-    }[];
-    model: string;
-    usage?: {
-        prompt_tokens: number;
-        total_tokens: number;
-    } | undefined;
-}>;
-export type OpenAITextEmbeddingResponse = z.infer<typeof openAITextEmbeddingResponseSchema>;
-export {};

package/model-provider/openai/AbstractOpenAITextEmbeddingModel.js

@@ -1,79 +0,0 @@
-import { z } from "zod";
-import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
-import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { zodSchema } from "../../core/schema/ZodSchema.js";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
-import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
-/**
- * Abstract text embedding model that calls an API that is compatible with the OpenAI embedding API.
- *
- * @see https://platform.openai.com/docs/api-reference/embeddings
- */
-export class AbstractOpenAITextEmbeddingModel extends AbstractModel {
-    constructor(settings) {
-        super({ settings });
-        Object.defineProperty(this, "isParallelizable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-    }
-    get maxValuesPerCall() {
-        return this.settings.maxValuesPerCall ?? 2048;
-    }
-    async callAPI(texts, callOptions) {
-        const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const abortSignal = callOptions.run?.abortSignal;
-        return callWithRetryAndThrottle({
-            retry: api.retry,
-            throttle: api.throttle,
-            call: async () => postJsonToApi({
-                url: api.assembleUrl("/embeddings"),
-                headers: api.headers({
-                    functionType: callOptions.functionType,
-                    functionId: callOptions.functionId,
-                    run: callOptions.run,
-                    callId: callOptions.callId,
-                }),
-                body: {
-                    model: this.modelName,
-                    input: texts,
-                    dimensions: this.settings.dimensions,
-                    user: this.settings.isUserIdForwardingEnabled
-                        ? callOptions.run?.userId
-                        : undefined,
-                },
-                failedResponseHandler: failedOpenAICallResponseHandler,
-                successfulResponseHandler: createJsonResponseHandler(zodSchema(openAITextEmbeddingResponseSchema)),
-                abortSignal,
-            }),
-        });
-    }
-    async doEmbedValues(texts, callOptions) {
-        if (texts.length > this.maxValuesPerCall) {
-            throw new Error(`The OpenAI embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
-        }
-        const rawResponse = await this.callAPI(texts, callOptions);
-        return {
-            rawResponse,
-            embeddings: rawResponse.data.map((data) => data.embedding),
-        };
-    }
-}
-const openAITextEmbeddingResponseSchema = z.object({
-    object: z.literal("list"),
-    data: z.array(z.object({
-        object: z.literal("embedding"),
-        embedding: z.array(z.number()),
-        index: z.number(),
-    })),
-    model: z.string(),
-    usage: z
-        .object({
-        prompt_tokens: z.number(),
-        total_tokens: z.number(),
-    })
-        .optional(), // for openai-compatible models
-});