langsmith 0.1.39 → 0.1.40

package/dist/utils/prompts.js

@@ -0,0 +1,33 @@
+import { parse as parseVersion } from "semver";
+export function isVersionGreaterOrEqual(current_version, target_version) {
+    const current = parseVersion(current_version);
+    const target = parseVersion(target_version);
+    if (!current || !target) {
+        throw new Error("Invalid version format.");
+    }
+    return current.compare(target) >= 0;
+}
+export function parsePromptIdentifier(identifier) {
+    if (!identifier ||
+        identifier.split("/").length > 2 ||
+        identifier.startsWith("/") ||
+        identifier.endsWith("/") ||
+        identifier.split(":").length > 2) {
+        throw new Error(`Invalid identifier format: ${identifier}`);
+    }
+    const [ownerNamePart, commitPart] = identifier.split(":");
+    const commit = commitPart || "latest";
+    if (ownerNamePart.includes("/")) {
+        const [owner, name] = ownerNamePart.split("/", 2);
+        if (!owner || !name) {
+            throw new Error(`Invalid identifier format: ${identifier}`);
+        }
+        return [owner, name, commit];
+    }
+    else {
+        if (!ownerNamePart) {
+            throw new Error(`Invalid identifier format: ${identifier}`);
+        }
+        return ["-", ownerNamePart, commit];
+    }
+}

package/dist/wrappers/generic.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapSDK = exports._wrapClient = void 0;
+const traceable_js_1 = require("../traceable.cjs");
+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), {
+                    run_type: "llm",
+                    ...options,
+                    name: [runName, propKey.toString()].join("."),
+                });
+            }
+            else if (originalValue != null &&
+                !Array.isArray(originalValue) &&
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(originalValue instanceof Date) &&
+                typeof originalValue === "object") {
+                return (0, exports._wrapClient)(originalValue, [runName, propKey.toString()].join("."), options);
+            }
+            else {
+                return Reflect.get(target, propKey, receiver);
+            }
+        },
+    });
+};
+exports._wrapClient = _wrapClient;
+/**
+ * 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) => {
+    const traceableOptions = options ? { ...options } : undefined;
+    if (traceableOptions != null) {
+        delete traceableOptions.runName;
+        delete traceableOptions.name;
+    }
+    return (0, exports._wrapClient)(sdk, options?.name ?? options?.runName ?? sdk.constructor?.name, traceableOptions);
+};
+exports.wrapSDK = wrapSDK;

package/dist/wrappers/generic.d.ts

@@ -0,0 +1,21 @@
+import type { RunTreeConfig } from "../index.js";
+export declare const _wrapClient: <T extends object>(sdk: T, runName: string, options?: Omit<RunTreeConfig, "name">) => T;
+type WrapSDKOptions = Partial<RunTreeConfig & {
+    /**
+     * @deprecated Use `name` instead.
+     */
+    runName: string;
+}>;
+/**
+ * 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?: WrapSDKOptions) => T;
+export {};

package/dist/wrappers/generic.js

@@ -0,0 +1,44 @@
+import { traceable } from "../traceable.js";
+export 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), {
+                    run_type: "llm",
+                    ...options,
+                    name: [runName, propKey.toString()].join("."),
+                });
+            }
+            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) => {
+    const traceableOptions = options ? { ...options } : undefined;
+    if (traceableOptions != null) {
+        delete traceableOptions.runName;
+        delete traceableOptions.name;
+    }
+    return _wrapClient(sdk, options?.name ?? options?.runName ?? sdk.constructor?.name, traceableOptions);
+};

package/dist/wrappers/index.cjs

@@ -14,4 +14,7 @@ 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 });
+exports.wrapSDK = void 0;
 __exportStar(require("./openai.cjs"), exports);
+var generic_js_1 = require("./generic.cjs");
+Object.defineProperty(exports, "wrapSDK", { enumerable: true, get: function () { return generic_js_1.wrapSDK; } });

package/dist/wrappers/index.d.ts

@@ -1 +1,2 @@
 export * from "./openai.js";
+export { wrapSDK } from "./generic.js";

package/dist/wrappers/index.js

@@ -1 +1,2 @@
 export * from "./openai.js";
+export { wrapSDK } from "./generic.js";

package/dist/wrappers/openai.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapSDK = exports.wrapOpenAI = void 0;
+exports.wrapOpenAI = void 0;
 const traceable_js_1 = require("../traceable.cjs");
 function _combineChatCompletionChoices(choices
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -191,40 +191,3 @@ const wrapOpenAI = (openai, options) => {
     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));
-            }
-            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

@@ -1,6 +1,6 @@
 import { OpenAI } from "openai";
 import type { APIPromise } from "openai/core";
-import type { Client, RunTreeConfig } from "../index.js";
+import type { RunTreeConfig } from "../index.js";
 type OpenAIType = {
     chat: {
         completions: {
@@ -63,19 +63,4 @@ type PatchedOpenAIClient<T extends OpenAIType> = T & {
  * ```
  */
 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

