@nocobase/plugin-ai 1.9.32 → 1.9.34

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/run_trees.cjs

@@ -15,21 +15,37 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRunnableConfigLike = exports.isRunTree = exports.RunTree = exports.convertToDottedOrderFormat = void 0;
+exports.RunTree = void 0;
+exports.convertToDottedOrderFormat = convertToDottedOrderFormat;
+exports.isRunTree = isRunTree;
+exports.isRunnableConfigLike = isRunnableConfigLike;
 const uuid = __importStar(require("uuid"));
-const env_js_1 = require("./utils/env.cjs");
 const client_js_1 = require("./client.cjs");
-const env_js_2 = require("./env.cjs");
-const warn_js_1 = require("./utils/warn.cjs");
+const env_js_1 = require("./env.cjs");
+const error_js_1 = require("./utils/error.cjs");
 const constants_js_1 = require("./singletons/constants.cjs");
+const env_js_2 = require("./utils/env.cjs");
+const project_js_1 = require("./utils/project.cjs");
+const env_js_3 = require("./utils/env.cjs");
+const warn_js_1 = require("./utils/warn.cjs");
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
@@ -37,14 +53,19 @@ function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
     // Date only has millisecond precision, so we use the microseconds to break
     // possible ties, avoiding incorrect run order
     const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
-    return (stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId);
+    const microsecondPrecisionDatestring = `${new Date(epoch)
+        .toISOString()
+        .slice(0, -1)}${paddedOrder}Z`;
+    return {
+        dottedOrder: stripNonAlphanumeric(microsecondPrecisionDatestring) + runId,
+        microsecondPrecisionDatestring,
+    };
 }
