langsmith 0.3.56 → 0.3.57-rc.1

package/dist/experimental/vercel/index.cjs

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapAISDK = void 0;
+/* eslint-disable import/no-extraneous-dependencies */
+const middleware_js_1 = require("./middleware.cjs");
+const traceable_js_1 = require("../../traceable.cjs");
+const _wrapTools = (tools) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const wrappedTools = {};
+    if (tools) {
+        for (const [key, tool] of Object.entries(tools)) {
+            wrappedTools[key] = tool;
+            if (tool != null &&
+                typeof tool === "object" &&
+                "execute" in tool &&
+                typeof tool.execute === "function") {
+                wrappedTools[key].execute = (0, traceable_js_1.traceable)(tool.execute.bind(tool), {
+                    name: key,
+                    run_type: "tool",
+                });
+            }
+        }
+    }
+    return wrappedTools;
+};
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const _getModelDisplayName = (model) => {
+    if (typeof model === "string") {
+        return model;
+    }
+    if (model.config != null &&
+        typeof model.config === "object" &&
+        typeof model.config.provider === "string") {
+        return model.config.provider;
+    }
+    return model.modelId ?? "unknown";
+};
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const _getModelId = (model) => {
+    if (typeof model === "string") {
+        return model;
+    }
+    return typeof model.modelId === "string" ? model.modelId : undefined;
+};
+const _formatTracedInputs = (params) => {
+    const { prompt, messages, model, tools, ...rest } = params;
+    if (Array.isArray(prompt)) {
+        return { ...rest, messages: prompt.map(middleware_js_1.populateToolCallsForTracing) };
+    }
+    else if (Array.isArray(messages)) {
+        return { ...rest, messages: messages.map(middleware_js_1.populateToolCallsForTracing) };
+    }
+    else {
+        return { ...rest, prompt, messages };
+    }
+};
+/**
+ * Wraps Vercel AI SDK 5 functions with LangSmith tracing capabilities.
+ *
+ * @param methods - Object containing AI SDK methods to wrap
+ * @param methods.wrapLanguageModel - AI SDK's wrapLanguageModel function
+ * @param methods.generateText - AI SDK's generateText function
+ * @param methods.streamText - AI SDK's streamText function
+ * @param methods.streamObject - AI SDK's streamObject function
+ * @param methods.generateObject - AI SDK's generateObject function
+ *
+ * @returns Object containing wrapped versions of the AI SDK functions with LangSmith tracing
+ * @returns returns.generateText - Wrapped generateText function that traces calls to LangSmith
+ * @returns returns.generateObject - Wrapped generateObject function that traces calls to LangSmith
+ * @returns returns.streamText - Wrapped streamText function that traces calls to LangSmith
+ * @returns returns.streamObject - Wrapped streamObject function that traces calls to LangSmith
+ */
+const wrapAISDK = ({ wrapLanguageModel, generateText, streamText, streamObject, generateObject, }, lsConfig) => {
+    /**
+     * Wrapped version of AI SDK 5's generateText with LangSmith tracing.
+     *
+     * This function has the same signature and behavior as the original generateText,
+     * but adds automatic tracing to LangSmith for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { generateText } = wrapAISDK(ai);
+     * const { text } = await generateText(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-text} Original generateText documentation
+     * @param params - Same parameters as the original generateText function
+     * @returns Promise resolving to the same result as generateText, with tracing applied
+     */
+    const wrappedGenerateText = async (params) => {
+        const traceableFunc = (0, traceable_js_1.traceable)(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: (0, middleware_js_1.LangSmithMiddleware)({
+                    name: _getModelDisplayName(params.model),
+                    modelId: params.model.modelId,
+                }),
+            });
+            return generateText({
+                ...params,
+                tools: _wrapTools(params.tools),
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.generateText",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+            processOutputs: (outputs) => {
+                if (outputs.outputs == null || typeof outputs.outputs !== "object") {
+                    return outputs;
+                }
+                const { steps } = outputs.outputs;
+                if (Array.isArray(steps)) {
+                    const lastStep = steps.at(-1);
+                    if (lastStep == null || typeof lastStep !== "object") {
+                        return outputs;
+                    }
+                    const { content } = lastStep;
+                    return (0, middleware_js_1.populateToolCallsForTracing)({
+                        content,
+                        role: "assistant",
+                    });
+                }
+                else {
+                    return outputs;
+                }
+            },
+        });
+        return traceableFunc(params);
+    };
+    /**
+     * Wrapped version of AI SDK 5's generateObject with LangSmith tracing.
+     *
+     * This function has the same signature and behavior as the original generateObject,
+     * but adds automatic tracing to LangSmith for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { generateObject } = wrapAISDK(ai);
+     * const { object } = await generateObject(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-structured-data} Original generateObject documentation
+     * @param params - Same parameters as the original generateObject function
+     * @returns Promise resolving to the same result as generateObject, with tracing applied
+     */
+    const wrappedGenerateObject = async (params) => {
+        const traceableFunc = (0, traceable_js_1.traceable)(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: (0, middleware_js_1.LangSmithMiddleware)({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                }),
+            });
+            return generateObject({
+                ...params,
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.generateObject",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+            processOutputs: (outputs) => {
+                if (outputs.outputs == null || typeof outputs.outputs !== "object") {
+                    return outputs;
+                }
+                return outputs.outputs.object ?? outputs;
+            },
+        });
+        return traceableFunc(params);
+    };
+    /**
+     * Wrapped version of AI SDK 5's streamText with LangSmith tracing.
+     *
+     * Must be called with `await`, but otherwise behaves the same as the
+     * original streamText and adds adds automatic tracing to LangSmith
+     * for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { streamText } = wrapAISDK(ai);
+     * const { textStream } = await streamText(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-text} Original streamText documentation
+     * @param params - Same parameters as the original streamText function
+     * @returns Promise resolving to the same result as streamText, with tracing applied
+     */
+    const wrappedStreamText = async (params) => {
+        const traceableFunc = (0, traceable_js_1.traceable)(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: (0, middleware_js_1.LangSmithMiddleware)({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                }),
+            });
+            return streamText({
+                ...params,
+                tools: _wrapTools(params.tools),
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.streamText",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+        });
+        return traceableFunc(params);
+    };
+    /**
+     * Wrapped version of AI SDK 5's streamObject with LangSmith tracing.
+     *
+     * Must be called with `await`, but otherwise behaves the same as the
+     * original streamObject and adds adds automatic tracing to LangSmith
+     * for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { streamObject } = wrapAISDK(ai);
+     * const { partialObjectStream } = await streamObject(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-structured-data} Original streamObject documentation
+     * @param params - Same parameters as the original streamObject function
+     * @returns Promise resolving to the same result as streamObject, with tracing applied
+     */
+    const wrappedStreamObject = async (params) => {
+        const traceableFunc = (0, traceable_js_1.traceable)(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: (0, middleware_js_1.LangSmithMiddleware)({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                }),
+            });
+            return streamObject({
+                ...params,
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.streamObject",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+        });
+        return traceableFunc(params);
+    };
+    return {
+        generateText: wrappedGenerateText,
+        generateObject: wrappedGenerateObject,
+        streamText: wrappedStreamText,
+        streamObject: wrappedStreamObject,
+    };
+};
+exports.wrapAISDK = wrapAISDK;

package/dist/experimental/vercel/index.d.ts

@@ -0,0 +1,30 @@
+import { RunTreeConfig } from "../../run_trees.js";
+/**
+ * Wraps Vercel AI SDK 5 functions with LangSmith tracing capabilities.
+ *
+ * @param methods - Object containing AI SDK methods to wrap
+ * @param methods.wrapLanguageModel - AI SDK's wrapLanguageModel function
+ * @param methods.generateText - AI SDK's generateText function
+ * @param methods.streamText - AI SDK's streamText function
+ * @param methods.streamObject - AI SDK's streamObject function
+ * @param methods.generateObject - AI SDK's generateObject function
+ *
+ * @returns Object containing wrapped versions of the AI SDK functions with LangSmith tracing
+ * @returns returns.generateText - Wrapped generateText function that traces calls to LangSmith
+ * @returns returns.generateObject - Wrapped generateObject function that traces calls to LangSmith
+ * @returns returns.streamText - Wrapped streamText function that traces calls to LangSmith
+ * @returns returns.streamObject - Wrapped streamObject function that traces calls to LangSmith
+ */
+declare const wrapAISDK: <WrapLanguageModelType extends (...args: any[]) => any, GenerateTextType extends (...args: any[]) => any, StreamTextType extends (...args: any[]) => any, StreamObjectType extends (...args: any[]) => any, GenerateObjectType extends (...args: any[]) => any>({ wrapLanguageModel, generateText, streamText, streamObject, generateObject, }: {
+    wrapLanguageModel: WrapLanguageModelType;
+    generateText: GenerateTextType;
+    streamText: StreamTextType;
+    streamObject: StreamObjectType;
+    generateObject: GenerateObjectType;
+}, lsConfig?: Partial<Omit<RunTreeConfig, "inputs" | "outputs">>) => {
+    generateText: (params: Parameters<GenerateTextType>[0]) => Promise<ReturnType<GenerateTextType>>;
+    generateObject: (params: Parameters<GenerateObjectType>[0]) => Promise<ReturnType<GenerateObjectType>>;
+    streamText: (params: Parameters<StreamTextType>[0]) => Promise<ReturnType<StreamTextType>>;
+    streamObject: (params: Parameters<StreamObjectType>[0]) => Promise<ReturnType<StreamObjectType>>;
+};
+export { wrapAISDK };

package/dist/experimental/vercel/index.js

@@ -0,0 +1,276 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { LangSmithMiddleware, populateToolCallsForTracing, } from "./middleware.js";
+import { traceable } from "../../traceable.js";
+const _wrapTools = (tools) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const wrappedTools = {};
+    if (tools) {
+        for (const [key, tool] of Object.entries(tools)) {
+            wrappedTools[key] = tool;
+            if (tool != null &&
+                typeof tool === "object" &&
+                "execute" in tool &&
+                typeof tool.execute === "function") {
+                wrappedTools[key].execute = traceable(tool.execute.bind(tool), {
+                    name: key,
+                    run_type: "tool",
+                });
+            }
+        }
+    }
+    return wrappedTools;
+};
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const _getModelDisplayName = (model) => {
+    if (typeof model === "string") {
+        return model;
+    }
+    if (model.config != null &&
+        typeof model.config === "object" &&
+        typeof model.config.provider === "string") {
+        return model.config.provider;
+    }
+    return model.modelId ?? "unknown";
+};
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const _getModelId = (model) => {
+    if (typeof model === "string") {
+        return model;
+    }
+    return typeof model.modelId === "string" ? model.modelId : undefined;
+};
+const _formatTracedInputs = (params) => {
+    const { prompt, messages, model, tools, ...rest } = params;
+    if (Array.isArray(prompt)) {
+        return { ...rest, messages: prompt.map(populateToolCallsForTracing) };
+    }
+    else if (Array.isArray(messages)) {
+        return { ...rest, messages: messages.map(populateToolCallsForTracing) };
+    }
+    else {
+        return { ...rest, prompt, messages };
+    }
+};
+/**
+ * Wraps Vercel AI SDK 5 functions with LangSmith tracing capabilities.
+ *
+ * @param methods - Object containing AI SDK methods to wrap
+ * @param methods.wrapLanguageModel - AI SDK's wrapLanguageModel function
+ * @param methods.generateText - AI SDK's generateText function
+ * @param methods.streamText - AI SDK's streamText function
+ * @param methods.streamObject - AI SDK's streamObject function
+ * @param methods.generateObject - AI SDK's generateObject function
+ *
+ * @returns Object containing wrapped versions of the AI SDK functions with LangSmith tracing
+ * @returns returns.generateText - Wrapped generateText function that traces calls to LangSmith
+ * @returns returns.generateObject - Wrapped generateObject function that traces calls to LangSmith
+ * @returns returns.streamText - Wrapped streamText function that traces calls to LangSmith
+ * @returns returns.streamObject - Wrapped streamObject function that traces calls to LangSmith
+ */
+const wrapAISDK = ({ wrapLanguageModel, generateText, streamText, streamObject, generateObject, }, lsConfig) => {
+    /**
+     * Wrapped version of AI SDK 5's generateText with LangSmith tracing.
+     *
+     * This function has the same signature and behavior as the original generateText,
+     * but adds automatic tracing to LangSmith for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { generateText } = wrapAISDK(ai);
+     * const { text } = await generateText(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-text} Original generateText documentation
+     * @param params - Same parameters as the original generateText function
+     * @returns Promise resolving to the same result as generateText, with tracing applied
+     */
+    const wrappedGenerateText = async (params) => {
+        const traceableFunc = traceable(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: params.model.modelId,
+                }),
+            });
+            return generateText({
+                ...params,
+                tools: _wrapTools(params.tools),
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.generateText",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+            processOutputs: (outputs) => {
+                if (outputs.outputs == null || typeof outputs.outputs !== "object") {
+                    return outputs;
+                }
+                const { steps } = outputs.outputs;
+                if (Array.isArray(steps)) {
+                    const lastStep = steps.at(-1);
+                    if (lastStep == null || typeof lastStep !== "object") {
+                        return outputs;
+                    }
+                    const { content } = lastStep;
+                    return populateToolCallsForTracing({
+                        content,
+                        role: "assistant",
+                    });
+                }
+                else {
+                    return outputs;
+                }
+            },
+        });
+        return traceableFunc(params);
+    };
+    /**
+     * Wrapped version of AI SDK 5's generateObject with LangSmith tracing.
+     *
+     * This function has the same signature and behavior as the original generateObject,
+     * but adds automatic tracing to LangSmith for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { generateObject } = wrapAISDK(ai);
+     * const { object } = await generateObject(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-structured-data} Original generateObject documentation
+     * @param params - Same parameters as the original generateObject function
+     * @returns Promise resolving to the same result as generateObject, with tracing applied
+     */
+    const wrappedGenerateObject = async (params) => {
+        const traceableFunc = traceable(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                }),
+            });
+            return generateObject({
+                ...params,
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.generateObject",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+            processOutputs: (outputs) => {
+                if (outputs.outputs == null || typeof outputs.outputs !== "object") {
+                    return outputs;
+                }
+                return outputs.outputs.object ?? outputs;
+            },
+        });
+        return traceableFunc(params);
+    };
+    /**
+     * Wrapped version of AI SDK 5's streamText with LangSmith tracing.
+     *
+     * Must be called with `await`, but otherwise behaves the same as the
+     * original streamText and adds adds automatic tracing to LangSmith
+     * for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { streamText } = wrapAISDK(ai);
+     * const { textStream } = await streamText(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-text} Original streamText documentation
+     * @param params - Same parameters as the original streamText function
+     * @returns Promise resolving to the same result as streamText, with tracing applied
+     */
+    const wrappedStreamText = async (params) => {
+        const traceableFunc = traceable(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                }),
+            });
+            return streamText({
+                ...params,
+                tools: _wrapTools(params.tools),
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.streamText",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+        });
+        return traceableFunc(params);
+    };
+    /**
+     * Wrapped version of AI SDK 5's streamObject with LangSmith tracing.
+     *
+     * Must be called with `await`, but otherwise behaves the same as the
+     * original streamObject and adds adds automatic tracing to LangSmith
+     * for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { streamObject } = wrapAISDK(ai);
+     * const { partialObjectStream } = await streamObject(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-structured-data} Original streamObject documentation
+     * @param params - Same parameters as the original streamObject function
+     * @returns Promise resolving to the same result as streamObject, with tracing applied
+     */
+    const wrappedStreamObject = async (params) => {
+        const traceableFunc = traceable(async (params) => {
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                }),
+            });
+            return streamObject({
+                ...params,
+                model: wrappedModel,
+            });
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...lsConfig,
+            metadata: {
+                ai_sdk_method: "ai.streamObject",
+                ...lsConfig?.metadata,
+            },
+            processInputs: (inputs) => _formatTracedInputs(inputs),
+        });
+        return traceableFunc(params);
+    };
+    return {
+        generateText: wrappedGenerateText,
+        generateObject: wrappedGenerateObject,
+        streamText: wrappedStreamText,
+        streamObject: wrappedStreamObject,
+    };
+};
+export { wrapAISDK };

