langsmith 0.3.82 → 0.3.83-rc.1

package/dist/index.cjs

@@ -13,4 +13,4 @@ var uuid_js_1 = require("./uuid.cjs");
 Object.defineProperty(exports, "uuid7", { enumerable: true, get: function () { return uuid_js_1.uuid7; } });
 Object.defineProperty(exports, "uuid7FromTime", { enumerable: true, get: function () { return uuid_js_1.uuid7FromTime; } });
 // Update using yarn bump-version
-exports.__version__ = "0.3.82";
+exports.__version__ = "0.3.83-rc.1";

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
-export declare const __version__ = "0.3.82";
+export declare const __version__ = "0.3.83-rc.1";

package/dist/index.js

@@ -4,4 +4,4 @@ export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 // Update using yarn bump-version
-export const __version__ = "0.3.82";
+export const __version__ = "0.3.83-rc.1";

package/dist/wrappers/anthropic.cjs

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapAnthropic = void 0;
+const traceable_js_1 = require("../traceable.cjs");
+const TRACED_INVOCATION_KEYS = ["top_k", "top_p", "stream", "thinking"];
+/**
+ * Create usage metadata from Anthropic's token usage format.
+ */
+function createUsageMetadata(anthropicUsage) {
+    if (!anthropicUsage) {
+        return undefined;
+    }
+    const inputTokens = anthropicUsage.input_tokens ?? 0;
+    const outputTokens = anthropicUsage.output_tokens ?? 0;
+    const totalTokens = inputTokens + outputTokens;
+    // Anthropic provides cache tokens separately
+    const cacheReadTokens = anthropicUsage.cache_read_input_tokens ?? 0;
+    const cacheCreationTokens = anthropicUsage.cache_creation_input_tokens ?? 0;
+    const inputTokenDetails = {};
+    if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
+        inputTokenDetails.cache_read = cacheReadTokens + cacheCreationTokens;
+    }
+    return {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+        ...(Object.keys(inputTokenDetails).length > 0 && {
+            input_token_details: inputTokenDetails,
+        }),
+    };
+}
+/**
+ * Process Anthropic message outputs
+ */
+function processMessageOutput(outputs) {
+    const message = outputs;
+    const result = { ...message };
+    delete result.type;
+    if (message.usage) {
+        result.usage_metadata = createUsageMetadata(message.usage);
+        delete result.usage;
+    }
+    return result;
+}
+/**
+ * Accumulate a single content block delta into the content array.
+ */
+function accumulateContentBlockDelta(content, event) {
+    const block = content[event.index];
+    if (!block)
+        return;
+    if (block.type === "text" && event.delta.type === "text_delta") {
+        block.text += event.delta.text;
+    }
+    else if (block.type === "tool_use" &&
+        event.delta.type === "input_json_delta") {
+        // Accumulate JSON input for tool use
+        const toolBlock = block;
+        toolBlock._partial_json =
+            (toolBlock._partial_json ?? "") + event.delta.partial_json;
+    }
+}
+/**
+ * Aggregate streaming chunks into a complete message response
+ */
+const messageAggregator = (chunks) => {
+    if (!chunks || chunks.length === 0) {
+        return {
+            role: "assistant",
+            content: [],
+        };
+    }
+    let message = {
+        role: "assistant",
+        content: [],
+        model: "",
+        stop_reason: null,
+        stop_sequence: null,
+    };
+    // Track usage
+    let usage = {
+        input_tokens: 0,
+        output_tokens: 0,
+    };
+    for (const chunk of chunks) {
+        switch (chunk.type) {
+            case "message_start":
+                // Initialize message
+                message = {
+                    id: chunk.message.id,
+                    role: chunk.message.role,
+                    content: [],
+                    model: chunk.message.model,
+                    stop_reason: chunk.message.stop_reason,
+                    stop_sequence: chunk.message.stop_sequence,
+                };
+                // Capture initial usage
+                if (chunk.message.usage) {
+                    usage = {
+                        input_tokens: chunk.message.usage.input_tokens,
+                        output_tokens: chunk.message.usage.output_tokens,
+                        cache_read_input_tokens: chunk.message.usage.cache_read_input_tokens,
+                        cache_creation_input_tokens: chunk.message.usage.cache_creation_input_tokens,
+                    };
+                }
+                break;
+            case "content_block_start":
+                // Add new content block
+                if (message.content) {
+                    message.content[chunk.index] =
+                        chunk.content_block;
+                }
+                break;
+            case "content_block_delta":
+                // Accumulate delta
+                if (message.content) {
+                    accumulateContentBlockDelta(message.content, chunk);
+                }
+                break;
+            case "content_block_stop":
+                // Finalize content block
+                if (message.content) {
+                    const block = message.content[chunk.index];
+                    if (block?.type === "tool_use") {
+                        const toolBlock = block;
+                        if (toolBlock._partial_json) {
+                            try {
+                                toolBlock.input = JSON.parse(toolBlock._partial_json);
+                            }
+                            catch {
+                                // Keep partial JSON as-is if parsing fails
+                                toolBlock.input = toolBlock._partial_json;
+                            }
+                            delete toolBlock._partial_json;
+                        }
+                    }
+                }
+                break;
+            case "message_delta":
+                // Update message metadata
+                message.stop_reason = chunk.delta.stop_reason;
+                message.stop_sequence = chunk.delta.stop_sequence ?? null;
+                if (chunk.usage) {
+                    usage.output_tokens = chunk.usage.output_tokens;
+                }
+                break;
+            case "message_stop":
+                // Message complete
+                break;
+        }
+    }
+    // Build final output
+    const result = {
+        ...message,
+    };
+    delete result.type;
+    // Add usage metadata
+    result.usage_metadata = createUsageMetadata(usage);
+    return result;
+};
+/**
+ * Wraps an Anthropic client's completion methods, enabling automatic LangSmith
+ * tracing. Method signatures are unchanged, with the exception that you can pass
+ * an additional and optional "langsmithExtra" field within the second parameter.
+ *
+ * @param anthropic An Anthropic client instance.
+ * @param options LangSmith options.
+ * @returns The wrapped client.
+ *
+ * @example
+ * ```ts
+ * import Anthropic from "@anthropic-ai/sdk";
+ * import { wrapAnthropic } from "langsmith/wrappers/anthropic";
+ *
+ * const anthropic = wrapAnthropic(new Anthropic());
+ *
+ * // Non-streaming
+ * const message = await anthropic.messages.create({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ *
+ * // Streaming with create()
+ * const stream = await anthropic.messages.create({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ *   stream: true,
+ * });
+ * for await (const event of stream) {
+ *   // process events
+ * }
+ *
+ * // Streaming with stream()
+ * const messageStream = anthropic.messages.stream({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ * for await (const event of messageStream) {
+ *   // process events
+ * }
+ * const finalMessage = await messageStream.finalMessage();
+ * ```
+ */
+const wrapAnthropic = (anthropic, options) => {
+    if ((0, traceable_js_1.isTraceableFunction)(anthropic.messages.create) ||
+        (0, traceable_js_1.isTraceableFunction)(anthropic.messages.stream)) {
+        throw new Error("This instance of Anthropic client has been already wrapped once.");
+    }
+    const tracedAnthropicClient = { ...anthropic };
+    // Common configuration for messages.create
+    const messagesCreateConfig = {
+        name: "ChatAnthropic",
+        run_type: "llm",
+        aggregator: messageAggregator,
+        argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: (payload) => {
+            if (typeof payload !== "object" || payload == null)
+                return undefined;
+            const params = payload;
+            const ls_stop = (typeof params.stop_sequences === "string"
+                ? [params.stop_sequences]
+                : params.stop_sequences) ?? undefined;
+            const ls_invocation_params = {};
+            for (const [key, value] of Object.entries(params)) {
+                if (TRACED_INVOCATION_KEYS.includes(key)) {
+                    ls_invocation_params[key] = value;
+                }
+            }
+            return {
+                ls_provider: "anthropic",
+                ls_model_type: "chat",
+                ls_model_name: params.model,
+                ls_max_tokens: params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+                ls_invocation_params,
+            };
+        },
+        processOutputs: processMessageOutput,
+        ...options,
+    };
+    // Create a new messages object preserving the prototype
+    tracedAnthropicClient.messages = Object.create(Object.getPrototypeOf(anthropic.messages));
+    // Copy all own properties
+    Object.assign(tracedAnthropicClient.messages, anthropic.messages);
+    // Wrap messages.create
+    tracedAnthropicClient.messages.create = (0, traceable_js_1.traceable)(anthropic.messages.create.bind(anthropic.messages), messagesCreateConfig);
+    // Wrap messages.stream
+    const originalStream = anthropic.messages.stream.bind(anthropic.messages);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const streamMethod = function (...args) {
+        const stream = originalStream(...args);
+        if ("finalMessage" in stream && typeof stream.finalMessage === "function") {
+            const originalFinalMessage = stream.finalMessage.bind(stream);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            stream.finalMessage = async (...args) => {
+                for await (const _ of stream) {
+                    // consume chunks
+                }
+                return originalFinalMessage(...args);
+            };
+        }
+        return stream;
+    };
+    tracedAnthropicClient.messages.stream = (0, traceable_js_1.traceable)(streamMethod, {
+        name: "ChatAnthropic",
+        run_type: "llm",
+        aggregator: messageAggregator,
+        argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: messagesCreateConfig.getInvocationParams,
+        processOutputs: processMessageOutput,
+        ...options,
+    });
+    // Wrap beta.messages if it exists
+    if (anthropic.beta &&
+        anthropic.beta.messages &&
+        typeof anthropic.beta.messages.create === "function") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tracedBeta = { ...anthropic.beta };
+        tracedBeta.messages = Object.create(Object.getPrototypeOf(anthropic.beta.messages));
+        Object.assign(tracedBeta.messages, anthropic.beta.messages);
+        // Wrap beta.messages.create
+        tracedBeta.messages.create = (0, traceable_js_1.traceable)(anthropic.beta.messages.create.bind(anthropic.beta.messages), messagesCreateConfig);
+        // Wrap beta.messages.stream if it exists
+        if (typeof anthropic.beta.messages.stream === "function") {
+            tracedBeta.messages.stream = (0, traceable_js_1.traceable)(anthropic.beta.messages.stream.bind(anthropic.beta.messages), {
+                name: "ChatAnthropic",
+                run_type: "llm",
+                aggregator: messageAggregator,
+                argsConfigPath: [1, "langsmithExtra"],
+                getInvocationParams: messagesCreateConfig.getInvocationParams,
+                processOutputs: processMessageOutput,
+                ...options,
+            });
+        }
+        tracedAnthropicClient.beta = tracedBeta;
+    }
+    return tracedAnthropicClient;
+};
+exports.wrapAnthropic = wrapAnthropic;

