@nocobase/plugin-ai 2.0.0-alpha.6 → 2.0.0-alpha.60

package/dist/node_modules/@langchain/ollama/dist/llms.d.ts

@@ -0,0 +1,130 @@
+import type { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { GenerationChunk } from "@langchain/core/outputs";
+import type { StringWithAutocomplete } from "@langchain/core/utils/types";
+import { LLM, type BaseLLMParams } from "@langchain/core/language_models/llms";
+import { Ollama as OllamaClient } from "ollama/browser";
+import { OllamaCamelCaseOptions } from "./types.js";
+export interface OllamaCallOptions extends BaseLanguageModelCallOptions {
+    images?: string[];
+}
+export interface OllamaInput extends BaseLLMParams, OllamaCamelCaseOptions {
+    /**
+     * The model to use when making requests.
+     * @default "llama3"
+     */
+    model?: string;
+    /**
+     * Optionally override the base URL to make request to.
+     * This should only be set if your Ollama instance is being
+     * server from a non-standard location.
+     * @default "http://localhost:11434"
+     */
+    baseUrl?: string;
+    format?: string;
+    /**
+     * Optional HTTP Headers to include in the request.
+     */
+    headers?: Headers;
+}
+/**
+ * Class that represents the Ollama language model. It extends the base
+ * LLM class and implements the OllamaInput interface.
+ * @example
+ * ```typescript
+ * const ollama = new Ollama({
+ *   baseUrl: "http://api.example.com",
+ *   model: "llama3",
+ * });
+ *
+ * // Streaming translation from English to German
+ * const stream = await ollama.stream(
+ *   `Translate "I love programming" into German.`
+ * );
+ *
+ * const chunks = [];
+ * for await (const chunk of stream) {
+ *   chunks.push(chunk);
+ * }
+ *
+ * console.log(chunks.join(""));
+ * ```
+ */
+export declare class Ollama extends LLM<OllamaCallOptions> implements OllamaInput {
+    static lc_name(): string;
+    lc_serializable: boolean;
+    model: string;
+    baseUrl: string;
+    keepAlive?: string | number;
+    embeddingOnly?: boolean;
+    f16KV?: boolean;
+    frequencyPenalty?: number;
+    logitsAll?: boolean;
+    lowVram?: boolean;
+    mainGpu?: number;
+    mirostat?: number;
+    mirostatEta?: number;
+    mirostatTau?: number;
+    numBatch?: number;
+    numCtx?: number;
+    numGpu?: number;
+    numKeep?: number;
+    numPredict?: number;
+    numThread?: number;
+    penalizeNewline?: boolean;
+    presencePenalty?: number;
+    repeatLastN?: number;
+    repeatPenalty?: number;
+    temperature?: number;
+    stop?: string[];
+    tfsZ?: number;
+    topK?: number;
+    topP?: number;
+    typicalP?: number;
+    useMLock?: boolean;
+    useMMap?: boolean;
+    vocabOnly?: boolean;
+    format?: StringWithAutocomplete<"json">;
+    client: OllamaClient;
+    constructor(fields?: OllamaInput & BaseLLMParams);
+    _llmType(): string;
+    invocationParams(options?: this["ParsedCallOptions"]): {
+        model: string;
+        format: StringWithAutocomplete<"json"> | undefined;
+        keep_alive: string | number | undefined;
+        images: string[] | undefined;
+        options: {
+            embedding_only: boolean | undefined;
+            f16_kv: boolean | undefined;
+            frequency_penalty: number | undefined;
+            logits_all: boolean | undefined;
+            low_vram: boolean | undefined;
+            main_gpu: number | undefined;
+            mirostat: number | undefined;
+            mirostat_eta: number | undefined;
+            mirostat_tau: number | undefined;
+            num_batch: number | undefined;
+            num_ctx: number | undefined;
+            num_gpu: number | undefined;
+            num_keep: number | undefined;
+            num_predict: number | undefined;
+            num_thread: number | undefined;
+            penalize_newline: boolean | undefined;
+            presence_penalty: number | undefined;
+            repeat_last_n: number | undefined;
+            repeat_penalty: number | undefined;
+            temperature: number | undefined;
+            stop: string[] | undefined;
+            tfs_z: number | undefined;
+            top_k: number | undefined;
+            top_p: number | undefined;
+            typical_p: number | undefined;
+            use_mlock: boolean | undefined;
+            use_mmap: boolean | undefined;
+            vocab_only: boolean | undefined;
+        };
+    };
+    _streamResponseChunks(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+    /** @ignore */
+    _call(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+}

package/dist/node_modules/@langchain/ollama/dist/llms.js

@@ -0,0 +1,361 @@
+import { GenerationChunk } from "@langchain/core/outputs";
+import { LLM } from "@langchain/core/language_models/llms";
+import { Ollama as OllamaClient } from "ollama/browser";
+/**
+ * Class that represents the Ollama language model. It extends the base
+ * LLM class and implements the OllamaInput interface.
+ * @example
+ * ```typescript
+ * const ollama = new Ollama({
+ *   baseUrl: "http://api.example.com",
+ *   model: "llama3",
+ * });
+ *
+ * // Streaming translation from English to German
+ * const stream = await ollama.stream(
+ *   `Translate "I love programming" into German.`
+ * );
+ *
+ * const chunks = [];
+ * for await (const chunk of stream) {
+ *   chunks.push(chunk);
+ * }
+ *
+ * console.log(chunks.join(""));
+ * ```
+ */
+export class Ollama extends LLM {
+    static lc_name() {
+        return "Ollama";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "llama3"
+        });
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "http://localhost:11434"
+        });
+        Object.defineProperty(this, "keepAlive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "f16KV", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "frequencyPenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logitsAll", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lowVram", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mainGpu", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mirostat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mirostatEta", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mirostatTau", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numBatch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numCtx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numGpu", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numKeep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numPredict", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numThread", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "penalizeNewline", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "presencePenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "repeatLastN", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "repeatPenalty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tfsZ", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "topK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "typicalP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useMLock", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "useMMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vocabOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "format", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields?.model ?? this.model;
+        this.baseUrl = fields?.baseUrl?.endsWith("/")
+            ? fields?.baseUrl.slice(0, -1)
+            : fields?.baseUrl ?? this.baseUrl;
+        this.client = new OllamaClient({
+            host: this.baseUrl,
+            headers: fields?.headers,
+        });
+        this.keepAlive = fields?.keepAlive;
+        this.embeddingOnly = fields?.embeddingOnly;
+        this.f16KV = fields?.f16Kv;
+        this.frequencyPenalty = fields?.frequencyPenalty;
+        this.logitsAll = fields?.logitsAll;
+        this.lowVram = fields?.lowVram;
+        this.mainGpu = fields?.mainGpu;
+        this.mirostat = fields?.mirostat;
+        this.mirostatEta = fields?.mirostatEta;
+        this.mirostatTau = fields?.mirostatTau;
+        this.numBatch = fields?.numBatch;
+        this.numCtx = fields?.numCtx;
+        this.numGpu = fields?.numGpu;
+        this.numKeep = fields?.numKeep;
+        this.numPredict = fields?.numPredict;
+        this.numThread = fields?.numThread;
+        this.penalizeNewline = fields?.penalizeNewline;
+        this.presencePenalty = fields?.presencePenalty;
+        this.repeatLastN = fields?.repeatLastN;
+        this.repeatPenalty = fields?.repeatPenalty;
+        this.temperature = fields?.temperature;
+        this.stop = fields?.stop;
+        this.tfsZ = fields?.tfsZ;
+        this.topK = fields?.topK;
+        this.topP = fields?.topP;
+        this.typicalP = fields?.typicalP;
+        this.useMLock = fields?.useMlock;
+        this.useMMap = fields?.useMmap;
+        this.vocabOnly = fields?.vocabOnly;
+        this.format = fields?.format;
+    }
+    _llmType() {
+        return "ollama";
+    }
+    invocationParams(options) {
+        return {
+            model: this.model,
+            format: this.format,
+            keep_alive: this.keepAlive,
+            images: options?.images,
+            options: {
+                embedding_only: this.embeddingOnly,
+                f16_kv: this.f16KV,
+                frequency_penalty: this.frequencyPenalty,
+                logits_all: this.logitsAll,
+                low_vram: this.lowVram,
+                main_gpu: this.mainGpu,
+                mirostat: this.mirostat,
+                mirostat_eta: this.mirostatEta,
+                mirostat_tau: this.mirostatTau,
+                num_batch: this.numBatch,
+                num_ctx: this.numCtx,
+                num_gpu: this.numGpu,
+                num_keep: this.numKeep,
+                num_predict: this.numPredict,
+                num_thread: this.numThread,
+                penalize_newline: this.penalizeNewline,
+                presence_penalty: this.presencePenalty,
+                repeat_last_n: this.repeatLastN,
+                repeat_penalty: this.repeatPenalty,
+                temperature: this.temperature,
+                stop: options?.stop ?? this.stop,
+                tfs_z: this.tfsZ,
+                top_k: this.topK,
+                top_p: this.topP,
+                typical_p: this.typicalP,
+                use_mlock: this.useMLock,
+                use_mmap: this.useMMap,
+                vocab_only: this.vocabOnly,
+            },
+        };
+    }
+    async *_streamResponseChunks(prompt, options, runManager) {
+        const stream = await this.caller.call(async () => this.client.generate({
+            ...this.invocationParams(options),
+            prompt,
+            stream: true,
+        }));
+        for await (const chunk of stream) {
+            if (options.signal?.aborted) {
+                throw new Error("This operation was aborted");
+            }
+            if (!chunk.done) {
+                yield new GenerationChunk({
+                    text: chunk.response,
+                    generationInfo: {
+                        ...chunk,
+                        response: undefined,
+                    },
+                });
+                await runManager?.handleLLMNewToken(chunk.response ?? "");
+            }
+            else {
+                yield new GenerationChunk({
+                    text: "",
+                    generationInfo: {
+                        model: chunk.model,
+                        total_duration: chunk.total_duration,
+                        load_duration: chunk.load_duration,
+                        prompt_eval_count: chunk.prompt_eval_count,
+                        prompt_eval_duration: chunk.prompt_eval_duration,
+                        eval_count: chunk.eval_count,
+                        eval_duration: chunk.eval_duration,
+                    },
+                });
+            }
+        }
+    }
+    /** @ignore */
+    async _call(prompt, options, runManager) {
+        const chunks = [];
+        for await (const chunk of this._streamResponseChunks(prompt, options, runManager)) {
+            chunks.push(chunk.text);
+        }
+        return chunks.join("");
+    }
+}

