@nocobase/plugin-ai 1.9.33 → 1.9.35

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/fetch.js

@@ -1,3 +1,4 @@
+import { getLangSmithEnvironmentVariable } from "../utils/env.js";
 // Wrap the default fetch call due to issues with illegal invocations
 // in some environments:
 // https://stackoverflow.com/questions/69876859/why-does-bind-fix-failed-to-execute-fetch-on-window-illegal-invocation-err
@@ -13,10 +14,33 @@ const LANGSMITH_FETCH_IMPLEMENTATION_KEY = Symbol.for("ls:fetch_implementation")
 export const overrideFetchImplementation = (fetch) => {
     globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY] = fetch;
 };
+export const clearFetchImplementation = () => {
+    delete globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY];
+};
+export const _globalFetchImplementationIsNodeFetch = () => {
+    const fetchImpl = globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY];
+    if (!fetchImpl)
+        return false;
+    // Check if the implementation has node-fetch specific properties
+    return (typeof fetchImpl === "function" &&
+        "Headers" in fetchImpl &&
+        "Request" in fetchImpl &&
+        "Response" in fetchImpl);
+};
 /**
  * @internal
  */
-export const _getFetchImplementation = () => {
-    return (globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY] ??
-        DEFAULT_FETCH_IMPLEMENTATION);
+export const _getFetchImplementation = (debug) => {
+    return async (...args) => {
+        if (debug || getLangSmithEnvironmentVariable("DEBUG") === "true") {
+            const [url, options] = args;
+            console.log(`→ ${options?.method || "GET"} ${url}`);
+        }
+        const res = await (globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY] ??
+            DEFAULT_FETCH_IMPLEMENTATION)(...args);
+        if (debug || getLangSmithEnvironmentVariable("DEBUG") === "true") {
+            console.log(`← ${res.status} ${res.statusText} ${res.url}`);
+        }
+        return res;
+    };
 };

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/otel.cjs