package/dist/wrappers/anthropic.d.ts

@@ -0,0 +1,81 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import type { Stream } from "@anthropic-ai/sdk/streaming";
+import type { MessageStream } from "@anthropic-ai/sdk/lib/MessageStream";
+import type { RunTreeConfig } from "../index.js";
+type ExtraRunTreeConfig = Pick<Partial<RunTreeConfig>, "name" | "metadata" | "tags">;
+type MessagesNamespace = {
+    create: (...args: any[]) => any;
+    stream: (...args: any[]) => any;
+};
+type AnthropicType = {
+    messages: MessagesNamespace;
+    beta?: {
+        messages?: MessagesNamespace;
+    };
+};
+type PatchedAnthropicClient<T extends AnthropicType> = T & {
+    messages: T["messages"] & {
+        create: {
+            (arg: Anthropic.MessageCreateParamsStreaming, arg2?: Anthropic.RequestOptions & {
+                langsmithExtra?: ExtraRunTreeConfig;
+            }): Promise<Stream<Anthropic.MessageStreamEvent>>;
+        } & {
+            (arg: Anthropic.MessageCreateParamsNonStreaming, arg2?: Anthropic.RequestOptions & {
+                langsmithExtra?: ExtraRunTreeConfig;
+            }): Promise<Anthropic.Message>;
+        };
+        stream: {
+            (arg: Anthropic.MessageStreamParams, arg2?: Anthropic.RequestOptions & {
+                langsmithExtra?: ExtraRunTreeConfig;
+            }): MessageStream;
+        };
+    };
+};
+/**
+ * Wraps an Anthropic client's completion methods, enabling automatic LangSmith
+ * tracing. Method signatures are unchanged, with the exception that you can pass
+ * an additional and optional "langsmithExtra" field within the second parameter.
+ *
+ * @param anthropic An Anthropic client instance.
+ * @param options LangSmith options.
+ * @returns The wrapped client.
+ *
+ * @example
+ * ```ts
+ * import Anthropic from "@anthropic-ai/sdk";
+ * import { wrapAnthropic } from "langsmith/wrappers/anthropic";
+ *
+ * const anthropic = wrapAnthropic(new Anthropic());
+ *
+ * // Non-streaming
+ * const message = await anthropic.messages.create({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ *
+ * // Streaming with create()
+ * const stream = await anthropic.messages.create({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ *   stream: true,
+ * });
+ * for await (const event of stream) {
+ *   // process events
+ * }
+ *
+ * // Streaming with stream()
+ * const messageStream = anthropic.messages.stream({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ * for await (const event of messageStream) {
+ *   // process events
+ * }
+ * const finalMessage = await messageStream.finalMessage();
+ * ```
+ */
+export declare const wrapAnthropic: <T extends AnthropicType>(anthropic: T, options?: Partial<RunTreeConfig>) => PatchedAnthropicClient<T>;
+export {};

