@elizaos/core 1.7.0 → 1.7.1-alpha.1

package/dist/node/index.node.js

@@ -25505,6 +25505,34 @@ function mapKeys(fields, mapper, map) {
   return mapped;
 }
 
+// ../../node_modules/@langchain/core/dist/load/validation.js
+var LC_ESCAPED_KEY = "__lc_escaped__";
+function needsEscaping(obj) {
+  return "lc" in obj || Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;
+}
+function escapeObject(obj) {
+  return { [LC_ESCAPED_KEY]: obj };
+}
+function isSerializableLike(obj) {
+  return obj !== null && typeof obj === "object" && "lc_serializable" in obj && typeof obj.toJSON === "function";
+}
+function escapeIfNeeded(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    if (isSerializableLike(value))
+      return value;
+    const record = value;
+    if (needsEscaping(record))
+      return escapeObject(record);
+    const result = {};
+    for (const [key, val] of Object.entries(record))
+      result[key] = escapeIfNeeded(val);
+    return result;
+  }
+  if (Array.isArray(value))
+    return value.map((item) => escapeIfNeeded(item));
+  return value;
+}
+
 // ../../node_modules/@langchain/core/dist/load/serializable.js
 var serializable_exports = {};
 __export(serializable_exports, {
@@ -25604,11 +25632,16 @@ var Serializable = class Serializable2 {
       if (last in read && read[last] !== undefined)
         write[last] = write[last] || read[last];
     });
+    const escapedKwargs = {};
+    for (const [key, value] of Object.entries(kwargs))
+      escapedKwargs[key] = escapeIfNeeded(value);
+    const kwargsWithSecrets = Object.keys(secrets).length ? replaceSecrets(escapedKwargs, secrets) : escapedKwargs;
+    const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);
     return {
       lc: 1,
       type: "constructor",
       id: this.lc_id,
-      kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases)
+      kwargs: processedKwargs
     };
   }
   toJSONNotImplemented() {
@@ -26351,7 +26384,7 @@ function convertToPrettyString(message) {
         lines.push(` Call ID: ${tc.id}`);
         lines.push("  Args:");
         for (const [key, value] of Object.entries(tc.args))
-          lines.push(`    ${key}: ${value}`);
+          lines.push(`    ${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`);
       }
     }
   }
