langsmith 0.1.26 → 0.1.27

package/dist/env.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTracingEnabled = void 0;
+const env_js_1 = require("./utils/env.cjs");
+const isTracingEnabled = (tracingEnabled) => {
+    if (tracingEnabled !== undefined) {
+        return tracingEnabled;
+    }
+    const envVars = [
+        "LANGSMITH_TRACING_V2",
+        "LANGCHAIN_TRACING_V2",
+        "LANGSMITH_TRACING",
+        "LANGCHAIN_TRACING",
+    ];
+    return !!envVars.find((envVar) => (0, env_js_1.getEnvironmentVariable)(envVar) === "true");
+};
+exports.isTracingEnabled = isTracingEnabled;

package/dist/env.d.ts

@@ -0,0 +1 @@
+export declare const isTracingEnabled: (tracingEnabled?: boolean) => boolean;

package/dist/env.js

@@ -0,0 +1,13 @@
+import { getEnvironmentVariable } from "./utils/env.js";
+export const isTracingEnabled = (tracingEnabled) => {
+    if (tracingEnabled !== undefined) {
+        return tracingEnabled;
+    }
+    const envVars = [
+        "LANGSMITH_TRACING_V2",
+        "LANGCHAIN_TRACING_V2",
+        "LANGSMITH_TRACING",
+        "LANGCHAIN_TRACING",
+    ];
+    return !!envVars.find((envVar) => getEnvironmentVariable(envVar) === "true");
+};

package/dist/index.cjs

@@ -6,4 +6,4 @@ Object.defineProperty(exports, "Client", { enumerable: true, get: function () {
 var run_trees_js_1 = require("./run_trees.cjs");
 Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () { return run_trees_js_1.RunTree; } });
 // Update using yarn bump-version
-exports.__version__ = "0.1.26";
+exports.__version__ = "0.1.27";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
-export declare const __version__ = "0.1.26";
+export declare const __version__ = "0.1.27";

package/dist/index.js

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export { RunTree } from "./run_trees.js";
 // Update using yarn bump-version
-export const __version__ = "0.1.26";
+export const __version__ = "0.1.27";

package/dist/langchain.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnableTraceable = exports.getLangchainCallbacks = void 0;
+const manager_1 = require("@langchain/core/callbacks/manager");
+const tracer_langchain_1 = require("@langchain/core/tracers/tracer_langchain");
+const runnables_1 = require("@langchain/core/runnables");
+const traceable_js_1 = require("./traceable.cjs");
+/**
+ * Converts the current run tree active within a traceable-wrapped function
+ * into a LangChain compatible callback manager. This is useful to handoff tracing
+ * from LangSmith to LangChain Runnables and LLMs.
+ *
+ * @param {RunTree | undefined} currentRunTree Current RunTree from within a traceable-wrapped function. If not provided, the current run tree will be inferred from AsyncLocalStorage.
+ * @returns {CallbackManager | undefined} Callback manager used by LangChain Runnable objects.
+ */
+async function getLangchainCallbacks(currentRunTree) {
+    const runTree = currentRunTree ?? (0, traceable_js_1.getCurrentRunTree)();
+    if (!runTree)
+        return undefined;
+    // TODO: CallbackManager.configure() is only async due to LangChainTracer
+    // factory being unnecessarily async.
+    let callbacks = await manager_1.CallbackManager.configure();
+    if (!callbacks && runTree.tracingEnabled) {
+        callbacks = new manager_1.CallbackManager();
+    }
+    let langChainTracer = callbacks?.handlers.find((handler) => handler?.name === "langchain_tracer");
+    if (!langChainTracer && runTree.tracingEnabled) {
+        langChainTracer = new tracer_langchain_1.LangChainTracer();
+        callbacks?.addHandler(langChainTracer);
+    }
+    const runMap = new Map();
+    // find upward root run
+    let rootRun = runTree;
+    const rootVisited = new Set();
+    while (rootRun.parent_run) {
+        if (rootVisited.has(rootRun.id))
+            break;
+        rootVisited.add(rootRun.id);
+        rootRun = rootRun.parent_run;
+    }
+    const queue = [rootRun];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || visited.has(current.id))
+            continue;
+        visited.add(current.id);
+        runMap.set(current.id, current);
+        if (current.child_runs) {
+            queue.push(...current.child_runs);
+        }
+    }
+    if (callbacks != null) {
+        Object.assign(callbacks, { _parentRunId: runTree.id });
+    }
+    if (langChainTracer != null) {
+        Object.assign(langChainTracer, {
+            runMap,
+            client: runTree.client,
+            projectName: runTree.project_name || langChainTracer.projectName,
+            exampleId: runTree.reference_example_id || langChainTracer.exampleId,
+        });
+    }
+    return callbacks;
+}
+exports.getLangchainCallbacks = getLangchainCallbacks;
+/**
+ * RunnableTraceable is a Runnable that wraps a traceable function.
+ * This allows adding Langsmith traced functions into LangChain sequences.
+ */
+class RunnableTraceable extends runnables_1.Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!(0, traceable_js_1.isTraceableFunction)(fields.func)) {
+            throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+        }
+        this.func = fields.func;
+    }
+    async invoke(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
+        return (await this.func(config, input));
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}
+exports.RunnableTraceable = RunnableTraceable;