@@ -0,0 +1,155 @@
+"use strict";
+// Should not import any OTEL packages to avoid pulling in optional deps.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTELProviderSingleton = void 0;
+exports.getOTELTrace = getOTELTrace;
+exports.getOTELContext = getOTELContext;
+exports.setOTELInstances = setOTELInstances;
+exports.setDefaultOTLPTracerComponents = setDefaultOTLPTracerComponents;
+exports.getDefaultOTLPTracerComponents = getDefaultOTLPTracerComponents;
+const env_js_1 = require("../utils/env.cjs");
+class MockTracer {
+    constructor() {
+        Object.defineProperty(this, "hasWarned", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    startActiveSpan(_name, ...args) {
+        if (!this.hasWarned && (0, env_js_1.getOtelEnabled)()) {
+            console.warn("You have enabled OTEL export via the `OTEL_ENABLED` or `LANGSMITH_OTEL_ENABLED` environment variable, but have not initialized the required OTEL instances. " +
+                'Please add:\n```\nimport { initializeOTEL } from "langsmith/experimental/otel/setup";\ninitializeOTEL();\n```\nat the beginning of your code.');
+            this.hasWarned = true;
+        }
+        // Handle different overloads:
+        // startActiveSpan(name, fn)
+        // startActiveSpan(name, options, fn)
+        // startActiveSpan(name, options, context, fn)
+        let fn;
+        if (args.length === 1 && typeof args[0] === "function") {
+            fn = args[0];
+        }
+        else if (args.length === 2 && typeof args[1] === "function") {
+            fn = args[1];
+        }
+        else if (args.length === 3 && typeof args[2] === "function") {
+            fn = args[2];
+        }
+        if (typeof fn === "function") {
+            return fn();
+        }
+        return undefined;
+    }
+}
+class MockOTELTrace {
+    constructor() {
+        Object.defineProperty(this, "mockTracer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new MockTracer()
+        });
+    }
+    getTracer(_name, _version) {
+        return this.mockTracer;
+    }
+    getActiveSpan() {
+        return undefined;
+    }
+    setSpan(context, _span) {
+        return context;
+    }
+    getSpan(_context) {
+        return undefined;
+    }
+    setSpanContext(context, _spanContext) {
+        return context;
+    }
+    getTracerProvider() {
+        return undefined;
+    }
+    setGlobalTracerProvider(_tracerProvider) {
+        return false;
+    }
+}
+class MockOTELContext {
+    active() {
+        return {};
+    }
+    with(_context, fn) {
+        return fn();
+    }
+}
+const OTEL_TRACE_KEY = Symbol.for("ls:otel_trace");
+const OTEL_CONTEXT_KEY = Symbol.for("ls:otel_context");
+const OTEL_GET_DEFAULT_OTLP_TRACER_PROVIDER_KEY = Symbol.for("ls:otel_get_default_otlp_tracer_provider");
+const mockOTELTrace = new MockOTELTrace();
+const mockOTELContext = new MockOTELContext();
+class OTELProvider {
+    getTraceInstance() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return globalThis[OTEL_TRACE_KEY] ?? mockOTELTrace;
+    }
+    getContextInstance() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return globalThis[OTEL_CONTEXT_KEY] ?? mockOTELContext;
+    }
+    initializeGlobalInstances(otel) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (globalThis[OTEL_TRACE_KEY] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis[OTEL_TRACE_KEY] = otel.trace;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (globalThis[OTEL_CONTEXT_KEY] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis[OTEL_CONTEXT_KEY] = otel.context;
+        }
+    }
+    setDefaultOTLPTracerComponents(components) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis[OTEL_GET_DEFAULT_OTLP_TRACER_PROVIDER_KEY] = components;
+    }
+    getDefaultOTLPTracerComponents() {
+        return (globalThis[OTEL_GET_DEFAULT_OTLP_TRACER_PROVIDER_KEY] ??
+            undefined);
+    }
+}
+exports.OTELProviderSingleton = new OTELProvider();
+/**
+ * Get the current OTEL trace instance.
+ * Returns a mock implementation if OTEL is not available.
+ */
+function getOTELTrace() {
+    return exports.OTELProviderSingleton.getTraceInstance();
+}
+/**
+ * Get the current OTEL context instance.
+ * Returns a mock implementation if OTEL is not available.
+ */
+function getOTELContext() {
+    return exports.OTELProviderSingleton.getContextInstance();
+}
+/**
+ * Initialize the global OTEL instances.
+ * Should be called once when OTEL packages are available.
+ */
+function setOTELInstances(otel) {
+    exports.OTELProviderSingleton.initializeGlobalInstances(otel);
+}
+/**
+ * Set a getter function for the default OTLP tracer provider.
+ * This allows lazy initialization of the tracer provider.
+ */
+function setDefaultOTLPTracerComponents(components) {
+    exports.OTELProviderSingleton.setDefaultOTLPTracerComponents(components);
+}
+/**
+ * Get the default OTLP tracer provider instance.
+ * Returns undefined if not set.
+ */
+function getDefaultOTLPTracerComponents() {
+    return exports.OTELProviderSingleton.getDefaultOTLPTracerComponents();
+}

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/otel.d.ts

