langsmith 0.1.25 → 0.1.27

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) {
@@ -60,12 +59,19 @@ const handleRunOutputs = (rawOutputs) => {
     }
     return { outputs: rawOutputs };
 };
-const getTracingRunTree = (runTree, inputs) => {
-    const tracingEnabled_ = tracingIsEnabled(runTree.tracingEnabled);
-    if (!tracingEnabled_) {
+const getTracingRunTree = (runTree, inputs, getInvocationParams) => {
+    if (!isTracingEnabled(runTree.tracingEnabled)) {
         return undefined;
     }
     runTree.inputs = handleRunInputs(inputs);
+    const invocationParams = getInvocationParams?.(...inputs);
+    if (invocationParams != null) {
+        runTree.extra ??= {};
+        runTree.extra.metadata = {
+            ...runTree.extra.metadata,
+            ...invocationParams,
+        };
+    }
     return runTree;
 };
 // idea: store the state of the promise outside
@@ -266,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++) {
@@ -276,11 +283,11 @@ export function traceable(wrappedFunc, config) {
             // used for handoff between LangChain.JS and traceable functions
             if (isRunnableConfigLike(firstArg)) {
                 return [
-                    getTracingRunTree(RunTree.fromRunnableConfig(firstArg, ensuredConfig), restArgs),
+                    getTracingRunTree(RunTree.fromRunnableConfig(firstArg, ensuredConfig), restArgs, config?.getInvocationParams),
                     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 &&
@@ -292,7 +299,7 @@ export function traceable(wrappedFunc, config) {
             if (firstArg === ROOT || isRunTree(firstArg)) {
                 const currentRunTree = getTracingRunTree(firstArg === ROOT
                     ? new RunTree(ensuredConfig)
-                    : firstArg.createChild(ensuredConfig), restArgs);
+                    : firstArg.createChild(ensuredConfig), restArgs, config?.getInvocationParams);
                 return [currentRunTree, [currentRunTree, ...restArgs]];
             }
             // Node.JS uses AsyncLocalStorage (ALS) and AsyncResource
@@ -300,11 +307,11 @@ export function traceable(wrappedFunc, config) {
             const prevRunFromStore = asyncLocalStorage.getStore();
             if (prevRunFromStore) {
                 return [
-                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs),
+                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams),
                     processedArgs,
                 ];
             }
-            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), processedArgs);
+            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), processedArgs, config?.getInvocationParams);
             return [currentRunTree, processedArgs];
         })();
         return asyncLocalStorage.run(currentRunTree, () => {
@@ -440,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/dist/utils/error.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printErrorStackTrace = void 0;
+function getErrorStackTrace(e) {
+    if (typeof e !== "object" || e == null)
+        return undefined;
+    if (!("stack" in e) || typeof e.stack !== "string")
+        return undefined;
+    let stack = e.stack;
+    const prevLine = `${e}`;
+    if (stack.startsWith(prevLine)) {
+        stack = stack.slice(prevLine.length);
+    }
+    if (stack.startsWith("\n")) {
+        stack = stack.slice(1);
+    }
+    return stack;
+}
+function printErrorStackTrace(e) {
+    const stack = getErrorStackTrace(e);
+    if (stack == null)
+        return;
+    console.error(stack);
+}
+exports.printErrorStackTrace = printErrorStackTrace;

package/dist/utils/error.d.ts

@@ -0,0 +1 @@
+export declare function printErrorStackTrace(e: unknown): void;

package/dist/utils/error.js

@@ -0,0 +1,21 @@
+function getErrorStackTrace(e) {
+    if (typeof e !== "object" || e == null)
+        return undefined;
+    if (!("stack" in e) || typeof e.stack !== "string")
+        return undefined;
+    let stack = e.stack;
+    const prevLine = `${e}`;
+    if (stack.startsWith(prevLine)) {
+        stack = stack.slice(prevLine.length);
+    }
+    if (stack.startsWith("\n")) {
+        stack = stack.slice(1);
+    }
+    return stack;
+}
+export function printErrorStackTrace(e) {
+    const stack = getErrorStackTrace(e);
+    if (stack == null)
+        return;
+    console.error(stack);
+}

package/dist/wrappers/openai.cjs

@@ -147,6 +147,22 @@ const wrapOpenAI = (openai, options) => {
         run_type: "llm",
         aggregator: chatAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: (payload) => {
+            if (typeof payload !== "object" || payload == null)
+                return undefined;
+            // we can safely do so, as the types are not exported in TSC
+            const params = payload;
+            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                undefined;
+            return {
+                ls_provider: "openai",
+                ls_model_type: "chat",
+                ls_model_name: params.model,
+                ls_max_tokens: params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+            };
+        },
         ...options,
     });
     openai.completions.create = (0, traceable_js_1.traceable)(openai.completions.create.bind(openai.completions), {
@@ -154,6 +170,22 @@ const wrapOpenAI = (openai, options) => {
         run_type: "llm",
         aggregator: textAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: (payload) => {
+            if (typeof payload !== "object" || payload == null)
+                return undefined;
+            // we can safely do so, as the types are not exported in TSC
+            const params = payload;
+            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                undefined;
+            return {
+                ls_provider: "openai",
+                ls_model_type: "chat",
+                ls_model_name: params.model,
+                ls_max_tokens: params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+            };
+        },
         ...options,
     });
     return openai;

package/dist/wrappers/openai.js

@@ -144,6 +144,22 @@ export const wrapOpenAI = (openai, options) => {
         run_type: "llm",
         aggregator: chatAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: (payload) => {
+            if (typeof payload !== "object" || payload == null)
+                return undefined;
+            // we can safely do so, as the types are not exported in TSC
+            const params = payload;
+            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                undefined;
+            return {
+                ls_provider: "openai",
+                ls_model_type: "chat",
+                ls_model_name: params.model,
+                ls_max_tokens: params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+            };
+        },
         ...options,
     });
     openai.completions.create = traceable(openai.completions.create.bind(openai.completions), {
@@ -151,6 +167,22 @@ export const wrapOpenAI = (openai, options) => {
         run_type: "llm",
         aggregator: textAggregator,
         argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: (payload) => {
+            if (typeof payload !== "object" || payload == null)
+                return undefined;
+            // we can safely do so, as the types are not exported in TSC
+            const params = payload;
+            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                undefined;
+            return {
+                ls_provider: "openai",
+                ls_model_type: "chat",
+                ls_model_name: params.model,
+                ls_max_tokens: params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+            };
+        },
         ...options,
     });
     return openai;

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.25",
+  "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'