langsmith 0.1.38 → 0.1.39

package/dist/client.cjs

@@ -933,6 +933,43 @@ class Client {
             }
         }
     }
+    async getRunStats({ id, trace, parentRun, runType, projectNames, projectIds, referenceExampleIds, startTime, endTime, error, query, filter, traceFilter, treeFilter, isRoot, dataSourceType, }) {
+        let projectIds_ = projectIds || [];
+        if (projectNames) {
+            projectIds_ = [
+                ...(projectIds || []),
+                ...(await Promise.all(projectNames.map((name) => this.readProject({ projectName: name }).then((project) => project.id)))),
+            ];
+        }
+        const payload = {
+            id,
+            trace,
+            parent_run: parentRun,
+            run_type: runType,
+            session: projectIds_,
+            reference_example: referenceExampleIds,
+            start_time: startTime,
+            end_time: endTime,
+            error,
+            query,
+            filter,
+            trace_filter: traceFilter,
+            tree_filter: treeFilter,
+            is_root: isRoot,
+            data_source_type: dataSourceType,
+        };
+        // Remove undefined values from the payload
+        const filteredPayload = Object.fromEntries(Object.entries(payload).filter(([_, value]) => value !== undefined));
+        const response = await this.caller.call(fetch, `${this.apiUrl}/runs/stats`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(filteredPayload),
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        const result = await response.json();
+        return result;
+    }
     async shareRun(runId, { shareId } = {}) {
         const data = {
             run_id: runId,

package/dist/client.d.ts

@@ -300,6 +300,24 @@ export declare class Client {
      * });
      */
     listRuns(props: ListRunsParams): AsyncIterable<Run>;
+    getRunStats({ id, trace, parentRun, runType, projectNames, projectIds, referenceExampleIds, startTime, endTime, error, query, filter, traceFilter, treeFilter, isRoot, dataSourceType, }: {
+        id?: string[];
+        trace?: string;
+        parentRun?: string;
+        runType?: string;
+        projectNames?: string[];
+        projectIds?: string[];
+        referenceExampleIds?: string[];
+        startTime?: string;
+        endTime?: string;
+        error?: boolean;
+        query?: string;
+        filter?: string;
+        traceFilter?: string;
+        treeFilter?: string;
+        isRoot?: boolean;
+        dataSourceType?: string;
+    }): Promise<any>;
     shareRun(runId: string, { shareId }?: {
         shareId?: string;
     }): Promise<string>;

package/dist/client.js

@@ -906,6 +906,43 @@ export class Client {
             }
         }
     }
+    async getRunStats({ id, trace, parentRun, runType, projectNames, projectIds, referenceExampleIds, startTime, endTime, error, query, filter, traceFilter, treeFilter, isRoot, dataSourceType, }) {
+        let projectIds_ = projectIds || [];
+        if (projectNames) {
+            projectIds_ = [
+                ...(projectIds || []),
+                ...(await Promise.all(projectNames.map((name) => this.readProject({ projectName: name }).then((project) => project.id)))),
+            ];
+        }
+        const payload = {
+            id,
+            trace,
+            parent_run: parentRun,
+            run_type: runType,
+            session: projectIds_,
+            reference_example: referenceExampleIds,
+            start_time: startTime,
+            end_time: endTime,
+            error,
+            query,
+            filter,
+            trace_filter: traceFilter,
+            tree_filter: treeFilter,
+            is_root: isRoot,
+            data_source_type: dataSourceType,
+        };
+        // Remove undefined values from the payload
+        const filteredPayload = Object.fromEntries(Object.entries(payload).filter(([_, value]) => value !== undefined));
+        const response = await this.caller.call(fetch, `${this.apiUrl}/runs/stats`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(filteredPayload),
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        const result = await response.json();
+        return result;
+    }
     async shareRun(runId, { shareId } = {}) {
         const data = {
             run_id: runId,

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.38";
+exports.__version__ = "0.1.39";

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.38";
+export declare const __version__ = "0.1.39";

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.38";
+export const __version__ = "0.1.39";

package/dist/langchain.cjs

@@ -55,12 +55,20 @@ async function getLangchainCallbacks(currentRunTree) {
         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,
-        });
+        if ("updateFromRunTree" in langChainTracer &&
+            typeof langChainTracer === "function") {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore @langchain/core can use a different version of LangSmith
+            langChainTracer.updateFromRunTree(runTree);
+        }
+        else {
+            Object.assign(langChainTracer, {
+                runMap,
+                client: runTree.client,
+                projectName: runTree.project_name || langChainTracer.projectName,
+                exampleId: runTree.reference_example_id || langChainTracer.exampleId,
+            });
+        }
     }
     return callbacks;
 }

package/dist/langchain.js

