langsmith 0.5.25 → 0.5.26

package/dist/experimental/anthropic/transcripts.js

@@ -0,0 +1,141 @@
+import { readFile } from "node:fs/promises";
+import { convertFromAnthropicMessage, } from "./messages.js";
+import { extractUsageMetadata } from "./usage.js";
+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
+ */
+export async function readTranscript(filePath) {
+    let contents;
+    try {
+        contents = await 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(...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] = extractUsageMetadata(rawUsage);
+        }
+        const turn = {
+            messageId,
+            model: sdkMessage.message.model,
+            content: sdkMessage.message.content,
+            usage: rawUsage,
+            usageMetadata: rawUsage != null ? 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(...convertFromAnthropicMessage(sdkMessage));
+        }
+    }
+    return {
+        turns: Array.from(entriesById.values()).filter((turn) => turn.message.message.stop_reason),
+        usageByMessageId,
+        toolResults,
+    };
+}

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

@@ -6,6 +6,7 @@ export type SDKAssistantMessage = {
         content: Record<string, any>[];
         usage?: Record<string, any>;
         model?: string;
+        stop_reason?: string | null;
     };
     parent_tool_use_id: string | null;
 };

package/dist/experimental/anthropic/usage.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aggregateUsageFromModelUsage = aggregateUsageFromModelUsage;
+exports.extractUsageMetadata = extractUsageMetadata;
 exports.extractUsageFromMessage = extractUsageFromMessage;
 exports.correctUsageFromResults = correctUsageFromResults;
 const usage_js_1 = require("../../utils/usage.cjs");
