langsmith 0.1.18 → 0.1.19

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.19";

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.19";

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.19";

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

@@ -24,12 +24,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])) {
@@ -79,7 +80,26 @@ function traceable(wrappedFunc, config) {
                                 chunks.push(chunk);
                                 yield chunk;
                             }
-                            await currentRunTree.end({ outputs: chunks });
+                            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());
@@ -112,7 +132,7 @@ function traceable(wrappedFunc, config) {
         });
     };
     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

@@ -21,12 +21,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])) {
@@ -76,7 +77,26 @@ export function traceable(wrappedFunc, config) {
                                 chunks.push(chunk);
                                 yield chunk;
                             }
-                            await currentRunTree.end({ outputs: chunks });
+                            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());
@@ -109,7 +129,7 @@ export function traceable(wrappedFunc, config) {
         });
     };
     Object.defineProperty(traceableFunc, "langsmith:traceable", {
-        value: config,
+        value: runTreeConfig,
     });
     return traceableFunc;
 }

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.19",
   "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",
@@ -70,6 +74,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 +99,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 +183,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,
-    });
-};