@nocobase/plugin-ai 1.9.32 → 1.9.34

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/middleware.d.ts

@@ -0,0 +1,27 @@
+import type { LanguageModelV2Middleware, SharedV2ProviderMetadata, LanguageModelV2FinishReason } from "@ai-sdk/provider";
+import type { RunTreeConfig } from "../../run_trees.js";
+export type AggregatedDoStreamOutput = {
+    content: string;
+    role: "assistant";
+    tool_calls: {
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
+    providerMetadata?: SharedV2ProviderMetadata;
+    finishReason?: LanguageModelV2FinishReason;
+};
+/**
+ * AI SDK middleware that wraps an AI SDK 5 model and adds LangSmith tracing.
+ */
+export declare function LangSmithMiddleware(config?: {
+    name: string;
+    modelId?: string;
+    lsConfig?: Partial<Omit<RunTreeConfig, "inputs" | "outputs" | "run_type">> & {
+        processInputs?: (inputs: Record<string, unknown>) => Record<string, unknown>;
+        processOutputs?: (outputs: Record<string, unknown>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    };
+}): LanguageModelV2Middleware;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/middleware.js

@@ -0,0 +1,232 @@
+import { getCurrentRunTree, traceable } from "../../traceable.js";
+import { extractInputTokenDetails, extractOutputTokenDetails, } from "../../utils/vercel.js";
+import { convertMessageToTracedFormat } from "./utils.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const _formatTracedInputs = (params) => {
+    const { prompt, ...rest } = params;
+    if (prompt == null) {
+        return params;
+    }
+    if (Array.isArray(prompt)) {
+        return { ...rest, messages: prompt.map(convertMessageToTracedFormat) };
+    }
+    return rest;
+};
+const _formatTracedOutputs = (outputs) => {
+    const formattedOutputs = { ...outputs };
+    if (formattedOutputs.role == null) {
+        formattedOutputs.role = formattedOutputs.type ?? "assistant";
+    }
+    return convertMessageToTracedFormat(formattedOutputs);
+};
+const setUsageMetadataOnRunTree = (result, runTree) => {
+    if (result.usage == null || typeof result.usage !== "object") {
+        return;
+    }
+    // Shim for AI SDK 4
+    const inputTokens = result.usage?.inputTokens ??
+        result.usage?.promptTokens;
+    const outputTokens = result.usage?.outputTokens ??
+        result.usage?.completionTokens;
+    let totalTokens = result.usage?.totalTokens;
+    if (typeof totalTokens !== "number" &&
+        typeof inputTokens === "number" &&
+        typeof outputTokens === "number") {
+        totalTokens = inputTokens + outputTokens;
+    }
+    const langsmithUsage = {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+    };
+    const inputTokenDetails = extractInputTokenDetails(result.usage, result.providerMetadata);
+    const outputTokenDetails = extractOutputTokenDetails(result.usage, result.providerMetadata);
+    runTree.extra = {
+        ...runTree.extra,
+        metadata: {
+            ...runTree.extra?.metadata,
+            usage_metadata: {
+                ...langsmithUsage,
+                input_token_details: {
+                    ...inputTokenDetails,
+                },
+                output_token_details: {
+                    ...outputTokenDetails,
+                },
+            },
+        },
+    };
+};
+/**
+ * AI SDK middleware that wraps an AI SDK 5 model and adds LangSmith tracing.
+ */
+export function LangSmithMiddleware(config) {
+    const { name, modelId, lsConfig } = config ?? {};
+    return {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const traceableFunc = traceable(async (_params) => {
+                const result = await doGenerate();
+                const currentRunTree = getCurrentRunTree(true);
+                if (currentRunTree !== undefined) {
+                    setUsageMetadataOnRunTree(result, currentRunTree);
+                }
+                return result;
+            }, {
+                ...lsConfig,
+                name: name ?? "ai.doGenerate",
+                run_type: "llm",
+                metadata: {
+                    ls_model_name: modelId,
+                    ai_sdk_method: "ai.doGenerate",
+                    ...lsConfig?.metadata,
+                },
+                processInputs: (inputs) => {
+                    const typedInputs = inputs;
+                    const inputFormatter = lsConfig?.processInputs ?? _formatTracedInputs;
+                    return inputFormatter(typedInputs);
+                },
+                processOutputs: (outputs) => {
+                    const typedOutputs = outputs;
+                    const outputFormatter = lsConfig?.processOutputs ?? _formatTracedOutputs;
+                    return outputFormatter(typedOutputs);
+                },
+            });
+            const res = await traceableFunc(params);
+            return res;
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const parentRunTree = getCurrentRunTree(true);
+            let runTree;
+            if (parentRunTree != null &&
+                typeof parentRunTree === "object" &&
+                typeof parentRunTree.createChild === "function") {
+                const inputFormatter = lsConfig?.processInputs ?? _formatTracedInputs;
+                const formattedInputs = inputFormatter(params);
+                runTree = parentRunTree?.createChild({
+                    ...lsConfig,
+                    name: name ?? "ai.doStream",
+                    run_type: "llm",
+                    metadata: {
+                        ls_model_name: modelId,
+                        ai_sdk_method: "ai.doStream",
+                        ...lsConfig?.metadata,
+                    },
+                    inputs: formattedInputs,
+                });
+            }
+            await runTree?.postRun();
+            try {
+                const { stream, ...rest } = await doStream();
+                const chunks = [];
+                const transformStream = new TransformStream({
+                    async transform(chunk, controller) {
+                        if (chunk.type === "tool-input-start" ||
+                            chunk.type === "text-start") {
+                            // Only necessary to log the first token event
+                            if (runTree?.events == null ||
+                                (Array.isArray(runTree.events) && runTree.events.length === 0)) {
+                                runTree?.addEvent({ name: "new_token" });
+                            }
+                        }
+                        else if (chunk.type === "finish") {
+                            runTree?.addEvent({ name: "end" });
+                        }
+                        chunks.push(chunk);
+                        controller.enqueue(chunk);
+                    },
+                    async flush() {
+                        try {
+                            const output = chunks.reduce((aggregated, chunk) => {
+                                if (chunk.type === "text-delta") {
+                                    if (chunk.delta != null) {
+                                        return {
+                                            ...aggregated,
+                                            content: aggregated.content + chunk.delta,
+                                        };
+                                    }
+                                    else if ("textDelta" in chunk &&
+                                        chunk.textDelta != null) {
+                                        // AI SDK 4 shim
+                                        return {
+                                            ...aggregated,
+                                            content: aggregated.content + chunk.textDelta,
+                                        };
+                                    }
+                                    else {
+                                        return aggregated;
+                                    }
+                                }
+                                else if (chunk.type === "tool-call") {
+                                    const matchingToolCall = aggregated.tool_calls.find((call) => call.id === chunk.toolCallId);
+                                    if (matchingToolCall != null) {
+                                        return aggregated;
+                                    }
+                                    let chunkArgs = chunk.input;
+                                    if (chunkArgs == null &&
+                                        "args" in chunk &&
+                                        typeof chunk.args === "string") {
+                                        chunkArgs = chunk.args;
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        tool_calls: [
+                                            ...aggregated.tool_calls,
+                                            {
+                                                id: chunk.toolCallId,
+                                                type: "function",
+                                                function: {
+                                                    name: chunk.toolName,
+                                                    arguments: chunkArgs,
+                                                },
+                                            },
+                                        ],
+                                    };
+                                }
+                                else if (chunk.type === "finish") {
+                                    if (runTree != null) {
+                                        setUsageMetadataOnRunTree(chunk, runTree);
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        providerMetadata: chunk.providerMetadata,
+                                        finishReason: chunk.finishReason,
+                                    };
+                                }
+                                else {
+                                    return aggregated;
+                                }
+                            }, {
+                                content: "",
+                                role: "assistant",
+                                tool_calls: [],
+                            });
+                            const outputFormatter = lsConfig?.processOutputs ?? convertMessageToTracedFormat;
+                            const formattedOutputs = await outputFormatter(output);
+                            await runTree?.end(formattedOutputs);
+                        }
+                        catch (error) {
+                            await runTree?.end(undefined, error.message ?? String(error));
+                            throw error;
+                        }
+                        finally {
+                            await runTree?.patchRun({
+                                excludeInputs: true,
+                            });
+                        }
+                    },
+                });
+                return {
+                    stream: stream.pipeThrough(transformStream),
+                    ...rest,
+                };
+            }
+            catch (error) {
+                await runTree?.end(undefined, error.message ?? String(error));
+                await runTree?.patchRun({
+                    excludeInputs: true,
+                });
+                throw error;
+            }
+        },
+    };
+}

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/utils.cjs

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertMessageToTracedFormat = exports.normalizeFileDataAsDataURL = void 0;
+const guessMimetypeFromBase64 = (data) => {
+    // Check magic bytes from base64 data
+    const bytes = atob(data.substring(0, 20)); // Decode first few bytes
+    // PNG: 89 50 4E 47
+    if (bytes.charCodeAt(0) === 0x89 &&
+        bytes.charCodeAt(1) === 0x50 &&
+        bytes.charCodeAt(2) === 0x4e &&
+        bytes.charCodeAt(3) === 0x47) {
+        return "image/png";
+    }
+    // JPEG: FF D8 FF
+    if (bytes.charCodeAt(0) === 0xff &&
+        bytes.charCodeAt(1) === 0xd8 &&
+        bytes.charCodeAt(2) === 0xff) {
+        return "image/jpeg";
+    }
+    // GIF: 47 49 46 38
+    if (bytes.charCodeAt(0) === 0x47 &&
+        bytes.charCodeAt(1) === 0x49 &&
+        bytes.charCodeAt(2) === 0x46 &&
+        bytes.charCodeAt(3) === 0x38) {
+        return "image/gif";
+    }
+    // WebP: 52 49 46 46 (RIFF) ... 57 45 42 50 (WEBP)
+    if (bytes.charCodeAt(0) === 0x52 &&
+        bytes.charCodeAt(1) === 0x49 &&
+        bytes.charCodeAt(2) === 0x46 &&
+        bytes.charCodeAt(3) === 0x46) {
+        if (bytes.indexOf("WEBP") !== -1) {
+            return "image/webp";
+        }
+    }
+    // PDF: 25 50 44 46 (%PDF)
+    if (bytes.charCodeAt(0) === 0x25 &&
+        bytes.charCodeAt(1) === 0x50 &&
+        bytes.charCodeAt(2) === 0x44 &&
+        bytes.charCodeAt(3) === 0x46) {
+        return "application/pdf";
+    }
+    return undefined;
+};
+const normalizeFileDataAsDataURL = (fileData, mimeType) => {
+    // eslint-disable-next-line no-instanceof/no-instanceof
+    if (fileData instanceof URL) {
+        return fileData.toString();
+    }
+    let normalizedFileData;
+    if (typeof fileData !== "string") {
+        let uint8Array;
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (fileData instanceof Uint8Array) {
+            uint8Array = fileData;
+        }
+        else if (fileData != null &&
+            typeof fileData === "object" &&
+            "type" in fileData &&
+            "data" in fileData &&
+            typeof fileData.data === "object" &&
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            fileData.data instanceof Uint8Array) {
+            uint8Array = fileData.data;
+            // eslint-disable-next-line no-instanceof/no-instanceof
+        }
+        else if (fileData instanceof ArrayBuffer) {
+            uint8Array = new Uint8Array(fileData);
+        }
+        if (uint8Array) {
+            let binary = "";
+            for (let i = 0; i < uint8Array.length; i++) {
+                binary += String.fromCharCode(uint8Array[i]);
+            }
+            const base64 = btoa(binary);
+            normalizedFileData = `data:${mimeType ??
+                guessMimetypeFromBase64(base64) ??
+                "application/octet-stream"};base64,${base64}`;
+        }
+        else {
+            normalizedFileData = "";
+        }
+    }
+    else {
+        if (fileData.startsWith("http://") || fileData.startsWith("https://")) {
+            normalizedFileData = fileData;
+        }
+        else if (!fileData.startsWith("data:")) {
+            normalizedFileData = `data:${mimeType ??
+                guessMimetypeFromBase64(fileData) ??
+                "application/octet-stream"};base64,${fileData}`;
+        }
+        else {
+            normalizedFileData = fileData;
+        }
+    }
+    return normalizedFileData;
+};
+exports.normalizeFileDataAsDataURL = normalizeFileDataAsDataURL;
+const convertMessageToTracedFormat = (message) => {
+    const formattedMessage = {
+        ...message,
+    };
+    if (Array.isArray(message.content)) {
+        if (message.role === "assistant") {
+            const toolCallBlocks = message.content.filter((block) => {
+                return (block != null &&
+                    typeof block === "object" &&
+                    block.type === "tool-call");
+            });
+            const toolCalls = toolCallBlocks.map((block) => {
+                // AI SDK 4 shim
+                let toolArgs = block.input ?? (("args" in block && block.args) || undefined);
+                if (typeof toolArgs !== "string") {
+                    toolArgs = JSON.stringify(toolArgs);
+                }
+                return {
+                    id: block.toolCallId,
+                    type: "function",
+                    function: {
+                        name: block.toolName,
+                        arguments: toolArgs,
+                    },
+                };
+            });
+            if (toolCalls.length > 0) {
+                formattedMessage.tool_calls = toolCalls;
+            }
+        }
+        const newContent = message.content.map((part) => {
+            if (part.type === "file") {
+                const { data, mediaType, filename, ...rest } = part;
+                return {
+                    ...rest,
+                    file: {
+                        filename,
+                        file_data: (0, exports.normalizeFileDataAsDataURL)(data, mediaType),
+                    },
+                };
+            }
+            else if (part.type === "image") {
+                const { image, mediaType, ...rest } = part;
+                return {
+                    ...rest,
+                    type: "image_url",
+                    image_url: (0, exports.normalizeFileDataAsDataURL)(image, mediaType),
+                };
+            }
+            return part;
+        });
+        formattedMessage.content = newContent;
+    }
+    else if (message.content == null && "text" in message) {
+        // AI SDK 4 shim
+        formattedMessage.content = message.text ?? "";
+        if ("toolCalls" in message &&
+            Array.isArray(message.toolCalls) &&
+            !("tool_calls" in formattedMessage)) {
+            formattedMessage.tool_calls = message.toolCalls.map((toolCall) => {
+                return {
+                    id: toolCall.toolCallId,
+                    type: "function",
+                    function: { name: toolCall.toolName, arguments: toolCall.args },
+                };
+            });
+        }
+    }
+    return formattedMessage;
+};
+exports.convertMessageToTracedFormat = convertMessageToTracedFormat;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/utils.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageModelV2DataContent, LanguageModelV2Message } from "@ai-sdk/provider";
+import type { ModelMessage } from "ai";
+export declare const normalizeFileDataAsDataURL: (fileData: LanguageModelV2DataContent | ArrayBuffer, mimeType?: string) => string;
+export declare const convertMessageToTracedFormat: (message: LanguageModelV2Message | ModelMessage) => Record<string, unknown>;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/utils.js

