modelfusion 0.98.0 → 0.100.0

package/model-provider/ollama/OllamaCompletionModel.d.ts

@@ -0,0 +1,159 @@
+import { z } from "zod";
+import { FunctionOptions } 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 { Delta } from "../../model-function/Delta.js";
+import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
+import { TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationPromptTemplate } from "../../model-function/generate-text/TextGenerationPromptTemplate.js";
+import { TextGenerationToolCallModel, ToolCallPromptTemplate } from "../../tool/generate-tool-call/TextGenerationToolCallModel.js";
+import { TextGenerationToolCallsOrGenerateTextModel, ToolCallsOrGenerateTextPromptTemplate } from "../../tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.js";
+import { OllamaTextGenerationSettings } from "./OllamaTextGenerationSettings.js";
+export interface OllamaCompletionPrompt {
+    /**
+     * Text prompt.
+     */
+    prompt: string;
+    /**
+     Images. Supports base64-encoded `png` and `jpeg` images up to 100MB in size.
+     */
+    images?: Array<string>;
+}
+/**
+ * Text generation model that uses the Ollama completion API.
+ *
+ * @see https://github.com/jmorganca/ollama/blob/main/docs/api.md#generate-a-completion
+ */
+export interface OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE extends number | undefined> extends OllamaTextGenerationSettings {
+    api?: ApiConfiguration;
+    /**
+     * Specify the context window size of the model that you have loaded in your
+     * Ollama server. (Default: 2048)
+     */
+    contextWindowSize?: CONTEXT_WINDOW_SIZE;
+    /**
+     * When set to true, no formatting will be applied to the prompt and no context
+     * will be returned.
+     */
+    raw?: boolean;
+    system?: string;
+    context?: number[];
+}
+export declare class OllamaCompletionModel<CONTEXT_WINDOW_SIZE extends number | undefined> extends AbstractModel<OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>> implements TextStreamingModel<OllamaCompletionPrompt, OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>> {
+    constructor(settings: OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>);
+    readonly provider = "ollama";
+    get modelName(): string;
+    readonly tokenizer: undefined;
+    readonly countPromptTokens: undefined;
+    get contextWindowSize(): CONTEXT_WINDOW_SIZE;
+    callAPI<RESPONSE>(prompt: OllamaCompletionPrompt, options: {
+        responseFormat: OllamaCompletionResponseFormatType<RESPONSE>;
+    } & FunctionOptions): Promise<RESPONSE>;
+    get settingsForEvent(): Partial<OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>>;
+    doGenerateTexts(prompt: OllamaCompletionPrompt, options?: FunctionOptions): Promise<{
+        response: {
+            response: string;
+            model: string;
+            done: true;
+            created_at: string;
+            total_duration: number;
+            prompt_eval_count: number;
+            eval_count: number;
+            eval_duration: number;
+            load_duration?: number | undefined;
+            prompt_eval_duration?: number | undefined;
+            context?: number[] | undefined;
+        };
+        texts: string[];
+    }>;
+    doStreamText(prompt: OllamaCompletionPrompt, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, OllamaCompletionPrompt>): TextGenerationToolCallModel<INPUT_PROMPT, OllamaCompletionPrompt, this>;
+    asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsOrGenerateTextPromptTemplate<INPUT_PROMPT, OllamaCompletionPrompt>): TextGenerationToolCallsOrGenerateTextModel<INPUT_PROMPT, OllamaCompletionPrompt, this>;
+    withTextPrompt(): PromptTemplateTextStreamingModel<string, OllamaCompletionPrompt, OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>, this>;
+    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, OllamaCompletionPrompt>): PromptTemplateTextStreamingModel<INPUT_PROMPT, OllamaCompletionPrompt, OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>, this>;
+    withSettings(additionalSettings: Partial<OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>>): this;
+}
+declare const ollamaCompletionResponseSchema: z.ZodObject<{
+    done: z.ZodLiteral<true>;
+    model: z.ZodString;
+    created_at: z.ZodString;
+    response: z.ZodString;
+    total_duration: z.ZodNumber;
+    load_duration: z.ZodOptional<z.ZodNumber>;
+    prompt_eval_count: z.ZodNumber;
+    prompt_eval_duration: z.ZodOptional<z.ZodNumber>;
+    eval_count: z.ZodNumber;
+    eval_duration: z.ZodNumber;
+    context: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    response: string;
+    model: string;
+    done: true;
+    created_at: string;
+    total_duration: number;
+    prompt_eval_count: number;
+    eval_count: number;
+    eval_duration: number;
+    load_duration?: number | undefined;
+    prompt_eval_duration?: number | undefined;
+    context?: number[] | undefined;
+}, {
+    response: string;
+    model: string;
+    done: true;
+    created_at: string;
+    total_duration: number;
+    prompt_eval_count: number;
+    eval_count: number;
+    eval_duration: number;
+    load_duration?: number | undefined;
+    prompt_eval_duration?: number | undefined;
+    context?: number[] | undefined;
+}>;
+export type OllamaCompletionResponse = z.infer<typeof ollamaCompletionResponseSchema>;
+export type OllamaCompletionDelta = {
+    content: string;
+    isComplete: boolean;
+    delta: string;
+};
+export type OllamaCompletionResponseFormatType<T> = {
+    stream: boolean;
+    handler: ResponseHandler<T>;
+};
+export declare const OllamaCompletionResponseFormat: {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false;
+        handler: ({ response, url, requestBodyValues }: {
+            url: string;
+            requestBodyValues: unknown;
+            response: Response;
+        }) => Promise<{
+            response: string;
+            model: string;
+            done: true;
+            created_at: string;
+            total_duration: number;
+            prompt_eval_count: number;
+            eval_count: number;
+            eval_duration: number;
+            load_duration?: number | undefined;
+            prompt_eval_duration?: number | undefined;
+            context?: number[] | 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: true;
+        handler: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<Delta<string>>>;
+    };
+};
+export {};