@@ -0,0 +1,63 @@
+interface OTELTraceInterface {
+    getTracer: (name: string, version?: string) => any;
+    getActiveSpan: () => any;
+    setSpan: (context: any, span: any) => any;
+    getSpan: (context: any) => any;
+    setSpanContext: (context: any, spanContext: any) => any;
+    getTracerProvider: () => any;
+    setGlobalTracerProvider: (tracerProvider: any) => boolean;
+}
+interface OTELContextInterface {
+    active: () => any;
+    with: <T>(context: any, fn: () => T) => T;
+}
+interface OTELInterface {
+    trace: OTELTraceInterface;
+    context: OTELContextInterface;
+}
+declare class OTELProvider {
+    getTraceInstance(): OTELTraceInterface;
+    getContextInstance(): OTELContextInterface;
+    initializeGlobalInstances(otel: OTELInterface): void;
+    setDefaultOTLPTracerComponents(components: {
+        DEFAULT_LANGSMITH_SPAN_PROCESSOR: any;
+        DEFAULT_LANGSMITH_TRACER_PROVIDER: any;
+        DEFAULT_LANGSMITH_SPAN_EXPORTER: any;
+    }): void;
+    getDefaultOTLPTracerComponents(): any;
+}
+export declare const OTELProviderSingleton: OTELProvider;
+/**
+ * Get the current OTEL trace instance.
+ * Returns a mock implementation if OTEL is not available.
+ */
+export declare function getOTELTrace(): OTELTraceInterface;
+/**
+ * Get the current OTEL context instance.
+ * Returns a mock implementation if OTEL is not available.
+ */
+export declare function getOTELContext(): OTELContextInterface;
+/**
+ * Initialize the global OTEL instances.
+ * Should be called once when OTEL packages are available.
+ */
+export declare function setOTELInstances(otel: OTELInterface): void;
+/**
+ * Set a getter function for the default OTLP tracer provider.
+ * This allows lazy initialization of the tracer provider.
+ */
+export declare function setDefaultOTLPTracerComponents(components: {
+    DEFAULT_LANGSMITH_SPAN_PROCESSOR: any;
+    DEFAULT_LANGSMITH_TRACER_PROVIDER: any;
+    DEFAULT_LANGSMITH_SPAN_EXPORTER: any;
+}): void;
+/**
+ * Get the default OTLP tracer provider instance.
+ * Returns undefined if not set.
+ */
+export declare function getDefaultOTLPTracerComponents(): {
+    DEFAULT_LANGSMITH_SPAN_PROCESSOR: any;
+    DEFAULT_LANGSMITH_TRACER_PROVIDER: any;
+    DEFAULT_LANGSMITH_SPAN_EXPORTER: any;
+} | undefined;
+export {};

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/otel.js

