langsmith 0.4.7 → 0.4.9

package/dist/client.cjs

@@ -429,6 +429,12 @@ class Client {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_runCompressionDisabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, env_js_1.getLangSmithEnvironmentVariable)("DISABLE_RUN_COMPRESSION") === "true"
+        });
         Object.defineProperty(this, "debug", {
             enumerable: true,
             configurable: true,
@@ -806,7 +812,8 @@ class Client {
                 const useMultipart = !this._multipartDisabled &&
                     (serverInfo?.batch_ingest_config?.use_multipart_endpoint ?? true);
                 if (useMultipart) {
-                    const useGzip = serverInfo?.instance_flags?.gzip_body_enabled;
+                    const useGzip = !this._runCompressionDisabled &&
+                        serverInfo?.instance_flags?.gzip_body_enabled;
                     try {
                         await this.multipartIngestRuns(ingestParams, {
                             ...options,
@@ -2187,7 +2194,8 @@ class Client {
     async uploadCsv({ csvFile, fileName, inputKeys, outputKeys, description, dataType, name, }) {
         const url = `${this.apiUrl}/datasets/upload`;
         const formData = new FormData();
-        formData.append("file", csvFile, fileName);
+        const csvBlob = new Blob([csvFile], { type: "text/csv" });
+        formData.append("file", csvBlob, fileName);
         inputKeys.forEach((key) => {
             formData.append("input_keys", key);
         });

package/dist/client.d.ts

@@ -378,6 +378,7 @@ export declare class Client implements LangSmithTracingClientInterface {
     private get _fetch();
     private multipartStreamingDisabled;
     private _multipartDisabled;
+    private _runCompressionDisabled;
     debug: boolean;
     constructor(config?: ClientConfig);
     static getDefaultClientConfig(): {

package/dist/client.js

@@ -391,6 +391,12 @@ export class Client {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_runCompressionDisabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getLangSmithEnvironmentVariable("DISABLE_RUN_COMPRESSION") === "true"
+        });
         Object.defineProperty(this, "debug", {
             enumerable: true,
             configurable: true,
@@ -768,7 +774,8 @@ export class Client {
                 const useMultipart = !this._multipartDisabled &&
                     (serverInfo?.batch_ingest_config?.use_multipart_endpoint ?? true);
                 if (useMultipart) {
-                    const useGzip = serverInfo?.instance_flags?.gzip_body_enabled;
+                    const useGzip = !this._runCompressionDisabled &&
+                        serverInfo?.instance_flags?.gzip_body_enabled;
                     try {
                         await this.multipartIngestRuns(ingestParams, {
                             ...options,
@@ -2149,7 +2156,8 @@ export class Client {
     async uploadCsv({ csvFile, fileName, inputKeys, outputKeys, description, dataType, name, }) {
         const url = `${this.apiUrl}/datasets/upload`;
         const formData = new FormData();
-        formData.append("file", csvFile, fileName);
+        const csvBlob = new Blob([csvFile], { type: "text/csv" });
+        formData.append("file", csvBlob, fileName);
         inputKeys.forEach((key) => {
             formData.append("input_keys", key);
         });

package/dist/experimental/anthropic/context.cjs

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamManager = void 0;
+const messages_js_1 = require("./messages.cjs");
+const traceable_js_1 = require("../../traceable.cjs");
+const usage_js_1 = require("./usage.cjs");
+/**
+ * @internal
+ */
+class StreamManager {
+    constructor() {
+        Object.defineProperty(this, "namespaces", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "history", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "assistant", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "postRunQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "runTrees", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        const rootRun = (0, traceable_js_1.getCurrentRunTree)(true);
+        this.namespaces = rootRun?.createChild ? { root: rootRun } : {};
+        this.history = { root: [] };
+    }
+    addMessage(message) {
+        const eventTime = Date.now();
+        // Short-circuit if no root run found
+        // This can happen if tracing is disabled globally
+        if (this.namespaces["root"] == null)
+            return;
+        if (message.type === "result") {
+            if (message.modelUsage) {
+                (0, usage_js_1.correctUsageFromResults)(message.modelUsage, Object.values(this.assistant));
+            }
+            const usage = message.modelUsage
+                ? (0, usage_js_1.aggregateUsageFromModelUsage)(message.modelUsage)
+                : (0, usage_js_1.extractUsageFromMessage)(message);
+            if (message.total_cost_usd != null && usage != null) {
+                usage.total_cost = message.total_cost_usd;
+            }
+            this.namespaces["root"].extra ??= {};
+            this.namespaces["root"].extra.metadata ??= {};
+            this.namespaces["root"].extra.metadata.usage_metadata = usage;
+            this.namespaces["root"].extra.metadata.is_error = message.is_error;
+            this.namespaces["root"].extra.metadata.num_turns = message.num_turns;
+            this.namespaces["root"].extra.metadata.session_id = message.session_id;
+            this.namespaces["root"].extra.metadata.duration_ms = message.duration_ms;
+            this.namespaces["root"].extra.metadata.duration_api_ms =
+                message.duration_api_ms;
+        }
+        // Skip non-user / non-assistant messages
+        if (!("message" in message))
+            return;
+        const namespace = (() => {
+            if ("parent_tool_use_id" in message)
+                return message.parent_tool_use_id ?? "root";
+            return "root";
+        })();
+        // `eventTime` records the time we receive an event, which for `includePartialMessages: false`
+        // equals to the end time of an LLM block, so we need to use the first available end time within namespace.
+        const candidateStartTime = this.namespaces[namespace]?.child_runs?.at(-1)?.end_time ??
+            this.namespaces[namespace]?.start_time ??
+            eventTime;
+        this.history[namespace] ??= this.history["root"].slice();
+        if (message.type === "assistant") {
+            const messageId = message.message.id;
+            this.assistant[messageId] ??= this.createChild(namespace, {
+                name: "claude.assistant.turn",
+                run_type: "llm",
+                start_time: candidateStartTime,
+                inputs: {
+                    messages: (0, messages_js_1.convertFromAnthropicMessage)(this.history[namespace]),
+                },
+                outputs: { output: { messages: [] } },
+            });
+            this.assistant[messageId].outputs = (() => {
+                const prevMessages = this.assistant[messageId].outputs?.output.messages ?? [];
+                const newMessages = (0, messages_js_1.convertFromAnthropicMessage)([message]);
+                return { output: { messages: [...prevMessages, ...newMessages] } };
+            })();
+            this.assistant[messageId].end_time = eventTime;
+            this.assistant[messageId].extra ??= {};
+            this.assistant[messageId].extra.metadata ??= {};
+            if (message.message.model != null) {
+                this.assistant[messageId].extra.metadata.ls_model_name =
+                    message.message.model;
+            }
+            this.assistant[messageId].extra.metadata.usage_metadata =
+                (0, usage_js_1.extractUsageFromMessage)(message);
+            const tools = Array.isArray(message.message.content)
+                ? message.message.content.filter((block) => (0, messages_js_1.isToolBlock)(block))
+                : [];
+            for (const block of tools) {
+                if ((0, messages_js_1.isTaskTool)(block)) {
+                    const name = block.input.subagent_type ||
+                        block.input.agent_type ||
+                        (block.input.description
+                            ? block.input.description.split(" ")[0]
+                            : null) ||
+                        "unknown-agent";
+                    this.tools[block.id] ??= this.createChild("root", {
+                        name,
+                        run_type: "chain",
+                        inputs: block.input,
+                        start_time: eventTime,
+                    });
+                    this.namespaces[block.id] ??= this.tools[block.id];
+                }
+                else {
+                    const name = block.name || "unknown-tool";
+                    this.tools[block.id] ??= this.createChild(namespace, {
+                        name,
+                        run_type: "tool",
+                        inputs: block.input ? { input: block.input } : {},
+                        start_time: eventTime,
+                    });
+                }
+            }
+        }
+        if (message.type === "user") {
+            if (message.tool_use_result) {
+                const toolResult = Array.isArray(message.message.content)
+                    ? message.message.content.find((block) => "tool_use_id" in block)
+                    : undefined;
+                if (toolResult?.tool_use_id &&
+                    this.tools[toolResult.tool_use_id] != null) {
+                    const toolOutput = Array.isArray(message.tool_use_result)
+                        ? { content: message.tool_use_result }
+                        : message.tool_use_result;
+                    const toolError = "is_error" in toolResult && toolResult.is_error === true
+                        ? ["string", "number", "boolean"].includes(typeof message.tool_use_result)
+                            ? String(message.tool_use_result)
+                            : JSON.stringify(message.tool_use_result)
+                        : undefined;
+                    void this.tools[toolResult.tool_use_id].end(toolOutput, toolError);
+                }
+            }
+        }
+        this.history[namespace].push(message);
+    }
+    createChild(namespace, args) {
+        const runTree = this.namespaces[namespace].createChild(args);
+        this.postRunQueue.push(runTree.postRun());
+        this.runTrees.push(runTree);
+        return runTree;
+    }
+    async finish() {
+        // Clean up incomplete tools and subagent calls
+        for (const tool of Object.values(this.tools)) {
+            if (tool.outputs == null && tool.error == null) {
+                void tool.end(undefined, "Run not completed (conversation ended)");
+            }
+        }
+        // First make sure all the runs are created
+        await Promise.allSettled(this.postRunQueue);
+        // Then patch the runs
+        await Promise.allSettled(this.runTrees.map((runTree) => runTree.patchRun()));
+    }
+}
+exports.StreamManager = StreamManager;

package/dist/experimental/anthropic/context.d.ts

@@ -0,0 +1,5 @@
+import type { RunTreeConfig } from "../../run_trees.js";
+/**
+ * Configuration options for wrapping Claude Agent SDK with LangSmith tracing.
+ */
+export type WrapClaudeAgentSDKConfig = Partial<Omit<RunTreeConfig, "inputs" | "outputs" | "run_type" | "child_runs" | "parent_run" | "error">>;

package/dist/experimental/anthropic/context.js

@@ -0,0 +1,183 @@
+import { convertFromAnthropicMessage, isTaskTool, isToolBlock, } from "./messages.js";
+import { getCurrentRunTree } from "../../traceable.js";
+import { aggregateUsageFromModelUsage, correctUsageFromResults, extractUsageFromMessage, } from "./usage.js";
+/**
+ * @internal
+ */
+export class StreamManager {
+    constructor() {
+        Object.defineProperty(this, "namespaces", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "history", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "assistant", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "postRunQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "runTrees", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        const rootRun = getCurrentRunTree(true);
+        this.namespaces = rootRun?.createChild ? { root: rootRun } : {};
+        this.history = { root: [] };
+    }
+    addMessage(message) {
+        const eventTime = Date.now();
+        // Short-circuit if no root run found
+        // This can happen if tracing is disabled globally
+        if (this.namespaces["root"] == null)
+            return;
+        if (message.type === "result") {
+            if (message.modelUsage) {
+                correctUsageFromResults(message.modelUsage, Object.values(this.assistant));
+            }
+            const usage = message.modelUsage
+                ? aggregateUsageFromModelUsage(message.modelUsage)
+                : extractUsageFromMessage(message);
+            if (message.total_cost_usd != null && usage != null) {
+                usage.total_cost = message.total_cost_usd;
+            }
+            this.namespaces["root"].extra ??= {};
+            this.namespaces["root"].extra.metadata ??= {};
+            this.namespaces["root"].extra.metadata.usage_metadata = usage;
+            this.namespaces["root"].extra.metadata.is_error = message.is_error;
+            this.namespaces["root"].extra.metadata.num_turns = message.num_turns;
+            this.namespaces["root"].extra.metadata.session_id = message.session_id;
+            this.namespaces["root"].extra.metadata.duration_ms = message.duration_ms;
+            this.namespaces["root"].extra.metadata.duration_api_ms =
+                message.duration_api_ms;
+        }
+        // Skip non-user / non-assistant messages
+        if (!("message" in message))
+            return;
+        const namespace = (() => {
+            if ("parent_tool_use_id" in message)
+                return message.parent_tool_use_id ?? "root";
+            return "root";
+        })();
+        // `eventTime` records the time we receive an event, which for `includePartialMessages: false`
+        // equals to the end time of an LLM block, so we need to use the first available end time within namespace.
+        const candidateStartTime = this.namespaces[namespace]?.child_runs?.at(-1)?.end_time ??
+            this.namespaces[namespace]?.start_time ??
+            eventTime;
+        this.history[namespace] ??= this.history["root"].slice();
+        if (message.type === "assistant") {
+            const messageId = message.message.id;
+            this.assistant[messageId] ??= this.createChild(namespace, {
+                name: "claude.assistant.turn",
+                run_type: "llm",
+                start_time: candidateStartTime,
+                inputs: {
+                    messages: convertFromAnthropicMessage(this.history[namespace]),
+                },
+                outputs: { output: { messages: [] } },
+            });
+            this.assistant[messageId].outputs = (() => {
+                const prevMessages = this.assistant[messageId].outputs?.output.messages ?? [];
+                const newMessages = convertFromAnthropicMessage([message]);
+                return { output: { messages: [...prevMessages, ...newMessages] } };
+            })();
+            this.assistant[messageId].end_time = eventTime;
+            this.assistant[messageId].extra ??= {};
+            this.assistant[messageId].extra.metadata ??= {};
+            if (message.message.model != null) {
+                this.assistant[messageId].extra.metadata.ls_model_name =
+                    message.message.model;
+            }
+            this.assistant[messageId].extra.metadata.usage_metadata =
+                extractUsageFromMessage(message);
+            const tools = Array.isArray(message.message.content)
+                ? message.message.content.filter((block) => isToolBlock(block))
+                : [];
+            for (const block of tools) {
+                if (isTaskTool(block)) {
+                    const name = block.input.subagent_type ||
+                        block.input.agent_type ||
+                        (block.input.description
+                            ? block.input.description.split(" ")[0]
+                            : null) ||
+                        "unknown-agent";
+                    this.tools[block.id] ??= this.createChild("root", {
+                        name,
+                        run_type: "chain",
+                        inputs: block.input,
+                        start_time: eventTime,
+                    });
+                    this.namespaces[block.id] ??= this.tools[block.id];
+                }
+                else {
+                    const name = block.name || "unknown-tool";
+                    this.tools[block.id] ??= this.createChild(namespace, {
+                        name,
+                        run_type: "tool",
+                        inputs: block.input ? { input: block.input } : {},
+                        start_time: eventTime,
+                    });
+                }
+            }
+        }
+        if (message.type === "user") {
+            if (message.tool_use_result) {
+                const toolResult = Array.isArray(message.message.content)
+                    ? message.message.content.find((block) => "tool_use_id" in block)
+                    : undefined;
+                if (toolResult?.tool_use_id &&
+                    this.tools[toolResult.tool_use_id] != null) {
+                    const toolOutput = Array.isArray(message.tool_use_result)
+                        ? { content: message.tool_use_result }
+                        : message.tool_use_result;
+                    const toolError = "is_error" in toolResult && toolResult.is_error === true
+                        ? ["string", "number", "boolean"].includes(typeof message.tool_use_result)
+                            ? String(message.tool_use_result)
+                            : JSON.stringify(message.tool_use_result)
+                        : undefined;
+                    void this.tools[toolResult.tool_use_id].end(toolOutput, toolError);
+                }
+            }
+        }
+        this.history[namespace].push(message);
+    }
+    createChild(namespace, args) {
+        const runTree = this.namespaces[namespace].createChild(args);
+        this.postRunQueue.push(runTree.postRun());
+        this.runTrees.push(runTree);
+        return runTree;
+    }
+    async finish() {
+        // Clean up incomplete tools and subagent calls
+        for (const tool of Object.values(this.tools)) {
+            if (tool.outputs == null && tool.error == null) {
+                void tool.end(undefined, "Run not completed (conversation ended)");
+            }
+        }
+        // First make sure all the runs are created
+        await Promise.allSettled(this.postRunQueue);
+        // Then patch the runs
+        await Promise.allSettled(this.runTrees.map((runTree) => runTree.patchRun()));
+    }
+}

package/dist/experimental/anthropic/index.cjs

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK;
+const traceable_js_1 = require("../../traceable.cjs");
+const context_js_1 = require("./context.cjs");
+const messages_js_1 = require("./messages.cjs");
+/**
+ * Wraps the Claude Agent SDK's query function to add LangSmith tracing.
+ * Traces the entire agent interaction including all streaming messages.
+ * @internal Use `wrapClaudeAgentSDK` instead.
+ */
+function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
+    async function* generator(originalGenerator, prompt) {
+        const streamManager = new context_js_1.StreamManager();
+        try {
+            let systemCount = 0;
+            for await (const message of originalGenerator) {
+                if (message.type === "system") {
+                    const content = getLatestInput(prompt, systemCount);
+                    systemCount += 1;
+                    if (content != null)
+                        streamManager.addMessage(content);
+                }
+                streamManager.addMessage(message);
+                yield message;
+            }
+        }
+        finally {
+            await streamManager.finish();
+        }
+    }
+    function getLatestInput(arg, systemCount) {
+        const value = (() => {
+            if (typeof arg !== "object" || arg == null)
+                return arg;
+            const toJSON = arg["toJSON"];
+            if (typeof toJSON !== "function")
+                return undefined;
+            const latest = toJSON();
+            return latest?.at(systemCount);
+        })();
+        if (value == null)
+            return undefined;
+        if (typeof value === "string") {
+            return {
+                type: "user",
+                message: { content: value, role: "user" },
+                parent_tool_use_id: null,
+                session_id: "",
+            };
+        }
+        return typeof value === "object" && value != null ? value : undefined;
+    }
+    async function processInputs(rawInputs) {
+        const inputs = rawInputs;
+        const newInputs = { ...inputs };
+        return Object.assign(newInputs, {
+            toJSON: () => {
+                const toJSON = (value) => {
+                    if (typeof value !== "object" || value == null)
+                        return value;
+                    const fn = value?.toJSON;
+                    if (typeof fn === "function")
+                        return fn();
+                    return value;
+                };
+                const prompt = toJSON(inputs.prompt);
+                const options = inputs.options != null
+                    ? { ...inputs.options }
+                    : undefined;
+                if (options?.mcpServers != null) {
+                    options.mcpServers = Object.fromEntries(Object.entries(options.mcpServers ?? {}).map(([key, value]) => [
+                        key,
+                        { name: value.name, type: value.type },
+                    ]));
+                }
+                return { messages: (0, messages_js_1.convertFromAnthropicMessage)(prompt), options };
+            },
+        });
+    }
+    function processOutputs(rawOutputs) {
+        if ("outputs" in rawOutputs && Array.isArray(rawOutputs.outputs)) {
+            const sdkMessages = rawOutputs.outputs;
+            const messages = sdkMessages
+                .filter((message) => {
+                if (!("message" in message))
+                    return true;
+                return message.parent_tool_use_id == null;
+            })
+                .flatMap(messages_js_1.convertFromAnthropicMessage);
+            return { output: { messages } };
+        }
+        return rawOutputs;
+    }
+    return (0, traceable_js_1.traceable)((params, ...args) => {
+        const actualGenerator = queryFn.call(defaultThis, params, ...args);
+        const wrappedGenerator = generator(actualGenerator, params.prompt);
+        for (const method of Object.getOwnPropertyNames(Object.getPrototypeOf(actualGenerator)).filter((method) => !["constructor", "next", "throw", "return"].includes(method))) {
+            Object.defineProperty(wrappedGenerator, method, {
+                get() {
+                    const getValue = actualGenerator?.[method];
+                    if (typeof getValue === "function")
+                        return getValue.bind(actualGenerator);
+                    return getValue;
+                },
+            });
+        }
+        return wrappedGenerator;
+    }, {
+        name: "claude.conversation",
+        run_type: "chain",
+        ...baseConfig,
+        metadata: { ...baseConfig?.metadata },
+        __deferredSerializableArgOptions: { maxDepth: 1 },
+        processInputs,
+        processOutputs,
+    });
+}
+/**
+ * Wraps the Claude Agent SDK with LangSmith tracing. This returns wrapped versions
+ * of query and tool that automatically trace all agent interactions.
+ *
+ * @param sdk - The Claude Agent SDK module
+ * @param config - Optional LangSmith configuration
+ * @returns Object with wrapped query, tool, and createSdkMcpServer functions
+ *
+ * @example
+ * ```typescript
+ * import * as claudeSDK from "@anthropic-ai/claude-agent-sdk";
+ * import { wrapClaudeAgentSDK } from "langsmith/experimental/claude_agent_sdk";
+ *
+ * // Wrap once - returns { query, tool, createSdkMcpServer } with tracing built-in
+ * const { query, tool, createSdkMcpServer } = wrapClaudeAgentSDK(claudeSDK);
+ *
+ * // Use normally - tracing is automatic
+ * for await (const message of query({
+ *   prompt: "Hello, Claude!",
+ *   options: { model: "claude-haiku-4-5-20251001" }
+ * })) {
+ *   console.log(message);
+ * }
+ *
+ * // Tools created with wrapped tool() are automatically traced
+ * const calculator = tool("calculator", "Does math", schema, handler);
+ * ```
+ */
+function wrapClaudeAgentSDK(sdk, config) {
+    const inputSdk = sdk;
+    const wrappedSdk = { ...sdk };
+    if ("query" in inputSdk && (0, traceable_js_1.isTraceableFunction)(inputSdk.query)) {
+        throw new Error("This instance of Claude Agent SDK has been already wrapped by `wrapClaudeAgentSDK`.");
+    }
+    // Wrap the query method if it exists
+    if ("query" in inputSdk && typeof inputSdk.query === "function") {
+        wrappedSdk.query = wrapClaudeAgentQuery(inputSdk.query, inputSdk, config);
+    }
+    // Wrap the tool method if it exists
+    if ("tool" in inputSdk && typeof inputSdk.tool === "function") {
+        wrappedSdk.tool = inputSdk.tool.bind(inputSdk);
+    }
+    // Keep createSdkMcpServer and other methods as-is (bound to original SDK)
+    if ("createSdkMcpServer" in inputSdk &&
+        typeof inputSdk.createSdkMcpServer === "function") {
+        wrappedSdk.createSdkMcpServer = inputSdk.createSdkMcpServer.bind(inputSdk);
+    }
+    if ("unstable_v2_createSession" in inputSdk &&
+        typeof inputSdk.unstable_v2_createSession === "function") {
+        wrappedSdk.unstable_v2_createSession = (...args) => {
+            console.warn("Tracing of `unstable_v2_createSession` is not supported by LangSmith. Tracing will not be applied.");
+            return inputSdk.unstable_v2_createSession?.(...args);
+        };
+    }
+    if ("unstable_v2_prompt" in inputSdk &&
+        typeof inputSdk.unstable_v2_prompt === "function") {
+        wrappedSdk.unstable_v2_prompt = (...args) => {
+            console.warn("Tracing of `unstable_v2_prompt` is not supported by LangSmith. Tracing will not be applied.");
+            return inputSdk.unstable_v2_prompt?.(...args);
+        };
+    }
+    if ("unstable_v2_resumeSession" in inputSdk &&
+        typeof inputSdk.unstable_v2_resumeSession === "function") {
+        wrappedSdk.unstable_v2_resumeSession = (...args) => {
+            console.warn("Tracing of `unstable_v2_resumeSession` is not supported by LangSmith. Tracing will not be applied.");
+            return inputSdk.unstable_v2_resumeSession?.(...args);
+        };
+    }
+    return wrappedSdk;
+}

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

@@ -0,0 +1,30 @@
+import { type WrapClaudeAgentSDKConfig } from "./context.js";
+/**
+ * Wraps the Claude Agent SDK with LangSmith tracing. This returns wrapped versions
+ * of query and tool that automatically trace all agent interactions.
+ *
+ * @param sdk - The Claude Agent SDK module
+ * @param config - Optional LangSmith configuration
+ * @returns Object with wrapped query, tool, and createSdkMcpServer functions
+ *
+ * @example
+ * ```typescript
+ * import * as claudeSDK from "@anthropic-ai/claude-agent-sdk";
+ * import { wrapClaudeAgentSDK } from "langsmith/experimental/claude_agent_sdk";
+ *
+ * // Wrap once - returns { query, tool, createSdkMcpServer } with tracing built-in
+ * const { query, tool, createSdkMcpServer } = wrapClaudeAgentSDK(claudeSDK);
+ *
+ * // Use normally - tracing is automatic
+ * for await (const message of query({
+ *   prompt: "Hello, Claude!",
+ *   options: { model: "claude-haiku-4-5-20251001" }
+ * })) {
+ *   console.log(message);
+ * }
+ *
+ * // Tools created with wrapped tool() are automatically traced
+ * const calculator = tool("calculator", "Does math", schema, handler);
+ * ```
+ */
+export declare function wrapClaudeAgentSDK<T extends object>(sdk: T, config?: WrapClaudeAgentSDKConfig): T;