@@ -26598,10 +26631,10 @@ function _mergeLists(left, right) {
   }
 }
 function _mergeObj(left, right) {
-  if (!left && !right)
-    throw new Error("Cannot merge two undefined objects.");
-  if (!left || !right)
-    return left || right;
+  if (left === undefined && right === undefined)
+    return;
+  if (left === undefined || right === undefined)
+    return left ?? right;
   else if (typeof left !== typeof right)
     throw new Error(`Cannot merge objects of different types.
 Left ${typeof left}
@@ -27420,6 +27453,117 @@ function mergeUsageMetadata(a, b) {
 }
 
 // ../../node_modules/@langchain/core/dist/messages/ai.js
+var AIMessage = class extends BaseMessage {
+  type = "ai";
+  tool_calls = [];
+  invalid_tool_calls = [];
+  usage_metadata;
+  get lc_aliases() {
+    return {
+      ...super.lc_aliases,
+      tool_calls: "tool_calls",
+      invalid_tool_calls: "invalid_tool_calls"
+    };
+  }
+  constructor(fields) {
+    let initParams;
+    if (typeof fields === "string" || Array.isArray(fields))
+      initParams = {
+        content: fields,
+        tool_calls: [],
+        invalid_tool_calls: [],
+        additional_kwargs: {}
+      };
+    else {
+      initParams = fields;
+      const rawToolCalls = initParams.additional_kwargs?.tool_calls;
+      const toolCalls = initParams.tool_calls;
+      if (!(rawToolCalls == null) && rawToolCalls.length > 0 && (toolCalls === undefined || toolCalls.length === 0))
+        console.warn([
+          "New LangChain packages are available that more efficiently handle",
+          `tool calling.
+
+Please upgrade your packages to versions that set`,
+          "message tool calls. e.g., `pnpm install @langchain/anthropic`,",
+          "pnpm install @langchain/openai`, etc."
+        ].join(" "));
+      try {
+        if (!(rawToolCalls == null) && toolCalls === undefined) {
+          const [toolCalls$1, invalidToolCalls] = defaultToolCallParser(rawToolCalls);
+          initParams.tool_calls = toolCalls$1 ?? [];
+          initParams.invalid_tool_calls = invalidToolCalls ?? [];
+        } else {
+          initParams.tool_calls = initParams.tool_calls ?? [];
+          initParams.invalid_tool_calls = initParams.invalid_tool_calls ?? [];
+        }
+      } catch {
+        initParams.tool_calls = [];
+        initParams.invalid_tool_calls = [];
+      }
+      if (initParams.response_metadata !== undefined && "output_version" in initParams.response_metadata && initParams.response_metadata.output_version === "v1") {
+        initParams.contentBlocks = initParams.content;
+        initParams.content = undefined;
+      }
+      if (initParams.contentBlocks !== undefined) {
+        initParams.contentBlocks.push(...initParams.tool_calls.map((toolCall) => ({
+          type: "tool_call",
+          id: toolCall.id,
+          name: toolCall.name,
+          args: toolCall.args
+        })));
+        const missingToolCalls = initParams.contentBlocks.filter((block) => block.type === "tool_call").filter((block) => !initParams.tool_calls?.some((toolCall) => toolCall.id === block.id && toolCall.name === block.name));
+        if (missingToolCalls.length > 0)
+          initParams.tool_calls = missingToolCalls.map((block) => ({
+            type: "tool_call",
+            id: block.id,
+            name: block.name,
+            args: block.args
+          }));
+      }
+    }
+    super(initParams);
+    if (typeof initParams !== "string") {
+      this.tool_calls = initParams.tool_calls ?? this.tool_calls;
+      this.invalid_tool_calls = initParams.invalid_tool_calls ?? this.invalid_tool_calls;
+    }
+    this.usage_metadata = initParams.usage_metadata;
+  }
+  static lc_name() {
+    return "AIMessage";
+  }
+  get contentBlocks() {
+    if (this.response_metadata && "output_version" in this.response_metadata && this.response_metadata.output_version === "v1")
+      return this.content;
+    if (this.response_metadata && "model_provider" in this.response_metadata && typeof this.response_metadata.model_provider === "string") {
+      const translator = getTranslator(this.response_metadata.model_provider);
+      if (translator)
+        return translator.translateContent(this);
+    }
+    const blocks = super.contentBlocks;
+    if (this.tool_calls) {
+      const missingToolCalls = this.tool_calls.filter((block) => !blocks.some((b) => b.id === block.id && b.name === block.name));
+      blocks.push(...missingToolCalls.map((block) => ({
+        ...block,
+        type: "tool_call",
+        id: block.id,
+        name: block.name,
+        args: block.args
+      })));
+    }
+    return blocks;
+  }
+  get _printableFields() {
+    return {
+      ...super._printableFields,
+      tool_calls: this.tool_calls,
+      invalid_tool_calls: this.invalid_tool_calls,
+      usage_metadata: this.usage_metadata
+    };
+  }
+  static isInstance(obj) {
+    return super.isInstance(obj) && obj.type === "ai";
+  }
+};
 var AIMessageChunk = class extends BaseMessageChunk {
   type = "ai";
   tool_calls = [];
@@ -27745,7 +27889,7 @@ var BaseCallbackHandler = class extends BaseCallbackHandlerMethodsClass {
   static fromMethods(methods) {
 
     class Handler extends BaseCallbackHandler {
-      name = v4();
+      name = v7();
       constructor() {
         super();
         Object.assign(this, methods);
@@ -27859,7 +28003,7 @@ function uuid7FromTime(timestamp) {
   return v72({ msecs, seq: 0 });
 }
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.3.82";
+var __version__ = "0.4.2";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -28823,6 +28967,23 @@ class LangSmithConflictError extends Error {
     this.status = 409;
   }
 }
+
+class LangSmithNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    Object.defineProperty(this, "status", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    this.name = "LangSmithNotFoundError";
+    this.status = 404;
+  }
+}
+function isLangSmithNotFoundError(error) {
+  return error != null && typeof error === "object" && "name" in error && error?.name === "LangSmithNotFoundError";
+}
 async function raiseForStatus(response, context, consumeOnSuccess) {
   let errorBody;
   if (response.ok) {
@@ -28852,6 +29013,9 @@ async function raiseForStatus(response, context, consumeOnSuccess) {
     }
   }
   const fullMessage = `Failed to ${context}. Received status [${response.status}]: ${response.statusText}. Message: ${errorBody}`;
+  if (response.status === 404) {
+    throw new LangSmithNotFoundError(fullMessage);
+  }
   if (response.status === 409) {
     throw new LangSmithConflictError(fullMessage);
   }
@@ -29030,7 +29194,10 @@ function replaceGetterValues(replacer) {
 }
 
 // ../../node_modules/langsmith/dist/client.js
-function mergeRuntimeEnvIntoRun(run, cachedEnvVars) {
+function mergeRuntimeEnvIntoRun(run, cachedEnvVars, omitTracedRuntimeInfo) {
+  if (omitTracedRuntimeInfo) {
+    return run;
+  }
   const runtimeEnv = getRuntimeEnvironment2();
   const envVars = cachedEnvVars ?? getLangSmithEnvVarsMetadata();
   const extra = run.extra ?? {};
@@ -29250,6 +29417,12 @@ class Client {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "omitTracedRuntimeInfo", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
     Object.defineProperty(this, "tracingSampleRate", {
       enumerable: true,
       configurable: true,
@@ -29364,6 +29537,12 @@ class Client {
       writable: true,
       value: false
     });
+    Object.defineProperty(this, "_multipartDisabled", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: false
+    });
     Object.defineProperty(this, "debug", {
       enumerable: true,
       configurable: true,
@@ -29405,6 +29584,7 @@ class Client {
     });
     this.hideInputs = config.hideInputs ?? config.anonymizer ?? defaultConfig.hideInputs;
     this.hideOutputs = config.hideOutputs ?? config.anonymizer ?? defaultConfig.hideOutputs;
+    this.omitTracedRuntimeInfo = config.omitTracedRuntimeInfo ?? false;
     this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
     this.autoBatchQueue = new AutoBatchQueue(maxMemory);
     this.blockOnRootRunFinalization = config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
@@ -29628,11 +29808,11 @@ class Client {
   }
   async _getBatchSizeLimitBytes() {
     const serverInfo = await this._ensureServerInfo();
-    return this.batchSizeBytesLimit ?? serverInfo.batch_ingest_config?.size_limit_bytes ?? DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES;
+    return this.batchSizeBytesLimit ?? serverInfo?.batch_ingest_config?.size_limit_bytes ?? DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES;
   }
   async _getBatchSizeLimit() {
     const serverInfo = await this._ensureServerInfo();
-    return this.batchSizeLimit ?? serverInfo.batch_ingest_config?.size_limit ?? DEFAULT_BATCH_SIZE_LIMIT;
+    return this.batchSizeLimit ?? serverInfo?.batch_ingest_config?.size_limit ?? DEFAULT_BATCH_SIZE_LIMIT;
   }
   async _getDatasetExamplesMultiPartSupport() {
     const serverInfo = await this._ensureServerInfo();
@@ -29687,13 +29867,26 @@ class Client {
           runUpdates: batch.filter((item) => item.action === "update").map((item) => item.item)
         };
         const serverInfo = await this._ensureServerInfo();
-        if (serverInfo?.batch_ingest_config?.use_multipart_endpoint) {
+        const useMultipart = !this._multipartDisabled && (serverInfo?.batch_ingest_config?.use_multipart_endpoint ?? true);
+        if (useMultipart) {
           const useGzip = serverInfo?.instance_flags?.gzip_body_enabled;
-          await this.multipartIngestRuns(ingestParams, {
-            ...options,
-            useGzip,
-            sizeBytes: batchSizeBytes
-          });
+          try {
+            await this.multipartIngestRuns(ingestParams, {
+              ...options,
+              useGzip,
+              sizeBytes: batchSizeBytes
+            });
+          } catch (e) {
+            if (isLangSmithNotFoundError(e)) {
+              this._multipartDisabled = true;
+              await this.batchIngestRuns(ingestParams, {
+                ...options,
+                sizeBytes: batchSizeBytes
+              });
+            } else {
+              throw e;
+            }
+          }
         } else {
           await this.batchIngestRuns(ingestParams, {
             ...options,
@@ -29735,7 +29928,7 @@ class Client {
   async processRunOperation(item) {
     clearTimeout(this.autoBatchTimeout);
     this.autoBatchTimeout = undefined;
-    item.item = mergeRuntimeEnvIntoRun(item.item, this.cachedLSEnvVarsForMetadata);
+    item.item = mergeRuntimeEnvIntoRun(item.item, this.cachedLSEnvVarsForMetadata, this.omitTracedRuntimeInfo);
     const itemPromise = this.autoBatchQueue.push(item);
     if (this.manualFlushMode) {
       return itemPromise;
@@ -29850,7 +30043,7 @@ class Client {
       }).catch(console.error);
       return;
     }
-    const mergedRunCreateParam = mergeRuntimeEnvIntoRun(runCreate, this.cachedLSEnvVarsForMetadata);
+    const mergedRunCreateParam = mergeRuntimeEnvIntoRun(runCreate, this.cachedLSEnvVarsForMetadata, this.omitTracedRuntimeInfo);
     if (options?.apiKey !== undefined) {
       headers["x-api-key"] = options.apiKey;
     }
@@ -30166,6 +30359,9 @@ class Client {
         res = await sendWithRetry(buildBuffered);
       }
     } catch (e) {
+      if (isLangSmithNotFoundError(e)) {
+        throw e;
+      }
       console.warn(`${e.message.trim()}
 
 Context: ${context}`);
@@ -31338,6 +31534,39 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
       return res;
     });
   }
+  async deleteExamples(exampleIds, options) {
+    exampleIds.forEach((id) => assertUuid(id));
+    if (options?.hardDelete) {
+      const path = this._getPlatformEndpointPath("datasets/examples/delete");
+      await this.caller.call(async () => {
+        const res = await this._fetch(`${this.apiUrl}${path}`, {
+          method: "POST",
+          headers: { ...this.headers, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            example_ids: exampleIds,
+            hard_delete: true
+          }),
+          signal: AbortSignal.timeout(this.timeout_ms),
+          ...this.fetchOptions
+        });
+        await raiseForStatus(res, "hard delete examples", true);
+        return res;
+      });
+    } else {
+      const params = new URLSearchParams;
+      exampleIds.forEach((id) => params.append("example_ids", id));
+      await this.caller.call(async () => {
+        const res = await this._fetch(`${this.apiUrl}/examples?${params.toString()}`, {
+          method: "DELETE",
+          headers: this.headers,
+          signal: AbortSignal.timeout(this.timeout_ms),
+          ...this.fetchOptions
+        });
+        await raiseForStatus(res, "delete examples", true);
+        return res;
+      });
+    }
+  }
   async updateExample(exampleIdOrUpdate, update) {
     let exampleId;
     if (update) {
@@ -31457,23 +31686,6 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
       return res;
     });
   }
-  async evaluateRun(run, evaluator, { sourceInfo, loadChildRuns, referenceExample } = { loadChildRuns: false }) {
-    warnOnce("This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.");
-    let run_;
-    if (typeof run === "string") {
-      run_ = await this.readRun(run, { loadChildRuns });
-    } else if (typeof run === "object" && "id" in run) {
-      run_ = run;
-    } else {
-      throw new Error(`Invalid run type: ${typeof run}`);
-    }
-    if (run_.reference_example_id !== null && run_.reference_example_id !== undefined) {
-      referenceExample = await this.readExample(run_.reference_example_id);
-    }
-    const feedbackResult = await evaluator.evaluateRun(run_, referenceExample);
-    const [_, feedbacks] = await this._logEvaluationFeedback(feedbackResult, run_, sourceInfo);
-    return feedbacks[0];
-  }
   async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId }) {
     if (!runId && !projectId) {
       throw new Error("One of runId or projectId must be provided");
@@ -32333,6 +32545,7 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
       console.warn("[WARNING]: When tracing in manual flush mode, you must call `await client.flush()` manually to submit trace batches.");
       return Promise.resolve();
     }
+    await new Promise((resolve) => setTimeout(resolve, 1));
     await Promise.all([
       ...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise),
       this.batchIngestCaller.queue.onIdle()
@@ -32357,6 +32570,7 @@ var isTracingEnabled = (tracingEnabled) => {
 
 // ../../node_modules/langsmith/dist/singletons/constants.js
 var _LC_CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
+var _LC_CHILD_RUN_END_PROMISES_KEY = Symbol.for("lc:child_run_end_promises");
 var _REPLICA_TRACE_ROOTS_KEY = Symbol.for("langsmith:replica_trace_roots");
 
 // ../../node_modules/langsmith/dist/utils/context_vars.js
@@ -32950,6 +33164,7 @@ class RunTree {
           await childRun.postRun(false);
         }
       }
+      this.child_runs = [];
     } catch (error) {
       console.error(`Error in postRun for run ${this.id}:`, error);
     }
@@ -33022,6 +33237,7 @@ class RunTree {
         console.error(`Error in patchRun for run ${this.id}`, error);
       }
     }
+    this.child_runs = [];
   }
   toJSON() {
     return this._convertToCreate(this, undefined, false);
@@ -33154,7 +33370,8 @@ function isCallbackManagerLike(x) {
   return typeof x === "object" && x != null && Array.isArray(x.handlers);
 }
 function isRunnableConfigLike(x) {
-  return x != null && typeof x.callbacks === "object" && (containsLangChainTracerLike(x.callbacks?.handlers) || containsLangChainTracerLike(x.callbacks));
+  const callbacks = x?.callbacks;
+  return x != null && typeof callbacks === "object" && (containsLangChainTracerLike(callbacks?.handlers) || containsLangChainTracerLike(callbacks));
 }
 function _getWriteReplicasFromEnv() {
   const envVar = getEnvironmentVariable2("LANGSMITH_RUNS_ENDPOINTS");
@@ -33295,7 +33512,7 @@ ${error.stack}` : "");
     const { dottedOrder: currentDottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(new Date(run.start_time).getTime(), run.id, run.execution_order);
     const storedRun = { ...run };
     const parentRun = this.getRunById(storedRun.parent_run_id);
-    if (storedRun.parent_run_id !== undefined) {
+    if (storedRun.parent_run_id !== undefined)
       if (parentRun) {
         this._addChildRun(parentRun, storedRun);
         parentRun.child_execution_order = Math.max(parentRun.child_execution_order, storedRun.child_execution_order);
@@ -33304,8 +33521,9 @@ ${error.stack}` : "");
           storedRun.dotted_order = [parentRun.dotted_order, currentDottedOrder].join(".");
           storedRun._serialized_start_time = microsecondPrecisionDatestring;
         }
-      }
-    } else {
+      } else
+        storedRun.parent_run_id = undefined;
+    else {
       storedRun.trace_id = storedRun.id;
       storedRun.dotted_order = currentDottedOrder;
       storedRun._serialized_start_time = microsecondPrecisionDatestring;
@@ -33438,7 +33656,7 @@ ${error.stack}` : "");
     await this._endTrace(run);
     return run;
   }
-  _createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+  _createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name, extra) {
     const execution_order = this._getExecutionOrder(parentRunId);
     const start_time = Date.now();
     const run = {
@@ -33456,7 +33674,10 @@ ${error.stack}` : "");
       child_execution_order: execution_order,
       run_type: runType ?? "chain",
       child_runs: [],
-      extra: metadata ? { metadata } : {},
+      extra: metadata ? {
+        ...extra,
+        metadata
+      } : { ...extra },
       tags: tags || []
     };
     return this._addRunToRunMap(run);
@@ -33827,6 +34048,14 @@ function isTraceableFunction(x) {
 // ../../node_modules/@langchain/core/dist/tracers/tracer_langchain.js
 var tracer_langchain_exports = {};
 __export(tracer_langchain_exports, { LangChainTracer: () => LangChainTracer });
+function _getUsageMetadataFromGenerations(generations) {
+  let output = undefined;
+  for (const generationBatch of generations)
+    for (const generation of generationBatch)
+      if (AIMessage.isInstance(generation.message) && generation.message.usage_metadata !== undefined)
+        output = mergeUsageMetadata(output, generation.message.usage_metadata);
+  return output;
+}
 var LangChainTracer = class LangChainTracer2 extends BaseTracer {
   name = "langchain_tracer";
   projectName;
@@ -33847,12 +34076,29 @@ var LangChainTracer = class LangChainTracer2 extends BaseTracer {
   }
   async persistRun(_run) {}
   async onRunCreate(run) {
-    const runTree = this.getRunTreeWithTracingConfig(run.id);
-    await runTree?.postRun();
+    if (!run.extra?.lc_defers_inputs) {
+      const runTree = this.getRunTreeWithTracingConfig(run.id);
+      await runTree?.postRun();
+    }
   }
   async onRunUpdate(run) {
     const runTree = this.getRunTreeWithTracingConfig(run.id);
-    await runTree?.patchRun();
+    if (run.extra?.lc_defers_inputs)
+      await runTree?.postRun();
+    else
+      await runTree?.patchRun();
+  }
+  onLLMEnd(run) {
+    const outputs = run.outputs;
+    if (outputs?.generations) {
+      const usageMetadata = _getUsageMetadataFromGenerations(outputs.generations);
+      if (usageMetadata !== undefined) {
+        run.extra = run.extra ?? {};
+        const metadata = run.extra.metadata ?? {};
+        metadata.usage_metadata = usageMetadata;
+        run.extra.metadata = metadata;
+      }
+    }
   }
   getRun(id) {
     return this.runTreeMap.get(id);
@@ -34246,7 +34492,7 @@ var CallbackManager = class CallbackManager2 extends BaseCallbackManager {
   }
   async handleLLMStart(llm, prompts, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
     return Promise.all(prompts.map(async (prompt, idx) => {
-      const runId_ = idx === 0 && runId ? runId : v4();
+      const runId_ = idx === 0 && runId ? runId : v7();
       await Promise.all(this.handlers.map((handler) => {
         if (handler.ignoreLLM)
           return;
@@ -34268,7 +34514,7 @@ var CallbackManager = class CallbackManager2 extends BaseCallbackManager {
   }
   async handleChatModelStart(llm, messages, runId = undefined, _parentRunId = undefined, extraParams = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
     return Promise.all(messages.map(async (messageGroup, idx) => {
-      const runId_ = idx === 0 && runId ? runId : v4();
+      const runId_ = idx === 0 && runId ? runId : v7();
       await Promise.all(this.handlers.map((handler) => {
         if (handler.ignoreLLM)
           return;
@@ -34293,15 +34539,15 @@ var CallbackManager = class CallbackManager2 extends BaseCallbackManager {
       return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }));
   }
-  async handleChainStart(chain, inputs, runId = v4(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
+  async handleChainStart(chain, inputs, runId = v7(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined, _parentRunId = undefined, extra = undefined) {
     await Promise.all(this.handlers.map((handler) => {
       if (handler.ignoreChain)
         return;
       if (isBaseTracer(handler))
-        handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
+        handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName, extra);
       return consumeCallback(async () => {
         try {
-          await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
+          await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName, extra);
         } catch (err) {
           const logFunction = handler.raiseError ? console.error : console.warn;
           logFunction(`Error in handler ${handler.constructor.name}, handleChainStart: ${err}`);
@@ -34312,7 +34558,7 @@ var CallbackManager = class CallbackManager2 extends BaseCallbackManager {
     }));
     return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
   }
-  async handleToolStart(tool, input, runId = v4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
+  async handleToolStart(tool, input, runId = v7(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
     await Promise.all(this.handlers.map((handler) => {
       if (handler.ignoreAgent)
         return;
@@ -34331,7 +34577,7 @@ var CallbackManager = class CallbackManager2 extends BaseCallbackManager {
     }));
     return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
   }
-  async handleRetrieverStart(retriever, query, runId = v4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
+  async handleRetrieverStart(retriever, query, runId = v7(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
     await Promise.all(this.handlers.map((handler) => {
       if (handler.ignoreRetriever)
         return;
@@ -34429,7 +34675,7 @@ var CallbackManager = class CallbackManager2 extends BaseCallbackManager {
   static fromHandlers(handlers) {
 
     class Handler extends BaseCallbackHandler {
-      name = v4();
+      name = v7();
       constructor() {
         super();
         Object.assign(this, handlers);
@@ -34688,7 +34934,12 @@ function ensureConfig(config) {
   if (empty.timeout !== undefined) {
     if (empty.timeout <= 0)
       throw new Error("Timeout must be a positive number");
-    const timeoutSignal = AbortSignal.timeout(empty.timeout);
+    const originalTimeoutMs = empty.timeout;
+    const timeoutSignal = AbortSignal.timeout(originalTimeoutMs);
+    if (!empty.metadata)
+      empty.metadata = {};
+    if (empty.metadata.timeoutMs === undefined)
+      empty.metadata.timeoutMs = originalTimeoutMs;
     if (empty.signal !== undefined) {
       if ("any" in AbortSignal)
         empty.signal = AbortSignal.any([empty.signal, timeoutSignal]);
@@ -35074,12 +35325,19 @@ __export(core_exports, {
 });
 var JsonPatchError = PatchError;
 var deepClone = _deepClone;
+function isDangerousKey(key) {
+  return Object.getOwnPropertyNames(Object.prototype).includes(key);
+}
 var objOps = {
   add: function(obj, key, document2) {
+    if (isDangerousKey(key))
+      throw new TypeError("JSON-Patch: modifying `__proto__`, `constructor`, or `prototype` prop is banned for security reasons");
     obj[key] = this.value;
     return { newDocument: document2 };
   },
   remove: function(obj, key, document2) {
+    if (isDangerousKey(key))
+      throw new TypeError("JSON-Patch: modifying `__proto__`, `constructor`, or `prototype` prop is banned for security reasons");
     var removed = obj[key];
     delete obj[key];
     return {
@@ -35088,6 +35346,8 @@ var objOps = {
     };
   },
   replace: function(obj, key, document2) {
+    if (isDangerousKey(key))
+      throw new TypeError("JSON-Patch: modifying `__proto__`, `constructor`, or `prototype` prop is banned for security reasons");
     var removed = obj[key];
     obj[key] = this.value;
     return {
@@ -35711,6 +35971,7 @@ var EventStreamCallbackHandler = class extends BaseTracer {
   transformStream;
   writer;
   receiveStream;
+  readableStreamClosed = false;
   name = "event_stream_tracer";
   lc_prefer_streaming = true;
   constructor(fields) {
@@ -35725,7 +35986,9 @@ var EventStreamCallbackHandler = class extends BaseTracer {
     this.excludeNames = fields?.excludeNames;
     this.excludeTypes = fields?.excludeTypes;
     this.excludeTags = fields?.excludeTags;
-    this.transformStream = new TransformStream;
+    this.transformStream = new TransformStream({ flush: () => {
+      this.readableStreamClosed = true;
+    } });
     this.writer = this.transformStream.writable.getWriter();
     this.receiveStream = IterableReadableStream.fromReadableStream(this.transformStream.readable);
   }
@@ -35803,6 +36066,8 @@ var EventStreamCallbackHandler = class extends BaseTracer {
     }
   }
   async send(payload, run) {
+    if (this.readableStreamClosed)
+      return;
     if (this._includeRun(run))
       await this.writer.write(payload);
   }
@@ -36540,7 +36805,7 @@ function interopZodTransformInputSchemaImpl(schema, recursive, cache) {
       outputSchema = interopZodTransformInputSchemaImpl(schema._zod.def.in, recursive, cache);
     if (recursive) {
       if (isZodObjectV4(outputSchema)) {
-        const outputShape = outputSchema._zod.def.shape;
+        const outputShape = {};
         for (const [key, keySchema] of Object.entries(outputSchema._zod.def.shape))
           outputShape[key] = interopZodTransformInputSchemaImpl(keySchema, recursive, cache);
         outputSchema = clone(outputSchema, {
@@ -36631,16 +36896,24 @@ graph TD;
     edgeGroups[commonPrefix].push(edge);
   }
   const seenSubgraphs = /* @__PURE__ */ new Set;
+  function sortPrefixesByDepth(prefixes) {
+    return [...prefixes].sort((a, b) => {
+      return a.split(":").length - b.split(":").length;
+    });
+  }
   function addSubgraph(edges$1, prefix) {
     const selfLoop = edges$1.length === 1 && edges$1[0].source === edges$1[0].target;
     if (prefix && !selfLoop) {
       const subgraph = prefix.split(":").pop();
-      if (seenSubgraphs.has(subgraph))
-        throw new Error(`Found duplicate subgraph '${subgraph}' -- this likely means that you're reusing a subgraph node with the same name. Please adjust your graph to have subgraph nodes with unique names.`);
-      seenSubgraphs.add(subgraph);
+      if (seenSubgraphs.has(prefix))
+        throw new Error(`Found duplicate subgraph '${subgraph}' at '${prefix} -- this likely means that you're reusing a subgraph node with the same name. Please adjust your graph to have subgraph nodes with unique names.`);
+      seenSubgraphs.add(prefix);
       mermaidGraph += `	subgraph ${subgraph}
 `;
     }
+    const nestedPrefixes = sortPrefixesByDepth(Object.keys(edgeGroups).filter((nestedPrefix) => nestedPrefix.startsWith(`${prefix}:`) && nestedPrefix !== prefix && nestedPrefix.split(":").length === prefix.split(":").length + 1));
+    for (const nestedPrefix of nestedPrefixes)
+      addSubgraph(edgeGroups[nestedPrefix], nestedPrefix);
     for (const edge of edges$1) {
       const { source, target, data, conditional } = edge;
       let edgeLabel = "";
@@ -36655,9 +36928,6 @@ graph TD;
       mermaidGraph += `	${_escapeNodeLabel(source)}${edgeLabel}${_escapeNodeLabel(target)};
 `;
     }
-    for (const nestedPrefix in edgeGroups)
-      if (nestedPrefix.startsWith(`${prefix}:`) && nestedPrefix !== prefix)
-        addSubgraph(edgeGroups[nestedPrefix], nestedPrefix);
     if (prefix && !selfLoop)
       mermaidGraph += `	end
 `;
@@ -38980,14 +39250,14 @@ __export(json_schema_exports, {
   toJsonSchema: () => toJsonSchema,
   validatesOnlyStrings: () => validatesOnlyStrings
 });
-function toJsonSchema(schema) {
+function toJsonSchema(schema, params) {
   if (isZodSchemaV4(schema)) {
     const inputSchema = interopZodTransformInputSchema(schema, true);
     if (isZodObjectV4(inputSchema)) {
       const strictSchema = interopZodObjectStrict(inputSchema, true);
-      return toJSONSchema(strictSchema);
+      return toJSONSchema(strictSchema, params);
     } else
-      return toJSONSchema(schema);
+      return toJSONSchema(schema, params);
   }
   if (isZodSchemaV3(schema))
     return zodToJsonSchema(schema);
@@ -39452,7 +39722,7 @@ var Runnable = class extends Serializable {
     }
     let runManager;
     try {
-      const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), options?.signal, config);
+      const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName(), undefined, { lc_defers_inputs: true }), options?.signal, config);
       delete config.runId;
       runManager = pipe.setup;
       const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
@@ -50944,5 +51214,5 @@ export {
   ActionStreamFilter
 };
 
-//# debugId=7435777E3B16550264756E2164756E21
+//# debugId=108305E81D5AB81564756E2164756E21
 //# sourceMappingURL=index.node.js.map