package/dist/experimental/vercel/middleware.cjs

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateToolCallsForTracing = void 0;
+exports.LangSmithMiddleware = LangSmithMiddleware;
+const traceable_js_1 = require("../../traceable.cjs");
+const vercel_js_1 = require("../../utils/vercel.cjs");
+const populateToolCallsForTracing = (message) => {
+    const formattedMessage = {
+        ...message,
+    };
+    if (formattedMessage.role !== "assistant") {
+        return formattedMessage;
+    }
+    if (Array.isArray(formattedMessage.content)) {
+        const toolCalls = formattedMessage.content
+            .filter((block) => {
+            return (block != null &&
+                typeof block === "object" &&
+                block.type == "tool-call");
+        })
+            .map((block) => {
+            return {
+                id: block.toolCallId,
+                type: "function",
+                function: {
+                    name: block.toolName,
+                    arguments: typeof block.input !== "string"
+                        ? JSON.stringify(block.input)
+                        : block.input,
+                },
+            };
+        });
+        if (toolCalls.length > 0) {
+            formattedMessage.tool_calls = toolCalls;
+        }
+    }
+    return formattedMessage;
+};
+exports.populateToolCallsForTracing = populateToolCallsForTracing;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const _formatTracedInputs = (params) => {
+    const { prompt, ...rest } = params;
+    if (prompt == null) {
+        return params;
+    }
+    if (Array.isArray(prompt)) {
+        return { ...rest, messages: prompt.map(exports.populateToolCallsForTracing) };
+    }
+    return rest;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const _formatTracedOutputs = (outputs) => {
+    const { request, response, ...rest } = outputs;
+    const formattedOutputs = { ...rest };
+    if (formattedOutputs.role == null) {
+        formattedOutputs.role = formattedOutputs.type ?? "assistant";
+    }
+    return (0, exports.populateToolCallsForTracing)(formattedOutputs);
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const setUsageMetadataOnRunTree = (result, runTree) => {
+    if (result.usage == null || typeof result.usage !== "object") {
+        return;
+    }
+    const langsmithUsage = {
+        input_tokens: result.usage?.inputTokens,
+        output_tokens: result.usage?.outputTokens,
+        total_tokens: result.usage?.totalTokens,
+    };
+    const inputTokenDetails = (0, vercel_js_1.extractInputTokenDetails)(result.providerMetadata ?? {}, result.usage?.cachedInputTokens);
+    runTree.extra = {
+        ...runTree.extra,
+        metadata: {
+            ...runTree.extra?.metadata,
+            usage_metadata: {
+                ...langsmithUsage,
+                input_token_details: {
+                    ...inputTokenDetails,
+                },
+            },
+        },
+    };
+};
+/**
+ * AI SDK middleware that wraps an AI SDK 5 model and adds LangSmith tracing.
+ */
+function LangSmithMiddleware(config) {
+    const { name, modelId, lsConfig } = config ?? {};
+    return {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const traceableFunc = (0, traceable_js_1.traceable)(async (_params) => {
+                const result = await doGenerate();
+                const currentRunTree = (0, traceable_js_1.getCurrentRunTree)(true);
+                if (currentRunTree !== undefined) {
+                    setUsageMetadataOnRunTree(result, currentRunTree);
+                }
+                return result;
+            }, {
+                ...lsConfig,
+                name: name ?? "ai.doGenerate",
+                run_type: "llm",
+                metadata: {
+                    ls_model_name: modelId,
+                    ai_sdk_method: "ai.doGenerate",
+                    ...lsConfig?.metadata,
+                },
+                processInputs: (inputs) => _formatTracedInputs(inputs),
+                processOutputs: (outputs) => {
+                    return _formatTracedOutputs(outputs);
+                },
+            });
+            return traceableFunc(params);
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const parentRunTree = (0, traceable_js_1.getCurrentRunTree)(true);
+            let runTree;
+            if (parentRunTree != null &&
+                typeof parentRunTree === "object" &&
+                typeof parentRunTree.createChild === "function") {
+                runTree = parentRunTree?.createChild({
+                    ...lsConfig,
+                    name: name ?? "ai.doStream",
+                    run_type: "llm",
+                    metadata: {
+                        ls_model_name: modelId,
+                        ai_sdk_method: "ai.doStream",
+                        ...lsConfig?.metadata,
+                    },
+                    inputs: _formatTracedInputs(params),
+                });
+            }
+            await runTree?.postRun();
+            try {
+                const { stream, ...rest } = await doStream();
+                const chunks = [];
+                const transformStream = new TransformStream({
+                    async transform(chunk, controller) {
+                        chunks.push(chunk);
+                        controller.enqueue(chunk);
+                    },
+                    async flush() {
+                        try {
+                            const output = chunks.reduce((aggregated, chunk) => {
+                                if (chunk.type === "text-delta") {
+                                    if (chunk.delta == null) {
+                                        return aggregated;
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        text: aggregated.text + chunk.delta,
+                                    };
+                                }
+                                else if (chunk.type === "tool-call") {
+                                    const matchingToolCall = aggregated.tool_calls.find((call) => call.id === chunk.toolCallId);
+                                    if (matchingToolCall != null) {
+                                        return aggregated;
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        tool_calls: [
+                                            ...aggregated.tool_calls,
+                                            {
+                                                id: chunk.toolCallId,
+                                                type: "function",
+                                                function: {
+                                                    name: chunk.toolName,
+                                                    arguments: chunk.input,
+                                                },
+                                            },
+                                        ],
+                                    };
+                                }
+                                else if (chunk.type === "finish") {
+                                    if (runTree != null) {
+                                        setUsageMetadataOnRunTree(chunk, runTree);
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        providerMetadata: chunk.providerMetadata,
+                                        finishReason: chunk.finishReason,
+                                    };
+                                }
+                                else {
+                                    return aggregated;
+                                }
+                            }, {
+                                text: "",
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                tool_calls: [],
+                            });
+                            await runTree?.end(_formatTracedOutputs(output));
+                        }
+                        catch (error) {
+                            await runTree?.end(undefined, error.message ?? String(error));
+                            throw error;
+                        }
+                        finally {
+                            await runTree?.patchRun();
+                        }
+                    },
+                });
+                return {
+                    stream: stream.pipeThrough(transformStream),
+                    ...rest,
+                };
+            }
+            catch (error) {
+                await runTree?.end(undefined, error.message ?? String(error));
+                await runTree?.patchRun();
+                throw error;
+            }
+        },
+    };
+}

package/dist/experimental/vercel/middleware.d.ts

@@ -0,0 +1,31 @@
+import type { LanguageModelV2Middleware, LanguageModelV2Message } from "@ai-sdk/provider";
+import type { RunTreeConfig } from "../../run_trees.js";
+export declare const populateToolCallsForTracing: (message: LanguageModelV2Message) => ({
+    role: "system";
+    content: string;
+} & {
+    providerOptions?: import("@ai-sdk/provider").SharedV2ProviderOptions;
+} & Record<string, unknown>) | ({
+    role: "user";
+    content: Array<import("@ai-sdk/provider").LanguageModelV2TextPart | import("@ai-sdk/provider").LanguageModelV2FilePart>;
+} & {
+    providerOptions?: import("@ai-sdk/provider").SharedV2ProviderOptions;
+} & Record<string, unknown>) | ({
+    role: "assistant";
+    content: Array<import("@ai-sdk/provider").LanguageModelV2TextPart | import("@ai-sdk/provider").LanguageModelV2FilePart | import("@ai-sdk/provider").LanguageModelV2ReasoningPart | import("@ai-sdk/provider").LanguageModelV2ToolCallPart | import("@ai-sdk/provider").LanguageModelV2ToolResultPart>;
+} & {
+    providerOptions?: import("@ai-sdk/provider").SharedV2ProviderOptions;
+} & Record<string, unknown>) | ({
+    role: "tool";
+    content: Array<import("@ai-sdk/provider").LanguageModelV2ToolResultPart>;
+} & {
+    providerOptions?: import("@ai-sdk/provider").SharedV2ProviderOptions;
+} & Record<string, unknown>);
+/**
+ * AI SDK middleware that wraps an AI SDK 5 model and adds LangSmith tracing.
+ */
+export declare function LangSmithMiddleware(config?: {
+    name: string;
+    modelId?: string;
+    lsConfig?: Partial<Omit<RunTreeConfig, "inputs" | "outputs">>;
+}): LanguageModelV2Middleware;

package/dist/experimental/vercel/middleware.js

@@ -0,0 +1,209 @@
+import { getCurrentRunTree, traceable } from "../../traceable.js";
+import { extractInputTokenDetails } from "../../utils/vercel.js";
+export const populateToolCallsForTracing = (message) => {
+    const formattedMessage = {
+        ...message,
+    };
+    if (formattedMessage.role !== "assistant") {
+        return formattedMessage;
+    }
+    if (Array.isArray(formattedMessage.content)) {
+        const toolCalls = formattedMessage.content
+            .filter((block) => {
+            return (block != null &&
+                typeof block === "object" &&
+                block.type == "tool-call");
+        })
+            .map((block) => {
+            return {
+                id: block.toolCallId,
+                type: "function",
+                function: {
+                    name: block.toolName,
+                    arguments: typeof block.input !== "string"
+                        ? JSON.stringify(block.input)
+                        : block.input,
+                },
+            };
+        });
+        if (toolCalls.length > 0) {
+            formattedMessage.tool_calls = toolCalls;
+        }
+    }
+    return formattedMessage;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const _formatTracedInputs = (params) => {
+    const { prompt, ...rest } = params;
+    if (prompt == null) {
+        return params;
+    }
+    if (Array.isArray(prompt)) {
+        return { ...rest, messages: prompt.map(populateToolCallsForTracing) };
+    }
+    return rest;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const _formatTracedOutputs = (outputs) => {
+    const { request, response, ...rest } = outputs;
+    const formattedOutputs = { ...rest };
+    if (formattedOutputs.role == null) {
+        formattedOutputs.role = formattedOutputs.type ?? "assistant";
+    }
+    return populateToolCallsForTracing(formattedOutputs);
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const setUsageMetadataOnRunTree = (result, runTree) => {
+    if (result.usage == null || typeof result.usage !== "object") {
+        return;
+    }
+    const langsmithUsage = {
+        input_tokens: result.usage?.inputTokens,
+        output_tokens: result.usage?.outputTokens,
+        total_tokens: result.usage?.totalTokens,
+    };
+    const inputTokenDetails = extractInputTokenDetails(result.providerMetadata ?? {}, result.usage?.cachedInputTokens);
+    runTree.extra = {
+        ...runTree.extra,
+        metadata: {
+            ...runTree.extra?.metadata,
+            usage_metadata: {
+                ...langsmithUsage,
+                input_token_details: {
+                    ...inputTokenDetails,
+                },
+            },
+        },
+    };
+};
+/**
+ * AI SDK middleware that wraps an AI SDK 5 model and adds LangSmith tracing.
+ */
+export function LangSmithMiddleware(config) {
+    const { name, modelId, lsConfig } = config ?? {};
+    return {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const traceableFunc = traceable(async (_params) => {
+                const result = await doGenerate();
+                const currentRunTree = getCurrentRunTree(true);
+                if (currentRunTree !== undefined) {
+                    setUsageMetadataOnRunTree(result, currentRunTree);
+                }
+                return result;
+            }, {
+                ...lsConfig,
+                name: name ?? "ai.doGenerate",
+                run_type: "llm",
+                metadata: {
+                    ls_model_name: modelId,
+                    ai_sdk_method: "ai.doGenerate",
+                    ...lsConfig?.metadata,
+                },
+                processInputs: (inputs) => _formatTracedInputs(inputs),
+                processOutputs: (outputs) => {
+                    return _formatTracedOutputs(outputs);
+                },
+            });
+            return traceableFunc(params);
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const parentRunTree = getCurrentRunTree(true);
+            let runTree;
+            if (parentRunTree != null &&
+                typeof parentRunTree === "object" &&
+                typeof parentRunTree.createChild === "function") {
+                runTree = parentRunTree?.createChild({
+                    ...lsConfig,
+                    name: name ?? "ai.doStream",
+                    run_type: "llm",
+                    metadata: {
+                        ls_model_name: modelId,
+                        ai_sdk_method: "ai.doStream",
+                        ...lsConfig?.metadata,
+                    },
+                    inputs: _formatTracedInputs(params),
+                });
+            }
+            await runTree?.postRun();
+            try {
+                const { stream, ...rest } = await doStream();
+                const chunks = [];
+                const transformStream = new TransformStream({
+                    async transform(chunk, controller) {
+                        chunks.push(chunk);
+                        controller.enqueue(chunk);
+                    },
+                    async flush() {
+                        try {
+                            const output = chunks.reduce((aggregated, chunk) => {
+                                if (chunk.type === "text-delta") {
+                                    if (chunk.delta == null) {
+                                        return aggregated;
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        text: aggregated.text + chunk.delta,
+                                    };
+                                }
+                                else if (chunk.type === "tool-call") {
+                                    const matchingToolCall = aggregated.tool_calls.find((call) => call.id === chunk.toolCallId);
+                                    if (matchingToolCall != null) {
+                                        return aggregated;
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        tool_calls: [
+                                            ...aggregated.tool_calls,
+                                            {
+                                                id: chunk.toolCallId,
+                                                type: "function",
+                                                function: {
+                                                    name: chunk.toolName,
+                                                    arguments: chunk.input,
+                                                },
+                                            },
+                                        ],
+                                    };
+                                }
+                                else if (chunk.type === "finish") {
+                                    if (runTree != null) {
+                                        setUsageMetadataOnRunTree(chunk, runTree);
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        providerMetadata: chunk.providerMetadata,
+                                        finishReason: chunk.finishReason,
+                                    };
+                                }
+                                else {
+                                    return aggregated;
+                                }
+                            }, {
+                                text: "",
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                tool_calls: [],
+                            });
+                            await runTree?.end(_formatTracedOutputs(output));
+                        }
+                        catch (error) {
+                            await runTree?.end(undefined, error.message ?? String(error));
+                            throw error;
+                        }
+                        finally {
+                            await runTree?.patchRun();
+                        }
+                    },
+                });
+                return {
+                    stream: stream.pipeThrough(transformStream),
+                    ...rest,
+                };
+            }
+            catch (error) {
+                await runTree?.end(undefined, error.message ?? String(error));
+                await runTree?.patchRun();
+                throw error;
+            }
+        },
+    };
+}

package/dist/index.cjs

@@ -10,4 +10,4 @@ Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true
 var project_js_1 = require("./utils/project.cjs");
 Object.defineProperty(exports, "getDefaultProjectName", { enumerable: true, get: function () { return project_js_1.getDefaultProjectName; } });
 // Update using yarn bump-version
-exports.__version__ = "0.3.56";
+exports.__version__ = "0.3.57-rc.1";

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, }
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
-export declare const __version__ = "0.3.56";
+export declare const __version__ = "0.3.57-rc.1";

package/dist/index.js

@@ -3,4 +3,4 @@ export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 // Update using yarn bump-version
-export const __version__ = "0.3.56";
+export const __version__ = "0.3.57-rc.1";

package/dist/utils/vercel.cjs

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInputTokenDetails = extractInputTokenDetails;
 exports.extractUsageMetadata = extractUsageMetadata;
-function extractInputTokenDetails(providerMetadata, spanAttributes) {
+function extractInputTokenDetails(providerMetadata, cachedTokenUsage) {
     const inputTokenDetails = {};
     if (providerMetadata.anthropic != null &&
         typeof providerMetadata.anthropic === "object") {
@@ -52,9 +53,8 @@ function extractInputTokenDetails(providerMetadata, spanAttributes) {
             typeof openai.cachedPromptTokens === "number") {
             inputTokenDetails.cache_read = openai.cachedPromptTokens;
         }
-        else if (typeof spanAttributes?.["ai.usage.cachedInputTokens"] === "number") {
-            inputTokenDetails.cache_read =
-                spanAttributes["ai.usage.cachedInputTokens"];
+        else if (typeof cachedTokenUsage === "number") {
+            inputTokenDetails.cache_read = cachedTokenUsage;
         }
     }
     return inputTokenDetails;
@@ -88,7 +88,9 @@ function extractUsageMetadata(span) {
     if (typeof span.attributes["ai.response.providerMetadata"] === "string") {
         try {
             const providerMetadata = JSON.parse(span.attributes["ai.response.providerMetadata"]);
-            usageMetadata.input_token_details = extractInputTokenDetails(providerMetadata, span.attributes);
+            usageMetadata.input_token_details = extractInputTokenDetails(providerMetadata, typeof span.attributes["ai.usage.cachedInputTokens"] === "number"
+                ? span.attributes["ai.usage.cachedInputTokens"]
+                : undefined);
             if (providerMetadata.anthropic != null &&
                 typeof providerMetadata.anthropic === "object") {
                 // AI SDK does not include Anthropic cache tokens in their stated input token

package/dist/utils/vercel.d.ts

@@ -1,4 +1,5 @@
 import { KVMap } from "../schemas.js";
+export declare function extractInputTokenDetails(providerMetadata: Record<string, unknown>, cachedTokenUsage?: number): Record<string, number>;
 export declare function extractUsageMetadata(span?: {
     status?: {
         code: number;

package/dist/utils/vercel.js

@@ -1,4 +1,4 @@
-function extractInputTokenDetails(providerMetadata, spanAttributes) {
+export function extractInputTokenDetails(providerMetadata, cachedTokenUsage) {
     const inputTokenDetails = {};
     if (providerMetadata.anthropic != null &&
         typeof providerMetadata.anthropic === "object") {
@@ -49,9 +49,8 @@ function extractInputTokenDetails(providerMetadata, spanAttributes) {
             typeof openai.cachedPromptTokens === "number") {
             inputTokenDetails.cache_read = openai.cachedPromptTokens;
         }
-        else if (typeof spanAttributes?.["ai.usage.cachedInputTokens"] === "number") {
-            inputTokenDetails.cache_read =
-                spanAttributes["ai.usage.cachedInputTokens"];
+        else if (typeof cachedTokenUsage === "number") {
+            inputTokenDetails.cache_read = cachedTokenUsage;
         }
     }
     return inputTokenDetails;
@@ -85,7 +84,9 @@ export function extractUsageMetadata(span) {
     if (typeof span.attributes["ai.response.providerMetadata"] === "string") {
         try {
             const providerMetadata = JSON.parse(span.attributes["ai.response.providerMetadata"]);
-            usageMetadata.input_token_details = extractInputTokenDetails(providerMetadata, span.attributes);
+            usageMetadata.input_token_details = extractInputTokenDetails(providerMetadata, typeof span.attributes["ai.usage.cachedInputTokens"] === "number"
+                ? span.attributes["ai.usage.cachedInputTokens"]
+                : undefined);
             if (providerMetadata.anthropic != null &&
                 typeof providerMetadata.anthropic === "object") {
                 // AI SDK does not include Anthropic cache tokens in their stated input token

package/dist/wrappers/vercel.cjs

@@ -4,6 +4,7 @@ exports.wrapAISDKModel = void 0;
 const traceable_js_1 = require("../traceable.cjs");
 const generic_js_1 = require("./generic.cjs");
 /**
+ * @deprecated Use `wrapAISDK` from `langsmith/experimental/vercel` instead.
  * 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.

package/dist/wrappers/vercel.d.ts

@@ -1,5 +1,6 @@
 import type { RunTreeConfig } from "../index.js";
 /**
+ * @deprecated Use `wrapAISDK` from `langsmith/experimental/vercel` instead.
  * 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.

package/dist/wrappers/vercel.js

@@ -1,6 +1,7 @@
 import { traceable } from "../traceable.js";
 import { _wrapClient } from "./generic.js";
 /**
+ * @deprecated Use `wrapAISDK` from `langsmith/experimental/vercel` instead.
  * 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.

package/experimental/vercel.cjs

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

package/experimental/vercel.d.cts

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

package/experimental/vercel.d.ts

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

package/experimental/vercel.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.3.56",
+  "version": "0.3.57-rc.1",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -89,6 +89,10 @@
     "experimental/otel/processor.js",
     "experimental/otel/processor.d.ts",
     "experimental/otel/processor.d.cts",
+    "experimental/vercel.cjs",
+    "experimental/vercel.js",
+    "experimental/vercel.d.ts",
+    "experimental/vercel.d.cts",
     "index.cjs",
     "index.js",
     "index.d.ts",
@@ -144,8 +148,8 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "2.0.0-beta.12",
-    "@ai-sdk/openai": "2.0.0-beta.15",
+    "@ai-sdk/anthropic": "^2.0.1",
+    "@ai-sdk/openai": "^2.0.10",
     "@babel/preset-env": "^7.22.4",
     "@faker-js/faker": "^8.4.1",
     "@jest/globals": "^29.5.0",
@@ -163,7 +167,7 @@
     "@types/node-fetch": "^2.6.12",
     "@typescript-eslint/eslint-plugin": "^5.59.8",
     "@typescript-eslint/parser": "^5.59.8",
-    "ai": "5.0.0-beta.25",
+    "ai": "^5.0.10",
     "babel-jest": "^29.5.0",
     "cross-env": "^7.0.3",
     "dotenv": "^16.1.3",
@@ -410,6 +414,15 @@
       "import": "./experimental/otel/processor.js",
       "require": "./experimental/otel/processor.cjs"
     },
+    "./experimental/vercel": {
+      "types": {
+        "import": "./experimental/vercel.d.ts",
+        "require": "./experimental/vercel.d.cts",
+        "default": "./experimental/vercel.d.ts"
+      },
+      "import": "./experimental/vercel.js",
+      "require": "./experimental/vercel.cjs"
+    },
     "./package.json": "./package.json"
   }
 }