langsmith 0.1.14 → 0.1.19

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/evaluation.d.cts

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

package/index.d.cts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.14",
+  "version": "0.1.19",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -8,24 +8,35 @@
     "client.cjs",
     "client.js",
     "client.d.ts",
+    "client.d.cts",
     "run_trees.cjs",
     "run_trees.js",
     "run_trees.d.ts",
+    "run_trees.d.cts",
     "traceable.cjs",
     "traceable.js",
     "traceable.d.ts",
+    "traceable.d.cts",
     "evaluation.cjs",
     "evaluation.js",
     "evaluation.d.ts",
+    "evaluation.d.cts",
     "schemas.cjs",
     "schemas.js",
     "schemas.d.ts",
+    "schemas.d.cts",
     "wrappers.cjs",
     "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"
+    "index.d.ts",
+    "index.d.cts"
   ],
   "type": "module",
   "main": "./dist/index.js",
@@ -63,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",
@@ -81,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}": [
@@ -102,40 +121,77 @@
   },
   "exports": {
     ".": {
-      "types": "./index.d.ts",
+      "types": {
+        "import": "./index.d.ts",
+        "require": "./index.d.cts",
+        "default": "./index.d.ts"
+      },
       "import": "./index.js",
       "require": "./index.cjs"
     },
     "./client": {
-      "types": "./client.d.ts",
+      "types": {
+        "import": "./client.d.ts",
+        "require": "./client.d.cts",
+        "default": "./client.d.ts"
+      },
       "import": "./client.js",
       "require": "./client.cjs"
     },
     "./run_trees": {
-      "types": "./run_trees.d.ts",
+      "types": {
+        "import": "./run_trees.d.ts",
+        "require": "./run_trees.d.cts",
+        "default": "./run_trees.d.ts"
+      },
       "import": "./run_trees.js",
       "require": "./run_trees.cjs"
     },
     "./traceable": {
-      "types": "./traceable.d.ts",
+      "types": {
+        "import": "./traceable.d.ts",
+        "require": "./traceable.d.cts",
+        "default": "./traceable.d.ts"
+      },
       "import": "./traceable.js",
       "require": "./traceable.cjs"
     },
     "./evaluation": {
-      "types": "./evaluation.d.ts",
+      "types": {
+        "import": "./evaluation.d.ts",
+        "require": "./evaluation.d.cts",
+        "default": "./evaluation.d.ts"
+      },
       "import": "./evaluation.js",
       "require": "./evaluation.cjs"
     },
     "./schemas": {
-      "types": "./schemas.d.ts",
+      "types": {
+        "import": "./schemas.d.ts",
+        "require": "./schemas.d.cts",
+        "default": "./schemas.d.ts"
+      },
       "import": "./schemas.js",
       "require": "./schemas.cjs"
     },
     "./wrappers": {
-      "types": "./wrappers.d.ts",
+      "types": {
+        "import": "./wrappers.d.ts",
+        "require": "./wrappers.d.cts",
+        "default": "./wrappers.d.ts"
+      },
       "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/run_trees.d.cts

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

package/schemas.d.cts

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

package/traceable.d.cts

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