modelfusion 0.41.2 → 0.42.0

package/README.md

@@ -51,7 +51,7 @@ const text = await generateText(
 );
 ```
 
-Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Cohere](https://modelfusion.dev/integration/model-provider/cohere), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp), [Hugging Face](https://modelfusion.dev/integration/model-provider/huggingface)
+Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Anthropic](https://modelfusion.dev/integration/model-provider/anthropic), [Cohere](https://modelfusion.dev/integration/model-provider/cohere), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp), [Hugging Face](https://modelfusion.dev/integration/model-provider/huggingface)
 
 #### streamText
 
@@ -68,7 +68,7 @@ for await (const textFragment of textStream) {
 }
 ```
 
-Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Cohere](https://modelfusion.dev/integration/model-provider/cohere), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp)
+Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai), [Anthropic](https://modelfusion.dev/integration/model-provider/anthropic), [Cohere](https://modelfusion.dev/integration/model-provider/cohere), [Llama.cpp](https://modelfusion.dev/integration/model-provider/llamacpp)
 
 #### Prompt Format
 
@@ -104,6 +104,7 @@ const textStream = await streamText(
 | Prompt Format | Instruction Prompt | Chat Prompt |
 | ------------- | ------------------ | ----------- |
 | OpenAI Chat   | ✅                 | ✅          |
+| Anthropic     | ✅                 | ✅          |
 | Llama 2       | ✅                 | ✅          |
 | Alpaca        | ✅                 | ❌          |
 | Vicuna        | ❌                 | ✅          |
@@ -494,10 +495,18 @@ Integrations: [Helicone](https://modelfusion.dev/integration/observability/helic
 
 Examples for almost all of the individual functions and objects. Highly recommended to get started.
 
+### [StoryTeller](https://github.com/lgrammel/storyteller)
+
+> _multi-modal_, _structure streaming_, _image generation_, _text to speech_, _speech to text_, _text generation_, _structure generation_, _embeddings_
+
+StoryTeller is an exploratory web application that creates short audio stories for pre-school kids.
+
 ### [Chatbot (Terminal)](https://github.com/lgrammel/modelfusion/tree/main/examples/chatbot-terminal)
 
 > _Terminal app_, _chat_, _llama.cpp_
 
+A chat with an AI assistant, implemented as a terminal app.
+
 ### [Chatbot (Next.JS)](https://github.com/lgrammel/modelfusion/tree/main/examples/chatbot-next-js)
 
 > _Next.js app_, _OpenAI GPT-3.5-turbo_, _streaming_, _abort handling_

package/model-function/generate-text/TextGenerationModel.d.ts

@@ -1,7 +1,5 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
-import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { Delta } from "../Delta.js";
 import { Model, ModelSettings } from "../Model.js";
 import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
@@ -38,9 +36,9 @@ export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationMode
             totalTokens: number;
         };
     }>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): TextGenerationModel<INPUT_PROMPT, SETTINGS>;
 }
 export interface TextStreamingModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends TextGenerationModel<PROMPT, SETTINGS> {
     doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<string>>>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextStreamingModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): TextStreamingModel<INPUT_PROMPT, SETTINGS>;
 }

package/model-provider/anthropic/AnthropicApiConfiguration.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicApiConfiguration = void 0;
+const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
+const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
+class AnthropicApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
+    constructor({ baseUrl = "https://api.anthropic.com/v1", apiKey, retry, throttle, } = {}) {
+        super({
+            baseUrl,
+            headers: {
+                "x-api-key": (0, loadApiKey_js_1.loadApiKey)({
+                    apiKey,
+                    environmentVariableName: "ANTHROPIC_API_KEY",
+                    description: "Anthropic",
+                }),
+                "anthropic-version": "2023-06-01",
+            },
+            retry,
+            throttle,
+        });
+    }
+}
+exports.AnthropicApiConfiguration = AnthropicApiConfiguration;

package/model-provider/anthropic/AnthropicApiConfiguration.d.ts