package/dist/langchain.d.ts

@@ -0,0 +1,29 @@
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { Runnable, RunnableConfig } from "@langchain/core/runnables";
+import { RunTree } from "./run_trees.js";
+import { TraceableFunction } from "./traceable.js";
+/**
+ * Converts the current run tree active within a traceable-wrapped function
+ * into a LangChain compatible callback manager. This is useful to handoff tracing
+ * from LangSmith to LangChain Runnables and LLMs.
+ *
+ * @param {RunTree | undefined} currentRunTree Current RunTree from within a traceable-wrapped function. If not provided, the current run tree will be inferred from AsyncLocalStorage.
+ * @returns {CallbackManager | undefined} Callback manager used by LangChain Runnable objects.
+ */
+export declare function getLangchainCallbacks(currentRunTree?: RunTree | undefined): Promise<CallbackManager | undefined>;
+type AnyTraceableFunction = TraceableFunction<(...any: any[]) => any>;
+/**
+ * RunnableTraceable is a Runnable that wraps a traceable function.
+ * This allows adding Langsmith traced functions into LangChain sequences.
+ */
+export declare class RunnableTraceable<RunInput, RunOutput> extends Runnable<RunInput, RunOutput> {
+    lc_serializable: boolean;
+    lc_namespace: string[];
+    protected func: AnyTraceableFunction;
+    constructor(fields: {
+        func: AnyTraceableFunction;
+    });
+    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
+    static from(func: AnyTraceableFunction): RunnableTraceable<unknown, unknown>;
+}
+export {};

package/dist/langchain.js

