modelfusion 0.107.0 → 0.109.0

package/model-provider/openai/OpenAICompletionModel.js

@@ -1,15 +1,8 @@
-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 { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
 import { chat, instruction, } from "../../model-function/generate-text/prompt-template/TextPromptTemplate.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
-import { createEventSourceResponseHandler } from "../../util/streaming/createEventSourceResponseHandler.js";
-import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
-import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
+import { AbstractOpenAICompletionModel, } from "./AbstractOpenAICompletionModel.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
 /**
  * @see https://platform.openai.com/docs/models/
@@ -139,9 +132,9 @@ export const calculateOpenAICompletionCostInMillicents = ({ model, response, })
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export class OpenAICompletionModel extends AbstractModel {
+export class OpenAICompletionModel extends AbstractOpenAICompletionModel {
     constructor(settings) {
-        super({ settings });
+        super(settings);
         Object.defineProperty(this, "provider", {
             enumerable: true,
             configurable: true,
@@ -172,52 +165,6 @@ export class OpenAICompletionModel extends AbstractModel {
     async countPromptTokens(input) {
         return countTokens(this.tokenizer, input);
     }
-    async callAPI(prompt, options) {
-        const api = this.settings.api ?? new OpenAIApiConfiguration();
-        const user = this.settings.isUserIdForwardingEnabled
-            ? options.run?.userId
-            : undefined;
-        const abortSignal = options.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 () => {
-                return 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: 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,
-                });
-            },
-        });
-    }
     get settingsForEvent() {
         const eventSettingProperties = [
             ...textGenerationModelProperties,
@@ -234,52 +181,6 @@ export class OpenAICompletionModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    async doGenerateTexts(prompt, options) {
-        const response = await this.callAPI(prompt, {
-            ...options,
-            responseFormat: OpenAITextResponseFormat.json,
-        });
-        return {
-            response,
-            textGenerationResults: response.choices.map((choice) => {
-                return {
-                    finishReason: this.translateFinishReason(choice.finish_reason),
-                    text: choice.text,
-                };
-            }),
-            usage: {
-                promptTokens: response.usage.prompt_tokens,
-                completionTokens: response.usage.completion_tokens,
-                totalTokens: response.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;
-    }
     /**
      * Returns this model with an instruction prompt template.
      */
@@ -307,56 +208,3 @@ export class OpenAICompletionModel extends AbstractModel {
         return new OpenAICompletionModel(Object.assign({}, this.settings, additionalSettings));
     }
 }
-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 = zodSchema(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(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(openaiCompletionStreamChunkSchema),
-    },
-};

package/model-provider/openai/index.cjs

@@ -28,6 +28,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.openai = exports.OpenAIChatPrompt = void 0;
 __exportStar(require("./AbstractOpenAIChatModel.cjs"), exports);
+__exportStar(require("./AbstractOpenAICompletionModel.cjs"), exports);
 __exportStar(require("./AzureOpenAIApiConfiguration.cjs"), exports);
 __exportStar(require("./OpenAIApiConfiguration.cjs"), exports);
 __exportStar(require("./OpenAIChatMessage.cjs"), exports);

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

@@ -1,4 +1,5 @@
 export * from "./AbstractOpenAIChatModel.js";
+export * from "./AbstractOpenAICompletionModel.js";
 export * from "./AzureOpenAIApiConfiguration.js";
 export * from "./OpenAIApiConfiguration.js";
 export * from "./OpenAIChatMessage.js";

package/model-provider/openai/index.js

@@ -1,4 +1,5 @@
 export * from "./AbstractOpenAIChatModel.js";
+export * from "./AbstractOpenAICompletionModel.js";
 export * from "./AzureOpenAIApiConfiguration.js";
 export * from "./OpenAIApiConfiguration.js";
 export * from "./OpenAIChatMessage.js";

package/model-provider/openai-compatible/OpenAICompatibleChatModel.d.ts

@@ -1,15 +1,14 @@
 import { StructureFromTextPromptTemplate } from "../../model-function/generate-structure/StructureFromTextPromptTemplate.js";
 import { StructureFromTextStreamingModel } from "../../model-function/generate-structure/StructureFromTextStreamingModel.js";
 import { PromptTemplateFullTextModel } from "../../model-function/generate-text/PromptTemplateFullTextModel.js";
-import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
 import { TextGenerationPromptTemplate } from "../../model-function/generate-text/TextGenerationPromptTemplate.js";
 import { ToolCallGenerationModel } from "../../tool/generate-tool-call/ToolCallGenerationModel.js";
 import { ToolCallsOrTextGenerationModel } from "../../tool/generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.js";
