langsmith 0.1.40-rc.0 → 0.1.40

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.39";
+exports.__version__ = "0.1.40";

package/dist/index.d.ts

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

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

package/dist/traceable.cjs

@@ -192,7 +192,7 @@ const convertSerializableArg = (arg) => {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function traceable(wrappedFunc, config) {
-    const { aggregator, argsConfigPath, ...runTreeConfig } = config ?? {};
+    const { aggregator, argsConfigPath, __finalTracedIteratorKey, ...runTreeConfig } = config ?? {};
     const traceableFunc = (...args) => {
         let ensuredConfig;
         try {
@@ -294,6 +294,38 @@ function traceable(wrappedFunc, config) {
                 }
                 return chunks;
             }
+            function tapReadableStreamForTracing(stream, snapshot) {
+                const reader = stream.getReader();
+                let finished = false;
+                const chunks = [];
+                const tappedStream = new ReadableStream({
+                    async start(controller) {
+                        // eslint-disable-next-line no-constant-condition
+                        while (true) {
+                            const result = await (snapshot
+                                ? snapshot(() => reader.read())
+                                : reader.read());
+                            if (result.done) {
+                                finished = true;
+                                await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks)));
+                                await handleEnd();
+                                controller.close();
+                                break;
+                            }
+                            chunks.push(result.value);
+                            controller.enqueue(result.value);
+                        }
+                    },
+                    async cancel(reason) {
+                        if (!finished)
+                            await currentRunTree?.end(undefined, "Cancelled");
+                        await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks)));
+                        await handleEnd();
+                        return reader.cancel(reason);
+                    },
+                });
+                return tappedStream;
+            }
             async function* wrapAsyncIteratorForTracing(iterator, snapshot) {
                 let finished = false;
                 const chunks = [];
@@ -322,6 +354,9 @@ function traceable(wrappedFunc, config) {
                 }
             }
             function wrapAsyncGeneratorForTracing(iterable, snapshot) {
+                if ((0, asserts_js_1.isReadableStream)(iterable)) {
+                    return tapReadableStreamForTracing(iterable, snapshot);
+                }
                 const iterator = iterable[Symbol.asyncIterator]();
                 const wrappedIterator = wrapAsyncIteratorForTracing(iterator, snapshot);
                 iterable[Symbol.asyncIterator] = () => wrappedIterator;
@@ -362,6 +397,17 @@ function traceable(wrappedFunc, config) {
                 const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
                 return wrapAsyncGeneratorForTracing(returnValue, snapshot);
             }
+            if (!Array.isArray(returnValue) &&
+                typeof returnValue === "object" &&
+                returnValue != null &&
+                __finalTracedIteratorKey !== undefined &&
+                (0, asserts_js_1.isAsyncIterable)(returnValue[__finalTracedIteratorKey])) {
+                const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
+                return {
+                    ...returnValue,
+                    [__finalTracedIteratorKey]: wrapAsyncGeneratorForTracing(returnValue[__finalTracedIteratorKey], snapshot),
+                };
+            }
             const tracedPromise = new Promise((resolve, reject) => {
                 Promise.resolve(returnValue)
                     .then(async (rawOutput) => {
@@ -369,6 +415,17 @@ function traceable(wrappedFunc, config) {
                         const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
                         return resolve(wrapAsyncGeneratorForTracing(rawOutput, snapshot));
                     }
+                    if (!Array.isArray(rawOutput) &&
+                        typeof rawOutput === "object" &&
+                        rawOutput != null &&
+                        __finalTracedIteratorKey !== undefined &&
+                        (0, asserts_js_1.isAsyncIterable)(rawOutput[__finalTracedIteratorKey])) {
+                        const snapshot = node_async_hooks_1.AsyncLocalStorage.snapshot();
+                        return {
+                            ...rawOutput,
+                            [__finalTracedIteratorKey]: wrapAsyncGeneratorForTracing(rawOutput[__finalTracedIteratorKey], snapshot),
+                        };
+                    }
                     if ((0, asserts_js_1.isGenerator)(wrappedFunc) && (0, asserts_js_1.isIteratorLike)(rawOutput)) {
                         const chunks = gatherAll(rawOutput);
                         await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {

package/dist/traceable.d.ts

@@ -18,6 +18,7 @@ import { TraceableFunction } from "./singletons/types.js";
 export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: Partial<RunTreeConfig> & {
     aggregator?: (args: any[]) => any;
     argsConfigPath?: [number] | [number, string];
+    __finalTracedIteratorKey?: string;
     /**
      * Extract invocation parameters from the arguments of the traced function.
      * This is useful for LangSmith to properly track common metadata like

package/dist/traceable.js

@@ -189,7 +189,7 @@ const convertSerializableArg = (arg) => {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function traceable(wrappedFunc, config) {
-    const { aggregator, argsConfigPath, ...runTreeConfig } = config ?? {};
+    const { aggregator, argsConfigPath, __finalTracedIteratorKey, ...runTreeConfig } = config ?? {};
     const traceableFunc = (...args) => {
         let ensuredConfig;
         try {
@@ -291,6 +291,38 @@ export function traceable(wrappedFunc, config) {
                 }
                 return chunks;
             }
+            function tapReadableStreamForTracing(stream, snapshot) {
+                const reader = stream.getReader();
+                let finished = false;
+                const chunks = [];
+                const tappedStream = new ReadableStream({
+                    async start(controller) {
+                        // eslint-disable-next-line no-constant-condition
+                        while (true) {
+                            const result = await (snapshot
+                                ? snapshot(() => reader.read())
+                                : reader.read());
+                            if (result.done) {
+                                finished = true;
+                                await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks)));
+                                await handleEnd();
+                                controller.close();
+                                break;
+                            }
+                            chunks.push(result.value);
+                            controller.enqueue(result.value);
+                        }
+                    },
+                    async cancel(reason) {
+                        if (!finished)
+                            await currentRunTree?.end(undefined, "Cancelled");
+                        await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks)));
+                        await handleEnd();
+                        return reader.cancel(reason);
+                    },
+                });
+                return tappedStream;
+            }
             async function* wrapAsyncIteratorForTracing(iterator, snapshot) {
                 let finished = false;
                 const chunks = [];
@@ -319,6 +351,9 @@ export function traceable(wrappedFunc, config) {
                 }
             }
             function wrapAsyncGeneratorForTracing(iterable, snapshot) {
+                if (isReadableStream(iterable)) {
+                    return tapReadableStreamForTracing(iterable, snapshot);
+                }
                 const iterator = iterable[Symbol.asyncIterator]();
                 const wrappedIterator = wrapAsyncIteratorForTracing(iterator, snapshot);
                 iterable[Symbol.asyncIterator] = () => wrappedIterator;
@@ -359,6 +394,17 @@ export function traceable(wrappedFunc, config) {
                 const snapshot = AsyncLocalStorage.snapshot();
                 return wrapAsyncGeneratorForTracing(returnValue, snapshot);
             }
+            if (!Array.isArray(returnValue) &&
+                typeof returnValue === "object" &&
+                returnValue != null &&
+                __finalTracedIteratorKey !== undefined &&
+                isAsyncIterable(returnValue[__finalTracedIteratorKey])) {
+                const snapshot = AsyncLocalStorage.snapshot();
+                return {
+                    ...returnValue,
+                    [__finalTracedIteratorKey]: wrapAsyncGeneratorForTracing(returnValue[__finalTracedIteratorKey], snapshot),
+                };
+            }
             const tracedPromise = new Promise((resolve, reject) => {
                 Promise.resolve(returnValue)
                     .then(async (rawOutput) => {
@@ -366,6 +412,17 @@ export function traceable(wrappedFunc, config) {
                         const snapshot = AsyncLocalStorage.snapshot();
                         return resolve(wrapAsyncGeneratorForTracing(rawOutput, snapshot));
                     }
+                    if (!Array.isArray(rawOutput) &&
+                        typeof rawOutput === "object" &&
+                        rawOutput != null &&
+                        __finalTracedIteratorKey !== undefined &&
+                        isAsyncIterable(rawOutput[__finalTracedIteratorKey])) {
+                        const snapshot = AsyncLocalStorage.snapshot();
+                        return {
+                            ...rawOutput,
+                            [__finalTracedIteratorKey]: wrapAsyncGeneratorForTracing(rawOutput[__finalTracedIteratorKey], snapshot),
+                        };
+                    }
                     if (isGenerator(wrappedFunc) && isIteratorLike(rawOutput)) {
                         const chunks = gatherAll(rawOutput);
                         await currentRunTree?.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {

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,47 +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), {
-                    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
- */
-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);
-};
-exports.wrapSDK = wrapSDK;

package/dist/wrappers/openai.d.ts

@@ -63,22 +63,4 @@ type PatchedOpenAIClient<T extends OpenAIType> = T & {
  * ```
  */
 export declare const wrapOpenAI: <T extends OpenAIType>(openai: T, options?: Partial<RunTreeConfig>) => PatchedOpenAIClient<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/openai.js

@@ -187,46 +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), {
-                    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/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.40-rc.0",
+  "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",
@@ -101,10 +105,10 @@
     "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.10",
     "@langchain/core": "^0.2.17",
     "@langchain/langgraph": "^0.0.29",
     "@langchain/openai": "^0.2.5",
@@ -112,6 +116,7 @@
     "@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",
@@ -121,11 +126,13 @@
     "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": {
     "@langchain/core": "*",
@@ -249,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'