langsmith 0.1.21 → 0.1.23-rc.0

package/dist/traceable.js

@@ -8,16 +8,48 @@ function isPromiseMethod(x) {
     return false;
 }
 const asyncLocalStorage = new AsyncLocalStorage();
+export const ROOT = Symbol("langsmith:traceable:root");
 const isAsyncIterable = (x) => x != null &&
     typeof x === "object" &&
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     typeof x[Symbol.asyncIterator] === "function";
-const getTracingRunTree = (runTree) => {
-    const tracingEnabled = getEnvironmentVariable("LANGSMITH_TRACING_V2") === "true" ||
-        getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true";
-    if (!tracingEnabled) {
+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) {
+        return {};
+    }
+    if (rawInputs.length > 1) {
+        return { args: rawInputs };
+    }
+    if (isKVMap(firstInput)) {
+        return firstInput;
+    }
+    return { input: firstInput };
+};
+const handleRunOutputs = (rawOutputs) => {
+    if (isKVMap(rawOutputs)) {
+        return rawOutputs;
+    }
+    return { outputs: rawOutputs };
+};
+const getTracingRunTree = (runTree, inputs) => {
+    const tracingEnabled_ = tracingIsEnabled(runTree.tracingEnabled);
+    if (!tracingEnabled_) {
         return undefined;
     }
+    runTree.inputs = handleRunInputs(inputs);
     return runTree;
 };
 /**
@@ -38,8 +70,6 @@ const getTracingRunTree = (runTree) => {
 export function traceable(wrappedFunc, config) {
     const { aggregator, argsConfigPath, ...runTreeConfig } = config ?? {};
     const traceableFunc = (...args) => {
-        let currentRunTree;
-        let rawInputs;
         let ensuredConfig;
         try {
             let runtimeConfig;
@@ -85,41 +115,42 @@ export function traceable(wrappedFunc, config) {
                 ...runTreeConfig,
             };
         }
-        const previousRunTree = asyncLocalStorage.getStore();
-        if (isRunTree(args[0])) {
-            currentRunTree = args[0];
-            rawInputs = args.slice(1);
-        }
-        else if (isRunnableConfigLike(args[0])) {
-            currentRunTree = RunTree.fromRunnableConfig(args[0], ensuredConfig);
-            rawInputs = args.slice(1);
-        }
-        else if (previousRunTree !== undefined) {
-            currentRunTree = previousRunTree.createChild(ensuredConfig);
-            rawInputs = args;
-        }
-        else {
-            currentRunTree = new RunTree(ensuredConfig);
-            rawInputs = args;
-        }
-        currentRunTree = getTracingRunTree(currentRunTree);
-        let inputs;
-        const firstInput = rawInputs[0];
-        if (firstInput == null) {
-            inputs = {};
-        }
-        else if (rawInputs.length > 1) {
-            inputs = { args: rawInputs };
-        }
-        else if (isKVMap(firstInput)) {
-            inputs = firstInput;
-        }
-        else {
-            inputs = { input: firstInput };
-        }
-        if (currentRunTree) {
-            currentRunTree.inputs = inputs;
-        }
+        const [currentRunTree, rawInputs] = (() => {
+            const [firstArg, ...restArgs] = args;
+            // used for handoff between LangChain.JS and traceable functions
+            if (isRunnableConfigLike(firstArg)) {
+                return [
+                    getTracingRunTree(RunTree.fromRunnableConfig(firstArg, ensuredConfig), restArgs),
+                    restArgs,
+                ];
+            }
+            // legacy CallbackManagerRunTree used in runOnDataset
+            // override ALS and do not pass-through the run tree
+            if (isRunTree(firstArg) &&
+                "callbackManager" in firstArg &&
+                firstArg.callbackManager != null) {
+                return [firstArg, restArgs];
+            }
+            // when ALS is unreliable, users can manually
+            // pass in the run tree
+            if (firstArg === ROOT || isRunTree(firstArg)) {
+                const currentRunTree = getTracingRunTree(firstArg === ROOT
+                    ? new RunTree(ensuredConfig)
+                    : firstArg.createChild(ensuredConfig), restArgs);
+                return [currentRunTree, [currentRunTree, ...restArgs]];
+            }
+            // Node.JS uses AsyncLocalStorage (ALS) and AsyncResource
+            // to allow storing context
+            const prevRunFromStore = asyncLocalStorage.getStore();
+            if (prevRunFromStore) {
+                return [
+                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), args),
+                    args,
+                ];
+            }
+            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), args);
+            return [currentRunTree, args];
+        })();
         return asyncLocalStorage.run(currentRunTree, () => {
             const postRunPromise = currentRunTree?.postRun();
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -170,6 +201,15 @@ export function traceable(wrappedFunc, config) {
                         else {
                             await currentRunTree?.end({ outputs: finalOutputs });
                         }
+                        const onEnd = config?.on_end;
+                        if (onEnd) {
+                            if (!currentRunTree) {
+                                console.warn("Can not call 'on_end' if currentRunTree is undefined");
+                            }
+                            else {
+                                onEnd(currentRunTree);
+                            }
+                        }
                         await postRunPromise;
                         await currentRunTree?.patchRun();
                     }
@@ -222,6 +262,15 @@ export function traceable(wrappedFunc, config) {
                                 else {
                                     await currentRunTree?.end({ outputs: finalOutputs });
                                 }
+                                const onEnd = config?.on_end;
+                                if (onEnd) {
+                                    if (!currentRunTree) {
+                                        console.warn("Can not call 'on_end' if currentRunTree is undefined");
+                                    }
+                                    else {
+                                        onEnd(currentRunTree);
+                                    }
+                                }
                                 await postRunPromise;
                                 await currentRunTree?.patchRun();
                             }
@@ -230,7 +279,16 @@ export function traceable(wrappedFunc, config) {
                     }
                     else {
                         try {
-                            await currentRunTree?.end(isKVMap(rawOutput) ? rawOutput : { outputs: rawOutput });
+                            await currentRunTree?.end(handleRunOutputs(rawOutput));
+                            const onEnd = config?.on_end;
+                            if (onEnd) {
+                                if (!currentRunTree) {
+                                    console.warn("Can not call 'on_end' if currentRunTree is undefined");
+                                }
+                                else {
+                                    onEnd(currentRunTree);
+                                }
+                            }
                             await postRunPromise;
                             await currentRunTree?.patchRun();
                         }
@@ -243,6 +301,15 @@ export function traceable(wrappedFunc, config) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 async (error) => {
                     await currentRunTree?.end(undefined, String(error));
+                    const onEnd = config?.on_end;
+                    if (onEnd) {
+                        if (!currentRunTree) {
+                            console.warn("Can not call 'on_end' if currentRunTree is undefined");
+                        }
+                        else {
+                            onEnd(currentRunTree);
+                        }
+                    }
                     await postRunPromise;
                     await currentRunTree?.patchRun();
                     throw error;
@@ -296,3 +363,12 @@ function isKVMap(x) {
         // eslint-disable-next-line no-instanceof/no-instanceof
         !(x instanceof Date));
 }
+export function wrapFunctionAndEnsureTraceable(target, options, name = "target") {
+    if (typeof target === "function") {
+        return traceable(target, {
+            ...options,
+            name,
+        });
+    }
+    throw new Error("Target must be runnable function");
+}

package/dist/utils/_git.cjs

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRevisionId = exports.getGitInfo = void 0;
+async function importChildProcess() {
+    const { exec } = await import("child_process");
+    return { exec };
+}
+const execGit = (command, exec) => {
+    return new Promise((resolve) => {
+        exec(`git ${command.join(" ")}`, (error, stdout) => {
+            if (error) {
+                resolve(null);
+            }
+            else {
+                resolve(stdout.trim());
+            }
+        });
+    });
+};
+const getGitInfo = async (remote = "origin") => {
+    let exec;
+    try {
+        const execImport = await importChildProcess();
+        exec = execImport.exec;
+    }
+    catch (e) {
+        // no-op
+        return null;
+    }
+    const isInsideWorkTree = await execGit(["rev-parse", "--is-inside-work-tree"], exec);
+    if (!isInsideWorkTree) {
+        return null;
+    }
+    const [remoteUrl, commit, commitTime, branch, tags, dirty, authorName, authorEmail,] = await Promise.all([
+        execGit(["remote", "get-url", remote], exec),
+        execGit(["rev-parse", "HEAD"], exec),
+        execGit(["log", "-1", "--format=%ct"], exec),
+        execGit(["rev-parse", "--abbrev-ref", "HEAD"], exec),
+        execGit(["describe", "--tags", "--exact-match", "--always", "--dirty"], exec),
+        execGit(["status", "--porcelain"], exec).then((output) => output !== ""),
+        execGit(["log", "-1", "--format=%an"], exec),
+        execGit(["log", "-1", "--format=%ae"], exec),
+    ]);
+    return {
+        remoteUrl,
+        commit,
+        commitTime,
+        branch,
+        tags,
+        dirty,
+        authorName,
+        authorEmail,
+    };
+};
+exports.getGitInfo = getGitInfo;
+const getDefaultRevisionId = async () => {
+    let exec;
+    try {
+        const execImport = await importChildProcess();
+        exec = execImport.exec;
+    }
+    catch (e) {
+        // no-op
+        return null;
+    }
+    const commit = await execGit(["rev-parse", "HEAD"], exec);
+    if (!commit) {
+        return null;
+    }
+    return commit;
+};
+exports.getDefaultRevisionId = getDefaultRevisionId;

package/dist/utils/_git.d.ts

@@ -0,0 +1,14 @@
+interface GitInfo {
+    remoteUrl?: string | null;
+    commit?: string | null;
+    branch?: string | null;
+    authorName?: string | null;
+    authorEmail?: string | null;
+    commitMessage?: string | null;
+    commitTime?: string | null;
+    dirty?: boolean | null;
+    tags?: string | null;
+}
+export declare const getGitInfo: (remote?: string) => Promise<GitInfo | null>;
+export declare const getDefaultRevisionId: () => Promise<string | null>;
+export {};

package/dist/utils/_git.js

@@ -0,0 +1,67 @@
+async function importChildProcess() {
+    const { exec } = await import("child_process");
+    return { exec };
+}
+const execGit = (command, exec) => {
+    return new Promise((resolve) => {
+        exec(`git ${command.join(" ")}`, (error, stdout) => {
+            if (error) {
+                resolve(null);
+            }
+            else {
+                resolve(stdout.trim());
+            }
+        });
+    });
+};
+export const getGitInfo = async (remote = "origin") => {
+    let exec;
+    try {
+        const execImport = await importChildProcess();
+        exec = execImport.exec;
+    }
+    catch (e) {
+        // no-op
+        return null;
+    }
+    const isInsideWorkTree = await execGit(["rev-parse", "--is-inside-work-tree"], exec);
+    if (!isInsideWorkTree) {
+        return null;
+    }
+    const [remoteUrl, commit, commitTime, branch, tags, dirty, authorName, authorEmail,] = await Promise.all([
+        execGit(["remote", "get-url", remote], exec),
+        execGit(["rev-parse", "HEAD"], exec),
+        execGit(["log", "-1", "--format=%ct"], exec),
+        execGit(["rev-parse", "--abbrev-ref", "HEAD"], exec),
+        execGit(["describe", "--tags", "--exact-match", "--always", "--dirty"], exec),
+        execGit(["status", "--porcelain"], exec).then((output) => output !== ""),
+        execGit(["log", "-1", "--format=%an"], exec),
+        execGit(["log", "-1", "--format=%ae"], exec),
+    ]);
+    return {
+        remoteUrl,
+        commit,
+        commitTime,
+        branch,
+        tags,
+        dirty,
+        authorName,
+        authorEmail,
+    };
+};
+export const getDefaultRevisionId = async () => {
+    let exec;
+    try {
+        const execImport = await importChildProcess();
+        exec = execImport.exec;
+    }
+    catch (e) {
+        // no-op
+        return null;
+    }
+    const commit = await execGit(["rev-parse", "HEAD"], exec);
+    if (!commit) {
+        return null;
+    }
+    return commit;
+};

package/dist/utils/_uuid.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertUuid = void 0;
+const uuid = __importStar(require("uuid"));
+function assertUuid(str) {
+    if (!uuid.validate(str)) {
+        throw new Error(`Invalid UUID: ${str}`);
+    }
+}
+exports.assertUuid = assertUuid;

package/dist/utils/_uuid.d.ts

@@ -0,0 +1 @@
+export declare function assertUuid(str: string): void;

package/dist/utils/_uuid.js

@@ -0,0 +1,6 @@
+import * as uuid from "uuid";
+export function assertUuid(str) {
+    if (!uuid.validate(str)) {
+        throw new Error(`Invalid UUID: ${str}`);
+    }
+}

package/dist/utils/atee.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atee = void 0;
+function atee(iter, length = 2) {
+    const buffers = Array.from({ length }, () => []);
+    return buffers.map(async function* makeIter(buffer) {
+        while (true) {
+            if (buffer.length === 0) {
+                const result = await iter.next();
+                for (const buffer of buffers) {
+                    buffer.push(result);
+                }
+            }
+            else if (buffer[0].done) {
+                return;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                yield buffer.shift().value;
+            }
+        }
+    });
+}
+exports.atee = atee;

package/dist/utils/atee.d.ts

@@ -0,0 +1 @@
+export declare function atee<T>(iter: AsyncGenerator<T>, length?: number): AsyncGenerator<T>[];

package/dist/utils/atee.js

@@ -0,0 +1,20 @@
+export function atee(iter, length = 2) {
+    const buffers = Array.from({ length }, () => []);
+    return buffers.map(async function* makeIter(buffer) {
+        while (true) {
+            if (buffer.length === 0) {
+                const result = await iter.next();
+                for (const buffer of buffers) {
+                    buffer.push(result);
+                }
+            }
+            else if (buffer[0].done) {
+                return;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                yield buffer.shift().value;
+            }
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.21",
+  "version": "0.1.23-rc.0",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -52,6 +52,7 @@
     "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --passWithNoTests --testPathIgnorePatterns='\\.int\\.test.[tj]s' --testTimeout 30000",
     "test:integration": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000",
     "test:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
+    "watch:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --watch --config jest.config.cjs --testTimeout 100000",
     "lint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
     "lint:fix": "yarn lint --fix",
     "format": "prettier --write 'src/**/*.{ts,tsx}'",