-import { AbstractOpenAIChatCallSettings, AbstractOpenAIChatModel, OpenAIChatPrompt } from "../openai/AbstractOpenAIChatModel.js";
-export type OpenAICompatibleProviderName = `openaicompatible` | `openaicompatible-${string}`;
-export interface OpenAICompatibleChatSettings extends TextGenerationModelSettings, Omit<AbstractOpenAIChatCallSettings, "stop" | "maxTokens"> {
+import { AbstractOpenAIChatModel, AbstractOpenAIChatSettings, OpenAIChatPrompt } from "../openai/AbstractOpenAIChatModel.js";
+import { OpenAICompatibleProviderName } from "./OpenAICompatibleProviderName.js";
+export interface OpenAICompatibleChatSettings extends AbstractOpenAIChatSettings {
     provider?: OpenAICompatibleProviderName;
-    isUserIdForwardingEnabled?: boolean;
 }
 /**
  * Create a text generation model that calls an API that is compatible with OpenAI's chat API.

package/model-provider/openai-compatible/OpenAICompatibleCompletionModel.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleCompletionModel = void 0;
+const PromptTemplateTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptTemplateTextStreamingModel.cjs");
+const TextGenerationModel_js_1 = require("../../model-function/generate-text/TextGenerationModel.cjs");
+const AbstractOpenAICompletionModel_js_1 = require("../openai/AbstractOpenAICompletionModel.cjs");
+/**
+ * Create a text generation model that calls an API that is compatible with OpenAI's completion API.
+ *
+ * Please note that many providers implement the API with slight differences, which can cause
+ * unexpected errors and different behavior in less common scenarios.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ */
+class OpenAICompatibleCompletionModel extends AbstractOpenAICompletionModel_js_1.AbstractOpenAICompletionModel {
+    constructor(settings) {
+        super(settings);
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get provider() {
+        return this.settings.provider ?? "openaicompatible";
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            ...TextGenerationModel_js_1.textGenerationModelProperties,
+            "suffix",
+            "temperature",
+            "topP",
+            "logprobs",
+            "echo",
+            "presencePenalty",
+            "frequencyPenalty",
+            "bestOf",
+            "logitBias",
+            "seed",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    withPromptTemplate(promptTemplate) {
+        return new PromptTemplateTextStreamingModel_js_1.PromptTemplateTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptTemplate.stopSequences,
+                ],
+            }),
+            promptTemplate,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OpenAICompatibleCompletionModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.OpenAICompatibleCompletionModel = OpenAICompatibleCompletionModel;

package/model-provider/openai-compatible/OpenAICompatibleCompletionModel.d.ts

@@ -0,0 +1,27 @@
+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 { AbstractOpenAICompletionModel, AbstractOpenAICompletionModelSettings } from "../openai/AbstractOpenAICompletionModel.js";
+import { OpenAICompatibleProviderName } from "./OpenAICompatibleProviderName.js";
+export interface OpenAICompatibleCompletionModelSettings extends AbstractOpenAICompletionModelSettings {
+    provider?: OpenAICompatibleProviderName;
+}
+/**
+ * Create a text generation model that calls an API that is compatible with OpenAI's completion API.
+ *
+ * Please note that many providers implement the API with slight differences, which can cause
+ * unexpected errors and different behavior in less common scenarios.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ */
+export declare class OpenAICompatibleCompletionModel extends AbstractOpenAICompletionModel<OpenAICompatibleCompletionModelSettings> implements TextStreamingModel<string, OpenAICompatibleCompletionModelSettings> {
+    constructor(settings: OpenAICompatibleCompletionModelSettings);
+    get provider(): OpenAICompatibleProviderName;
+    get modelName(): string;
+    readonly contextWindowSize: undefined;
+    readonly tokenizer: undefined;
+    readonly countPromptTokens: undefined;
+    get settingsForEvent(): Partial<OpenAICompatibleCompletionModelSettings>;
+    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, string>): PromptTemplateTextStreamingModel<INPUT_PROMPT, string, OpenAICompatibleCompletionModelSettings, this>;
+    withSettings(additionalSettings: Partial<OpenAICompatibleCompletionModelSettings>): this;
+}

package/model-provider/openai-compatible/OpenAICompatibleCompletionModel.js

@@ -0,0 +1,70 @@
+import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
+import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
+import { AbstractOpenAICompletionModel, } from "../openai/AbstractOpenAICompletionModel.js";
+/**
+ * Create a text generation model that calls an API that is compatible with OpenAI's completion API.
+ *
+ * Please note that many providers implement the API with slight differences, which can cause
+ * unexpected errors and different behavior in less common scenarios.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ */
+export class OpenAICompatibleCompletionModel extends AbstractOpenAICompletionModel {
+    constructor(settings) {
+        super(settings);
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get provider() {
+        return this.settings.provider ?? "openaicompatible";
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            ...textGenerationModelProperties,
+            "suffix",
+            "temperature",
+            "topP",
+            "logprobs",
+            "echo",
+            "presencePenalty",
+            "frequencyPenalty",
+            "bestOf",
+            "logitBias",
+            "seed",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    withPromptTemplate(promptTemplate) {
+        return new PromptTemplateTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptTemplate.stopSequences,
+                ],
+            }),
+            promptTemplate,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OpenAICompatibleCompletionModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}

package/model-provider/openai-compatible/OpenAICompatibleFacade.cjs

@@ -1,7 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatTextGenerator = void 0;
+exports.ChatTextGenerator = exports.CompletionTextGenerator = void 0;
 const OpenAICompatibleChatModel_js_1 = require("./OpenAICompatibleChatModel.cjs");
+const OpenAICompatibleCompletionModel_js_1 = require("./OpenAICompatibleCompletionModel.cjs");
+/**
+ * Create a text generation model that calls an API that is compatible with OpenAI's completion API.
+ *
+ * Please note that many providers implement the API with slight differences, which can cause
+ * unexpected errors and different behavior in less common scenarios.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ *
+ * @example
+ * ```ts
+ * const model = openaicompatible.CompletionTextGenerator({
+ *   model: "provider-specific-model-name",
+ *   temperature: 0.7,
+ *   maxGenerationTokens: 500,
+ * });
+ *
+ * const text = await generateText(
+ *   model,
+ *   "Write a short story about a robot learning to love:"
+ * );
+ * ```
+ */
+function CompletionTextGenerator(settings) {
+    return new OpenAICompatibleCompletionModel_js_1.OpenAICompatibleCompletionModel(settings);
+}
+exports.CompletionTextGenerator = CompletionTextGenerator;
 /**
  * Create a text generation model that calls an API that is compatible with OpenAI's chat API.
  *
@@ -11,18 +38,22 @@ const OpenAICompatibleChatModel_js_1 = require("./OpenAICompatibleChatModel.cjs"
  * @see https://platform.openai.com/docs/api-reference/chat/create
  *
  * @example
+ * ```ts
  * const model = openaicompatible.ChatTextGenerator({
  *   model: "provider-specific-model-name",
  *   temperature: 0.7,
  *   maxGenerationTokens: 500,
  * });
  *
- * const text = await generateText([
+ * const text = await generateText(
  *   model,
- *   openai.ChatMessage.system(
- *     "Write a short story about a robot learning to love:"
- *   ),
- * ]);
+ *   [
+ *     openai.ChatMessage.user(
+ *       "Write a short story about a robot learning to love:"
+ *     ),
+ *   ]
+ * );
+ * ```
  */
 function ChatTextGenerator(settings) {
     return new OpenAICompatibleChatModel_js_1.OpenAICompatibleChatModel(settings);

package/model-provider/openai-compatible/OpenAICompatibleFacade.d.ts

@@ -1,4 +1,28 @@
 import { OpenAICompatibleChatModel, OpenAICompatibleChatSettings } from "./OpenAICompatibleChatModel.js";
+import { OpenAICompatibleCompletionModel } from "./OpenAICompatibleCompletionModel.js";
+/**
+ * Create a text generation model that calls an API that is compatible with OpenAI's completion API.
+ *
+ * Please note that many providers implement the API with slight differences, which can cause
+ * unexpected errors and different behavior in less common scenarios.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ *
+ * @example
+ * ```ts
+ * const model = openaicompatible.CompletionTextGenerator({
+ *   model: "provider-specific-model-name",
+ *   temperature: 0.7,
+ *   maxGenerationTokens: 500,
+ * });
+ *
+ * const text = await generateText(
+ *   model,
+ *   "Write a short story about a robot learning to love:"
+ * );
+ * ```
+ */
+export declare function CompletionTextGenerator(settings: OpenAICompatibleChatSettings): OpenAICompatibleCompletionModel;
 /**
  * Create a text generation model that calls an API that is compatible with OpenAI's chat API.
  *
@@ -8,17 +32,21 @@ import { OpenAICompatibleChatModel, OpenAICompatibleChatSettings } from "./OpenA
  * @see https://platform.openai.com/docs/api-reference/chat/create
  *
  * @example
+ * ```ts
  * const model = openaicompatible.ChatTextGenerator({
  *   model: "provider-specific-model-name",
  *   temperature: 0.7,
  *   maxGenerationTokens: 500,
  * });
  *
- * const text = await generateText([
+ * const text = await generateText(
  *   model,
- *   openai.ChatMessage.system(
- *     "Write a short story about a robot learning to love:"
- *   ),
- * ]);
+ *   [
+ *     openai.ChatMessage.user(
+ *       "Write a short story about a robot learning to love:"
+ *     ),
+ *   ]
+ * );
+ * ```
  */
 export declare function ChatTextGenerator(settings: OpenAICompatibleChatSettings): OpenAICompatibleChatModel;

package/model-provider/openai-compatible/OpenAICompatibleFacade.js

@@ -1,4 +1,30 @@
 import { OpenAICompatibleChatModel, } from "./OpenAICompatibleChatModel.js";
+import { OpenAICompatibleCompletionModel } from "./OpenAICompatibleCompletionModel.js";
+/**
+ * Create a text generation model that calls an API that is compatible with OpenAI's completion API.
+ *
+ * Please note that many providers implement the API with slight differences, which can cause
+ * unexpected errors and different behavior in less common scenarios.
+ *
+ * @see https://platform.openai.com/docs/api-reference/completions/create
+ *
+ * @example
+ * ```ts
+ * const model = openaicompatible.CompletionTextGenerator({
+ *   model: "provider-specific-model-name",
+ *   temperature: 0.7,
+ *   maxGenerationTokens: 500,
+ * });
+ *
+ * const text = await generateText(
+ *   model,
+ *   "Write a short story about a robot learning to love:"
+ * );
+ * ```
+ */
+export function CompletionTextGenerator(settings) {
+    return new OpenAICompatibleCompletionModel(settings);
+}
 /**
  * Create a text generation model that calls an API that is compatible with OpenAI's chat API.
  *
@@ -8,18 +34,22 @@ import { OpenAICompatibleChatModel, } from "./OpenAICompatibleChatModel.js";
  * @see https://platform.openai.com/docs/api-reference/chat/create
  *
  * @example
+ * ```ts
  * const model = openaicompatible.ChatTextGenerator({
  *   model: "provider-specific-model-name",
  *   temperature: 0.7,
  *   maxGenerationTokens: 500,
  * });
  *
- * const text = await generateText([
+ * const text = await generateText(
  *   model,
- *   openai.ChatMessage.system(
- *     "Write a short story about a robot learning to love:"
- *   ),
- * ]);
+ *   [
+ *     openai.ChatMessage.user(
+ *       "Write a short story about a robot learning to love:"
+ *     ),
+ *   ]
+ * );
+ * ```
  */
 export function ChatTextGenerator(settings) {
     return new OpenAICompatibleChatModel(settings);

package/model-provider/openai-compatible/OpenAICompatibleProviderName.cjs

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

package/model-provider/openai-compatible/OpenAICompatibleProviderName.d.ts

@@ -0,0 +1 @@
+export type OpenAICompatibleProviderName = `openaicompatible` | `openaicompatible-${string}`;

package/model-provider/openai-compatible/OpenAICompatibleProviderName.js

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

package/model-provider/openai-compatible/TogetherAIApiConfiguration.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TogetherAIApiConfiguration = void 0;
+const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
+const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
+/**
+ * Configuration for the Together.ai API.
+ *
+ * It uses the `TOGETHER_API_KEY` api key environment variable.
+ *
+ * @see https://docs.together.ai/docs/openai-api-compatibility
+ */
+class TogetherAIApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
+    constructor({ baseUrl = "https://api.together.xyz/v1", apiKey, retry, throttle, } = {}) {
+        super({
+            baseUrl,
+            headers: {
+                Authorization: `Bearer ${(0, loadApiKey_js_1.loadApiKey)({
+                    apiKey,
+                    environmentVariableName: "TOGETHER_API_KEY",
+                    description: "Together AI",
+                })}`,
+            },
+            retry,
+            throttle,
+        });
+    }
+}
+exports.TogetherAIApiConfiguration = TogetherAIApiConfiguration;

package/model-provider/openai-compatible/TogetherAIApiConfiguration.d.ts

@@ -0,0 +1,18 @@
+import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { RetryFunction } from "../../core/api/RetryFunction.js";
+import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
+/**
+ * Configuration for the Together.ai API.
+ *
+ * It uses the `TOGETHER_API_KEY` api key environment variable.
+ *
+ * @see https://docs.together.ai/docs/openai-api-compatibility
+ */
+export declare class TogetherAIApiConfiguration extends BaseUrlApiConfiguration {
+    constructor({ baseUrl, apiKey, retry, throttle, }?: {
+        baseUrl?: string;
+        apiKey?: string;
+        retry?: RetryFunction;
+        throttle?: ThrottleFunction;
+    });
+}