@@ -0,0 +1,100 @@
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
+import { Runnable } from "@langchain/core/runnables";
+import { getCurrentRunTree, isTraceableFunction, } from "./traceable.js";
+/**
+ * Converts the current run tree active within a traceable-wrapped function
+ * into a LangChain compatible callback manager. This is useful to handoff tracing
+ * from LangSmith to LangChain Runnables and LLMs.
+ *
+ * @param {RunTree | undefined} currentRunTree Current RunTree from within a traceable-wrapped function. If not provided, the current run tree will be inferred from AsyncLocalStorage.
+ * @returns {CallbackManager | undefined} Callback manager used by LangChain Runnable objects.
+ */
+export async function getLangchainCallbacks(currentRunTree) {
+    const runTree = currentRunTree ?? getCurrentRunTree();
+    if (!runTree)
+        return undefined;
+    // TODO: CallbackManager.configure() is only async due to LangChainTracer
+    // factory being unnecessarily async.
+    let callbacks = await CallbackManager.configure();
+    if (!callbacks && runTree.tracingEnabled) {
+        callbacks = new CallbackManager();
+    }
+    let langChainTracer = callbacks?.handlers.find((handler) => handler?.name === "langchain_tracer");
+    if (!langChainTracer && runTree.tracingEnabled) {
+        langChainTracer = new LangChainTracer();
+        callbacks?.addHandler(langChainTracer);
+    }
+    const runMap = new Map();
+    // find upward root run
+    let rootRun = runTree;
+    const rootVisited = new Set();
+    while (rootRun.parent_run) {
+        if (rootVisited.has(rootRun.id))
+            break;
+        rootVisited.add(rootRun.id);
+        rootRun = rootRun.parent_run;
+    }
+    const queue = [rootRun];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || visited.has(current.id))
+            continue;
+        visited.add(current.id);
+        runMap.set(current.id, current);
+        if (current.child_runs) {
+            queue.push(...current.child_runs);
+        }
+    }
+    if (callbacks != null) {
+        Object.assign(callbacks, { _parentRunId: runTree.id });
+    }
+    if (langChainTracer != null) {
+        Object.assign(langChainTracer, {
+            runMap,
+            client: runTree.client,
+            projectName: runTree.project_name || langChainTracer.projectName,
+            exampleId: runTree.reference_example_id || langChainTracer.exampleId,
+        });
+    }
+    return callbacks;
+}
+/**
+ * RunnableTraceable is a Runnable that wraps a traceable function.
+ * This allows adding Langsmith traced functions into LangChain sequences.
+ */
+export class RunnableTraceable extends Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!isTraceableFunction(fields.func)) {
+            throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+        }
+        this.func = fields.func;
+    }
+    async invoke(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
+        return (await this.func(config, input));
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}

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/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) {
@@ -64,8 +63,7 @@ const handleRunOutputs = (rawOutputs) => {
     return { outputs: rawOutputs };
 };
 const getTracingRunTree = (runTree, inputs, getInvocationParams) => {
-    const tracingEnabled_ = tracingIsEnabled(runTree.tracingEnabled);
-    if (!tracingEnabled_) {
+    if (!(0, env_js_1.isTracingEnabled)(runTree.tracingEnabled)) {
         return undefined;
     }
     runTree.inputs = handleRunInputs(inputs);
@@ -277,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++) {
@@ -291,7 +290,7 @@ function traceable(wrappedFunc, config) {
                     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 &&
@@ -300,8 +299,8 @@ 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, config?.getInvocationParams);
                 return [currentRunTree, [currentRunTree, ...restArgs]];
@@ -452,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,41 +1,6 @@
-import { RunTree, RunTreeConfig, RunnableConfigLike } from "./run_trees.js";
+import { RunTreeConfig } from "./run_trees.js";
 import { InvocationParamsSchema } from "./schemas.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 { TraceableFunction } from "./singletons/types.js";
 /**
  * Higher-order function that takes function as input and returns a
  * "TraceableFunction" - a wrapped version of the input that
@@ -63,13 +28,5 @@ export declare function traceable<Func extends (...args: any[]) => any>(wrappedF
      */
     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";

package/dist/traceable.js

@@ -1,23 +1,34 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
-import { getEnvironmentVariable } from "./utils/env.js";
+import { isTracingEnabled } from "./env.js";
+import { ROOT, AsyncLocalStorageProviderSingleton, } from "./singletons/traceable.js";
+AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
 function isPromiseMethod(x) {
     if (x === "then" || x === "catch" || x === "finally") {
         return true;
     }
     return false;
 }
-const asyncLocalStorage = new AsyncLocalStorage();
-export const 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;
@@ -29,18 +40,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) => getEnvironmentVariable(envVar) === "true"));
-};
 const handleRunInputs = (rawInputs) => {
     const firstInput = rawInputs[0];
     if (firstInput == null) {
@@ -61,8 +60,7 @@ const handleRunOutputs = (rawOutputs) => {
     return { outputs: rawOutputs };
 };
 const getTracingRunTree = (runTree, inputs, getInvocationParams) => {
-    const tracingEnabled_ = tracingIsEnabled(runTree.tracingEnabled);
-    if (!tracingEnabled_) {
+    if (!isTracingEnabled(runTree.tracingEnabled)) {
         return undefined;
     }
     runTree.inputs = handleRunInputs(inputs);
@@ -274,6 +272,7 @@ export function traceable(wrappedFunc, config) {
                 ...runTreeConfig,
             };
         }
+        const asyncLocalStorage = AsyncLocalStorageProviderSingleton.getInstance();
         // TODO: deal with possible nested promises and async iterables
         const processedArgs = args;
         for (let i = 0; i < processedArgs.length; i++) {
@@ -288,7 +287,7 @@ export function traceable(wrappedFunc, config) {
                     restArgs,
                 ];
             }
-            // legacy CallbackManagerRunTree used in runOnDataset
+            // deprecated: legacy CallbackManagerRunTree used in runOnDataset
             // override ALS and do not pass-through the run tree
             if (isRunTree(firstArg) &&
                 "callbackManager" in firstArg &&
@@ -448,45 +447,4 @@ export function traceable(wrappedFunc, config) {
     });
     return traceableFunc;
 }
-/**
- * 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 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;
-}
-export function isTraceableFunction(x
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    return typeof x === "function" && "langsmith:traceable" in x;
-}
-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));
-}
-export function wrapFunctionAndEnsureTraceable(target, options, name = "target") {
-    if (typeof target === "function") {
-        return traceable(target, {
-            ...options,
-            name,
-        });
-    }
-    throw new Error("Target must be runnable function");
-}
+export { getCurrentRunTree, isTraceableFunction, ROOT, } from "./singletons/traceable.js";

package/langchain.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/langchain.cjs');

package/langchain.d.cts

@@ -0,0 +1 @@
+export * from './dist/langchain.js'

package/langchain.d.ts

@@ -0,0 +1 @@
+export * from './dist/langchain.js'

package/langchain.js

@@ -0,0 +1 @@
+export * from './dist/langchain.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -25,6 +25,10 @@
     "schemas.js",
     "schemas.d.ts",
     "schemas.d.cts",
+    "langchain.cjs",
+    "langchain.js",
+    "langchain.d.ts",
+    "langchain.d.cts",
     "wrappers.cjs",
     "wrappers.js",
     "wrappers.d.ts",
@@ -33,6 +37,10 @@
     "wrappers/openai.js",
     "wrappers/openai.d.ts",
     "wrappers/openai.d.cts",
+    "singletons/traceable.cjs",
+    "singletons/traceable.js",
+    "singletons/traceable.d.ts",
+    "singletons/traceable.d.cts",
     "index.cjs",
     "index.js",
     "index.d.ts",
@@ -109,11 +117,15 @@
     "typescript": "^5.4.5"
   },
   "peerDependencies": {
-    "openai": "*"
+    "openai": "*",
+    "@langchain/core": "*"
   },
   "peerDependenciesMeta": {
     "openai": {
       "optional": true
+    },
+    "@langchain/core": {
+      "optional": true
     }
   },
   "lint-staged": {
@@ -177,6 +189,15 @@
       "import": "./schemas.js",
       "require": "./schemas.cjs"
     },
+    "./langchain": {
+      "types": {
+        "import": "./langchain.d.ts",
+        "require": "./langchain.d.cts",
+        "default": "./langchain.d.ts"
+      },
+      "import": "./langchain.js",
+      "require": "./langchain.cjs"
+    },
     "./wrappers": {
       "types": {
         "import": "./wrappers.d.ts",
@@ -195,6 +216,15 @@
       "import": "./wrappers/openai.js",
       "require": "./wrappers/openai.cjs"
     },
+    "./singletons/traceable": {
+      "types": {
+        "import": "./singletons/traceable.d.ts",
+        "require": "./singletons/traceable.d.cts",
+        "default": "./singletons/traceable.d.ts"
+      },
+      "import": "./singletons/traceable.js",
+      "require": "./singletons/traceable.cjs"
+    },
     "./package.json": "./package.json"
   }
 }

package/singletons/traceable.cjs

@@ -0,0 +1 @@
+module.exports = require('../dist/singletons/traceable.cjs');

package/singletons/traceable.d.cts

@@ -0,0 +1 @@
+export * from '../dist/singletons/traceable.js'

package/singletons/traceable.d.ts

@@ -0,0 +1 @@
+export * from '../dist/singletons/traceable.js'

package/singletons/traceable.js

@@ -0,0 +1 @@
+export * from '../dist/singletons/traceable.js'