package/dist/wrappers/anthropic.js

@@ -0,0 +1,299 @@
+import { isTraceableFunction, traceable, } from "../traceable.js";
+const TRACED_INVOCATION_KEYS = ["top_k", "top_p", "stream", "thinking"];
+/**
+ * Create usage metadata from Anthropic's token usage format.
+ */
+function createUsageMetadata(anthropicUsage) {
+    if (!anthropicUsage) {
+        return undefined;
+    }
+    const inputTokens = anthropicUsage.input_tokens ?? 0;
+    const outputTokens = anthropicUsage.output_tokens ?? 0;
+    const totalTokens = inputTokens + outputTokens;
+    // Anthropic provides cache tokens separately
+    const cacheReadTokens = anthropicUsage.cache_read_input_tokens ?? 0;
+    const cacheCreationTokens = anthropicUsage.cache_creation_input_tokens ?? 0;
+    const inputTokenDetails = {};
+    if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
+        inputTokenDetails.cache_read = cacheReadTokens + cacheCreationTokens;
+    }
+    return {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+        ...(Object.keys(inputTokenDetails).length > 0 && {
+            input_token_details: inputTokenDetails,
+        }),
+    };
+}
+/**
+ * Process Anthropic message outputs
+ */
+function processMessageOutput(outputs) {
+    const message = outputs;
+    const result = { ...message };
+    delete result.type;
+    if (message.usage) {
+        result.usage_metadata = createUsageMetadata(message.usage);
+        delete result.usage;
+    }
+    return result;
+}
+/**
+ * Accumulate a single content block delta into the content array.
+ */
+function accumulateContentBlockDelta(content, event) {
+    const block = content[event.index];
+    if (!block)
+        return;
+    if (block.type === "text" && event.delta.type === "text_delta") {
+        block.text += event.delta.text;
+    }
+    else if (block.type === "tool_use" &&
+        event.delta.type === "input_json_delta") {
+        // Accumulate JSON input for tool use
+        const toolBlock = block;
+        toolBlock._partial_json =
+            (toolBlock._partial_json ?? "") + event.delta.partial_json;
+    }
+}
+/**
+ * Aggregate streaming chunks into a complete message response
+ */
+const messageAggregator = (chunks) => {
+    if (!chunks || chunks.length === 0) {
+        return {
+            role: "assistant",
+            content: [],
+        };
+    }
+    let message = {
+        role: "assistant",
+        content: [],
+        model: "",
+        stop_reason: null,
+        stop_sequence: null,
+    };
+    // Track usage
+    let usage = {
+        input_tokens: 0,
+        output_tokens: 0,
+    };
+    for (const chunk of chunks) {
+        switch (chunk.type) {
+            case "message_start":
+                // Initialize message
+                message = {
+                    id: chunk.message.id,
+                    role: chunk.message.role,
+                    content: [],
+                    model: chunk.message.model,
+                    stop_reason: chunk.message.stop_reason,
+                    stop_sequence: chunk.message.stop_sequence,
+                };
+                // Capture initial usage
+                if (chunk.message.usage) {
+                    usage = {
+                        input_tokens: chunk.message.usage.input_tokens,
+                        output_tokens: chunk.message.usage.output_tokens,
+                        cache_read_input_tokens: chunk.message.usage.cache_read_input_tokens,
+                        cache_creation_input_tokens: chunk.message.usage.cache_creation_input_tokens,
+                    };
+                }
+                break;
+            case "content_block_start":
+                // Add new content block
+                if (message.content) {
+                    message.content[chunk.index] =
+                        chunk.content_block;
+                }
+                break;
+            case "content_block_delta":
+                // Accumulate delta
+                if (message.content) {
+                    accumulateContentBlockDelta(message.content, chunk);
+                }
+                break;
+            case "content_block_stop":
+                // Finalize content block
+                if (message.content) {
+                    const block = message.content[chunk.index];
+                    if (block?.type === "tool_use") {
+                        const toolBlock = block;
+                        if (toolBlock._partial_json) {
+                            try {
+                                toolBlock.input = JSON.parse(toolBlock._partial_json);
+                            }
+                            catch {
+                                // Keep partial JSON as-is if parsing fails
+                                toolBlock.input = toolBlock._partial_json;
+                            }
+                            delete toolBlock._partial_json;
+                        }
+                    }
+                }
+                break;
+            case "message_delta":
+                // Update message metadata
+                message.stop_reason = chunk.delta.stop_reason;
+                message.stop_sequence = chunk.delta.stop_sequence ?? null;
+                if (chunk.usage) {
+                    usage.output_tokens = chunk.usage.output_tokens;
+                }
+                break;
+            case "message_stop":
+                // Message complete
+                break;
+        }
+    }
+    // Build final output
+    const result = {
+        ...message,
+    };
+    delete result.type;
+    // Add usage metadata
+    result.usage_metadata = createUsageMetadata(usage);
+    return result;
+};
+/**
+ * Wraps an Anthropic client's completion methods, enabling automatic LangSmith
+ * tracing. Method signatures are unchanged, with the exception that you can pass
+ * an additional and optional "langsmithExtra" field within the second parameter.
+ *
+ * @param anthropic An Anthropic client instance.
+ * @param options LangSmith options.
+ * @returns The wrapped client.
+ *
+ * @example
+ * ```ts
+ * import Anthropic from "@anthropic-ai/sdk";
+ * import { wrapAnthropic } from "langsmith/wrappers/anthropic";
+ *
+ * const anthropic = wrapAnthropic(new Anthropic());
+ *
+ * // Non-streaming
+ * const message = await anthropic.messages.create({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ *
+ * // Streaming with create()
+ * const stream = await anthropic.messages.create({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ *   stream: true,
+ * });
+ * for await (const event of stream) {
+ *   // process events
+ * }
+ *
+ * // Streaming with stream()
+ * const messageStream = anthropic.messages.stream({
+ *   model: "claude-sonnet-4-20250514",
+ *   max_tokens: 1024,
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ * for await (const event of messageStream) {
+ *   // process events
+ * }
+ * const finalMessage = await messageStream.finalMessage();
+ * ```
+ */
+export const wrapAnthropic = (anthropic, options) => {
+    if (isTraceableFunction(anthropic.messages.create) ||
+        isTraceableFunction(anthropic.messages.stream)) {
+        throw new Error("This instance of Anthropic client has been already wrapped once.");
+    }
+    const tracedAnthropicClient = { ...anthropic };
+    // Common configuration for messages.create
+    const messagesCreateConfig = {
+        name: "ChatAnthropic",
+        run_type: "llm",
+        aggregator: messageAggregator,
+        argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: (payload) => {
+            if (typeof payload !== "object" || payload == null)
+                return undefined;
+            const params = payload;
+            const ls_stop = (typeof params.stop_sequences === "string"
+                ? [params.stop_sequences]
+                : params.stop_sequences) ?? undefined;
+            const ls_invocation_params = {};
+            for (const [key, value] of Object.entries(params)) {
+                if (TRACED_INVOCATION_KEYS.includes(key)) {
+                    ls_invocation_params[key] = value;
+                }
+            }
+            return {
+                ls_provider: "anthropic",
+                ls_model_type: "chat",
+                ls_model_name: params.model,
+                ls_max_tokens: params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+                ls_invocation_params,
+            };
+        },
+        processOutputs: processMessageOutput,
+        ...options,
+    };
+    // Create a new messages object preserving the prototype
+    tracedAnthropicClient.messages = Object.create(Object.getPrototypeOf(anthropic.messages));
+    // Copy all own properties
+    Object.assign(tracedAnthropicClient.messages, anthropic.messages);
+    // Wrap messages.create
+    tracedAnthropicClient.messages.create = traceable(anthropic.messages.create.bind(anthropic.messages), messagesCreateConfig);
+    // Wrap messages.stream
+    const originalStream = anthropic.messages.stream.bind(anthropic.messages);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const streamMethod = function (...args) {
+        const stream = originalStream(...args);
+        if ("finalMessage" in stream && typeof stream.finalMessage === "function") {
+            const originalFinalMessage = stream.finalMessage.bind(stream);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            stream.finalMessage = async (...args) => {
+                for await (const _ of stream) {
+                    // consume chunks
+                }
+                return originalFinalMessage(...args);
+            };
+        }
+        return stream;
+    };
+    tracedAnthropicClient.messages.stream = traceable(streamMethod, {
+        name: "ChatAnthropic",
+        run_type: "llm",
+        aggregator: messageAggregator,
+        argsConfigPath: [1, "langsmithExtra"],
+        getInvocationParams: messagesCreateConfig.getInvocationParams,
+        processOutputs: processMessageOutput,
+        ...options,
+    });
+    // Wrap beta.messages if it exists
+    if (anthropic.beta &&
+        anthropic.beta.messages &&
+        typeof anthropic.beta.messages.create === "function") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tracedBeta = { ...anthropic.beta };
+        tracedBeta.messages = Object.create(Object.getPrototypeOf(anthropic.beta.messages));
+        Object.assign(tracedBeta.messages, anthropic.beta.messages);
+        // Wrap beta.messages.create
+        tracedBeta.messages.create = traceable(anthropic.beta.messages.create.bind(anthropic.beta.messages), messagesCreateConfig);
+        // Wrap beta.messages.stream if it exists
+        if (typeof anthropic.beta.messages.stream === "function") {
+            tracedBeta.messages.stream = traceable(anthropic.beta.messages.stream.bind(anthropic.beta.messages), {
+                name: "ChatAnthropic",
+                run_type: "llm",
+                aggregator: messageAggregator,
+                argsConfigPath: [1, "langsmithExtra"],
+                getInvocationParams: messagesCreateConfig.getInvocationParams,
+                processOutputs: processMessageOutput,
+                ...options,
+            });
+        }
+        tracedAnthropicClient.beta = tracedBeta;
+    }
+    return tracedAnthropicClient;
+};

package/dist/wrappers/index.cjs

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapSDK = void 0;
 __exportStar(require("./openai.cjs"), exports);
+__exportStar(require("./anthropic.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,2 +1,3 @@
 export * from "./openai.js";
+export * from "./anthropic.js";
 export { wrapSDK } from "./generic.js";

package/dist/wrappers/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.3.82",
+  "version": "0.3.83-rc.1",
   "description": "Client library to connect to the LangSmith Observability and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -150,6 +150,7 @@
   "devDependencies": {
     "@ai-sdk/anthropic": "^2.0.17",
     "@ai-sdk/openai": "^2.0.23",
+    "@anthropic-ai/sdk": "^0.71.2",
     "@babel/preset-env": "^7.22.4",
     "@faker-js/faker": "^8.4.1",
     "@jest/globals": "^29.5.0",