langsmith 0.5.24 → 0.5.26

package/dist/experimental/anthropic/index.cjs

@@ -4,14 +4,15 @@ exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK;
 const traceable_js_1 = require("../../traceable.cjs");
 const context_js_1 = require("./context.cjs");
 const messages_js_1 = require("./messages.cjs");
+const WRAPPED_TOOL_SYMBOL = Symbol.for("langsmith:claude_agent_sdk:wrapped_tool");
+const WRAPPED_TOOL_HANDLER_SYMBOL = Symbol.for("langsmith:claude_agent_sdk:wrapped_tool_handler");
 /**
  * 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();
+    async function* generator(originalGenerator, prompt, streamManager) {
         try {
             let systemCount = 0;
             for await (const message of originalGenerator) {
@@ -19,9 +20,9 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
                     const content = getLatestInput(prompt, systemCount);
                     systemCount += 1;
                     if (content != null)
-                        streamManager.addMessage(content);
+                        await streamManager.addMessage(content);
                 }
-                streamManager.addMessage(message);
+                await streamManager.addMessage(message);
                 yield message;
             }
         }
@@ -78,6 +79,32 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
             },
         });
     }
+    function addLangSmithHooks(params, streamManager) {
+        const options = { ...(params.options ?? {}) };
+        const hooks = { ...(options.hooks ?? {}) };
+        const addHook = (eventName) => {
+            const existing = Array.isArray(hooks[eventName])
+                ? hooks[eventName]
+                : [];
+            hooks[eventName] = [
+                ...existing,
+                {
+                    hooks: [
+                        async (input, toolUseId) => {
+                            streamManager.addHookEvent(input, toolUseId);
+                            return {};
+                        },
+                    ],
+                },
+            ];
+        };
+        addHook("PreToolUse");
+        addHook("SubagentStart");
+        addHook("SubagentStop");
+        addHook("Stop");
+        options.hooks = hooks;
+        return { ...params, options };
+    }
     function processOutputs(rawOutputs) {
         if ("outputs" in rawOutputs && Array.isArray(rawOutputs.outputs)) {
             const sdkMessages = rawOutputs.outputs;
@@ -87,14 +114,17 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
                     return true;
                 return message.parent_tool_use_id == null;
             })
-                .flatMap(messages_js_1.convertFromAnthropicMessage);
+                .flatMap(messages_js_1.convertFromAnthropicMessage)
+                .reduce((acc, message) => (0, messages_js_1.mergeMessagesById)(acc, [message]), []);
             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);
+        const streamManager = new context_js_1.StreamManager();
+        const paramsWithHooks = addLangSmithHooks(params, streamManager);
+        const actualGenerator = queryFn.call(defaultThis, paramsWithHooks, ...args);
+        const wrappedGenerator = generator(actualGenerator, params.prompt, streamManager);
         for (const method of Object.getOwnPropertyNames(Object.getPrototypeOf(actualGenerator)).filter((method) => !["constructor", "next", "throw", "return"].includes(method))) {
             Object.defineProperty(wrappedGenerator, method, {
                 get() {
@@ -151,16 +181,54 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
 function wrapClaudeAgentSDK(sdk, config) {
     const inputSdk = sdk;
     const wrappedSdk = { ...sdk };
-    if ("query" in inputSdk && (0, traceable_js_1.isTraceableFunction)(inputSdk.query)) {
+    const toolAlreadyWrapped = "tool" in inputSdk &&
+        typeof inputSdk.tool === "function" &&
+        WRAPPED_TOOL_SYMBOL in inputSdk.tool;
+    if (("query" in inputSdk && (0, traceable_js_1.isTraceableFunction)(inputSdk.query)) ||
+        toolAlreadyWrapped) {
         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
+    // Wrap the tool method if it exists. The SDK invokes MCP tool handlers in an
+    // async context that may not inherit the query trace context, so bind nested
+    // traceable calls back to the active tool run when possible.
     if ("tool" in inputSdk && typeof inputSdk.tool === "function") {
-        wrappedSdk.tool = inputSdk.tool.bind(inputSdk);
+        wrappedSdk.tool = (...args) => {
+            const toolName = typeof args[0] === "string" ? args[0] : undefined;
+            let handlerIndex = -1;
+            for (let index = args.length - 1; index >= 0; index -= 1) {
+                if (typeof args[index] === "function") {
+                    handlerIndex = index;
+                    break;
+                }
+            }
+            if (handlerIndex < 0) {
+                return inputSdk.tool?.(...args);
+            }
+            const originalHandler = args[handlerIndex];
+            if (WRAPPED_TOOL_HANDLER_SYMBOL in originalHandler) {
+                return inputSdk.tool?.(...args);
+            }
+            const wrappedHandler = (...handlerArgs) => {
+                const activeToolRun = context_js_1.StreamManager.getActiveToolRun(toolName, handlerArgs[0]);
+                if (activeToolRun == null) {
+                    return originalHandler(...handlerArgs);
+                }
+                return (0, traceable_js_1.withRunTree)(activeToolRun, () => originalHandler(...handlerArgs));
+            };
+            Object.defineProperty(wrappedHandler, WRAPPED_TOOL_HANDLER_SYMBOL, {
+                value: true,
+            });
+            const wrappedArgs = [...args];
+            wrappedArgs[handlerIndex] = wrappedHandler;
+            return inputSdk.tool?.(...wrappedArgs);
+        };
+        Object.defineProperty(wrappedSdk.tool, WRAPPED_TOOL_SYMBOL, {
+            value: true,
+        });
     }
     // Keep createSdkMcpServer and other methods as-is (bound to original SDK)
     if ("createSdkMcpServer" in inputSdk &&

package/dist/experimental/anthropic/index.js

@@ -1,14 +1,15 @@
-import { traceable, isTraceableFunction } from "../../traceable.js";
+import { traceable, isTraceableFunction, withRunTree, } from "../../traceable.js";
 import { StreamManager } from "./context.js";
-import { convertFromAnthropicMessage } from "./messages.js";
+import { convertFromAnthropicMessage, mergeMessagesById } from "./messages.js";
+const WRAPPED_TOOL_SYMBOL = Symbol.for("langsmith:claude_agent_sdk:wrapped_tool");
+const WRAPPED_TOOL_HANDLER_SYMBOL = Symbol.for("langsmith:claude_agent_sdk:wrapped_tool_handler");
 /**
  * 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 StreamManager();
+    async function* generator(originalGenerator, prompt, streamManager) {
         try {
             let systemCount = 0;
             for await (const message of originalGenerator) {
@@ -16,9 +17,9 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
                     const content = getLatestInput(prompt, systemCount);
                     systemCount += 1;
                     if (content != null)
-                        streamManager.addMessage(content);
+                        await streamManager.addMessage(content);
                 }
-                streamManager.addMessage(message);
+                await streamManager.addMessage(message);
                 yield message;
             }
         }
@@ -75,6 +76,32 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
             },
         });
     }
+    function addLangSmithHooks(params, streamManager) {
+        const options = { ...(params.options ?? {}) };
+        const hooks = { ...(options.hooks ?? {}) };
+        const addHook = (eventName) => {
+            const existing = Array.isArray(hooks[eventName])
+                ? hooks[eventName]
+                : [];
+            hooks[eventName] = [
+                ...existing,
+                {
+                    hooks: [
+                        async (input, toolUseId) => {
+                            streamManager.addHookEvent(input, toolUseId);
+                            return {};
+                        },
+                    ],
+                },
+            ];
+        };
+        addHook("PreToolUse");
+        addHook("SubagentStart");
+        addHook("SubagentStop");
+        addHook("Stop");
+        options.hooks = hooks;
+        return { ...params, options };
+    }
     function processOutputs(rawOutputs) {
         if ("outputs" in rawOutputs && Array.isArray(rawOutputs.outputs)) {
             const sdkMessages = rawOutputs.outputs;
@@ -84,14 +111,17 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
                     return true;
                 return message.parent_tool_use_id == null;
             })
-                .flatMap(convertFromAnthropicMessage);
+                .flatMap(convertFromAnthropicMessage)
+                .reduce((acc, message) => mergeMessagesById(acc, [message]), []);
             return { output: { messages } };
         }
         return rawOutputs;
     }
     return traceable((params, ...args) => {
-        const actualGenerator = queryFn.call(defaultThis, params, ...args);
-        const wrappedGenerator = generator(actualGenerator, params.prompt);
+        const streamManager = new StreamManager();
+        const paramsWithHooks = addLangSmithHooks(params, streamManager);
+        const actualGenerator = queryFn.call(defaultThis, paramsWithHooks, ...args);
+        const wrappedGenerator = generator(actualGenerator, params.prompt, streamManager);
         for (const method of Object.getOwnPropertyNames(Object.getPrototypeOf(actualGenerator)).filter((method) => !["constructor", "next", "throw", "return"].includes(method))) {
             Object.defineProperty(wrappedGenerator, method, {
                 get() {
@@ -148,16 +178,54 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
 export function wrapClaudeAgentSDK(sdk, config) {
     const inputSdk = sdk;
     const wrappedSdk = { ...sdk };
-    if ("query" in inputSdk && isTraceableFunction(inputSdk.query)) {
+    const toolAlreadyWrapped = "tool" in inputSdk &&
+        typeof inputSdk.tool === "function" &&
+        WRAPPED_TOOL_SYMBOL in inputSdk.tool;
+    if (("query" in inputSdk && isTraceableFunction(inputSdk.query)) ||
+        toolAlreadyWrapped) {
         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
+    // Wrap the tool method if it exists. The SDK invokes MCP tool handlers in an
+    // async context that may not inherit the query trace context, so bind nested
+    // traceable calls back to the active tool run when possible.
     if ("tool" in inputSdk && typeof inputSdk.tool === "function") {
-        wrappedSdk.tool = inputSdk.tool.bind(inputSdk);
+        wrappedSdk.tool = (...args) => {
+            const toolName = typeof args[0] === "string" ? args[0] : undefined;
+            let handlerIndex = -1;
+            for (let index = args.length - 1; index >= 0; index -= 1) {
+                if (typeof args[index] === "function") {
+                    handlerIndex = index;
+                    break;
+                }
+            }
+            if (handlerIndex < 0) {
+                return inputSdk.tool?.(...args);
+            }
+            const originalHandler = args[handlerIndex];
+            if (WRAPPED_TOOL_HANDLER_SYMBOL in originalHandler) {
+                return inputSdk.tool?.(...args);
+            }
+            const wrappedHandler = (...handlerArgs) => {
+                const activeToolRun = StreamManager.getActiveToolRun(toolName, handlerArgs[0]);
+                if (activeToolRun == null) {
+                    return originalHandler(...handlerArgs);
+                }
+                return withRunTree(activeToolRun, () => originalHandler(...handlerArgs));
+            };
+            Object.defineProperty(wrappedHandler, WRAPPED_TOOL_HANDLER_SYMBOL, {
+                value: true,
+            });
+            const wrappedArgs = [...args];
+            wrappedArgs[handlerIndex] = wrappedHandler;
+            return inputSdk.tool?.(...wrappedArgs);
+        };
+        Object.defineProperty(wrappedSdk.tool, WRAPPED_TOOL_SYMBOL, {
+            value: true,
+        });
     }
     // Keep createSdkMcpServer and other methods as-is (bound to original SDK)
     if ("createSdkMcpServer" in inputSdk &&

package/dist/experimental/anthropic/messages.cjs

@@ -1,10 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeMessagesById = mergeMessagesById;
 exports.flattenContentBlocks = flattenContentBlocks;
 exports.convertFromAnthropicMessage = convertFromAnthropicMessage;
 exports.isTaskTool = isTaskTool;
 exports.isToolBlock = isToolBlock;
 const utils_js_1 = require("./utils.cjs");
+function getContentBlockKey(block) {
+    if (typeof block !== "object" || block == null)
+        return undefined;
+    const record = block;
+    if (typeof record.id === "string")
+        return `id:${record.id}`;
+    if (typeof record.signature === "string")
+        return `signature:${record.signature}`;
+    if (typeof record.type === "string" && typeof record.text === "string") {
+        return `text:${record.text}`;
+    }
+    try {
+        return `json:${JSON.stringify(record)}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mergeContentBlocks(existing, incoming) {
+    if (!Array.isArray(existing) || !Array.isArray(incoming))
+        return incoming;
+    const merged = [...existing];
+    const keys = new Set(merged.map(getContentBlockKey).filter(Boolean));
+    for (const block of incoming) {
+        const key = getContentBlockKey(block);
+        if (key != null && keys.has(key))
+            continue;
+        merged.push(block);
+        if (key != null)
+            keys.add(key);
+    }
+    return merged;
+}
+function mergeMessagesById(previousMessages, newMessages) {
+    const merged = [...previousMessages];
+    for (const message of newMessages) {
+        const existingIndex = merged.findIndex((prev) => prev.role === message.role &&
+            message.id != null &&
+            prev.id === message.id);
+        if (existingIndex < 0) {
+            merged.push(message);
+            continue;
+        }
+        const existing = merged[existingIndex];
+        merged[existingIndex] = {
+            ...existing,
+            ...message,
+            content: mergeContentBlocks(existing.content, message.content),
+        };
+    }
+    return merged;
+}
 /**
  * Converts SDK content blocks into serializable objects.
  * Matches Python's flatten_content_blocks behavior.

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

@@ -1,4 +1,10 @@
 import type { BetaContentBlock } from "./types.js";
+export type LangSmithMessage = {
+    content?: unknown;
+    role?: string;
+    id?: string;
+} & Record<string, unknown>;
+export declare function mergeMessagesById(previousMessages: LangSmithMessage[], newMessages: LangSmithMessage[]): LangSmithMessage[];
 /**
  * Converts SDK content blocks into serializable objects.
  * Matches Python's flatten_content_blocks behavior.

package/dist/experimental/anthropic/messages.js

@@ -1,4 +1,56 @@
 import { isIterable } from "./utils.js";
+function getContentBlockKey(block) {
+    if (typeof block !== "object" || block == null)
+        return undefined;
+    const record = block;
+    if (typeof record.id === "string")
+        return `id:${record.id}`;
+    if (typeof record.signature === "string")
+        return `signature:${record.signature}`;
+    if (typeof record.type === "string" && typeof record.text === "string") {
+        return `text:${record.text}`;
+    }
+    try {
+        return `json:${JSON.stringify(record)}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mergeContentBlocks(existing, incoming) {
+    if (!Array.isArray(existing) || !Array.isArray(incoming))
+        return incoming;
+    const merged = [...existing];
+    const keys = new Set(merged.map(getContentBlockKey).filter(Boolean));
+    for (const block of incoming) {
+        const key = getContentBlockKey(block);
+        if (key != null && keys.has(key))
+            continue;
+        merged.push(block);
+        if (key != null)
+            keys.add(key);
+    }
+    return merged;
+}
+export function mergeMessagesById(previousMessages, newMessages) {
+    const merged = [...previousMessages];
+    for (const message of newMessages) {
+        const existingIndex = merged.findIndex((prev) => prev.role === message.role &&
+            message.id != null &&
+            prev.id === message.id);
+        if (existingIndex < 0) {
+            merged.push(message);
+            continue;
+        }
+        const existing = merged[existingIndex];
+        merged[existingIndex] = {
+            ...existing,
+            ...message,
+            content: mergeContentBlocks(existing.content, message.content),
+        };
+    }
+    return merged;
+}
 /**
  * Converts SDK content blocks into serializable objects.
  * Matches Python's flatten_content_blocks behavior.

package/dist/experimental/anthropic/transcripts.cjs

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTranscript = readTranscript;
+const promises_1 = require("node:fs/promises");
+const messages_js_1 = require("./messages.cjs");
+const usage_js_1 = require("./usage.cjs");
+function parseTimestamp(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return undefined;
+    const timestamp = Date.parse(value);
+    return Number.isNaN(timestamp) ? undefined : timestamp;
+}
+function isRecord(value) {
+    return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function toSDKAssistantMessage(data) {
+    const message = data.message;
+    if (!isRecord(message))
+        return undefined;
+    const id = message.id;
+    if (typeof id !== "string" || id.length === 0)
+        return undefined;
+    return {
+        type: "assistant",
+        parent_tool_use_id: typeof data.parent_tool_use_id === "string"
+            ? data.parent_tool_use_id
+            : null,
+        message: {
+            ...message,
+            id,
+            content: Array.isArray(message.content)
+                ? message.content
+                : [],
+        },
+    };
+}
+function toSDKUserMessage(data) {
+    const message = data.message;
+    if (!isRecord(message))
+        return undefined;
+    return {
+        type: "user",
+        parent_tool_use_id: typeof data.parent_tool_use_id === "string"
+            ? data.parent_tool_use_id
+            : null,
+        session_id: typeof data.session_id === "string" ? data.session_id : "",
+        message: message,
+        tool_use_result: data.tool_use_result,
+    };
+}
+/**
+ * Read a Claude Agent SDK JSONL transcript and return final assistant turns,
+ * final usage by message id, and tool_result blocks.
+ *
+ * The transcript format is not a contracted SDK API. This mirrors the Python
+ * reconciler and is intentionally best-effort: malformed lines and unreadable
+ * files are ignored so tracing never affects the user conversation.
+ * @internal
+ */
+async function readTranscript(filePath) {
+    let contents;
+    try {
+        contents = await (0, promises_1.readFile)(filePath, "utf8");
+    }
+    catch {
+        return { turns: [], usageByMessageId: {}, toolResults: [] };
+    }
+    const entriesById = new Map();
+    const usageByMessageId = {};
+    const toolResults = [];
+    const conversation = [];
+    for (const line of contents.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let data;
+        try {
+            data = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(data))
+            continue;
+        if (data.type === "user") {
+            const sdkMessage = toSDKUserMessage(data);
+            if (sdkMessage == null)
+                continue;
+            const content = sdkMessage.message.content;
+            const toolUseResultIsError = isRecord(sdkMessage.tool_use_result)
+                ? sdkMessage.tool_use_result.is_error === true ||
+                    sdkMessage.tool_use_result.isError === true
+                : false;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (!isRecord(block) || block.type !== "tool_result")
+                        continue;
+                    const toolUseId = block.tool_use_id;
+                    if (typeof toolUseId !== "string")
+                        continue;
+                    toolResults.push({
+                        toolUseId,
+                        content: block.content,
+                        isError: block.is_error === true ||
+                            block.isError === true ||
+                            toolUseResultIsError,
+                    });
+                }
+            }
+            conversation.push(...(0, messages_js_1.convertFromAnthropicMessage)(sdkMessage));
+            continue;
+        }
+        if (data.type !== "assistant")
+            continue;
+        const sdkMessage = toSDKAssistantMessage(data);
+        if (sdkMessage == null)
+            continue;
+        const messageId = sdkMessage.message.id;
+        const rawUsage = sdkMessage.message.usage;
+        if (rawUsage != null) {
+            usageByMessageId[messageId] = (0, usage_js_1.extractUsageMetadata)(rawUsage);
+        }
+        const turn = {
+            messageId,
+            model: sdkMessage.message.model,
+            content: sdkMessage.message.content,
+            usage: rawUsage,
+            usageMetadata: rawUsage != null ? (0, usage_js_1.extractUsageMetadata)(rawUsage) : undefined,
+            timestamp: parseTimestamp(data.timestamp),
+            inputMessages: conversation.slice(),
+            message: sdkMessage,
+        };
+        // Always overwrite. The final chunk (where stop_reason is set) appears last.
+        entriesById.set(messageId, turn);
+        if (sdkMessage.message.stop_reason) {
+            conversation.push(...(0, messages_js_1.convertFromAnthropicMessage)(sdkMessage));
+        }
+    }
+    return {
+        turns: Array.from(entriesById.values()).filter((turn) => turn.message.message.stop_reason),
+        usageByMessageId,
+        toolResults,
+    };
+}

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

@@ -0,0 +1,22 @@
+import { type LangSmithMessage } from "./messages.js";
+import type { SDKAssistantMessage } from "./types.js";
+export type TranscriptAssistantTurn = {
+    messageId: string;
+    model?: string;
+    content: Record<string, unknown>[];
+    usage?: Record<string, unknown>;
+    usageMetadata?: Record<string, unknown>;
+    timestamp?: number;
+    inputMessages: LangSmithMessage[];
+    message: SDKAssistantMessage;
+};
+export type TranscriptToolResult = {
+    toolUseId: string;
+    content: unknown;
+    isError?: boolean;
+};
+export type TranscriptData = {
+    turns: TranscriptAssistantTurn[];
+    usageByMessageId: Record<string, Record<string, unknown>>;
+    toolResults: TranscriptToolResult[];
+};