@@ -0,0 +1,147 @@
+// Should not import any OTEL packages to avoid pulling in optional deps.
+import { getOtelEnabled } from "../utils/env.js";
+class MockTracer {
+    constructor() {
+        Object.defineProperty(this, "hasWarned", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    startActiveSpan(_name, ...args) {
+        if (!this.hasWarned && getOtelEnabled()) {
+            console.warn("You have enabled OTEL export via the `OTEL_ENABLED` or `LANGSMITH_OTEL_ENABLED` environment variable, but have not initialized the required OTEL instances. " +
+                'Please add:\n```\nimport { initializeOTEL } from "langsmith/experimental/otel/setup";\ninitializeOTEL();\n```\nat the beginning of your code.');
+            this.hasWarned = true;
+        }
+        // Handle different overloads:
+        // startActiveSpan(name, fn)
+        // startActiveSpan(name, options, fn)
+        // startActiveSpan(name, options, context, fn)
+        let fn;
+        if (args.length === 1 && typeof args[0] === "function") {
+            fn = args[0];
+        }
+        else if (args.length === 2 && typeof args[1] === "function") {
+            fn = args[1];
+        }
+        else if (args.length === 3 && typeof args[2] === "function") {
+            fn = args[2];
+        }
+        if (typeof fn === "function") {
+            return fn();
+        }
+        return undefined;
+    }
+}
+class MockOTELTrace {
+    constructor() {
+        Object.defineProperty(this, "mockTracer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new MockTracer()
+        });
+    }
+    getTracer(_name, _version) {
+        return this.mockTracer;
+    }
+    getActiveSpan() {
+        return undefined;
+    }
+    setSpan(context, _span) {
+        return context;
+    }
+    getSpan(_context) {
+        return undefined;
+    }
+    setSpanContext(context, _spanContext) {
+        return context;
+    }
+    getTracerProvider() {
+        return undefined;
+    }
+    setGlobalTracerProvider(_tracerProvider) {
+        return false;
+    }
+}
+class MockOTELContext {
+    active() {
+        return {};
+    }
+    with(_context, fn) {
+        return fn();
+    }
+}
+const OTEL_TRACE_KEY = Symbol.for("ls:otel_trace");
+const OTEL_CONTEXT_KEY = Symbol.for("ls:otel_context");
+const OTEL_GET_DEFAULT_OTLP_TRACER_PROVIDER_KEY = Symbol.for("ls:otel_get_default_otlp_tracer_provider");
+const mockOTELTrace = new MockOTELTrace();
+const mockOTELContext = new MockOTELContext();
+class OTELProvider {
+    getTraceInstance() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return globalThis[OTEL_TRACE_KEY] ?? mockOTELTrace;
+    }
+    getContextInstance() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return globalThis[OTEL_CONTEXT_KEY] ?? mockOTELContext;
+    }
+    initializeGlobalInstances(otel) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (globalThis[OTEL_TRACE_KEY] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis[OTEL_TRACE_KEY] = otel.trace;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (globalThis[OTEL_CONTEXT_KEY] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis[OTEL_CONTEXT_KEY] = otel.context;
+        }
+    }
+    setDefaultOTLPTracerComponents(components) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis[OTEL_GET_DEFAULT_OTLP_TRACER_PROVIDER_KEY] = components;
+    }
+    getDefaultOTLPTracerComponents() {
+        return (globalThis[OTEL_GET_DEFAULT_OTLP_TRACER_PROVIDER_KEY] ??
+            undefined);
+    }
+}
+export const OTELProviderSingleton = new OTELProvider();
+/**
+ * Get the current OTEL trace instance.
+ * Returns a mock implementation if OTEL is not available.
+ */
+export function getOTELTrace() {
+    return OTELProviderSingleton.getTraceInstance();
+}
+/**
+ * Get the current OTEL context instance.
+ * Returns a mock implementation if OTEL is not available.
+ */
+export function getOTELContext() {
+    return OTELProviderSingleton.getContextInstance();
+}
+/**
+ * Initialize the global OTEL instances.
+ * Should be called once when OTEL packages are available.
+ */
+export function setOTELInstances(otel) {
+    OTELProviderSingleton.initializeGlobalInstances(otel);
+}
+/**
+ * Set a getter function for the default OTLP tracer provider.
+ * This allows lazy initialization of the tracer provider.
+ */
+export function setDefaultOTLPTracerComponents(components) {
+    OTELProviderSingleton.setDefaultOTLPTracerComponents(components);
+}
+/**
+ * Get the default OTLP tracer provider instance.
+ * Returns undefined if not set.
+ */
+export function getDefaultOTLPTracerComponents() {
+    return OTELProviderSingleton.getDefaultOTLPTracerComponents();
+}

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTraceableFunction = exports.ROOT = exports.withRunTree = exports.getCurrentRunTree = exports.AsyncLocalStorageProviderSingleton = void 0;
-const run_trees_js_1 = require("../run_trees.cjs");
+exports.ROOT = exports.AsyncLocalStorageProviderSingleton = void 0;
+exports.getCurrentRunTree = getCurrentRunTree;
+exports.withRunTree = withRunTree;
+exports.isTraceableFunction = isTraceableFunction;
 class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -26,24 +28,13 @@ class AsyncLocalStorageProvider {
     }
 }
 exports.AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
