langsmith 0.5.25 → 0.6.0

package/dist/experimental/opencode/tracer.js

@@ -0,0 +1,385 @@
+// import type { Event, FilePart, Message, Model, Part } from "@opencode-ai/sdk";
+import { RunTree } from "../../run_trees.js";
+import { Client } from "../../index.js";
+const dedupeParts = (parts) => {
+    const partById = {};
+    for (const part of parts) {
+        partById[part.id] = { ...partById[part.id], ...part };
+    }
+    return Object.values(partById);
+};
+const convertToStandardContentBlock = (part) => {
+    // Ignore AI SDK specific parts
+    if (part.type === "step-start" || part.type === "step-finish") {
+        return [];
+    }
+    if (part.type === "text") {
+        return {
+            type: "text",
+            text: part.text,
+            extras: part.metadata,
+        };
+    }
+    if (part.type === "reasoning") {
+        return {
+            type: "thinking",
+            thinking: part.text,
+        };
+    }
+    if (part.type === "file") {
+        return {
+            type: "file",
+            id: part.filename ?? part.id,
+            url: part.url,
+            mime_type: part.mime,
+        };
+    }
+    if (part.type === "tool") {
+        return {
+            type: "tool_use",
+            name: part.tool,
+            input: part.state.input,
+            id: part.callID,
+        };
+    }
+    if (part.type === "compaction") {
+        return {
+            type: "compaction",
+            data: { auto: part.auto },
+        };
+    }
+    return {
+        type: "non_standard",
+        value: part,
+    };
+};
+const convertToStandardMessages = (messages) => {
+    return messages.flatMap((message) => {
+        const parts = dedupeParts(message.parts);
+        if (message.info?.role === "assistant") {
+            // split out into "model message"
+            return [
+                {
+                    role: "assistant",
+                    content: parts.flatMap(convertToStandardContentBlock),
+                },
+                ...parts.flatMap((part) => {
+                    if (part.type !== "tool")
+                        return [];
+                    if (part.state.status === "completed") {
+                        return {
+                            role: "tool",
+                            content: part.state.output,
+                            name: part.tool,
+                            id: part.id,
+                            tool_call_id: part.callID,
+                        };
+                    }
+                    if (part.state.status === "error") {
+                        return {
+                            role: "tool",
+                            content: part.state.error,
+                            name: part.tool,
+                            id: part.id,
+                            tool_call_id: part.callID,
+                        };
+                    }
+                    return [];
+                }),
+            ];
+        }
+        if (message.info?.role === "user") {
+            return {
+                role: "user",
+                content: parts.flatMap(convertToStandardContentBlock),
+            };
+        }
+        return [];
+    });
+};
+export class OpenCodeSessionTracer {
+    constructor(inputConfig) {
+        Object.defineProperty(this, "sessions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.inputConfig = inputConfig ?? {};
+        this.client = inputConfig?.client ?? new Client();
+    }
+    getSession(sessionID) {
+        this.sessions[sessionID] ??= {
+            messages: {},
+            traces: {},
+            history: undefined,
+            pendingSystem: undefined,
+            postRunQueue: [],
+            parentID: undefined,
+        };
+        return this.sessions[sessionID];
+    }
+    getMessage(sessionID, messageID) {
+        const session = this.getSession(sessionID);
+        session.messages[messageID] ??= {
+            info: undefined,
+            parts: [],
+            complete: false,
+            system: undefined,
+        };
+        // Attach pending system to assistant messages
+        if (session.pendingSystem != null &&
+            session.messages[messageID]?.info?.role === "assistant") {
+            session.messages[messageID].system = session.pendingSystem;
+            session.pendingSystem = undefined;
+        }
+        return session.messages[messageID];
+    }
+    getProviderMetadata(run) {
+        const info = run.info;
+        if (!info || info.role !== "assistant")
+            return {};
+        const model = run.system?.model;
+        const modelId = model?.id ?? info.modelID;
+        const providerId = model?.providerID ?? info.providerID;
+        const ls_invocation_params = {
+            model: modelId,
+            providerID: providerId,
+        };
+        if (model?.name)
+            ls_invocation_params.model_display_name = model.name;
+        if (model?.api?.id)
+            ls_invocation_params.api_model_id = model.api.id;
+        if (model?.api?.url)
+            ls_invocation_params.api_url = model.api.url;
+        if (model?.api?.npm)
+            ls_invocation_params.api_npm_package = model.api.npm;
+        const stepFinish = run.parts.find((part) => part.type === "step-finish");
+        return {
+            ls_model_name: modelId,
+            ls_provider: providerId,
+            ls_model_type: "chat",
+            ls_invocation_params,
+            usage_metadata: stepFinish
+                ? {
+                    input_tokens: stepFinish.tokens.input,
+                    output_tokens: stepFinish.tokens.output + stepFinish.tokens.reasoning,
+                    total_tokens: stepFinish.tokens.input +
+                        stepFinish.tokens.output +
+                        stepFinish.tokens.reasoning,
+                    input_token_details: {
+                        cache_read: stepFinish.tokens.cache.read,
+                        cache_creation: stepFinish.tokens.cache.write,
+                    },
+                }
+                : undefined,
+        };
+    }
+    async sendTrace(sessionID, runs, options) {
+        const session = this.getSession(sessionID);
+        const userRunIdx = runs.findIndex(({ info }) => info?.role === "user");
+        const userRun = runs.at(userRunIdx);
+        const agentRuns = runs.slice(userRunIdx + 1);
+        if (userRunIdx === -1 || userRun == null)
+            return;
+        const parentStartTime = userRun?.info?.time?.created ?? Date.now();
+        const parentEndTime = agentRuns
+            .flatMap((run) => run.parts)
+            .reduce((acc, part) => {
+            if (!("time" in part) || part.time == null)
+                return acc;
+            if (!("end" in part.time) || typeof part.time.end !== "number")
+                return acc;
+            return Math.max(acc, part.time.end);
+        }, parentStartTime);
+        if (userRun?.info) {
+            session.history ??= [];
+            session.history.push({ info: userRun.info, parts: userRun.parts });
+        }
+        const parentConfig = {
+            name: "opencode.session",
+            run_type: "chain",
+            start_time: parentStartTime,
+            end_time: parentEndTime,
+            extra: {
+                metadata: {
+                    ls_integration: "opencode-js",
+                    ls_agent_type: "root",
+                    thread_id: sessionID,
+                },
+            },
+            inputs: { messages: convertToStandardMessages([userRun]) },
+            outputs: { messages: convertToStandardMessages(agentRuns) },
+            ...this.inputConfig,
+            client: this.client,
+        };
+        const parent = options?.parentRunTree?.createChild(parentConfig) ??
+            new RunTree(parentConfig);
+        session.postRunQueue.push(parent.postRun());
+        for (const run of agentRuns) {
+            const startTime = run.info?.time?.created ?? Date.now();
+            const endTime = run.parts.reduce((acc, part) => {
+                if (!("time" in part) || part.time == null)
+                    return acc;
+                if (!("end" in part.time) || typeof part.time.end !== "number")
+                    return acc;
+                return Math.max(acc, part.time.end);
+            }, startTime);
+            const parts = dedupeParts(run.parts);
+            // Create child runs for tool parts
+            const child = parent.createChild({
+                name: "opencode.assistant.turn",
+                run_type: "llm",
+                start_time: startTime,
+                end_time: endTime,
+                inputs: {
+                    messages: [
+                        ...(run.system?.system
+                            ? [{ role: "system", content: run.system.system.join("\n") }]
+                            : []),
+                        ...convertToStandardMessages(session.history ?? []),
+                    ],
+                },
+                outputs: { messages: convertToStandardMessages([run]) },
+                extra: { metadata: this.getProviderMetadata(run) },
+            });
+            session.postRunQueue.push(child.postRun());
+            for (const toolPart of parts) {
+                if (toolPart.type !== "tool")
+                    continue;
+                const state = toolPart.state;
+                // Try looking for subgraph
+                let toolHandled = false;
+                if (state.metadata?.sessionId) {
+                    const session = this.getSession(state.metadata.sessionId);
+                    for (const trace of Object.values(session.traces)) {
+                        if (trace.state !== "subgraph")
+                            continue;
+                        await this.sendTrace(state.metadata.sessionId, trace.runs, {
+                            parentRunTree: child,
+                        });
+                        toolHandled = true;
+                    }
+                }
+                if (toolHandled)
+                    continue;
+                const tool = child.createChild({
+                    name: toolPart.tool,
+                    run_type: "tool",
+                    inputs: state.input ?? {},
+                    outputs: {
+                        output: state.output,
+                        attachments: state.attachments?.map(convertToStandardContentBlock) ??
+                            undefined,
+                    },
+                    start_time: state.time?.start ?? startTime,
+                    end_time: state.time?.end ?? endTime,
+                    error: state.error,
+                    extra: { metadata: state.metadata },
+                });
+                session.postRunQueue.push(tool.postRun());
+            }
+            if (run.info) {
+                session.history ??= [];
+                session.history.push({ info: run.info, parts });
+            }
+        }
+    }
+    async flush() {
+        await Promise.all(Object.values(this.sessions).flatMap((session) => session.postRunQueue));
+        await this.client.flush();
+        await this.client.awaitPendingTraceBatches();
+    }
+    async handleSystem(input, output) {
+        if (!input.sessionID)
+            return;
+        const session = this.getSession(input.sessionID);
+        session.pendingSystem = { model: input.model, system: output.system };
+    }
+    async handleSessionLoad(sessionID, history) {
+        const session = this.getSession(sessionID);
+        if (session.history)
+            return;
+        session.history = await history(sessionID);
+    }
+    async handleEvent({ event: { properties, type } }) {
+        if (type === "server.instance.disposed") {
+            await this.flush();
+            return;
+        }
+        const sessionID = "sessionID" in properties && typeof properties.sessionID === "string"
+            ? properties.sessionID
+            : undefined;
+        if (!sessionID)
+            return;
+        const session = this.getSession(sessionID);
+        let updatedID;
+        if (type === "session.created" || type === "session.updated") {
+            session.parentID = properties.info.parentID;
+        }
+        if (type === "message.updated") {
+            const message = this.getMessage(sessionID, properties.info.id);
+            message.info = properties.info;
+            updatedID = properties.info.id;
+        }
+        if (type === "message.part.updated") {
+            const message = this.getMessage(sessionID, properties.part.messageID);
+            message.parts.push(properties.part);
+            updatedID = properties.part.messageID;
+        }
+        if (type === "message.part.removed") {
+            const message = this.getMessage(sessionID, properties.messageID);
+            message.parts = message.parts.filter((part) => part.id !== properties.partID);
+            updatedID = properties.messageID;
+        }
+        if (type === "message.removed") {
+            const session = this.getSession(sessionID);
+            delete session.messages[properties.messageID];
+        }
+        // Message consolidation logic
+        const message = updatedID ? session.messages[updatedID] : undefined;
+        if (message?.info?.role == null)
+            return;
+        // Skip if message is already marked as complete
+        if (message.complete)
+            return;
+        message.complete =
+            (message.info?.role === "user" && message.parts.length > 0) ||
+                (message.info?.role === "assistant" &&
+                    message.parts.some((part) => part.type === "step-finish"));
+        // Now we're complete, add to a trace
+        if (message.complete) {
+            const traceId = message.info.role === "user" ? message.info.id : message.info.parentID;
+            session.traces[traceId] ??= { runs: [], state: false };
+            const trace = session.traces[traceId];
+            trace.runs.push(message);
+            // Skip if trace is already marked as complete
+            if (trace.state !== false)
+                return;
+            trace.state = trace.runs.some((run) => run.parts.some(
+            // trace is marked complete when there's a step-finish part with reason "stop"
+            (part) => part.type === "step-finish" && part.reason === "stop"));
+            if (trace.state) {
+                // If trace is part of a subagent call, mark it as a subgraph and submit
+                // when parent is being submitted (to preserve correct dotted order)
+                if (session.parentID) {
+                    trace.state = "subgraph";
+                    return;
+                }
+                await this.sendTrace(sessionID, trace.runs);
+            }
+        }
+    }
+}

package/dist/experimental/otel/setup.cjs

@@ -56,7 +56,7 @@ const initializeOTEL = (config = {}) => {
             contextManager.enable();
             api_1.context.setGlobalContextManager(contextManager);
         }
-        catch (e) {
+        catch (_e) {
             console.log([
                 `Could not automatically set up an OTEL context manager.`,
                 `This may be expected if you have (or another imported library has) already set a global context manager.`,

package/dist/experimental/otel/setup.js

@@ -53,7 +53,7 @@ export const initializeOTEL = (config = {}) => {
             contextManager.enable();
             otel_context.setGlobalContextManager(contextManager);
         }
-        catch (e) {
+        catch (_e) {
             console.log([
                 `Could not automatically set up an OTEL context manager.`,
                 `This may be expected if you have (or another imported library has) already set a global context manager.`,

package/dist/experimental/sandbox/sandbox.cjs

@@ -87,7 +87,11 @@ class Sandbox {
             writable: true,
             value: void 0
         });
-        /** Idle timeout TTL in seconds (`0` means disabled). */
+        /**
+         * Idle timeout TTL in seconds (`0` means disabled).
+         * New sandboxes receive a server-side default of `600` seconds (10 minutes)
+         * when the caller did not set `idleTtlSeconds` explicitly.
+         */
         Object.defineProperty(this, "idle_ttl_seconds", {
             enumerable: true,
             configurable: true,
@@ -201,7 +205,7 @@ class Sandbox {
         catch (e) {
             // Fall back to HTTP on connection errors or missing ws package
             const name = e != null && typeof e === "object" ? e.name : "";
-            const message = e != null && typeof e === "object" ? e.message ?? "" : "";
+            const message = e != null && typeof e === "object" ? (e.message ?? "") : "";
             if (name === "LangSmithSandboxConnectionError" ||
                 name === "LangSmithSandboxServerReloadError" ||
                 message.includes("'ws' package")) {

package/dist/experimental/sandbox/sandbox.d.ts

@@ -40,7 +40,11 @@ export declare class Sandbox {
     readonly updated_at?: string;
     /** Maximum lifetime TTL in seconds (`0` means disabled). */
     readonly ttl_seconds?: number;
-    /** Idle timeout TTL in seconds (`0` means disabled). */
+    /**
+     * Idle timeout TTL in seconds (`0` means disabled).
+     * New sandboxes receive a server-side default of `600` seconds (10 minutes)
+     * when the caller did not set `idleTtlSeconds` explicitly.
+     */
     readonly idle_ttl_seconds?: number;
     /** Computed expiration timestamp when a TTL is active. */
     readonly expires_at?: string;

package/dist/experimental/sandbox/sandbox.js

@@ -84,7 +84,11 @@ export class Sandbox {
             writable: true,
             value: void 0
         });
-        /** Idle timeout TTL in seconds (`0` means disabled). */
+        /**
+         * Idle timeout TTL in seconds (`0` means disabled).
+         * New sandboxes receive a server-side default of `600` seconds (10 minutes)
+         * when the caller did not set `idleTtlSeconds` explicitly.
+         */
         Object.defineProperty(this, "idle_ttl_seconds", {
             enumerable: true,
             configurable: true,
@@ -198,7 +202,7 @@ export class Sandbox {
         catch (e) {
             // Fall back to HTTP on connection errors or missing ws package
             const name = e != null && typeof e === "object" ? e.name : "";
-            const message = e != null && typeof e === "object" ? e.message ?? "" : "";
+            const message = e != null && typeof e === "object" ? (e.message ?? "") : "";
             if (name === "LangSmithSandboxConnectionError" ||
                 name === "LangSmithSandboxServerReloadError" ||
                 message.includes("'ws' package")) {

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

@@ -270,7 +270,8 @@ export interface CreateSandboxOptions {
     ttlSeconds?: number;
     /**
      * Idle timeout in seconds. The sandbox is deleted after this much inactivity.
-     * Must be a multiple of 60, or `0`/`undefined` to disable or omit.
+     * Must be a multiple of 60. Pass `0` to explicitly disable the idle timeout.
+     * When omitted, the server applies a default of `600` seconds (10 minutes).
      */
     idleTtlSeconds?: number;
     /** Number of vCPUs. */
@@ -374,6 +375,7 @@ export interface UpdateSandboxOptions {
     ttlSeconds?: number;
     /**
      * Idle timeout in seconds. Must be a multiple of 60. Pass `0` to disable.
+     * Omit (or pass `undefined`) to leave the existing value unchanged.
      */
     idleTtlSeconds?: number;
 }

package/dist/experimental/vercel/index.cjs

@@ -191,7 +191,7 @@ const _getGenerateTextWrapperConfig = ({ model, runName, aiSdkMethodName, resolv
                 return (0, utils_js_1.convertMessageToTracedFormat)({
                     content: content ?? outputs.outputs.text,
                     role: "assistant",
-                }, resolvedLsConfig?.traceResponseMetadata ?? traceResponseMetadata
+                }, (resolvedLsConfig?.traceResponseMetadata ?? traceResponseMetadata)
                     ? { steps }
                     : undefined);
             }

package/dist/experimental/vercel/index.js

@@ -187,7 +187,7 @@ const _getGenerateTextWrapperConfig = ({ model, runName, aiSdkMethodName, resolv
                 return convertMessageToTracedFormat({
                     content: content ?? outputs.outputs.text,
                     role: "assistant",
-                }, resolvedLsConfig?.traceResponseMetadata ?? traceResponseMetadata
+                }, (resolvedLsConfig?.traceResponseMetadata ?? traceResponseMetadata)
                     ? { steps }
                     : undefined);
             }

package/dist/experimental/vercel/middleware.cjs

@@ -280,7 +280,8 @@ function LangSmithMiddleware(config) {
                             }
                             let formattedOutputs;
                             if (lsConfig?.processOutputs) {
-                                formattedOutputs = await lsConfig.processOutputs(outputForTracing);
+                                formattedOutputs =
+                                    await lsConfig.processOutputs(outputForTracing);
                             }
                             else {
                                 formattedOutputs = _formatTracedOutputs(outputForTracing, lsConfig?.traceRawHttp);

package/dist/experimental/vercel/middleware.js

@@ -277,7 +277,8 @@ export function LangSmithMiddleware(config) {
                             }
                             let formattedOutputs;
                             if (lsConfig?.processOutputs) {
-                                formattedOutputs = await lsConfig.processOutputs(outputForTracing);
+                                formattedOutputs =
+                                    await lsConfig.processOutputs(outputForTracing);
                             }
                             else {
                                 formattedOutputs = _formatTracedOutputs(outputForTracing, lsConfig?.traceRawHttp);

package/dist/index.cjs

@@ -18,4 +18,4 @@ Object.defineProperty(exports, "PromptCache", { enumerable: true, get: function
 Object.defineProperty(exports, "configureGlobalPromptCache", { enumerable: true, get: function () { return index_js_1.configureGlobalPromptCache; } });
 Object.defineProperty(exports, "promptCacheSingleton", { enumerable: true, get: function () { return index_js_1.promptCacheSingleton; } });
 // Update using pnpm bump-version
-exports.__version__ = "0.5.25";
+exports.__version__ = "0.6.0";

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, PromptCache, type CacheConfig, type CacheMetrics, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
-export declare const __version__ = "0.5.25";
+export declare const __version__ = "0.6.0";

package/dist/index.js

@@ -5,4 +5,4 @@ export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, PromptCache, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 // Update using pnpm bump-version
-export const __version__ = "0.5.25";
+export const __version__ = "0.6.0";

package/dist/singletons/traceable.cjs

@@ -43,8 +43,6 @@ function withRunTree(runTree, fn) {
     });
 }
 exports.ROOT = Symbol.for("langsmith:traceable:root");
-function isTraceableFunction(x
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+function isTraceableFunction(x) {
     return typeof x === "function" && "langsmith:traceable" in x;
 }

package/dist/singletons/traceable.js

@@ -37,8 +37,6 @@ export function withRunTree(runTree, fn) {
     });
 }
 export const ROOT = Symbol.for("langsmith:traceable:root");
-export function isTraceableFunction(x
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+export function isTraceableFunction(x) {
     return typeof x === "function" && "langsmith:traceable" in x;
 }

package/dist/traceable.cjs

@@ -16,9 +16,7 @@ traceable_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new n
 /**
  * Create OpenTelemetry context manager from RunTree if OTEL is enabled.
  */
-function maybeCreateOtelContext(runTree, projectName, tracer
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+function maybeCreateOtelContext(runTree, projectName, tracer) {
     if (!runTree || runTree.client.tracingMode !== "otel") {
         return;
     }

package/dist/traceable.js

@@ -12,9 +12,7 @@ AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorag
 /**
  * Create OpenTelemetry context manager from RunTree if OTEL is enabled.
  */
-function maybeCreateOtelContext(runTree, projectName, tracer
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+function maybeCreateOtelContext(runTree, projectName, tracer) {
     if (!runTree || runTree.client.tracingMode !== "otel") {
         return;
     }

package/dist/utils/_git.cjs

@@ -23,7 +23,7 @@ const getGitInfo = async (remote = "origin") => {
         const execImport = await importChildProcess();
         exec = execImport.exec;
     }
-    catch (e) {
+    catch (_e) {
         // no-op
         return null;
     }
@@ -59,7 +59,7 @@ const getDefaultRevisionId = async () => {
         const execImport = await importChildProcess();
         exec = execImport.exec;
     }
-    catch (e) {
+    catch (_e) {
         // no-op
         return null;
     }

package/dist/utils/_git.js

@@ -20,7 +20,7 @@ export const getGitInfo = async (remote = "origin") => {
         const execImport = await importChildProcess();
         exec = execImport.exec;
     }
-    catch (e) {
+    catch (_e) {
         // no-op
         return null;
     }
@@ -55,7 +55,7 @@ export const getDefaultRevisionId = async () => {
         const execImport = await importChildProcess();
         exec = execImport.exec;
     }
-    catch (e) {
+    catch (_e) {
         // no-op
         return null;
     }

package/dist/utils/env.cjs

@@ -146,7 +146,7 @@ function getLangSmithEnvironmentVariables() {
             }
         }
     }
-    catch (e) {
+    catch (_e) {
         // Catch any errors that might occur while trying to access environment variables
     }
     return envVars;
@@ -160,7 +160,7 @@ function getEnvironmentVariable(name) {
                 process.env?.[name]
             : undefined;
     }
-    catch (e) {
+    catch (_e) {
         return undefined;
     }
 }

package/dist/utils/env.js

@@ -128,7 +128,7 @@ export function getLangSmithEnvironmentVariables() {
             }
         }
     }
-    catch (e) {
+    catch (_e) {
         // Catch any errors that might occur while trying to access environment variables
     }
     return envVars;
@@ -142,7 +142,7 @@ export function getEnvironmentVariable(name) {
                 process.env?.[name]
             : undefined;
     }
-    catch (e) {
+    catch (_e) {
         return undefined;
     }
 }