@nocobase/plugin-ai 1.9.33 → 1.9.34

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

@@ -1,17 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ROOT = exports.withRunTree = exports.isTraceableFunction = exports.getCurrentRunTree = exports.traceable = void 0;
+exports.ROOT = exports.withRunTree = exports.isTraceableFunction = exports.getCurrentRunTree = void 0;
+exports.traceable = traceable;
 const node_async_hooks_1 = require("node:async_hooks");
 const run_trees_js_1 = require("./run_trees.cjs");
 const env_js_1 = require("./env.cjs");
 const traceable_js_1 = require("./singletons/traceable.cjs");
 const constants_js_1 = require("./singletons/constants.cjs");
 const asserts_js_1 = require("./utils/asserts.cjs");
+const env_js_2 = require("./utils/env.cjs");
+const index_js_1 = require("./index.cjs");
+const otel_js_1 = require("./singletons/otel.cjs");
+const utils_js_1 = require("./experimental/otel/utils.cjs");
+const constants_js_2 = require("./experimental/otel/constants.cjs");
 traceable_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
+/**
+ * Create OpenTelemetry context manager from RunTree if OTEL is enabled.
+ */
+function maybeCreateOtelContext(runTree, projectName, tracer
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!runTree || !(0, env_js_2.getOtelEnabled)()) {
+        return;
+    }
+    const otel_trace = (0, otel_js_1.getOTELTrace)();
+    try {
+        const activeTraceId = otel_trace.getActiveSpan()?.spanContext()?.traceId;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (fn) => {
+            const resolvedTracer = tracer ?? otel_trace.getTracer("langsmith", index_js_1.__version__);
+            const attributes = {
+                [constants_js_2.LANGSMITH_TRACEABLE]: "true",
+            };
+            if (runTree.reference_example_id) {
+                attributes[constants_js_2.LANGSMITH_REFERENCE_EXAMPLE_ID] =
+                    runTree.reference_example_id;
+            }
+            if (projectName !== undefined) {
+                attributes[constants_js_2.LANGSMITH_SESSION_NAME] = projectName;
+            }
+            const forceOTELRoot = runTree.extra?.ls_otel_root === true;
+            return resolvedTracer.startActiveSpan(runTree.name, {
+                attributes,
+                root: forceOTELRoot,
+            }, () => {
+                if (activeTraceId === undefined || forceOTELRoot) {
+                    const otelSpanId = otel_trace
+                        .getActiveSpan()
+                        ?.spanContext()?.spanId;
+                    if (otelSpanId) {
+                        const langsmithTraceId = (0, utils_js_1.getUuidFromOtelSpanId)(otelSpanId);
+                        // Must refetch from our primary async local storage
+                        const currentRunTree = (0, traceable_js_1.getCurrentRunTree)();
+                        if (currentRunTree) {
+                            // This is only for root runs to ensure that trace id
+                            // and the root run id are returned correctly.
+                            // This is important for things like leaving feedback on
+                            // target function runs during evaluation.
+                            currentRunTree.id = langsmithTraceId;
+                            currentRunTree.trace_id = langsmithTraceId;
+                        }
+                    }
+                }
+                return fn();
+            });
+        };
+    }
+    catch {
+        // Silent failure if OTEL setup is incomplete
+        return;
+    }
+}
 const runInputsToMap = (rawInputs) => {
     const firstInput = rawInputs[0];
     let inputs;
-    if (firstInput == null) {
+    if (firstInput === null) {
+        inputs = { inputs: null };
+    }
+    else if (firstInput === undefined) {
         inputs = {};
     }
     else if (rawInputs.length > 1) {
@@ -34,22 +100,98 @@ const handleRunInputs = (inputs, processInputs) => {
         return inputs;
     }
 };
-const handleRunOutputs = (rawOutputs, processOutputs) => {
+const _extractUsage = (runData) => {
+    const usageMetadataFromMetadata = (runData.runTree.extra.metadata ?? {})
+        .usage_metadata;
+    return runData.outputs?.usage_metadata ?? usageMetadataFromMetadata;
+};
+async function handleEnd(params) {
+    const { runTree, on_end, postRunPromise, excludeInputs } = params;
+    const onEnd = on_end;
+    if (onEnd) {
+        if (!runTree) {
+            console.warn("Can not call 'on_end' if currentRunTree is undefined");
+        }
+        else {
+            onEnd(runTree);
+        }
+    }
+    await postRunPromise;
+    await runTree?.patchRun({
+        excludeInputs,
+    });
+}
+const _populateUsageMetadata = (processedOutputs, runTree) => {
+    if (runTree !== undefined) {
+        let usageMetadata;
+        try {
+            usageMetadata = _extractUsage({ runTree, outputs: processedOutputs });
+        }
+        catch (e) {
+            console.error("Error occurred while extracting usage metadata:", e);
+        }
+        if (usageMetadata !== undefined) {
+            runTree.extra.metadata = {
+                ...runTree.extra.metadata,
+                usage_metadata: usageMetadata,
+            };
+            processedOutputs.usage_metadata = usageMetadata;
+        }
+    }
+};
+function isAsyncFn(fn) {
+    return (fn != null &&
+        typeof fn === "function" &&
+        fn.constructor.name === "AsyncFunction");
+}
+// Note: This mutates the run tree
+async function handleRunOutputs(params) {
+    const { runTree, rawOutputs, processOutputsFn, on_end, postRunPromise, excludeInputs, } = params;
     let outputs;
     if ((0, asserts_js_1.isKVMap)(rawOutputs)) {
-        outputs = rawOutputs;
+        outputs = { ...rawOutputs };
     }
     else {
         outputs = { outputs: rawOutputs };
     }
     try {
-        return processOutputs(outputs);
+        outputs = processOutputsFn(outputs);
+        // TODO: Investigate making this behavior for all returned promises
+        // on next minor bump.
+        if (isAsyncFn(processOutputsFn)) {
+            void outputs
+                .then(async (processedOutputs) => {
+                _populateUsageMetadata(processedOutputs, runTree);
+                await runTree?.end(processedOutputs);
+            })
+                .catch(async (e) => {
+                console.error("Error occurred during processOutputs. Sending unprocessed outputs:", e);
+                try {
+                    await runTree?.end(outputs);
+                }
+                catch (e) {
+                    console.error("Error occurred during runTree?.end.", e);
+                }
+            })
+                .finally(async () => {
+                try {
+                    await handleEnd({ runTree, postRunPromise, on_end, excludeInputs });
+                }
+                catch (e) {
+                    console.error("Error occurred during handleEnd.", e);
+                }
+            });
+            return;
+        }
     }
     catch (e) {
-        console.error("Error occurred during processOutputs. Sending raw outputs:", e);
-        return outputs;
+        console.error("Error occurred during processOutputs. Sending unprocessed outputs:", e);
     }
-};
+    _populateUsageMetadata(outputs, runTree);
+    await runTree?.end(outputs);
+    await handleEnd({ runTree, postRunPromise, on_end, excludeInputs });
+    return;
+}
 const handleRunAttachments = (rawInputs, extractAttachments) => {
     if (!extractAttachments) {
         return [undefined, rawInputs];
@@ -65,7 +207,7 @@ const handleRunAttachments = (rawInputs, extractAttachments) => {
 };
 const getTracingRunTree = (runTree, inputs, getInvocationParams, processInputs, extractAttachments) => {
     if (!(0, env_js_1.isTracingEnabled)(runTree.tracingEnabled)) {
-        return undefined;
+        return {};
     }
     const [attached, args] = handleRunAttachments(inputs, extractAttachments);
     runTree.attachments = attached;
@@ -137,11 +279,11 @@ const convertSerializableArg = (arg) => {
         });
         const pipeThrough = arg.pipeThrough(transform);
         Object.assign(pipeThrough, { toJSON: () => proxyState });
-        return pipeThrough;
+        return { converted: pipeThrough, deferredInput: true };
     }
     if ((0, asserts_js_1.isAsyncIterable)(arg)) {
         const proxyState = { current: [] };
-        return new Proxy(arg, {
+        const converted = new Proxy(arg, {
             get(target, prop, receiver) {
                 if (prop === Symbol.asyncIterator) {
                     return () => {
@@ -181,15 +323,15 @@ const convertSerializableArg = (arg) => {
                 return Reflect.get(target, prop, receiver);
             },
         });
+        return { converted, deferredInput: true };
     }
     if (!Array.isArray(arg) && (0, asserts_js_1.isIteratorLike)(arg)) {
         const proxyState = [];
-        return new Proxy(arg, {
+        const converted = new Proxy(arg, {
             get(target, prop, receiver) {
                 if (prop === "next" || prop === "return" || prop === "throw") {
                     const bound = arg[prop]?.bind(arg);
                     return (...args) => {
-                        // @ts-expect-error TS cannot infer the argument types for the bound function
                         const next = bound?.(...args);
                         if (next != null)
                             proxyState.push(next);
@@ -209,11 +351,12 @@ const convertSerializableArg = (arg) => {
                 return Reflect.get(target, prop, receiver);
             },
         });
+        return { converted, deferredInput: true };
     }
     if ((0, asserts_js_1.isThenable)(arg)) {
-        return getSerializablePromise(arg);
+        return { converted: getSerializablePromise(arg), deferredInput: true };
     }
-    return arg;
+    return { converted: arg, deferredInput: false };
 };
 /**
  * Higher-order function that takes function as input and returns a
@@ -284,10 +427,13 @@ function traceable(wrappedFunc, config) {
         const asyncLocalStorage = traceable_js_1.AsyncLocalStorageProviderSingleton.getInstance();
         // TODO: deal with possible nested promises and async iterables
         const processedArgs = args;
+        let deferredInput = false;
         for (let i = 0; i < processedArgs.length; i++) {
-            processedArgs[i] = convertSerializableArg(processedArgs[i]);
+            const { converted, deferredInput: argDefersInput } = convertSerializableArg(processedArgs[i]);
+            processedArgs[i] = converted;
+            deferredInput = deferredInput || argDefersInput;
         }
-        const [currentRunTree, rawInputs] = (() => {
+        const [currentContext, rawInputs] = (() => {
             const [firstArg, ...restArgs] = processedArgs;
             // used for handoff between LangChain.JS and traceable functions
             if ((0, run_trees_js_1.isRunnableConfigLike)(firstArg)) {
@@ -314,25 +460,35 @@ function traceable(wrappedFunc, config) {
             // Node.JS uses AsyncLocalStorage (ALS) and AsyncResource
             // to allow storing context
             const prevRunFromStore = asyncLocalStorage.getStore();
-            if ((0, run_trees_js_1.isRunTree)(prevRunFromStore)) {
-                return [
-                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn),
-                    processedArgs,
-                ];
-            }
-            const currentRunTree = getTracingRunTree(new run_trees_js_1.RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            let lc_contextVars;
             // If a context var is set by LangChain outside of a traceable,
             // it will be an object with a single property and we should copy
             // context vars over into the new run tree.
             if (prevRunFromStore !== undefined &&
                 constants_js_1._LC_CONTEXT_VARIABLES_KEY in prevRunFromStore) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                currentRunTree[constants_js_1._LC_CONTEXT_VARIABLES_KEY] =
-                    prevRunFromStore[constants_js_1._LC_CONTEXT_VARIABLES_KEY];
+                lc_contextVars = prevRunFromStore[constants_js_1._LC_CONTEXT_VARIABLES_KEY];
+            }
+            if ((0, run_trees_js_1.isRunTree)(prevRunFromStore)) {
+                const currentRunTree = getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+                if (lc_contextVars) {
+                    (currentRunTree ?? {})[constants_js_1._LC_CONTEXT_VARIABLES_KEY] =
+                        lc_contextVars;
+                }
+                return [currentRunTree, processedArgs];
+            }
+            const currentRunTree = getTracingRunTree(new run_trees_js_1.RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            if (lc_contextVars) {
+                (currentRunTree ?? {})[constants_js_1._LC_CONTEXT_VARIABLES_KEY] =
+                    lc_contextVars;
             }
             return [currentRunTree, processedArgs];
         })();
-        return asyncLocalStorage.run(currentRunTree, () => {
+        const currentRunTree = (0, run_trees_js_1.isRunTree)(currentContext)
+            ? currentContext
+            : undefined;
+        const otelContextManager = maybeCreateOtelContext(currentRunTree, config?.project_name, config?.tracer);
+        const otel_context = (0, otel_js_1.getOTELContext)();
+        const runWithContext = () => {
             const postRunPromise = currentRunTree?.postRun();
             async function handleChunks(chunks) {
                 if (aggregator !== undefined) {
@@ -349,17 +505,24 @@ function traceable(wrappedFunc, config) {
                 const reader = stream.getReader();
                 let finished = false;
                 const chunks = [];
+                const capturedOtelContext = otel_context.active();
                 const tappedStream = new ReadableStream({
                     async start(controller) {
                         // eslint-disable-next-line no-constant-condition
                         while (true) {
                             const result = await (snapshot
-                                ? snapshot(() => reader.read())
-                                : reader.read());
+                                ? snapshot(() => otel_context.with(capturedOtelContext, () => reader.read()))
+                                : otel_context.with(capturedOtelContext, () => reader.read()));
                             if (result.done) {
                                 finished = true;
-                                await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
-                                await handleEnd();
+                                await handleRunOutputs({
+                                    runTree: currentRunTree,
+                                    rawOutputs: await handleChunks(chunks),
+                                    processOutputsFn,
+                                    on_end: config?.on_end,
+                                    postRunPromise,
+                                    excludeInputs: !deferredInput,
+                                });
                                 controller.close();
                                 break;
                             }
@@ -377,8 +540,14 @@ function traceable(wrappedFunc, config) {
                     async cancel(reason) {
                         if (!finished)
                             await currentRunTree?.end(undefined, "Cancelled");
-                        await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
-                        await handleEnd();
+                        await handleRunOutputs({
+                            runTree: currentRunTree,
+                            rawOutputs: await handleChunks(chunks),
+                            processOutputsFn,
+                            on_end: config?.on_end,
+                            postRunPromise,
+                            excludeInputs: !deferredInput,
+                        });
                         return reader.cancel(reason);
                     },
                 });
@@ -387,11 +556,12 @@ function traceable(wrappedFunc, config) {
             async function* wrapAsyncIteratorForTracing(iterator, snapshot) {
                 let finished = false;
                 const chunks = [];
+                const capturedOtelContext = otel_context.active();
                 try {
                     while (true) {
                         const { value, done } = await (snapshot
-                            ? snapshot(() => iterator.next())
-                            : iterator.next());
+                            ? snapshot(() => otel_context.with(capturedOtelContext, () => iterator.next()))
+                            : otel_context.with(capturedOtelContext, () => iterator.next()));
                         if (done) {
                             finished = true;
                             break;
@@ -414,8 +584,14 @@ function traceable(wrappedFunc, config) {
                 finally {
                     if (!finished)
                         await currentRunTree?.end(undefined, "Cancelled");
-                    await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
-                    await handleEnd();
+                    await handleRunOutputs({
+                        runTree: currentRunTree,
+                        rawOutputs: await handleChunks(chunks),
+                        processOutputsFn,
+                        on_end: config?.on_end,
+                        postRunPromise,
+                        excludeInputs: !deferredInput,
+                    });
                 }
             }
             function wrapAsyncGeneratorForTracing(iterable, snapshot) {
@@ -427,19 +603,6 @@ function traceable(wrappedFunc, config) {
                 iterable[Symbol.asyncIterator] = () => wrappedIterator;
                 return iterable;
             }
-            async function handleEnd() {
-                const onEnd = config?.on_end;
-                if (onEnd) {
-                    if (!currentRunTree) {
-                        console.warn("Can not call 'on_end' if currentRunTree is undefined");
-                    }
-                    else {
-                        onEnd(currentRunTree);
-                    }
-                }
-                await postRunPromise;
-                await currentRunTree?.patchRun();
-            }
             function gatherAll(iterator) {
                 const chunks = [];
                 // eslint-disable-next-line no-constant-condition
@@ -494,16 +657,22 @@ function traceable(wrappedFunc, config) {
                     if ((0, asserts_js_1.isGenerator)(wrappedFunc) && (0, asserts_js_1.isIteratorLike)(rawOutput)) {
                         const chunks = gatherAll(rawOutput);
                         try {
-                            await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {
-                                if (!done || typeof value !== "undefined") {
-                                    memo.push(value);
-                                }
-                                return memo;
-                            }, [])), processOutputsFn));
-                            await handleEnd();
+                            await handleRunOutputs({
+                                runTree: currentRunTree,
+                                rawOutputs: await handleChunks(chunks.reduce((memo, { value, done }) => {
+                                    if (!done || typeof value !== "undefined") {
+                                        memo.push(value);
+                                    }
+                                    return memo;
+                                }, [])),
+                                processOutputsFn,
+                                on_end: config?.on_end,
+                                postRunPromise,
+                                excludeInputs: !deferredInput,
+                            });
                         }
                         catch (e) {
-                            console.error("Error occurred during handleEnd:", e);
+                            console.error("[LANGSMITH]: Error occurred while handling run outputs:", e);
                         }
                         return (function* () {
                             for (const ret of chunks) {
@@ -514,8 +683,14 @@ function traceable(wrappedFunc, config) {
                         })();
                     }
                     try {
-                        await currentRunTree?.end(handleRunOutputs(rawOutput, processOutputsFn));
-                        await handleEnd();
+                        await handleRunOutputs({
+                            runTree: currentRunTree,
+                            rawOutputs: rawOutput,
+                            processOutputsFn,
+                            on_end: config?.on_end,
+                            postRunPromise,
+                            excludeInputs: !deferredInput,
+                        });
                     }
                     finally {
                         // eslint-disable-next-line no-unsafe-finally
@@ -523,7 +698,12 @@ function traceable(wrappedFunc, config) {
                     }
                 }, async (error) => {
                     await currentRunTree?.end(undefined, String(error));
-                    await handleEnd();
+                    await handleEnd({
+                        runTree: currentRunTree,
+                        postRunPromise,
+                        on_end: config?.on_end,
+                        excludeInputs: !deferredInput,
+                    });
                     throw error;
                 })
                     .then(resolve, reject);
@@ -539,14 +719,20 @@ function traceable(wrappedFunc, config) {
                     return Reflect.get(target, prop, receiver);
                 },
             });
-        });
+        };
+        // Wrap with OTEL context if available, similar to Python's implementation
+        if (otelContextManager) {
+            return asyncLocalStorage.run(currentContext, () => otelContextManager(runWithContext));
+        }
+        else {
+            return asyncLocalStorage.run(currentContext, runWithContext);
+        }
     };
     Object.defineProperty(traceableFunc, "langsmith:traceable", {
         value: runTreeConfig,
     });
     return traceableFunc;
 }
-exports.traceable = traceable;
 var traceable_js_2 = require("./singletons/traceable.cjs");
 Object.defineProperty(exports, "getCurrentRunTree", { enumerable: true, get: function () { return traceable_js_2.getCurrentRunTree; } });
 Object.defineProperty(exports, "isTraceableFunction", { enumerable: true, get: function () { return traceable_js_2.isTraceableFunction; } });

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

@@ -1,23 +1,11 @@
 import { RunTreeConfig } from "./run_trees.js";
 import { Attachments, InvocationParamsSchema, KVMap } from "./schemas.js";
-import { TraceableFunction } from "./singletons/types.js";
-/**
- * Higher-order function that takes function as input and returns a
- * "TraceableFunction" - a wrapped version of the input that
- * automatically handles tracing. If the returned traceable function calls any
- * traceable functions, those are automatically traced as well.
- *
- * The returned TraceableFunction can accept a run tree or run tree config as
- * its first argument. If omitted, it will default to the caller's run tree,
- * or will be treated as a root run.
- *
- * @param wrappedFunc Targeted function to be traced
- * @param config Additional metadata such as name, tags or providing
- *     a custom LangSmith client instance
- */
-export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: Partial<RunTreeConfig> & {
+import type { TraceableFunction } from "./singletons/types.js";
+import { OTELTracer } from "./experimental/otel/types.js";
+export type TraceableConfig<Func extends (...args: any[]) => any> = Partial<Omit<RunTreeConfig, "inputs" | "outputs">> & {
     aggregator?: (args: any[]) => any;
     argsConfigPath?: [number] | [number, string];
+    tracer?: OTELTracer;
     __finalTracedIteratorKey?: string;
     /**
      * Extract attachments from args and return remaining args.
@@ -51,7 +39,22 @@ export declare function traceable<Func extends (...args: any[]) => any>(wrappedF
      * @param outputs Key-value map of the function outputs
      * @returns Transformed key-value map
      */
-    processOutputs?: (outputs: Readonly<KVMap>) => KVMap;
-}): TraceableFunction<Func>;
+    processOutputs?: (outputs: Readonly<KVMap>) => KVMap | Promise<KVMap>;
+};
+/**
+ * Higher-order function that takes function as input and returns a
+ * "TraceableFunction" - a wrapped version of the input that
+ * automatically handles tracing. If the returned traceable function calls any
+ * traceable functions, those are automatically traced as well.
+ *
+ * The returned TraceableFunction can accept a run tree or run tree config as
+ * its first argument. If omitted, it will default to the caller's run tree,
+ * or will be treated as a root run.
+ *
+ * @param wrappedFunc Targeted function to be traced
+ * @param config Additional metadata such as name, tags or providing
+ *     a custom LangSmith client instance
+ */
+export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: TraceableConfig<Func>): TraceableFunction<Func>;
 export { getCurrentRunTree, isTraceableFunction, withRunTree, ROOT, } from "./singletons/traceable.js";
 export type { RunTreeLike, TraceableFunction } from "./singletons/types.js";