langsmith 0.1.27 → 0.1.28

package/dist/evaluation/_runner.cjs

@@ -226,6 +226,7 @@ class _ExperimentManager {
                     metadata: projectMetadata,
                     description: this._description,
                 });
+                this._experiment = project;
             }
             catch (e) {
                 if (String(e).includes("already exists")) {

package/dist/evaluation/_runner.js

@@ -222,6 +222,7 @@ class _ExperimentManager {
                     metadata: projectMetadata,
                     description: this._description,
                 });
+                this._experiment = project;
             }
             catch (e) {
                 if (String(e).includes("already exists")) {

package/dist/evaluation/langchain.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLangchainStringEvaluator = void 0;
+const evaluation_1 = require("langchain/evaluation");
+const langchain_js_1 = require("../langchain.cjs");
+function isStringifiable(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint");
+}
+// utility methods for extracting stringified values
+// from unknown inputs and records
+function getPrimitiveValue(value) {
+    if (isStringifiable(value))
+        return String(value);
+    if (!Array.isArray(value) && typeof value === "object" && value != null) {
+        const values = Object.values(value);
+        if (values.length === 1 && isStringifiable(values[0])) {
+            return String(values[0]);
+        }
+    }
+    return undefined;
+}
+/**
+ * This utility function loads a LangChain string evaluator and returns a function
+ * which can be used by newer `evaluate` function.
+ *
+ * @param type Type of string evaluator, one of "criteria" or "labeled_criteria
+ * @param options Options for loading the evaluator
+ * @returns Evaluator consumable by `evaluate`
+ */
+async function getLangchainStringEvaluator(type, options) {
+    const evaluator = await (0, evaluation_1.loadEvaluator)(type, options);
+    const feedbackKey = getPrimitiveValue(options.criteria) ?? type;
+    const formatEvaluatorInputs = options.formatEvaluatorInputs ??
+        ((run, example) => {
+            const prediction = getPrimitiveValue(run.outputs);
+            const reference = getPrimitiveValue(example.outputs);
+            const input = getPrimitiveValue(example.inputs);
+            if (prediction == null)
+                throw new Error("Missing prediction");
+            if (type === "criteria")
+                return { prediction, input };
+            return { prediction, reference, input };
+        });
+    return async (run, example) => {
+        const score = await evaluator.evaluateStrings(formatEvaluatorInputs(run, example), { callbacks: await (0, langchain_js_1.getLangchainCallbacks)() });
+        return { key: feedbackKey, ...score };
+    };
+}
+exports.getLangchainStringEvaluator = getLangchainStringEvaluator;

package/dist/evaluation/langchain.d.ts

@@ -0,0 +1,19 @@
+import type { Run, Example } from "../schemas.js";
+import { type LoadEvaluatorOptions } from "langchain/evaluation";
+/**
+ * This utility function loads a LangChain string evaluator and returns a function
+ * which can be used by newer `evaluate` function.
+ *
+ * @param type Type of string evaluator, one of "criteria" or "labeled_criteria
+ * @param options Options for loading the evaluator
+ * @returns Evaluator consumable by `evaluate`
+ */
+export declare function getLangchainStringEvaluator(type: "criteria" | "labeled_criteria", options: LoadEvaluatorOptions & {
+    formatEvaluatorInputs?: (run: Run, example: Example) => {
+        prediction: string;
+        reference?: string;
+        input?: string;
+    };
+}): Promise<(run: Run, example: Example) => Promise<{
+    key: string;
+}>>;

package/dist/evaluation/langchain.js

@@ -0,0 +1,48 @@
+import { loadEvaluator } from "langchain/evaluation";
+import { getLangchainCallbacks } from "../langchain.js";
+function isStringifiable(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint");
+}
+// utility methods for extracting stringified values
+// from unknown inputs and records
+function getPrimitiveValue(value) {
+    if (isStringifiable(value))
+        return String(value);
+    if (!Array.isArray(value) && typeof value === "object" && value != null) {
+        const values = Object.values(value);
+        if (values.length === 1 && isStringifiable(values[0])) {
+            return String(values[0]);
+        }
+    }
+    return undefined;
+}
+/**
+ * This utility function loads a LangChain string evaluator and returns a function
+ * which can be used by newer `evaluate` function.
+ *
+ * @param type Type of string evaluator, one of "criteria" or "labeled_criteria
+ * @param options Options for loading the evaluator
+ * @returns Evaluator consumable by `evaluate`
+ */
+export async function getLangchainStringEvaluator(type, options) {
+    const evaluator = await loadEvaluator(type, options);
+    const feedbackKey = getPrimitiveValue(options.criteria) ?? type;
+    const formatEvaluatorInputs = options.formatEvaluatorInputs ??
+        ((run, example) => {
+            const prediction = getPrimitiveValue(run.outputs);
+            const reference = getPrimitiveValue(example.outputs);
+            const input = getPrimitiveValue(example.inputs);
+            if (prediction == null)
+                throw new Error("Missing prediction");
+            if (type === "criteria")
+                return { prediction, input };
+            return { prediction, reference, input };
+        });
+    return async (run, example) => {
+        const score = await evaluator.evaluateStrings(formatEvaluatorInputs(run, example), { callbacks: await getLangchainCallbacks() });
+        return { key: feedbackKey, ...score };
+    };
+}

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.27";
+exports.__version__ = "0.1.28";

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

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

package/dist/langchain.cjs

@@ -5,6 +5,7 @@ const manager_1 = require("@langchain/core/callbacks/manager");
 const tracer_langchain_1 = require("@langchain/core/tracers/tracer_langchain");
 const runnables_1 = require("@langchain/core/runnables");
 const traceable_js_1 = require("./traceable.cjs");
+const asserts_js_1 = require("./utils/asserts.cjs");
 /**
  * Converts the current run tree active within a traceable-wrapped function
  * into a LangChain compatible callback manager. This is useful to handoff tracing
@@ -96,7 +97,27 @@ class RunnableTraceable extends runnables_1.Runnable {
     }
     async invoke(input, options) {
         const [config] = this._getOptionsList(options ?? {}, 1);
-        return (await this.func(config, input));
+        const callbacks = await (0, runnables_1.getCallbackManagerForConfig)(config);
+        return (await this.func((0, runnables_1.patchConfig)(config, { callbacks }), input));
+    }
+    async *_streamIterator(input, options) {
+        const result = await this.invoke(input, options);
+        if ((0, asserts_js_1.isAsyncIterable)(result)) {
+            for await (const item of result) {
+                yield item;
+            }
+            return;
+        }
+        if ((0, asserts_js_1.isIteratorLike)(result)) {
+            while (true) {
+                const state = result.next();
+                if (state.done)
+                    break;
+                yield state.value;
+            }
+            return;
+        }
+        yield result;
     }
     static from(func) {
         return new RunnableTraceable({ func });

package/dist/langchain.d.ts

@@ -24,6 +24,7 @@ export declare class RunnableTraceable<RunInput, RunOutput> extends Runnable<Run
         func: AnyTraceableFunction;
     });
     invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
+    _streamIterator(input: RunInput, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
     static from(func: AnyTraceableFunction): RunnableTraceable<unknown, unknown>;
 }
 export {};

package/dist/langchain.js

@@ -1,7 +1,8 @@
 import { CallbackManager } from "@langchain/core/callbacks/manager";
 import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
-import { Runnable } from "@langchain/core/runnables";
+import { Runnable, patchConfig, getCallbackManagerForConfig, } from "@langchain/core/runnables";
 import { getCurrentRunTree, isTraceableFunction, } from "./traceable.js";
+import { isAsyncIterable, isIteratorLike } from "./utils/asserts.js";
 /**
  * Converts the current run tree active within a traceable-wrapped function
  * into a LangChain compatible callback manager. This is useful to handoff tracing
@@ -92,7 +93,27 @@ export class RunnableTraceable extends Runnable {
     }
     async invoke(input, options) {
         const [config] = this._getOptionsList(options ?? {}, 1);
-        return (await this.func(config, input));
+        const callbacks = await getCallbackManagerForConfig(config);
+        return (await this.func(patchConfig(config, { callbacks }), input));
+    }
+    async *_streamIterator(input, options) {
+        const result = await this.invoke(input, options);
+        if (isAsyncIterable(result)) {
+            for await (const item of result) {
+                yield item;
+            }
+            return;
+        }
+        if (isIteratorLike(result)) {
+            while (true) {
+                const state = result.next();
+                if (state.done)
+                    break;
+                yield state.value;
+            }
+            return;
+        }
+        yield result;
     }
     static from(func) {
         return new RunnableTraceable({ func });

package/dist/run_trees.cjs

@@ -28,13 +28,7 @@ const uuid = __importStar(require("uuid"));
 const env_js_1 = require("./utils/env.cjs");
 const client_js_1 = require("./client.cjs");
 const env_js_2 = require("./env.cjs");
-const warnedMessages = {};
-function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
-    }
-}
+const warn_js_1 = require("./utils/warn.cjs");
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
@@ -224,9 +218,19 @@ class RunTree {
             client = langChainTracer?.client;
             tracingEnabled = tracingEnabled || !!langChainTracer;
         }
+        if (!parentRun) {
+            return new RunTree({
+                client,
+                tracingEnabled,
+                project_name: projectName,
+                name: props.name,
+                tags: props.tags,
+                metadata: props.metadata,
+            });
+        }
         const parentRunTree = new RunTree({
-            name: parentRun?.name ?? "<parent>",
-            id: parentRun?.id,
+            name: parentRun.name,
+            id: parentRun.id,
             client,
             tracingEnabled,
             project_name: projectName,
@@ -241,7 +245,7 @@ class RunTree {
             },
         });
         return parentRunTree.createChild({
-            name: props?.name ?? "<lambda>",
+            name: props.name,
             tags: props.tags,
             metadata: props.metadata,
         });
@@ -338,7 +342,7 @@ class RunTree {
         const runCreate = await this._convertToCreate(this, runtimeEnv, true);
         await this.client.createRun(runCreate);
         if (!excludeChildRuns) {
-            warnOnce("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
+            (0, warn_js_1.warnOnce)("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
             for (const childRun of this.child_runs) {
                 await childRun.postRun(false);
             }

package/dist/run_trees.js

@@ -2,13 +2,7 @@ import * as uuid from "uuid";
 import { getEnvironmentVariable, getRuntimeEnvironment, } from "./utils/env.js";
 import { Client } from "./client.js";
 import { isTracingEnabled } from "./env.js";
-const warnedMessages = {};
-function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
-    }
-}
+import { warnOnce } from "./utils/warn.js";
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
@@ -197,9 +191,19 @@ export class RunTree {
             client = langChainTracer?.client;
             tracingEnabled = tracingEnabled || !!langChainTracer;
         }
+        if (!parentRun) {
+            return new RunTree({
+                client,
+                tracingEnabled,
+                project_name: projectName,
+                name: props.name,
+                tags: props.tags,
+                metadata: props.metadata,
+            });
+        }
         const parentRunTree = new RunTree({
-            name: parentRun?.name ?? "<parent>",
-            id: parentRun?.id,
+            name: parentRun.name,
+            id: parentRun.id,
             client,
             tracingEnabled,
             project_name: projectName,
@@ -214,7 +218,7 @@ export class RunTree {
             },
         });
         return parentRunTree.createChild({
-            name: props?.name ?? "<lambda>",
+            name: props.name,
             tags: props.tags,
             metadata: props.metadata,
         });

package/dist/schemas.d.ts

@@ -308,7 +308,7 @@ export type RetrieverOutput = Array<{
 export interface InvocationParamsSchema {
     ls_provider?: string;
     ls_model_name?: string;
-    ls_model_type: "chat";
+    ls_model_type: "chat" | "text";
     ls_temperature?: number;
     ls_max_tokens?: number;
     ls_stop?: string[];

package/dist/singletons/traceable.d.ts

@@ -20,4 +20,4 @@ export declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvid
 export declare const getCurrentRunTree: () => RunTree;
 export declare const ROOT: unique symbol;
 export declare function isTraceableFunction(x: unknown): x is TraceableFunction<any>;
-export {};
+export type { TraceableFunction } from "./types.js";

package/dist/traceable.cjs

@@ -5,44 +5,8 @@ const node_async_hooks_1 = require("node:async_hooks");
 const run_trees_js_1 = require("./run_trees.cjs");
 const env_js_1 = require("./env.cjs");
 const traceable_js_1 = require("./singletons/traceable.cjs");
+const asserts_js_1 = require("./utils/asserts.cjs");
 traceable_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
-function isPromiseMethod(x) {
-    if (x === "then" || x === "catch" || x === "finally") {
-        return true;
-    }
-    return false;
-}
-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 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;
-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 handleRunInputs = (rawInputs) => {
     const firstInput = rawInputs[0];
     if (firstInput == null) {
@@ -51,13 +15,13 @@ const handleRunInputs = (rawInputs) => {
     if (rawInputs.length > 1) {
         return { args: rawInputs };
     }
-    if (isKVMap(firstInput)) {
+    if ((0, asserts_js_1.isKVMap)(firstInput)) {
         return firstInput;
     }
     return { input: firstInput };
 };
 const handleRunOutputs = (rawOutputs) => {
-    if (isKVMap(rawOutputs)) {
+    if ((0, asserts_js_1.isKVMap)(rawOutputs)) {
         return rawOutputs;
     }
     return { outputs: rawOutputs };
@@ -122,7 +86,7 @@ const getSerializablePromise = (arg) => {
     return promiseProxy;
 };
 const convertSerializableArg = (arg) => {
-    if (isReadableStream(arg)) {
+    if ((0, asserts_js_1.isReadableStream)(arg)) {
         const proxyState = [];
         const transform = new TransformStream({
             start: () => void 0,
@@ -136,7 +100,7 @@ const convertSerializableArg = (arg) => {
         Object.assign(pipeThrough, { toJSON: () => proxyState });
         return pipeThrough;
     }
-    if (isAsyncIterable(arg)) {
+    if ((0, asserts_js_1.isAsyncIterable)(arg)) {
         const proxyState = { current: [] };
         return new Proxy(arg, {
             get(target, prop, receiver) {
@@ -179,7 +143,7 @@ const convertSerializableArg = (arg) => {
             },
         });
     }
-    if (!Array.isArray(arg) && isIteratorLike(arg)) {
+    if (!Array.isArray(arg) && (0, asserts_js_1.isIteratorLike)(arg)) {
         const proxyState = [];
         return new Proxy(arg, {
             get(target, prop, receiver) {
@@ -207,7 +171,7 @@ const convertSerializableArg = (arg) => {
             },
         });
     }
-    if (isThenable(arg)) {
+    if ((0, asserts_js_1.isThenable)(arg)) {
         return getSerializablePromise(arg);
     }
     return arg;
@@ -389,18 +353,18 @@ function traceable(wrappedFunc, config) {
             catch (err) {
                 returnValue = Promise.reject(err);
             }
-            if (isAsyncIterable(returnValue)) {
+            if ((0, asserts_js_1.isAsyncIterable)(returnValue)) {
                 const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
                 return wrapAsyncGeneratorForTracing(returnValue, snapshot);
             }
             const tracedPromise = new Promise((resolve, reject) => {
                 Promise.resolve(returnValue)
                     .then(async (rawOutput) => {
-                    if (isAsyncIterable(rawOutput)) {
+                    if ((0, asserts_js_1.isAsyncIterable)(rawOutput)) {
                         const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
                         return resolve(wrapAsyncGeneratorForTracing(rawOutput, snapshot));
                     }
-                    if (isGenerator(wrappedFunc) && isIteratorLike(rawOutput)) {
+                    if ((0, asserts_js_1.isGenerator)(wrappedFunc) && (0, asserts_js_1.isIteratorLike)(rawOutput)) {
                         const chunks = gatherAll(rawOutput);
                         await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {
                             if (!done || typeof value !== "undefined") {
@@ -437,7 +401,7 @@ function traceable(wrappedFunc, config) {
             }
             return new Proxy(returnValue, {
                 get(target, prop, receiver) {
-                    if (isPromiseMethod(prop)) {
+                    if ((0, asserts_js_1.isPromiseMethod)(prop)) {
                         return tracedPromise[prop].bind(tracedPromise);
                     }
                     return Reflect.get(target, prop, receiver);

package/dist/traceable.js

@@ -2,44 +2,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
 import { isTracingEnabled } from "./env.js";
 import { ROOT, AsyncLocalStorageProviderSingleton, } from "./singletons/traceable.js";
+import { isKVMap, isReadableStream, isAsyncIterable, isIteratorLike, isThenable, isGenerator, isPromiseMethod, } from "./utils/asserts.js";
 AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
-function isPromiseMethod(x) {
-    if (x === "then" || x === "catch" || x === "finally") {
-        return true;
-    }
-    return false;
-}
-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 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;
-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 handleRunInputs = (rawInputs) => {
     const firstInput = rawInputs[0];
     if (firstInput == null) {

package/dist/utils/asserts.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReadableStream = exports.isThenable = exports.isGenerator = exports.isIteratorLike = exports.isAsyncIterable = exports.isKVMap = exports.isPromiseMethod = void 0;
+function isPromiseMethod(x) {
+    if (x === "then" || x === "catch" || x === "finally") {
+        return true;
+    }
+    return false;
+}
+exports.isPromiseMethod = isPromiseMethod;
+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));
+}
+exports.isKVMap = isKVMap;
+const isAsyncIterable = (x) => x != null &&
+    typeof x === "object" &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof x[Symbol.asyncIterator] === "function";
+exports.isAsyncIterable = isAsyncIterable;
+const isIteratorLike = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
+exports.isIteratorLike = isIteratorLike;
+const GeneratorFunction = function* () { }.constructor;
+const isGenerator = (x) => 
+// eslint-disable-next-line no-instanceof/no-instanceof
+x != null && typeof x === "function" && x instanceof GeneratorFunction;
+exports.isGenerator = isGenerator;
+const isThenable = (x) => x != null &&
+    typeof x === "object" &&
+    "then" in x &&
+    typeof x.then === "function";
+exports.isThenable = isThenable;
+const isReadableStream = (x) => x != null &&
+    typeof x === "object" &&
+    "getReader" in x &&
+    typeof x.getReader === "function";
+exports.isReadableStream = isReadableStream;

package/dist/utils/asserts.d.ts

@@ -0,0 +1,7 @@
+export declare function isPromiseMethod(x: string | symbol): x is "then" | "catch" | "finally";
+export declare function isKVMap(x: unknown): x is Record<string, unknown>;
+export declare const isAsyncIterable: (x: unknown) => x is AsyncIterable<unknown>;
+export declare const isIteratorLike: (x: unknown) => x is Iterator<unknown, any, undefined>;
+export declare const isGenerator: (x: unknown) => x is Generator<unknown, any, unknown>;
+export declare const isThenable: (x: unknown) => x is Promise<unknown>;
+export declare const isReadableStream: (x: unknown) => x is ReadableStream<any>;

package/dist/utils/asserts.js

@@ -0,0 +1,37 @@
+export function isPromiseMethod(x) {
+    if (x === "then" || x === "catch" || x === "finally") {
+        return true;
+    }
+    return false;
+}
+export 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 const isAsyncIterable = (x) => x != null &&
+    typeof x === "object" &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof x[Symbol.asyncIterator] === "function";
+export const isIteratorLike = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
+const GeneratorFunction = function* () { }.constructor;
+export const isGenerator = (x) => 
+// eslint-disable-next-line no-instanceof/no-instanceof
+x != null && typeof x === "function" && x instanceof GeneratorFunction;
+export const isThenable = (x) => x != null &&
+    typeof x === "object" &&
+    "then" in x &&
+    typeof x.then === "function";
+export const isReadableStream = (x) => x != null &&
+    typeof x === "object" &&
+    "getReader" in x &&
+    typeof x.getReader === "function";

package/dist/utils/warn.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnOnce = void 0;
+const warnedMessages = {};
+function warnOnce(message) {
+    if (!warnedMessages[message]) {
+        console.warn(message);
+        warnedMessages[message] = true;
+    }
+}
+exports.warnOnce = warnOnce;

package/dist/utils/warn.d.ts

@@ -0,0 +1 @@
+export declare function warnOnce(message: string): void;

package/dist/utils/warn.js

@@ -0,0 +1,7 @@
+const warnedMessages = {};
+export function warnOnce(message) {
+    if (!warnedMessages[message]) {
+        console.warn(message);
+        warnedMessages[message] = true;
+    }
+}

package/dist/wrappers/openai.cjs

@@ -179,7 +179,7 @@ const wrapOpenAI = (openai, options) => {
                 undefined;
             return {
                 ls_provider: "openai",
-                ls_model_type: "chat",
+                ls_model_type: "text",
                 ls_model_name: params.model,
                 ls_max_tokens: params.max_tokens ?? undefined,
                 ls_temperature: params.temperature ?? undefined,

package/dist/wrappers/openai.js

@@ -176,7 +176,7 @@ export const wrapOpenAI = (openai, options) => {
                 undefined;
             return {
                 ls_provider: "openai",
-                ls_model_type: "chat",
+                ls_model_type: "text",
                 ls_model_name: params.model,
                 ls_max_tokens: params.max_tokens ?? undefined,
                 ls_temperature: params.temperature ?? undefined,

package/evaluation/langchain.cjs

@@ -0,0 +1 @@
+module.exports = require('../dist/evaluation/langchain.cjs');

package/evaluation/langchain.d.cts

@@ -0,0 +1 @@
+export * from '../dist/evaluation/langchain.js'

package/evaluation/langchain.d.ts

@@ -0,0 +1 @@
+export * from '../dist/evaluation/langchain.js'

package/evaluation/langchain.js

@@ -0,0 +1 @@
+export * from '../dist/evaluation/langchain.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -21,6 +21,10 @@
     "evaluation.js",
     "evaluation.d.ts",
     "evaluation.d.cts",
+    "evaluation/langchain.cjs",
+    "evaluation/langchain.js",
+    "evaluation/langchain.d.ts",
+    "evaluation/langchain.d.cts",
     "schemas.cjs",
     "schemas.js",
     "schemas.d.ts",
@@ -95,8 +99,9 @@
     "@babel/preset-env": "^7.22.4",
     "@faker-js/faker": "^8.4.1",
     "@jest/globals": "^29.5.0",
-    "@langchain/core": "^0.1.32",
-    "@langchain/langgraph": "^0.0.8",
+    "langchain": "^0.2.0",
+    "@langchain/core": "^0.2.0",
+    "@langchain/langgraph": "^0.0.19",
     "@tsconfig/recommended": "^1.0.2",
     "@types/jest": "^29.5.1",
     "@typescript-eslint/eslint-plugin": "^5.59.8",
@@ -118,16 +123,23 @@
   },
   "peerDependencies": {
     "openai": "*",
+    "langchain": "*",
     "@langchain/core": "*"
   },
   "peerDependenciesMeta": {
     "openai": {
       "optional": true
     },
+    "langchain": {
+      "optional": true
+    },
     "@langchain/core": {
       "optional": true
     }
   },
+  "resolutions": {
+    "@langchain/core": "0.2.0"
+  },
   "lint-staged": {
     "**/*.{ts,tsx}": [
       "prettier --write --ignore-unknown",
@@ -180,6 +192,15 @@
       "import": "./evaluation.js",
       "require": "./evaluation.cjs"
     },
+    "./evaluation/langchain": {
+      "types": {
+        "import": "./evaluation/langchain.d.ts",
+        "require": "./evaluation/langchain.d.cts",
+        "default": "./evaluation/langchain.d.ts"
+      },
+      "import": "./evaluation/langchain.js",
+      "require": "./evaluation/langchain.cjs"
+    },
     "./schemas": {
       "types": {
         "import": "./schemas.d.ts",
@@ -227,4 +248,4 @@
     },
     "./package.json": "./package.json"
   }
-}
+}