-exports.convertToDottedOrderFormat = convertToDottedOrderFormat;
 /**
  * Baggage header information
  */
 class Baggage {
-    constructor(metadata, tags) {
+    constructor(metadata, tags, project_name, replicas) {
         Object.defineProperty(this, "metadata", {
             enumerable: true,
             configurable: true,
@@ -57,13 +78,29 @@ class Baggage {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "project_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "replicas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.metadata = metadata;
         this.tags = tags;
+        this.project_name = project_name;
+        this.replicas = replicas;
     }
     static fromHeader(value) {
         const items = value.split(",");
         let metadata = {};
         let tags = [];
+        let project_name;
+        let replicas;
         for (const item of items) {
             const [key, uriValue] = item.split("=");
             const value = decodeURIComponent(uriValue);
@@ -73,8 +110,14 @@ class Baggage {
             else if (key === "langsmith-tags") {
                 tags = value.split(",");
             }
+            else if (key === "langsmith-project") {
+                project_name = value;
+            }
+            else if (key === "langsmith-replicas") {
+                replicas = JSON.parse(value);
+            }
         }
-        return new Baggage(metadata, tags);
+        return new Baggage(metadata, tags, project_name, replicas);
     }
     toHeader() {
         const items = [];
@@ -84,6 +127,9 @@ class Baggage {
         if (this.tags && this.tags.length > 0) {
             items.push(`langsmith-tags=${encodeURIComponent(this.tags.join(","))}`);
         }
+        if (this.project_name) {
+            items.push(`langsmith-project=${encodeURIComponent(this.project_name)}`);
+        }
         return items.join(",");
     }
 }
@@ -119,6 +165,12 @@ class RunTree {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "parent_run_id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "child_runs", {
             enumerable: true,
             configurable: true,
@@ -231,6 +283,21 @@ class RunTree {
             writable: true,
             value: void 0
         });
+        /**
+         * Projects to replicate this run to with optional updates.
+         */
+        Object.defineProperty(this, "replicas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_serialized_start_time", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         // If you pass in a run tree directly, return a shallow clone
         if (isRunTree(originalConfig)) {
             Object.assign(this, { ...originalConfig });
@@ -253,29 +320,40 @@ class RunTree {
                 this.trace_id = this.id;
             }
         }
+        this.replicas = _ensureWriteReplicas(this.replicas);
         this.execution_order ??= 1;
         this.child_execution_order ??= 1;
         if (!this.dotted_order) {
-            const currentDottedOrder = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
+            const { dottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
             if (this.parent_run) {
-                this.dotted_order =
-                    this.parent_run.dotted_order + "." + currentDottedOrder;
+                this.dotted_order = this.parent_run.dotted_order + "." + dottedOrder;
             }
             else {
-                this.dotted_order = currentDottedOrder;
+                this.dotted_order = dottedOrder;
             }
+            this._serialized_start_time = microsecondPrecisionDatestring;
         }
     }
+    set metadata(metadata) {
+        this.extra = {
+            ...this.extra,
+            metadata: {
+                ...this.extra?.metadata,
+                ...metadata,
+            },
+        };
+    }
+    get metadata() {
+        return this.extra?.metadata;
+    }
     static getDefaultConfig() {
         return {
             id: uuid.v4(),
             run_type: "chain",
-            project_name: (0, env_js_1.getLangSmithEnvironmentVariable)("PROJECT") ??
-                (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION") ?? // TODO: Deprecate
-                "default",
+            project_name: (0, project_js_1.getDefaultProjectName)(),
             child_runs: [],
-            api_url: (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984",
-            api_key: (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_API_KEY"),
+            api_url: (0, env_js_2.getEnvironmentVariable)("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984",
+            api_key: (0, env_js_2.getEnvironmentVariable)("LANGCHAIN_API_KEY"),
             caller_options: {},
             start_time: Date.now(),
             serialized: {},
@@ -295,6 +373,7 @@ class RunTree {
             ...config,
             parent_run: this,
             project_name: this.project_name,
+            replicas: this.replicas,
             client: this.client,
             tracingEnabled: this.tracingEnabled,
             execution_order: child_execution_order,
@@ -349,13 +428,16 @@ class RunTree {
     }
     _convertToCreate(run, runtimeEnv, excludeChildRuns = true) {
         const runExtra = run.extra ?? {};
-        if (!runExtra.runtime) {
-            runExtra.runtime = {};
-        }
-        if (runtimeEnv) {
-            for (const [k, v] of Object.entries(runtimeEnv)) {
-                if (!runExtra.runtime[k]) {
-                    runExtra.runtime[k] = v;
+        // Avoid overwriting the runtime environment if it's already set
+        if (runExtra?.runtime?.library === undefined) {
+            if (!runExtra.runtime) {
+                runExtra.runtime = {};
+            }
+            if (runtimeEnv) {
+                for (const [k, v] of Object.entries(runtimeEnv)) {
+                    if (!runExtra.runtime[k]) {
+                        runExtra.runtime[k] = v;
+                    }
                 }
             }
         }
@@ -366,13 +448,13 @@ class RunTree {
             parent_run_id = undefined;
         }
         else {
-            parent_run_id = run.parent_run?.id;
+            parent_run_id = run.parent_run?.id ?? run.parent_run_id;
             child_runs = [];
         }
-        const persistedRun = {
+        return {
             id: run.id,
             name: run.name,
-            start_time: run.start_time,
+            start_time: run._serialized_start_time ?? run.start_time,
             end_time: run.end_time,
             run_type: run.run_type,
             reference_example_id: run.reference_example_id,
@@ -388,14 +470,74 @@ class RunTree {
             dotted_order: run.dotted_order,
             tags: run.tags,
             attachments: run.attachments,
+            events: run.events,
+        };
+    }
+    _remapForProject(projectName, runtimeEnv, excludeChildRuns = true) {
+        const baseRun = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
+        if (projectName === this.project_name) {
+            return baseRun;
+        }
+        // Create a deterministic UUID mapping for this project
+        const createRemappedId = (originalId) => {
+            return uuid.v5(`${originalId}:${projectName}`, uuid.v5.DNS);
+        };
+        // Remap the current run's ID
+        const newId = createRemappedId(baseRun.id);
+        const newTraceId = baseRun.trace_id
+            ? createRemappedId(baseRun.trace_id)
+            : undefined;
+        const newParentRunId = baseRun.parent_run_id
+            ? createRemappedId(baseRun.parent_run_id)
+            : undefined;
+        let newDottedOrder;
+        if (baseRun.dotted_order) {
+            const segments = _parseDottedOrder(baseRun.dotted_order);
+            const rebuilt = [];
+            // Process all segments except the last one
+            for (let i = 0; i < segments.length - 1; i++) {
+                const [timestamp, segmentId] = segments[i];
+                const remappedId = createRemappedId(segmentId);
+                rebuilt.push(timestamp.toISOString().replace(/[-:]/g, "").replace(".", "") +
+                    remappedId);
+            }
+            // Process the last segment with the new run ID
+            const [lastTimestamp] = segments[segments.length - 1];
+            rebuilt.push(lastTimestamp.toISOString().replace(/[-:]/g, "").replace(".", "") +
+                newId);
+            newDottedOrder = rebuilt.join(".");
+        }
+        else {
+            newDottedOrder = undefined;
+        }
+        const remappedRun = {
+            ...baseRun,
+            id: newId,
+            trace_id: newTraceId,
+            parent_run_id: newParentRunId,
+            dotted_order: newDottedOrder,
+            session_name: projectName,
         };
-        return persistedRun;
+        return remappedRun;
     }
     async postRun(excludeChildRuns = true) {
         try {
-            const runtimeEnv = (0, env_js_1.getRuntimeEnvironment)();
-            const runCreate = await this._convertToCreate(this, runtimeEnv, true);
-            await this.client.createRun(runCreate);
+            const runtimeEnv = (0, env_js_2.getRuntimeEnvironment)();
+            if (this.replicas && this.replicas.length > 0) {
+                for (const { projectName, apiKey, apiUrl, workspaceId } of this
+                    .replicas) {
+                    const runCreate = this._remapForProject(projectName ?? this.project_name, runtimeEnv, true);
+                    await this.client.createRun(runCreate, {
+                        apiKey,
+                        apiUrl,
+                        workspaceId,
+                    });
+                }
+            }
+            else {
+                const runCreate = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
+                await this.client.createRun(runCreate);
+            }
             if (!excludeChildRuns) {
                 (0, warn_js_1.warnOnce)("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
                 for (const childRun of this.child_runs) {
@@ -407,26 +549,67 @@ class RunTree {
             console.error(`Error in postRun for run ${this.id}:`, error);
         }
     }
-    async patchRun() {
-        try {
-            const runUpdate = {
-                end_time: this.end_time,
-                error: this.error,
-                inputs: this.inputs,
-                outputs: this.outputs,
-                parent_run_id: this.parent_run?.id,
-                reference_example_id: this.reference_example_id,
-                extra: this.extra,
-                events: this.events,
-                dotted_order: this.dotted_order,
-                trace_id: this.trace_id,
-                tags: this.tags,
-                attachments: this.attachments,
-            };
-            await this.client.updateRun(this.id, runUpdate);
+    async patchRun(options) {
+        if (this.replicas && this.replicas.length > 0) {
+            for (const { projectName, apiKey, apiUrl, workspaceId, updates } of this
+                .replicas) {
+                const runData = this._remapForProject(projectName ?? this.project_name);
+                const updatePayload = {
+                    id: runData.id,
+                    outputs: runData.outputs,
+                    error: runData.error,
+                    parent_run_id: runData.parent_run_id,
+                    session_name: runData.session_name,
+                    reference_example_id: runData.reference_example_id,
+                    end_time: runData.end_time,
+                    dotted_order: runData.dotted_order,
+                    trace_id: runData.trace_id,
+                    events: runData.events,
+                    tags: runData.tags,
+                    extra: runData.extra,
+                    attachments: this.attachments,
+                    ...updates,
+                };
+                // Important that inputs is not a key in the run update
+                // if excluded because it will overwrite the run create if the
+                // two operations are merged during batching
+                if (!options?.excludeInputs) {
+                    updatePayload.inputs = runData.inputs;
+                }
+                await this.client.updateRun(runData.id, updatePayload, {
+                    apiKey,
+                    apiUrl,
+                    workspaceId,
+                });
+            }
         }
-        catch (error) {
-            console.error(`Error in patchRun for run ${this.id}`, error);
+        else {
+            try {
+                const runUpdate = {
+                    end_time: this.end_time,
+                    error: this.error,
+                    outputs: this.outputs,
+                    parent_run_id: this.parent_run?.id ?? this.parent_run_id,
+                    reference_example_id: this.reference_example_id,
+                    extra: this.extra,
+                    events: this.events,
+                    dotted_order: this.dotted_order,
+                    trace_id: this.trace_id,
+                    tags: this.tags,
+                    attachments: this.attachments,
+                    session_name: this.project_name,
+                };
+                // Important that inputs is not a key in the run update
+                // if excluded because it will overwrite the run create if the
+                // two operations are merged during batching
+                if (!options?.excludeInputs) {
+                    runUpdate.inputs = this.inputs;
+                }
+                await this.client.updateRun(this.id, runUpdate);
+            }
+            catch (error) {
+                console.error(`Error in patchRun for run ${this.id}`, error);
+            }
         }
     }
     toJSON() {
@@ -460,7 +643,7 @@ class RunTree {
         let parentRun;
         let projectName;
         let client;
-        let tracingEnabled = (0, env_js_2.isTracingEnabled)();
+        let tracingEnabled = (0, env_js_1.isTracingEnabled)();
         if (callbackManager) {
             const parentRunId = callbackManager?.getParentRunId?.() ?? "";
             const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
@@ -529,13 +712,15 @@ class RunTree {
             const baggage = Baggage.fromHeader(rawHeaders["baggage"]);
             config.metadata = baggage.metadata;
             config.tags = baggage.tags;
+            config.project_name = baggage.project_name;
+            config.replicas = baggage.replicas;
         }
         return new RunTree(config);
     }
     toHeaders(headers) {
         const result = {
             "langsmith-trace": this.dotted_order,
-            baggage: new Baggage(this.extra?.metadata, this.tags).toHeader(),
+            baggage: new Baggage(this.extra?.metadata, this.tags, this.project_name, this.replicas).toHeader(),
         };
         if (headers) {
             for (const [key, value] of Object.entries(result)) {
@@ -553,11 +738,10 @@ Object.defineProperty(RunTree, "sharedClient", {
     value: null
 });
 function isRunTree(x) {
-    return (x !== undefined &&
+    return (x != null &&
         typeof x.createChild === "function" &&
         typeof x.postRun === "function");
 }
-exports.isRunTree = isRunTree;
 function isLangChainTracerLike(x) {
     return (typeof x === "object" &&
         x != null &&
@@ -576,11 +760,114 @@ function isRunnableConfigLike(x) {
     // Check that it's an object with a callbacks arg
     // that has either a CallbackManagerLike object with a langchain tracer within it
     // or an array with a LangChainTracerLike object within it
-    return (x !== undefined &&
+    return (x != null &&
         typeof x.callbacks === "object" &&
         // Callback manager with a langchain tracer
         (containsLangChainTracerLike(x.callbacks?.handlers) ||
             // Or it's an array with a LangChainTracerLike object within it
             containsLangChainTracerLike(x.callbacks)));
 }
-exports.isRunnableConfigLike = isRunnableConfigLike;
+function _parseDottedOrder(dottedOrder) {
+    const parts = dottedOrder.split(".");
+    return parts.map((part) => {
+        const timestampStr = part.slice(0, -36);
+        const uuidStr = part.slice(-36);
+        // Parse timestamp: "%Y%m%dT%H%M%S%fZ" format
+        // Example: "20231215T143045123456Z"
+        const year = parseInt(timestampStr.slice(0, 4));
+        const month = parseInt(timestampStr.slice(4, 6)) - 1; // JS months are 0-indexed
+        const day = parseInt(timestampStr.slice(6, 8));
+        const hour = parseInt(timestampStr.slice(9, 11));
+        const minute = parseInt(timestampStr.slice(11, 13));
+        const second = parseInt(timestampStr.slice(13, 15));
+        const microsecond = parseInt(timestampStr.slice(15, 21));
+        const timestamp = new Date(year, month, day, hour, minute, second, microsecond / 1000);
+        return [timestamp, uuidStr];
+    });
+}
+function _getWriteReplicasFromEnv() {
+    const envVar = (0, env_js_2.getEnvironmentVariable)("LANGSMITH_RUNS_ENDPOINTS");
+    if (!envVar)
+        return [];
+    try {
+        const parsed = JSON.parse(envVar);
+        if (Array.isArray(parsed)) {
+            const replicas = [];
+            for (const item of parsed) {
+                if (typeof item !== "object" || item === null) {
+                    console.warn(`Invalid item type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected object, got ${typeof item}`);
+                    continue;
+                }
+                if (typeof item.api_url !== "string") {
+                    console.warn(`Invalid api_url type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected string, got ${typeof item.api_url}`);
+                    continue;
+                }
+                if (typeof item.api_key !== "string") {
+                    console.warn(`Invalid api_key type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected string, got ${typeof item.api_key}`);
+                    continue;
+                }
+                replicas.push({
+                    apiUrl: item.api_url.replace(/\/$/, ""),
+                    apiKey: item.api_key,
+                });
+            }
+            return replicas;
+        }
+        else if (typeof parsed === "object" && parsed !== null) {
+            _checkEndpointEnvUnset(parsed);
+            const replicas = [];
+            for (const [url, key] of Object.entries(parsed)) {
+                const cleanUrl = url.replace(/\/$/, "");
+                if (typeof key === "string") {
+                    replicas.push({
+                        apiUrl: cleanUrl,
+                        apiKey: key,
+                    });
+                }
+                else {
+                    console.warn(`Invalid value type in LANGSMITH_RUNS_ENDPOINTS for URL ${url}: ` +
+                        `expected string, got ${typeof key}`);
+                    continue;
+                }
+            }
+            return replicas;
+        }
+        else {
+            console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of " +
+                `objects with api_url and api_key properties, or object mapping url->apiKey, got ${typeof parsed}`);
+            return [];
+        }
+    }
+    catch (e) {
+        if ((0, error_js_1.isConflictingEndpointsError)(e)) {
+            throw e;
+        }
+        console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of " +
+            "objects with api_url and api_key properties, or object mapping url->apiKey");
+        return [];
+    }
+}
+function _ensureWriteReplicas(replicas) {
+    // If null -> fetch from env
+    if (replicas) {
+        return replicas.map((replica) => {
+            if (Array.isArray(replica)) {
+                return {
+                    projectName: replica[0],
+                    updates: replica[1],
+                };
+            }
+            return replica;
+        });
+    }
+    return _getWriteReplicasFromEnv();
+}
+function _checkEndpointEnvUnset(parsed) {
+    if (Object.keys(parsed).length > 0 &&
+        (0, env_js_3.getLangSmithEnvironmentVariable)("ENDPOINT")) {
+        throw new error_js_1.ConflictingEndpointsError();
+    }
+}

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/run_trees.d.ts

@@ -1,6 +1,9 @@
-import { Attachments, BaseRun, KVMap, RunCreate } from "./schemas.js";
 import { Client } from "./client.js";
-export declare function convertToDottedOrderFormat(epoch: number, runId: string, executionOrder?: number): string;
+import { Attachments, BaseRun, KVMap, RunCreate } from "./schemas.js";
+export declare function convertToDottedOrderFormat(epoch: number, runId: string, executionOrder?: number): {
+    dottedOrder: string;
+    microsecondPrecisionDatestring: string;
+};
 export interface RunTreeConfig {
     name: string;
     run_type?: string;
@@ -9,8 +12,8 @@ export interface RunTreeConfig {
     parent_run?: RunTree;
     parent_run_id?: string;
     child_runs?: RunTree[];
-    start_time?: number;
-    end_time?: number;
+    start_time?: number | string;
+    end_time?: number | string;
     extra?: KVMap;
     metadata?: KVMap;
     tags?: string[];
@@ -27,6 +30,7 @@ export interface RunTreeConfig {
     trace_id?: string;
     dotted_order?: string;
     attachments?: Attachments;
+    replicas?: Replica[];
 }
 export interface RunnableConfigLike {
     /**
@@ -49,6 +53,16 @@ interface HeadersLike {
     get(name: string): string | null;
     set(name: string, value: string): void;
 }
+type ProjectReplica = [string, KVMap | undefined];
+type WriteReplica = {
+    apiUrl?: string;
+    apiKey?: string;
+    workspaceId?: string;
+    projectName?: string;
+    updates?: KVMap | undefined;
+    fromEnv?: boolean;
+};
+type Replica = ProjectReplica | WriteReplica;
 export declare class RunTree implements BaseRun {
     private static sharedClient;
     id: string;
@@ -56,6 +70,7 @@ export declare class RunTree implements BaseRun {
     run_type: string;
     project_name: string;
     parent_run?: RunTree;
+    parent_run_id?: string;
     child_runs: RunTree[];
     start_time: number;
     end_time?: number;
@@ -78,15 +93,27 @@ export declare class RunTree implements BaseRun {
      * Each entry is a tuple of [mime_type, bytes]
      */
     attachments?: Attachments;
+    /**
+     * Projects to replicate this run to with optional updates.
+     */
+    replicas?: WriteReplica[];
+    private _serialized_start_time;
     constructor(originalConfig: RunTreeConfig | RunTree);
+    set metadata(metadata: KVMap);
+    get metadata(): KVMap;
     private static getDefaultConfig;
-    private static getSharedClient;
+    static getSharedClient(): Client;
     createChild(config: RunTreeConfig): RunTree;
     end(outputs?: KVMap, error?: string, endTime?: number, metadata?: KVMap): Promise<void>;
     private _convertToCreate;
+    private _remapForProject;
     postRun(excludeChildRuns?: boolean): Promise<void>;
-    patchRun(): Promise<void>;
-    toJSON(): RunCreate;
+    patchRun(options?: {
+        excludeInputs?: boolean;
+    }): Promise<void>;
+    toJSON(): RunCreate & {
+        id: string;
+    };
     /**
      * Add an event to the run tree.
      * @param event - A single event or string to add
@@ -94,7 +121,7 @@ export declare class RunTree implements BaseRun {
     addEvent(event: RunEvent | string): void;
     static fromRunnableConfig(parentConfig: RunnableConfigLike, props: RunTreeConfig): RunTree;
     static fromDottedOrder(dottedOrder: string): RunTree | undefined;
-    static fromHeaders(headers: Record<string, string | string[]> | HeadersLike, inheritArgs?: RunTreeConfig): RunTree | undefined;
+    static fromHeaders(headers: Record<string, string | string[]> | HeadersLike, inheritArgs?: Partial<RunTreeConfig>): RunTree | undefined;
     toHeaders(headers?: HeadersLike): {
         "langsmith-trace": string;
         baggage: string;