@@ -187,39 +187,3 @@ export const wrapOpenAI = (openai, options) => {
     });
     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));
-            }
-            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/dist/wrappers/vercel.cjs

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapAISDKModel = void 0;
+const traceable_js_1 = require("../traceable.cjs");
+const generic_js_1 = require("./generic.cjs");
+/**
+ * Wrap a Vercel AI SDK model, enabling automatic LangSmith tracing.
+ * After wrapping a model, you can use it with the Vercel AI SDK Core
+ * methods as normal.
+ *
+ * @example
+ * ```ts
+ * import { anthropic } from "@ai-sdk/anthropic";
+ * import { streamText } from "ai";
+ * import { wrapAISDKModel } from "langsmith/wrappers/vercel";
+ *
+ * const anthropicModel = anthropic("claude-3-haiku-20240307");
+ *
+ * const modelWithTracing = wrapAISDKModel(anthropicModel);
+ *
+ * const { textStream } = await streamText({
+ *   model: modelWithTracing,
+ *   prompt: "Write a vegetarian lasagna recipe for 4 people.",
+ * });
+ *
+ * for await (const chunk of textStream) {
+ *   console.log(chunk);
+ * }
+ * ```
+ * @param model An AI SDK model instance.
+ * @param options LangSmith options.
+ * @returns
+ */
+const wrapAISDKModel = (model, options) => {
+    if (!("doStream" in model) ||
+        typeof model.doStream !== "function" ||
+        !("doGenerate" in model) ||
+        typeof model.doGenerate !== "function") {
+        throw new Error(`Received invalid input. This version of wrapAISDKModel only supports Vercel LanguageModelV1 instances.`);
+    }
+    const runName = options?.name ?? model.constructor?.name;
+    return new Proxy(model, {
+        get(target, propKey, receiver) {
+            const originalValue = target[propKey];
+            if (typeof originalValue === "function") {
+                let __finalTracedIteratorKey;
+                let aggregator;
+                if (propKey === "doStream") {
+                    __finalTracedIteratorKey = "stream";
+                    aggregator = (chunks) => {
+                        return chunks.reduce((aggregated, chunk) => {
+                            if (chunk.type === "text-delta") {
+                                return {
+                                    ...aggregated,
+                                    text: aggregated.text + chunk.textDelta,
+                                };
+                            }
+                            else if (chunk.type === "tool-call") {
+                                return {
+                                    ...aggregated,
+                                    ...chunk,
+                                };
+                            }
+                            else if (chunk.type === "finish") {
+                                return {
+                                    ...aggregated,
+                                    usage: chunk.usage,
+                                    finishReason: chunk.finishReason,
+                                };
+                            }
+                            else {
+                                return aggregated;
+                            }
+                        }, {
+                            text: "",
+                        });
+                    };
+                }
+                return (0, traceable_js_1.traceable)(originalValue.bind(target), {
+                    run_type: "llm",
+                    name: runName,
+                    ...options,
+                    __finalTracedIteratorKey,
+                    aggregator,
+                });
+            }
+            else if (originalValue != null &&
+                !Array.isArray(originalValue) &&
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(originalValue instanceof Date) &&
+                typeof originalValue === "object") {
+                return (0, generic_js_1._wrapClient)(originalValue, [runName, propKey.toString()].join("."), options);
+            }
+            else {
+                return Reflect.get(target, propKey, receiver);
+            }
+        },
+    });
+};
+exports.wrapAISDKModel = wrapAISDKModel;

