@nocobase/plugin-ai 1.9.0-beta.9 → 2.0.0-alpha.10

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 { getEnvironmentVariable } 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 && getEnvironmentVariable("OTEL_ENABLED") === "true") {
+            console.warn("You have enabled OTEL export via the `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,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTraceableFunction = exports.ROOT = exports.withRunTree = exports.getCurrentRunTree = exports.AsyncLocalStorageProviderSingleton = void 0;
+exports.ROOT = exports.AsyncLocalStorageProviderSingleton = void 0;
+exports.getCurrentRunTree = getCurrentRunTree;
+exports.withRunTree = withRunTree;
+exports.isTraceableFunction = isTraceableFunction;
 const run_trees_js_1 = require("../run_trees.cjs");
 class MockAsyncLocalStorage {
     getStore() {
@@ -26,24 +29,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 && !(0, run_trees_js_1.isRunTree)(runTree)) {
+        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 +43,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

@@ -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

@@ -23,23 +23,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 && !isRunTree(runTree)) {
+        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/traceable.cjs

@@ -1,13 +1,49 @@
 "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");
 traceable_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
+/**
+ * Create OpenTelemetry context manager from RunTree if OTEL is enabled.
+ */
+function maybeCreateOtelContext(runTree, tracer
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (!runTree || (0, env_js_2.getEnvironmentVariable)("OTEL_ENABLED") !== "true") {
+        return;
+    }
+    const otel_trace = (0, otel_js_1.getOTELTrace)();
+    const otel_context = (0, otel_js_1.getOTELContext)();
+    try {
+        const spanContext = (0, utils_js_1.createOtelSpanContextFromRun)(runTree);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (fn) => {
+            const resolvedTracer = tracer ?? otel_trace.getTracer("langsmith", index_js_1.__version__);
+            return resolvedTracer.startActiveSpan(runTree.name, {
+                attributes: {
+                    "langsmith.traceable": "true",
+                },
+            }, () => {
+                otel_trace.setSpanContext(otel_context.active(), spanContext);
+                return fn();
+            });
+        };
+    }
+    catch {
+        // Silent failure if OTEL setup is incomplete
+        return;
+    }
+}
 const runInputsToMap = (rawInputs) => {
     const firstInput = rawInputs[0];
     let inputs;
@@ -34,22 +70,64 @@ 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;
+};
+function validateExtractedUsageMetadata(data) {
+    const allowedKeys = new Set([
+        "input_tokens",
+        "output_tokens",
+        "total_tokens",
+        "input_token_details",
+        "output_token_details",
+        "input_cost",
+        "output_cost",
+        "total_cost",
+        "input_cost_details",
+        "output_cost_details",
+    ]);
+    const extraKeys = Object.keys(data).filter((key) => !allowedKeys.has(key));
+    if (extraKeys.length > 0) {
+        throw new Error(`Unexpected keys in usage metadata: ${extraKeys.join(", ")}`);
+    }
+    return data;
+}
+// Note: This mutates the run tree
+function handleRunOutputs(params) {
+    const { runTree, rawOutputs, processOutputsFn } = 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);
     }
     catch (e) {
-        console.error("Error occurred during processOutputs. Sending raw outputs:", e);
-        return outputs;
+        console.error("Error occurred during processOutputs. Sending unprocessed outputs:", e);
     }
-};
+    if (runTree !== undefined) {
+        let usageMetadata;
+        try {
+            usageMetadata = _extractUsage({ runTree, outputs });
+        }
+        catch (e) {
+            console.error("Error occurred while extracting usage metadata:", e);
+        }
+        if (usageMetadata !== undefined) {
+            runTree.extra.metadata = {
+                ...runTree.extra.metadata,
+                usage_metadata: validateExtractedUsageMetadata(usageMetadata),
+            };
+            outputs.usage_metadata = usageMetadata;
+        }
+    }
+    return outputs;
+}
 const handleRunAttachments = (rawInputs, extractAttachments) => {
     if (!extractAttachments) {
         return [undefined, rawInputs];
@@ -189,7 +267,6 @@ const convertSerializableArg = (arg) => {
                 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);
@@ -332,7 +409,9 @@ function traceable(wrappedFunc, config) {
             }
             return [currentRunTree, processedArgs];
         })();