@@ -52,12 +52,20 @@ export async function getLangchainCallbacks(currentRunTree) {
         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,
-        });
+        if ("updateFromRunTree" in langChainTracer &&
+            typeof langChainTracer === "function") {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore @langchain/core can use a different version of LangSmith
+            langChainTracer.updateFromRunTree(runTree);
+        }
+        else {
+            Object.assign(langChainTracer, {
+                runMap,
+                client: runTree.client,
+                projectName: runTree.project_name || langChainTracer.projectName,
+                exampleId: runTree.reference_example_id || langChainTracer.exampleId,
+            });
+        }
     }
     return callbacks;
 }

package/dist/run_trees.cjs

@@ -278,6 +278,26 @@ class RunTree {
             execution_order: child_execution_order,
             child_execution_order: child_execution_order,
         });
+        const LC_CHILD = Symbol.for("lc:child_config");
+        const presentConfig = config.extra?.[LC_CHILD] ??
+            this.extra[LC_CHILD];
+        // tracing for LangChain is defined by the _parentRunId and runMap of the tracer
+        if (isRunnableConfigLike(presentConfig)) {
+            const newConfig = { ...presentConfig };
+            const callbacks = isCallbackManagerLike(newConfig.callbacks)
+                ? newConfig.callbacks.copy?.()
+                : undefined;
+            if (callbacks) {
+                // update the parent run id
+                Object.assign(callbacks, { _parentRunId: child.id });
+                // only populate if we're in a newer LC.JS version
+                callbacks.handlers
+                    ?.find(isLangChainTracerLike)
+                    ?.updateFromRunTree?.(child);
+                newConfig.callbacks = callbacks;
+            }
+            child.extra[LC_CHILD] = newConfig;
+        }
         // propagate child_execution_order upwards
         const visited = new Set();
         let current = this;
@@ -463,12 +483,19 @@ function isRunTree(x) {
         typeof x.postRun === "function");
 }
 exports.isRunTree = isRunTree;
+function isLangChainTracerLike(x) {
+    return (typeof x === "object" &&
+        x != null &&
+        typeof x.name === "string" &&
+        x.name === "langchain_tracer");
+}
 function containsLangChainTracerLike(x) {
-    return (Array.isArray(x) &&
-        x.some((callback) => {
-            return (typeof callback.name === "string" &&
-                callback.name === "langchain_tracer");
-        }));
+    return (Array.isArray(x) && x.some((callback) => isLangChainTracerLike(callback)));
+}
+function isCallbackManagerLike(x) {
+    return (typeof x === "object" &&
+        x != null &&
+        Array.isArray(x.handlers));
 }
 function isRunnableConfigLike(x) {
     // Check that it's an object with a callbacks arg

package/dist/run_trees.js

@@ -251,6 +251,26 @@ export class RunTree {
             execution_order: child_execution_order,
             child_execution_order: child_execution_order,
         });
+        const LC_CHILD = Symbol.for("lc:child_config");
+        const presentConfig = config.extra?.[LC_CHILD] ??
+            this.extra[LC_CHILD];
+        // tracing for LangChain is defined by the _parentRunId and runMap of the tracer
+        if (isRunnableConfigLike(presentConfig)) {
+            const newConfig = { ...presentConfig };
+            const callbacks = isCallbackManagerLike(newConfig.callbacks)
+                ? newConfig.callbacks.copy?.()
+                : undefined;
+            if (callbacks) {
+                // update the parent run id
+                Object.assign(callbacks, { _parentRunId: child.id });
+                // only populate if we're in a newer LC.JS version
+                callbacks.handlers
+                    ?.find(isLangChainTracerLike)
+                    ?.updateFromRunTree?.(child);
+                newConfig.callbacks = callbacks;
+            }
+            child.extra[LC_CHILD] = newConfig;
+        }
         // propagate child_execution_order upwards
         const visited = new Set();
         let current = this;
@@ -434,12 +454,19 @@ export function isRunTree(x) {
         typeof x.createChild === "function" &&
         typeof x.postRun === "function");
 }
+function isLangChainTracerLike(x) {
+    return (typeof x === "object" &&
+        x != null &&
+        typeof x.name === "string" &&
+        x.name === "langchain_tracer");
+}
 function containsLangChainTracerLike(x) {
-    return (Array.isArray(x) &&
-        x.some((callback) => {
-            return (typeof callback.name === "string" &&
-                callback.name === "langchain_tracer");
-        }));
+    return (Array.isArray(x) && x.some((callback) => isLangChainTracerLike(callback)));
+}
+function isCallbackManagerLike(x) {
+    return (typeof x === "object" &&
+        x != null &&
+        Array.isArray(x.handlers));
 }
 export function isRunnableConfigLike(x) {
     // Check that it's an object with a callbacks arg

package/dist/singletons/traceable.cjs

@@ -9,28 +9,18 @@ class MockAsyncLocalStorage {
         return callback();
     }
 }