package/dist/wrappers/vercel.d.ts

@@ -0,0 +1,30 @@
+import type { RunTreeConfig } from "../index.js";
+/**
+ * Wrap a Vercel AI SDK model, enabling automatic LangSmith tracing.
+ * After wrapping a model, you can use it with the Vercel AI SDK Core
+ * methods as normal.
+ *
+ * @example
+ * ```ts
+ * import { anthropic } from "@ai-sdk/anthropic";
+ * import { streamText } from "ai";
+ * import { wrapAISDKModel } from "langsmith/wrappers/vercel";
+ *
+ * const anthropicModel = anthropic("claude-3-haiku-20240307");
+ *
+ * const modelWithTracing = wrapAISDKModel(anthropicModel);
+ *
+ * const { textStream } = await streamText({
+ *   model: modelWithTracing,
+ *   prompt: "Write a vegetarian lasagna recipe for 4 people.",
+ * });
+ *
+ * for await (const chunk of textStream) {
+ *   console.log(chunk);
+ * }
+ * ```
+ * @param model An AI SDK model instance.
+ * @param options LangSmith options.
+ * @returns
+ */
+export declare const wrapAISDKModel: <T extends object>(model: T, options?: Partial<RunTreeConfig>) => T;

package/dist/wrappers/vercel.js