@@ -0,0 +1,11 @@
+import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { RetryFunction } from "../../core/api/RetryFunction.js";
+import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
+export declare class AnthropicApiConfiguration extends BaseUrlApiConfiguration {
+    constructor({ baseUrl, apiKey, retry, throttle, }?: {
+        baseUrl?: string;
+        apiKey?: string;
+        retry?: RetryFunction;
+        throttle?: ThrottleFunction;
+    });
+}

package/model-provider/anthropic/AnthropicApiConfiguration.js

@@ -0,0 +1,19 @@
+import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { loadApiKey } from "../../core/api/loadApiKey.js";
+export class AnthropicApiConfiguration extends BaseUrlApiConfiguration {
+    constructor({ baseUrl = "https://api.anthropic.com/v1", apiKey, retry, throttle, } = {}) {
+        super({
+            baseUrl,
+            headers: {
+                "x-api-key": loadApiKey({
+                    apiKey,
+                    environmentVariableName: "ANTHROPIC_API_KEY",
+                    description: "Anthropic",
+                }),
+                "anthropic-version": "2023-06-01",
+            },
+            retry,
+            throttle,
+        });
+    }
+}

package/model-provider/anthropic/AnthropicError.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failedAnthropicCallResponseHandler = exports.AnthropicError = exports.anthropicErrorDataSchema = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const ApiCallError_js_1 = require("../../core/api/ApiCallError.cjs");
+exports.anthropicErrorDataSchema = zod_1.z.object({
+    error: zod_1.z.object({
+        type: zod_1.z.string(),
+        message: zod_1.z.string(),
+    }),
+});
+class AnthropicError extends ApiCallError_js_1.ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.error.message, }) {
+        super({ message, statusCode, requestBodyValues, url });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+exports.AnthropicError = AnthropicError;
+const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = exports.anthropicErrorDataSchema.parse(secure_json_parse_1.default.parse(responseBody));
+    return new AnthropicError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};
+exports.failedAnthropicCallResponseHandler = failedAnthropicCallResponseHandler;

package/model-provider/anthropic/AnthropicError.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { ApiCallError } from "../../core/api/ApiCallError.js";
+import { ResponseHandler } from "../../core/api/postToApi.js";
+export declare const anthropicErrorDataSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        type: string;
+    }, {
+        message: string;
+        type: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        message: string;
+        type: string;
+    };
+}, {
+    error: {
+        message: string;
+        type: string;
+    };
+}>;
+export type AnthropicErrorData = z.infer<typeof anthropicErrorDataSchema>;
+export declare class AnthropicError extends ApiCallError {
+    readonly data: AnthropicErrorData;
+    constructor({ data, statusCode, url, requestBodyValues, message, }: {
+        message?: string;
+        statusCode: number;
+        url: string;
+        requestBodyValues: unknown;
+        data: AnthropicErrorData;
+    });
+}
+export declare const failedAnthropicCallResponseHandler: ResponseHandler<ApiCallError>;

package/model-provider/anthropic/AnthropicError.js

@@ -0,0 +1,31 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { ApiCallError } from "../../core/api/ApiCallError.js";
+export const anthropicErrorDataSchema = z.object({
+    error: z.object({
+        type: z.string(),
+        message: z.string(),
+    }),
+});
+export class AnthropicError extends ApiCallError {
+    constructor({ data, statusCode, url, requestBodyValues, message = data.error.message, }) {
+        super({ message, statusCode, requestBodyValues, url });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+}
+export const failedAnthropicCallResponseHandler = async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const parsedError = anthropicErrorDataSchema.parse(SecureJSON.parse(responseBody));
+    return new AnthropicError({
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        data: parsedError,
+    });
+};