@@ -41,40 +42,38 @@ function aggregateUsageFromModelUsage(modelUsage) {
  * Extracts and normalizes usage metrics from a Claude Agent SDK message.
  * @internal
  */
-function extractUsageFromMessage(message) {
+function extractUsageMetadata(usage) {
     const metrics = {};
-    // Assistant messages contain usage in message.message.usage
-    // Result messages contain usage in message.usage
-    let usage;
-    if (message.type === "assistant") {
-        usage = message.message?.usage;
-    }
-    else if (message.type === "result") {
-        usage = message.usage;
-    }
     if (!usage || typeof usage !== "object") {
         return metrics;
     }
     // Standard token counts - use LangSmith's expected field names
     const inputTokens = (0, utils_js_1.getNumberProperty)(usage, "input_tokens") || 0;
     const outputTokens = (0, utils_js_1.getNumberProperty)(usage, "output_tokens") || 0;
-    // Get cache tokens
-    const cacheRead = (0, utils_js_1.getNumberProperty)(usage, "cache_read_input_tokens") || 0;
-    const cacheCreation = (0, utils_js_1.getNumberProperty)(usage, "cache_creation_input_tokens") || 0;
-    // Build input_token_details if we have cache tokens
-    if (cacheRead > 0 || cacheCreation > 0) {
-        const inputTokenDetails = (0, usage_js_1.convertAnthropicUsageToInputTokenDetails)(usage);
-        if (Object.keys(inputTokenDetails).length > 0) {
-            metrics.input_token_details = inputTokenDetails;
-        }
+    const inputTokenDetails = (0, usage_js_1.convertAnthropicUsageToInputTokenDetails)(usage);
+    const cacheTokens = Object.values(inputTokenDetails).reduce((sum, value) => sum + (typeof value === "number" ? value : 0), 0);
+    if (Object.keys(inputTokenDetails).length > 0 && cacheTokens > 0) {
+        metrics.input_token_details = inputTokenDetails;
     }
     // Sum cache tokens into input_tokens total (matching Python's sum_anthropic_tokens)
-    const totalInputTokens = inputTokens + cacheRead + cacheCreation;
+    const totalInputTokens = inputTokens + cacheTokens;
     metrics.input_tokens = totalInputTokens;
     metrics.output_tokens = outputTokens;
     metrics.total_tokens = totalInputTokens + outputTokens;
     return metrics;
 }
+function extractUsageFromMessage(message) {
+    // Assistant messages contain usage in message.message.usage
+    // Result messages contain usage in message.usage
+    let usage;
+    if (message.type === "assistant") {
+        usage = message.message?.usage;
+    }
+    else if (message.type === "result") {
+        usage = message.usage;
+    }
+    return extractUsageMetadata(usage);
+}
 /**
  * Corrects usage metrics for assistant runs based on the results of the runs.
  * @internal

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

@@ -1 +1,2 @@
-export {};
+import type { SDKMessage } from "./types.js";
+export declare function extractUsageFromMessage(message: SDKMessage): Record<string, unknown>;

package/dist/experimental/anthropic/usage.js

@@ -36,40 +36,38 @@ export function aggregateUsageFromModelUsage(modelUsage) {
  * Extracts and normalizes usage metrics from a Claude Agent SDK message.
  * @internal
  */
-export function extractUsageFromMessage(message) {
+export function extractUsageMetadata(usage) {
     const metrics = {};
-    // Assistant messages contain usage in message.message.usage
-    // Result messages contain usage in message.usage
-    let usage;
-    if (message.type === "assistant") {
-        usage = message.message?.usage;
-    }
-    else if (message.type === "result") {
-        usage = message.usage;
-    }
     if (!usage || typeof usage !== "object") {
         return metrics;
     }
     // Standard token counts - use LangSmith's expected field names
     const inputTokens = getNumberProperty(usage, "input_tokens") || 0;
     const outputTokens = getNumberProperty(usage, "output_tokens") || 0;
-    // Get cache tokens
-    const cacheRead = getNumberProperty(usage, "cache_read_input_tokens") || 0;
-    const cacheCreation = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
-    // Build input_token_details if we have cache tokens
-    if (cacheRead > 0 || cacheCreation > 0) {
-        const inputTokenDetails = convertAnthropicUsageToInputTokenDetails(usage);
-        if (Object.keys(inputTokenDetails).length > 0) {
-            metrics.input_token_details = inputTokenDetails;
-        }
+    const inputTokenDetails = convertAnthropicUsageToInputTokenDetails(usage);
+    const cacheTokens = Object.values(inputTokenDetails).reduce((sum, value) => sum + (typeof value === "number" ? value : 0), 0);
+    if (Object.keys(inputTokenDetails).length > 0 && cacheTokens > 0) {
+        metrics.input_token_details = inputTokenDetails;
     }
     // Sum cache tokens into input_tokens total (matching Python's sum_anthropic_tokens)
-    const totalInputTokens = inputTokens + cacheRead + cacheCreation;
+    const totalInputTokens = inputTokens + cacheTokens;
     metrics.input_tokens = totalInputTokens;
     metrics.output_tokens = outputTokens;
     metrics.total_tokens = totalInputTokens + outputTokens;
     return metrics;
 }
+export function extractUsageFromMessage(message) {
+    // Assistant messages contain usage in message.message.usage
+    // Result messages contain usage in message.usage
+    let usage;
+    if (message.type === "assistant") {
+        usage = message.message?.usage;
+    }
+    else if (message.type === "result") {
+        usage = message.usage;
+    }
+    return extractUsageMetadata(usage);
+}
 /**
  * Corrects usage metrics for assistant runs based on the results of the runs.
  * @internal

package/dist/experimental/opencode/index.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangSmithPlugin = void 0;
+// import type { Plugin } from "@opencode-ai/plugin";
+const tracer_js_1 = require("./tracer.cjs");
+const LangSmithPlugin = async (ctx) => {
+    const tracer = new tracer_js_1.OpenCodeSessionTracer();
+    async function getSessionHistory(sessionID) {
+        const past = await ctx.client.session.messages({
+            path: { id: sessionID },
+        });
+        if (past.error)
+            throw past.error;
+        return past.data;
+    }
+    return {
+        "experimental.chat.system.transform": async (input, output) => {
+            const sessionID = input.sessionID;
+            if (!sessionID)
+                return;
+            await tracer.handleSessionLoad(sessionID, getSessionHistory);
+            await tracer.handleSystem(input, output);
+        },
+        event: async (input) => {
+            const sessionID = "sessionID" in input.event.properties &&
+                typeof input.event.properties.sessionID === "string"
+                ? input.event.properties.sessionID
+                : undefined;
+            if (!sessionID)
+                return;
+            await tracer.handleSessionLoad(sessionID, getSessionHistory);
+            await tracer.handleEvent(input);
+        },
+    };
+};
+exports.LangSmithPlugin = LangSmithPlugin;

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

@@ -0,0 +1,3 @@
+type Plugin = (ctx: any) => any;
+export declare const LangSmithPlugin: Plugin;
+export {};

package/dist/experimental/opencode/index.js

@@ -0,0 +1,32 @@
+// import type { Plugin } from "@opencode-ai/plugin";
+import { OpenCodeSessionTracer } from "./tracer.js";
+export const LangSmithPlugin = async (ctx) => {
+    const tracer = new OpenCodeSessionTracer();
+    async function getSessionHistory(sessionID) {
+        const past = await ctx.client.session.messages({
+            path: { id: sessionID },
+        });
+        if (past.error)
+            throw past.error;
+        return past.data;
+    }
+    return {
+        "experimental.chat.system.transform": async (input, output) => {
+            const sessionID = input.sessionID;
+            if (!sessionID)
+                return;
+            await tracer.handleSessionLoad(sessionID, getSessionHistory);
+            await tracer.handleSystem(input, output);
+        },
+        event: async (input) => {
+            const sessionID = "sessionID" in input.event.properties &&
+                typeof input.event.properties.sessionID === "string"
+                ? input.event.properties.sessionID
+                : undefined;
+            if (!sessionID)
+                return;
+            await tracer.handleSessionLoad(sessionID, getSessionHistory);
+            await tracer.handleEvent(input);
+        },
+    };
+};