@@ -0,0 +1,96 @@
+import { traceable } from "../traceable.js";
+import { _wrapClient } from "./generic.js";
+/**
+ * Wrap a Vercel AI SDK model, enabling automatic LangSmith tracing.
+ * After wrapping a model, you can use it with the Vercel AI SDK Core
+ * methods as normal.
+ *
+ * @example
+ * ```ts
+ * import { anthropic } from "@ai-sdk/anthropic";
+ * import { streamText } from "ai";
+ * import { wrapAISDKModel } from "langsmith/wrappers/vercel";
+ *
+ * const anthropicModel = anthropic("claude-3-haiku-20240307");
+ *
+ * const modelWithTracing = wrapAISDKModel(anthropicModel);
+ *
+ * const { textStream } = await streamText({
+ *   model: modelWithTracing,
+ *   prompt: "Write a vegetarian lasagna recipe for 4 people.",
+ * });
+ *
+ * for await (const chunk of textStream) {
+ *   console.log(chunk);
+ * }
+ * ```
+ * @param model An AI SDK model instance.
+ * @param options LangSmith options.
+ * @returns
+ */
+export const wrapAISDKModel = (model, options) => {
+    if (!("doStream" in model) ||
+        typeof model.doStream !== "function" ||
+        !("doGenerate" in model) ||
+        typeof model.doGenerate !== "function") {
+        throw new Error(`Received invalid input. This version of wrapAISDKModel only supports Vercel LanguageModelV1 instances.`);
+    }
+    const runName = options?.name ?? model.constructor?.name;
+    return new Proxy(model, {
+        get(target, propKey, receiver) {
+            const originalValue = target[propKey];
+            if (typeof originalValue === "function") {
+                let __finalTracedIteratorKey;
+                let aggregator;
+                if (propKey === "doStream") {
+                    __finalTracedIteratorKey = "stream";
+                    aggregator = (chunks) => {
+                        return chunks.reduce((aggregated, chunk) => {
+                            if (chunk.type === "text-delta") {
+                                return {
+                                    ...aggregated,
+                                    text: aggregated.text + chunk.textDelta,
+                                };
+                            }
+                            else if (chunk.type === "tool-call") {
+                                return {
+                                    ...aggregated,
+                                    ...chunk,
+                                };
+                            }
+                            else if (chunk.type === "finish") {
+                                return {
+                                    ...aggregated,
+                                    usage: chunk.usage,
+                                    finishReason: chunk.finishReason,
+                                };
+                            }
+                            else {
+                                return aggregated;
+                            }
+                        }, {
+                            text: "",
+                        });
+                    };
+                }
+                return traceable(originalValue.bind(target), {
+                    run_type: "llm",
+                    name: runName,
+                    ...options,
+                    __finalTracedIteratorKey,
+                    aggregator,
+                });
+            }
+            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);
+            }
+        },
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -45,6 +45,10 @@
     "wrappers/openai.js",
     "wrappers/openai.d.ts",
     "wrappers/openai.d.cts",
+    "wrappers/vercel.cjs",
+    "wrappers/vercel.js",
+    "wrappers/vercel.d.ts",
+    "wrappers/vercel.d.cts",
     "singletons/traceable.cjs",
     "singletons/traceable.js",
     "singletons/traceable.d.ts",
@@ -97,19 +101,22 @@
     "commander": "^10.0.1",
     "p-queue": "^6.6.2",
     "p-retry": "4",
+    "semver": "^7.6.3",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
+    "@ai-sdk/openai": "^0.0.40",
     "@babel/preset-env": "^7.22.4",
     "@faker-js/faker": "^8.4.1",
     "@jest/globals": "^29.5.0",
-    "langchain": "^0.2.0",
-    "@langchain/core": "^0.2.0",
-    "@langchain/langgraph": "^0.0.19",
+    "@langchain/core": "^0.2.17",
+    "@langchain/langgraph": "^0.0.29",
+    "@langchain/openai": "^0.2.5",
     "@tsconfig/recommended": "^1.0.2",
     "@types/jest": "^29.5.1",
     "@typescript-eslint/eslint-plugin": "^5.59.8",
     "@typescript-eslint/parser": "^5.59.8",
+    "ai": "^3.2.37",
     "babel-jest": "^29.5.0",
     "cross-env": "^7.0.3",
     "dotenv": "^16.1.3",
@@ -119,16 +126,18 @@
     "eslint-plugin-no-instanceof": "^1.0.1",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.5.0",
+    "langchain": "^0.2.10",
     "openai": "^4.38.5",
     "prettier": "^2.8.8",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "zod": "^3.23.8"
   },
   "peerDependencies": {
-    "openai": "*",
+    "@langchain/core": "*",
     "langchain": "*",
-    "@langchain/core": "*"
+    "openai": "*"
   },
   "peerDependenciesMeta": {
     "openai": {
@@ -141,9 +150,6 @@
       "optional": true
     }
   },
-  "resolutions": {
-    "@langchain/core": "0.2.0"
-  },
   "lint-staged": {
     "**/*.{ts,tsx}": [
       "prettier --write --ignore-unknown",
@@ -250,6 +256,15 @@
       "import": "./wrappers/openai.js",
       "require": "./wrappers/openai.cjs"
     },
+    "./wrappers/vercel": {
+      "types": {
+        "import": "./wrappers/vercel.d.ts",
+        "require": "./wrappers/vercel.d.cts",
+        "default": "./wrappers/vercel.d.ts"
+      },
+      "import": "./wrappers/vercel.js",
+      "require": "./wrappers/vercel.cjs"
+    },
     "./singletons/traceable": {
       "types": {
         "import": "./singletons/traceable.d.ts",

package/wrappers/vercel.cjs

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

package/wrappers/vercel.d.cts

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

package/wrappers/vercel.d.ts

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

package/wrappers/vercel.js

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