-        return asyncLocalStorage.run(currentRunTree, () => {
+        const otelContextManager = maybeCreateOtelContext(currentRunTree, config?.tracer);
+        const otel_context = (0, otel_js_1.getOTELContext)();
+        const runWithContext = () => {
             const postRunPromise = currentRunTree?.postRun();
             async function handleChunks(chunks) {
                 if (aggregator !== undefined) {
@@ -349,16 +428,22 @@ 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));
+                                const processedOutputs = handleRunOutputs({
+                                    runTree: currentRunTree,
+                                    rawOutputs: await handleChunks(chunks),
+                                    processOutputsFn,
+                                });
+                                await currentRunTree?.end(processedOutputs);
                                 await handleEnd();
                                 controller.close();
                                 break;
@@ -377,7 +462,12 @@ function traceable(wrappedFunc, config) {
                     async cancel(reason) {
                         if (!finished)
                             await currentRunTree?.end(undefined, "Cancelled");
-                        await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
+                        const processedOutputs = handleRunOutputs({
+                            runTree: currentRunTree,
+                            rawOutputs: await handleChunks(chunks),
+                            processOutputsFn,
+                        });
+                        await currentRunTree?.end(processedOutputs);
                         await handleEnd();
                         return reader.cancel(reason);
                     },
@@ -387,11 +477,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,7 +505,12 @@ function traceable(wrappedFunc, config) {
                 finally {
                     if (!finished)
                         await currentRunTree?.end(undefined, "Cancelled");
-                    await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks), processOutputsFn));
+                    const processedOutputs = handleRunOutputs({
+                        runTree: currentRunTree,
+                        rawOutputs: await handleChunks(chunks),
+                        processOutputsFn,
+                    });
+                    await currentRunTree?.end(processedOutputs);
                     await handleEnd();
                 }
             }
@@ -494,12 +590,17 @@ 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));
+                            const processedOutputs = handleRunOutputs({
+                                runTree: currentRunTree,
+                                rawOutputs: await handleChunks(chunks.reduce((memo, { value, done }) => {
+                                    if (!done || typeof value !== "undefined") {
+                                        memo.push(value);
+                                    }
+                                    return memo;
+                                }, [])),
+                                processOutputsFn,
+                            });
+                            await currentRunTree?.end(processedOutputs);
                             await handleEnd();
                         }
                         catch (e) {
@@ -514,7 +615,12 @@ function traceable(wrappedFunc, config) {
                         })();
                     }
                     try {
-                        await currentRunTree?.end(handleRunOutputs(rawOutput, processOutputsFn));
+                        const processedOutputs = handleRunOutputs({
+                            runTree: currentRunTree,
+                            rawOutputs: rawOutput,
+                            processOutputsFn,
+                        });
+                        await currentRunTree?.end(processedOutputs);
                         await handleEnd();
                     }
                     finally {
@@ -539,14 +645,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(currentRunTree, () => otelContextManager(runWithContext));
+        }
+        else {
+            return asyncLocalStorage.run(currentRunTree, 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,6 +1,7 @@
 import { RunTreeConfig } from "./run_trees.js";
 import { Attachments, InvocationParamsSchema, KVMap } from "./schemas.js";
 import { TraceableFunction } from "./singletons/types.js";
+import { OTELTracer } from "./experimental/otel/types.js";
 /**
  * Higher-order function that takes function as input and returns a
  * "TraceableFunction" - a wrapped version of the input that
@@ -15,9 +16,10 @@ import { TraceableFunction } from "./singletons/types.js";
  * @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> & {
+export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: 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.