langsmith 0.5.6 → 0.5.8

package/dist/client.js

@@ -10,6 +10,7 @@ import { warnOnce } from "./utils/warn.js";
 import { parsePromptIdentifier } from "./utils/prompts.js";
 import { raiseForStatus, isLangSmithNotFoundError } from "./utils/error.js";
 import { promptCacheSingleton, } from "./utils/prompt_cache/index.js";
+import * as fsUtils from "./utils/fs.js";
 import { _shouldStreamForGlobalFetchImplementation, _getFetchImplementation, } from "./singletons/fetch.js";
 import { serialize as serializePayloadForTracing } from "./utils/fast-safe-stringify/index.js";
 export function mergeRuntimeEnvIntoRun(run, cachedEnvVars, omitTracedRuntimeInfo) {
@@ -397,6 +398,18 @@ export class Client {
             writable: true,
             value: getLangSmithEnvironmentVariable("DISABLE_RUN_COMPRESSION") === "true"
         });
+        Object.defineProperty(this, "failedTracesDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "failedTracesMaxBytes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 100 * 1024 * 1024
+        });
         Object.defineProperty(this, "debug", {
             enumerable: true,
             configurable: true,
@@ -428,6 +441,16 @@ export class Client {
         }
         this.debug = config.debug ?? this.debug;
         this.fetchImplementation = config.fetchImplementation;
+        // Failed trace dump configuration
+        this.failedTracesDir =
+            getLangSmithEnvironmentVariable("FAILED_TRACES_DIR") || undefined;
+        const failedTracesMb = getLangSmithEnvironmentVariable("FAILED_TRACES_MAX_MB");
+        if (failedTracesMb) {
+            const n = parseInt(failedTracesMb, 10);
+            if (Number.isFinite(n) && n > 0) {
+                this.failedTracesMaxBytes = n * 1024 * 1024;
+            }
+        }
         // Use maxIngestMemoryBytes for both queues
         const maxMemory = config.maxIngestMemoryBytes ?? DEFAULT_MAX_SIZE_BYTES;
         this.batchIngestCaller = new AsyncCaller({
@@ -768,6 +791,63 @@ export class Client {
         }
         return Promise.all(promises);
     }
+    /**
+     * Persist a failed trace payload to a local fallback directory.
+     *
+     * Saves a self-contained JSON file containing the endpoint path, the HTTP
+     * headers required for replay, and the base64-encoded request body.
+     * Can be replayed later with a simple POST:
+     *
+     *   POST /<endpoint>
+     *   Content-Type: <value from saved headers>
+     *   [Content-Encoding: <value from saved headers>]
+     *   <decoded body>
+     */
+    static async _writeTraceToFallbackDir(directory, body, replayHeaders, endpoint, maxBytes) {
+        try {
+            const bodyBuffer = typeof body === "string"
+                ? Buffer.from(body, "utf8")
+                : Buffer.from(body);
+            const envelope = JSON.stringify({
+                version: 1,
+                endpoint,
+                headers: replayHeaders,
+                body_base64: bodyBuffer.toString("base64"),
+            });
+            const filename = `trace_${Date.now()}_${uuid.v4().slice(0, 8)}.json`;
+            const filepath = fsUtils.path.join(directory, filename);
+            if (!Client._fallbackDirsCreated.has(directory)) {
+                await fsUtils.mkdir(directory);
+                Client._fallbackDirsCreated.add(directory);
+            }
+            // Check budget before writing — drop new traces if over limit.
+            if (maxBytes !== undefined && maxBytes > 0) {
+                try {
+                    const entries = await fsUtils.readdir(directory);
+                    const traceFiles = entries.filter((f) => f.startsWith("trace_") && f.endsWith(".json"));
+                    let total = 0;
+                    for (const name of traceFiles) {
+                        const { size } = await fsUtils.stat(fsUtils.path.join(directory, name));
+                        total += size;
+                    }
+                    if (total >= maxBytes) {
+                        console.warn(`Could not write trace to fallback dir ${directory} as it's ` +
+                            `already over size limit (${total} bytes >= ${maxBytes} bytes). ` +
+                            `Increase LANGSMITH_FAILED_TRACES_MAX_MB if possible.`);
+                        return;
+                    }
+                }
+                catch {
+                    // budget check errors must never prevent writing
+                }
+            }
+            await fsUtils.writeFileAtomic(filepath, envelope);
+            console.warn(`LangSmith trace upload failed; data saved to ${filepath} for later replay.`);
+        }
+        catch (writeErr) {
+            console.error(`LangSmith tracing error: could not write trace to fallback dir ${directory}:`, writeErr);
+        }
+    }
     async _processBatch(batch, options) {
         if (!batch.length) {
             return;
@@ -1348,6 +1428,12 @@ export class Client {
                 throw e;
             }
             console.warn(`${e.message.trim()}\n\nContext: ${context}`);
+            if (this.failedTracesDir) {
+                const bodyBuffer = await this._createNodeFetchBody(parts, boundary).catch(() => null);
+                if (bodyBuffer) {
+                    await Client._writeTraceToFallbackDir(this.failedTracesDir, bodyBuffer, { "Content-Type": `multipart/form-data; boundary=${boundary}` }, "runs/multipart", this.failedTracesMaxBytes);
+                }
+            }
         }
     }
     async updateRun(runId, run, options) {
@@ -1701,6 +1787,128 @@ export class Client {
             }
         }
     }
+    async *readThread(props) {
+        const { threadId, projectId, projectName, isRoot = true, limit, filter: userFilter, order = "asc", } = props;
+        if (!projectId && !projectName) {
+            throw new Error("threadId requires projectId or projectName");
+        }
+        const threadFilter = `eq(thread_id, ${JSON.stringify(threadId)})`;
+        const combinedFilter = userFilter
+            ? `and(${threadFilter}, ${userFilter})`
+            : threadFilter;
+        yield* this.listRuns({
+            projectId: projectId ?? undefined,
+            projectName: projectName ?? undefined,
+            isRoot,
+            limit,
+            filter: combinedFilter,
+            order,
+        });
+    }
+    async listThreads(props) {
+        const { projectId, projectName, limit, offset = 0, filter, startTime, isRoot = true, } = props;
+        if (!projectId && !projectName) {
+            throw new Error("Either projectId or projectName must be provided");
+        }
+        if (projectId && projectName) {
+            throw new Error("Provide exactly one of projectId or projectName");
+        }
+        const sessionId = projectId ?? (await this.readProject({ projectName: projectName })).id;
+        const startTimeResolved = startTime ?? new Date(Date.now() - 1 * 24 * 60 * 60 * 1000);
+        const runSelect = [
+            "id",
+            "name",
+            "status",
+            "start_time",
+            "end_time",
+            "thread_id",
+            "trace_id",
+            "run_type",
+            "error",
+            "tags",
+            "session_id",
+            "parent_run_id",
+            "total_tokens",
+            "total_cost",
+            "dotted_order",
+            "reference_example_id",
+            "feedback_stats",
+            "app_path",
+            "completion_cost",
+            "completion_tokens",
+            "prompt_cost",
+            "prompt_tokens",
+            "first_token_time",
+        ];
+        const bodyQuery = {
+            session: [sessionId],
+            is_root: isRoot,
+            limit: 100,
+            order: "desc",
+            select: runSelect,
+            start_time: startTimeResolved.toISOString(),
+        };
+        if (filter != null) {
+            bodyQuery.filter = filter;
+        }
+        const threadsMap = new Map();
+        for await (const runs of this._getCursorPaginatedList("/runs/query", bodyQuery)) {
+            for (const run of runs) {
+                const tid = run.thread_id;
+                if (tid) {
+                    const list = threadsMap.get(tid) ?? [];
+                    list.push(run);
+                    threadsMap.set(tid, list);
+                }
+            }
+        }
+        const result = [];
+        for (const [threadId, runs] of threadsMap.entries()) {
+            runs.sort((a, b) => {
+                const aRun = a;
+                const bRun = b;
+                const aStart = aRun.start_time ?? "";
+                const bStart = bRun.start_time ?? "";
+                if (aStart !== bStart)
+                    return aStart.localeCompare(bStart);
+                const aOrder = aRun.dotted_order ?? "";
+                const bOrder = bRun.dotted_order ?? "";
+                return aOrder.localeCompare(bOrder);
+            });
+            const startTimes = runs
+                .map((r) => r.start_time)
+                .filter(Boolean);
+            const sortedTimes = [...startTimes].sort();
+            const minStart = sortedTimes.length ? sortedTimes[0] : "";
+            const maxStart = sortedTimes.length
+                ? sortedTimes[sortedTimes.length - 1]
+                : "";
+            result.push({
+                thread_id: threadId,
+                runs,
+                count: runs.length,
+                filter: "",
+                total_tokens: 0,
+                total_cost: null,
+                min_start_time: minStart,
+                max_start_time: maxStart,
+                latency_p50: 0,
+                latency_p99: 0,
+                feedback_stats: null,
+                first_inputs: "",
+                last_outputs: "",
+                last_error: null,
+            });
+        }
+        result.sort((a, b) => {
+            const aMax = a.max_start_time ?? "";
+            const bMax = b.max_start_time ?? "";
+            return bMax.localeCompare(aMax);
+        });
+        const withOffset = offset > 0 ? result.slice(offset) : result;
+        const withLimit = limit !== undefined ? withOffset.slice(0, limit) : withOffset;
+        return withLimit;
+    }
     async getRunStats({ id, trace, parentRun, runType, projectNames, projectIds, referenceExampleIds, startTime, endTime, error, query, filter, traceFilter, treeFilter, isRoot, dataSourceType, }) {
         let projectIds_ = projectIds || [];
         if (projectNames) {
@@ -2949,7 +3157,7 @@ export class Client {
             assertUuid(feedback_source.metadata["__run"].run_id);
         }
         const feedback = {
-            id: feedbackId ?? uuid.v4(),
+            id: feedbackId ?? uuid.v7(),
             run_id: runId,
             key,
             score: _formatFeedbackScore(score),
@@ -3567,21 +3775,110 @@ export class Client {
             }
         }
     }
+    /**
+     * Check if a prompt exists.
+     * @param promptIdentifier - The identifier of the prompt. Can be in the format:
+     *   - "promptName" (for private prompts, owner defaults to "-")
+     *   - "owner/promptName" (for prompts with explicit owner)
+     * @returns A Promise that resolves to true if the prompt exists, false otherwise
+     * @example
+     * ```typescript
+     * // Check if a prompt exists before creating a commit
+     * if (await client.promptExists("my-prompt")) {
+     *   await client.createCommit("my-prompt", template);
+     * } else {
+     *   await client.createPrompt("my-prompt");
+     * }
+     * ```
+     */
     async promptExists(promptIdentifier) {
         const prompt = await this.getPrompt(promptIdentifier);
         return !!prompt;
     }
+    /**
+     * Like a prompt.
+     * @param promptIdentifier - The identifier of the prompt. Can be in the format:
+     *   - "promptName" (for private prompts, owner defaults to "-")
+     *   - "owner/promptName" (for prompts with explicit owner)
+     * @returns A Promise that resolves to the like response containing the updated like count
+     * @example
+     * ```typescript
+     * // Like a prompt
+     * const response = await client.likePrompt("owner/useful-prompt");
+     * console.log(`Prompt now has ${response.likes} likes`);
+     * ```
+     */
     async likePrompt(promptIdentifier) {
         return this._likeOrUnlikePrompt(promptIdentifier, true);
     }
+    /**
+     * Unlike a prompt (remove a previously added like).
+     * @param promptIdentifier - The identifier of the prompt. Can be in the format:
+     *   - "promptName" (for private prompts, owner defaults to "-")
+     *   - "owner/promptName" (for prompts with explicit owner)
+     * @returns A Promise that resolves to the like response containing the updated like count
+     * @example
+     * ```typescript
+     * // Unlike a prompt
+     * const response = await client.unlikePrompt("owner/useful-prompt");
+     * console.log(`Prompt now has ${response.likes} likes`);
+     * ```
+     */
     async unlikePrompt(promptIdentifier) {
         return this._likeOrUnlikePrompt(promptIdentifier, false);
     }
-    async *listCommits(promptOwnerAndName) {
-        for await (const commits of this._getPaginated(`/commits/${promptOwnerAndName}/`, new URLSearchParams(), (res) => res.commits)) {
+    /**
+     * List all commits for a prompt.
+     * @param promptIdentifier - The identifier of the prompt. Can be in the format:
+     *   - "promptName" (for private prompts, owner defaults to "-")
+     *   - "owner/promptName" (for prompts with explicit owner)
+     *   - "promptName:commitHash" (commit hash is ignored, all commits are returned)
+     * @returns An async iterable iterator of PromptCommit objects
+     * @example
+     * ```typescript
+     * // List commits for a private prompt
+     * for await (const commit of client.listCommits("my-prompt")) {
+     *   console.log(commit);
+     * }
+     *
+     * // List commits for a prompt with explicit owner
+     * for await (const commit of client.listCommits("owner/my-prompt")) {
+     *   console.log(commit);
+     * }
+     * ```
+     */
+    async *listCommits(promptIdentifier) {
+        const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
+        for await (const commits of this._getPaginated(`/commits/${owner}/${promptName}/`, new URLSearchParams(), (res) => res.commits)) {
             yield* commits;
         }
     }
+    /**
+     * List prompts by filter.
+     * @param options - Optional filters for listing prompts
+     * @param options.isPublic - Filter by public/private prompts. If undefined, returns all prompts.
+     * @param options.isArchived - Filter by archived status. Defaults to false (non-archived prompts only).
+     * @param options.sortField - Field to sort by. Defaults to "updated_at".
+     * @param options.query - Search query to filter prompts by name or description.
+     * @returns An async iterable iterator of Prompt objects
+     * @example
+     * ```typescript
+     * // List all prompts
+     * for await (const prompt of client.listPrompts()) {
+     *   console.log(prompt);
+     * }
+     *
+     * // List only public prompts
+     * for await (const prompt of client.listPrompts({ isPublic: true })) {
+     *   console.log(prompt);
+     * }
+     *
+     * // Search for prompts
+     * for await (const prompt of client.listPrompts({ query: "translation" })) {
+     *   console.log(prompt);
+     * }
+     * ```
+     */
     async *listPrompts(options) {
         const params = new URLSearchParams();
         params.append("sort_field", options?.sortField ?? "updated_at");
@@ -3597,6 +3894,22 @@ export class Client {
             yield* prompts;
         }
     }
+    /**
+     * Get a prompt by its identifier.
+     * @param promptIdentifier - The identifier of the prompt. Can be in the format:
+     *   - "promptName" (for private prompts, owner defaults to "-")
+     *   - "owner/promptName" (for prompts with explicit owner)
+     *   - "promptName:commitHash" (commit hash is ignored, latest version is returned)
+     * @returns A Promise that resolves to the Prompt object, or null if not found
+     * @example
+     * ```typescript
+     * // Get a private prompt
+     * const prompt = await client.getPrompt("my-prompt");
+     *
+     * // Get a public prompt
+     * const publicPrompt = await client.getPrompt("owner/public-prompt");
+     * ```
+     */
     async getPrompt(promptIdentifier) {
         const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
         const response = await this.caller.call(async () => {
@@ -3620,6 +3933,33 @@ export class Client {
             return null;
         }
     }
+    /**
+     * Create a new prompt.
+     * @param promptIdentifier - The identifier for the new prompt. Can be in the format:
+     *   - "promptName" (creates a private prompt)
+     *   - "owner/promptName" (creates a prompt under a specific owner, must match your tenant)
+     * @param options - Optional configuration for the prompt
+     * @param options.description - A description of the prompt
+     * @param options.readme - Markdown content for the prompt's README
+     * @param options.tags - Array of tags to categorize the prompt
+     * @param options.isPublic - Whether the prompt should be public. Requires a LangChain Hub handle.
+     * @returns A Promise that resolves to the created Prompt object
+     * @throws {Error} If creating a public prompt without a LangChain Hub handle, or if owner doesn't match current tenant
+     * @example
+     * ```typescript
+     * // Create a private prompt
+     * const prompt = await client.createPrompt("my-new-prompt", {
+     *   description: "A prompt for translations",
+     *   tags: ["translation", "language"]
+     * });
+     *
+     * // Create a public prompt
+     * const publicPrompt = await client.createPrompt("my-public-prompt", {
+     *   description: "A public translation prompt",
+     *   isPublic: true
+     * });
+     * ```
+     */
     async createPrompt(promptIdentifier, options) {
         const settings = await this._getSettings();
         if (options?.isPublic && !settings.tenant_handle) {
@@ -3654,6 +3994,35 @@ export class Client {
         const { repo } = await response.json();
         return repo;
     }
+    /**
+     * Create a new commit for an existing prompt.
+     * @param promptIdentifier - The identifier of the prompt. Can be in the format:
+     *   - "promptName" (for private prompts, owner defaults to "-")
+     *   - "owner/promptName" (for prompts with explicit owner)
+     * @param object - The prompt object/manifest to commit (e.g., ChatPromptTemplate, messages array, etc.)
+     * @param options - Optional configuration for the commit
+     * @param options.parentCommitHash - The parent commit hash. Defaults to "latest" (the most recent commit).
+     * @returns A Promise that resolves to the URL of the newly created commit
+     * @throws {Error} If the prompt does not exist
+     * @example
+     * ```typescript
+     * import { ChatPromptTemplate } from "@langchain/core/prompts";
+     *
+     * // Create a commit with a new version of the prompt
+     * const template = ChatPromptTemplate.fromMessages([
+     *   ["system", "You are a helpful assistant."],
+     *   ["human", "{input}"]
+     * ]);
+     *
+     * const commitUrl = await client.createCommit("my-prompt", template);
+     * console.log(`Commit created: ${commitUrl}`);
+     *
+     * // Create a commit based on a specific parent commit
+     * const commitUrl2 = await client.createCommit("my-prompt", template, {
+     *   parentCommitHash: "abc123def456"
+     * });
+     * ```
+     */
     async createCommit(promptIdentifier, object, options) {
         if (!(await this.promptExists(promptIdentifier))) {
             throw new Error("Prompt does not exist, you must create it first.");
@@ -4137,6 +4506,12 @@ export class Client {
         }
     }
 }
+Object.defineProperty(Client, "_fallbackDirsCreated", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Set()
+});
 function isExampleCreate(input) {
     return "dataset_id" in input || "dataset_name" in input;
 }

package/dist/evaluation/evaluator.cjs

@@ -67,7 +67,7 @@ class DynamicRunEvaluator {
      * @returns A promise that extracts to the evaluation result.
      */
     async evaluateRun(run, example, options) {
-        let sourceRunId = (0, uuid_1.v4)();
+        let sourceRunId = (0, uuid_1.v7)();
         const metadata = {
             targetRunId: run.id,
         };

package/dist/evaluation/evaluator.js

@@ -1,4 +1,4 @@
-import { v4 as uuidv4 } from "uuid";
+import { v7 as uuidv7 } from "uuid";
 import { traceable } from "../traceable.js";
 /**
  * Wraps an evaluator function + implements the RunEvaluator interface.
@@ -63,7 +63,7 @@ export class DynamicRunEvaluator {
      * @returns A promise that extracts to the evaluation result.
      */
     async evaluateRun(run, example, options) {
-        let sourceRunId = uuidv4();
+        let sourceRunId = uuidv7();
         const metadata = {
             targetRunId: run.id,
         };

package/dist/experimental/anthropic/index.cjs

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK;
+const module_1 = require("module");
 const traceable_js_1 = require("../../traceable.cjs");
 const context_js_1 = require("./context.cjs");
 const messages_js_1 = require("./messages.cjs");
+function _getPackageVersion(packageName) {
+    try {
+        const req = (0, module_1.createRequire)(process.cwd() + "/package.json");
+        return req(`${packageName}/package.json`).version;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Wraps the Claude Agent SDK's query function to add LangSmith tracing.
  * Traces the entire agent interaction including all streaming messages.
@@ -110,7 +120,11 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
         name: "claude.conversation",
         run_type: "chain",
         ...baseConfig,
-        metadata: { ...baseConfig?.metadata },
+        metadata: {
+            ls_integration: "claude-agent-sdk",
+            ls_integration_version: _getPackageVersion("@anthropic-ai/claude-agent-sdk"),
+            ...baseConfig?.metadata,
+        },
         __deferredSerializableArgOptions: { maxDepth: 1 },
         processInputs,
         processOutputs,

package/dist/experimental/anthropic/index.js

@@ -1,6 +1,16 @@
+import { createRequire } from "module";
 import { traceable, isTraceableFunction } from "../../traceable.js";
 import { StreamManager } from "./context.js";
 import { convertFromAnthropicMessage } from "./messages.js";
+function _getPackageVersion(packageName) {
+    try {
+        const req = createRequire(process.cwd() + "/package.json");
+        return req(`${packageName}/package.json`).version;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Wraps the Claude Agent SDK's query function to add LangSmith tracing.
  * Traces the entire agent interaction including all streaming messages.
@@ -107,7 +117,11 @@ function wrapClaudeAgentQuery(queryFn, defaultThis, baseConfig) {
         name: "claude.conversation",
         run_type: "chain",
         ...baseConfig,
-        metadata: { ...baseConfig?.metadata },
+        metadata: {
+            ls_integration: "claude-agent-sdk",
+            ls_integration_version: _getPackageVersion("@anthropic-ai/claude-agent-sdk"),
+            ...baseConfig?.metadata,
+        },
         __deferredSerializableArgOptions: { maxDepth: 1 },
         processInputs,
         processOutputs,

package/dist/experimental/vercel/index.cjs

@@ -1,6 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertMessageToTracedFormat = exports.wrapAISDK = exports.createLangSmithProviderOptions = void 0;
+const module_1 = require("module");
+function _getPackageVersion(packageName) {
+    try {
+        const req = (0, module_1.createRequire)(process.cwd() + "/package.json");
+        return req(`${packageName}/package.json`).version;
+    }
+    catch {
+        return undefined;
+    }
+}
 const middleware_js_1 = require("./middleware.cjs");
 const utils_js_1 = require("./utils.cjs");
 Object.defineProperty(exports, "convertMessageToTracedFormat", { enumerable: true, get: function () { return utils_js_1.convertMessageToTracedFormat; } });
@@ -305,6 +315,14 @@ exports.createLangSmithProviderOptions = createLangSmithProviderOptions;
  * @returns returns.streamObject - Wrapped streamObject function that traces calls to LangSmith
  */
 const wrapAISDK = (ai, baseLsConfig) => {
+    const _baseLsConfig = {
+        ...baseLsConfig,
+        metadata: {
+            ls_integration: "vercel-ai-sdk",
+            ls_integration_version: _getPackageVersion("ai"),
+            ...baseLsConfig?.metadata,
+        },
+    };
     /**
      * Wrapped version of AI SDK's generateText with LangSmith tracing.
      *
@@ -326,7 +344,7 @@ const wrapAISDK = (ai, baseLsConfig) => {
     const wrappedGenerateText = async (...args) => {
         const params = args[0];
         const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
-        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig } = _resolveConfigs(_baseLsConfig, runtimeLsConfig);
         const hasExplicitOutput = "output" in params;
         const hasExplicitExperimentalOutput = "experimental_output" in params;
         const traceableFunc = (0, traceable_js_1.traceable)(async (...args) => {
@@ -378,7 +396,7 @@ const wrapAISDK = (ai, baseLsConfig) => {
         wrappedGenerateObject = async (...args) => {
             const params = args[0];
             const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
-            const { resolvedLsConfig, resolvedChildLLMRunConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+            const { resolvedLsConfig, resolvedChildLLMRunConfig } = _resolveConfigs(_baseLsConfig, runtimeLsConfig);
             const traceableFunc = (0, traceable_js_1.traceable)(async (...args) => {
                 const [params, ...rest] = args;
                 const wrappedModel = ai.wrapLanguageModel({
@@ -446,7 +464,7 @@ const wrapAISDK = (ai, baseLsConfig) => {
     const wrappedStreamText = (...args) => {
         const params = args[0];
         const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
-        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig } = _resolveConfigs(_baseLsConfig, runtimeLsConfig);
         const hasExplicitOutput = "output" in params;
         const hasExplicitExperimentalOutput = "experimental_output" in params;
         const traceableFunc = (0, traceable_js_1.traceable)((...args) => {
@@ -499,7 +517,7 @@ const wrapAISDK = (ai, baseLsConfig) => {
         wrappedStreamObject = (...args) => {
             const params = args[0];
             const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
-            const { resolvedLsConfig, resolvedChildLLMRunConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+            const { resolvedLsConfig, resolvedChildLLMRunConfig } = _resolveConfigs(_baseLsConfig, runtimeLsConfig);
             const traceableFunc = (0, traceable_js_1.traceable)((...args) => {
                 const [params, ...rest] = args;
                 const wrappedModel = ai.wrapLanguageModel({
@@ -563,7 +581,7 @@ const wrapAISDK = (ai, baseLsConfig) => {
                     construct(ToolLoopAgent, args) {
                         const params = args[0] ?? {};
                         const { langsmith: runtimeLsConfig } = params.providerOptions ?? {};
-                        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig, } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+                        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig, } = _resolveConfigs(_baseLsConfig, runtimeLsConfig);
                         let wrappedModel = params.model;
                         if (wrappedModel != null) {
                             wrappedModel = ai.wrapLanguageModel({