langsmith 0.1.20 → 0.1.22

package/dist/traceable.js

@@ -1,15 +1,32 @@
 import { AsyncLocalStorage } from "async_hooks";
 import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
 import { getEnvironmentVariable } from "./utils/env.js";
+function isPromiseMethod(x) {
+    if (x === "then" || x === "catch" || x === "finally") {
+        return true;
+    }
+    return false;
+}
 const asyncLocalStorage = new AsyncLocalStorage();
 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 getTracingRunTree = (runTree, tracingEnabled) => {
+    const tracingEnabled_ = tracingIsEnabled(tracingEnabled);
+    if (!tracingEnabled_) {
         return undefined;
     }
     return runTree;
@@ -30,14 +47,55 @@ const getTracingRunTree = (runTree) => {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function traceable(wrappedFunc, config) {
-    const { aggregator, ...runTreeConfig } = config ?? {};
-    const traceableFunc = async (...args) => {
+    const { aggregator, argsConfigPath, tracingEnabled, ...runTreeConfig } = config ?? {};
+    const traceableFunc = (...args) => {
         let currentRunTree;
         let rawInputs;
-        const ensuredConfig = {
-            name: wrappedFunc.name || "<lambda>",
-            ...runTreeConfig,
-        };
+        let ensuredConfig;
+        try {
+            let runtimeConfig;
+            if (argsConfigPath) {
+                const [index, path] = argsConfigPath;
+                if (index === args.length - 1 && !path) {
+                    runtimeConfig = args.pop();
+                }
+                else if (index <= args.length &&
+                    typeof args[index] === "object" &&
+                    args[index] !== null) {
+                    if (path) {
+                        const { [path]: extracted, ...rest } = args[index];
+                        runtimeConfig = extracted;
+                        args[index] = rest;
+                    }
+                    else {
+                        runtimeConfig = args[index];
+                        args.splice(index, 1);
+                    }
+                }
+            }
+            ensuredConfig = {
+                name: wrappedFunc.name || "<lambda>",
+                ...runTreeConfig,
+                ...runtimeConfig,
+                tags: [
+                    ...new Set([
+                        ...(runTreeConfig?.tags ?? []),
+                        ...(runtimeConfig?.tags ?? []),
+                    ]),
+                ],
+                metadata: {
+                    ...runTreeConfig?.metadata,
+                    ...runtimeConfig?.metadata,
+                },
+            };
+        }
+        catch (err) {
+            console.warn(`Failed to extract runtime config from args for ${runTreeConfig?.name ?? wrappedFunc.name}`, err);
+            ensuredConfig = {
+                name: wrappedFunc.name || "<lambda>",
+                ...runTreeConfig,
+            };
+        }
         const previousRunTree = asyncLocalStorage.getStore();
         if (isRunTree(args[0])) {
             currentRunTree = args[0];
@@ -48,14 +106,14 @@ export function traceable(wrappedFunc, config) {
             rawInputs = args.slice(1);
         }
         else if (previousRunTree !== undefined) {
-            currentRunTree = await previousRunTree.createChild(ensuredConfig);
+            currentRunTree = previousRunTree.createChild(ensuredConfig);
             rawInputs = args;
         }
         else {
             currentRunTree = new RunTree(ensuredConfig);
             rawInputs = args;
         }
-        currentRunTree = getTracingRunTree(currentRunTree);
+        currentRunTree = getTracingRunTree(currentRunTree, tracingEnabled);
         let inputs;
         const firstInput = rawInputs[0];
         if (firstInput == null) {
@@ -73,74 +131,181 @@ export function traceable(wrappedFunc, config) {
         if (currentRunTree) {
             currentRunTree.inputs = inputs;
         }
-        const initialOutputs = currentRunTree?.outputs;
-        const initialError = currentRunTree?.error;
-        await currentRunTree?.postRun();
-        return new Promise((resolve, reject) => {
-            void asyncLocalStorage.run(currentRunTree, async () => {
-                try {
-                    const rawOutput = await wrappedFunc(...rawInputs);
+        return asyncLocalStorage.run(currentRunTree, () => {
+            const postRunPromise = currentRunTree?.postRun();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let returnValue;
+            try {
+                returnValue = wrappedFunc(...rawInputs);
+            }
+            catch (err) {
+                returnValue = Promise.reject(err);
+            }
+            if (isAsyncIterable(returnValue)) {
+                // eslint-disable-next-line no-inner-declarations
+                async function* wrapOutputForTracing() {
+                    let finished = false;
+                    const chunks = [];
+                    try {
+                        for await (const chunk of returnValue) {
+                            chunks.push(chunk);
+                            yield chunk;
+                        }
+                        finished = true;
+                    }
+                    catch (e) {
+                        await currentRunTree?.end(undefined, String(e));
+                        throw e;
+                    }
+                    finally {
+                        if (!finished) {
+                            await currentRunTree?.end(undefined, "Cancelled");
+                        }
+                        let finalOutputs;
+                        if (aggregator !== undefined) {
+                            try {
+                                finalOutputs = await aggregator(chunks);
+                            }
+                            catch (e) {
+                                console.error(`[ERROR]: LangSmith aggregation failed: `, e);
+                                finalOutputs = chunks;
+                            }
+                        }
+                        else {
+                            finalOutputs = chunks;
+                        }
+                        if (typeof finalOutputs === "object" &&
+                            !Array.isArray(finalOutputs)) {
+                            await currentRunTree?.end(finalOutputs);
+                        }
+                        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();
+                    }
+                }
+                return wrapOutputForTracing();
+            }
+            const tracedPromise = new Promise((resolve, reject) => {
+                Promise.resolve(returnValue)
+                    .then(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (rawOutput) => {
                     if (isAsyncIterable(rawOutput)) {
                         // eslint-disable-next-line no-inner-declarations
                         async function* wrapOutputForTracing() {
+                            let finished = false;
                             const chunks = [];
-                            // TypeScript thinks this is unsafe
-                            for await (const chunk of rawOutput) {
-                                chunks.push(chunk);
-                                yield chunk;
+                            try {
+                                // TypeScript thinks this is unsafe
+                                for await (const chunk of rawOutput) {
+                                    chunks.push(chunk);
+                                    yield chunk;
+                                }
+                                finished = true;
+                            }
+                            catch (e) {
+                                await currentRunTree?.end(undefined, String(e));
+                                throw e;
                             }
-                            let finalOutputs;
-                            if (aggregator !== undefined) {
-                                try {
-                                    finalOutputs = await aggregator(chunks);
+                            finally {
+                                if (!finished) {
+                                    await currentRunTree?.end(undefined, "Cancelled");
                                 }
-                                catch (e) {
-                                    console.error(`[ERROR]: LangSmith aggregation failed: `, e);
+                                let finalOutputs;
+                                if (aggregator !== undefined) {
+                                    try {
+                                        finalOutputs = await aggregator(chunks);
+                                    }
+                                    catch (e) {
+                                        console.error(`[ERROR]: LangSmith aggregation failed: `, e);
+                                        finalOutputs = chunks;
+                                    }
+                                }
+                                else {
                                     finalOutputs = chunks;
                                 }
+                                if (typeof finalOutputs === "object" &&
+                                    !Array.isArray(finalOutputs)) {
+                                    await currentRunTree?.end(finalOutputs);
+                                }
+                                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();
                             }
-                            else {
-                                finalOutputs = chunks;
-                            }
-                            if (typeof finalOutputs === "object" &&
-                                !Array.isArray(finalOutputs)) {
-                                await currentRunTree?.end(finalOutputs);
-                            }
-                            else {
-                                await currentRunTree?.end({ outputs: finalOutputs });
-                            }
-                            await currentRunTree?.patchRun();
                         }
                         return resolve(wrapOutputForTracing());
                     }
                     else {
-                        const outputs = isKVMap(rawOutput)
-                            ? rawOutput
-                            : { outputs: rawOutput };
-                        if (initialOutputs === currentRunTree?.outputs) {
-                            await currentRunTree?.end(outputs);
-                        }
-                        else {
-                            if (currentRunTree !== undefined) {
-                                currentRunTree.end_time = Date.now();
+                        try {
+                            await currentRunTree?.end(isKVMap(rawOutput) ? rawOutput : { outputs: 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();
+                        }
+                        finally {
+                            // eslint-disable-next-line no-unsafe-finally
+                            return rawOutput;
                         }
-                        await currentRunTree?.patchRun();
-                        return resolve(rawOutput);
-                    }
-                }
-                catch (error) {
-                    if (initialError === currentRunTree?.error) {
-                        await currentRunTree?.end(initialOutputs, String(error));
                     }
-                    else {
-                        if (currentRunTree !== undefined) {
-                            currentRunTree.end_time = Date.now();
+                }, 
+                // 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();
-                    reject(error);
-                }
+                    throw error;
+                })
+                    .then(resolve, reject);
+            });
+            if (typeof returnValue !== "object" || returnValue === null) {
+                return tracedPromise;
+            }
+            return new Proxy(returnValue, {
+                get(target, prop, receiver) {
+                    if (isPromiseMethod(prop)) {
+                        return tracedPromise[prop].bind(tracedPromise);
+                    }
+                    return Reflect.get(target, prop, receiver);
+                },
             });
         });
     };
@@ -178,3 +343,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/async_caller.cjs

@@ -7,13 +7,13 @@ exports.AsyncCaller = void 0;
 const p_retry_1 = __importDefault(require("p-retry"));
 const p_queue_1 = __importDefault(require("p-queue"));
 const STATUS_NO_RETRY = [
-    400,
-    401,
-    403,
-    404,
-    405,
-    406,
-    407,
+    400, // Bad Request
+    401, // Unauthorized
+    403, // Forbidden
+    404, // Not Found
+    405, // Method Not Allowed
+    406, // Not Acceptable
+    407, // Proxy Authentication Required
     408, // Request Timeout
 ];
 const STATUS_IGNORE = [
@@ -60,8 +60,16 @@ class AsyncCaller {
         });
         this.maxConcurrency = params.maxConcurrency ?? Infinity;
         this.maxRetries = params.maxRetries ?? 6;
-        const PQueue = "default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default;
-        this.queue = new PQueue({ concurrency: this.maxConcurrency });
+        if ("default" in p_queue_1.default) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new p_queue_1.default.default({
+                concurrency: this.maxConcurrency,
+            });
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new p_queue_1.default({ concurrency: this.maxConcurrency });
+        }
         this.onFailedResponseHook = params?.onFailedResponseHook;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/utils/async_caller.js

@@ -1,13 +1,13 @@
 import pRetry from "p-retry";
 import PQueueMod from "p-queue";
 const STATUS_NO_RETRY = [
-    400,
-    401,
-    403,
-    404,
-    405,
-    406,
-    407,
+    400, // Bad Request
+    401, // Unauthorized
+    403, // Forbidden
+    404, // Not Found
+    405, // Method Not Allowed
+    406, // Not Acceptable
+    407, // Proxy Authentication Required
     408, // Request Timeout
 ];
 const STATUS_IGNORE = [
@@ -54,8 +54,16 @@ export class AsyncCaller {
         });
         this.maxConcurrency = params.maxConcurrency ?? Infinity;
         this.maxRetries = params.maxRetries ?? 6;
-        const PQueue = "default" in PQueueMod ? PQueueMod.default : PQueueMod;
-        this.queue = new PQueue({ concurrency: this.maxConcurrency });
+        if ("default" in PQueueMod) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new PQueueMod.default({
+                concurrency: this.maxConcurrency,
+            });
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.queue = new PQueueMod({ concurrency: this.maxConcurrency });
+        }
         this.onFailedResponseHook = params?.onFailedResponseHook;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

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>[];