langsmith 0.1.18 → 0.1.20

package/dist/client.d.ts

@@ -138,6 +138,7 @@ interface ProjectOptions {
     projectName?: string;
     projectId?: string;
 }
+type RecordStringAny = Record<string, any>;
 export type FeedbackSourceType = "model" | "api" | "app";
 export type CreateExampleOptions = {
     datasetId?: string;
@@ -313,16 +314,16 @@ export declare class Client {
     createProject({ projectName, description, metadata, upsert, projectExtra, referenceDatasetId, }: {
         projectName: string;
         description?: string | null;
-        metadata?: Record<string, any> | null;
+        metadata?: RecordStringAny | null;
         upsert?: boolean;
-        projectExtra?: Record<string, any> | null;
+        projectExtra?: RecordStringAny | null;
         referenceDatasetId?: string | null;
     }): Promise<TracerSession>;
     updateProject(projectId: string, { name, description, metadata, projectExtra, endTime, }: {
         name?: string | null;
         description?: string | null;
-        metadata?: Record<string, any> | null;
-        projectExtra?: Record<string, any> | null;
+        metadata?: RecordStringAny | null;
+        projectExtra?: RecordStringAny | null;
         endTime?: string | null;
     }): Promise<TracerSession>;
     hasProject({ projectId, projectName, }: {

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.18";
+exports.__version__ = "0.1.20";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export type { Dataset, Example, TracerSession, Run, Feedback, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
-export declare const __version__ = "0.1.18";
+export declare const __version__ = "0.1.20";

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

package/dist/run_trees.cjs

@@ -43,7 +43,7 @@ function convertToDottedOrderFormat(epoch, runId) {
 }
 exports.convertToDottedOrderFormat = convertToDottedOrderFormat;
 class RunTree {
-    constructor(config) {
+    constructor(originalConfig) {
         Object.defineProperty(this, "id", {
             enumerable: true,
             configurable: true,
@@ -159,7 +159,13 @@ class RunTree {
             value: void 0
         });
         const defaultConfig = RunTree.getDefaultConfig();
+        const { metadata, ...config } = originalConfig;
         const client = config.client ?? new client_js_1.Client();
+        const dedupedMetadata = {
+            ...metadata,
+            ...config?.extra?.metadata,
+        };
+        config.extra = { ...config.extra, metadata: dedupedMetadata };
         Object.assign(this, { ...defaultConfig, ...config, client });
         if (!this.trace_id) {
             if (this.parent_run) {
@@ -191,7 +197,7 @@ class RunTree {
             parentRun = langChainTracer?.getRun?.(parentRunId);
             projectName = langChainTracer?.projectName;
         }
-        const deduppedTags = [
+        const dedupedTags = [
             ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
         ];
         const dedupedMetadata = {
@@ -201,7 +207,7 @@ class RunTree {
         const rt = new RunTree({
             name: props?.name ?? "<lambda>",
             parent_run: parentRun,
-            tags: deduppedTags,
+            tags: dedupedTags,
             extra: {
                 metadata: dedupedMetadata,
             },

package/dist/run_trees.d.ts

@@ -12,6 +12,7 @@ export interface RunTreeConfig {
     start_time?: number;
     end_time?: number;
     extra?: KVMap;
+    metadata?: KVMap;
     tags?: string[];
     error?: string;
     serialized?: object;
@@ -57,7 +58,7 @@ export declare class RunTree implements BaseRun {
     events?: KVMap[] | undefined;
     trace_id: string;
     dotted_order: string;
-    constructor(config: RunTreeConfig);
+    constructor(originalConfig: RunTreeConfig);
     static fromRunnableConfig(config: RunnableConfigLike, props: {
         name: string;
         tags?: string[];

package/dist/run_trees.js

@@ -16,7 +16,7 @@ export function convertToDottedOrderFormat(epoch, runId) {
         runId);
 }
 export class RunTree {
-    constructor(config) {
+    constructor(originalConfig) {
         Object.defineProperty(this, "id", {
             enumerable: true,
             configurable: true,
@@ -132,7 +132,13 @@ export class RunTree {
             value: void 0
         });
         const defaultConfig = RunTree.getDefaultConfig();
+        const { metadata, ...config } = originalConfig;
         const client = config.client ?? new Client();
+        const dedupedMetadata = {
+            ...metadata,
+            ...config?.extra?.metadata,
+        };
+        config.extra = { ...config.extra, metadata: dedupedMetadata };
         Object.assign(this, { ...defaultConfig, ...config, client });
         if (!this.trace_id) {
             if (this.parent_run) {
@@ -164,7 +170,7 @@ export class RunTree {
             parentRun = langChainTracer?.getRun?.(parentRunId);
             projectName = langChainTracer?.projectName;
         }
-        const deduppedTags = [
+        const dedupedTags = [
             ...new Set((parentRun?.tags ?? []).concat(config?.tags ?? [])),
         ];
         const dedupedMetadata = {
@@ -174,7 +180,7 @@ export class RunTree {
         const rt = new RunTree({
             name: props?.name ?? "<lambda>",
             parent_run: parentRun,
-            tags: deduppedTags,
+            tags: dedupedTags,
             extra: {
                 metadata: dedupedMetadata,
             },

package/dist/traceable.cjs

@@ -3,11 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTraceableFunction = exports.getCurrentRunTree = exports.traceable = void 0;
 const async_hooks_1 = require("async_hooks");
 const run_trees_js_1 = require("./run_trees.cjs");
+const env_js_1 = require("./utils/env.cjs");
 const asyncLocalStorage = new async_hooks_1.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 = (0, env_js_1.getEnvironmentVariable)("LANGSMITH_TRACING_V2") === "true" ||
+        (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true";
+    if (!tracingEnabled) {
+        return undefined;
+    }
+    return runTree;
+};
 /**
  * Higher-order function that takes function as input and returns a
  * "TraceableFunction" - a wrapped version of the input that
@@ -24,12 +33,13 @@ const isAsyncIterable = (x) => x != null &&
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function traceable(wrappedFunc, config) {
+    const { aggregator, ...runTreeConfig } = config ?? {};
     const traceableFunc = async (...args) => {
         let currentRunTree;
         let rawInputs;
         const ensuredConfig = {
             name: wrappedFunc.name || "<lambda>",
-            ...config,
+            ...runTreeConfig,
         };
         const previousRunTree = asyncLocalStorage.getStore();
         if ((0, run_trees_js_1.isRunTree)(args[0])) {
@@ -48,6 +58,7 @@ function traceable(wrappedFunc, config) {
             currentRunTree = new run_trees_js_1.RunTree(ensuredConfig);
             rawInputs = args;
         }
+        currentRunTree = getTracingRunTree(currentRunTree);
         let inputs;
         const firstInput = rawInputs[0];
         if (firstInput == null) {
@@ -62,10 +73,12 @@ function traceable(wrappedFunc, config) {
         else {
             inputs = { input: firstInput };
         }
-        currentRunTree.inputs = inputs;
-        const initialOutputs = currentRunTree.outputs;
-        const initialError = currentRunTree.error;
-        await currentRunTree.postRun();
+        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 {
@@ -79,8 +92,27 @@ function traceable(wrappedFunc, config) {
                                 chunks.push(chunk);
                                 yield chunk;
                             }
-                            await currentRunTree.end({ outputs: chunks });
-                            await currentRunTree.patchRun();
+                            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 });
+                            }
+                            await currentRunTree?.patchRun();
                         }
                         return resolve(wrapOutputForTracing());
                     }
@@ -88,31 +120,35 @@ function traceable(wrappedFunc, config) {
                         const outputs = isKVMap(rawOutput)
                             ? rawOutput
                             : { outputs: rawOutput };
-                        if (initialOutputs === currentRunTree.outputs) {
-                            await currentRunTree.end(outputs);
+                        if (initialOutputs === currentRunTree?.outputs) {
+                            await currentRunTree?.end(outputs);
                         }
                         else {
-                            currentRunTree.end_time = Date.now();
+                            if (currentRunTree !== undefined) {
+                                currentRunTree.end_time = Date.now();
+                            }
                         }
-                        await currentRunTree.patchRun();
+                        await currentRunTree?.patchRun();
                         return resolve(rawOutput);
                     }
                 }
                 catch (error) {
-                    if (initialError === currentRunTree.error) {
-                        await currentRunTree.end(initialOutputs, String(error));
+                    if (initialError === currentRunTree?.error) {
+                        await currentRunTree?.end(initialOutputs, String(error));
                     }
                     else {
-                        currentRunTree.end_time = Date.now();
+                        if (currentRunTree !== undefined) {
+                            currentRunTree.end_time = Date.now();
+                        }
                     }
-                    await currentRunTree.patchRun();
+                    await currentRunTree?.patchRun();
                     reject(error);
                 }
             });
         });
     };
     Object.defineProperty(traceableFunc, "langsmith:traceable", {
-        value: config,
+        value: runTreeConfig,
     });
     return traceableFunc;
 }

package/dist/traceable.d.ts

@@ -44,7 +44,9 @@ export type TraceableFunction<Func extends (...args: any[]) => any> = Func exten
  * @param config Additional metadata such as name, tags or providing
  *     a custom LangSmith client instance
  */
-export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: Partial<RunTreeConfig>): TraceableFunction<Func>;
+export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: Partial<RunTreeConfig> & {
+    aggregator?: (args: any[]) => any;
+}): TraceableFunction<Func>;
 /**
  * Return the current run tree from within a traceable-wrapped function.
  * Will throw an error if called outside of a traceable function.

package/dist/traceable.js

@@ -1,10 +1,19 @@
 import { AsyncLocalStorage } from "async_hooks";
 import { RunTree, isRunTree, isRunnableConfigLike, } from "./run_trees.js";
+import { getEnvironmentVariable } from "./utils/env.js";
 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) {
+        return undefined;
+    }
+    return runTree;
+};
 /**
  * Higher-order function that takes function as input and returns a
  * "TraceableFunction" - a wrapped version of the input that
@@ -21,12 +30,13 @@ const isAsyncIterable = (x) => x != null &&
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function traceable(wrappedFunc, config) {
+    const { aggregator, ...runTreeConfig } = config ?? {};
     const traceableFunc = async (...args) => {
         let currentRunTree;
         let rawInputs;
         const ensuredConfig = {
             name: wrappedFunc.name || "<lambda>",
-            ...config,
+            ...runTreeConfig,
         };
         const previousRunTree = asyncLocalStorage.getStore();
         if (isRunTree(args[0])) {
@@ -45,6 +55,7 @@ export function traceable(wrappedFunc, config) {
             currentRunTree = new RunTree(ensuredConfig);
             rawInputs = args;
         }
+        currentRunTree = getTracingRunTree(currentRunTree);
         let inputs;
         const firstInput = rawInputs[0];
         if (firstInput == null) {
@@ -59,10 +70,12 @@ export function traceable(wrappedFunc, config) {
         else {
             inputs = { input: firstInput };
         }
-        currentRunTree.inputs = inputs;
-        const initialOutputs = currentRunTree.outputs;
-        const initialError = currentRunTree.error;
-        await currentRunTree.postRun();
+        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 {
@@ -76,8 +89,27 @@ export function traceable(wrappedFunc, config) {
                                 chunks.push(chunk);
                                 yield chunk;
                             }
-                            await currentRunTree.end({ outputs: chunks });
-                            await currentRunTree.patchRun();
+                            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 });
+                            }
+                            await currentRunTree?.patchRun();
                         }
                         return resolve(wrapOutputForTracing());
                     }
@@ -85,31 +117,35 @@ export function traceable(wrappedFunc, config) {
                         const outputs = isKVMap(rawOutput)
                             ? rawOutput
                             : { outputs: rawOutput };
-                        if (initialOutputs === currentRunTree.outputs) {
-                            await currentRunTree.end(outputs);
+                        if (initialOutputs === currentRunTree?.outputs) {
+                            await currentRunTree?.end(outputs);
                         }
                         else {
-                            currentRunTree.end_time = Date.now();
+                            if (currentRunTree !== undefined) {
+                                currentRunTree.end_time = Date.now();
+                            }
                         }
-                        await currentRunTree.patchRun();
+                        await currentRunTree?.patchRun();
                         return resolve(rawOutput);
                     }
                 }
                 catch (error) {
-                    if (initialError === currentRunTree.error) {
-                        await currentRunTree.end(initialOutputs, String(error));
+                    if (initialError === currentRunTree?.error) {
+                        await currentRunTree?.end(initialOutputs, String(error));
                     }
                     else {
-                        currentRunTree.end_time = Date.now();
+                        if (currentRunTree !== undefined) {
+                            currentRunTree.end_time = Date.now();
+                        }
                     }
-                    await currentRunTree.patchRun();
+                    await currentRunTree?.patchRun();
                     reject(error);
                 }
             });
         });
     };
     Object.defineProperty(traceableFunc, "langsmith:traceable", {
-        value: config,
+        value: runTreeConfig,
     });
     return traceableFunc;
 }

package/dist/utils/messages.cjs

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertLangChainMessageToExample = exports.isLangChainMessage = void 0;
-function isLangChainMessage(message) {
+function isLangChainMessage(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+message) {
     return typeof message?._getType === "function";
 }
 exports.isLangChainMessage = isLangChainMessage;

package/dist/utils/messages.js

@@ -1,4 +1,6 @@
-export function isLangChainMessage(message) {
+export function isLangChainMessage(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+message) {
     return typeof message?._getType === "function";
 }
 export function convertLangChainMessageToExample(message) {

package/dist/wrappers/index.cjs

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openai.cjs"), exports);

package/dist/wrappers/index.d.ts

@@ -0,0 +1 @@
+export * from "./openai.js";

package/dist/wrappers/index.js

@@ -0,0 +1 @@
+export * from "./openai.js";

package/dist/wrappers/openai.cjs

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapSDK = exports.wrapOpenAI = void 0;
+const traceable_js_1 = require("../traceable.cjs");
+function _combineChatCompletionChoices(choices) {
+    const reversedChoices = choices.slice().reverse();
+    const message = {
+        role: "assistant",
+        content: "",
+    };
+    for (const c of reversedChoices) {
+        if (c.delta.role) {
+            message["role"] = c.delta.role;
+            break;
+        }
+    }
+    const toolCalls = {};
+    for (const c of choices) {
+        if (c.delta.content) {
+            message.content = message.content.concat(c.delta.content);
+        }
+        if (c.delta.function_call) {
+            if (!message.function_call) {
+                message.function_call = { name: "", arguments: "" };
+            }
+            if (c.delta.function_call.name) {
+                message.function_call.name += c.delta.function_call.name;
+            }
+            if (c.delta.function_call.arguments) {
+                message.function_call.arguments += c.delta.function_call.arguments;
+            }
+        }
+        if (c.delta.tool_calls) {
+            for (const tool_call of c.delta.tool_calls) {
+                if (!toolCalls[c.index]) {
+                    toolCalls[c.index] = [];
+                }
+                toolCalls[c.index].push(tool_call);
+            }
+        }
+    }
+    if (Object.keys(toolCalls).length > 0) {
+        message.tool_calls = [...Array(Object.keys(toolCalls).length)];
+        for (const [index, toolCallChunks] of Object.entries(toolCalls)) {
+            const idx = parseInt(index);
+            message.tool_calls[idx] = {
+                index: idx,
+                id: toolCallChunks.find((c) => c.id)?.id || null,
+                type: toolCallChunks.find((c) => c.type)?.type || null,
+            };
+            for (const chunk of toolCallChunks) {
+                if (chunk.function) {
+                    if (!message.tool_calls[idx].function) {
+                        message.tool_calls[idx].function = {
+                            name: "",
+                            arguments: "",
+                        };
+                    }
+                    if (chunk.function.name) {
+                        message.tool_calls[idx].function.name += chunk.function.name;
+                    }
+                    if (chunk.function.arguments) {
+                        message.tool_calls[idx].function.arguments +=
+                            chunk.function.arguments;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        index: choices[0].index,
+        finish_reason: reversedChoices.find((c) => c.finish_reason) || null,
+        message: message,
+    };
+}
+async function extractLangSmithExtraAndCall(openAIMethod, args, defaultRunConfig) {
+    if (args[1]?.langsmithExtra !== undefined) {
+        const { langsmithExtra, ...openAIOptions } = args[1];
+        const wrappedMethod = (0, traceable_js_1.traceable)(openAIMethod, {
+            ...defaultRunConfig,
+            ...langsmithExtra,
+        });
+        const finalArgs = [args[0]];
+        if (args.length > 2) {
+            finalArgs.push(openAIOptions);
+            finalArgs.push(args.slice(2));
+        }
+        else if (Object.keys(openAIOptions).length !== 0) {
+            finalArgs.push(openAIOptions);
+        }
+        return wrappedMethod(...finalArgs);
+    }
+    const wrappedMethod = (0, traceable_js_1.traceable)(openAIMethod, defaultRunConfig);
+    return wrappedMethod(...args);
+}
+/**
+ * Wraps an OpenAI client's completion methods, enabling automatic LangSmith
+ * tracing. Method signatures are unchanged, with the exception that you can pass
+ * an additional and optional "langsmithExtra" field within the second parameter.
+ * @param openai An OpenAI client instance.
+ * @param options LangSmith options.
+ * @example
+ * ```ts
+ * const patchedStream = await patchedClient.chat.completions.create(
+ *   {
+ *     messages: [{ role: "user", content: `Say 'foo'` }],
+ *     model: "gpt-3.5-turbo",
+ *     stream: true,
+ *   },
+ *   {
+ *     langsmithExtra: {
+ *       metadata: {
+ *         additional_data: "bar",
+ *       },
+ *     },
+ *   },
+ * );
+ * ```
+ */
+const wrapOpenAI = (openai, options) => {
+    const originalChatCompletionsFn = openai.chat.completions.create.bind(openai.chat.completions);
+    openai.chat.completions.create = async (...args) => {
+        const aggregator = (chunks) => {
+            if (!chunks || chunks.length === 0) {
+                return { choices: [{ message: { role: "assistant", content: "" } }] };
+            }
+            const choicesByIndex = {};
+            for (const chunk of chunks) {
+                for (const choice of chunk.choices) {
+                    if (choicesByIndex[choice.index] === undefined) {
+                        choicesByIndex[choice.index] = [];
+                    }
+                    choicesByIndex[choice.index].push(choice);
+                }
+            }
+            const aggregatedOutput = chunks[chunks.length - 1];
+            aggregatedOutput.choices = Object.values(choicesByIndex).map((choices) => _combineChatCompletionChoices(choices));
+            return aggregatedOutput;
+        };
+        const defaultRunConfig = {
+            name: "ChatOpenAI",
+            run_type: "llm",
+            aggregator,
+            ...options,
+        };
+        return extractLangSmithExtraAndCall(originalChatCompletionsFn, args, defaultRunConfig);
+    };
+    const originalCompletionsFn = openai.completions.create.bind(openai.chat.completions);
+    openai.completions.create = async (...args) => {
+        const aggregator = (allChunks) => {
+            if (allChunks.length === 0) {
+                return { choices: [{ text: "" }] };
+            }
+            const allContent = [];
+            for (const chunk of allChunks) {
+                const content = chunk.choices[0].text;
+                if (content != null) {
+                    allContent.push(content);
+                }
+            }
+            const content = allContent.join("");
+            const aggregatedOutput = allChunks[allChunks.length - 1];
+            aggregatedOutput.choices = [
+                { ...aggregatedOutput.choices[0], text: content },
+            ];
+            return aggregatedOutput;
+        };
+        const defaultRunConfig = {
+            name: "OpenAI",
+            run_type: "llm",
+            aggregator,
+            ...options,
+        };
+        return extractLangSmithExtraAndCall(originalCompletionsFn, args, defaultRunConfig);
+    };
+    return openai;
+};
+exports.wrapOpenAI = wrapOpenAI;
+const _wrapClient = (sdk, runName, options) => {
+    return new Proxy(sdk, {
+        get(target, propKey, receiver) {
+            const originalValue = target[propKey];
+            if (typeof originalValue === "function") {
+                return (0, traceable_js_1.traceable)(originalValue.bind(target), Object.assign({ name: [runName, propKey.toString()].join("."), run_type: "llm" }, options?.client));
+            }
+            else if (originalValue != null &&
+                !Array.isArray(originalValue) &&
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(originalValue instanceof Date) &&
+                typeof originalValue === "object") {
+                return _wrapClient(originalValue, [runName, propKey.toString()].join("."), options);
+            }
+            else {
+                return Reflect.get(target, propKey, receiver);
+            }
+        },
+    });
+};
+/**
+ * Wrap an arbitrary SDK, enabling automatic LangSmith tracing.
+ * Method signatures are unchanged.
+ *
+ * Note that this will wrap and trace ALL SDK methods, not just
+ * LLM completion methods. If the passed SDK contains other methods,
+ * we recommend using the wrapped instance for LLM calls only.
+ * @param sdk An arbitrary SDK instance.
+ * @param options LangSmith options.
+ * @returns
+ */
+const wrapSDK = (sdk, options) => {
+    return _wrapClient(sdk, options?.runName ?? sdk.constructor?.name, {
+        client: options?.client,
+    });
+};
+exports.wrapSDK = wrapSDK;

package/dist/wrappers/openai.d.ts

@@ -0,0 +1,83 @@
+import type { OpenAI } from "openai";
+import type { Client, RunTreeConfig } from "../index.js";
+import { type RunnableConfigLike } from "../run_trees.js";
+import { type RunTreeLike } from "../traceable.js";
+type OpenAIType = {
+    chat: {
+        completions: {
+            create: (...args: any[]) => any;
+        };
+    };
+    completions: {
+        create: (...args: any[]) => any;
+    };
+};
+type PatchedOpenAIClient<T extends OpenAIType> = {
+    [P in keyof T]: T[P];
+} & {
+    chat: {
+        completions: {
+            create: {
+                (arg: OpenAI.ChatCompletionCreateParamsStreaming, arg2?: OpenAI.RequestOptions & {
+                    langsmithExtra?: RunnableConfigLike | RunTreeLike;
+                }): Promise<AsyncGenerator<OpenAI.ChatCompletionChunk>>;
+            } & {
+                (arg: OpenAI.ChatCompletionCreateParamsNonStreaming, arg2?: OpenAI.RequestOptions & {
+                    langsmithExtra?: RunnableConfigLike | RunTreeLike;
+                }): Promise<OpenAI.ChatCompletionChunk>;
+            };
+        };
+    };
+    completions: {
+        create: {
+            (arg: OpenAI.CompletionCreateParamsStreaming, arg2?: OpenAI.RequestOptions & {
+                langsmithExtra?: RunnableConfigLike | RunTreeLike;
+            }): Promise<AsyncGenerator<OpenAI.Completion>>;
+        } & {
+            (arg: OpenAI.CompletionCreateParamsNonStreaming, arg2?: OpenAI.RequestOptions & {
+                langsmithExtra?: RunnableConfigLike | RunTreeLike;
+            }): Promise<OpenAI.Completion>;
+        };
+    };
+};
+/**
+ * Wraps an OpenAI client's completion methods, enabling automatic LangSmith
+ * tracing. Method signatures are unchanged, with the exception that you can pass
+ * an additional and optional "langsmithExtra" field within the second parameter.
+ * @param openai An OpenAI client instance.
+ * @param options LangSmith options.
+ * @example
+ * ```ts
+ * const patchedStream = await patchedClient.chat.completions.create(
+ *   {
+ *     messages: [{ role: "user", content: `Say 'foo'` }],
+ *     model: "gpt-3.5-turbo",
+ *     stream: true,
+ *   },
+ *   {
+ *     langsmithExtra: {
+ *       metadata: {
+ *         additional_data: "bar",
+ *       },
+ *     },
+ *   },
+ * );
+ * ```
+ */
+export declare const wrapOpenAI: <T extends OpenAIType>(openai: T, options?: Partial<RunTreeConfig>) => PatchedOpenAIClient<T>;
+/**
+ * Wrap an arbitrary SDK, enabling automatic LangSmith tracing.
+ * Method signatures are unchanged.
+ *
+ * Note that this will wrap and trace ALL SDK methods, not just
+ * LLM completion methods. If the passed SDK contains other methods,
+ * we recommend using the wrapped instance for LLM calls only.
+ * @param sdk An arbitrary SDK instance.
+ * @param options LangSmith options.
+ * @returns
+ */
+export declare const wrapSDK: <T extends object>(sdk: T, options?: {
+    client?: Client;
+    runName?: string;
+}) => T;
+export {};

package/dist/wrappers/openai.js

@@ -0,0 +1,210 @@
+import { traceable } from "../traceable.js";
+function _combineChatCompletionChoices(choices) {
+    const reversedChoices = choices.slice().reverse();
+    const message = {
+        role: "assistant",
+        content: "",
+    };
+    for (const c of reversedChoices) {
+        if (c.delta.role) {
+            message["role"] = c.delta.role;
+            break;
+        }
+    }
+    const toolCalls = {};
+    for (const c of choices) {
+        if (c.delta.content) {
+            message.content = message.content.concat(c.delta.content);
+        }
+        if (c.delta.function_call) {
+            if (!message.function_call) {
+                message.function_call = { name: "", arguments: "" };
+            }
+            if (c.delta.function_call.name) {
+                message.function_call.name += c.delta.function_call.name;
+            }
+            if (c.delta.function_call.arguments) {
+                message.function_call.arguments += c.delta.function_call.arguments;
+            }
+        }
+        if (c.delta.tool_calls) {
+            for (const tool_call of c.delta.tool_calls) {
+                if (!toolCalls[c.index]) {
+                    toolCalls[c.index] = [];
+                }
+                toolCalls[c.index].push(tool_call);
+            }
+        }
+    }
+    if (Object.keys(toolCalls).length > 0) {
+        message.tool_calls = [...Array(Object.keys(toolCalls).length)];
+        for (const [index, toolCallChunks] of Object.entries(toolCalls)) {
+            const idx = parseInt(index);
+            message.tool_calls[idx] = {
+                index: idx,
+                id: toolCallChunks.find((c) => c.id)?.id || null,
+                type: toolCallChunks.find((c) => c.type)?.type || null,
+            };
+            for (const chunk of toolCallChunks) {
+                if (chunk.function) {
+                    if (!message.tool_calls[idx].function) {
+                        message.tool_calls[idx].function = {
+                            name: "",
+                            arguments: "",
+                        };
+                    }
+                    if (chunk.function.name) {
+                        message.tool_calls[idx].function.name += chunk.function.name;
+                    }
+                    if (chunk.function.arguments) {
+                        message.tool_calls[idx].function.arguments +=
+                            chunk.function.arguments;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        index: choices[0].index,
+        finish_reason: reversedChoices.find((c) => c.finish_reason) || null,
+        message: message,
+    };
+}
+async function extractLangSmithExtraAndCall(openAIMethod, args, defaultRunConfig) {
+    if (args[1]?.langsmithExtra !== undefined) {
+        const { langsmithExtra, ...openAIOptions } = args[1];
+        const wrappedMethod = traceable(openAIMethod, {
+            ...defaultRunConfig,
+            ...langsmithExtra,
+        });
+        const finalArgs = [args[0]];
+        if (args.length > 2) {
+            finalArgs.push(openAIOptions);
+            finalArgs.push(args.slice(2));
+        }
+        else if (Object.keys(openAIOptions).length !== 0) {
+            finalArgs.push(openAIOptions);
+        }
+        return wrappedMethod(...finalArgs);
+    }
+    const wrappedMethod = traceable(openAIMethod, defaultRunConfig);
+    return wrappedMethod(...args);
+}
+/**
+ * Wraps an OpenAI client's completion methods, enabling automatic LangSmith
+ * tracing. Method signatures are unchanged, with the exception that you can pass
+ * an additional and optional "langsmithExtra" field within the second parameter.
+ * @param openai An OpenAI client instance.
+ * @param options LangSmith options.
+ * @example
+ * ```ts
+ * const patchedStream = await patchedClient.chat.completions.create(
+ *   {
+ *     messages: [{ role: "user", content: `Say 'foo'` }],
+ *     model: "gpt-3.5-turbo",
+ *     stream: true,
+ *   },
+ *   {
+ *     langsmithExtra: {
+ *       metadata: {
+ *         additional_data: "bar",
+ *       },
+ *     },
+ *   },
+ * );
+ * ```
+ */
+export const wrapOpenAI = (openai, options) => {
+    const originalChatCompletionsFn = openai.chat.completions.create.bind(openai.chat.completions);
+    openai.chat.completions.create = async (...args) => {
+        const aggregator = (chunks) => {
+            if (!chunks || chunks.length === 0) {
+                return { choices: [{ message: { role: "assistant", content: "" } }] };
+            }
+            const choicesByIndex = {};
+            for (const chunk of chunks) {
+                for (const choice of chunk.choices) {
+                    if (choicesByIndex[choice.index] === undefined) {
+                        choicesByIndex[choice.index] = [];
+                    }
+                    choicesByIndex[choice.index].push(choice);
+                }
+            }
+            const aggregatedOutput = chunks[chunks.length - 1];
+            aggregatedOutput.choices = Object.values(choicesByIndex).map((choices) => _combineChatCompletionChoices(choices));
+            return aggregatedOutput;
+        };
+        const defaultRunConfig = {
+            name: "ChatOpenAI",
+            run_type: "llm",
+            aggregator,
+            ...options,
+        };
+        return extractLangSmithExtraAndCall(originalChatCompletionsFn, args, defaultRunConfig);
+    };
+    const originalCompletionsFn = openai.completions.create.bind(openai.chat.completions);
+    openai.completions.create = async (...args) => {
+        const aggregator = (allChunks) => {
+            if (allChunks.length === 0) {
+                return { choices: [{ text: "" }] };
+            }
+            const allContent = [];
+            for (const chunk of allChunks) {
+                const content = chunk.choices[0].text;
+                if (content != null) {
+                    allContent.push(content);
+                }
+            }
+            const content = allContent.join("");
+            const aggregatedOutput = allChunks[allChunks.length - 1];
+            aggregatedOutput.choices = [
+                { ...aggregatedOutput.choices[0], text: content },
+            ];
+            return aggregatedOutput;
+        };
+        const defaultRunConfig = {
+            name: "OpenAI",
+            run_type: "llm",
+            aggregator,
+            ...options,
+        };
+        return extractLangSmithExtraAndCall(originalCompletionsFn, args, defaultRunConfig);
+    };
+    return openai;
+};
+const _wrapClient = (sdk, runName, options) => {
+    return new Proxy(sdk, {
+        get(target, propKey, receiver) {
+            const originalValue = target[propKey];
+            if (typeof originalValue === "function") {
+                return traceable(originalValue.bind(target), Object.assign({ name: [runName, propKey.toString()].join("."), run_type: "llm" }, options?.client));
+            }
+            else if (originalValue != null &&
+                !Array.isArray(originalValue) &&
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(originalValue instanceof Date) &&
+                typeof originalValue === "object") {
+                return _wrapClient(originalValue, [runName, propKey.toString()].join("."), options);
+            }
+            else {
+                return Reflect.get(target, propKey, receiver);
+            }
+        },
+    });
+};
+/**
+ * Wrap an arbitrary SDK, enabling automatic LangSmith tracing.
+ * Method signatures are unchanged.
+ *
+ * Note that this will wrap and trace ALL SDK methods, not just
+ * LLM completion methods. If the passed SDK contains other methods,
+ * we recommend using the wrapped instance for LLM calls only.
+ * @param sdk An arbitrary SDK instance.
+ * @param options LangSmith options.
+ * @returns
+ */
+export const wrapSDK = (sdk, options) => {
+    return _wrapClient(sdk, options?.runName ?? sdk.constructor?.name, {
+        client: options?.client,
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -29,6 +29,10 @@
     "wrappers.js",
     "wrappers.d.ts",
     "wrappers.d.cts",
+    "wrappers/openai.cjs",
+    "wrappers/openai.js",
+    "wrappers/openai.d.ts",
+    "wrappers/openai.d.cts",
     "index.cjs",
     "index.js",
     "index.d.ts",
@@ -48,7 +52,8 @@
     "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",
-    "lint": "eslint 'src/**/*.{ts,tsx}' --quiet --fix",
+    "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}'",
     "format:check": "prettier --check 'src/**/*.{ts,tsx}'",
     "precommit": "lint-staged",
@@ -70,6 +75,13 @@
     "url": "https://github.com/langchain-ai/langsmith-sdk/issues"
   },
   "homepage": "https://github.com/langchain-ai/langsmith-sdk#readme",
+  "dependencies": {
+    "@types/uuid": "^9.0.1",
+    "commander": "^10.0.1",
+    "p-queue": "^6.6.2",
+    "p-retry": "4",
+    "uuid": "^9.0.0"
+  },
   "devDependencies": {
     "@babel/preset-env": "^7.22.4",
     "@jest/globals": "^29.5.0",
@@ -88,18 +100,19 @@
     "eslint-plugin-no-instanceof": "^1.0.1",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.5.0",
-    "openai": "^4.28.0",
+    "openai": "^4.38.5",
     "prettier": "^2.8.8",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4"
   },
-  "dependencies": {
-    "@types/uuid": "^9.0.1",
-    "commander": "^10.0.1",
-    "p-queue": "^6.6.2",
-    "p-retry": "4",
-    "uuid": "^9.0.0"
+  "peerDependencies": {
+    "openai": "*"
+  },
+  "peerDependenciesMeta": {
+    "openai": {
+      "optional": true
+    }
   },
   "lint-staged": {
     "**/*.{ts,tsx}": [
@@ -171,6 +184,15 @@
       "import": "./wrappers.js",
       "require": "./wrappers.cjs"
     },
+    "./wrappers/openai": {
+      "types": {
+        "import": "./wrappers/openai.d.ts",
+        "require": "./wrappers/openai.d.cts",
+        "default": "./wrappers/openai.d.ts"
+      },
+      "import": "./wrappers/openai.js",
+      "require": "./wrappers/openai.cjs"
+    },
     "./package.json": "./package.json"
   }
 }

package/wrappers/openai.cjs

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

package/wrappers/openai.d.cts

@@ -0,0 +1 @@
+export * from '../dist/wrappers/openai.js'

package/wrappers/openai.d.ts

@@ -0,0 +1 @@
+export * from '../dist/wrappers/openai.js'

package/wrappers/openai.js

@@ -0,0 +1 @@
+export * from '../dist/wrappers/openai.js'

package/wrappers.cjs

@@ -1 +1 @@
-module.exports = require('./dist/wrappers.cjs');
+module.exports = require('./dist/wrappers/index.cjs');

package/wrappers.d.cts

@@ -1 +1 @@
-export * from './dist/wrappers.js'
+export * from './dist/wrappers/index.js'

package/wrappers.d.ts

@@ -1 +1 @@
-export * from './dist/wrappers.js'
+export * from './dist/wrappers/index.js'

package/wrappers.js

@@ -1 +1 @@
-export * from './dist/wrappers.js'
+export * from './dist/wrappers/index.js'

package/dist/wrappers.cjs

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapSDK = exports.wrapOpenAI = void 0;
-const traceable_js_1 = require("./traceable.cjs");
-/**
- * Wraps an OpenAI client's completion methods, enabling automatic LangSmith
- * tracing. Method signatures are unchanged.
- * @param openai An OpenAI client instance.
- * @param options LangSmith options.
- * @returns
- */
-const wrapOpenAI = (openai, options) => {
-    openai.chat.completions.create = (0, traceable_js_1.traceable)(openai.chat.completions.create.bind(openai.chat.completions), Object.assign({ name: "ChatOpenAI", run_type: "llm" }, options?.client));
-    openai.completions.create = (0, traceable_js_1.traceable)(openai.completions.create.bind(openai.completions), Object.assign({ name: "OpenAI", run_type: "llm" }, options?.client));
-    return openai;
-};
-exports.wrapOpenAI = wrapOpenAI;
-const _wrapClient = (sdk, runName, options) => {
-    return new Proxy(sdk, {
-        get(target, propKey, receiver) {
-            const originalValue = target[propKey];
-            if (typeof originalValue === "function") {
-                return (0, traceable_js_1.traceable)(originalValue.bind(target), Object.assign({ name: [runName, propKey.toString()].join("."), run_type: "llm" }, options?.client));
-            }
-            else if (originalValue != null &&
-                !Array.isArray(originalValue) &&
-                // eslint-disable-next-line no-instanceof/no-instanceof
-                !(originalValue instanceof Date) &&
-                typeof originalValue === "object") {
-                return _wrapClient(originalValue, [runName, propKey.toString()].join("."), options);
-            }
-            else {
-                return Reflect.get(target, propKey, receiver);
-            }
-        },
-    });
-};
-/**
- * Wrap an arbitrary SDK, enabling automatic LangSmith tracing.
- * Method signatures are unchanged.
- *
- * Note that this will wrap and trace ALL SDK methods, not just
- * LLM completion methods. If the passed SDK contains other methods,
- * we recommend using the wrapped instance for LLM calls only.
- * @param sdk An arbitrary SDK instance.
- * @param options LangSmith options.
- * @returns
- */
-const wrapSDK = (sdk, options) => {
-    return _wrapClient(sdk, options?.runName ?? sdk.constructor?.name, {
-        client: options?.client,
-    });
-};
-exports.wrapSDK = wrapSDK;

package/dist/wrappers.d.ts

@@ -1,37 +0,0 @@
-import type { Client } from "./index.js";
-type OpenAIType = {
-    chat: {
-        completions: {
-            create: (...args: any[]) => any;
-        };
-    };
-    completions: {
-        create: (...args: any[]) => any;
-    };
-};
-/**
- * Wraps an OpenAI client's completion methods, enabling automatic LangSmith
- * tracing. Method signatures are unchanged.
- * @param openai An OpenAI client instance.
- * @param options LangSmith options.
- * @returns
- */
-export declare const wrapOpenAI: <T extends OpenAIType>(openai: T, options?: {
-    client?: Client;
-}) => T;
-/**
- * Wrap an arbitrary SDK, enabling automatic LangSmith tracing.
- * Method signatures are unchanged.
- *
- * Note that this will wrap and trace ALL SDK methods, not just
- * LLM completion methods. If the passed SDK contains other methods,
- * we recommend using the wrapped instance for LLM calls only.
- * @param sdk An arbitrary SDK instance.
- * @param options LangSmith options.
- * @returns
- */
-export declare const wrapSDK: <T extends object>(sdk: T, options?: {
-    client?: Client;
-    runName?: string;
-}) => T;
-export {};

package/dist/wrappers.js

@@ -1,49 +0,0 @@
-import { traceable } from "./traceable.js";
-/**
- * Wraps an OpenAI client's completion methods, enabling automatic LangSmith
- * tracing. Method signatures are unchanged.
- * @param openai An OpenAI client instance.
- * @param options LangSmith options.
- * @returns
- */
-export const wrapOpenAI = (openai, options) => {
-    openai.chat.completions.create = traceable(openai.chat.completions.create.bind(openai.chat.completions), Object.assign({ name: "ChatOpenAI", run_type: "llm" }, options?.client));
-    openai.completions.create = traceable(openai.completions.create.bind(openai.completions), Object.assign({ name: "OpenAI", run_type: "llm" }, options?.client));
-    return openai;
-};
-const _wrapClient = (sdk, runName, options) => {
-    return new Proxy(sdk, {
-        get(target, propKey, receiver) {
-            const originalValue = target[propKey];
-            if (typeof originalValue === "function") {
-                return traceable(originalValue.bind(target), Object.assign({ name: [runName, propKey.toString()].join("."), run_type: "llm" }, options?.client));
-            }
-            else if (originalValue != null &&
-                !Array.isArray(originalValue) &&
-                // eslint-disable-next-line no-instanceof/no-instanceof
-                !(originalValue instanceof Date) &&
-                typeof originalValue === "object") {
-                return _wrapClient(originalValue, [runName, propKey.toString()].join("."), options);
-            }
-            else {
-                return Reflect.get(target, propKey, receiver);
-            }
-        },
-    });
-};
-/**
- * Wrap an arbitrary SDK, enabling automatic LangSmith tracing.
- * Method signatures are unchanged.
- *
- * Note that this will wrap and trace ALL SDK methods, not just
- * LLM completion methods. If the passed SDK contains other methods,
- * we recommend using the wrapped instance for LLM calls only.
- * @param sdk An arbitrary SDK instance.
- * @param options LangSmith options.
- * @returns
- */
-export const wrapSDK = (sdk, options) => {
-    return _wrapClient(sdk, options?.runName ?? sdk.constructor?.name, {
-        client: options?.client,
-    });
-};