package/dist/node_modules/@langchain/ollama/dist/types.cjs

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

package/dist/node_modules/@langchain/ollama/dist/types.d.ts

@@ -0,0 +1,36 @@
+export interface OllamaCamelCaseOptions {
+    numa?: boolean;
+    numCtx?: number;
+    numBatch?: number;
+    numGpu?: number;
+    mainGpu?: number;
+    lowVram?: boolean;
+    f16Kv?: boolean;
+    logitsAll?: boolean;
+    vocabOnly?: boolean;
+    useMmap?: boolean;
+    useMlock?: boolean;
+    embeddingOnly?: boolean;
+    numThread?: number;
+    numKeep?: number;
+    seed?: number;
+    numPredict?: number;
+    topK?: number;
+    topP?: number;
+    tfsZ?: number;
+    typicalP?: number;
+    repeatLastN?: number;
+    temperature?: number;
+    repeatPenalty?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    mirostat?: number;
+    mirostatTau?: number;
+    mirostatEta?: number;
+    penalizeNewline?: boolean;
+    /**
+     * @default "5m"
+     */
+    keepAlive?: string | number;
+    stop?: string[];
+}

package/dist/node_modules/@langchain/ollama/dist/types.js

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

package/dist/node_modules/@langchain/ollama/dist/utils.cjs

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToOllamaMessages = exports.convertOllamaMessagesToLangChain = void 0;
+const messages_1 = require("@langchain/core/messages");
+const uuid_1 = require("uuid");
+function convertOllamaMessagesToLangChain(messages, extra) {
+    return new messages_1.AIMessageChunk({
+        content: messages.content ?? "",
+        tool_call_chunks: messages.tool_calls?.map((tc) => ({
+            name: tc.function.name,
+            args: JSON.stringify(tc.function.arguments),
+            type: "tool_call_chunk",
+            index: 0,
+            id: (0, uuid_1.v4)(),
+        })),
+        response_metadata: extra?.responseMetadata,
+        usage_metadata: extra?.usageMetadata,
+    });
+}
+exports.convertOllamaMessagesToLangChain = convertOllamaMessagesToLangChain;
+function extractBase64FromDataUrl(dataUrl) {
+    const match = dataUrl.match(/^data:.*?;base64,(.*)$/);
+    return match ? match[1] : "";
+}
+function convertAMessagesToOllama(messages) {
+    if (typeof messages.content === "string") {
+        return [
+            {
+                role: "assistant",
+                content: messages.content,
+            },
+        ];
+    }
+    const textFields = messages.content.filter((c) => c.type === "text" && typeof c.text === "string");
+    const textMessages = textFields.map((c) => ({
+        role: "assistant",
+        content: c.text,
+    }));
+    let toolCallMsgs;
+    if (messages.content.find((c) => c.type === "tool_use") &&
+        messages.tool_calls?.length) {
+        // `tool_use` content types are accepted if the message has tool calls
+        const toolCalls = messages.tool_calls?.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+                name: tc.name,
+                arguments: tc.args,
+            },
+        }));
+        if (toolCalls) {
+            toolCallMsgs = {
+                role: "assistant",
+                tool_calls: toolCalls,
+                content: "",
+            };
+        }
+    }
+    else if (messages.content.find((c) => c.type === "tool_use") &&
+        !messages.tool_calls?.length) {
+        throw new Error("'tool_use' content type is not supported without tool calls.");
+    }
+    return [...textMessages, ...(toolCallMsgs ? [toolCallMsgs] : [])];
+}
+function convertHumanGenericMessagesToOllama(message) {
+    if (typeof message.content === "string") {
+        return [
+            {
+                role: "user",
+                content: message.content,
+            },
+        ];
+    }
+    return message.content.map((c) => {
+        if (c.type === "text") {
+            return {
+                role: "user",
+                content: c.text,
+            };
+        }
+        else if (c.type === "image_url") {
+            if (typeof c.image_url === "string") {
+                return {
+                    role: "user",
+                    content: "",
+                    images: [extractBase64FromDataUrl(c.image_url)],
+                };
+            }
+            else if (c.image_url.url && typeof c.image_url.url === "string") {
+                return {
+                    role: "user",
+                    content: "",
+                    images: [extractBase64FromDataUrl(c.image_url.url)],
+                };
+            }
+        }
+        throw new Error(`Unsupported content type: ${c.type}`);
+    });
+}
+function convertSystemMessageToOllama(message) {
+    if (typeof message.content === "string") {
+        return [
+            {
+                role: "system",
+                content: message.content,
+            },
+        ];
+    }
+    else if (message.content.every((c) => c.type === "text" && typeof c.text === "string")) {
+        return message.content.map((c) => ({
+            role: "system",
+            content: c.text,
+        }));
+    }
+    else {
+        throw new Error(`Unsupported content type(s): ${message.content
+            .map((c) => c.type)
+            .join(", ")}`);
+    }
+}
+function convertToolMessageToOllama(message) {
+    if (typeof message.content !== "string") {
+        throw new Error("Non string tool message content is not supported");
+    }
+    return [
+        {
+            role: "tool",
+            content: message.content,
+        },
+    ];
+}
+function convertToOllamaMessages(messages) {
+    return messages.flatMap((msg) => {
+        if (["human", "generic"].includes(msg._getType())) {
+            return convertHumanGenericMessagesToOllama(msg);
+        }
+        else if (msg._getType() === "ai") {
+            return convertAMessagesToOllama(msg);
+        }
+        else if (msg._getType() === "system") {
+            return convertSystemMessageToOllama(msg);
+        }
+        else if (msg._getType() === "tool") {
+            return convertToolMessageToOllama(msg);
+        }
+        else {
+            throw new Error(`Unsupported message type: ${msg._getType()}`);
+        }
+    });
+}
+exports.convertToOllamaMessages = convertToOllamaMessages;

package/dist/node_modules/@langchain/ollama/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import { AIMessageChunk, BaseMessage, UsageMetadata } from "@langchain/core/messages";
+import type { Message as OllamaMessage } from "ollama";
+export declare function convertOllamaMessagesToLangChain(messages: OllamaMessage, extra?: {
+    responseMetadata?: Record<string, any>;
+    usageMetadata?: UsageMetadata;
+}): AIMessageChunk;
+export declare function convertToOllamaMessages(messages: BaseMessage[]): OllamaMessage[];