langsmith 0.1.25 → 0.1.27

package/dist/run_trees.cjs

@@ -27,6 +27,7 @@ exports.isRunnableConfigLike = exports.isRunTree = exports.RunTree = exports.con
 const uuid = __importStar(require("uuid"));
 const env_js_1 = require("./utils/env.cjs");
 const client_js_1 = require("./client.cjs");
+const env_js_2 = require("./env.cjs");
 const warnedMessages = {};
 function warnOnce(message) {
     if (!warnedMessages[message]) {
@@ -208,34 +209,42 @@ class RunTree {
             }
         }
     }
-    static fromRunnableConfig(config, props) {
+    static fromRunnableConfig(parentConfig, props) {
         // We only handle the callback manager case for now
-        const callbackManager = config?.callbacks;
+        const callbackManager = parentConfig?.callbacks;
         let parentRun;
         let projectName;
+        let client;
+        let tracingEnabled = (0, env_js_2.isTracingEnabled)();
         if (callbackManager) {
             const parentRunId = callbackManager?.getParentRunId?.() ?? "";
             const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
             parentRun = langChainTracer?.getRun?.(parentRunId);
             projectName = langChainTracer?.projectName;
+            client = langChainTracer?.client;
+            tracingEnabled = tracingEnabled || !!langChainTracer;
         }
-        const dedupedTags = [
-            ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
-        ];
-        const dedupedMetadata = {
-            ...parentRun?.extra?.metadata,
-            ...config?.metadata,
-        };
-        const rt = new RunTree({
-            name: props?.name ?? "<lambda>",
-            parent_run: parentRun,
-            tags: dedupedTags,
+        const parentRunTree = new RunTree({
+            name: parentRun?.name ?? "<parent>",
+            id: parentRun?.id,
+            client,
+            tracingEnabled,
+            project_name: projectName,
+            tags: [
+                ...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? [])),
+            ],
             extra: {
-                metadata: dedupedMetadata,
+                metadata: {
+                    ...parentRun?.extra?.metadata,
+                    ...parentConfig?.metadata,
+                },
             },
-            project_name: projectName,
         });
-        return rt;
+        return parentRunTree.createChild({
+            name: props?.name ?? "<lambda>",
+            tags: props.tags,
+            metadata: props.metadata,
+        });
     }
     static getDefaultConfig() {
         return {

package/dist/run_trees.d.ts

@@ -66,7 +66,7 @@ export declare class RunTree implements BaseRun {
     execution_order: number;
     child_execution_order: number;
     constructor(originalConfig: RunTreeConfig);
-    static fromRunnableConfig(config: RunnableConfigLike, props: {
+    static fromRunnableConfig(parentConfig: RunnableConfigLike, props: {
         name: string;
         tags?: string[];
         metadata?: KVMap;

package/dist/run_trees.js

@@ -1,6 +1,7 @@
 import * as uuid from "uuid";
 import { getEnvironmentVariable, getRuntimeEnvironment, } from "./utils/env.js";
 import { Client } from "./client.js";
+import { isTracingEnabled } from "./env.js";
 const warnedMessages = {};
 function warnOnce(message) {
     if (!warnedMessages[message]) {
@@ -181,34 +182,42 @@ export class RunTree {
             }
         }
     }
-    static fromRunnableConfig(config, props) {
+    static fromRunnableConfig(parentConfig, props) {
         // We only handle the callback manager case for now
-        const callbackManager = config?.callbacks;
+        const callbackManager = parentConfig?.callbacks;
         let parentRun;
         let projectName;
+        let client;
+        let tracingEnabled = isTracingEnabled();
         if (callbackManager) {
             const parentRunId = callbackManager?.getParentRunId?.() ?? "";
             const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
             parentRun = langChainTracer?.getRun?.(parentRunId);
             projectName = langChainTracer?.projectName;
+            client = langChainTracer?.client;
+            tracingEnabled = tracingEnabled || !!langChainTracer;
         }
-        const dedupedTags = [
-            ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
-        ];
-        const dedupedMetadata = {
-            ...parentRun?.extra?.metadata,
-            ...config?.metadata,
-        };
-        const rt = new RunTree({
-            name: props?.name ?? "<lambda>",
-            parent_run: parentRun,
-            tags: dedupedTags,
+        const parentRunTree = new RunTree({
+            name: parentRun?.name ?? "<parent>",
+            id: parentRun?.id,
+            client,
+            tracingEnabled,
+            project_name: projectName,
+            tags: [
+                ...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? [])),
+            ],
             extra: {
-                metadata: dedupedMetadata,
+                metadata: {
+                    ...parentRun?.extra?.metadata,
+                    ...parentConfig?.metadata,
+                },
             },
-            project_name: projectName,
         });
-        return rt;
+        return parentRunTree.createChild({
+            name: props?.name ?? "<lambda>",
+            tags: props.tags,
+            metadata: props.metadata,
+        });
     }
     static getDefaultConfig() {
         return {

package/dist/schemas.d.ts

@@ -162,6 +162,7 @@ export interface RunUpdate {
 export interface ExampleCreate extends BaseExample {
     id?: string;
     created_at?: string;
+    split?: string | string[];
 }
 export interface Example extends BaseExample {
     id: string;
@@ -175,6 +176,7 @@ export interface ExampleUpdate {
     inputs?: KVMap;
     outputs?: KVMap;
     metadata?: KVMap;
+    split?: string | string[];
 }
 export interface BaseDataset {
     name: string;
@@ -293,4 +295,22 @@ export interface ComparativeExperiment {
     experiments_info?: Array<Record<string, unknown>>;
     feedback_stats?: Record<string, unknown>;
 }
+/**
+ * Represents the expected output schema returned by traceable
+ * or by run tree output for LangSmith to correctly display
+ * documents in the UI
+ */
+export type RetrieverOutput = Array<{
+    page_content: string;
+    type: "Document";
+    metadata?: KVMap;
+}>;
+export interface InvocationParamsSchema {
+    ls_provider?: string;
+    ls_model_name?: string;
+    ls_model_type: "chat";
+    ls_temperature?: number;
+    ls_max_tokens?: number;
+    ls_stop?: string[];
+}
 export {};

package/dist/singletons/traceable.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTraceableFunction = exports.ROOT = exports.getCurrentRunTree = exports.AsyncLocalStorageProviderSingleton = void 0;
+class MockAsyncLocalStorage {
+    getStore() {
+        return undefined;
+    }
+    run(_, callback) {
+        return callback();
+    }
+}
+class AsyncLocalStorageProvider {
+    constructor() {
+        Object.defineProperty(this, "asyncLocalStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new MockAsyncLocalStorage()
+        });
+        Object.defineProperty(this, "hasBeenInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    getInstance() {
+        return this.asyncLocalStorage;
+    }
+    initializeGlobalInstance(instance) {
+        if (!this.hasBeenInitialized) {
+            this.hasBeenInitialized = true;
+            this.asyncLocalStorage = instance;
+        }
+    }
+}
+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 = () => {
+    const runTree = exports.AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    if (runTree === undefined) {
+        throw new Error([
+            "Could not get the current run tree.",
+            "",
+            "Please make sure you are calling this method within a traceable function.",
+        ].join("\n"));
+    }
+    return runTree;
+};
+exports.getCurrentRunTree = getCurrentRunTree;
+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/singletons/traceable.d.ts

@@ -0,0 +1,23 @@
+import { RunTree } from "../run_trees.js";
+import { TraceableFunction } from "./types.js";
+interface AsyncLocalStorageInterface {
+    getStore: () => RunTree | undefined;
+    run: (context: RunTree | undefined, fn: () => void) => void;
+}
+declare class AsyncLocalStorageProvider {
+    private asyncLocalStorage;
+    private hasBeenInitialized;
+    getInstance(): AsyncLocalStorageInterface;
+    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
+}
+export declare const AsyncLocalStorageProviderSingleton: 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 declare const getCurrentRunTree: () => RunTree;
+export declare const ROOT: unique symbol;
+export declare function isTraceableFunction(x: unknown): x is TraceableFunction<any>;
+export {};

package/dist/singletons/traceable.js

@@ -0,0 +1,57 @@
+class MockAsyncLocalStorage {
+    getStore() {
+        return undefined;
+    }
+    run(_, callback) {
+        return callback();
+    }
+}
+class AsyncLocalStorageProvider {
+    constructor() {
+        Object.defineProperty(this, "asyncLocalStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new MockAsyncLocalStorage()
+        });
+        Object.defineProperty(this, "hasBeenInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    getInstance() {
+        return this.asyncLocalStorage;
+    }
+    initializeGlobalInstance(instance) {
+        if (!this.hasBeenInitialized) {
+            this.hasBeenInitialized = true;
+            this.asyncLocalStorage = instance;
+        }
+    }
+}
+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 = () => {
+    const runTree = AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    if (runTree === undefined) {
+        throw new Error([
+            "Could not get the current run tree.",
+            "",
+            "Please make sure you are calling this method within a traceable function.",
+        ].join("\n"));
+    }
+    return runTree;
+};
+export const ROOT = Symbol.for("langsmith:traceable:root");
+export function isTraceableFunction(x
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    return typeof x === "function" && "langsmith:traceable" in x;
+}

package/dist/singletons/types.cjs

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

package/dist/singletons/types.d.ts

@@ -0,0 +1,38 @@
+import { RunTree, RunnableConfigLike } from "../run_trees.js";
+import { ROOT } from "./traceable.js";
+type SmartPromise<T> = T extends AsyncGenerator ? T : T extends Promise<unknown> ? T : Promise<T>;
+type WrapArgReturnPair<Pair> = Pair extends [
+    infer Args extends any[],
+    infer Return
+] ? Args extends [RunTree, ...infer RestArgs] ? {
+    (runTree: RunTree | typeof ROOT, ...args: RestArgs): SmartPromise<Return>;
+    (config: RunnableConfigLike, ...args: RestArgs): SmartPromise<Return>;
+} : {
+    (...args: Args): SmartPromise<Return>;
+    (runTree: RunTree, ...rest: Args): SmartPromise<Return>;
+    (config: RunnableConfigLike, ...args: Args): SmartPromise<Return>;
+} : never;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export type TraceableFunction<Func extends (...args: any[]) => any> = Func extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+    (...args: infer A5): infer R5;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3] | [A4, R4] | [A5, R5]>> : Func extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+    (...args: infer A4): infer R4;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3] | [A4, R4]>> : Func extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3]>> : Func extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2]>> : Func extends {
+    (...args: infer A1): infer R1;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1]>> : never;
+export type RunTreeLike = RunTree;
+export {};

package/dist/singletons/types.js

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

package/dist/traceable.cjs

@@ -1,26 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapFunctionAndEnsureTraceable = exports.isTraceableFunction = exports.getCurrentRunTree = exports.traceable = exports.ROOT = void 0;
+exports.ROOT = exports.isTraceableFunction = exports.getCurrentRunTree = exports.traceable = void 0;
 const node_async_hooks_1 = require("node:async_hooks");
 const run_trees_js_1 = require("./run_trees.cjs");
-const env_js_1 = require("./utils/env.cjs");
+const env_js_1 = require("./env.cjs");
+const traceable_js_1 = require("./singletons/traceable.cjs");
+traceable_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
 function isPromiseMethod(x) {
     if (x === "then" || x === "catch" || x === "finally") {
         return true;
     }
     return false;
 }
-const asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
-exports.ROOT = Symbol("langsmith:traceable:root");
+function isKVMap(x) {
+    if (typeof x !== "object" || x == null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(x);
+    return ((prototype === null ||
+        prototype === Object.prototype ||
+        Object.getPrototypeOf(prototype) === null) &&
+        !(Symbol.toStringTag in x) &&
+        !(Symbol.iterator in x));
+}
 const isAsyncIterable = (x) => x != null &&
     typeof x === "object" &&
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     typeof x[Symbol.asyncIterator] === "function";
-const GeneratorFunction = function* () { }.constructor;
 const isIteratorLike = (x) => x != null &&
     typeof x === "object" &&
     "next" in x &&
     typeof x.next === "function";
+const GeneratorFunction = function* () { }.constructor;
 const isGenerator = (x) => 
 // eslint-disable-next-line no-instanceof/no-instanceof
 x != null && typeof x === "function" && x instanceof GeneratorFunction;
@@ -32,18 +43,6 @@ const isReadableStream = (x) => x != null &&
     typeof x === "object" &&
     "getReader" in x &&
     typeof x.getReader === "function";
-const tracingIsEnabled = (tracingEnabled) => {
-    if (tracingEnabled !== undefined) {
-        return tracingEnabled;
-    }
-    const envVars = [
-        "LANGSMITH_TRACING_V2",
-        "LANGCHAIN_TRACING_V2",
-        "LANGSMITH_TRACING",
-        "LANGCHAIN_TRACING",
-    ];
-    return Boolean(envVars.find((envVar) => (0, env_js_1.getEnvironmentVariable)(envVar) === "true"));
-};
 const handleRunInputs = (rawInputs) => {
     const firstInput = rawInputs[0];
     if (firstInput == null) {
@@ -63,12 +62,19 @@ const handleRunOutputs = (rawOutputs) => {
     }
     return { outputs: rawOutputs };
 };
-const getTracingRunTree = (runTree, inputs) => {
-    const tracingEnabled_ = tracingIsEnabled(runTree.tracingEnabled);
-    if (!tracingEnabled_) {
+const getTracingRunTree = (runTree, inputs, getInvocationParams) => {
+    if (!(0, env_js_1.isTracingEnabled)(runTree.tracingEnabled)) {
         return undefined;
     }
     runTree.inputs = handleRunInputs(inputs);
+    const invocationParams = getInvocationParams?.(...inputs);
+    if (invocationParams != null) {
+        runTree.extra ??= {};
+        runTree.extra.metadata = {
+            ...runTree.extra.metadata,
+            ...invocationParams,
+        };
+    }
     return runTree;
 };
 // idea: store the state of the promise outside
@@ -269,6 +275,7 @@ function traceable(wrappedFunc, config) {
                 ...runTreeConfig,
             };
         }
+        const asyncLocalStorage = traceable_js_1.AsyncLocalStorageProviderSingleton.getInstance();
         // TODO: deal with possible nested promises and async iterables
         const processedArgs = args;
         for (let i = 0; i < processedArgs.length; i++) {
@@ -279,11 +286,11 @@ function traceable(wrappedFunc, config) {
             // used for handoff between LangChain.JS and traceable functions
             if ((0, run_trees_js_1.isRunnableConfigLike)(firstArg)) {
                 return [
-                    getTracingRunTree(run_trees_js_1.RunTree.fromRunnableConfig(firstArg, ensuredConfig), restArgs),
+                    getTracingRunTree(run_trees_js_1.RunTree.fromRunnableConfig(firstArg, ensuredConfig), restArgs, config?.getInvocationParams),
                     restArgs,
                 ];
             }
-            // legacy CallbackManagerRunTree used in runOnDataset
+            // deprecated: legacy CallbackManagerRunTree used in runOnDataset
             // override ALS and do not pass-through the run tree
             if ((0, run_trees_js_1.isRunTree)(firstArg) &&
                 "callbackManager" in firstArg &&
@@ -292,10 +299,10 @@ function traceable(wrappedFunc, config) {
             }
             // when ALS is unreliable, users can manually
             // pass in the run tree
-            if (firstArg === exports.ROOT || (0, run_trees_js_1.isRunTree)(firstArg)) {
-                const currentRunTree = getTracingRunTree(firstArg === exports.ROOT
+            if (firstArg === traceable_js_1.ROOT || (0, run_trees_js_1.isRunTree)(firstArg)) {
+                const currentRunTree = getTracingRunTree(firstArg === traceable_js_1.ROOT
                     ? new run_trees_js_1.RunTree(ensuredConfig)
-                    : firstArg.createChild(ensuredConfig), restArgs);
+                    : firstArg.createChild(ensuredConfig), restArgs, config?.getInvocationParams);
                 return [currentRunTree, [currentRunTree, ...restArgs]];
             }
             // Node.JS uses AsyncLocalStorage (ALS) and AsyncResource
@@ -303,11 +310,11 @@ function traceable(wrappedFunc, config) {
             const prevRunFromStore = asyncLocalStorage.getStore();
             if (prevRunFromStore) {
                 return [
-                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs),
+                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams),
                     processedArgs,
                 ];
             }
-            const currentRunTree = getTracingRunTree(new run_trees_js_1.RunTree(ensuredConfig), processedArgs);
+            const currentRunTree = getTracingRunTree(new run_trees_js_1.RunTree(ensuredConfig), processedArgs, config?.getInvocationParams);
             return [currentRunTree, processedArgs];
         })();
         return asyncLocalStorage.run(currentRunTree, () => {
@@ -444,48 +451,7 @@ function traceable(wrappedFunc, config) {
     return traceableFunc;
 }
 exports.traceable = traceable;
-/**
- * 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.
- */
-function getCurrentRunTree() {
-    const runTree = asyncLocalStorage.getStore();
-    if (runTree === undefined) {
-        throw new Error([
-            "Could not get the current run tree.",
-            "",
-            "Please make sure you are calling this method within a traceable function.",
-        ].join("\n"));
-    }
-    return runTree;
-}
-exports.getCurrentRunTree = getCurrentRunTree;
-function isTraceableFunction(x
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    return typeof x === "function" && "langsmith:traceable" in x;
-}
-exports.isTraceableFunction = isTraceableFunction;
-function isKVMap(x) {
-    if (typeof x !== "object" || x == null) {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(x);
-    return ((prototype === null ||
-        prototype === Object.prototype ||
-        Object.getPrototypeOf(prototype) === null) &&
-        !(Symbol.toStringTag in x) &&
-        !(Symbol.iterator in x));
-}
-function wrapFunctionAndEnsureTraceable(target, options, name = "target") {
-    if (typeof target === "function") {
-        return traceable(target, {
-            ...options,
-            name,
-        });
-    }
-    throw new Error("Target must be runnable function");
-}
-exports.wrapFunctionAndEnsureTraceable = wrapFunctionAndEnsureTraceable;
+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; } });
+Object.defineProperty(exports, "ROOT", { enumerable: true, get: function () { return traceable_js_2.ROOT; } });

package/dist/traceable.d.ts

@@ -1,40 +1,6 @@
-import { RunTree, RunTreeConfig, RunnableConfigLike } from "./run_trees.js";
-export declare const ROOT: unique symbol;
-export type RunTreeLike = RunTree;
-type SmartPromise<T> = T extends AsyncGenerator ? T : T extends Promise<unknown> ? T : Promise<T>;
-type WrapArgReturnPair<Pair> = Pair extends [
-    infer Args extends any[],
-    infer Return
-] ? Args extends [RunTreeLike, ...infer RestArgs] ? {
-    (runTree: RunTreeLike | typeof ROOT, ...args: RestArgs): SmartPromise<Return>;
-    (config: RunnableConfigLike, ...args: RestArgs): SmartPromise<Return>;
-} : {
-    (...args: Args): SmartPromise<Return>;
-    (runTree: RunTreeLike, ...rest: Args): SmartPromise<Return>;
-    (config: RunnableConfigLike, ...args: Args): SmartPromise<Return>;
-} : never;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export type TraceableFunction<Func extends (...args: any[]) => any> = Func extends {
-    (...args: infer A1): infer R1;
-    (...args: infer A2): infer R2;
-    (...args: infer A3): infer R3;
-    (...args: infer A4): infer R4;
-    (...args: infer A5): infer R5;
-} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3] | [A4, R4] | [A5, R5]>> : Func extends {
-    (...args: infer A1): infer R1;
-    (...args: infer A2): infer R2;
-    (...args: infer A3): infer R3;
-    (...args: infer A4): infer R4;
-} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3] | [A4, R4]>> : Func extends {
-    (...args: infer A1): infer R1;
-    (...args: infer A2): infer R2;
-    (...args: infer A3): infer R3;
-} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2] | [A3, R3]>> : Func extends {
-    (...args: infer A1): infer R1;
-    (...args: infer A2): infer R2;
-} ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2]>> : Func extends {
-    (...args: infer A1): infer R1;
-} ? UnionToIntersection<WrapArgReturnPair<[A1, R1]>> : never;
+import { RunTreeConfig } from "./run_trees.js";
+import { InvocationParamsSchema } 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
@@ -52,14 +18,15 @@ export type TraceableFunction<Func extends (...args: any[]) => any> = Func exten
 export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: Partial<RunTreeConfig> & {
     aggregator?: (args: any[]) => any;
     argsConfigPath?: [number] | [number, string];
+    /**
+     * Extract invocation parameters from the arguments of the traced function.
+     * This is useful for LangSmith to properly track common metadata like
+     * provider, model name and temperature.
+     *
+     * @param args Arguments of the traced function
+     * @returns Key-value map of the invocation parameters, which will be merged with the existing metadata
+     */
+    getInvocationParams?: (...args: Parameters<Func>) => InvocationParamsSchema | undefined;
 }): TraceableFunction<Func>;
-/**
- * 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 declare function getCurrentRunTree(): RunTree;
-export declare function isTraceableFunction(x: unknown): x is TraceableFunction<any>;
-export declare function wrapFunctionAndEnsureTraceable<Func extends (...args: any[]) => any>(target: Func, options: Partial<RunTreeConfig>, name?: string): TraceableFunction<Func>;
-export {};
+export { getCurrentRunTree, isTraceableFunction, ROOT, } from "./singletons/traceable.js";
+export type { RunTreeLike, TraceableFunction } from "./singletons/types.js";