@@ -0,0 +1,165 @@
+const guessMimetypeFromBase64 = (data) => {
+    // Check magic bytes from base64 data
+    const bytes = atob(data.substring(0, 20)); // Decode first few bytes
+    // PNG: 89 50 4E 47
+    if (bytes.charCodeAt(0) === 0x89 &&
+        bytes.charCodeAt(1) === 0x50 &&
+        bytes.charCodeAt(2) === 0x4e &&
+        bytes.charCodeAt(3) === 0x47) {
+        return "image/png";
+    }
+    // JPEG: FF D8 FF
+    if (bytes.charCodeAt(0) === 0xff &&
+        bytes.charCodeAt(1) === 0xd8 &&
+        bytes.charCodeAt(2) === 0xff) {
+        return "image/jpeg";
+    }
+    // GIF: 47 49 46 38
+    if (bytes.charCodeAt(0) === 0x47 &&
+        bytes.charCodeAt(1) === 0x49 &&
+        bytes.charCodeAt(2) === 0x46 &&
+        bytes.charCodeAt(3) === 0x38) {
+        return "image/gif";
+    }
+    // WebP: 52 49 46 46 (RIFF) ... 57 45 42 50 (WEBP)
+    if (bytes.charCodeAt(0) === 0x52 &&
+        bytes.charCodeAt(1) === 0x49 &&
+        bytes.charCodeAt(2) === 0x46 &&
+        bytes.charCodeAt(3) === 0x46) {
+        if (bytes.indexOf("WEBP") !== -1) {
+            return "image/webp";
+        }
+    }
+    // PDF: 25 50 44 46 (%PDF)
+    if (bytes.charCodeAt(0) === 0x25 &&
+        bytes.charCodeAt(1) === 0x50 &&
+        bytes.charCodeAt(2) === 0x44 &&
+        bytes.charCodeAt(3) === 0x46) {
+        return "application/pdf";
+    }
+    return undefined;
+};
+export const normalizeFileDataAsDataURL = (fileData, mimeType) => {
+    // eslint-disable-next-line no-instanceof/no-instanceof
+    if (fileData instanceof URL) {
+        return fileData.toString();
+    }
+    let normalizedFileData;
+    if (typeof fileData !== "string") {
+        let uint8Array;
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (fileData instanceof Uint8Array) {
+            uint8Array = fileData;
+        }
+        else if (fileData != null &&
+            typeof fileData === "object" &&
+            "type" in fileData &&
+            "data" in fileData &&
+            typeof fileData.data === "object" &&
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            fileData.data instanceof Uint8Array) {
+            uint8Array = fileData.data;
+            // eslint-disable-next-line no-instanceof/no-instanceof
+        }
+        else if (fileData instanceof ArrayBuffer) {
+            uint8Array = new Uint8Array(fileData);
+        }
+        if (uint8Array) {
+            let binary = "";
+            for (let i = 0; i < uint8Array.length; i++) {
+                binary += String.fromCharCode(uint8Array[i]);
+            }
+            const base64 = btoa(binary);
+            normalizedFileData = `data:${mimeType ??
+                guessMimetypeFromBase64(base64) ??
+                "application/octet-stream"};base64,${base64}`;
+        }
+        else {
+            normalizedFileData = "";
+        }
+    }
+    else {
+        if (fileData.startsWith("http://") || fileData.startsWith("https://")) {
+            normalizedFileData = fileData;
+        }
+        else if (!fileData.startsWith("data:")) {
+            normalizedFileData = `data:${mimeType ??
+                guessMimetypeFromBase64(fileData) ??
+                "application/octet-stream"};base64,${fileData}`;
+        }
+        else {
+            normalizedFileData = fileData;
+        }
+    }
+    return normalizedFileData;
+};
+export const convertMessageToTracedFormat = (message) => {
+    const formattedMessage = {
+        ...message,
+    };
+    if (Array.isArray(message.content)) {
+        if (message.role === "assistant") {
+            const toolCallBlocks = message.content.filter((block) => {
+                return (block != null &&
+                    typeof block === "object" &&
+                    block.type === "tool-call");
+            });
+            const toolCalls = toolCallBlocks.map((block) => {
+                // AI SDK 4 shim
+                let toolArgs = block.input ?? (("args" in block && block.args) || undefined);
+                if (typeof toolArgs !== "string") {
+                    toolArgs = JSON.stringify(toolArgs);
+                }
+                return {
+                    id: block.toolCallId,
+                    type: "function",
+                    function: {
+                        name: block.toolName,
+                        arguments: toolArgs,
+                    },
+                };
+            });
+            if (toolCalls.length > 0) {
+                formattedMessage.tool_calls = toolCalls;
+            }
+        }
+        const newContent = message.content.map((part) => {
+            if (part.type === "file") {
+                const { data, mediaType, filename, ...rest } = part;
+                return {
+                    ...rest,
+                    file: {
+                        filename,
+                        file_data: normalizeFileDataAsDataURL(data, mediaType),
+                    },
+                };
+            }
+            else if (part.type === "image") {
+                const { image, mediaType, ...rest } = part;
+                return {
+                    ...rest,
+                    type: "image_url",
+                    image_url: normalizeFileDataAsDataURL(image, mediaType),
+                };
+            }
+            return part;
+        });
+        formattedMessage.content = newContent;
+    }
+    else if (message.content == null && "text" in message) {
+        // AI SDK 4 shim
+        formattedMessage.content = message.text ?? "";
+        if ("toolCalls" in message &&
+            Array.isArray(message.toolCalls) &&
+            !("tool_calls" in formattedMessage)) {
+            formattedMessage.tool_calls = message.toolCalls.map((toolCall) => {
+                return {
+                    id: toolCall.toolCallId,
+                    type: "function",
+                    function: { name: toolCall.toolName, arguments: toolCall.args },
+                };
+            });
+        }
+    }
+    return formattedMessage;
+};

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/index.cjs

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__version__ = exports.overrideFetchImplementation = exports.RunTree = exports.Client = void 0;
+exports.__version__ = exports.getDefaultProjectName = exports.overrideFetchImplementation = exports.RunTree = exports.Client = void 0;
 var client_js_1 = require("./client.cjs");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });
 var run_trees_js_1 = require("./run_trees.cjs");
 Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () { return run_trees_js_1.RunTree; } });
 var fetch_js_1 = require("./singletons/fetch.cjs");
 Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true, get: function () { return fetch_js_1.overrideFetchImplementation; } });
+var project_js_1 = require("./utils/project.cjs");
+Object.defineProperty(exports, "getDefaultProjectName", { enumerable: true, get: function () { return project_js_1.getDefaultProjectName; } });
 // Update using yarn bump-version
-exports.__version__ = "0.3.12";
+exports.__version__ = "0.3.74";

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/index.d.ts

@@ -2,4 +2,5 @@ export { Client, type ClientConfig, type LangSmithTracingClientInterface, } from
 export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
-export declare const __version__ = "0.3.12";
+export { getDefaultProjectName } from "./utils/project.js";
+export declare const __version__ = "0.3.74";

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/index.js

@@ -1,5 +1,6 @@
 export { Client, } from "./client.js";
 export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
+export { getDefaultProjectName } from "./utils/project.js";
 // Update using yarn bump-version
-export const __version__ = "0.3.12";
+export const __version__ = "0.3.74";