langsmith 0.1.23 → 0.1.24

package/dist/traceable.js

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from "async_hooks";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
 import { getEnvironmentVariable } from "./utils/env.js";
 function isPromiseMethod(x) {
@@ -13,6 +13,22 @@ 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 isGenerator = (x) => 
+// eslint-disable-next-line no-instanceof/no-instanceof
+x != null && typeof x === "function" && x instanceof GeneratorFunction;
+const isThenable = (x) => x != null &&
+    typeof x === "object" &&
+    "then" in x &&
+    typeof x.then === "function";
+const isReadableStream = (x) => x != null &&
+    typeof x === "object" &&
+    "getReader" in x &&
+    typeof x.getReader === "function";
 const tracingIsEnabled = (tracingEnabled) => {
     if (tracingEnabled !== undefined) {
         return tracingEnabled;
@@ -52,6 +68,141 @@ const getTracingRunTree = (runTree, inputs) => {
     runTree.inputs = handleRunInputs(inputs);
     return runTree;
 };
+// idea: store the state of the promise outside
+// but only when the promise is "consumed"
+const getSerializablePromise = (arg) => {
+    const proxyState = { current: undefined };
+    const promiseProxy = new Proxy(arg, {
+        get(target, prop, receiver) {
+            if (prop === "then") {
+                const boundThen = arg[prop].bind(arg);
+                return (resolve, reject = (x) => {
+                    throw x;
+                }) => {
+                    return boundThen((value) => {
+                        proxyState.current = ["resolve", value];
+                        return resolve(value);
+                    }, (error) => {
+                        proxyState.current = ["reject", error];
+                        return reject(error);
+                    });
+                };
+            }
+            if (prop === "catch") {
+                const boundCatch = arg[prop].bind(arg);
+                return (reject) => {
+                    return boundCatch((error) => {
+                        proxyState.current = ["reject", error];
+                        return reject(error);
+                    });
+                };
+            }
+            if (prop === "toJSON") {
+                return () => {
+                    if (!proxyState.current)
+                        return undefined;
+                    const [type, value] = proxyState.current ?? [];
+                    if (type === "resolve")
+                        return value;
+                    return { error: value };
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    return promiseProxy;
+};
+const convertSerializableArg = (arg) => {
+    if (isReadableStream(arg)) {
+        const proxyState = [];
+        const transform = new TransformStream({
+            start: () => void 0,
+            transform: (chunk, controller) => {
+                proxyState.push(chunk);
+                controller.enqueue(chunk);
+            },
+            flush: () => void 0,
+        });
+        const pipeThrough = arg.pipeThrough(transform);
+        Object.assign(pipeThrough, { toJSON: () => proxyState });
+        return pipeThrough;
+    }
+    if (isAsyncIterable(arg)) {
+        const proxyState = { current: [] };
+        return new Proxy(arg, {
+            get(target, prop, receiver) {
+                if (prop === Symbol.asyncIterator) {
+                    return () => {
+                        const boundIterator = arg[Symbol.asyncIterator].bind(arg);
+                        const iterator = boundIterator();
+                        return new Proxy(iterator, {
+                            get(target, prop, receiver) {
+                                if (prop === "next" || prop === "return" || prop === "throw") {
+                                    const bound = iterator.next.bind(iterator);
+                                    return (...args) => {
+                                        // @ts-expect-error TS cannot infer the argument types for the bound function
+                                        const wrapped = getSerializablePromise(bound(...args));
+                                        proxyState.current.push(wrapped);
+                                        return wrapped;
+                                    };
+                                }
+                                if (prop === "return" || prop === "throw") {
+                                    return iterator.next.bind(iterator);
+                                }
+                                return Reflect.get(target, prop, receiver);
+                            },
+                        });
+                    };
+                }
+                if (prop === "toJSON") {
+                    return () => {
+                        const onlyNexts = proxyState.current;
+                        const serialized = onlyNexts.map((next) => next.toJSON());
+                        const chunks = serialized.reduce((memo, next) => {
+                            if (next?.value)
+                                memo.push(next.value);
+                            return memo;
+                        }, []);
+                        return chunks;
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    if (!Array.isArray(arg) && isIteratorLike(arg)) {
+        const proxyState = [];
+        return new Proxy(arg, {
+            get(target, prop, receiver) {
+                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);
+                        return next;
+                    };
+                }
+                if (prop === "toJSON") {
+                    return () => {
+                        const chunks = proxyState.reduce((memo, next) => {
+                            if (next.value)
+                                memo.push(next.value);
+                            return memo;
+                        }, []);
+                        return chunks;
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    if (isThenable(arg)) {
+        return getSerializablePromise(arg);
+    }
+    return arg;
+};
 /**
  * Higher-order function that takes function as input and returns a
  * "TraceableFunction" - a wrapped version of the input that
@@ -115,8 +266,13 @@ export function traceable(wrappedFunc, config) {
                 ...runTreeConfig,
             };
         }
+        // TODO: deal with possible nested promises and async iterables
+        const processedArgs = args;
+        for (let i = 0; i < processedArgs.length; i++) {
+            processedArgs[i] = convertSerializableArg(processedArgs[i]);
+        }
         const [currentRunTree, rawInputs] = (() => {
-            const [firstArg, ...restArgs] = args;
+            const [firstArg, ...restArgs] = processedArgs;
             // used for handoff between LangChain.JS and traceable functions
             if (isRunnableConfigLike(firstArg)) {
                 return [
@@ -144,12 +300,12 @@ export function traceable(wrappedFunc, config) {
             const prevRunFromStore = asyncLocalStorage.getStore();
             if (prevRunFromStore) {
                 return [
-                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), args),
-                    args,
+                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs),
+                    processedArgs,
                 ];
             }
-            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), args);
-            return [currentRunTree, args];
+            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), processedArgs);
+            return [currentRunTree, processedArgs];
         })();
         return asyncLocalStorage.run(currentRunTree, () => {
             const postRunPromise = currentRunTree?.postRun();
@@ -205,6 +361,17 @@ export function traceable(wrappedFunc, config) {
                 await postRunPromise;
                 await currentRunTree?.patchRun();
             }
+            function gatherAll(iterator) {
+                const chunks = [];
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    const next = iterator.next();
+                    chunks.push(next);
+                    if (next.done)
+                        break;
+                }
+                return chunks;
+            }
             let returnValue;
             try {
                 returnValue = wrappedFunc(...rawInputs);
@@ -223,15 +390,30 @@ export function traceable(wrappedFunc, config) {
                         const snapshot = AsyncLocalStorage.snapshot();
                         return resolve(wrapAsyncGeneratorForTracing(rawOutput, snapshot));
                     }
-                    else {
-                        try {
-                            await currentRunTree?.end(handleRunOutputs(rawOutput));
-                            await handleEnd();
-                        }
-                        finally {
-                            // eslint-disable-next-line no-unsafe-finally
-                            return rawOutput;
-                        }
+                    if (isGenerator(wrappedFunc) && isIteratorLike(rawOutput)) {
+                        const chunks = gatherAll(rawOutput);
+                        await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {
+                            if (!done || typeof value !== "undefined") {
+                                memo.push(value);
+                            }
+                            return memo;
+                        }, []))));
+                        await handleEnd();
+                        return (function* () {
+                            for (const ret of chunks) {
+                                if (ret.done)
+                                    return ret.value;
+                                yield ret.value;
+                            }
+                        })();
+                    }
+                    try {
+                        await currentRunTree?.end(handleRunOutputs(rawOutput));
+                        await handleEnd();
+                    }
+                    finally {
+                        // eslint-disable-next-line no-unsafe-finally
+                        return rawOutput;
                     }
                 }, async (error) => {
                     await currentRunTree?.end(undefined, String(error));
@@ -281,11 +463,15 @@ export function isTraceableFunction(x
     return typeof x === "function" && "langsmith:traceable" in x;
 }
 function isKVMap(x) {
-    return (typeof x === "object" &&
-        x != null &&
-        !Array.isArray(x) &&
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        !(x instanceof Date));
+    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") {

package/dist/utils/shuffle.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = void 0;
+function shuffle(array) {
+    let currentIndex = array.length;
+    while (currentIndex !== 0) {
+        const randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex -= 1;
+        const tmp = array[currentIndex];
+        array[currentIndex] = array[randomIndex];
+        array[randomIndex] = tmp;
+    }
+    return array;
+}
+exports.shuffle = shuffle;

package/dist/utils/shuffle.d.ts

@@ -0,0 +1 @@
+export declare function shuffle<T extends unknown[]>(array: T): T;

package/dist/utils/shuffle.js

@@ -0,0 +1,11 @@
+export function shuffle(array) {
+    let currentIndex = array.length;
+    while (currentIndex !== 0) {
+        const randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex -= 1;
+        const tmp = array[currentIndex];
+        array[currentIndex] = array[randomIndex];
+        array[randomIndex] = tmp;
+    }
+    return array;
+}

package/package.json

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