package/model-provider/anthropic/AnthropicPromptFormat.cjs

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapChatPromptToAnthropicFormat = exports.mapInstructionPromptToAnthropicFormat = void 0;
+const validateChatPrompt_js_1 = require("../../prompt/chat/validateChatPrompt.cjs");
+/**
+ * Formats an instruction prompt as an Anthropic prompt.
+ */
+function mapInstructionPromptToAnthropicFormat() {
+    return {
+        format: (instruction) => {
+            let text = "";
+            if (instruction.system != null) {
+                text += `${instruction.system}`;
+            }
+            text += "\n\nHuman:";
+            text += instruction.instruction;
+            if (instruction.input != null) {
+                // use tags per Anthropic instruction:
+                // https://docs.anthropic.com/claude/docs/constructing-a-prompt
+                text += `\n\n<data>${instruction.input}</data>`;
+            }
+            text += "\n\nAssistant:";
+            return text;
+        },
+        stopSequences: [],
+    };
+}
+exports.mapInstructionPromptToAnthropicFormat = mapInstructionPromptToAnthropicFormat;
+/**
+ * Formats a chat prompt as an Anthropic prompt.
+ */
+function mapChatPromptToAnthropicFormat() {
+    return {
+        format: (chatPrompt) => {
+            (0, validateChatPrompt_js_1.validateChatPrompt)(chatPrompt);
+            let text = "";
+            for (let i = 0; i < chatPrompt.length; i++) {
+                const message = chatPrompt[i];
+                // system message:
+                if (i === 0 &&
+                    "system" in message &&
+                    typeof message.system === "string") {
+                    text += `${message.system}\n\n`;
+                    continue;
+                }
+                // user message
+                if ("user" in message) {
+                    text += `\n\nHuman:${message.user}`;
+                    continue;
+                }
+                // ai message:
+                if ("ai" in message) {
+                    text += `\n\nAssistant:${message.ai}`;
+                    continue;
+                }
+                // unsupported message:
+                throw new Error(`Unsupported message: ${JSON.stringify(message)}`);
+            }
+            // AI message prefix:
+            text += `\n\nAssistant:`;
+            return text;
+        },
+        stopSequences: [],
+    };
+}
+exports.mapChatPromptToAnthropicFormat = mapChatPromptToAnthropicFormat;

package/model-provider/anthropic/AnthropicPromptFormat.d.ts

@@ -0,0 +1,11 @@
+import { ChatPrompt } from "../../prompt/chat/ChatPrompt.js";
+import { InstructionPrompt } from "../../prompt/InstructionPrompt.js";
+import { PromptFormat } from "../../prompt/PromptFormat.js";
+/**
+ * Formats an instruction prompt as an Anthropic prompt.
+ */
+export declare function mapInstructionPromptToAnthropicFormat(): PromptFormat<InstructionPrompt, string>;
+/**
+ * Formats a chat prompt as an Anthropic prompt.
+ */
+export declare function mapChatPromptToAnthropicFormat(): PromptFormat<ChatPrompt, string>;

package/model-provider/anthropic/AnthropicPromptFormat.js

@@ -0,0 +1,61 @@
+import { validateChatPrompt } from "../../prompt/chat/validateChatPrompt.js";
+/**
+ * Formats an instruction prompt as an Anthropic prompt.
+ */
+export function mapInstructionPromptToAnthropicFormat() {
+    return {
+        format: (instruction) => {
+            let text = "";
+            if (instruction.system != null) {
+                text += `${instruction.system}`;
+            }
+            text += "\n\nHuman:";
+            text += instruction.instruction;
+            if (instruction.input != null) {
+                // use tags per Anthropic instruction:
+                // https://docs.anthropic.com/claude/docs/constructing-a-prompt
+                text += `\n\n<data>${instruction.input}</data>`;
+            }
+            text += "\n\nAssistant:";
+            return text;
+        },
+        stopSequences: [],
+    };
+}
+/**
+ * Formats a chat prompt as an Anthropic prompt.
+ */
+export function mapChatPromptToAnthropicFormat() {
+    return {
+        format: (chatPrompt) => {
+            validateChatPrompt(chatPrompt);
+            let text = "";
+            for (let i = 0; i < chatPrompt.length; i++) {
+                const message = chatPrompt[i];
+                // system message:
+                if (i === 0 &&
+                    "system" in message &&
+                    typeof message.system === "string") {
+                    text += `${message.system}\n\n`;
+                    continue;
+                }
+                // user message
+                if ("user" in message) {
+                    text += `\n\nHuman:${message.user}`;
+                    continue;
+                }
+                // ai message:
+                if ("ai" in message) {
+                    text += `\n\nAssistant:${message.ai}`;
+                    continue;
+                }
+                // unsupported message:
+                throw new Error(`Unsupported message: ${JSON.stringify(message)}`);
+            }
+            // AI message prefix:
+            text += `\n\nAssistant:`;
+            return text;
+        },
+        stopSequences: [],
+    };
+}