+const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+const mockAsyncLocalStorage = new MockAsyncLocalStorage();
 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;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return globalThis[TRACING_ALS_KEY] ?? mockAsyncLocalStorage;
     }
     initializeGlobalInstance(instance) {
-        if (!this.hasBeenInitialized) {
-            this.hasBeenInitialized = true;
-            this.asyncLocalStorage = instance;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (globalThis[TRACING_ALS_KEY] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis[TRACING_ALS_KEY] = instance;
         }
     }
 }

package/dist/singletons/traceable.d.ts

@@ -5,8 +5,6 @@ interface AsyncLocalStorageInterface {
     run: (context: RunTree | undefined, fn: () => void) => void;
 }
 declare class AsyncLocalStorageProvider {
-    private asyncLocalStorage;
-    private hasBeenInitialized;
     getInstance(): AsyncLocalStorageInterface;
     initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
 }

package/dist/singletons/traceable.js

@@ -6,28 +6,18 @@ class MockAsyncLocalStorage {
         return callback();
     }
 }
+const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+const mockAsyncLocalStorage = new MockAsyncLocalStorage();
 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;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return globalThis[TRACING_ALS_KEY] ?? mockAsyncLocalStorage;
     }
     initializeGlobalInstance(instance) {
-        if (!this.hasBeenInitialized) {
-            this.hasBeenInitialized = true;
-            this.asyncLocalStorage = instance;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (globalThis[TRACING_ALS_KEY] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            globalThis[TRACING_ALS_KEY] = instance;
         }
     }
 }

package/dist/singletons/types.d.ts

@@ -13,7 +13,7 @@ type WrapArgReturnPair<Pair> = Pair extends [
     (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 {
+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;
@@ -33,6 +33,8 @@ export type TraceableFunction<Func extends (...args: any[]) => any> = Func exten
     (...args: infer A2): infer R2;
 } ? UnionToIntersection<WrapArgReturnPair<[A1, R1] | [A2, R2]>> : Func extends {
     (...args: infer A1): infer R1;
-} ? UnionToIntersection<WrapArgReturnPair<[A1, R1]>> : never;
+} ? UnionToIntersection<WrapArgReturnPair<[A1, R1]>> : never) & {
+    [K in keyof Func]: Func[K];
+};
 export type RunTreeLike = RunTree;
 export {};

package/dist/traceable.cjs

@@ -294,11 +294,10 @@ function traceable(wrappedFunc, config) {
                 }
                 return chunks;
             }
-            async function* wrapAsyncGeneratorForTracing(iterable, snapshot) {
+            async function* wrapAsyncIteratorForTracing(iterator, snapshot) {
                 let finished = false;
                 const chunks = [];
                 try {
-                    const iterator = iterable[Symbol.asyncIterator]();
                     while (true) {
                         const { value, done } = await (snapshot
                             ? snapshot(() => iterator.next())
@@ -322,6 +321,12 @@ function traceable(wrappedFunc, config) {
                     await handleEnd();
                 }
             }
+            function wrapAsyncGeneratorForTracing(iterable, snapshot) {
+                const iterator = iterable[Symbol.asyncIterator]();
+                const wrappedIterator = wrapAsyncIteratorForTracing(iterator, snapshot);
+                iterable[Symbol.asyncIterator] = () => wrappedIterator;
+                return iterable;
+            }
             async function handleEnd() {
                 const onEnd = config?.on_end;
                 if (onEnd) {

package/dist/traceable.js

@@ -291,11 +291,10 @@ export function traceable(wrappedFunc, config) {
                 }
                 return chunks;
             }
-            async function* wrapAsyncGeneratorForTracing(iterable, snapshot) {
+            async function* wrapAsyncIteratorForTracing(iterator, snapshot) {
                 let finished = false;
                 const chunks = [];
                 try {
-                    const iterator = iterable[Symbol.asyncIterator]();
                     while (true) {
                         const { value, done } = await (snapshot
                             ? snapshot(() => iterator.next())
@@ -319,6 +318,12 @@ export function traceable(wrappedFunc, config) {
                     await handleEnd();
                 }
             }
+            function wrapAsyncGeneratorForTracing(iterable, snapshot) {
+                const iterator = iterable[Symbol.asyncIterator]();
+                const wrappedIterator = wrapAsyncIteratorForTracing(iterator, snapshot);
+                iterable[Symbol.asyncIterator] = () => wrappedIterator;
+                return iterable;
+            }
             async function handleEnd() {
                 const onEnd = config?.on_end;
                 if (onEnd) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [