@nocobase/plugin-ai 1.9.36 → 1.9.37

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

@@ -1,22 +1,38 @@
-import * as uuid from "uuid";
 import { Client } from "./client.js";
 import { isTracingEnabled } from "./env.js";
 import { isConflictingEndpointsError, ConflictingEndpointsError, } from "./utils/error.js";
-import { _LC_CONTEXT_VARIABLES_KEY } from "./singletons/constants.js";
+import { _LC_CONTEXT_VARIABLES_KEY, _REPLICA_TRACE_ROOTS_KEY, } from "./singletons/constants.js";
+import { getContextVar, setContextVar } from "./utils/context_vars.js";
 import { getEnvironmentVariable, getRuntimeEnvironment, } from "./utils/env.js";
 import { getDefaultProjectName } from "./utils/project.js";
 import { getLangSmithEnvironmentVariable } from "./utils/env.js";
 import { warnOnce } from "./utils/warn.js";
+import { uuid7FromTime } from "./utils/_uuid.js";
+import { v5 as uuidv5 } from "uuid";
+const TIMESTAMP_LENGTH = 36;
+// DNS namespace for UUID v5 (same as Python's uuid.NAMESPACE_DNS)
+const UUID_NAMESPACE_DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+function getReplicaKey(replica) {
+    // Generate a unique key by hashing the replica's identifying properties
+    // This ensures each unique replica (combination of projectName, apiUrl, workspaceId, apiKey) gets a unique key
+    // Sort keys to ensure consistent hashing
+    const sortedKeys = Object.keys(replica).sort();
+    const keyData = sortedKeys
+        .map((key) => `${key}:${replica[key] ?? ""}`)
+        .join("|");
+    return uuidv5(keyData, UUID_NAMESPACE_DNS);
+}
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
-export function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
+function getMicrosecondPrecisionDatestring(epoch, 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");
-    const microsecondPrecisionDatestring = `${new Date(epoch)
-        .toISOString()
-        .slice(0, -1)}${paddedOrder}Z`;
+    return `${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`;
+}
+export function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
+    const microsecondPrecisionDatestring = getMicrosecondPrecisionDatestring(epoch, executionOrder);
     return {
         dottedOrder: stripNonAlphanumeric(microsecondPrecisionDatestring) + runId,
         microsecondPrecisionDatestring,
@@ -253,6 +269,12 @@ export class RunTree {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "distributedParentId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_serialized_start_time", {
             enumerable: true,
             configurable: true,
@@ -272,7 +294,20 @@ export class RunTree {
             ...config?.extra?.metadata,
         };
         config.extra = { ...config.extra, metadata: dedupedMetadata };
+        if ("id" in config && config.id == null) {
+            delete config.id;
+        }
         Object.assign(this, { ...defaultConfig, ...config, client });
+        this.execution_order ??= 1;
+        this.child_execution_order ??= 1;
+        // Generate serialized start time for ID generation
+        if (!this.dotted_order) {
+            this._serialized_start_time = getMicrosecondPrecisionDatestring(this.start_time, this.execution_order);
+        }
+        // Generate id from serialized start_time if not provided
+        if (!this.id) {
+            this.id = uuid7FromTime(this._serialized_start_time ?? this.start_time);
+        }
         if (!this.trace_id) {
             if (this.parent_run) {
                 this.trace_id = this.parent_run.trace_id ?? this.id;
@@ -282,17 +317,15 @@ export class RunTree {
             }
         }
         this.replicas = _ensureWriteReplicas(this.replicas);
-        this.execution_order ??= 1;
-        this.child_execution_order ??= 1;
+        // Now set the dotted order with the actual ID
         if (!this.dotted_order) {
-            const { dottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
+            const { dottedOrder } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
             if (this.parent_run) {
                 this.dotted_order = this.parent_run.dotted_order + "." + dottedOrder;
             }
             else {
                 this.dotted_order = dottedOrder;
             }
-            this._serialized_start_time = microsecondPrecisionDatestring;
         }
     }
     set metadata(metadata) {
@@ -308,15 +341,15 @@ export class RunTree {
         return this.extra?.metadata;
     }
     static getDefaultConfig() {
+        const start_time = Date.now();
         return {
-            id: uuid.v4(),
             run_type: "chain",
             project_name: getDefaultProjectName(),
             child_runs: [],
             api_url: getEnvironmentVariable("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984",
             api_key: getEnvironmentVariable("LANGCHAIN_API_KEY"),
             caller_options: {},
-            start_time: Date.now(),
+            start_time,
             serialized: {},
             inputs: {},
             extra: {},
@@ -330,11 +363,18 @@ export class RunTree {
     }
     createChild(config) {
         const child_execution_order = this.child_execution_order + 1;
+        // Handle replicas: if child has its own replicas, use those; otherwise inherit parent's (with reroot stripped)
+        // Reroot should only apply to the run where it's explicitly configured, not propagate down
+        const inheritedReplicas = this.replicas?.map((replica) => {
+            const { reroot, ...rest } = replica;
+            return rest;
+        });
+        const childReplicas = config.replicas ?? inheritedReplicas;
         const child = new RunTree({
             ...config,
             parent_run: this,
             project_name: this.project_name,
-            replicas: this.replicas,
+            replicas: childReplicas,
             client: this.client,
             tracingEnabled: this.tracingEnabled,
             execution_order: child_execution_order,
@@ -434,60 +474,185 @@ export class RunTree {
             events: run.events,
         };
     }
-    _remapForProject(projectName, runtimeEnv, excludeChildRuns = true) {
+    _sliceParentId(parentId, run) {
+        /**
+         * Slice the parent id from dotted order.
+         * Additionally check if the current run is a child of the parent. If so, update
+         * the parent_run_id to undefined, and set the trace id to the new root id after
+         * parent_id.
+         */
+        if (run.dotted_order) {
+            const segs = run.dotted_order.split(".");
+            let startIdx = null;
+            // Find the index of the parent ID in the dotted order
+            for (let idx = 0; idx < segs.length; idx++) {
+                const segId = segs[idx].slice(-TIMESTAMP_LENGTH);
+                if (segId === parentId) {
+                    startIdx = idx;
+                    break;
+                }
+            }
+            if (startIdx !== null) {
+                // Trim segments to start after parent_id (exclusive)
+                const trimmedSegs = segs.slice(startIdx + 1);
+                // Rebuild dotted_order
+                run.dotted_order = trimmedSegs.join(".");
+                if (trimmedSegs.length > 0) {
+                    run.trace_id = trimmedSegs[0].slice(-TIMESTAMP_LENGTH);
+                }
+                else {
+                    run.trace_id = run.id;
+                }
+            }
+        }
+        if (run.parent_run_id === parentId) {
+            // We've found the new root node.
+            run.parent_run_id = undefined;
+        }
+    }
+    _setReplicaTraceRoot(replicaKey, traceRootId) {
+        // Set the replica trace root in context vars on this run and all descendants
+        const replicaTraceRoots = getContextVar(this, _REPLICA_TRACE_ROOTS_KEY) ?? {};
+        replicaTraceRoots[replicaKey] = traceRootId;
+        setContextVar(this, _REPLICA_TRACE_ROOTS_KEY, replicaTraceRoots);
+        // Recursively update all descendants to avoid race conditions
+        // around run tree creation vs processing time
+        for (const child of this.child_runs) {
+            child._setReplicaTraceRoot(replicaKey, traceRootId);
+        }
+    }
+    _remapForProject(params) {
+        const { projectName, runtimeEnv, excludeChildRuns = true, reroot = false, distributedParentId, apiUrl, apiKey, workspaceId, } = params;
         const baseRun = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
+        // Skip remapping if project name is the same
         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);
+            return {
+                ...baseRun,
+                session_name: projectName,
+            };
+        }
+        // Apply reroot logic before ID remapping
+        if (reroot) {
+            if (distributedParentId) {
+                // If we have a distributed parent ID, slice at that point
+                this._sliceParentId(distributedParentId, baseRun);
+            }
+            else {
+                // If no distributed parent ID, simply make this run a root run
+                // by removing parent_run_id and resetting trace info
+                baseRun.parent_run_id = undefined;
+                // Keep the current run as the trace root
+                if (baseRun.dotted_order) {
+                    // Reset dotted order to just this run
+                    const segs = baseRun.dotted_order.split(".");
+                    if (segs.length > 0) {
+                        baseRun.dotted_order = segs[segs.length - 1];
+                        baseRun.trace_id = baseRun.id;
+                    }
+                }
             }
-            // 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(".");
+            // Store this run's original ID in context vars so descendants know the new trace root
+            // We store the original ID (before remapping) so it can be found in dotted_order
+            const replicaKey = getReplicaKey({
+                projectName,
+                apiUrl,
+                apiKey,
+                workspaceId,
+            });
+            this._setReplicaTraceRoot(replicaKey, baseRun.id);
+        }
+        // If an ancestor was rerooted for this replica, update trace_id and dotted_order
+        // to reflect the new trace hierarchy. This is tracked via context variables.
+        let ancestorRerootedTraceId;
+        if (!reroot) {
+            const replicaTraceRoots = getContextVar(this, _REPLICA_TRACE_ROOTS_KEY) ?? {};
+            const replicaKey = getReplicaKey({
+                projectName,
+                apiUrl,
+                apiKey,
+                workspaceId,
+            });
+            ancestorRerootedTraceId = replicaTraceRoots[replicaKey];
+            if (ancestorRerootedTraceId) {
+                // An ancestor was rerooted for this replica, so set our trace_id
+                // to the ancestor's original (unmapped) ID. It will be remapped along with other IDs.
+                baseRun.trace_id = ancestorRerootedTraceId;
+                // Also slice the dotted_order to start from the new trace root
+                // This ensures descendants of a rerooted ancestor have correct hierarchy
+                if (baseRun.dotted_order) {
+                    const segs = baseRun.dotted_order.split(".");
+                    let rootIdx = null;
+                    // Find the new trace root's segment in dotted_order
+                    for (let idx = 0; idx < segs.length; idx++) {
+                        const segId = segs[idx].slice(-TIMESTAMP_LENGTH);
+                        if (segId === ancestorRerootedTraceId) {
+                            rootIdx = idx;
+                            break;
+                        }
+                    }
+                    if (rootIdx !== null) {
+                        // Keep segments from new trace root onwards
+                        const trimmedSegs = segs.slice(rootIdx);
+                        baseRun.dotted_order = trimmedSegs.join(".");
+                    }
+                }
+            }
+        }
+        // Remap IDs for the replica using uuid5 (deterministic)
+        // This ensures consistency across runs in the same replica
+        const oldId = baseRun.id;
+        const newId = uuidv5(`${oldId}:${projectName}`, UUID_NAMESPACE_DNS);
+        // Remap trace_id
+        let newTraceId;
+        if (baseRun.trace_id) {
+            newTraceId = uuidv5(`${baseRun.trace_id}:${projectName}`, UUID_NAMESPACE_DNS);
         }
         else {
-            newDottedOrder = undefined;
+            newTraceId = newId;
         }
-        const remappedRun = {
+        // Remap parent_run_id
+        let newParentId;
+        if (baseRun.parent_run_id) {
+            newParentId = uuidv5(`${baseRun.parent_run_id}:${projectName}`, UUID_NAMESPACE_DNS);
+        }
+        // Remap dotted_order segments
+        let newDottedOrder;
+        if (baseRun.dotted_order) {
+            const segs = baseRun.dotted_order.split(".");
+            const remappedSegs = segs.map((seg) => {
+                // Extract the UUID from the segment (last TIMESTAMP_LENGTH characters)
+                const segId = seg.slice(-TIMESTAMP_LENGTH);
+                const remappedId = uuidv5(`${segId}:${projectName}`, UUID_NAMESPACE_DNS);
+                // Replace the UUID part while keeping the timestamp prefix
+                return seg.slice(0, -TIMESTAMP_LENGTH) + remappedId;
+            });
+            newDottedOrder = remappedSegs.join(".");
+        }
+        return {
             ...baseRun,
             id: newId,
             trace_id: newTraceId,
-            parent_run_id: newParentRunId,
+            parent_run_id: newParentId,
             dotted_order: newDottedOrder,
             session_name: projectName,
         };
-        return remappedRun;
     }
     async postRun(excludeChildRuns = true) {
         try {
             const runtimeEnv = getRuntimeEnvironment();
             if (this.replicas && this.replicas.length > 0) {
-                for (const { projectName, apiKey, apiUrl, workspaceId } of this
+                for (const { projectName, apiKey, apiUrl, workspaceId, reroot } of this
                     .replicas) {
-                    const runCreate = this._remapForProject(projectName ?? this.project_name, runtimeEnv, true);
+                    const runCreate = this._remapForProject({
+                        projectName: projectName ?? this.project_name,
+                        runtimeEnv,
+                        excludeChildRuns: true,
+                        reroot,
+                        distributedParentId: this.distributedParentId,
+                        apiUrl,
+                        apiKey,
+                        workspaceId,
+                    });
                     await this.client.createRun(runCreate, {
                         apiKey,
                         apiUrl,
@@ -512,11 +677,22 @@ export class RunTree {
     }
     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);
+            for (const { projectName, apiKey, apiUrl, workspaceId, updates, reroot, } of this.replicas) {
+                const runData = this._remapForProject({
+                    projectName: projectName ?? this.project_name,
+                    runtimeEnv: undefined,
+                    excludeChildRuns: true,
+                    reroot,
+                    distributedParentId: this.distributedParentId,
+                    apiUrl,
+                    apiKey,
+                    workspaceId,
+                });
                 const updatePayload = {
                     id: runData.id,
+                    name: runData.name,
+                    run_type: runData.run_type,
+                    start_time: runData.start_time,
                     outputs: runData.outputs,
                     error: runData.error,
                     parent_run_id: runData.parent_run_id,
@@ -547,6 +723,9 @@ export class RunTree {
         else {
             try {
                 const runUpdate = {
+                    name: this.name,
+                    run_type: this.run_type,
+                    start_time: this._serialized_start_time ?? this.start_time,
                     end_time: this.end_time,
                     error: this.error,
                     outputs: this.outputs,
@@ -676,7 +855,10 @@ export class RunTree {
             config.project_name = baggage.project_name;
             config.replicas = baggage.replicas;
         }
-        return new RunTree(config);
+        const runTree = new RunTree(config);
+        // Set the distributed parent ID to this run's ID for rerooting
+        runTree.distributedParentId = runTree.id;
+        return runTree;
     }
     toHeaders(headers) {
         const result = {
@@ -720,30 +902,14 @@ export 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
+    const callbacks = x?.callbacks;
     return (x != null &&
-        typeof x.callbacks === "object" &&
+        typeof callbacks === "object" &&
         // Callback manager with a langchain tracer
-        (containsLangChainTracerLike(x.callbacks?.handlers) ||
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (containsLangChainTracerLike(callbacks?.handlers) ||
             // Or it's an array with a LangChainTracerLike object within it
-            containsLangChainTracerLike(x.callbacks)));
-}
-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];
-    });
+            containsLangChainTracerLike(callbacks)));
 }
 function _getWriteReplicasFromEnv() {
     const envVar = getEnvironmentVariable("LANGSMITH_RUNS_ENDPOINTS");

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

@@ -152,6 +152,9 @@ export interface RunCreate extends BaseRun {
 }
 export interface RunUpdate {
     id?: string;
+    name?: string;
+    run_type?: string;
+    start_time?: number | string;
     end_time?: number | string;
     extra?: KVMap;
     tags?: string[];

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/constants.cjs

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._LC_CONTEXT_VARIABLES_KEY = void 0;
+exports._REPLICA_TRACE_ROOTS_KEY = exports._LC_CONTEXT_VARIABLES_KEY = void 0;
 exports._LC_CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
+exports._REPLICA_TRACE_ROOTS_KEY = Symbol.for("langsmith:replica_trace_roots");

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/constants.d.ts

@@ -1 +1,2 @@
 export declare const _LC_CONTEXT_VARIABLES_KEY: unique symbol;
+export declare const _REPLICA_TRACE_ROOTS_KEY: unique symbol;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/constants.js

@@ -1 +1,2 @@
 export const _LC_CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
+export const _REPLICA_TRACE_ROOTS_KEY = Symbol.for("langsmith:replica_trace_roots");

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/singletons/types.d.ts

@@ -1,16 +1,18 @@
 import { RunTree, RunnableConfigLike } from "../run_trees.js";
 import { ROOT } from "./traceable.js";
 import { _LC_CONTEXT_VARIABLES_KEY } from "./constants.js";
-type SmartPromise<T> = T extends AsyncGenerator ? T : T extends Promise<unknown> ? T : Promise<T>;
+type SmartPromise<T> = T extends AsyncIterable<any> ? T : T extends Promise<unknown> ? T : Promise<T>;
 type WrapArgReturnPair<Pair> = Pair extends [
     infer Args extends any[],
     infer Return
 ] ? Args extends [RunTree, ...infer RestArgs] ? {
     (runTree: RunTree | typeof ROOT, ...args: RestArgs): SmartPromise<Return>;
+    /** @deprecated Will be removed in 0.4 */
     (config: RunnableConfigLike, ...args: RestArgs): SmartPromise<Return>;
 } : {
     (...args: Args): SmartPromise<Return>;
-    (runTree: RunTree, ...rest: Args): SmartPromise<Return>;
+    (runTree: RunTree | typeof ROOT, ...rest: Args): SmartPromise<Return>;
+    /** @deprecated Will be removed in 0.4 */
     (config: RunnableConfigLike, ...args: Args): SmartPromise<Return>;
 } : never;
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;

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

@@ -91,7 +91,9 @@ const runInputsToMap = (rawInputs) => {
     }
     return inputs;
 };
-const handleRunInputs = (inputs, processInputs) => {
+const handleRunInputs = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+inputs, processInputs) => {
     try {
         return processInputs(inputs);
     }
@@ -147,6 +149,7 @@ function isAsyncFn(fn) {
 // Note: This mutates the run tree
 async function handleRunOutputs(params) {
     const { runTree, rawOutputs, processOutputsFn, on_end, postRunPromise, excludeInputs, } = params;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let outputs;
     if ((0, asserts_js_1.isKVMap)(rawOutputs)) {
         outputs = { ...rawOutputs };

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

@@ -2,6 +2,18 @@ import { RunTreeConfig } from "./run_trees.js";
 import { Attachments, InvocationParamsSchema, KVMap } from "./schemas.js";
 import type { TraceableFunction } from "./singletons/types.js";
 import { OTELTracer } from "./experimental/otel/types.js";
+export type ProcessInputs<Args extends unknown[]> = Args extends [] ? Record<string, never> : Args extends [infer Input] ? Input extends KVMap ? Input extends Iterable<infer Item> | AsyncIterable<infer Item> ? {
+    input: Array<Item>;
+} : Input : {
+    input: Input;
+} : {
+    args: Args;
+};
+export type ProcessOutputs<ReturnValue> = ReturnValue extends KVMap ? ReturnValue extends Iterable<infer Item> | AsyncIterable<infer Item> ? {
+    outputs: Array<Item>;
+} : ReturnValue : {
+    outputs: ReturnValue;
+};
 export type TraceableConfig<Func extends (...args: any[]) => any> = Partial<Omit<RunTreeConfig, "inputs" | "outputs">> & {
     aggregator?: (args: any[]) => any;
     argsConfigPath?: [number] | [number, string];
@@ -27,19 +39,31 @@ export type TraceableConfig<Func extends (...args: any[]) => any> = Partial<Omit
      * This function should NOT mutate the inputs.
      * `processInputs` is not inherited by nested traceable functions.
      *
+     * The input to this function is determined as follows based on the
+     * arguments passed to the wrapped function:
+     * - If called with one argument that is an object, it will be the unchanged argument
+     * - If called with one argument that is not an object, it will be `{ input: arg }`
+     * - If called with multiple arguments, it will be `{ args: [...arguments] }`
+     * - If called with no arguments, it will be an empty object `{}`
+     *
      * @param inputs Key-value map of the function inputs.
      * @returns Transformed key-value map
      */
-    processInputs?: (inputs: Readonly<KVMap>) => KVMap;
+    processInputs?: (inputs: Readonly<ProcessInputs<Parameters<Func>>>) => KVMap;
     /**
      * Apply transformations to the outputs before logging.
      * This function should NOT mutate the outputs.
      * `processOutputs` is not inherited by nested traceable functions.
      *
+     * The input to this function is determined as follows based on the
+     * return value of the wrapped function:
+     * - If the return value is an object, it will be the unchanged return value
+     * - If the return value is not an object, it will wrapped as `{ outputs: returnValue }`
+     *
      * @param outputs Key-value map of the function outputs
      * @returns Transformed key-value map
      */
-    processOutputs?: (outputs: Readonly<KVMap>) => KVMap | Promise<KVMap>;
+    processOutputs?: (outputs: Readonly<ProcessOutputs<Awaited<ReturnType<Func>>>>) => KVMap | Promise<KVMap>;
 };
 /**
  * Higher-order function that takes function as input and returns a

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/traceable.js

@@ -87,7 +87,9 @@ const runInputsToMap = (rawInputs) => {
     }
     return inputs;
 };
-const handleRunInputs = (inputs, processInputs) => {
+const handleRunInputs = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+inputs, processInputs) => {
     try {
         return processInputs(inputs);
     }
@@ -143,6 +145,7 @@ function isAsyncFn(fn) {
 // Note: This mutates the run tree
 async function handleRunOutputs(params) {
     const { runTree, rawOutputs, processOutputsFn, on_end, postRunPromise, excludeInputs, } = params;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let outputs;
     if (isKVMap(rawOutputs)) {
         outputs = { ...rawOutputs };

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/_uuid.cjs

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertUuid = assertUuid;
+exports.uuid7FromTime = uuid7FromTime;
+exports.getUuidVersion = getUuidVersion;
+exports.warnIfNotUuidV7 = warnIfNotUuidV7;
 // Relaxed UUID validation regex (allows any valid UUID format including nil UUIDs)
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const uuid_1 = require("uuid");
+const warn_js_1 = require("./warn.cjs");
+let UUID7_WARNING_EMITTED = false;
 function assertUuid(str, which) {
     // Use relaxed regex validation instead of strict uuid.validate()
     // This allows edge cases like nil UUIDs or test UUIDs that might not pass strict validation
@@ -14,3 +20,47 @@ function assertUuid(str, which) {
     }
     return str;
 }
+/**
+ * Generate a UUID v7 from a timestamp.
+ *
+ * @param timestamp - The timestamp in milliseconds
+ * @returns A UUID v7 string
+ */
+function uuid7FromTime(timestamp) {
+    const msecs = typeof timestamp === "string" ? Date.parse(timestamp) : timestamp;
+    // Work around uuid@10 behavior where providing only { msecs }
+    // may not set the internal timestamp used for stringification.
+    // Providing a seq ensures the implementation updates its internal state
+    // and encodes the provided milliseconds into the UUID bytes.
+    return (0, uuid_1.v7)({ msecs, seq: 0 });
+}
+/**
+ * Get the version of a UUID string.
+ * @param uuidStr - The UUID string to check
+ * @returns The version number (1-7) or null if invalid
+ */
+function getUuidVersion(uuidStr) {
+    if (!UUID_REGEX.test(uuidStr)) {
+        return null;
+    }
+    // Version is in bits 48-51
+    // Format: xxxxxxxx-xxxx-Vxxx-xxxx-xxxxxxxxxxxx
+    const versionChar = uuidStr[14];
+    return parseInt(versionChar, 16);
+}
+/**
+ * Warn if a UUID is not version 7.
+ *
+ * @param uuidStr - The UUID string to check
+ * @param idType - The type of ID (e.g., "run_id", "trace_id") for the warning message
+ */
+function warnIfNotUuidV7(uuidStr, _idType) {
+    const version = getUuidVersion(uuidStr);
+    if (version !== null && version !== 7 && !UUID7_WARNING_EMITTED) {
+        UUID7_WARNING_EMITTED = true;
+        (0, warn_js_1.warnOnce)(`LangSmith now uses UUID v7 for run and trace identifiers. ` +
+            `This warning appears when passing custom IDs. ` +
+            `Please use: import { uuidv7 } from 'langsmith'; const id = uuidv7(); ` +
+            `Future versions will require UUID v7.`);
+    }
+}