package/model-provider/ollama/{OllamaTextGenerationModel.js → OllamaCompletionModel.js}

@@ -12,7 +12,7 @@ import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseJsonStream } from "../../util/streaming/parseJsonStream.js";
 import { OllamaApiConfiguration } from "./OllamaApiConfiguration.js";
 import { failedOllamaCallResponseHandler } from "./OllamaError.js";
-export class OllamaTextGenerationModel extends AbstractModel {
+export class OllamaCompletionModel extends AbstractModel {
     constructor(settings) {
         super({ settings });
         Object.defineProperty(this, "provider", {
@@ -63,7 +63,7 @@ export class OllamaTextGenerationModel extends AbstractModel {
                         num_ctx: this.settings.contextWindowSize,
                         num_gpu: this.settings.numGpu,
                         num_gqa: this.settings.numGqa,
-                        num_predict: this.settings.maxCompletionTokens,
+                        num_predict: this.settings.maxGenerationTokens,
                         num_threads: this.settings.numThreads,
                         repeat_last_n: this.settings.repeatLastN,
                         repeat_penalty: this.settings.repeatPenalty,
@@ -87,7 +87,7 @@ export class OllamaTextGenerationModel extends AbstractModel {
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
             "contextWindowSize",
             "temperature",
@@ -111,20 +111,20 @@ export class OllamaTextGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
-            responseFormat: OllamaTextGenerationResponseFormat.json,
+            responseFormat: OllamaCompletionResponseFormat.json,
         });
         return {
             response,
-            text: response.response,
+            texts: [response.response],
         };
     }
     doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
-            responseFormat: OllamaTextGenerationResponseFormat.deltaIterable,
+            responseFormat: OllamaCompletionResponseFormat.deltaIterable,
         });
     }
     asToolCallGenerationModel(promptTemplate) {
@@ -159,21 +159,23 @@ export class OllamaTextGenerationModel extends AbstractModel {
         });
     }
     withSettings(additionalSettings) {
-        return new OllamaTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+        return new OllamaCompletionModel(Object.assign({}, this.settings, additionalSettings));
     }
 }