package/model-provider/anthropic/AnthropicTextGenerationModel.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicTextGenerationResponseFormat = exports.AnthropicTextGenerationModel = exports.ANTHROPIC_TEXT_GENERATION_MODELS = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const zod_1 = require("zod");
+const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const PromptFormatTextStreamingModel_js_1 = require("../../prompt/PromptFormatTextStreamingModel.cjs");
+const AnthropicApiConfiguration_js_1 = require("./AnthropicApiConfiguration.cjs");
+const AnthropicError_js_1 = require("./AnthropicError.cjs");
+exports.ANTHROPIC_TEXT_GENERATION_MODELS = {
+    "claude-instant-1": {
+        contextWindowSize: 100000,
+    },
+    "claude-instant-1.2": {
+        contextWindowSize: 100000,
+    },
+    "claude-2": {
+        contextWindowSize: 100000,
+    },
+    "claude-2.0": {
+        contextWindowSize: 100000,
+    },
+};
+/**
+ * Create a text generation model that calls the Anthropic API.
+ *
+ * @see https://docs.anthropic.com/claude/reference/complete_post
+ */
+class AnthropicTextGenerationModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "anthropic"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        this.contextWindowSize =
+            exports.ANTHROPIC_TEXT_GENERATION_MODELS[this.settings.model].contextWindowSize;
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    async callAPI(prompt, options) {
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callAnthropicTextGenerationAPI({
+                ...this.settings,
+                stopSequences: this.settings.stopSequences,
+                maxTokens: this.settings.maxCompletionTokens,
+                abortSignal: options.run?.abortSignal,
+                responseFormat: options.responseFormat,
+                prompt,
+            }),
+        });
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "maxCompletionTokens",
+            "stopSequences",
+            "temperature",
+            "topK",
+            "topP",
+            "userId",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.AnthropicTextGenerationResponseFormat.json,
+        });
+        return {
+            response,
+            text: response.completion,
+        };
+    }
+    doStreamText(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.AnthropicTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new AnthropicTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.AnthropicTextGenerationModel = AnthropicTextGenerationModel;
+const anthropicTextGenerationResponseSchema = zod_1.z.object({
+    completion: zod_1.z.string(),
+    stop_reason: zod_1.z.string(),
+    model: zod_1.z.string(),
+});
+async function callAnthropicTextGenerationAPI({ api = new AnthropicApiConfiguration_js_1.AnthropicApiConfiguration(), abortSignal, responseFormat, model, prompt, maxTokens, stopSequences, temperature, topK, topP, userId, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: api.assembleUrl(`/complete`),
+        headers: api.headers,
+        body: {
+            model,
+            prompt,
+            stream: responseFormat.stream,
+            max_tokens_to_sample: maxTokens,
+            temperature,
+            top_k: topK,
+            top_p: topP,
+            stop_sequences: stopSequences,
+            metadata: userId != null ? { user_id: userId } : undefined,
+        },
+        failedResponseHandler: AnthropicError_js_1.failedAnthropicCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+const anthropicTextStreamingResponseSchema = zod_1.z.object({
+    completion: zod_1.z.string(),
+    stop_reason: zod_1.z.string().nullable(),
+    model: zod_1.z.string(),
+});
+async function createAnthropicFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    let content = "";
+    // process the stream asynchonously (no 'await' on purpose):
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                if (event.event === "error") {
+                    queue.push({ type: "error", error: event.data });
+                    queue.close();
+                    return;
+                }
+                if (event.event !== "completion") {
+                    continue;
+                }
+                const data = event.data;
+                const json = secure_json_parse_1.default.parse(data);
+                const parseResult = anthropicTextStreamingResponseSchema.safeParse(json);
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    queue.close();
+                    return;
+                }
+                const eventData = parseResult.data;
+                content += eventData.completion;
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content,
+                        isComplete: eventData.stop_reason != null,
+                        delta: eventData.completion,
+                    },
+                    valueDelta: eventData.completion,
+                });
+                if (eventData.stop_reason != null) {
+                    queue.close();
+                }
+            }
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+    });
+    return queue;
+}
+exports.AnthropicTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(anthropicTextGenerationResponseSchema),
+    },
+    /**
+     * 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: async ({ response }) => createAnthropicFullDeltaIterableQueue(response.body),
+    },
+};

package/model-provider/anthropic/AnthropicTextGenerationModel.d.ts

@@ -0,0 +1,102 @@
+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 { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
+import { PromptFormat } from "../../prompt/PromptFormat.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
+export declare const ANTHROPIC_TEXT_GENERATION_MODELS: {
+    "claude-instant-1": {
+        contextWindowSize: number;
+    };
+    "claude-instant-1.2": {
+        contextWindowSize: number;
+    };
+    "claude-2": {
+        contextWindowSize: number;
+    };
+    "claude-2.0": {
+        contextWindowSize: number;
+    };
+};
+export type AnthropicTextGenerationModelType = keyof typeof ANTHROPIC_TEXT_GENERATION_MODELS;
+export interface AnthropicTextGenerationModelSettings extends TextGenerationModelSettings {
+    api?: ApiConfiguration;
+    model: AnthropicTextGenerationModelType;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    userId?: number;
+}
+/**
+ * Create a text generation model that calls the Anthropic API.
+ *
+ * @see https://docs.anthropic.com/claude/reference/complete_post
+ */
+export declare class AnthropicTextGenerationModel extends AbstractModel<AnthropicTextGenerationModelSettings> implements TextStreamingModel<string, AnthropicTextGenerationModelSettings> {
+    constructor(settings: AnthropicTextGenerationModelSettings);
+    readonly provider: "anthropic";
+    get modelName(): "claude-instant-1" | "claude-instant-1.2" | "claude-2" | "claude-2.0";
+    readonly contextWindowSize: number;
+    readonly tokenizer: undefined;
+    readonly countPromptTokens: undefined;
+    callAPI<RESPONSE>(prompt: string, options: {
+        responseFormat: AnthropicTextGenerationResponseFormatType<RESPONSE>;
+    } & FunctionOptions): Promise<RESPONSE>;
+    get settingsForEvent(): Partial<AnthropicTextGenerationModelSettings>;
+    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            model: string;
+            completion: string;
+            stop_reason: string;
+        };
+        text: string;
+    }>;
+    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextStreamingModel<INPUT_PROMPT, string, AnthropicTextGenerationModelSettings, this>;
+    withSettings(additionalSettings: Partial<AnthropicTextGenerationModelSettings>): this;
+}
+declare const anthropicTextGenerationResponseSchema: z.ZodObject<{
+    completion: z.ZodString;
+    stop_reason: z.ZodString;
+    model: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    completion: string;
+    stop_reason: string;
+}, {
+    model: string;
+    completion: string;
+    stop_reason: string;
+}>;
+export type AnthropicTextGenerationResponse = z.infer<typeof anthropicTextGenerationResponseSchema>;
+export type AnthropicTextGenerationResponseFormatType<T> = {
+    stream: boolean;
+    handler: ResponseHandler<T>;
+};
+export declare const AnthropicTextGenerationResponseFormat: {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false;
+        handler: ResponseHandler<{
+            model: string;
+            completion: string;
+            stop_reason: string;
+        }>;
+    };
+    /**
+     * 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/anthropic/AnthropicTextGenerationModel.js

@@ -0,0 +1,219 @@
+import SecureJSON from "secure-json-parse";
+import { z } from "zod";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
+import { AnthropicApiConfiguration } from "./AnthropicApiConfiguration.js";
+import { failedAnthropicCallResponseHandler } from "./AnthropicError.js";
+export const ANTHROPIC_TEXT_GENERATION_MODELS = {
+    "claude-instant-1": {
+        contextWindowSize: 100000,
+    },
+    "claude-instant-1.2": {
+        contextWindowSize: 100000,
+    },
+    "claude-2": {
+        contextWindowSize: 100000,
+    },
+    "claude-2.0": {
+        contextWindowSize: 100000,
+    },
+};
+/**
+ * Create a text generation model that calls the Anthropic API.
+ *
+ * @see https://docs.anthropic.com/claude/reference/complete_post
+ */
+export class AnthropicTextGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "anthropic"
+        });
+        Object.defineProperty(this, "contextWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        this.contextWindowSize =
+            ANTHROPIC_TEXT_GENERATION_MODELS[this.settings.model].contextWindowSize;
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    async callAPI(prompt, options) {
+        return callWithRetryAndThrottle({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callAnthropicTextGenerationAPI({
+                ...this.settings,
+                stopSequences: this.settings.stopSequences,
+                maxTokens: this.settings.maxCompletionTokens,
+                abortSignal: options.run?.abortSignal,
+                responseFormat: options.responseFormat,
+                prompt,
+            }),
+        });
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            "maxCompletionTokens",
+            "stopSequences",
+            "temperature",
+            "topK",
+            "topP",
+            "userId",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: AnthropicTextGenerationResponseFormat.json,
+        });
+        return {
+            response,
+            text: response.completion,
+        };
+    }
+    doStreamText(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: AnthropicTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new AnthropicTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+const anthropicTextGenerationResponseSchema = z.object({
+    completion: z.string(),
+    stop_reason: z.string(),
+    model: z.string(),
+});
+async function callAnthropicTextGenerationAPI({ api = new AnthropicApiConfiguration(), abortSignal, responseFormat, model, prompt, maxTokens, stopSequences, temperature, topK, topP, userId, }) {
+    return postJsonToApi({
+        url: api.assembleUrl(`/complete`),
+        headers: api.headers,
+        body: {
+            model,
+            prompt,
+            stream: responseFormat.stream,
+            max_tokens_to_sample: maxTokens,
+            temperature,
+            top_k: topK,
+            top_p: topP,
+            stop_sequences: stopSequences,
+            metadata: userId != null ? { user_id: userId } : undefined,
+        },
+        failedResponseHandler: failedAnthropicCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+const anthropicTextStreamingResponseSchema = z.object({
+    completion: z.string(),
+    stop_reason: z.string().nullable(),
+    model: z.string(),
+});
+async function createAnthropicFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue();
+    let content = "";
+    // process the stream asynchonously (no 'await' on purpose):
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                if (event.event === "error") {
+                    queue.push({ type: "error", error: event.data });
+                    queue.close();
+                    return;
+                }
+                if (event.event !== "completion") {
+                    continue;
+                }
+                const data = event.data;
+                const json = SecureJSON.parse(data);
+                const parseResult = anthropicTextStreamingResponseSchema.safeParse(json);
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    queue.close();
+                    return;
+                }
+                const eventData = parseResult.data;
+                content += eventData.completion;
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content,
+                        isComplete: eventData.stop_reason != null,
+                        delta: eventData.completion,
+                    },
+                    valueDelta: eventData.completion,
+                });
+                if (eventData.stop_reason != null) {
+                    queue.close();
+                }
+            }
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+    });
+    return queue;
+}
+export const AnthropicTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(anthropicTextGenerationResponseSchema),
+    },
+    /**
+     * 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: async ({ response }) => createAnthropicFullDeltaIterableQueue(response.body),
+    },
+};

package/model-provider/anthropic/index.cjs

@@ -0,0 +1,23 @@
+"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.anthropicErrorDataSchema = exports.AnthropicError = void 0;
+__exportStar(require("./AnthropicApiConfiguration.cjs"), exports);
+var AnthropicError_js_1 = require("./AnthropicError.cjs");
+Object.defineProperty(exports, "AnthropicError", { enumerable: true, get: function () { return AnthropicError_js_1.AnthropicError; } });
+Object.defineProperty(exports, "anthropicErrorDataSchema", { enumerable: true, get: function () { return AnthropicError_js_1.anthropicErrorDataSchema; } });
+__exportStar(require("./AnthropicPromptFormat.cjs"), exports);
+__exportStar(require("./AnthropicTextGenerationModel.cjs"), exports);

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

@@ -0,0 +1,4 @@
+export * from "./AnthropicApiConfiguration.js";
+export { AnthropicError, anthropicErrorDataSchema } from "./AnthropicError.js";
+export * from "./AnthropicPromptFormat.js";
+export * from "./AnthropicTextGenerationModel.js";

package/model-provider/anthropic/index.js

@@ -0,0 +1,4 @@
+export * from "./AnthropicApiConfiguration.js";
+export { AnthropicError, anthropicErrorDataSchema } from "./AnthropicError.js";
+export * from "./AnthropicPromptFormat.js";
+export * from "./AnthropicTextGenerationModel.js";

package/model-provider/huggingface/HuggingFaceTextGenerationModel.d.ts

@@ -44,9 +44,9 @@ export declare class HuggingFaceTextGenerationModel extends AbstractModel<Huggin
     get modelName(): string;
     readonly contextWindowSize: undefined;
     readonly tokenizer: undefined;
+    readonly countPromptTokens: undefined;
     callAPI(prompt: string, options?: FunctionOptions): Promise<HuggingFaceTextGenerationResponse>;
     get settingsForEvent(): Partial<HuggingFaceTextGenerationModelSettings>;
-    readonly countPromptTokens: undefined;
     doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
         response: {
             generated_text: string;

package/model-provider/index.cjs

@@ -14,6 +14,7 @@ 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 });
+__exportStar(require("./anthropic/index.cjs"), exports);
 __exportStar(require("./automatic1111/index.cjs"), exports);
 __exportStar(require("./cohere/index.cjs"), exports);
 __exportStar(require("./elevenlabs/index.cjs"), exports);

package/model-provider/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./anthropic/index.js";
 export * from "./automatic1111/index.js";
 export * from "./cohere/index.js";
 export * from "./elevenlabs/index.js";

package/model-provider/index.js

@@ -1,3 +1,4 @@
+export * from "./anthropic/index.js";
 export * from "./automatic1111/index.js";
 export * from "./cohere/index.js";
 export * from "./elevenlabs/index.js";

package/model-provider/llamacpp/LlamaCppTextGenerationModel.cjs

@@ -102,9 +102,6 @@ class LlamaCppTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             responseFormat: exports.LlamaCppTextGenerationResponseFormat.deltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta.delta;
-    }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
             model: this.withSettings({

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

@@ -100,7 +100,6 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
         };
     }>;
     doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
-    extractTextDelta(fullDelta: LlamaCppTextGenerationDelta): string | undefined;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextStreamingModel<INPUT_PROMPT, string, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
     withSettings(additionalSettings: Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;
 }

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -96,9 +96,6 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
             responseFormat: LlamaCppTextGenerationResponseFormat.deltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta.delta;
-    }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextStreamingModel({
             model: this.withSettings({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.41.2",
+  "version": "0.42.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/prompt/PromptFormatTextGenerationModel.cjs

@@ -41,6 +41,9 @@ class PromptFormatTextGenerationModel {
         const mappedPrompt = this.promptFormat.format(prompt);
         return this.model.doGenerateText(mappedPrompt, options);
     }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel({
             model: this.withSettings({
@@ -52,9 +55,6 @@ class PromptFormatTextGenerationModel {
             promptFormat,
         });
     }
-    get settingsForEvent() {
-        return this.model.settingsForEvent;
-    }
     withSettings(additionalSettings) {
         return new PromptFormatTextGenerationModel({
             model: this.model.withSettings(additionalSettings),

package/prompt/PromptFormatTextGenerationModel.d.ts

@@ -22,7 +22,7 @@ export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, SETTI
             totalTokens: number;
         } | undefined;
     }>;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     get settingsForEvent(): Partial<SETTINGS>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/prompt/PromptFormatTextGenerationModel.js

@@ -38,6 +38,9 @@ export class PromptFormatTextGenerationModel {
         const mappedPrompt = this.promptFormat.format(prompt);
         return this.model.doGenerateText(mappedPrompt, options);
     }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel({
             model: this.withSettings({
@@ -49,9 +52,6 @@ export class PromptFormatTextGenerationModel {
             promptFormat,
         });
     }
-    get settingsForEvent() {
-        return this.model.settingsForEvent;
-    }
     withSettings(additionalSettings) {
         return new PromptFormatTextGenerationModel({
             model: this.model.withSettings(additionalSettings),

package/util/getAudioFileExtension.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioFileExtension = void 0;
+function getAudioFileExtension(mimeType) {
+    const normalizedMimeType = mimeType.split(";")[0].toLowerCase();
+    switch (normalizedMimeType) {
+        case "audio/webm":
+            return "webm";
+        case "audio/mp3":
+            return "mp3";
+        case "audio/wav":
+            return "wav";
+        case "audio/mp4":
+            return "mp4";
+        case "audio/mpeg":
+        case "audio/mpga":
+            return "mpeg";
+        case "audio/ogg":
+        case "audio/oga":
+            return "ogg";
+        case "audio/flac":
+            return "flac";
+        case "audio/m4a":
+            return "m4a";
+        default:
+            throw new Error(`Unsupported audio format: ${mimeType}`);
+    }
+}
+exports.getAudioFileExtension = getAudioFileExtension;

package/util/getAudioFileExtension.d.ts

@@ -0,0 +1 @@
+export declare function getAudioFileExtension(mimeType: string): "mp3" | "flac" | "m4a" | "mp4" | "mpeg" | "ogg" | "wav" | "webm";

package/util/getAudioFileExtension.js

@@ -0,0 +1,25 @@
+export function getAudioFileExtension(mimeType) {
+    const normalizedMimeType = mimeType.split(";")[0].toLowerCase();
+    switch (normalizedMimeType) {
+        case "audio/webm":
+            return "webm";
+        case "audio/mp3":
+            return "mp3";
+        case "audio/wav":
+            return "wav";
+        case "audio/mp4":
+            return "mp4";
+        case "audio/mpeg":
+        case "audio/mpga":
+            return "mpeg";
+        case "audio/ogg":
+        case "audio/oga":
+            return "ogg";
+        case "audio/flac":
+            return "flac";
+        case "audio/m4a":
+            return "m4a";
+        default:
+            throw new Error(`Unsupported audio format: ${mimeType}`);
+    }
+}

package/util/index.cjs

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./cosineSimilarity.cjs"), exports);
+__exportStar(require("./getAudioFileExtension.cjs"), exports);

package/util/index.d.ts

@@ -1 +1,2 @@
 export * from "./cosineSimilarity.js";
+export * from "./getAudioFileExtension.js";

package/util/index.js

@@ -1 +1,2 @@
 export * from "./cosineSimilarity.js";
+export * from "./getAudioFileExtension.js";