-/**
- * Return the current run tree from within a traceable-wrapped function.
- * Will throw an error if called outside of a traceable function.
- *
- * @returns The run tree for the given context.
- */
-const getCurrentRunTree = () => {
+function getCurrentRunTree(permitAbsentRunTree = false) {
     const runTree = exports.AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    if (!(0, run_trees_js_1.isRunTree)(runTree)) {
-        throw new Error([
-            "Could not get the current run tree.",
-            "",
-            "Please make sure you are calling this method within a traceable function and that tracing is enabled.",
-        ].join("\n"));
+    if (!permitAbsentRunTree && runTree === undefined) {
+        throw new Error("Could not get the current run tree.\n\nPlease make sure you are calling this method within a traceable function and that tracing is enabled.");
     }
     return runTree;
-};
-exports.getCurrentRunTree = getCurrentRunTree;
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function withRunTree(runTree, fn) {
     const storage = exports.AsyncLocalStorageProviderSingleton.getInstance();
@@ -51,11 +42,9 @@ function withRunTree(runTree, fn) {
         storage.run(runTree, () => void Promise.resolve(fn()).then(resolve).catch(reject));
     });
 }
-exports.withRunTree = withRunTree;
 exports.ROOT = Symbol.for("langsmith:traceable:root");
 function isTraceableFunction(x
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
     return typeof x === "function" && "langsmith:traceable" in x;
 }
-exports.isTraceableFunction = isTraceableFunction;

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

@@ -1,8 +1,8 @@
-import { RunTree } from "../run_trees.js";
-import { TraceableFunction } from "./types.js";
+import type { RunTree } from "../run_trees.js";
+import type { ContextPlaceholder, TraceableFunction } from "./types.js";
 interface AsyncLocalStorageInterface {
-    getStore: () => RunTree | undefined;
-    run: (context: RunTree | undefined, fn: () => void) => void;
+    getStore: () => RunTree | ContextPlaceholder | undefined;
+    run: (context: RunTree | ContextPlaceholder | undefined, fn: () => void) => void;
 }
 declare class AsyncLocalStorageProvider {
     getInstance(): AsyncLocalStorageInterface;
@@ -15,7 +15,9 @@ export declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvid
  *
  * @returns The run tree for the given context.
  */
-export declare const getCurrentRunTree: () => RunTree;
+export declare function getCurrentRunTree(): RunTree;
+export declare function getCurrentRunTree(permitAbsentRunTree: false): RunTree;
+export declare function getCurrentRunTree(permitAbsentRunTree: boolean): RunTree | undefined;
 export declare function withRunTree<Fn extends (...args: any[]) => any>(runTree: RunTree, fn: Fn): Promise<Awaited<ReturnType<Fn>>>;
 export declare const ROOT: unique symbol;
 export declare function isTraceableFunction(x: unknown): x is TraceableFunction<any>;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/traceable.js

@@ -1,4 +1,3 @@
-import { isRunTree } from "../run_trees.js";
 class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -23,23 +22,13 @@ class AsyncLocalStorageProvider {
     }
 }
 export const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
-/**
- * Return the current run tree from within a traceable-wrapped function.
- * Will throw an error if called outside of a traceable function.
- *
- * @returns The run tree for the given context.
- */
-export const getCurrentRunTree = () => {
+export function getCurrentRunTree(permitAbsentRunTree = false) {
     const runTree = AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    if (!isRunTree(runTree)) {
-        throw new Error([
-            "Could not get the current run tree.",
-            "",
-            "Please make sure you are calling this method within a traceable function and that tracing is enabled.",
-        ].join("\n"));
+    if (!permitAbsentRunTree && runTree === undefined) {
+        throw new Error("Could not get the current run tree.\n\nPlease make sure you are calling this method within a traceable function and that tracing is enabled.");
     }
     return runTree;
-};
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function withRunTree(runTree, fn) {
     const storage = AsyncLocalStorageProviderSingleton.getInstance();

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/types.cjs

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const constants_js_1 = require("./constants.cjs");

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/types.d.ts

@@ -1,5 +1,6 @@
 import { RunTree, RunnableConfigLike } from "../run_trees.js";
 import { ROOT } from "./traceable.js";
+import { _LC_CONTEXT_VARIABLES_KEY } from "./constants.js";
 type SmartPromise<T> = T extends AsyncGenerator ? T : T extends Promise<unknown> ? T : Promise<T>;
 type WrapArgReturnPair<Pair> = Pair extends [
     infer Args extends any[],
@@ -37,4 +38,7 @@ export type TraceableFunction<Func extends (...args: any[]) => any> = (Func exte
     [K in keyof Func]: Func[K];
 };
 export type RunTreeLike = RunTree;
+export type ContextPlaceholder = {
+    [_LC_CONTEXT_VARIABLES_KEY]?: Record<string, unknown>;
+};
 export {};

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/types.js

@@ -1 +1 @@
-export {};
+import { _LC_CONTEXT_VARIABLES_KEY } from "./constants.js";