-const ollamaTextGenerationResponseSchema = z.object({
+const ollamaCompletionResponseSchema = z.object({
     done: z.literal(true),
     model: z.string(),
+    created_at: z.string(),
     response: z.string(),
     total_duration: z.number(),
     load_duration: z.number().optional(),
     prompt_eval_count: z.number(),
+    prompt_eval_duration: z.number().optional(),
     eval_count: z.number(),
     eval_duration: z.number(),
     context: z.array(z.number()).optional(),
 });
-const ollamaTextStreamingResponseSchema = new ZodSchema(z.discriminatedUnion("done", [
+const ollamaCompletionStreamSchema = new ZodSchema(z.discriminatedUnion("done", [
     z.object({
         done: z.literal(false),
         model: z.string(),
@@ -201,7 +203,7 @@ async function createOllamaFullDeltaIterableQueue(stream) {
     // process the stream asynchonously (no 'await' on purpose):
     parseJsonStream({
         stream,
-        schema: ollamaTextStreamingResponseSchema,
+        schema: ollamaCompletionStreamSchema,
         process(event) {
             if (event.done === true) {
                 queue.push({
@@ -233,7 +235,7 @@ async function createOllamaFullDeltaIterableQueue(stream) {
     });
     return queue;
 }
-export const OllamaTextGenerationResponseFormat = {
+export const OllamaCompletionResponseFormat = {
     /**
      * Returns the response as a JSON object.
      */
@@ -244,7 +246,7 @@ export const OllamaTextGenerationResponseFormat = {
             const parsedResult = safeParseJSON({
                 text: responseBody,
                 schema: new ZodSchema(z.union([
-                    ollamaTextGenerationResponseSchema,
+                    ollamaCompletionResponseSchema,
                     z.object({
                         done: z.literal(false),
                         model: z.string(),

package/model-provider/ollama/{OllamaTextGenerationModel.test.cjs → OllamaCompletionModel.test.cjs}

@@ -7,7 +7,7 @@ const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
 const retryNever_js_1 = require("../../core/api/retryNever.cjs");
 const generateText_js_1 = require("../../model-function/generate-text/generateText.cjs");
 const OllamaApiConfiguration_js_1 = require("./OllamaApiConfiguration.cjs");
-const OllamaTextGenerationModel_js_1 = require("./OllamaTextGenerationModel.cjs");
+const OllamaCompletionModel_js_1 = require("./OllamaCompletionModel.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let responseBodyJson = {};
 const server = (0, node_1.setupServer)(msw_1.http.post("http://127.0.0.1:11434/api/generate", () => msw_1.HttpResponse.json(responseBodyJson)));
@@ -34,7 +34,7 @@ describe("generateText", () => {
             eval_count: 113,
             eval_duration: 1325948000,
         };
-        const result = await (0, generateText_js_1.generateText)(new OllamaTextGenerationModel_js_1.OllamaTextGenerationModel({
+        const result = await (0, generateText_js_1.generateText)(new OllamaCompletionModel_js_1.OllamaCompletionModel({
             model: "test-model",
         }).withTextPrompt(), "test prompt");
         expect(result).toEqual("test response");
@@ -47,7 +47,7 @@ describe("generateText", () => {
             done: false,
         };
         try {
-            await (0, generateText_js_1.generateText)(new OllamaTextGenerationModel_js_1.OllamaTextGenerationModel({
+            await (0, generateText_js_1.generateText)(new OllamaCompletionModel_js_1.OllamaCompletionModel({
                 api: new OllamaApiConfiguration_js_1.OllamaApiConfiguration({
                     retry: (0, retryNever_js_1.retryNever)(),
                 }),

package/model-provider/ollama/{OllamaTextGenerationModel.test.js → OllamaCompletionModel.test.js}

@@ -5,7 +5,7 @@ import { ApiCallError } from "../../core/api/ApiCallError.js";
 import { retryNever } from "../../core/api/retryNever.js";
 import { generateText } from "../../model-function/generate-text/generateText.js";
 import { OllamaApiConfiguration } from "./OllamaApiConfiguration.js";
-import { OllamaTextGenerationModel } from "./OllamaTextGenerationModel.js";
+import { OllamaCompletionModel } from "./OllamaCompletionModel.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let responseBodyJson = {};
 const server = setupServer(http.post("http://127.0.0.1:11434/api/generate", () => HttpResponse.json(responseBodyJson)));
@@ -32,7 +32,7 @@ describe("generateText", () => {
             eval_count: 113,
             eval_duration: 1325948000,
         };
-        const result = await generateText(new OllamaTextGenerationModel({
+        const result = await generateText(new OllamaCompletionModel({
             model: "test-model",
         }).withTextPrompt(), "test prompt");
         expect(result).toEqual("test response");
@@ -45,7 +45,7 @@ describe("generateText", () => {
             done: false,
         };
         try {
-            await generateText(new OllamaTextGenerationModel({
+            await generateText(new OllamaCompletionModel({
                 api: new OllamaApiConfiguration({
                     retry: retryNever(),
                 }),

package/model-provider/ollama/OllamaFacade.cjs

@@ -1,12 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextEmbedder = exports.TextGenerator = void 0;
+exports.TextEmbedder = exports.ChatTextGenerator = exports.CompletionTextGenerator = exports.Api = void 0;
+const OllamaChatModel_js_1 = require("./OllamaChatModel.cjs");
 const OllamaTextEmbeddingModel_js_1 = require("./OllamaTextEmbeddingModel.cjs");
-const OllamaTextGenerationModel_js_1 = require("./OllamaTextGenerationModel.cjs");
-function TextGenerator(settings) {
-    return new OllamaTextGenerationModel_js_1.OllamaTextGenerationModel(settings);
+const OllamaCompletionModel_js_1 = require("./OllamaCompletionModel.cjs");
+const OllamaApiConfiguration_js_1 = require("./OllamaApiConfiguration.cjs");
+function Api(settings) {
+    return new OllamaApiConfiguration_js_1.OllamaApiConfiguration(settings);
 }
-exports.TextGenerator = TextGenerator;
+exports.Api = Api;
+function CompletionTextGenerator(settings) {
+    return new OllamaCompletionModel_js_1.OllamaCompletionModel(settings);
+}
+exports.CompletionTextGenerator = CompletionTextGenerator;
+function ChatTextGenerator(settings) {
+    return new OllamaChatModel_js_1.OllamaChatModel(settings);
+}
+exports.ChatTextGenerator = ChatTextGenerator;
 function TextEmbedder(settings) {
     return new OllamaTextEmbeddingModel_js_1.OllamaTextEmbeddingModel(settings);
 }

package/model-provider/ollama/OllamaFacade.d.ts

@@ -1,4 +1,9 @@
+import { OllamaChatModel, OllamaChatModelSettings } from "./OllamaChatModel.js";
 import { OllamaTextEmbeddingModel, OllamaTextEmbeddingModelSettings } from "./OllamaTextEmbeddingModel.js";
-import { OllamaTextGenerationModel, OllamaTextGenerationModelSettings } from "./OllamaTextGenerationModel.js";
-export declare function TextGenerator<CONTEXT_WINDOW_SIZE extends number>(settings: OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>): OllamaTextGenerationModel<CONTEXT_WINDOW_SIZE>;
+import { OllamaCompletionModel, OllamaCompletionModelSettings } from "./OllamaCompletionModel.js";
+import { OllamaApiConfiguration, OllamaApiConfigurationSettings } from "./OllamaApiConfiguration.js";
+export declare function Api(settings: OllamaApiConfigurationSettings): OllamaApiConfiguration;
+export declare function CompletionTextGenerator<CONTEXT_WINDOW_SIZE extends number>(settings: OllamaCompletionModelSettings<CONTEXT_WINDOW_SIZE>): OllamaCompletionModel<CONTEXT_WINDOW_SIZE>;
+export declare function ChatTextGenerator(settings: OllamaChatModelSettings): OllamaChatModel;
 export declare function TextEmbedder(settings: OllamaTextEmbeddingModelSettings): OllamaTextEmbeddingModel;
+export { OllamaChatMessage as ChatMessage, OllamaChatPrompt as ChatPrompt, } from "./OllamaChatModel.js";

package/model-provider/ollama/OllamaFacade.js

@@ -1,7 +1,15 @@
+import { OllamaChatModel } from "./OllamaChatModel.js";
 import { OllamaTextEmbeddingModel, } from "./OllamaTextEmbeddingModel.js";
-import { OllamaTextGenerationModel, } from "./OllamaTextGenerationModel.js";
-export function TextGenerator(settings) {
-    return new OllamaTextGenerationModel(settings);
+import { OllamaCompletionModel, } from "./OllamaCompletionModel.js";
+import { OllamaApiConfiguration, } from "./OllamaApiConfiguration.js";
+export function Api(settings) {
+    return new OllamaApiConfiguration(settings);
+}
+export function CompletionTextGenerator(settings) {
+    return new OllamaCompletionModel(settings);
+}
+export function ChatTextGenerator(settings) {
+    return new OllamaChatModel(settings);
 }
 export function TextEmbedder(settings) {
     return new OllamaTextEmbeddingModel(settings);

package/model-provider/ollama/OllamaTextGenerationSettings.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/model-provider/ollama/OllamaTextGenerationSettings.d.ts

@@ -0,0 +1,87 @@
+import { TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+export interface OllamaTextGenerationSettings extends TextGenerationModelSettings {
+    /**
+     * The name of the model to use. For example, 'mistral'.
+     *
+     * @see https://ollama.ai/library
+     */
+    model: string;
+    /**
+     * The temperature of the model. Increasing the temperature will make the model
+     * answer more creatively. (Default: 0.8)
+     */
+    temperature?: number;
+    /**
+     * Enable Mirostat sampling for controlling perplexity.
+     * (default: 0, 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0)
+     */
+    mirostat?: number;
+    /**
+     * Influences how quickly the algorithm responds to feedback from the generated text.
+     * A lower learning rate will result in slower adjustments,
+     * while a higher learning rate will make the algorithm more responsive. (Default: 0.1)
+     */
+    mirostatEta?: number;
+    /**
+     * Controls the balance between coherence and diversity of the output.
+     * A lower value will result in more focused and coherent text. (Default: 5.0)
+     */
+    mirostatTau?: number;
+    /**
+     * The number of GQA groups in the transformer layer. Required for some models,
+     * for example it is 8 for llama2:70b
+     */
+    numGqa?: number;
+    /**
+     * The number of layers to send to the GPU(s). On macOS it defaults to 1 to
+     * enable metal support, 0 to disable.
+     */
+    numGpu?: number;
+    /**
+     * Sets the number of threads to use during computation. By default, Ollama will
+     * detect this for optimal performance. It is recommended to set this value to the
+     * number of physical CPU cores your system has (as opposed to the logical number of cores).
+     */
+    numThreads?: number;
+    /**
+     * Sets how far back for the model to look back to prevent repetition.
+     * (Default: 64, 0 = disabled, -1 = num_ctx)
+     */
+    repeatLastN?: number;
+    /**
+     * Sets how strongly to penalize repetitions. A higher value (e.g., 1.5)
+     * will penalize repetitions more strongly, while a lower value (e.g., 0.9)
+     * will be more lenient. (Default: 1.1)
+     */
+    repeatPenalty?: number;
+    /**
+     * Sets the random number seed to use for generation. Setting this to a
+     * specific number will make the model generate the same text for the same prompt.
+     * (Default: 0)
+     */
+    seed?: number;
+    /**
+     * Tail free sampling is used to reduce the impact of less probable tokens
+     * from the output. A higher value (e.g., 2.0) will reduce the impact more,
+     * while a value of 1.0 disables this setting. (default: 1)
+     */
+    tfsZ?: number;
+    /**
+     * Reduces the probability of generating nonsense. A higher value (e.g. 100)
+     * will give more diverse answers, while a lower value (e.g. 10) will be more
+     *  conservative. (Default: 40)
+     */
+    topK?: number;
+    /**
+     * Works together with top-k. A higher value (e.g., 0.95) will lead to more
+     * diverse text, while a lower value (e.g., 0.5) will generate more focused
+     * and conservative text. (Default: 0.9)
+     */
+    topP?: number;
+    /**
+     * The format to return a response in. Currently the only accepted value is 'json'.
+     * Leave undefined to return a string.
+     */
+    format?: "json";
+    template?: string;
+}

package/model-provider/ollama/OllamaTextGenerationSettings.js

@@ -0,0 +1 @@
+export {};

package/model-provider/ollama/index.cjs

@@ -28,6 +28,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ollama = void 0;
 __exportStar(require("./OllamaApiConfiguration.cjs"), exports);
+__exportStar(require("./OllamaChatModel.cjs"), exports);
+__exportStar(require("./OllamaChatPromptTemplate.cjs"), exports);
+__exportStar(require("./OllamaCompletionModel.cjs"), exports);
 exports.ollama = __importStar(require("./OllamaFacade.cjs"));
 __exportStar(require("./OllamaTextEmbeddingModel.cjs"), exports);
-__exportStar(require("./OllamaTextGenerationModel.cjs"), exports);
+__exportStar(require("./OllamaTextGenerationSettings.cjs"), exports);

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

@@ -1,5 +1,8 @@
 export * from "./OllamaApiConfiguration.js";
+export * from "./OllamaChatModel.js";
+export * from "./OllamaChatPromptTemplate.js";
+export * from "./OllamaCompletionModel.js";
 export { OllamaErrorData } from "./OllamaError.js";
 export * as ollama from "./OllamaFacade.js";
 export * from "./OllamaTextEmbeddingModel.js";
-export * from "./OllamaTextGenerationModel.js";
+export * from "./OllamaTextGenerationSettings.js";

package/model-provider/ollama/index.js

@@ -1,4 +1,7 @@
 export * from "./OllamaApiConfiguration.js";
+export * from "./OllamaChatModel.js";
+export * from "./OllamaChatPromptTemplate.js";
+export * from "./OllamaCompletionModel.js";
 export * as ollama from "./OllamaFacade.js";
 export * from "./OllamaTextEmbeddingModel.js";
-export * from "./OllamaTextGenerationModel.js";
+export * from "./OllamaTextGenerationSettings.js";

package/model-provider/openai/OpenAICompletionModel.cjs

@@ -137,7 +137,7 @@ exports.calculateOpenAICompletionCostInMillicents = calculateOpenAICompletionCos
  * const model = new OpenAICompletionModel({
  *   model: "gpt-3.5-turbo-instruct",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  *   retry: retryWithExponentialBackoff({ maxTries: 5 }),
  * });
  *
@@ -180,33 +180,60 @@ class OpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
     async callAPI(prompt, options) {
-        const { run, responseFormat } = options;
-        const callSettings = {
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...this.settings,
-            // map to OpenAI API names:
-            stop: this.settings.stopSequences,
-            maxTokens: this.settings.maxCompletionTokens,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            prompt,
-            responseFormat,
-        };
+        const api = this.settings.api ?? new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration();
+        const user = this.settings.isUserIdForwardingEnabled
+            ? options.run?.userId
+            : undefined;
+        const abortSignal = options.run?.abortSignal;
+        let { stopSequences } = this.settings;
+        const openaiResponseFormat = options.responseFormat;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAICompletionAPI(callSettings),
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => {
+                // empty arrays are not allowed for stop:
+                if (stopSequences != null &&
+                    Array.isArray(stopSequences) &&
+                    stopSequences.length === 0) {
+                    stopSequences = undefined;
+                }
+                return (0, postToApi_js_1.postJsonToApi)({
+                    url: api.assembleUrl("/completions"),
+                    headers: api.headers,
+                    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: this.settings.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: OpenAIError_js_1.failedOpenAICallResponseHandler,
+                    successfulResponseHandler: openaiResponseFormat.handler,
+                    abortSignal,
+                });
+            },
         });
     }
     get settingsForEvent() {
         const eventSettingProperties = [
-            "maxCompletionTokens",
+            "maxGenerationTokens",
             "stopSequences",
+            "numberOfGenerations",
             "suffix",
             "temperature",
             "topP",
-            "n",
             "logprobs",
             "echo",
             "presencePenalty",
@@ -217,14 +244,14 @@ class OpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: exports.OpenAITextResponseFormat.json,
         });
         return {
             response,
-            text: response.choices[0].text,
+            texts: response.choices.map((choice) => choice.text),
             usage: {
                 promptTokens: response.usage.prompt_tokens,
                 completionTokens: response.usage.completion_tokens,
@@ -287,38 +314,6 @@ const OpenAICompletionResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
-async function callOpenAICompletionAPI({ api = new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration(), abortSignal, responseFormat, model, prompt, suffix, maxTokens, temperature, topP, n, logprobs, echo, stop, presencePenalty, frequencyPenalty, bestOf, logitBias, seed, user, }) {
-    // empty arrays are not allowed for stop:
-    if (stop != null && Array.isArray(stop) && stop.length === 0) {
-        stop = undefined;
-    }
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl("/completions"),
-        headers: api.headers,
-        body: {
-            stream: responseFormat.stream,
-            model,
-            prompt,
-            suffix,
-            max_tokens: maxTokens,
-            temperature,
-            top_p: topP,
-            n,
-            logprobs,
-            echo,
-            stop,
-            seed,
-            presence_penalty: presencePenalty,
-            frequency_penalty: frequencyPenalty,
-            best_of: bestOf,
-            logit_bias: logitBias,
-            user,
-        },
-        failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 exports.OpenAITextResponseFormat = {
     /**
      * Returns the response as a JSON object.